Spring学习—Aop

标题：Spring学习—Aop

学习内容：

1、Aop基本概念
2、Aop底层原理
3、Aop操作术语
4、切入点表达式
5、基于AspectJ注解进行Aop操作
6、基于AspectJ配置文件进行Aop操作

---

内容详情：

1、Aop基本概念
什么是AOP·

(1）面向切面编程（方面)，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
(2）通俗描述:不通过修改源代码方式，在主千功能里面添加新功能,

2、Aop底层原理

AOP底层使用动态代理

有两种情况动态代理

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

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

JDK动态代理代码

相关内容
使用Proxy类里面的newProxyInstance方法创建代理对象。

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

创建User接口，Userlmpl类实现User接口，创建一个JDKProxy类，里面写一个主方法，主方法里面使用proxy类

1.创建User接口，Userlmpl类实现User接口

//User接口
package jr.xiaobai;

public interface User {

    public int add(int a,int b);
    public String  update(String id);
}

//Userlmpl类
package jr.xiaobai;

public class Userlmpl implements User {
    @Override
    public int add(int a, int b) {

        System.out.println("方法执行了");
        return a+b;
    }

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

2.创建一个JDKProxy类，使用 Proxy.newProxyInstance来创建代理对象，该方法的第三个参数，另外用一个UserlmplProxy类去实现这个接口，里面的 invoke方法就是写的增强的那部分。

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

public class JDkProxy {
    public static void main(String[] args) {

        Class[] interfaces={User.class};
        Userlmpl userlmpl = new Userlmpl();
        //使用 Proxy.newProxyInstance来创建代理对象
        User user = (User) Proxy.newProxyInstance(JDkProxy.class.getClassLoader(), interfaces, new UserlmplProxy(userlmpl));

        System.out.println(user.add(2,3));
    }


}

    //创建代理对象
class UserlmplProxy implements InvocationHandler{
//    创建谁的代理对象，就传进来谁
    private Object object;
    public UserlmplProxy(Object object){
        this.object=object;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //方法执行之前
        System.out.println("方法执行之前");
        //方法执行
        Object invoke = method.invoke(object, args);
        //方法执行之后
        System.out.println("方法执行之后");

        return invoke;
    }
}

3、 Aop操作术语

1、连接点

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

2、切入点

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

3、通知(增强)

(1)实际增强的逻辑部分称为通知〔增强)
(2）通知有多钟类型
前置通知
后置通知
环绕通知
异常通知
最终通知finally

4、切面是动作

把通知应用到切入点过程

4、 切入点表达式
切入点表达式作用

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

语法结构:

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

举例:对 jr.xiaobai.dao.BookDao类里面的add进行增强
execution(* jr.xiaobai.dao.BookDao.add(…))

注意：*后面有空格，方法里面的…表示参数列表

5、基于AspectJ注解进行Aop操作

相关内容
1.创建三个类
User被增强类，UserProxy增强类，AopTest测试类
2.一个配置文件bean1.xml

User类

package jr.xiaobai.zhujie;

import org.springframework.stereotype.Component;

@Component
public class User {

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

    }
}

UserProxy类

package jr.xiaobai.zhujie;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.junit.jupiter.api.Order;
import org.springframework.stereotype.Component;


//增强类
@Component
@Aspect
@Order(1)//增加优先级，数值越小越先执行
public class UserProxy {
    @Pointcut(value = "execution(* jr.xiaobai.zhujie.User.add(..))")
    public void pointDemo(){

    }
    @Before(value ="pointDemo()")
//    @Before(value = "execution(* jr.xiaobai.zhujie.User.add(..))")//方法前面执行
    @After(value = "execution(* jr.xiaobai.zhujie.User.add(..))")//方法后面执行
    @AfterReturning(value = "execution(* jr.xiaobai.zhujie.User.add(..))")//返回值之后执行
    @AfterThrowing(value = "execution(* jr.xiaobai.zhujie.User.add(..))")//方法异常执行
    public void add(){
        System.out.println("增强");
    }

    @Around(value = "execution(* jr.xiaobai.zhujie.User.add(..))")//方法前后都执行
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前");
        //被争强的方法执行
        proceedingJoinPoint.proceed();

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

}

AopTest类

package jr.xiaobai.zhujie;

import javafx.application.Application;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class AopTest {


    @Test
    public void test1(){
        ApplicationContext Context = new FileSystemXmlApplicationContext("C:\\ideacode\\Aop\\src\\main\\java\\bean1.xml");
        User user = Context.getBean("user", User.class);
        user.add();
    }
    @Test
    public void test2(){
        ApplicationContext Context = new FileSystemXmlApplicationContext("C:\\ideacode\\Aop\\src\\main\\java\\bean2.xml");
        User user = Context.getBean("user", User.class);
        user.add();
    }
}

bean.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="jr.xiaobai"></context:component-scan>

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>


</beans>

用法很简单，就是在类上面加一个注解，然后切入表达式
可以用order增加优先级
还有下面这段代码提取出切入表达式

   @Pointcut(value = "execution(* jr.xiaobai.zhujie.User.add(..))")
    public void pointDemo(){

    }

6、基于AspectJ配置文件进行Aop操作

这个跟IOC差不多，一般用注解，代码简要看一下怎么配置的

<?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 class="jr.xiaobai.zhujie.User" id="user"></bean>
    <bean class="jr.xiaobai.zhujie.UserProxy" id="userProxy"></bean>


    <!--    配置增强aop-->
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="p" expression="execution(* jr.xiaobai.zhujie.User.add(..))"/>
        <!--配置切面-->
        <aop:aspect  ref="userProxy">
<!--            增强作用在具体的方法上-->
            <aop:before method="add" pointcut-ref="p"></aop:before>
        </aop:aspect>



    </aop:config>

</beans>

---