代理设计模式,框架AOP思想

简介: 代理设计模式,框架AOP思想

文章目录


引言🤪


代理对象(Proxy)


如何开发一个代理对象


开发中的业务层代码冗余问题


开发静态代理类


动态代理


引言🤪


代理 (proxy) ,举个生活中常见的现象,在之前网路还未走进大众的时代里,如果我们想买一些东西,只是直接去店里,现在网络普及了,互联网+shopping,使我们足不出户就可以办很多事,比如网上购物,注意啊,网上购物大多数都是有一个代收点,而不是直接送到你的手上,家里,为什么呢?,因为那样的代价会很大,影响效率,所以出现了代收点,我们再去代收点去拿到网购的货物,完成网购,那么,根据这个现象,如果放在编程中,我们就可以把这个代收点比做成是一个代理对象,在整个购物的过程中起到了一个代收的作用,同时他也介入了购物的一部分,OK


6964006ed9c247599d487a44773cfb1e.png


代理对象(Proxy)


代理:指的是一种设计模式

作用:在整个业务中完成一些 业务之外的附加操作,同时也可以中断整个业务

好处:专注于业务开发,对于一些附加操作,交予代理完成一些繁琐的重复的操作,好耶!


如何开发一个代理对象


1.代理对象要和原始业务对象有用一个规定,放在面向对象中就是实现同一个接口(interface)

2.代理对象依赖业务对象


开发中的业务层代码冗余问题



ShopService接口


//商品业务的接口
public interface ShopService {
    //添加商品
    void add();
    //下架商品
    void remove();
    //……
}


ShopService接口实现类ShopServiceImpl


public class ShopServiceImpl implements ShopService {
    @Override
    public void add() {
        try {
            System.out.println("开启事务");
            System.out.println("处理添加商品业务逻辑,调用DAO~~~");
            System.out.println("提交事务");
        }catch (Exception e){
            System.out.println("回滚事务");
            e.printStackTrace();
        }
    }
    @Override
    public void remove() {
        try {
            System.out.println("开启事务");
            System.out.println("处理添下架商品业务逻辑,调用DAO~~~");
            System.out.println("提交事务");
        }catch (Exception e){
            System.out.println("回滚事务");
            e.printStackTrace();
        }
    }
}


测试一下


public class ShopTest {
    public static void main(String[] args) {
        ShopServiceImpl shopService = new ShopServiceImpl();
        shopService.add();
        shopService.remove();
    }
}


是没有任何问题的,但是你会发现service控制事务的代码大量冗余,一点也不优雅,在做重复的事情,如果是你,你会怎么优化呢?问题给到你,🤪


开启事务
处理添加商品业务逻辑,调用DAO~~~
提交事务
开启事务
处理添下架商品业务逻辑,调用DAO~~~
提交事务


开发静态代理类


ShopServiceStaticProxy


/*静态代理类和业务类实现同一个接口*/
public class ShopServiceStaticProxy implements ShopService {
    /*静态代理类依赖业务类*/
    private ShopService shopService;
    public void setShopService(ShopService shopService) {
        this.shopService = shopService;
    }
    @Override
    public void add() {
        try {
            System.out.println("开启事务");
            shopService.add();
            System.out.println("提交事务");
        }catch (Exception e){
            System.out.println("回滚事务");
            e.printStackTrace();
        }
    }
    @Override
    public void remove() {
        try {
            System.out.println("开启事务");
            shopService.remove();
            System.out.println("提交事务");
        }catch (Exception e){
            System.out.println("回滚事务");
            e.printStackTrace();
        }
    }
}


ShopServiceImpl优化后的专注于业务


public class ShopServiceImpl implements ShopService {
    @Override
    public void add() {
        System.out.println("处理添加商品业务逻辑,调用DAO~~~");
    }
    @Override
    public void remove() {
        System.out.println("处理添下架商品业务逻辑,调用DAO~~~");
    }
}


能否可行,测试,必须行


public class ShopTest {
    public static void main(String[] args) {
        ShopServiceImpl shopService = new ShopServiceImpl();
        ShopServiceStaticProxy shopServiceStaticProxy = new ShopServiceStaticProxy();
        shopServiceStaticProxy.setShopService(shopService);
        shopServiceStaticProxy.add();
        shopServiceStaticProxy.remove();
    }
}
开启事务
处理添加商品业务逻辑,调用DAO~~~
提交事务
开启事务
处理添下架商品业务逻辑,调用DAO~~~
提交事务


perfect,现在看起来优雅很多了


往往在开发我们书写的不仅仅是一个业务层,两个业务层,而我们的业务层会有很多,如果为每一个业务层开发一个静态代理类,不仅没有减轻工作量,甚至让我们的工作量多了一倍不止怎么解决以上这个问题呢?


解决方案:

为业务层在运行过程中动态创建代理类,通过动态代理类去解决我们现有业务层中业务代码冗余的问题


动态代理


有了静态代理的基础之后,来看看更好玩的动态代理,它是spring框架AOP的实现原理,以及很多框架的核心思想及落地实现

GO


通过jdk提供的 Proxy 类,动态为现有的业务生成代理类


参数一:当前线程类加载器 classLoader

参数二:生成代理类的接口类型

参数三:通过代理类对象调用方法时会优先进入参数三中的invoke方Proxy.newProxyInstance(loader, interfaces, h);//返回值就是动态代理对象


AOP的原理就是对动态代理的封装


还有 MyBatis 框架中的 getMapper(xxx.class),就是使用了动态代理对象


public class TestDynamicProxy {
    public static void main(String[] args) {
        //参数1: classLoader 类加载器
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        //参数2: Class[] 动态代理对象的接口类型的数组
        Class[] classes = {ShopService.class};
        //参数3: InvocationHandler接口类型 invoke 方法 写附加操作
        ShopService userServiceDyProxy = (ShopService) Proxy.newProxyInstance(classLoader, classes, new InvocationHandler() {
            @Override
            //通过动态代理对象调用自己里面代理方法时会优先指定InvocationHandler类中invoke
            // invoke方法参数
            //1. 当前创建好的代理对象
            //2. 当前代理对象执行的方法对象
            //3. 当前代理对象执行方法的参数
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("当前执行的方法:" + method.getName());
                try {
                    System.out.println("开启事务");
                    //调用目标类中的业务方法
                    Object invoke = method.invoke(new ShopServiceImpl(), args);
                    System.out.println("提交事务");
                    return invoke;
                }catch (Exception e){
                    System.out.println("回滚事务");
                    e.printStackTrace();
                }
                return null;
            }
        });
        System.out.println(userServiceDyProxy.getClass());
        userServiceDyProxy.remove();
        userServiceDyProxy.add();
    }
}


class com.sun.proxy.$Proxy0
当前执行的方法:remove
开启事务
处理添下架商品业务逻辑,调用DAO~~~
提交事务
当前执行的方法:add
开启事务
处理添加商品业务逻辑,调用DAO~~~
提交事务



相关文章
|
2天前
|
设计模式 XML Java
【23种设计模式·全精解析 | 自定义Spring框架篇】Spring核心源码分析+自定义Spring的IOC功能,依赖注入功能
本文详细介绍了Spring框架的核心功能,并通过手写自定义Spring框架的方式,深入理解了Spring的IOC(控制反转)和DI(依赖注入)功能,并且学会实际运用设计模式到真实开发中。
【23种设计模式·全精解析 | 自定义Spring框架篇】Spring核心源码分析+自定义Spring的IOC功能,依赖注入功能
|
2月前
|
存储 缓存 Java
Spring高手之路23——AOP触发机制与代理逻辑的执行
本篇文章深入解析了Spring AOP代理的触发机制和执行流程,从源码角度详细讲解了Bean如何被AOP代理,包括代理对象的创建、配置与执行逻辑,帮助读者全面掌握Spring AOP的核心技术。
53 3
Spring高手之路23——AOP触发机制与代理逻辑的执行
|
2月前
|
设计模式 网络协议 Java
05.静态代理设计模式
《静态代理设计模式》详细介绍了静态代理的基本概念、原理与实现、应用场景及优缺点。主要内容包括静态代理的由来、定义、使用场景、实现方式、结构图与时序图,以及其在降低耦合、保护对象权限等方面的优势。同时,文章也指出了静态代理的局限性,如缺乏灵活性、难以复用、难以动态添加功能等,并介绍了动态代理如何弥补这些不足。最后,通过多个实际案例和代码示例,帮助读者更好地理解和应用静态代理模式。
47 4
|
3月前
|
设计模式 Java 测试技术
spring复习04,静态代理动态代理,AOP
这篇文章讲解了Java代理模式的相关知识,包括静态代理和动态代理(JDK动态代理和CGLIB),以及AOP(面向切面编程)的概念和在Spring框架中的应用。文章还提供了详细的示例代码,演示了如何使用Spring AOP进行方法增强和代理对象的创建。
spring复习04,静态代理动态代理,AOP
|
3月前
|
设计模式 Java Spring
spring源码设计模式分析-代理设计模式(二)
spring源码设计模式分析-代理设计模式(二)
|
3月前
|
设计模式 SQL 安全
PHP中的设计模式:单例模式的深入探索与实践在PHP的编程实践中,设计模式是解决常见软件设计问题的最佳实践。单例模式作为设计模式中的一种,确保一个类只有一个实例,并提供全局访问点,广泛应用于配置管理、日志记录和测试框架等场景。本文将深入探讨单例模式的原理、实现方式及其在PHP中的应用,帮助开发者更好地理解和运用这一设计模式。
在PHP开发中,单例模式通过确保类仅有一个实例并提供一个全局访问点,有效管理和访问共享资源。本文详细介绍了单例模式的概念、PHP实现方式及应用场景,并通过具体代码示例展示如何在PHP中实现单例模式以及如何在实际项目中正确使用它来优化代码结构和性能。
56 2
|
4月前
|
设计模式 开发框架 API
我们在SqlSugar开发框架中,用到的一些设计模式
我们在SqlSugar开发框架中,用到的一些设计模式
|
5月前
|
缓存 安全 Java
Spring高手之路21——深入剖析Spring AOP代理对象的创建
本文详细介绍了Spring AOP代理对象的创建过程,分为三个核心步骤:判断是否增强、匹配增强器和创建代理对象。通过源码分析和时序图展示,深入剖析了Spring AOP的工作原理,帮助读者全面理解Spring AOP代理对象的生成机制及其实现细节。
57 0
Spring高手之路21——深入剖析Spring AOP代理对象的创建
|
4月前
|
缓存 安全 Java
Spring AOP 中两种代理类型的限制
【8月更文挑战第22天】
39 0
|
4月前
|
Java Spring