SpringMVC - AOP相关简介、概念与案例模拟

文章目录

• 什么是AOP
• AOP作用及其优势
• AOP的底层实现-AOP的动态代理技术
• • JDK动态代理
  • • 新建module
    • 编写测试接口
    • 测试实现接口类
    • 编写建议（通知）类
    • 编写代理测试类
    • • 测试成功
    • 方法执行前后...
    • • 测试成功
    • JDK动态代理自我总结
  • cglib动态代理
  • • 导入依赖
    • 编写初始类
    • 编写建议（通知）类
    • 编写代理类
• AOP相关概念
• • 连接点
  • 切入点
• AOP开发明确的事项
• • 需要编写的内容
  • AOP技术实现的内容
  • AOP底层使用哪种代理方式
  • 知识要点

什么是AOP

AOP作用及其优势

AOP的底层实现-AOP的动态代理技术

JDK动态代理

基于同一个接口的不同对象

新建module

编写测试接口

package com.taotao.proxy.jdk;

/**
 * create by 刘鸿涛
 * 2022/4/24 16:19
 */
@SuppressWarnings({"all"})
public interface TargetInterface {
    public void save();
}

测试实现接口类

package com.taotao.proxy.jdk;

/**
 * create by 刘鸿涛
 * 2022/4/24 16:27
 */
@SuppressWarnings({"all"})
public class Target implements TargetInterface{

    @Override
    public void save() {
        System.out.println("正在存储数据....");
    }
}

编写建议（通知）类

package com.taotao.proxy.jdk;

/**
 * create by 刘鸿涛
 * 2022/4/24 16:28
 */
@SuppressWarnings({"all"})
public class Advice {
    public void before(){
        System.out.println("前置增强...");
    }

    public void afterReturning(){
        System.out.println("后置增强...");
    }
}

编写代理测试类

package com.taotao.proxy.jdk;

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

/**
 * create by 刘鸿涛
 * 2022/4/24 16:31
 */
@SuppressWarnings({"all"})
public class ProxyTest {
    public static void main(String[] args) {

        final Target target = new Target();

        //返回值 就是动态生成的代理对象
        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 {
                        method.invoke(target,args);//执行目标方法
                        return null;
                    }
                }
        );

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

测试成功

方法执行前后…

编写ProxtyTest类

package com.taotao.proxy.jdk;

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

/**
 * create by 刘鸿涛
 * 2022/4/24 16:31
 */
@SuppressWarnings({"all"})
public class ProxyTest {
    public static void main(String[] args) {

        final Target target = new Target();

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

                        method.invoke(target,args);//执行目标方法

                        //后置增强
                        new Advice().afterReturning();
                        return null;
                    }
                }
        );

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

测试成功

JDK动态代理自我总结

鬼鬼骑士:
我描述下jdk的动态代理技术流程：
我们有一个类，实现了一个接口，然后我们有一个代理类，代理类里有实现接口类的对象，使用放射获取目标对象类加载器、以及与目标对象相同接口的字节码对象数组，使用匿名对象创建匿名内部类重写invoke方法，我们在匿名内部类重写方法里执行目标方法，传入实现接口类对象，执行invoke方法
最后，我们把代理类中代理对象返回成一个对象，用对象类的实现接口来接收，最后使用接口对象调用代理方法

鬼鬼骑士:
我们的优化拦截方案，可以在重写方法时进行拦截调用其他类对象方法，直接匿名对象调用方法即可

cglib动态代理

是根据目标对象生成的代理对象，而非接口实现、非继承关系

导入依赖

<dependency>
  <groupId>org.springframeworkgroupId>
  <artifactId>spring-coreartifactId>
  <version>5.0.5.RELEASEversion>
  <scope>compilescope>
dependency>

编写初始类

package com.taotao.proxy.cglib;


/**
 * create by 刘鸿涛
 * 2022/4/24 16:27
 */
@SuppressWarnings({"all"})
public class Target {

    public void save() {
        System.out.println("正在存储数据....");
    }
}

编写建议（通知）类

package com.taotao.proxy.cglib;

/**
 * create by 刘鸿涛
 * 2022/4/24 16:28
 */
@SuppressWarnings({"all"})
public class Advice {
    public void before(){
        System.out.println("前置增强...");
    }

    public void afterReturning(){
        System.out.println("后置增强...");
    }
}

编写代理类

package com.taotao.proxy.cglib;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * create by 刘鸿涛
 * 2022/4/24 16:31
 */
@SuppressWarnings({"all"})
public class ProxyTest {
    public static void main(final String[] args) {

        final Target target = new Target();

        //返回值 就是动态生成的代理对象 基于cglib
        //1.创建增强器
        Enhancer enhancer = new Enhancer();

        //2.设置父类（目标）
        enhancer.setSuperclass(Target.class);

        //3.设置回调
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object proxy, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                new Advice().before();//执行前置

                Object invoke = method.invoke(target, args);                //执行目标

                new Advice().afterReturning();//执行后置
                return null;
            }
        });

        //4.创建代理对象
        Target proxy = (Target)enhancer.create();

        proxy.save();

    }
}

AOP相关概念

连接点

可以被增强（通知）的方法

切入点

需要被增强（通知）的方法

AOP开发明确的事项 需要编写的内容

AOP技术实现的内容

AOP底层使用哪种代理方式

知识要点