Java Spring静态代理、动态代理

待我称王封你为后i 2022-12-04 05:28 200阅读 0赞

### 文章目录 ###

*  静态代理
 *  动态代理
 *   *  代理类：ProxyInvocation. java 即代理角色
     *  接口类： Rent.java 即抽象角色
     *  实现类： Host.java 即真实角色
     *  测试类： Client.java

# 静态代理 #

静态代理角色分析

*  抽象角色 : 一般使用接口或者抽象类来实现
 *  真实角色 : 被代理的角色
 *  代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作 .
 *  客户 : 使用代理角色来进行一些操作 .

1、创建一个抽象角色，抽象起来就是增删改查

//抽象角色：增删改查业务
    public interface UserService { 
       void add();
       void delete();
       void update();
       void query();
    }

2、我们需要一个真实对象来完成这些增删改查操作

//真实对象，完成增删改查操作的人
    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("查询了一个用户");
      }
    }

3、需求来了，现在我们需要增加一个日志功能，怎么实现？

*  思路1 ：在实现类上增加代码 【麻烦！】
 *  思路2：使用代理来做，能够不改变原来的业务情况下，实现此功能就是最好的了。

4、设置一个代理类来处理日志。代理角色。

//代理角色，在这里面增加日志的实现
    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("执行了"+msg+"方法");
      }
    
    }

5、测试访问类：

public class Client { 
       public static void main(String[] args) { 
           //真实业务
           UserServiceImpl userService = new UserServiceImpl();
           //代理类
           UserServiceProxy proxy = new UserServiceProxy();
           //使用代理类实现日志功能！
           proxy.setUserService(userService);
    
           proxy.add();
      }
    }

我们在不改变原来的代码的情况下，实现了对原有功能的增强，这是AOP中最核心的思想。

# 动态代理 #

*  动态代理的角色和静态代理的一样 .
 *  动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的
 *  动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理
 *  基于接口的动态代理----JDK动态代理
 *  基于类的动态代理–cglib
 *  现在用的比较多的是 javasist 来生成动态代理

动态代理类是动态生成的，不是我们直接写好的。基于反射。

动态代理：基于接口，基于类

*  基于接口：JDK的动态代理【使用】
 *  基于类：cglib
 *  java字节码

核心 : `InvocationHandler` 和 `Proxy`

*  InvocationHandler：调用处理程序。是代理实例和调用处理程序实现的接口
 *  Proxy提供了创建动态代理类和实例的静态方法。

## 代理类：ProxyInvocation. java 即代理角色 ##

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    //自动生成代理类
    public class ProxyInvocation implements InvocationHandler { 
    
        //被代理的接口
        private Rent rent;
    
        public void setRent(Rent rent) { 
            this.rent = rent;
        }
    
        //生成代理类
        public Object getProxy(){ 
            return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
        }
    
        //处理代理实例，并返回结果
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
            seeHouse();
            Object result = method.invoke(rent, args);
            fare();
            return result;
        }
    }

## 接口类： Rent.java 即抽象角色 ##

//出租房屋
    public interface Rent { 
        void rent();
    }

## 实现类： Host.java 即真实角色 ##

//房主
    public class Host implements Rent { 
        public void rent() { 
            System.out.println("host rent");
        }
    }

## 测试类： Client.java ##

//客户
    public class Client { 
        public static void main(String[] args) { 
            //真实角色
            Host host = new Host();
    
            //代理角色
            ProxyInvocation proxyInvocation = new ProxyInvocation();
    
            //通过调用程序处理角色来处理我们要调用的接口对象
            proxyInvocation.setRent(host);
    
            Rent proxy = (Rent) proxyInvocation.getProxy();  //这里的proxy是动态生成的
    
            proxy.rent();
        }
    }