Spring5框架

1.Spring5框架

  1. Spring是轻量级的开源JavaEE框架

  2. Spring可以解决企业应用开发的复杂性

  3. Spring有两个核心部分内容：IOC和AOP

    1. IOC:控制反转，把创建对象过程交给Spring进行管理，不用你找，我来提供给你”，这就是控制反转的含义
    2. AOP：面向切面，不修改源代码进行功能增强

  4. Spring的特点

    1. 方便解耦，简化开发
    2. AOP编程支持
    3. 方便程序测试
    4. 方便和其他框架进行整合
    5. 方便进行事物的操作
    6. 降低API开发难度

2.入门案例

2.1 下载Spring5

3.IOC容器

IOC：控制反转，就是对象创建和对象之间的调用过程，交给Spring处理

使用IOC的目的：为了降低耦合度

做的入门案例就是IOC实现

3.1 IOC底层原理

  1. xml解析，工厂模式，反射

  2. 图解IOC底层原理

  3. 原始方式

  1. 工厂模式
  1. IOC过程
  1. IOC(BeanFactory接口)

(1) .IOC思想基于IOC容器完成，IOC容器底层就是对象工厂

(2).Spring提供IOC容器的两种实现方式

  1. BeanFactory:IOC容器的基本实现，是Spring内部使用的接口，不建议开发人员使用（加载配置文件时不会创建对象，在获取对象时才回去创建对象）

  2. ApplicationContext:BeanFactory接口的子接口，提供更多，更强大的功能，一般由开发人员进行使用（加载配置文件时就会把配置文件对象进行创建）

(3).ApplicationContext接口的实现类:

  1. FileSystemXmlApplicationContext()
  2. ClassPathXmlApplicationContext()
  3. 第一个路径要加盘符，第二个默认在当前工程的src下

3.2 IOC操作Bean管理

3.2.1 IOC操作Bean管理的概念

一：什么是Bean管理

  1. Bean管理指的是两个操作
  2. Spring创建对象
  3. Spring注入属性

二：Bean管理由操作有两种方式

  1. 基于xml配置文件方式实现
  2. 基于注解方式实现

3.2.2 IOC操作Bean管理（基于xml方式）

  1. 基于xml方式创建对象
1
2
3
<!--    配置User对象创建-->
    <bean id="user" class="com.atguigu.spring5.User"></bean>

（1）在 spring 配置文件中，使用 bean 标签，标签里面添加对应属性，就可以实现对象创建

（2）在 bean 标签有很多属性，介绍常用的属性 * id 属性：唯一标识 * class 属性：类全路径（包类路径）

（3）创建对象时候，默认也是执行无参数构造方法完成对象创建

1
2
3
4
5
6
7
8
9
public void testAdd(){
       //1.加载spring配置文件
       ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");

       //2.获取配置创建的对象
       User user = context.getBean("user", User.class);
       System.out.println(user);
       user.add();
   }
  1. 基于xml方式注入属性

（1）DI：依赖注入，就是注入属性

  1. 第一种注入方式：使用set方法进行注入

（1）创建类，定义属性和对应的set方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
* 演示使用 set 方法进行注入属性
*/
public class Book {
 //创建属性
 private String bname;
 private String bauthor;
 //创建属性对应的 set 方法
 public void setBname(String bname) {
 this.bname = bname;
 }
 public void setBauthor(String bauthor) {
 this.bauthor = bauthor;
 }
}

（2）在Spring配置文件中配置对象创建，配置属性注入

1
2
3
4
5
6
7
8
9
<!--2 set 方法注入属性-->
<bean id="book" class="com.atguigu.spring5.Book">
 <!--使用 property 完成属性注入
 name：类里面属性名称
 value：向属性注入的值
 -->
 <property name="bname" value="易筋经"></property>
 <property name="bauthor" value="达摩老祖"></property>
</bean>
  1. 第二中创建方式：使用有参构造函数进行注入

（1）创建类，定义属性，创建属性对应有参构造方法

1
2
3
4
5
6
7
8
9
10
11
12
public class Orders {
    private String name;
    private String address;

    public Orders(String name, String address) {
        this.name = name;
        this.address = address;
    }
    public void show(){
        System.out.println(name + "::" + address);
    }
}

(2)在Spring配置文件中进行配置

1
2
3
4
5
<!--    有参构造函数注入属性-->
    <bean id="orders" class="com.atguigu.spring5.Orders">
        <constructor-arg name="name" value="abc" ></constructor-arg>
        <constructor-arg name="address" value="地球"></constructor-arg>
    </bean>

3.2.3 IOC操作Bean管理（xm注入其他类型属性）

  1. 字面量

（1) null值

1
2
3
<property name="address" >
            <null/>
</property>
  1. 属性值包含特殊符号
1
2
3
4
5
6
7
<!--        属性值中包含特殊符号
             1.把<>转义&lt,&gt
             2.把特殊符号的内容写到CDATA中去
             -->
        <property name="address">
            <value><![CDATA[<<南京>>]]></value>
        </property>
  1. 注入属性-外部Bean

(1)创建两个类service类和dao类

(2)在service类中调用dao里面的方法

(3)在spring中进行配置

service类：

1
2
3
4
5
6
7
8
9
10
11
12
public class UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void addUserTo(){
        userDao.addUser();
    }
}

dao类：

1
2
3
4
public interface UserDao {
    public void addUser();
}

daoImpl类：

1
2
3
4
5
6
7
public class UserDaoImpl implements UserDao{

    @Override
    public void addUser() {
        System.out.println("addUser 调用了");
    }
}

Spring配置文件：

1
2
3
4
5
6
7
8
9
10
<!--    service和dao对象的创建-->
    <bean id="userService" class="com.CodeX.Spring5.bean.service.UserService">
<!--        注入userDao属性
             name属性：UserService类中对应的属性名称
             ref属性：UserDaoImpl对应的bean标签的Id值
             -->
       <property name="userDao" ref="userDaoImpl"></property>
    </bean>
    <bean id="userDaoImpl" class="com.CodeX.Spring5.bean.dao.UserDaoImpl"></bean>
</beans>
  1. 注入属性-内部bean

(1)一对多的关系：部门和员工

一个部门有多个员工，一个员工属于一个部门

(2)在实体类之间表示一对多的关系，员工所属部门，使用对象类型属性进行表示

部门类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//部门类
public class Department {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Department{" +
                "name='" + name + '\'' +
                '}';
    }
}

员工类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class Employee {
    private String name;
    private Integer id;
    private Department dep;

    public void setName(String name) {
        this.name = name;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public void setDep(Department dep) {
        this.dep = dep;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", dep=" + dep +
                '}';
    }
}

Spring文件的配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
<!--    内部bean-->
    <bean id="emp" class="com.CodeX.Spring5.bean.Employee">
<!--        普通属性的赋值-->
        <property name="name" value="yhc"></property>
        <property name="id" value="1"></property>
<!--        对象属性的赋值-->
        <property name="dep">
            <bean id="dep" class="com.CodeX.Spring5.bean.Department">
                <property name="name" value="财务部"></property>
            </bean>
        </property>
     </bean>
</beans>
  1. 注入属性-级联赋值

(1)第一种写法

1
2
3
4
5
6
7
8
9
10
11
12

<!--   级联赋值-->
    <bean id="emp" class="com.CodeX.Spring5.bean.Employee">
<!--        普通属性的赋值-->
        <property name="name" value="yhc"></property>
        <property name="id" value="1"></property>
<!--        级联赋值-->
        <property name="dep" ref="dep"></property>
     </bean>
    <bean id="dep" class="com.CodeX.Spring5.bean.Department">
        <property name="name" value="财务部"></property>
    </bean>

(2)第二种写法

在员工类中生成dept的get方法

1
2
3
4
5
6
7
8
9
10
11
<!--    级联赋值-->
    <bean id="emp" class="com.CodeX.Spring5.bean.Employee">
<!--        普通属性的赋值-->
        <property name="name" value="yhc"></property>
        <property name="id" value="1"></property>
<!--        级联赋值-->
        <property name="dep" ref="dep"></property>
        <property name="dep.name" value="技术部"></property>
     </bean>
    <bean id="dep" class="com.CodeX.Spring5.bean.Department">
    </bean>

3.2.4 IOC操作Bean管理（xml注入集合属性）

  1. 注入数组类型的属性
  2. 注入list集合类型属性
  3. 注入Map集合类型属性

(1)创建类，定义数组，list,map,set类型属性，生成对应的set方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class Stu {
    //1.数组类型的属性
    private String[] array;

    //2.list类型属性
    private List<String> list;
    //3.Map类型属性
    private Map<String,Object> map;

    //4.set类型属性
    private Set<String> set;

    public void setArray(String[] array) {
        this.array = array;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMap(Map<String, Object> map) {
        this.map = map;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    @Override
    public String toString() {
        return "Stu{" +
                "array=" + Arrays.toString(array) +
                ", list=" + list +
                ", map=" + map +
                ", set=" + set +
                '}';
    }
}

(2)在spring配置文件中进行配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<bean id="stu" class="com.CodeX.Spring5.bean.Stu">
<!--        数组属性的注入-->
        <property name="array">
            <array>
                <value>yhc</value>
                <value>skt</value>
            </array>
        </property>
<!--        list属性的注入-->
        <property name="list">
            <list>
                <value>list</value>
                <value>element1</value>
            </list>
        </property>
        <property name="map">
            <map>
                <entry key="key1" value="value1"> </entry>
                <entry key="key2" value="value2"> </entry>
            </map>
        </property>
<!--        set类型属性的注入-->
        <property name="set">
            <set>
                <value>set</value>
                <value>element1</value>
            </set>
        </property>
    </bean>
  1. 在集合里面设置对象类型值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<!--        list属性的注入-->
        <property name="list">
            <list>
               <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
        
 <bean id="course1" class="com.CodeX.Spring5.bean.Course">
        <property name="name" value="course1"></property>
    </bean>
    <bean id="course2" class="com.CodeX.Spring5.bean.Course">
        <property name="name" value="course2"></property>
    </bean>
  1. 把集合注入部分提取出来

(1)在spring配置文件中引入名称空间util

1
2
3
4
5
6
7
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd>
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

(2) 使用util标签完成list集合注入提取

1
2
3
4
5
6
7
8
9
10
<!--    1.提取list集合类型属性注入-->
    <util:list id="bookList">
        <value>百年孤独</value>
        <value>蛙</value>
        <value>红高粱</value>
    </util:list>
<!--    2.提取后的注入-->
    <bean id="book" class="com.atguigu.spring5.collection.Book">
        <property name="list" ref="bookList"></property>
    </bean>

3.2.5 IOC操作Bean管理(FactoryBean)

  1. Spring中有两种类型bean,一种是普通bean,一种是工厂bean(BeanFactory)
  2. 普通bean:在配置文件中定义bean类型就是返回类型
  3. 工厂bean：在配置文件定义bean类型可以和返回值类型不一样

(1) 创建类，让这个类作为工厂bean,实现接口FactoryBean

(2)实现接口里的方法，在实现的方法中定义返回的bean类型

MyBean:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class MyBean implements FactoryBean<Course> {
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setName("abc");
        return course;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}

spring配置文件：

1
<bean id="myBean" class="com.CodeX.Spring5.bean.MyBean"></bean>

Test:

1
2
3
4
5
6
7
8
9
10
@Test
  public void testBean4(){
      //1.加载spring配置文件
      ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");

      //2.创建配置的对象
      Course course = context.getBean("myBean", Course.class);

      System.out.println(course);
  }

3.2.6 IOC操作Bean管理（bean作用域）

  1. 在Spring里面，设置创建bean是单实例，还是多实例

  2. 在Spring里面，默认情况下，bean是单实例对象

  3. 如何设置单实例，还是多实例

(1)在spring配置文件bean标签里面有属性(scope)用于设置单实例还是多实例

(2)scope默认值：

第一个值 默认值 , singleton,表示是单实例对象

第二个值 prototype，表示是多实例对象

(3)singleton和prototype区别

第一 single单实例，prototype多实例

第二 设置scope值是singleton的时候，加载spring配置文件的时候就会创建单实例对象

​ 设置scope值是prototype的时候，不是在加载spring配置文件时就创建对象，在调用getBean方法的时候创建多实例对象

3.2.7IOC操作生命周期

  1. 生命周期

(1)从对象创建到对象销毁的过程

  1. bean生命周期

(1)通过构造器创建bean实例（无参构造）

(2)为bean的属性设置值和对其他bean的引用（调用set方法）

(3)调用bean的初始化方法(需要进行配置初始化的方法)

(4)bean可以使用了(对象获取到了)

(5)当容器关闭时，调用bean的销毁的方法(需要进行配置销毁的方法)

  1. 演示bean的生命周期

LifeCircle类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class LifeCircle {
    private String name;

    public LifeCircle() {
        System.out.println("第一步 调用无参构造器创建对象");
    }

    public void setName(String name) {
        System.out.println("第二步 调用set方法 为对象的属性赋值");
        this.name = name;
    }
    public void InitMethod(){
        System.out.println("第三步 初始化方法调用了");
    }
    public void DestroyMethod(){
        System.out.println("第五步 销毁方法调用了");
    }

    @Override
    public String toString() {
        return "LifeCircle{" +
                "name='" + name + '\'' +
                '}';
    }
}

test类：

1
2
3
4
5
6
7
8
9
@Test
   public void testBean1(){
      ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
       LifeCircle lifeCircle = context.getBean("lifeCircle", LifeCircle.class);
       System.out.println("第四步 获取创建的实例");
       //System.out.println(lifeCircle);
       context.close();

   }

配置文件

1
2
3
<bean id="lifeCircle" class="com.atguigu.spring5.bean.LifeCircle" init-method="InitMethod" destroy-method="DestroyMethod">
       <property name="name" value="yhc"></property>
   </bean>

test类的结果：

  1. bean的后置处理器，bean生命周期有七步

(1)通过构造器创建bean实例（无参构造）

(2)为bean的属性设置值和对其他bean的引用（调用set方法）

(3)把bean实例传递给bean后置处理器的方法postProcessBeforeInititalization

(4)调用bean的初始化方法(需要进行配置初始化的方法)

(5)把bean实例传递给bean后置处理器的方法postProcessAfterInillization

(6)bean可以使用了(对象获取到了)

(7)当容器关闭时，调用bean的销毁的方法(需要进行配置销毁的方法)

  1. 演示添加后置处理器效果

(1)创建类实现BeanPostProcessor,创建后置处理器

MyBeanPost类：

1
2
3
4
5
6
7
8
9
10
11
12
13
public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之后执行的方法");
        return bean;
    }
}

在spring配置文件中配置后置处理器：

1
2
<!--    配置后置处理器-->
    <bean id="myBeanPost" class="com.atguigu.spring5.bean.MyBeanPost"></bean>

test类的结果：

3.2.8IOC操作Bean管理（xml自动装配）

  1. 什么是自动装配

(1)根据指定的装配规则（属性名称或者属性类型），Spring自动将匹配的属性值进行注入

  1. 演示自动装配的过程

(1)根据属性名称自动注入

1
2
3
4
5
6
7
8
9
10
11
12

<!--    实现自动装配
         bean标签属性autowire 配置自动装配
         autowire有两个常用的属性值:
            byName:根据名称进行注入  注入的bean的id值，和类属性名称一致
            byType:根据属性的类型注入
         -->
    <bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType">

    </bean>
    <bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>
</beans>

3.3IOC操作Bean管理(基于注解方式)

  1. 什么是注解

(1)注解是代码的特殊标记，格式：@注解名称(属性名称=属性值，属性名称=属性值…)

(2)注解作用在类，方法，属性等上面

(3)使用注解的目的：简化xml配置

  1. Spring针对Bean管理中创建对象提供的注解

(1)@Component

(2)@Service

(3)@Controller

(4)@Repository

上面四个注解的功能是一样的，都可以用来创建bean实例

  1. 基于注解方式实现对象创建

第一步 引入依赖

第二步：开启组件扫描

1
2
3
4
5
6

<!--    开启组件扫描
        1.如果扫描多个包，多个包之间用逗号隔开
        2.扫描上层目录
                  -->
    <context:component-scan base-package="com.atguigu.spring5"></context:component-scan>

第三步 创建类，在类上面添加创建对象注解

testAnnotation类：

1
2
3
4
5
6
7
8
@Test
   public void testBean3(){
       ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");

       UserService service = context.getBean("abc", UserService.class);
       service.add();
   }

  1. 开启组件扫描配置细节
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
4、开启组件扫描细节配置
<!--示例 1
 use-default-filters="false" 表示现在不使用默认 filter，自己配置 filter
 context:include-filter ，设置扫描哪些内容
-->
<context:component-scan base-package="com.atguigu" use-defaultfilters="false">
 <context:include-filter type="annotation" 
 
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!--示例 2
 下面配置扫描包所有内容
 context:exclude-filter： 设置哪些内容不进行扫描
-->
<context:component-scan base-package="com.atguigu">
 <context:exclude-filter type="annotation" 
 
expression="org.springframework.ste
  1. 基于注解方式实现属性注入

(1)@Autowired:根据属性类型进行自动装配

第一步 把service和dao对象创建，在service和dao类创建对象注解

第二部 在service注入dao对象，在service类添加dao类型属性，在属性上面使用注解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Service
public class UserService {
    @Value(value = "abc")
    private String name;
    //定义Dao类型属性 此时不需要定义set方法

    @Autowired//根据类型进行注入(userDao的实现类也需要加上注解)
    //@Qualifier(value = "userDaoImpl1")
    private UserDao userDao;
    public void add(){
        System.out.println("UserService add.....");
        userDao.add();
    }

    @Override
    public String toString() {
        return "UserService{" +
                "name='" + name + '\'' +
                ", userDao=" + userDao +
                '}';
    }
}

(2)@Qualifier:根据名称注入

这个@Qualifier注解的使用，和上面@Autowire一起使用

UserService类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Service
public class UserService {
    @Value(value = "abc")
    private String name;
    //定义Dao类型属性 此时不需要定义set方法

    @Autowired//根据类型进行注入
    @Qualifier(value = "userDaoImpl1")
    private UserDao userDao;
    public void add(){
        System.out.println("UserService add.....");
        userDao.add();
    }

    @Override
    public String toString() {
        return "UserService{" +
                "name='" + name + '\'' +
                ", userDao=" + userDao +
                '}';
    }
}

UserDaoImpl类：

1
2
3
4
5
6
7
8
9
10
11
12
13
@Repository(value = "userDaoImpl1")
public class UserDaoImpl implements UserDao{
    @Override
    public void add() {
        System.out.println("dao add......");
    }

    @Override
    public String toString() {
        return "UserDaoImpl{}";
    }
}

testAnnotation类

1
2
3
4
5
6
7
8
@Test
   public void testService(){
       ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
       UserService userService = context.getBean("userService", UserService.class);
       UserService userService1 = context.getBean("userService", UserService.class);
       //System.out.println(userService == userService1);
       userService.add();
   }

(3)@Resource:可以根据类型注入，也可以根据名称注入

1
2
3
//@Resource //根据类型进行注入
@Resource(name = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

(4)@value：注入普通类型属性

1
2
@Value(value="abc")
private String name;
  1. 完全注解开发

(1)创建配置类，代替xml配置文件

1
2
3
4
@Configuration//把当前类作为，配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.atguigu"})
public class SpringConfig {
}

(2)编写测试类

1
2
3
4
5
6
7
8
9
@Test
 public void testService(){
     ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
     UserService userService = context.getBean("userService", UserService.class);
     UserService userService1 = context.getBean("userService", UserService.class);
     //System.out.println(userService == userService1);
     System.out.println(userService);
     userService.add();
 }

4.AOP

4.1AOP概述

(1)面向切面编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高开发的效率.

(2)通俗描述：不通过修改源代码的方式，在主干功能里面添加新功能

4.2AOP底层原理

  1. AOP底层使用动态代理

(1)有两种情况的动态代理

第一种 有接口的情况，使用JDK动态代理：创建接口实现类的代理对象，增强类的方法

(2)没有接口的情况，使用CGLIB动态代理：创建子类的代理对象，增强类的方法

4.3AOP(JDK)动态代理

  1. 使用JDK动态代理，利用Proxy类里面的方法创建代理对象

(1)调用Proxy中的newProxyInstance方法

方法有三个参数：

第一个参数： 类的加载器

第二个参数：代理类实现的接口，支持多个接口

第三个参数：接口 InvocationHandler

  1. 编写JDK动态代理代码

(1)创建接口，定义方法

1
2
3
4
5
6
7
8
9
/**
 * @author yhc
 *
 */
public interface UserDao {
    int add(int a,int b);
    String update(String id);
}

(2)创建接口实现类（被代理类），实现方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
 * @author yhc
 *
 */
public class UserDaoImpl implements UserDao{

    @Override
    public int add(int a, int b) {
        System.out.println("add方法执行了...");
        return a + b;
    }

    @Override
    public String update(String id) {
        System.out.println("update方法执行了...");
        return id;
    }

    @Override
    public String toString() {
        return "UserDaoImpl{}";
    }
}

(3)使用Proxy类创建接口代理对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/**
 * @author yhc
 *
 */
public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类的代理对象
        Class[] interfaces = {UserDao.class};
        UserDaoImpl userDaoImpl = new UserDaoImpl();
        UserDao userDaoProxy = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxyHandler(userDaoImpl));
        int sum = userDaoProxy.add(1, 2);
        System.out.println(sum);
    }
}
class UserDaoProxyHandler implements InvocationHandler{
    //把被代理对象传进来
    private Object obj;
    public  UserDaoProxyHandler(Object obj){
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //方法之前
        System.out.println("方法执行之前的通用操作..." + method.getName() + ":传递参数..." + Arrays.toString(args));
        //被增强的方法执行
        Object returnValue = method.invoke(obj, args);

        //方法之后
        System.out.println("方法执行之后的通用操作..." + obj);
        return returnValue;
    }
}

4.4AOP术语

  1. 连接点：类里面哪些方法可以被增强，这些方法成为连接点
  2. 切入点：真正被增强的方法，成为切入点
  3. 通知：

(1)实际增强的逻辑部分称为通知

(2)通知有多种类型

  • 前置通知
  • 后置通知
  • 环绕通知
  • 异常通知
  • 最终通知
  1. 切面：把通知应用到切入点的过程

4.5AOP操作前的准备

  1. Spring框架一般都是基于AspectJ实现AOP操作

(1)AspectJ不是Spring的组成部分，独立于AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP

操作

  1. 基于AspectJ实现AOP操作

(1)基于xml配置文件实现

(2)基于注解方式实现

  1. 在项目工程中引入AOP相关依赖

  2. 切入点表达式

(1)切入点表达式的作用：知道对哪个类的哪个方法进行增强

(2)语法结构：execution(([权限修饰符] [返回类型] [类全路径] [方法名称] ([参数列表]) ))

(3)其中：访问修饰符可以省略，返回值可以使用通配符，表示任意返回值，包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.

举例1：对com.atguigu.dao.BookDao里面的add进行增强

execution(* com.atguigu.dao.BookDao.add(..))

举例 2：对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强 execution(* com.atguigu.dao.BookDao.* (..))

举例 3：对 com.atguigu.dao 包里面所有类，类里面所有方法进行增强 execution(* com.atguigu.dao.. (..))

4.6AOP操作(AspectJ注解)

  1. 创建类在类里面定义方法
1
2
3
4
5
6
public class User {

    public void add(){
        System.out.println("add......");
    }
}
  1. 创建增强类，创建方法，让不同方法代表不同的通知类型
1
2
3
4
5
public class UserProxy {
 public void before() {//前置通知
 System.out.println("before......");
 }
}
  1. 进行通知的配置

(1)在Spring配置文件中，添加context和aop命名空间，并开启注解扫描

1
2
3
4
5
6
7
8
9
10
11
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

<!--    开启注解扫描-->
    <context:component-scan base-package="com.atguigu.AOP"></context:component-scan>

(2)使用注解创建User和UserProxy对象

(3)在增强类上面添加注解@Aspect

(4)在Spring配置文件中开启生成代理对象

1
2
<!--    开启AspectJ生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
  1. 配置不同类型的通知

(1)在增强类里面，在作为通知的方法上面，添加通知类型的注解，使用切入点表达式配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
/**
 * @author yhc
 *
 */
//增强的类
@Component
@Aspect//生成代理对象
public class UserProxy {

    //相同切入点的抽取
    @Pointcut(value = "execution(* com.atguigu.AOP.User.add(..))")
    public void pointDemo(){

    }


    //Before注解表示作为前置通知
    @Before(value = "pointDemo()")
    public void before(){
        System.out.println("before......");
    }

    //后置通知(返回通知,有异常时不会执行)
    @AfterReturning(value = "execution(* com.atguigu.AOP.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning......");
    }

    //异常通知
    @AfterThrowing(value = "execution(* com.atguigu.AOP.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing......");
    }

    //最终通知(有无异常都会执行)
    @After(value = "execution(* com.atguigu.AOP.User.add(..))")
    public void after(){
        System.out.println("after......");
    }

    //环绕通知
    @Around(value = "execution(* com.atguigu.AOP.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("around环绕之前......");

        //被增强的方法add的执行
        proceedingJoinPoint.proceed();

        System.out.println("around环绕之后......");
    }
}

  1. 相同切入点的抽取
1
2
3
4
5
6
7
8
9
10
11
12
//相同切入点的抽取
   @Pointcut(value = "execution(* com.atguigu.AOP.User.add(..))")
   public void pointDemo(){

   }


   //Before注解表示作为前置通知
   @Before(value = "pointDemo()")
   public void before(){
       System.out.println("before......");
   }
  1. 有多个增强类对同一个方法进行增强，设置增强类的优先级

(1)在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高

1
2
3
4
@Component
@Aspect
@Order(1)
public class PersonProxy
  1. 完全使用注解开发

(1)创建配置类，不需要创建xml配置文件

1
2
3
4
5
6
7
8
9
/**
 * @author yhc
 *
 */
@Configuration
@ComponentScan(basePackages = {"com.atguigu"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAOP {
}
赏

谢谢你请我吃糖果

微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

大二学生一枚，共同进步