动态代理 过渡 AOP

已于 2024-04-02 18:25:47 修改
阅读量319 收藏 10
点赞数 3
分类专栏： Java技术总结 文章标签： java servlet AOP 动态代理 设计模式 代理模式
于 2024-04-02 17:23:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heng000000/article/details/137273162
版权

提问：你可以按照网上教程写一个动态代理的案例；也可以写一个AOP的案例。也常听到AOP的底层就是动态代理，是否能解释的清楚它两之间的关系呢？

目录

一 无代理

public interface UserService {
    void save(String name);
    void delete(String id);
    void update();
    String findAll(String name);
    String findOne(String id);
}

// 原始业务逻辑对象
public class UserServiceImpl implements UserService{
    // 开启事务   处理业务   调用dao
    @Override
    public void save(String name) {
        try {
            System.out.println("开启事务");
            System.out.println("处理事务逻辑,调用DAO~~~");
            System.out.println("提交事务");
        } catch (Exception e) {
            System.out.println("回滚事务");
            e.printStackTrace();
        }
    }

    @Override
    public void delete(String id) {
        try {
            System.out.println("开启事务");
            System.out.println("处理事务逻辑,调用DAO~~~");
            System.out.println("提交事务");
        } catch (Exception e) {
            System.out.println("回滚事务");
            e.printStackTrace();
        }
    }

    @Override
    public void update() {
        try {
            System.out.println("开启事务");
            System.out.println("处理事务逻辑,调用DAO~~~");
            System.out.println("提交事务");
        } catch (Exception e) {
            System.out.println("回滚事务");
            e.printStackTrace();
        }
    }

    @Override
    public String findAll(String name) {
        try {
            System.out.println("开启事务");
            System.out.println("处理事务逻辑,调用DAO~~~");
            System.out.println("提交事务");
        } catch (Exception e) {
            System.out.println("回滚事务");
            e.printStackTrace();
        }
        return name;
    }

    @Override
    public String findOne(String id) {
        try {
            System.out.println("开启事务");
            System.out.println("处理事务逻辑,调用DAO~~~");
            System.out.println("提交事务");
        } catch (Exception e) {
            System.out.println("回滚事务");
            e.printStackTrace();
        }
        return id;
    }
}

    public static void main(String[] args) {
        UserService  userService = new UserServiceImpl();
        userService.save("1");
     }

在这里插入图片描述
可以发现UserServiceImpl 中存在重复代码 和业务代码

重复代码
System.out.println("开启事务");
System.out.println("提交事务");
System.out.println("回滚事务");

业务代码
System.out.println("处理事务逻辑,调用DAO~~~");

我们希望将重复的非业务代码拆分出来，UserServiceImpl 专心写业务代码，创建一个代理类就负责重复的非业务代码
更新后的代码

二、静态代理改造

public interface UserService {
    void save(String name);
    void delete(String id);
    void update();
    String findAll(String name);
    String findOne(String id);
}

// 原始业务逻辑对象
public class UserServiceImpl implements UserService{
    // 开启事务   处理业务   调用dao
    @Override
    public void save(String name) {
        System.out.println("处理事务逻辑,调用DAO~~~");
    }

    @Override
    public void delete(String id) {
      System.out.println("处理事务逻辑,调用DAO~~~");
    }

    @Override
    public void update() {
       System.out.println("处理事务逻辑,调用DAO~~~");
    }

    @Override
    public String findAll(String name) {
        System.out.println("处理事务逻辑,调用DAO~~~");
        return name;
    }

    @Override
    public String findOne(String id) {
        System.out.println("处理事务逻辑,调用DAO~~~");
        return id;
    }
}

//静态代理类
//开发原则:代理类和目标类实现相同接口,依赖于真正的目标类
public class UserServiceStaticProxy implements UserService{

    // 依赖原始业务逻辑对象 // Target：目标对象|被代理对象称之为目标对象 原始业务逻辑对象
    private UserService userService;

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    @Override
    public void save(String name) {
        try {
            System.out.println("静态代理：开启事务");
            // 调用原始业务逻辑对象的方法
            userService.save(name);
            System.out.println("静态代理：提交事务");
        } catch (Exception e) {
            System.out.println("静态代理：回滚事务");
            e.printStackTrace();
        }
    }

    @Override
    public void delete(String id) {
        try {
            System.out.println("静态代理：开启事务");
            // 调用原始业务逻辑对象的方法
            userService.delete(id);
            System.out.println("静态代理：提交事务");
        } catch (Exception e) {
            System.out.println("静态代理：回滚事务");
            e.printStackTrace();
        }
    }

    @Override
    public void update() {
        try {
            System.out.println("静态代理：开启事务");
            // 调用原始业务逻辑对象的方法
            userService.update();
            System.out.println("静态代理：提交事务");
        } catch (Exception e) {
            System.out.println("静态代理：回滚事务");
            e.printStackTrace();
        }
    }

    @Override
    public String findAll(String name) {
        try {
            System.out.println("静态代理：开启事务");
            // 调用原始业务逻辑对象的方法
            String all = userService.findAll(name);
            System.out.println("静态代理：提交事务");
            return all;
        } catch (Exception e) {
            System.out.println("静态代理：回滚事务");
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public String findOne(String id) {
        try {
            System.out.println("静态代理：开启事务");
            // 调用原始业务逻辑对象的方法
            String one = userService.findOne(id);
            System.out.println("静态代理：提交事务");
            return one;
        } catch (Exception e) {
            System.out.println("静态代理：回滚事务");
            e.printStackTrace();
        }
        return null;
    }
}


    public static void main(String[] args) {
		UserService  userService = new UserServiceImpl();
        UserServiceStaticProxy proxy = new UserServiceStaticProxy();
        proxy.setUserService(userService);
        proxy.save("2");
     }

在这里插入图片描述

可以发现，UserServiceImpl中只写了业务代码，其他的写在了静态代理中。

静态代理是无法满足实际场景的，需要使用动态代理才行，具体原因参考此文

三 动态代理改造

public interface UserService {
    void save(String name);
    void delete(String id);
    void update();
    String findAll(String name);
    String findOne(String id);
}

// 原始业务逻辑对象
public class UserServiceImpl implements UserService{
    // 开启事务   处理业务   调用dao
    @Override
    public void save(String name) {
        System.out.println("处理事务逻辑,调用DAO~~~");
    }

    @Override
    public void delete(String id) {
      System.out.println("处理事务逻辑,调用DAO~~~");
    }

    @Override
    public void update() {
       System.out.println("处理事务逻辑,调用DAO~~~");
    }

    @Override
    public String findAll(String name) {
        System.out.println("处理事务逻辑,调用DAO~~~");
        return name;
    }

    @Override
    public String findOne(String id) {
        System.out.println("处理事务逻辑,调用DAO~~~");
        return id;
    }
}

public class UserServiceStaticSynamicProxy implements InvocationHandler {
    private Object target;

    public void setUserService(Object target) {
        this.target = target;
    }

    public Object getProxy(){
        Object o = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
        return o;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("代理：开启事务");
        Object result = method.invoke(target, args);
        System.out.println("代理：提交事务");
        return result;
    }
}


    public static void main(String[] args) {
        UserService  userService = new UserServiceImpl();
        UserServiceStaticSynamicProxy proxy = new UserServiceStaticSynamicProxy();
        proxy.setUserService(userService);
        UserService proxy2 = (UserService)proxy.getProxy();
        proxy2.findAll("3");
    }

在这里插入图片描述

四 spring AOP的实现

这里提供一个伪代码：
我们自己写一个@Before，@After注解，被该注解标记的方法中就写非业务代码。
如被@Before标记的方法，实现”spring aop 动态代理：开启事务“
被@After标记的方法，实现”spring aop 动态代理：提交事务“

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

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class Test {
    public static void main(String[] args) {
        ApplicationContext.registerBean(Config.class);
        Config o = (Config)ApplicationContext.map.get(Config.class.getName());
        o.pointCut();
    }


}

class Config {

	// 自定义注解Before
    @Before
    public void before() {
        System.out.println("before");
        System.out.println("spring aop 动态代理：开启事务");
    }

	// 自定义注解After
    @After
    public void before() {
        System.out.println("after");
        System.out.println("spring aop 动态代理：提交事务");
    }

	// 被代理的方法
    public void pointCut() {
        System.out.println("pointCut");
         System.out.println("处理事务逻辑,调用DAO~~~");
    }



}

class ApplicationContext {

    public static Map<String, Object> map = new HashMap<>();

	// 参数传递Class字节码：如Config.class
    public static void registerBean(Class clazz) {
        Method beforeMethod = null;
        Method afterMethod = null;
        // 获取Config类全部的public属性方法
        for (Method declaredMethod : clazz.getDeclaredMethods()) {
        
        	// 找到具有@Before注解的方法
            Before annotation = declaredMethod.getAnnotation(Before.class);
            if (annotation != null) {
                beforeMethod = declaredMethod;
            }
			// 找到具有@After注解的方法
			After annotation = declaredMethod.getAnnotation(After.class);
            if (annotation != null) {
                afterMethod = declaredMethod;
            }
        }

        Set<String> proxyMethName = new HashSet<>();
        for (Method declaredMethod : clazz.getDeclaredMethods()) {
            Before annotation = declaredMethod.getAnnotation(Before.class);
            if (annotation != null) {
                continue;
            }
			After annotation = declaredMethod.getAnnotation(After.class);
            if (annotation != null) {
                continue;
            }
            proxyMethName.add(declaredMethod.getName());
        }

// 这里使用cjlib的方式实现动态代理（没有接口的动态代理实现），之前实例的是jdk的动态代理实现（基于接口实现）
        Enhancer enhancer = new Enhancer();
        // 设置enhancer对象的父类
        enhancer.setSuperclass(clazz);
        // 设置enhancer的回调对象
        Method finalBeforeMethod = beforeMethod;
        Method finalAfterMethod = afterMethod;
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                if (proxyMethName.contains(method.getName()) && finalBeforeMethod != null) {
                	// 这一行打印：spring aop 动态代理：开启事务
                    finalBeforeMethod.invoke(o, objects);
                }
                // 调用被代理的方法（这一行打印：处理事务逻辑,调用DAO~~~）
                Object invoke = methodProxy.invokeSuper(o, objects);
                
				if (proxyMethName.contains(method.getName()) && finalAfterMethod != null) {
					// 这一行打印：spring aop 动态代理：提交事务
                    finalAfterMethod .invoke(o, objects);
                }
                return invoke;
            }
        });
        // 创建代理对象
        Object o = enhancer.create();
        map.put(clazz.getName(), o);
    }
}

最原始的方式，我们是手写了一个最标准的动态代理模式。现在我们改造了一下，模仿spring实现动态代理。表面看是只是用了@Before
注解，还有什么切面概念，其实还是代理的逻辑。

这个时候你再看spring aop的实现过程，是不是特别清晰

spring利用注解实现aop

spring利用xml实现aop

总结

目的：将非业务代码抽离出来，我们自定义了动态代理解决；也利用了spring提供的方案解决了。而在 ”利用xml实现aop“ 中提供的示例中，作者表面未使用动态代理的写法，最内层确实是动态代理
在这里插入图片描述

回顾一下前面的问题：为什么说aop的底层就是动态代理。我是这样理解的：
在没有spring之前，我们可以使用自定义的动态代理方式将业务代码前后的非业务代码抽离出来（例如前面将非业务代码抽离到代理类中）。后来spring一琢磨，把这种行为定义为切面编程的思想，取了个英文名AOP。并把将我们之前首先动态代理过程改造了一下，套了一壳，包装了一下，换成了更简单的写法。
所以，当你想将业务代码前后的非业务代码抽离出来时，你可以考虑自己手写一个动态代理，也可以使用spring提供的写法。根据实际需求出发。

Wyatt_zhai
关注
专栏目录
Spring高级源码学习笔记.zip
05-24
AOP代理有两种实现方式：JDK动态代理和CGLIB。前者针对实现了接口的类，后者则在没有接口的情况下通过子类化目标类实现。源码中，Advised接口和ProxyFactoryBean扮演着关键角色。 在数据访问/集成方面，Spring提供...
srping4.1.6核心包_spring4.1.6_
09-29
9. **AOP代理**：Spring支持JDK动态代理和CGLIB代理，允许创建代理对象以实现AOP切面。 10. **测试支持**：Spring提供了一系列测试工具，包括`@RunWith(SpringJUnit4ClassRunner.class)`注解支持Spring Test，`@...
study-collection:Java高级实践
03-06
动态代理则可用于实现AOP（面向切面编程），提供拦截和增强功能。 4. **JVM深入理解**：理解JVM的工作原理，包括类加载机制、类加载器、字节码执行、内存区域等，可以帮助我们进行更高效的代码编写和问题排查。 5....
spring----4.rar
06-06
Spring 4.x 在 AOP（面向切面编程）方面也有所改进，如支持 JDK 代理和 CGLIB 代理的混合使用，以及对动态代理的优化。 9. **国际化和本地化** Spring 4.x 对 `MessageSource` API 进行了改进，支持多级父消息源...
jar包
03-21
在Java Web开发中，代理技术可能用于实现AOP（面向切面编程），如Spring AOP，它能够方便地插入横切关注点，而无需修改业务代码。 综合以上信息，可以推测这篇博客文章可能深入探讨了Struts2框架的内部机制，包括与...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1252
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 939
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
FoolRabbit的专栏
10-06 366
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 707
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Java中的break、continue和return语句
weixin_73230994的博客
10-05 380
break语句用于终止某个语句块的执行，一般使用在switch或者循环【for, while ,do-while】（提前退出或结束循环不是终止程序）1.continue语句用于结束本次循环，继续执行下一次循环2.continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用规则一样。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 379
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
11.2 Linux_线程_同步与互斥
Fresh_man111的博客
10-03 196
同一时刻只允许一个任务访问的共享资源。比如写入文件，就是一个临界资源，当写入文件时，不允许两个任务同时往里面写。如果A写入abc，B写入def，同时写的情况下文件中的值不一定为abcdef，这时就需要在某一时刻只允许A写入abc，在另一时刻只允许B写入def。
JAVA开源项目 旅游管理系统 计算机毕业设计
as230627的博客
10-03 1409
旅游管理系统基于Springboot框架、JAVA编程语言、MYSQL数据库开发完成，“操作简单，功能实用”这是本软件设计的核心理念，本系统力求创造最好的用户体验。
租拼车平台|小区租拼车管理|基于java的小区租拼车管理信息系统小程序设计与实现(源码+数据库+文档)
伟庭的博客
10-06 905
在设计小区租拼车管理信息平台时，功能模块充分融合了用户与管理员的实际需求，实现了多元化且全面的小区租拼车管理信息功能。介绍了微信小程序小区租拼车管理信息系统的系统分析部分，包括可行性分析等，系统设计部分主要介绍了系统功能设计和数据库设计。本微信小程序小区租拼车管理信息系统功能有个人中心，用户管理，汽车信息管理，汽车入库管理，汽车出库管理，汽车租赁管理，汽车归还管理，汽车拼车管理，拼车信息管理，留言板管理，系统管理等。因而具有一定的实用性。
31 类和对象 · 上
最新发布
m0_66277256的博客
10-09 452
类与对象的学习总结
Python并发编程(1)——Python并发编程的几种实现方式
一点
10-03 1071
Python 并发编程是指在 Python 中编写能够同时执行多个任务的程序。并发编程在任何一门语言当中都是比较难的，因为会涉及各种各样的问题，在Python当中也不例外。Python 提供了多种方式来实现并发，包括多线程（threading）、多进程（multiprocessing）、异步编程（asyncio），以及一些高级用法concurrent.futures和第三方库如gevent。
【含开题报告+文档+PPT+源码】基于SSM框架的线上交易商城的设计与实现
码蜂窝编程-全网唯一毕设在线答疑，项目包运行成功，全套教学视频一站式辅导机构。
10-07 360
本课程演示的是一款校园二手交易系统，主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的 Java 学习者。包含：项目源码、项目文档、数据库脚本、软件工具等所有资料带你从零开始部署运行本套系统该项目附带的源码资料可作为毕设使用系统主要功能有：登录注册、公告管理、用户管理、商品管理、商品搜索、购物车、订单管理、用户私聊等模块。
【hot100-java】【两数相加】
m0_73629042的博客
10-04 163
【代码】【hot100-java】【两数相加】
古典舞在线交流：SpringBoot平台实现与优化
2401_85341950的博客
10-04 703
在这段时期里，我查找了很多相关的资料，查阅了很多Java的相关文献，结合自己的经验，设计了这个古典舞在线交流平台，虽然每个学期学校都会针对动手练习进行相应的课程设计，但是在古典舞在线交流平台的具体设计中还是遇到了一些小问题，但在不断的学习、研究中都将问题一一解决，在一一克服的过程中，我也得到了成长，知识和经验也得到了丰富，这对我来说是一笔巨大的财富。这次设计也大大提高了我的动手的能力，让我在学习中充分体会到了探索的乐趣，享受成功的创作过程，在本次设计过程中汲取的东西，是一笔宝贵的财富，让我受益匪浅。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值