spring的AOP

AOP概念：

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

（2）通俗描述就是，不通过修改源代码的方式，在主干功能里面添加新功能

1.AOP底层使用动态代理

（1）有两种情况动态代理

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

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

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

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

编写 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) {
        return a+b;
    }

    @Override
    public String update(String id) {
        return id;
    }
}

 （3）使用Proxy类创建接口代理对象

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 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("方法之后执行"+obj);
        return res;
    }
}

AOP（术语）
1、连接点
类里面哪些方法可以被增强，这些方法成为连接点
2、切入点
实际被增强的方法，叫做切入点
3、通知（增强）
实际被增强的逻辑部分
4、通知类型
前置通知（方法之前）
后置通知（方法之后）
环绕通知（方法之前之后）
异常通知（方法出现异常）
最终通知（方法执行完，return之前）
5、切面
把通知应用到切入点的过程

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.company.dao.BookDao 类里面的 add 进行增强
execution(* com.company.dao.BookDao.add(..))

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

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

AOP 操作（AspectJ 注解）

1.先写一个类

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

2.创建一个增强的类

package com.chen.aopanno;
//增强的类
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.chen.aopanno"></context:component-scan>
</beans>

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

 

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

 

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

4.配置不同类型的通知

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

package com.chen.aopanno;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

//增强的类
@Component
@Aspect
public class UserProxy {
    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "execution(* com.chen.aopanno.User.add(..))")
    public  void  before(){
        System.out.println("before........");
    }
    //后置通知
    @After(value = "execution(* com.chen.aopanno.User.add(..))")
    public  void  After(){
        System.out.println("After........");
    }
    //后置通知
    @AfterReturning(value = "execution(* com.chen.aopanno.User.add(..))")
    public  void  AfterReturning(){
        System.out.println("AfterReturning........");
    }
    //环绕通知，在增强方法之前做之后都执行
    @Around(value = "execution(* com.chen.aopanno.User.add(..))")
    public  void  Around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前........");
        //被增强的方法执行
        proceedingJoinPoint.proceed();

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

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

5.测试

public class Mytest {
    @Test
    public void  testaopAnno(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        User user = context.getBean("user", User.class);
        user.add();

    }
}

6.相同切入点抽取

//增强的类
@Component
@Aspect
public class UserProxy {
    //相同切入点抽取
    @Pointcut(value = "execution(* com.chen.aopanno.User.add(..))")
    public void pointdemo(){
        
    }
    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "pointdemo()")
    public  void  before(){
        System.out.println("before........");
    }

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

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

 

AOP 操作（AspectJ 配置文件）

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

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

@Component
@Aspect
public class BookProxy {
    @Pointcut(value ="execution(* com.chen.aopxml.Book.buy(..))" )
    public void pointcut(){

        }
    @Before(value = "pointcut()")
    public void before(){
        System.out.println("before......");
    }
}

2、在 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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--创建对象-->
    <bean id="book" class="com.chen.aopxml.Book"></bean>
    <bean id="bookproky" class="com.chen.aopxml.BookProxy"></bean>
</beans>

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

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

7.完全使用注解开发

（1）创建配置类不需要xml文件

@Configuration
@ComponentScan(basePackages = {"com.chen"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AOPconfig {
}