设计模式之静态/动态代理模式

参考博客：https://blog.youkuaiyun.com/qq_33369905/article/details/105828919?spm=1001.2014.3001.5501

重要性：AOP的底层机制就是动态代理！

1、静态代理

（1）静态代理角色分析

• 抽象角色 : 一般使用接口或者抽象类来实现，代理和真实角色都有的功能

• 真实角色 : 被代理的角色

• 代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作（比如日志，附加功能） .

• 客户  :  使用代理角色来进行一些操作 .

（2）代码实现

Rent（抽象角色）

package cn.qqa.demo1;

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

Host  （房东，真实角色）

package cn.qqa.demo1;

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

Proxy（代理角色）

有看房，签合同，收房租等附加操作

package cn.qqa.demo1;

public class Proxy implements Rent{
    //原则：少用继承，多用组合
    private Host host;

    public Proxy() {
    }

    public Proxy(Host host) {
        this.host = host;
    }

    @Override
    public void rent() {
        seeHouse();
        host.rent();
        contract();
        fare();
    }

    //看房
    public void seeHouse(){
        System.out.println("中介带你看房！");
    }

    //收房租
    public void fare(){
        System.out.println("中介收房租！");
    }

    //签合同
    public void contract(){
        System.out.println("签租赁合同！");
    }




}

Client

package cn.qqa.demo1;

import java.util.Properties;

public class Client {
    public static void main(String[] args) {
/*
        非代理模式
        Host host = new Host();
        host.rent();
*/
        //房东要出租房子
        Host host = new Host();
        //代理，中介帮房东出租房子，但是，代理一般会有一些附属操作！
        //比如，带看房子、帮收房租、帮签合同
        Proxy proxy = new Proxy(host);
        //客户不用面对房东，直接找中介租房即可！
        proxy.rent();
    }
}

分析：在这个过程中，你直接接触的就是中介，就如同现实生活中的样子，你看不到房东，但是你依旧通过代理租到了房东的房子，这就是所谓的代理模式，程序源自于生活，所以学编程的人，一般能够更加抽象的看待生活中发生的事情。

静态代理的优点:

• 可以使得我们的真实角色（主体业务）更加纯粹 ，不再去关注一些公共的业务。
• 公共的业务由代理来完成 ，实现了业务的分工 。
• 公共业务发生扩展时变得更加集中和方便 。

缺点 :

• 类多了 , 代理类变多了 , 工作量变大了 ，开发效率降低 。

我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理 !

（3）静态代理再理解

（1）UserService接口

创建一个抽象角色，比如平时做的用户主体业务，抽象起来就是增删改查！

package cn.qqa.demo2;

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

（2）UserServiceImpl实现类

package cn.qqa.demo2;
//开发原则：尽量不修改源代码
//单一职责原则
//1.改动原有的业务代码在公司中是大忌！

public class UserServiceImpl implements UserService {
    @Override
    public void add() {
        //System.out.println("日志：使用了add方法！");
        System.out.println("增加了一个用户！");
    }

    @Override
    public void delete() {
        //System.out.println("日志：使用了delete方法！");
        System.out.println("删除了一个用户！");
    }

    @Override
    public void update() {
        //System.out.println("日志：使用了update方法！");
        System.out.println("修改了一个用户！");
    }

    @Override
    public void query() {
        //System.out.println("日志：使用了query方法！");
        System.out.println("查询了一个用户！");
    }
}

（3）现在要求在增删查改时输出日志的功能。

• 思路1 ：在实现类上增加代码 【麻烦！】

• 思路2：使用代理来做，能够不改变原来的业务情况下，实现此功能就是最好的了！

（4）UserServiceProxy代理类

package cn.qqa.demo2;

public class UserServiceProxy implements UserService {

    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("[Debug]:使用了"+msg+"方法！");
    }

}

（5）测试类

package cn.qqa.demo2;

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();

        UserServiceProxy userServiceProxy = new UserServiceProxy();
        userServiceProxy.setUserService(userService);
        userServiceProxy.delete();
    }
}

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

2、动态代理

（1）特点

• 动态代理的角色和静态代理的一样 .
• 动态代理的代理类是动态生成的 . 静态代理的代理类是我们提前写好的
• 动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理

（2）动态代理的实现方式

基于接口的动态代理----JDK动态代理

基于类的动态代理----cglib

现在用的比较多的是 javasist 来生成动态代理 . 百度一下javasist

（3）基于接口的动态代理----JDK动态代理

核心类 : InvocationHandler 和  Proxy  

就两个类。生成代理类Proxy.newProxyInvocation(参数1.参数2，参数3)
参数1：表名你要用那个类加载器去加载生成的代理类。（这个是JVM类加载的知识）。
参数2：说明你要生成的代理类的接口。
参数3：实现了InvocationHandle的类，这个类只有一个方法需要你要实现它。
invoke(Object proxy, Method method, Object[] args) ｛
这个方法第一个参数，是生成的代理类，目前没发现用处，不管它。
第二个参数，是执行的方法(利用反射的原理，可以去看反射。)
第三个参数，是执行某方法需要的参数。
第二个第三个参数解释执行的方法意思是：代理类不是要代理某个对象么，然后增强里面的方法么，指得就是这个方法，代理类会为几乎所有方法都增强，除非你在这里做判断。
返回值，是执行这个方法所返回的值。
然后你要去执行方法，就是用第二参数的invoke(obj,args);第一个参数是你要增强的对象。第二个是参数。object是你返回的类型
Object object= method.invoke(obj,args)。

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

（4）实现代码

Rent（抽象角色）

package cn.qqa.demo03;

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

Host（真实角色，被代理的角色）

package cn.qqa.demo03;

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

ProxyInvocationHandler（动态生成代理类，代理角色）

package cn.qqa.demo03;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//我们用这个类，自动生成代理
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);
    }

    //处理代理实例，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        seeHouse();
        //动态代理的机制，就是使用反射的机制实现！
        Object result = method.invoke(rent, args);
        fare();
        contract();
        return result;
    }

    //看房
    public void seeHouse(){
        System.out.println("中介带你看房！");
    }

    //收房租
    public void fare(){
        System.out.println("中介收房租！");
    }

    //签合同
    public void contract(){
        System.out.println("签租赁合同！");
    }

}

Client（客户）

package cn.qqa.demo03;

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();
    }

}

小结：一个动态代理 , 一般代理某一类业务 , 一个动态代理可以代理多个类，代理的是接口！

（4）通用的动态代理实现的类

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);
    }
 
    // proxy : 代理类
    // method : 代理类的调用处理程序的方法对象.
    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 methodName){
        System.out.println("执行了"+methodName+"方法");
    }
 
}

测试类：

public class Test {
    public static void main(String[] args) {
        //真实对象
        UserServiceImpl userService = new UserServiceImpl();
        //代理对象的调用处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(userService); //设置要代理的对象
        UserService proxy = (UserService)pih.getProxy(); //动态生成代理类！
        proxy.delete();
    }
}

 

（5）动态代理的优点

静态代理有的它都有，静态代理没有的，它也有！

• 可以使得我们的真实角色的主体业务更加纯粹 ，不再去关注一些公共的业务 。
• 公共的业务由代理来完成 . 实现了业务的分工 。
• 公共业务发生扩展时变得更加集中和方便 。
• 一个动态代理 , 一般代理某一类业务。
• 一个动态代理可以代理多个类，代理的是接口！