代理模式（静态和动态代理）

---

前言

代理模式：

代理模式的定义:为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

---

一、代理模式

代理模式分类:
静态代理
动态代理
 
静态代理
是由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。

动态代理
是在实现阶段不用关心代理类，而在运行阶段才指定哪一个对象。

二、静态代理

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

抽象角色（就是一个接口）

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("查询了一个用户");
    }
}

 
代理角色（会有附属操作）

public class UserServiceProxy implements UserService{
    private UserServiceImpl userService;
    public UserServiceProxy() {
    }
    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+"方法");
    }
}

 
客户：

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

 
❤就相当于在已经写好的程序中加入一些新功能。需要一个代理对象与真实对象继承同一个接口，实现相同的方法，但不修改真实角色中的代码，因为
改动原有的业务代码，在公司是大忌！
 
静态代理的好处：
*可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
*公共也就交给代理角色！实现了业务的分工
*公共业务发生扩展的时候，方便集中管理！
缺点:
*一个真实角色就会产生一个代理角色；代码量会翻倍，开发效率会变低
 

三、动态代理

*动态代理和静态代理角色一样
*动态代理的代理类是动态生成的，不是我们直接写好的
*动态代理分为两大类：基于接口的动态代理。基于类的动态代理
 
基于接口–JDK动态代理[现在使用]
基于类：cglib
java字节码：javalist
 
 
就像租房一样，房东需要出租房，找到中介，中介也是出租房，他们有一个共同的接口就是租房
 
抽象角色

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

 
真实角色就是房东要出租房子
真实角色：

//房东
public class Host implements Rent {
    public void rent() {
        System.out.println("房东要出租房子！");
    }
}

代理角色就像是中介一样，他可以实现房东的方法就是租房，也可以附加自己的操作，例如收中介费，看房等
 
代理角色（会有附属操作）

//用这个类，自动生成代理类！
public class ProxyInvocationHandler 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 {
        //动态代理的本质，就是使用反射机制实现
        Object result = method.invoke(rent, args);
        return result;
    }
}

动态代理最重要的两个类：
Proxy:代理 ，InvocationHandler:调用处理程序
 
InvocationHandler：是由代理实例的，调用处理程序实现的接口
       每个代理实例都有一个关联的调用处理程序。当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法
 
Proxy：
提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。
 
此时的代理角色不想静态代理那样有具体的类，而是自动生成的类
客户：

public class Client {
    public static void main(String[] args) {
        //真实角色
        Host host=new Host();
        //代理角色：现在没有
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //通过调用程序处理角色来处理我们要调用的接口对象
        pih.setRent(host);
        //返回一个代理类，这里的proxy就是动态生成的，我们并没有写
        Rent proxy = (Rent) pih.getProxy();
        proxy.rent();
    }
}

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

---