Spring 学习笔记（三）

学习内容来自 B站尚硅谷视频

AOP 概念

AOP 即面向切面编程（Aspect Oriented Programming）

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

AOP 可以在不修改源代码的情况下，在主干功能模块中加入新的功能

AOP 底层原理

AOP 底层使用了动态代理，代理是指创建要增强对象的代理对象

动态代理有两种情况

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

• 没有接口的情况，使用 CGLIB 动态代理

创建子类的代理对象，增强类的方法

AOP–JDK 动态代理

1. 使用 JDK 动态代理，通过 Proxy 类里面的方法创建代理对象
   
   调用 newProxyInstance 方法，该方法有三个参数

ClassLoader 类加载器
Class<?>[] 待增强方法所在的类实现的接口
InvocationHandler 要实现的接口，创建代理对象，写增强的方法

2. 编写 JDK 动态代理代码

（1）创建接口

public interface UserDao {

    public int add(int a, int b);

    public String update(String id);

}

（2）创建接口实现类，实现方法

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;
    }
}

（3）创建代理类

// 创建代理对象的代理类
class UserDaoProxy implements InvocationHandler {

    // 被代理对象
    private Object obj;

    public UserDaoProxy(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 res = method.invoke(obj, args);

        // 在被增强方法执行之后增加的功能
        System.out.println("被增强方法的输出结果：" + res);

        return res;
    }
}

（4）使用 Proxy 类的 newInstance 方法生成代理对象

public static void main(String[] args) {
        Class[] interfaces = new Class[]{UserDao.class};

        // 创建接口实现类的代理对象
        // 这里创建了实现 InvocationHandler 接口的匿名内部类
        /**
        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                return null;
            }
        });
         */
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao = (UserDao) Proxy.newProxyInstance(UserDaoProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        System.out.println(dao.add(1, 2));
        System.out.println(dao.update("12"));
    }

输出结果为：

被增强方法为 add，传递的参数为[1, 2]
add 方法被调用
被增强方法的输出结果：3
3
被增强方法为 update，传递的参数为[12]
update 方法被调用
被增强方法的输出结果：12
12

AOP 操作术语

连接点

类中可以被增强的方法称为连接点

切入点

类中真正被增强的方法称为切入点

通知（增强）

对方法的增强逻辑称为通知（增强）

通知（增强）有多种类型：

• 前置通知：增强逻辑在被增强方法执行前执行
• 后置通知：增强逻辑在被增强方法执行后执行
• 环绕通知：增强逻辑在被增强方法执行前后都执行
• 异常通知：增强逻辑在被增强方法出现异常时执行，类似 try-catch 中的 catch
• 最终通知：被增强方法执行时不管是否抛出异常，都会执行增强逻辑，类似 try-catch-finally 中的 finally

切面

切面是一个动作，即把通知（增强）应用到切入点的过程

AOP 操作

准备

在 Spring 框架中一般基于AspectJ 实现 AOP 操作

AspectJ 并不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spring 框架一起使用，进行 AOP 操作

基于 AspectJ 实现 AOP 操作的方式有：

• 基于 xml 配置文件
• 基于注解，常用

1. 首先需要引入 AOP 相关依赖
   
   
2. 构造切入点表达式

切入点表达式用来表达对哪个类的哪个方法进行增强

语法结构：

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

举个栗子，对 com.sict.dao.UserDao 类中的 test 方法进行增强，表达式为

execution(* com.sict.dao.UserDao.add(..))

其中：

• *表示任意权限修饰符
• com.sict.dao.UserDao表示全类名
• .add表示增强 add 方法
• (..)即表示参数列表

再举个例子，对 com.sict.dao.UserDao 类中的所有方法进行增强

execution(* com.sict.dao.UserDao.*(..))

再来个，对 com.sict.dao 包里面所有类的所有方法进行增强

execution(* com.sict.dao.*.*.(..))

基于注解实现

1. 创建类，在类中定义方法

public class User {

    public void add() {
        System.out.println("User add..");
    }
}

2. 编写增强逻辑所在类

// 增强逻辑所在类
public class UserProxy {

    // 前置通知
    public void before() {
        System.out.println("before ..");
    }
}

3. 进行通知的配置

（1）在 spring 配置文件中开启注解扫描

<?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.sict.spring5.annotationAOP"/>

</beans>

（2）使用注解创建 User 和 UserProxy 对象，即在之前创建的类上方加上 @Component 注解

（3）在增强类中添加注解 @Aspect

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

<!--    开启 Aspect 生成代理对象
        即开启该配置后，会自动扫描含有 @Aspect 注解的类，生成代理对象
-->
    <aop:aspectj-autoproxy/>

4. 配置不同类型的通知

即在增强类中使用切入点表达式配置通知类型的注解

	// 前置通知
    // @Before 表示前置通知注解
    @Before(value = "execution(* com.sict.spring5.annotationAOP.User.add())")
    public void before() {
        System.out.println("before ..");
    }

    @After(value = "execution(* com.sict.spring5.annotationAOP.User.add())")
    public void after() {
        System.out.println("after ..");
    }

    @AfterReturning(value = "execution(* com.sict.spring5.annotationAOP.User.add())")
    public void afterReturning() {
        System.out.println("afterReturing ..");
    }

    @AfterThrowing(value = "execution(* com.sict.spring5.annotationAOP.User.add())")
    public void afterThrowing() {
        System.out.println("afterThrowing");
    }

    @Around(value = "execution(* com.sict.spring5.annotationAOP.User.add())")
    public void arount(ProceedingJoinPoint proceed) throws Throwable {
        System.out.println("around begin..");

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

        System.out.println("around end..");
    }

编写测试代码

public void testAOPAnnotation() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");

        User user = context.getBean("user", User.class);

        user.add();
    }

输出结果

around begin..
before ..
User add..
around end..
after ..
afterReturing ..

此时没有执行异常通知

修改方法代码，加上运行时异常

public void add() {
        System.out.println("User add..");
        // 运行时异常
        System.out.println(1 / 0);
    }

输出结果

around begin..
before ..
User add..
after ..
afterThrowing

总结

AOP 的通知有五种类型，相对应注解如下

• @Before 方法执行之前执行
• @After 方法执行之后执行，不管方法是否正常执行完毕，都会执行
• @AfterThrowing 方法抛出异常时执行
• @AfterReturning 方法返回值之后执行
• @Around 方法执行前，以及方法正常执行后执行

相同的切入点提取

在上面的例子中，五种通知的切入点表达式都相同，于是可以抽取出切入点的相同部分

可以通过注解 @Pointcut 实现

// 相同切入点抽取
    @Pointcut(value = "execution(* com.sict.spring5.annotationAOP.User.add())")
    public void pointdemo() {

    }

然后在原来注解的 value 处引用该方法即可，如下

    // 方法执行之后执行
    @After(value = "pointdemo()")
    public void after() {
        System.out.println("after ..");
    }

设置增强类优先级

若一个方法有多个增强类，可以设置不同增强类之间的执行的优先级

可以通过在增强类上方添加注解 @Order(int)，int 对应的值越小，优先级越高

于是，可以在之前的增强类上加上该注解

再新建一个增强类：

@Component
@Aspect
@Order(1)
public class PersonProxy {

    @Before(value = "execution(* com.sict.spring5.annotationAOP.User.add())")
    public void before() {
        System.out.println("Person Before...");
    }
}

然后运行测试，输出结果为：

Person Before...
around begin..
before ..
User add..
around end..
after ..
afterReturing ..

可以看到，先执行了 PersonProxy 的增强方法

完全注解开发

创建一个配置类替代配置文件

@Configuration
@ComponentScan(basePackages = {"com.sict.spring5.annotationAOP"})   // 开启组件扫描
@EnableAspectJAutoProxy(proxyTargetClass = true)    // 开启 Aspect 生成代理类对象
public class ConfigAOP {

}

这时候的测试代码不用加载 xml，而是加载配置类，如下：

public void testAOPAnnotation02() {
        ApplicationContext context =
                new AnnotationConfigApplicationContext(ConfigAOP.class);

        User user = context.getBean("user", User.class);

        user.add();
    }

输出结果：

Person Before...
around begin..
before ..
User add..
around end..
after ..
afterReturing ..

基于配置文件

1. 首先需要创建增强类和被增强类

被增强类

public class Book {

    public void buy() {
        System.out.println("buy book ..........");
    }
}

增强类

public class BookProxy {

    public void before() {
        System.out.println("before.........");
    }

}

2. 在 Spring 配置文件中创建两个类的对象

<!--    创建对象-->
    <bean id="book" class="com.sict.spring5.xmlAOP.Book"/>
    <bean id="bookProxy" class="com.sict.spring5.xmlAOP.BookProxy"/>

3. 在 Spring 配置文件中配置切入点

<!--    配置 AOP 增强-->
    <aop:config>
<!--        切入点
            id 是切入点的唯一标识符
            expression 是切入点表达式
-->
        <aop:pointcut id="p" expression="execution(* com.sict.spring5.xmlAOP.Book.buy())"/>

<!--        配置切面
            ref 是增强类
-->
        <aop:aspect ref="bookProxy">
<!--            method 是通知类型
                pointcut-ref 是被增强类的 id
-->
            <aop:before method="before" pointcut-ref="p"/>
        </aop:aspect>
    </aop:config>

4. 编写测试代码

public void testAOPXML() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean2.xml");

        Book book = context.getBean("book", Book.class);

        book.buy();
    }

输出结果为：

before.........
buy book ..........