Spring框架学习之AOP详解

一、概念

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

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

二、底层原理:动态代理

有两种情况动态代理

2.1 有接口, JDK 动态代理

1.被代理的对象

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

}

2.代理

package cn.zj.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

import cn.zj.dao.UserDao;
import cn.zj.dao.impl.UserDaoImpl;

public class JDKProxy {

    public static void main(String[] args) {
        // 创建接口实现类代理对象
        Class[] interfaces = { UserDao.class };
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces,
                new UserDaoProxy(userDao));
        
        int result = dao.add(1, 2);
        System. out .println( "result:"+result);
    }
}

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

    private Object target;// 目标类

    public UserDaoProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 方法执行之前
        System.out.println("方法执行之前.." + method.getName() + ";传递的参数:" + Arrays.toString(args));
        // 增强方法
        Object res = method.invoke(target, args);
        // 方法执行之后
        System.out.println("方法执行之后.." + target);
        return res;
    }

}

3.打印

方法执行之前..add;传递的参数:[1, 2]
add执行
方法执行之后..cn.zj.dao.impl.UserDaoImpl@6c629d6e
result:3

2.2 无接口, CGLIB 动态代理

1.被代理的对象

public class Cat {

    public void eat() {
        System.out.println("猫吃鱼");
    }
}

2.代理

public class CglibProxy {

    public static void main(String[] args) {
        Cat c = new CglibProxy().createProxyObject(Cat.class);
        c.eat();
    }

    // JDK代理是对对象做代理，cglib代理是对类做代理
    public Cat createProxyObject(Class clazz) {
        // 1.创建内存中的动态类 Enhance
        // 内存中造出一个没有名称的动态类
        Enhancer enhancer = new Enhancer();
        // 2.现在的类最终完成原始类的功能，同时对其进行功能的增强，必须先具有原始类对应的功能————继承
        enhancer.setSuperclass(clazz);
        // 3.进行功能的增强
        // 设置了方法的调用拦截
        // 设置具体的回调操作
        Callback callback = new MethodInterceptor() {
            // proxy:代理对象
            // method:被拦截的方法对象
            // args:调用参数
            // methodProxy:
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy)
                    throws Throwable {
                // 做增强
                System.out.println("执行前");
                // Object obj=method.invoke(proxy, args);//这种执行是代理类的方法,而不是目标类的,会造成内存溢出
                // 以下的两种都是执行目标类的方法
                // Object obj = methodProxy.invokeSuper(proxy, args);//执行目标类的方法
                // Object obj=method.invoke(proxy, args);
                Object res = methodProxy.invokeSuper(proxy, args);
                System.out.println("执行后");
                return res;
            }
        };
        enhancer.setCallback(callback);
        // 4.创建内存中的全新的类的对象
        Object proxyObj = enhancer.create();
        return (Cat) proxyObj;
    }

}

三、术语

1.连接点(Joinpoint)

类中的任意方法的运行时表示，可以简单理解为类中的方法,也就是可以被增强的方法

2.切入点(Pointcut)

具有共性功能的方法的运行时表示，可以简单理解为具有共性功能的方法,也就是实际被增强的方法

注意：切入点对应的是被挖去了共性功能后的方法执行时匹配断言（格式）

3.通知/增强(Advice)

共性功能模块化，可以简单理解为将共性功能抽取出来制作成独立的方法,实际增强的逻辑部分

类型:前置，后置，异常，最终，环绕

4.切面(Aspect)

切入点与通知的对应关系，可以简单理解为被抽取的共性功能与共性功能被抽取位置对应的方法之间的关系,把通知应用到切入点的过程

5.目标对象(Target Object)

包含切入点的运行时对象，开发阶段制作的是目标对象对应的类

6.AOP代理(AOP Proxy)

使用AOP的代理机制创建目标对象运行时代理对象，完成原始的功能

注意：原始目标对象已经被挖去了共性功能，此时使用目标对象执行任务无法完成原始任务，使用AOP代理机制，创建一个代理对象来完成原始目标对象的功能

7.织入(Weaving)

是一个将通知功能加入原始字节码的动态过程，将增强添加对目标类具体连接点上的过程

Spring使用的是运行时织入机制

8.引入(Introduction)

一种特殊的机制，可以为一个类的字节码动态的加入变量或方法

四、操作

4.1 Spring 框架一般都是基于 AspectJ 实现 AOP

AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使

用，进行 AOP 操作

4.2 实践

1.jar包引入

<dependencies>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.6</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-expression -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.3.6</version>
        </dependency>



        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.3.6</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.6</version>
        </dependency>

        <!-- @Resource注解需要 -->
        <dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>javax.annotation-api</artifactId>
            <version>1.3.1</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.3.6</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/net.sourceforge.cglib/com.springsource.net.sf.cglib -->
        <dependency>
            <groupId>net.sourceforge.cglib</groupId>
            <artifactId>com.springsource.net.sf.cglib</artifactId>
            <version>2.2.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aopalliance/com.springsource.org.aopalliance -->
        <dependency>
            <groupId>org.aopalliance</groupId>
            <artifactId>com.springsource.org.aopalliance</artifactId>
            <version>1.0.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/com.springsource.org.aspectj.weaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>com.springsource.org.aspectj.weaver</artifactId>
            <version>1.6.8.RELEASE</version>
        </dependency>



    </dependencies>

2.切入点表达式

作用：知道对哪个类里面的哪个方法进行增强

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

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

execution(* com.zj.dao.BookDao.add(…))

举例 2：对 com.zj.dao.BookDao 类里面的所有的方法进行增强

execution(* com.zj.dao.BookDao.* (…))

举例 3：对 com.zj.dao 包里面所有类，类里面所有方法进行增强

execution(* com.zj.dao.. (…))

3.xml方式

1.创建类

package cn.zj.aop.xml;

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

2.增强类

package cn.zj.aop.xml;

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

3.xml

<?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">
    <!--创建对象-->
    <bean id="book" class="cn.zj.aop.xml.Book"></bean>
    <bean id="bookProxy" class="cn.zj.aop.xml.BookProxy"></bean>

    <!--配置aop增强-->
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="p" expression="execution(* cn.zj.aop.xml.Book.buy(..))"/>
        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <!--增强作用在具体的方法上-->
            <aop:before method="before" pointcut-ref="p"/>
        </aop:aspect>
    </aop:config>
</beans>

4.注解方式

1.创建类

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

}

2.创建增强类

package cn.zj.aop.an;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

//增强的类
@Component
@Aspect  //生成代理对象

public class UserProxy {

    //前置通知
    @Before(value = "execution(* cn.zj.aop.an.User.add(..))")
    public void before() {
        System.out.println("before.........");
    }

    //后置通知（返回通知）
    @AfterReturning(value = "execution(* cn.zj.aop.an.User.add(..))")
    public void afterReturning() {
        System.out.println("afterReturning.........");
    }

    //最终通知
    @After(value = "execution(* cn.zj.aop.an.User.add(..))")
    public void after() {
        System.out.println("after.........");
    }

    //异常通知
    @AfterThrowing(value = "execution(* cn.zj.aop.an.User.add(..))")
    public void afterThrowing() {
        System.out.println("afterThrowing.........");
    }

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

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

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

3.xml配置注解扫描

<?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="cn.zj.aop.an"></context:component-scan>

    <!-- 开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

4.测试

ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        User user = context.getBean("user", User.class);
        user.add();

5.相同点抽取

//相同切入点抽取
    @Pointcut(value = "execution(* cn.zj.aop.an.User.add(..))")
    public void pointdemo() {

    }

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

6.有多个增强类多同一个方法进行增强，设置增强类优先级

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

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

     //后置通知（返回通知）
    @Before(value = "execution(* cn.zj.aop.an.User.add(..))")
    public void afterReturning() {
        System.out.println("Person Before.........");
    }
}
//增强的类
@Component
@Aspect  //生成代理对象
@Order(2)
public class UserProxy {

到此这篇关于Spring框架学习之AOP详解的文章就介绍到这了,更多相关Spring框架AOP内容请搜索自学编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持自学编程网！

编程技巧