Spring AOP基础之代理模式.静态代理和动态代理

叁歲伎倆 2023-09-29 17:17 53阅读 0赞

代理模式

一、代理模式介绍  
代理模式是一种设计模式，提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。  
简言之，代理模式就是设置一个中间代理来控制访问原目标对象，以达到增强原对象的功能和简化访问方式。

一.静态代理  
上图角色分析：  
?抽象角色：一般会使用接口或者抽象类来解决  
?真实角色：被代理的角色实现抽象方法  
?代理角色：代理真实角色，代理真实角色,也实现抽象方法，一般会做一些附属操作。

代理模式的优点：  
?可以使真实角色的操作更加纯粹！不用关注一些公共的业务。  
?公共业务交给代理角色，实现了业务的分工  
?公共业务扩展的时候，方便集中管理。  
静态代理的缺点：  
?一个真实角色就会产生一个代理角色，代码量翻倍，开发效率变低。

参考代码如下：

//1.抽象角色
    public interface IRent {
        
        //租房接口的方法;
        public void rent();
    }
    /*2.房东：中式英语；*/
    public class HouseOwner implements IRent{
        
        public void rent() {
        
            System.out.println("房东直租房屋，一室一厅一卫，一个月300$");
        }
    }
    /*3.传说中中介，非链家莫属了*/
    public class Proxy implements IRent{
        
        //1.目标对象,代理房东的房子
        HouseOwner target;
        //2.构造方法
        public Proxy(HouseOwner target) {
        
            this.target = target;
        }
        //3.实现的代理方法
        public void rent() {
        
            before();
            target.rent();
            after();
        }
        //代理增强的附加功能;
        public void before(){
        
            System.out.println("收取看房费100元");
        }
        public void after(){
        
            System.out.println("合适进行收费");
        }
    }
    public class ClientTest {
        
        @Test
        public void test(){
        
            //3.1房东直租
            HouseOwner owner=new HouseOwner();
            //3.2 中介代理对象的创建，来了
            Proxy proxy=new Proxy(owner);
            //3.3 客户看房子;
            proxy.rent();
        }
    }

效果：  
![在这里插入图片描述][30d0ad1b77a446cc802c443f357166cc.png]

作业扩充：  
代理增加日志功能  
1.?创建一个抽象接口，对用户业务进行抽象：实现一个日志输出功能，以记录业务代码的调用情况。  
实现思路有两种，如下：  
?思路1：在业务实现类每个方法中增加相应操作（该思路是传统方法，缺点很多）。  
?思路2：使用代理，在不改变原有业务的情况下，实现此日志记录功能！

体现一个重要的思想：在不改变原有代码的情况下，实现对原有功能的增强。AOP的核心思想。  
**二.动态代理**  
动态代理和静态代理的角色是一样的，动态代理的代理类是动态生成的，不是像静态代理那样是直接写死的。动态代理可以分为两大类：一类是基于接口动态代理 , 一类是基于类的动态代理。

基于接口的动态代理，如JDK动态代理  
基于类的动态代理，如cglib  
JDK的动态代理需要了解两个类：

核心 : InvocationHandler （调用处理程序） 和 Proxy （代理）  
//proxy - 调用该方法的代理实例  
//method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。  
//args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。  
Object invoke(Object proxy, 方法 method, Object\[\] args)

.  
static Object newProxyInstance(ClassLoader loader, //指定当前目标对象使用类加载器  
Class<?>\[\] interfaces, //目标对象实现的接口的类型  
InvocationHandler h //事件处理器  
)

案例说明：  
订单模块进行操作，增加日志功能。  
JDK动态代理是代理工厂，不再需要实现多个接口了，注意这里面变化比较大。

package com.yh.jdk;
    //1.抽象接口
    public interface OrderService {
        
        void addOrder();
        void updateOrder();
        void selectOders();
    }
    package com.yh.jdk;
    /*2.目标对象*/
    public class OrderDaoImpl implements OrderService{
        
        public void addOrder() {
        
            System.out.println("增加订单业务");
        }
    
        public void updateOrder() {
        
            System.out.println("更新订单业务");
        }
    
        public void selectOders() {
        
            System.out.println("查询日志信息");
        }
    }
    package com.yh.jdk;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /*3.定义一个动态代理的，工厂，又来了。呵呵，好处大大滴
    * static Object newProxyInstance(ClassLoader loader, 类<?>[] interfaces, InvocationHandler h)
    返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。
    *           loader - 类加载器来定义代理类
                interfaces - 代理类实现的接口列表
                InvocationHandler h - 调度方法调用的调用处理函数
    * */
    public class JDKProxyFactory {
        
        //3.1要代理的目标对象;
        Object target;
        //3.2构造方法;
        public JDKProxyFactory(Object target) {
        
            this.target = target;
        }
        //3.3 注意这里是重要的，合并实现的方法.
        public Object getInstance(){
        
            return Proxy.newProxyInstance(
                    target.getClass().getClassLoader(),//获取目标对象的类加载器;
                    target.getClass().getInterfaces(),//获取目标对象的接口
                    new InvocationHandler() {
           //事件处理器，拦截方法，处理.
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
                            //注意看这里有个参数是method,还有印象吗？
                            System.out.println("******开始记录日志 **********");
                            Object invoke = method.invoke(target, args);
                            if(method.getName().equals("selectOders"))
                                System.out.println("******结束记录日志 **********");
                            return invoke;
                        }
                    }
            );
        }
    }
    ```package com.yh.jdk;
    
    import org.junit.Test;
    
    public class TestJdkClient {
        
        @Test
        public void test03(){
        
            OrderService target=new OrderDaoImpl();
            System.out.println(target.getClass());
            //注意动态代理的灵活性;获取实例方法.
            OrderService jdkProxyFactory = (OrderService) new JDKProxyFactory(target).getInstance();
            //代理类执行;
            jdkProxyFactory.addOrder();
        }
    }

[30d0ad1b77a446cc802c443f357166cc.png]: https://img-blog.csdnimg.cn/30d0ad1b77a446cc802c443f357166cc.png