Spring AOP详解

Spring AOP详解 AOP（概念）

1、什么是 AOP

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

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

3. 使用登录例子说明 AOP

AOP（底层原理）

AOP 底层使用动态代理，有两种情况动的态代理：

第一种 有接口情况，使用 JDK 动态代理

• 创建接口实现类代理对象，增强类的方法

第二种 没有接口情况，使用 CGLIB 动态代理

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

AOP（JDK 动态代理）

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

调用 newProxyInstance 方法

方法有三个参数：

• 第一参数，类加载器
• 第二参数，增强方法所在的类，这个类实现的接口，支持多个接口
• 第三参数，实现这个接口 InvocationHandler，创建代理对象，写增强的部分

2. 编写 JDK 动态代理代码

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

public interface UserDao {
    int add(int a,int b);
    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）使用 Proxy 类创建接口代理对象

public class JDKProxy {
    public static void main(String[] args) {
       //增强方法所在的类，这个类实现的接口，支持多个接口
        Class[] interfaces={UserDao.class};
        //创建接口实现类代理对象  new InvocationHandler()是一个接口  有两种方式创建代理对象 一种是通过匿名内部类实现
        // 另一种是创建一个类来继承InvocationHandler这个接口
//        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
//            @Override
//            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//                return null;
//            }
//        });

        //创建接口实现类对象
        UserDao userDao=new UserDaoImpl();

        //为了结构清晰就使用继承InvocationHandler这个接口来创建代理对象
        UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int result = dao.add(10, 2);
        System.out.println("result:"+result);
    }
}

//创建代理对象代码
class UserDaoProxy implements InvocationHandler{
    //1 把创建的是谁的代理对象，那么就把它传递过来
    //通过有参传递
    private Object obj;
    public UserDaoProxy(Object obj) {
        this.obj=obj;
    }

    //增强的逻辑代码
    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("方法之后执行...."+obj);
        return res;
    }
}

(4) 运行结果

方法之前执行....add :传递的参数...[10, 2]
add方法被执行了。。。。。。
方法之后执行....cn.demo.dao.UserDaoImpl@2503dbd3
result:12

AOP（术语）

1. 连接点

类里面哪些方法可以被增强，那么这些方法就称为连接点

2. 切入点

实际被真正增强的方法，称为切入点

3. 通知

实际增强的逻辑部分称为通知（增强）

通知有多种类型 ：

	前置通知：在方法之前 *** 作
	后置通知：在方法之后 *** 作
	环绕通知：在方法之前和之后 *** 作
	异常通知：在方法报错的时候 *** 作
	最终通知：无论什么情况下都会执行 *** 作，相当于finally

4. 切面

是一个动作，把通知应用到切入点的过程

AOP *** 作（准备工作）

1、Spring 框架一般都是基于 AspectJ 实现 AOP *** 作！

（1）AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使
用，进行 AOP *** 作

2、基于 AspectJ 实现 AOP *** 作：

（1）基于 xml 配置文件实现

（2）基于注解方式实现（使用）

3、在项目工程里面引入 AOP 相关依赖

4、切入点表达式

（1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强
（2）语法结构： execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )

举例 1：对 com.lay.dao.BookDao 类里面的 add 进行增强
execution(* com.lay.dao.BookDao.add(..))

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

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

AOP *** 作（AspectJ 注解）

1、创建类，在类里面定义方法

//被增强的类
public class User {
 	public void add() {
 		System.out.println("add.......");
 	} 
}

2、创建增强类（编写增强逻辑）

在增强类里面，创建方法，让不同方法代表不同通知类型

//增强的类
public class UserProxy {
 	public void before() {//前置通知
 		System.out.println("before......");
	} 
}

3、进行通知的配置

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

（2）使用注解创建 User 和 UserProxy 对象

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

//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy {}

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

4、配置不同类型的通知

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

//增强类
@Component//创建对象
@Aspect//生成代理对象
public class UserProxy {

    //前置通知
    //@Before 注解表示作为前置通知
    @Before(value =  "execution(* cn.demo.aopanno.User.add(..))")
    public void before(){
        System.out.println("before......");
    }

    //后置通知（返回通知）
    //@AfterReturning 注解表示作为后置通知（返回通知）
    @AfterReturning(value =  "execution(* cn.demo.aopanno.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning......");
    }

    //环绕通知
    //@Around 注解表示作为环绕通知
    @Around(value =  "execution(* cn.demo.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知之前......");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕通知之后......");
    }

    //最终通知
    //@After 注解表示作为最终通知
    @After(value =  "execution(* cn.demo.aopanno.User.add(..))")
    public void after(){
        System.out.println("after......");
    }

    //异常通知
    //@AfterThrowing 注解表示作为异常通知
    @AfterThrowing(value =  "execution(* cn.demo.aopanno.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing......");
    }

}

测试

 public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
        User user = context.getBean("user", User.class);
        user.add();
    }
 //结果：
 //环绕通知之前......
 //before......
 //被增强的方法add执行.......................
 //afterReturning......
 //after......
// 环绕通知之后......

5、相同的切入点抽取

 //相同切入点抽取
    @Pointcut(value =  "execution(* cn.demo.aopanno.User.add(..))")
    public void pointCut(){

    }

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

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

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

@Component//创建对象
@Aspect//生成代理对象
@Order(1)//设置增强类优先级
public class PersonProxy {
    //前置通知
    //@Before 注解表示作为前置通知
    @Before(value =  "execution(* cn.demo.aopanno.User.add(..))")
    public void before(){
        System.out.println("PersonProxy before......");
    }
}

7、完全使用注解开发

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

@Configuration//作为配置类，替代 xml 配置文件
@ComponentScan(basePackages = {"cn.demo"})//开启注解扫描
@EnableAspectJAutoProxy(proxyTargetClass = true)//开启 Aspect 生成代理对象
public class ConfigSpring {

}

AOP *** 作（AspectJ 配置文件）

1、创建两个类，增强类和被增强类，创建方法

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

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

2、在 spring 配置文件中创建两个类对象

3、在 spring 配置文件中配置切入点

到了这里，AOP的思想和使用相信大家就没问题了！

周星驰：江湖险恶，我从来都不轻易留下我的姓名！