04-Spring5-Aop

1、什么是AOP

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

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

(3)使用登录例子说明 AOP

2、底层原理

Aop底层使用动态代理，动态代理有两种情况:

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

第二种 没有接口情况，使用 CGLIB 动态代理；创建子类的代理对象，增强类的方法

2.1、JDK动态代理实现

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

调用 newProxyInstance 方法，方法有三个参数：

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
​ 第一参数，类加载器

​ 第二参数，增强方法所在的类，这个类实现的接口，支持多个接口

​ 第三参数，实现这个接口 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) {
        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 o = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int add = o.add(1, 2);
        System.out.println(add);
    }
}
//创建代理对象代码
class UserDaoProxy implements InvocationHandler{
    //1 把创建的是谁的代理对象，把谁传递过来
    //有参构造传递
    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 invoke = method.invoke(obj, args);
        //方法之后
        System.out.println("方法之后执行..." + obj);
        return invoke;
    }
}

3、操作术语

1.连接点

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

2.切入点

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

3.通知(增强)

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

(2)通知有多种类型:

• 前置通知
• 后置通知
• 环绕通知
• 异常通知
• 最终通知

4.切面

是动作

(1) 把通知应用到切面点过程

(2)个人见解: 实际增强的逻辑代码模块放到实际增强的方法之前或之后执行，称为切面。

4、Aop操作(准备工作)

1.Spirng框架一般都是基于AspectJ实现Aop操作

​ (1)什么是AspectJ

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

2.基于AspectJ实现Aop操作

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

​ (2)基于注解方式实现(建议使用)

3.在项目工程里面引入Aop依赖

<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjweaver</artifactId>
   <version>1.9.4</version>
</dependency>

4.切入点表达式

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

​ (2)语法结构:

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

举例1 : 对com.atguigu.dao.BookDao类里面的add进行增强
* 代表所有权限修饰符
.. 参数列表    
execution(*com.atguigu.dao.BookDao.add(..)) 
    
举例2 : 对com.atguigu.dao.BookDao对类中所有的方法进行增强
第一个* 所有权限修饰符
第二个* 所有方法    
execution(*com.atguigu.dao.BookDao.*(..)) 
    
举例2 : 对com.atguigu.dao包里面所有类，类里面所有方法进行增强
第一个* 所有权限修饰符
第二个* dao包下的所有类
第三个* 所有方法    
execution(*com.atguigu.dao.*.*(..))     

5、Aop操作(基于注解方式)(推荐使用)

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

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

2.创建增强类(编写增强逻辑)

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

//增强的类
public class UserProxy {

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

3.进行通知的配置

(1)在spring配置文件中，开启注解扫描

<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.spring5.aopanno"/>

</beans>

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

@Component
public class User {}

//增强的类
@Repository
public class UserProxy {}

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

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

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

//到类里面查看是否有@Aspect,如果有则生成代理对象
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

4.配置不同类型的通知

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

	//前置通知
    //@Before注解表示作为前置通知
    @Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void before(){
        System.out.println("before....");
    }
    //@After注解表示作为最终通知，在实际增强的方法之后执行，不管有没有异常都会执行。
    @After(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void afer(){
        System.out.println("afer...");
    }
    //@AfterReturning注解表示后置通知在实际增强的方法返回结果值之后执行，有异常就不会执行
    @AfterReturning(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning...");
    }
    //表示有异常才会执行
    @AfterThrowing(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing...");
    }
    //环绕通知
    @Around(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前...");
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后...");
    }

5.相同的切入点进行抽取

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

    }

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

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

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

@Component
@Aspect
@Order(0)
public class PersionProxy {}

7.完全使用注解开发

​ (1)创建配置类,不需要创建xml配置文件。

@Configuration
@ComponentScan(basePackages = {"com.atguigu.spring5"})
@EnableAspectJAutoProxy(proxyTargetClass = true)//开启代理
public class AopConfiguration {
}

6、Aop操作(基于Xml配置方式)

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

//被增强类
public class Book {

    public void buy(){
        System.out.println("buy..........");
    }
}
//增强类
public class BookProxy {

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

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

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

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

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