Spring的代理模式

桃扇骨 2023-10-05 23:59 105阅读 0赞

## 1、代理模式 ##

为什么要学习代理模式？

因为这就是springAOP的底层！【springAOP和springMVC】

代理模式的分类：

*  静态代理
 *  动态代理

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

角色分析：

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

代码步骤：

*  1.接口 ——Rent
    
        //出租房子
        public interface Rent {
              
            void rent();
        }
 *  2.真实角色——Host
    
        //房东
        public class Host implements Rent {
              
            @Override
            public void rent() {
              
                //打印
                System.out.println("房东有房子出租！");
            }
        }
 *  3.代理角色——Proxy
    
        //中介
        public class Proxy implements Rent {
              
            private Host host;
        
            public Proxy() {
              
            }
        
            public Proxy(Host host) {
              
                this.host = host;
            }
        
            @Override
            public void rent() {
              
                host.rent();
                seeHouse();
                hetong();
                fare();
            }
        
            public void seeHouse() {
              
                //打印
                System.out.println("See House 看房子");
            }
        
            public void hetong(){
              
                //打印
                System.out.println("签约租凭合同");
            }
            public void fare(){
              
                //打印
                System.out.println("收取中介费用!");
            }
        }
 *  4.客户端访问代理角色——Client
    
        public class Client {
              
            //这是一个main方法，是程序的入口：
            public static void main(String[] args) {
              
                //房东出租房子给中介代理
                Host host = new Host();
                //代理。帮助房东出租房子，会有一些附属的操作
                Proxy proxy = new Proxy(host);
                //
                proxy.rent();
            }
        }

#### 小结 ####

代理模式的好处：

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

缺点：

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

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

UserService

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

UserServiceImpl——真实对象

//真实对象
    public class UserServiceImpl implements UserService{
        
        @Override
        public void add() {
        
            System.out.println("增加了一个用户");
        }
    
        @Override
        public void delete() {
        
            System.out.println("删除了一个用户");
        }
    
        @Override
        public void update() {
        
            System.out.println("修改了一个用户");
        }
    
        @Override
        public void query() {
        
            System.out.println("查询了一个用户");
        }
    }

UserServiceProxy——代理

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

加粗样式Client

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

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

动态代理和静态代理角色一样

动态代理的代理类是动态生成的，不是我们直接写好的！

动态代理分为两大类：基于接口的动态代理，基于类的动态代理

*  基于接口-JDK 动态代理【我们在这里使用】
 *  基于：cglib
 *  java字节码实现：javasist

需要了解两个类：

*  Proxy：代理，
 *  InvocationHandler：调用处理程序，是由代理实例的调用处理程序实现的接口。

![在这里插入图片描述][1b7a3fb912564d8ca64f33b44273c0bb.png]

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)                    
        //返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。  
    
    /**
    所需三个参数参数 
    loader - 类加载器来定义代理类 ，需要一个
    interfaces - 代理类实现的接口列表 
    h - 调度方法调用的调用处理函数 
    
    newProxyInstance，方法有三个参数：
    loader: 用哪个类加载器去加载代理对象
    interfaces/：动态代理类需要实现的接口
    h：动态代理方法在执行时，会调用h里面的invoke方法去执行
    */
        
    /**
    * ClassLoader loader 类加载器，用于加载代理对象的字节码
    * Class<?>[] interfaces 字节码数组，用于让代理对象和被代理对象有相同的方法
    * InvocationHandler h 处理方法，用于方法增强
    */
    
    Object invoke(Object proxy, 方法 method, Object[] args) //处理代理实例上的方法调用并返回结果。  
        
    /**
    * Object proxy 被代理的类
    * Method method 被代理类的方法
    * Object[] args 方法参数
    */

ProxyInvocationHandler

//自动生成代理类！
    public class ProxyInvocationHandler implements InvocationHandler {
        
    
        //被代理的接口
        private Rent rent;
    
        public void setRent(Rent rent) {
        
            this.rent = rent;
        }
    
        //生成代理类
        public Object getProxy() {
        
    
            //第一个参数：目标对象类的加载器，第二个参数：目标对象相同的接口字节码对象数组，第三个参数：InvocationHandler对象
            return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(), this);
        }
    
        //调用代理对象的任何方法，实质执行的都是invoke方法
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
            seeHouse();
            //动态代理的本质，就是使用反射机制实现的
            Object invoke = method.invoke(rent, args);//目标方法
            hetong();
            fare();
            return invoke;
        }
    
        public void seeHouse() {
        
            //打印
            System.out.println("See House 看房子");
        }
    
        public void hetong() {
        
            //打印
            System.out.println("签约租凭合同");
        }
    
        public void fare() {
        
            //打印
            System.out.println("收取中介费用!");
        }
    
    }

Client

public class Client {
        
        //这是一个main方法，是程序的入口：
        public static void main(String[] args) {
        
            //真实角色
            Host host = new Host();
            //代理角色。
            ProxyInvocationHandler pih = new ProxyInvocationHandler();
            //通过调用处理角色来处理我们调用的接口对象
            pih.setRent(host);
            Rent proxy =(Rent) pih.getProxy();
            proxy.rent();
        }
    }

#### 真正动态 ####

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);
        }
    
        //处理代理实例，返回结果
        @Override
        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+"方法");
    
        }
    
    }

import com.blue.demo02.UserService;
    import com.blue.demo02.UserServiceImpl;
    
    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.delete();
    
        }
    }

#### 动态代理的好处： ####

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

https://cloud.tencent.com/developer/support-plan?invite\_code=tf892a33j43m

[1b7a3fb912564d8ca64f33b44273c0bb.png]: https://img-blog.csdnimg.cn/1b7a3fb912564d8ca64f33b44273c0bb.png