代理设计模式,框架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~~~
提交事务



相关文章
|
23天前
|
缓存 安全 Java
Spring高手之路21——深入剖析Spring AOP代理对象的创建
本文详细介绍了Spring AOP代理对象的创建过程,分为三个核心步骤:判断是否增强、匹配增强器和创建代理对象。通过源码分析和时序图展示,深入剖析了Spring AOP的工作原理,帮助读者全面理解Spring AOP代理对象的生成机制及其实现细节。
17 0
Spring高手之路21——深入剖析Spring AOP代理对象的创建
|
29天前
|
分布式计算 Java MaxCompute
详解 Java 限流接口实现问题之在Spring框架中使用AOP来实现基于注解的限流问题如何解决
详解 Java 限流接口实现问题之在Spring框架中使用AOP来实现基于注解的限流问题如何解决
|
2月前
|
存储 算法 Java
ASM字节码操纵框架实现AOP
ASM字节码操纵框架实现AOP
21 0
|
2月前
|
设计模式 SQL Java
Spring框架第四章(AOP概念及相关术语)
Spring框架第四章(AOP概念及相关术语)
|
3月前
|
安全 Java 开发者
在Spring框架中,IoC和AOP是如何实现的?
【4月更文挑战第30天】在Spring框架中,IoC和AOP是如何实现的?
49 0
|
3月前
|
设计模式 缓存 安全
设计模式-代理模式(静态代理、动态代理、cglib代理)、代理模式和装饰者模式的区别
设计模式-代理模式(静态代理、动态代理、cglib代理)、代理模式和装饰者模式的区别
|
3月前
|
设计模式 安全 Java
深入理解Spring Boot AOP:CGLIB代理与JDK动态代理的完全指南
深入理解Spring Boot AOP:CGLIB代理与JDK动态代理的完全指南
1095 1
|
3月前
|
XML 存储 Java
JAVAEE框架整合技术之Spring02-AOP面向切面编程技术
JAVAEE框架整合技术之Spring02-AOP面向切面编程技术
64 0
JAVAEE框架整合技术之Spring02-AOP面向切面编程技术
|
3月前
|
设计模式 Java Spring
Spring AOP基础之代理模式.静态代理和动态代理
Spring AOP基础之代理模式.静态代理和动态代理
44 0
Spring AOP基础之代理模式.静态代理和动态代理
|
3月前
|
设计模式 安全 Java
静态代理还是动态代理?来聊聊Java中的代理设计模式
代理模式(Proxy Design Pattern)是一种结构型设计模式,为一个对象提供一个代理对象,然后使用代理对象控制对原对象的引用。即通过代理对象访问目标对象。被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象。
39 0
静态代理还是动态代理?来聊聊Java中的代理设计模式