Spring的静态代理和动态代理模式

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

代理模式的分类

• 静态代理
• 动态代理

1.静态代理

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

代码步骤：

• 目录结构

• 编写抽象角色接口

package com.cbbpp.demo1;

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

• 编写真实角色实现1接口

package com.cbbpp.demo1;

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

• 编写代理角色实现1接口且添加多种业务

package com.cbbpp.demo1;

public class Proxy implements Rent{
    private Host host;

    public Proxy() {
    }

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

    public void rent() {
        seeHouse();
        contract();
        host.rent();
        tip();
    }

    public void seeHouse(){
        System.out.println("中介带领看房子");
    }
    public void contract(){
        System.out.println("中介安排签合同");
    }
    public void tip(){
        System.out.println("中介收取小费");
    }
}

• 客户操作

package com.cbbpp.demo1;

public class Client {
    public static void main(String[] args) {
        //房东要租房子
        Host host = new Host();
        //代理，中介帮房东租房子，但是代理角色一般会有一些附属操作
        Proxy proxy = new Proxy(host);
        //你不用面对房东，直接找中介代理即可，得到全面的服务
        proxy.rent();
    }
}

优点：

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

缺点：

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

加深理解：

使用AOP，可以使得我们在不改变公司原有代码的基础上，横向的拓展业务和日志

举例子：下面例子是给在不改变原有的方法基础上，通过代理模式，给原有方法增加Log日志

• 编写抽象角色接口：

package com.cbbpp.demo2;

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

• 编写真实角色实现1接口：

package com.cbbpp.demo2;

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接口且添加多种业务：

package com.cbbpp.demo2;

public class Proxy implements UserService {
    private UserServiceImpl userService;

    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }
    public void add() {
        log("add");
        System.out.println("增加了一个用户");
    }
    public void delete() {
        log("del");
        System.out.println("删除了一个用户");
    }
    public void update() {
        log("upd");
        System.out.println("更新了一个用户");
    }
    public void query() {
        log("que");
        System.out.println("查询了一个用户");
    }
    //日志方法
    public void log(String msg){
        System.out.println("使用了"+msg+"方法");

    }
}

• 客户操作：

package com.cbbpp.demo2;

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

---

---

2.动态代理

• 动态代理的角色和静态代理是一样的
• 动态代理的代理类是动态生成的，不是我们直接写好的
• 动态代理分为两大类：
  • 基于接口的动态代理----------JDK动态代理【下面使用此代理】
  • 基于类的动态代理-------------cglib
  • java字节码实现----------------javasist

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

InvocationHandler：是java.lang.reflect包下的

每个代理实例都有一个关联的调用处理程序。 当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法。

例子：

目录结构：

第一步：定义抽象接口：

package com.cbbpp.demo3;

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

第二步：定义真实对象实现接口并设置业务方法：

package com.cbbpp.demo3;

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

第三步：定义万能的动态代理模板：

package com.cbbpp.demo3;

import com.cbbpp.demo3.Rent;

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


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

}

第四步：测试实现：

package com.cbbpp.demo3;

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

//结果
执行了rent方法
房东要出租房子

Process finished with exit code 0

动态代理的好处：

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