手搓代码-从Java动态代理到AOP

其他 2020-02-13 18:37:16 阅读次数: 0

从Java动态代理到AOP

关键字 java 代理模式 动态代理 自定义注解 泛型使用 AOP springboot

1.java静态代理

遵循代理模式的思想，当一个对象需要完成某种操作，但是对象本身有不方便去完成的时候，对象可以委托给代理对象去完成相关操作。

示例代码：
假设：boss发现了系统的bug ，但是boss 修复不了，于是让可以修复问题的worker去修改。

第一步: 首先要有boss

public class Boss {
}

第二步：要有worker

public class Worker {
}

第三步：worker要有修复问题的能力，这里把这个修复问题的能力抽象成一个接口

public interface FixBug {
    void fixBug();
}

第四步：那有能力修复问题的worker就要实现这个FixBug的接口，并实现fixBug方法。

public class Worker implements FixBug {
    @Override
    public void fixBug() {
        System.out.println("worker 正在修复 问题 ....");
    }
}

第五步：boss要拥有这个worker，这里把worker当做是boss的一个字段（属性）。

public class Boss {
	// 这里要求的是一个有修复问题能力的worker所以就直接是定义FixBug的字段
    private FixBug worker;

    public Boss(FixBug fixBug) {
        this.worker = fixBug;
    }

    public void fixBug(){
        System.out.println("boss 要让worker 去修改问题");
        this.worker.fixBug();
        System.out.println("boss 的worker 已经修复了问题");
    }
}

第六步：测试

public class Main {
    public static void main(String[] args) {
        FixBug worker = new Worker();
        Boss boss = new Boss(worker);
        boss.fixBug();
    }
}
程序输出:
boss 要让worker 去修改问题
worker 正在修复 问题 ....
boss 的worker 已经修复了问题

以上就是个人理解的代理模式。

2.动态代理

动态代理的优势是不需要像静态代理一样硬编码。jdk支持在编译阶段动态去生成代理对象。

依然是上面的那个场景。

第一步：还是这个修改bug的能力。

public interface FixBug {
    void fixBug();
}

第二步：还是这个拥有修改bug能力的worker

public class Worker implements FixBug {
    @Override
    public void fixBug() {
        System.out.println("worker 正在修复 问题 ....");
    }
}

第三步：还是一个需要代理的Boss

public class Boss {
}

第四步：确定动态代理

public class Boss implements InvocationHandler {

    private FixBug worker;

    public Boss(FixBug fixBug) {
        this.worker = fixBug;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("worker开始修复问题了");
        Object invoke = method.invoke(worker, args);
        System.out.println("worker修复问题完成了");
        return invoke;
    }
}

到了这一步，其实是确定了代理关系。
Boss可以监控到worker的方法执行。也就是说这里boss变成了worker的代理了。
不过这个实例走到这里代理关系好像变成了Boss是worker的代理，不过也不是重点 ，重点是看动态代理的使用。

第五步:执行查看效果

public class Main {
    public static void main(String[] args) {
		// 要被代理的对象
        FixBug worker = new Worker();
        // 生成代理
        Boss boss = new Boss(worker);
		// 这一步是获取到一个被代理的对象 三个参数 第一个是被代理的对象ClassLoader ，第二个参数是 被代理的对象实现的接口，第三个参数是 代理对象
        FixBug fixBug = (FixBug) Proxy.newProxyInstance(worker.getClass().getClassLoader(), worker.getClass().getInterfaces(), boss);
		// 被代理的对象执行方法
        fixBug.fixBug();
    }
}
输出：
worker开始修复问题了
worker 正在修复 问题 ....
worker修复问题完成了

动态代理的特点是在编译过程中 可以动态生成被代理的对象。

3.总结整理动态代理

总结下jdk动态代理的特点。

  1. 被代理对象需要有接口实现。
    比如：worker实现了FixBug接口。

  2. 动态代理需要实现InvocationHandler接口，并可以获取到被代理的对象。
    比如：Boss实现了InvocationHandler接口，并在初始化时候传入了要被代理的对象worker。

  3. 通过Proxy.newProxyInstance获取到被代理的对象后，通过被代理的对象执行方法 会被代理对象拦截到。
    比如：

FixBug fixBug = (FixBug) Proxy.newProxyInstance(worker.getClass().getClassLoader(), worker.getClass().getInterfaces(), boss);
fixBug.fixBug();
输出：
worker开始修复问题了
worker 正在修复 问题 ....
worker修复问题完成了

当被添加了代理的对象 调用方法的时候，就会被Boss这个动态代理获拦截到方法的执行。

4.动态代理使用过程总结

  1. 想要添加动态代理的对象需至少要实现一个接口。

  2. 动态代理本身需要实现InvocationHandler，并可以接收到要被代理的对象,用于发起方法请求。

  3. 如果要使动态代理生效，需要使用Proxy.newProxyInstance方法来获取被添加代理的对象，并使用这个对象来发起方法调用。

5.封装动态代理的使用过程

  1. 第一步: 需要添加动态代理的对象 可以使用Object来代表。
  2. 第二步: 动态代理对象的封装
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class DynamicProxy implements InvocationHandler {

    private Object target;

    public DynamicProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("进入方法");
        Object invoke = method.invoke(target, args);
		System.out.println("即将结束方法");
        return invoke;
    }
}
  1. 第三步:封装获取添加代理对象的方法
   public static <T> T getProxyObject(T obj) throws Exception {
        Class<?>[] interfaces1 = obj.getClass().getInterfaces();
        if (interfaces1 == null || interfaces1.length == 0) throw new Exception("要求代理的对象要实现与其对应的接口");

        DynamicProxy dynamicProxy = new DynamicProxy(obj);
        ClassLoader classLoader = obj.getClass().getClassLoader();
        Class<?>[] interfaces = obj.getClass().getInterfaces();
        return (T) Proxy.newProxyInstance(classLoader, interfaces, dynamicProxy);
    }
  1. 第四步:使用过程
public static void main(String[] args) throws Exception{
   FixBug fixBug = getProxyObject((FixBug) (new Worker()));
   fixBug.fixBug();
}
输出结果:
进入方法
worker 正在修复 问题 ....
即将结束方法

通过方法的封装。现在可以快速实现动态代理。唯一的问题就是动态代理拦截到方法之后，做的操作太单一。
目前的处理,拦截到调用

  @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("进入方法");
        Object invoke = method.invoke(target, args);
		System.out.println("即将结束方法");
        return invoke;
    }

6.如何丰富拦截到方法之后的处理？

如果想要去丰富一类操作的处理。一定是通过抽象出这类操作的共同点，定义为接口，由接口的实现类去做具体的实现。在使用过程中通过选择不同的实现类来实现对于操作的灵活处理。

在我们现在的例子中，可以抽离出三个方法。
1.进入方法时
2.退出方法前
3.结果处理

抽离出接口则是

public interface MethodAroundHandler {
	// 进入接口
    void enterMethod();

	// 退出方法前
    void beforReturnMethod();
	// 结果处理
    <T>T dealResult(T obj);

}

做一个简单的实现类

public class SimpleMethodAround implements MethodAroundHandler {
    @Override
    public void enterMethod() {
        System.out.println("进入方法");
    }

    @Override
    public void beforReturnMethod() {
        System.out.println("方法退出前");
    }

    @Override
    public <T> T dealResult(T obj) {
        System.out.println("拦截到方法的返回值:"+obj);
        return obj;
    }
}

修改之前的DynamicProxy 动态代理

public class DynamicProxy implements InvocationHandler {

    private Object target;

    public DynamicProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        SimpleMethodAround simpleMethodAround = new SimpleMethodAround();
        simpleMethodAround.enterMethod();
        Object invoke = method.invoke(target, args);
        simpleMethodAround.beforReturnMethod();
        if (invoke != null) simpleMethodAround.dealResult(invoke);
        return invoke;
    }
}

依然还是原来的main方法


public class Main {

    public static <T> T getProxyObject(T obj) throws Exception {
        Class<?>[] interfaces1 = obj.getClass().getInterfaces();
        if (interfaces1 == null || interfaces1.length == 0) throw new Exception("要求代理的对象要实现与其对应的接口");
        DynamicProxy dynamicProxy = new DynamicProxy(obj);
        ClassLoader classLoader = obj.getClass().getClassLoader();
        Class<?>[] interfaces = obj.getClass().getInterfaces();
        return (T) Proxy.newProxyInstance(classLoader, interfaces, dynamicProxy);
    }

    public static void main(String[] args) throws Exception{
        FixBug fixBug = getProxyObject((FixBug) (new Worker()));
        fixBug.fixBug();
    }
}
输出结果:
进入方法
worker 正在修复 问题 ....
方法退出前

总结这次的处理。
把原来写在DynamicProxy中的方法拦击成功的转移并抽象成了接口，这样可以很方便的根据不同的情况来切换接口实现类。

下面应该考虑的是如何去动态的切换接口实现类。

7.通过注解的方式动态切换接口实现类

现在需要动态切换接口实现类的地方是在DynamicProxy 的invoke方法中。
先回回顾下这个方法

public class DynamicProxy implements InvocationHandler {

	// 被代理的对象
    private Object target;
	// 初始化时传入对象
    public DynamicProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    	// 初始化接口实现类
        SimpleMethodAround simpleMethodAround = new SimpleMethodAround();
        // 调用接口方法
        simpleMethodAround.enterMethod();
        // 调用原方法
        Object invoke = method.invoke(target, args);
        // 调用接口方法
        simpleMethodAround.beforReturnMethod();
        // 如果欧返回值 可以调用最后一个接口放方法
        if (invoke != null) simpleMethodAround.dealResult(invoke);
        // 最后返回结果
        return invoke;
    }
}

在invoke 可以拿到要调用的方法Method，这样就可以使用方法注解来指定使用哪个接口实现类，进而可以根据不同的注解来实例化不同的接口实现类。

这里修改invoke方法实现。主要是修改接口实现类的实例化过程。

@Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 如果是被注解标注的方法 才会被拦截
        if (method.isAnnotationPresent(DynamicProxyMethod.class)) {
            // 获取到注解
            DynamicProxyMethod annotation = method.getAnnotation(DynamicProxyMethod.class);
            // 获取到接口实现类
            MethodAroundHandler methodAroundHandler = (MethodAroundHandler) annotation.type().newInstance();
            // 调用接口方法
            methodAroundHandler.enterMethod();
            Object invoke = method.invoke(target, args);
            methodAroundHandler.beforReturnMethod();
            if (invoke != null) methodAroundHandler.dealResult(invoke);
            return invoke;
        }
        return method.invoke(target, args);
    }

定义方法注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DynamicProxyMethod {
    Class type() default SimpleMethodAround.class;
}

给原来的fixbug方法添加注解

public interface FixBug {
    @DynamicProxyMethod // 默认是SimpleMethodAround.class
    void fixBug();
}

还是原来的Main方法

public class Main {

    public static <T> T getProxyObject(T obj) throws Exception {
        Class<?>[] interfaces1 = obj.getClass().getInterfaces();
        if (interfaces1 == null || interfaces1.length == 0) throw new Exception("要求代理的对象要实现与其对应的接口");
        DynamicProxy dynamicProxy = new DynamicProxy(obj);
        ClassLoader classLoader = obj.getClass().getClassLoader();
        Class<?>[] interfaces = obj.getClass().getInterfaces();
        return (T) Proxy.newProxyInstance(classLoader, interfaces, dynamicProxy);
    }

    public static void main(String[] args) throws Exception{
        FixBug fixBug = getProxyObject((FixBug) (new Worker()));
        fixBug.fixBug();
    }
}
输出：
进入方法
worker 正在修复 问题 ....
方法退出前

到此 基本实现了对于方法的拦截 实现了方法进入时 返回前 以及 对结果的处理

8.整理代码

注解定义

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DynamicProxyMethod {
    Class type() default SimpleMethodAround.class;
}

方法拦截接口定义

public interface MethodAroundHandler {

    void enterMethod();

    void beforReturnMethod();

    <T>T dealResult(T obj);

}

两个MethodAroundHandler接口实现

public class SimpleMethodAround implements MethodAroundHandler {
    @Override
    public void enterMethod() {
        System.out.println("进入方法");
    }

    @Override
    public void beforReturnMethod() {
        System.out.println("方法退出前");
    }

    @Override
    public <T> T dealResult(T obj) {
        System.out.println("拦截到方法的返回值:"+obj);
        return obj;
    }
}

public class SimpleMethodAround2 implements MethodAroundHandler {
    @Override
    public void enterMethod() {
        System.out.println("222 进入方法");
    }

    @Override
    public void beforReturnMethod() {
        System.out.println("222 方法退出前");
    }

    @Override
    public <T> T dealResult(T obj) {
        System.out.println("222 拦截到方法的返回值:"+obj);
        return obj;
    }
}

要拦截的对象要实现一个接口

public interface FixBug {

    @DynamicProxyMethod // 注解标注要使用哪个MethodAroundHandler接口实现类
    void fixBug();

    @DynamicProxyMethod(type = SimpleMethodAround2.class) // 注解标注要使用哪个MethodAroundHandler接口实现类
    String coding();
}

要被动态代理的对象

public class Worker implements FixBug {

    @Override
    public void fixBug() {
        System.out.println("worker 正在修复 问题 ....");
    }

    @Override
    public String coding() {
        return "worker 正在coding .....";
    }
}

动态代理实现

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

public class DynamicProxy implements InvocationHandler {

    private Object target;

    public DynamicProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 如果是被注解标注的方法 才会被拦截
        if (method.isAnnotationPresent(DynamicProxyMethod.class)) {
            // 获取到注解
            DynamicProxyMethod annotation = method.getAnnotation(DynamicProxyMethod.class);
            // 获取到接口实现类
            MethodAroundHandler methodAroundHandler = (MethodAroundHandler) annotation.type().newInstance();
            // 调用接口方法
            methodAroundHandler.enterMethod();
            Object invoke = method.invoke(target, args);
            methodAroundHandler.beforReturnMethod();
            if (invoke != null) methodAroundHandler.dealResult(invoke);
            return invoke;
        }
        return method.invoke(target, args);
    }
}

Main函数


public class Main {

    public static <T> T getProxyObject(T obj) throws Exception {
        Class<?>[] interfaces1 = obj.getClass().getInterfaces();
        if (interfaces1 == null || interfaces1.length == 0) throw new Exception("要求代理的对象要实现与其对应的接口");
        DynamicProxy dynamicProxy = new DynamicProxy(obj);
        ClassLoader classLoader = obj.getClass().getClassLoader();
        Class<?>[] interfaces = obj.getClass().getInterfaces();
        return (T) Proxy.newProxyInstance(classLoader, interfaces, dynamicProxy);
    }

    public static void main(String[] args) throws Exception{
        FixBug fixBug = getProxyObject((FixBug) (new Worker()));
        fixBug.fixBug();
        fixBug.coding();
    }
}
最终输出:
进入方法
worker 正在修复 问题 ....
方法退出前
222 进入方法
222 方法退出前
222 拦截到方法的返回值:worker 正在coding .....

9. 最后MARK下

这个思路的实现，我封装了springboot-starter-dynamic-aop。
与文章中所讲的思路略微有些不同。
主要是利用了spring的Bean容器特性。来帮助创建动态代理。
githup地址: https://github.com/LH-0811/lh-springboot-starter-dynamic-aop

10.最后的最后

写了很多，希望大家能提出意见。指出我在思想上的不足。期待共同进步！！谢谢大家。

LH_0811
发布了7 篇原创文章 · 获赞 0 · 访问量 182
私信 关注

猜你喜欢

转载自blog.csdn.net/qq_30110435/article/details/100563130
今日推荐
零基础入门鸿蒙开发 HarmonyOS NEXT星河版开发学习
豆包MarsCode帮我2小时完成Go语言系统从开发、测试到部署全流程最佳实践，云IDE迁移PHP企业级项目最佳实践
内幕！smardaten无代码平台全方位测评，这些细节你绝对想不到！
idea安装及激活配置流程---2024旗舰版(需激活码)
Elastic 创始人：热爱开源，希望合作 OSI 创建新许可证
工业互联网标识解析体系开放开源下载服务中心发布
IDEA取消自动选择光标所在行
828华为云征文 | 使用Flexus X实例搭建Dubbo-Admin服务
Programmer&AI—AI辅助编程学习指南
【Linux】虚拟机安装 openEuler 24.03 X86_64
o1 发布后 Sam Altman 最新访谈：AI 发展不仅没有放缓，而且我们对未来几年已经胜券在握
AI芯片国产化率100%！运营商最大单集群智算中心投产
周排行
【后端】 Spring Cloud 服务间调用
Git 学习教程
Salesforce集成(三). 获取数据02_获取Object和Field信息
Oracle执行计划的稳定（使用MANUAL类型的SQL PROFILE）
js跨域请求之jsonp原理和运用
ios -解决view遮挡按钮问题
【PAT天梯赛】L2-003 月饼 （25 分)（贪心思想）
hive 存储格式的生产应用
【Python实践-6】将不规范的英文名字，变为首字母大写，其他小写的规范名字
容器学习点点滴滴（二）
每日归档
更多
2024-10-03(2)
2024-10-02(60)
2024-10-01(0)
2024-09-30(0)
2024-09-29(0)
2024-09-28(4)
2024-09-27(60)
2024-09-26(0)
2024-09-25(0)
2024-09-24(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022