Spring（八）代理模式-SpringAOP的底层

冷不防 2023-05-21 08:48 12阅读 0赞

## 1、代理模式 ##

为什么我们要学习代理模式？因为这就是SpringAOP的底层！

代理模式的分类：

*  静态代理
 *  动态代理

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTA3MjEzMg_size_16_color_FFFFFF_t_70]

### 1.1、静态代理 ###

角色分析：

*  抽象角色：一般会使用接口或者抽象类来解决
 *  真实角色：被代理的角色
 *  代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
 *  客户：访问代理对象的人！

代码步骤：

1.  接口
    
        //租房
        public interface Rent { 
        
            public void rent();
        }
2.  真实角色
    
        //房东
        public class Host implements Rent { 
            public void rent() { 
                System.out.println("房东要出租房子！");
            }
        }
3.  代理角色
    
        //代理
        public class Proxy implements Rent{ 
        
            private Host host;
        
            public Proxy() { 
            }
        
            public Proxy(Host host) { 
                this.host = host;
            }
        
            public void rent() { 
                host.rent();
                seeHouse();
                contract();
                fare();
            }
        
            //看房
            public void seeHouse(){ 
                System.out.println("中介带你看房");
            }
        
            //签合同
            public void contract(){ 
                System.out.println("签租赁合同");
            }
        
            //收中介费
            public void fare(){ 
                System.out.println("收中介费");
            }
        }
4.  客户端访问代理角色
    
        //客户
        public class Client { 
            public static void main(String[] args) { 
                //房东要出租房子
                Host host = new Host();
                //代理，中介帮房东租房子，但是呢？代理角色一般会有一些附属操作！
                Proxy proxy = new Proxy(host);
                //你不用面对房东，直接找中介租房即可！
                proxy.rent();
            }
        }

代理模式的好处：

*  可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
 *  公共的业务就交给代理角色！实现了业务的分工！
 *  公共业务发生扩展的时候，方便集中管理！

缺点：

*  一个真实角色就会产生一个代理角色；代码量会翻倍，开发效率会变低~

### 1.2、加深理解 ###

服务接口：

public interface UserService { 
    
        public void add();
        public void delete();
        public void update();
        public void query();
    }

服务实现类：

//真实对象
    public class UserServiceImpl implements UserService{ 
    
        public void add() { 
            System.out.println("增加了一个用户");
        }
    
        public void delete() { 
            System.out.println("删除了一个用户");
        }
    
        public void update() { 
            System.out.println("更新了一个用户");
        }
    
        public void query() { 
            System.out.println("查询了一个用户");
        }
    
        //1、改动原有的业务代码，在公司中是大忌！
    }

服务代理类：

public class UserServiceProxy implements UserService { 
    
        private UserServiceImpl userService;
    
    
        public void setUserService(UserServiceImpl userService) { 
            this.userService = userService;
        }
    
        public void add() { 
            log("add");
            userService.add();
        }
    
        public void delete() { 
            log("delete");
            userService.delete();
        }
    
        public void update() { 
            log("update");
            userService.update();
        }
    
        public void query() { 
            log("query");
            userService.query();
        }
    
        //日志方法
        public void log(String msg){ 
            System.out.println("【debug】使用了" + msg + "方法");
        }

客户需求类：

public class Client { 
        public static void main(String[] args) { 
            UserServiceImpl userService = new UserServiceImpl();
    
            UserServiceProxy proxy = new UserServiceProxy();
            proxy.setUserService(userService);
            proxy.add();
            proxy.delete();
        }
    }

聊聊AOP：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTA3MjEzMg_size_16_color_FFFFFF_t_70 1]

### 1.3、动态代理 ###

*  动态代理和静态代理角色一样
 *  动态代理的代理类是动态生成的，不是我们直接写好的！
 *  动态代理分为两大类：基于接口的动态代理，基于类的动态代理
    
     *  基于接口：JDK动态代理【我们在这里使用】
     *  基于类：cglib
     *  Java字节码实现：Javasist

需要了解两个类：Proxy：代理，InvocationHandler：调用处理程序

动态代理的好处：

*  可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
 *  公共业务就交给代理角色！实现业务的分工！
 *  公共业务发生扩展的时候，方便集中管理！
 *  一个动态代理类代理的是一个接口，一般就是对应的一类业务

动态代理类：

//等会我们会用这个类，自动生成代理类！
    public class ProxyInvocationHandler implements InvocationHandler { 
    
        //被代理的接口
        private Object target;
    
        public void setTarget(Object target) { 
            this.target = target;
        }
    
        //生成得到代理类
        public Object getProxy(){ 
            return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
        }
    
        //处理代理实例，并返回结果
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
            //动态代理的本质，就是使用反射机制实现！
            log(method.getName()); //通过反射获取到方法的名字
            Object result = method.invoke(target, args);
            return result;
        }
    
        //添加其他业务--日志业务
        public void log(String msg){ 
            System.out.println("执行了" + msg + "方法");
        }
    }

客户需求类：

public class Client { 
        public static void main(String[] args) { 
            //真实角色
            UserServiceImpl userService = new UserServiceImpl();
            //代理角色，不存在
            ProxyInvocationHandler pih = new ProxyInvocationHandler();
            //设置要代理的对象
            pih.setTarget(userService);
            //动态生成代理类
            UserService proxy = (UserService) pih.getProxy();
    
            proxy.add();
            proxy.delete();
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTA3MjEzMg_size_16_color_FFFFFF_t_70]: /images/20230521/6d85d4aaa75f461da5d15ceafb14a4a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTA3MjEzMg_size_16_color_FFFFFF_t_70 1]: /images/20230521/adadd636f6a342228c6eb8dfcae27632.png