JDK 动态代理、Spring 的 AOP学习笔记

1、Spring 的 AOP

Spring 的 AOP 实现底层就是对动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强

2、JDK 的动态代理

2.1目标接口和目标类

public interface TargetInterface {
    public void save();
}

public class Target implements TargetInterface{
    public void save() {
        System.out.println("save running....");
    }
}

2.2增强类

public class Advice {
    public void before(){
        System.out.println("前置增强");
    }
    public void afterturnback(){
        System.out.println("后置增强");
    }
}

2.3动态代理测试

    public static void main(String[] args) {
        final Target target = new Target();
        final Advice advice = new Advice();
        //返回值就是动态生成的代理对象
        TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),//目标对象类加载器
                target.getClass().getInterfaces(),//目标对象相同的接口字节码对象数组
                new InvocationHandler() {
                    //调用代理对象的任何方法，实际上执行的都是invoke方法
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //前置增强
                        advice.before();
                        Object invoke = method.invoke(target, args);
                        //后置增强
                        advice.afterturnback();
                        return invoke;
                    }
                }
        );

        //调用代理对象的方法
        proxy.save();
    }

3、AOP 技术实现的内容和相关概念

Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

Target（目标对象）：代理的目标对象
Proxy （代理）：Spring产生的结果代理类
Joinpoint（连接点）：指那些被拦截到的点
Pointcut（切入点）：被增强的方法
Advice（通知/ 增强）：封装增强业务逻辑的方法
Aspect（切面）：切点+通知
Weaving（织入）：将切点与通知结合的过程

4、基于 XML 的 AOP 开发

导入 AOP 相关坐标

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.3.RELEASE</version>
        </dependency>

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

创建目标接口和目标类、创建切面类

//目标接口
public interface TargetInterface {
    public void save();
}
//目标类
public class Target implements TargetInterface{
    public void save() {
        System.out.println("save running....");
    }
}
//切面类
public class Advice {
    public void before(){
        System.out.println("前置增强");
    }
    public void afterturnback(){
        System.out.println("后置增强");
    }
}

将目标类和切面类的对象创建权交给 spring、导入aop命名空间、配置织入关系

<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="target" class="cn.guixinchn.proxy.Target"></bean>
	<bean id="advice" class="cn.guixinchn.proxy.Advice"></bean>

    
    <aop:config>
        <!--引入advice切面类对象-->
        <aop:aspect ref="advice">
            <!--配置Target的save方法执行时要进行前置增强-->
            <aop:before method="before" pointcut="execution(public void cn.guixinchn.proxy.Target.save())"></aop:before>
            <!--配置Target的save方法执行时要进行后置增强-->
            <aop:after method="afterturnback" pointcut="execution(public void cn.guixinchn.proxy.Target.save())"></aop:after>
        </aop:aspect>
    </aop:config>

测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Autowired
    private TargetInterface targetInterface;

    @Test
    public void test(){
        targetInterface.save();
    }
}

4.1切点表达式的写法（作用：指定哪些方法需要增强）

execution([修饰符] 返回值类型包名.类名.方法名(参数))

常用的写法：

execution(* cn.guixinchn..*.*(..))

修饰符可省略、* 标识任意、包名后面两个点..表示当前包及其子包下的类、方法里面两个..表示任意参数

4.2通知的类型

<aop:config>
    <aop:aspect ref=“切面类”>
        <aop:通知类型 method=“通知方法名称” pointcut=“切点表达式"></aop:通知类型>
    </aop:aspect>
</aop:config>

前置通知：<aop:before>
后置通知：<aop:after-returning>
环绕通知：<aop:around>
异常通知：<aop:throwing>
最终通知：<aop:after>

5、基于注解的AOP开发

创建目标接口和目标类、创建切面类

//目标接口
public interface TargetInterface {
    public void save();
}
//目标类
public class Target implements TargetInterface{
    public void save() {
        System.out.println("save running....");
    }
}
//切面类
public class Advice {
    public void before(){
        System.out.println("前置增强");
    }
    public void afterturnback(){
        System.out.println("后置增强");
    }
}

目标类和切面类的对象创建权交给 spring、切面类中使用注解配置织入关系

//目标类
@Component("target")
public class Target implements TargetInterface{
    public void save() {
        System.out.println("save running....");
    }
}

//切面类
@Component("advice")
@Aspect
public class Advice {
    @Before("execution(* cn.guixinchn..*.*(..))")
    public void before(){
        System.out.println("前置增强");
    }
    @AfterReturning("execution(* cn.guixinchn..*.*(..))")
    public void afterturnback(){
        System.out.println("后置增强");
    }
}

在配置文件中开启组件扫描和 AOP 的自动代理

<!--组件扫描-->
<context:component-scan base-package="cn.guixinchn.proxy"></context:component-scan>
<!--aop自动代理-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Autowired
    private TargetInterface targetInterface;

    @Test
    public void test(){
        targetInterface.save();
    }
}

5.1注解通知的类型

通知的配置语法：@通知注解(“切点表达式")

前置通知：@Before
后置通知：@AfterReturning
环绕通知：@Around
异常通知：@AfterThrowing
最终通知：@After

5.2注解aop开发步骤

目标类和切面类的对象创建权交给 spring
使用@Aspect标注切面类、配置织入关系、通知方法
在配置文件中开启组件扫描和 AOP 的自动代理<aop:aspectj-autoproxy/>

posted @ 2020-12-17 21:54 咕咕星阅读(67) 评论(0) 编辑收藏举报

刷新页面返回顶部

咕咕星

当你每一次有想要努力的念头，都是未来的你在向现在的你求救