多线程：3-代理模式

2020-06-05 阅读量

3.代理模式

代理模式分类：

静态代理
动态代理

1.静态代理

角色分析：

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

代码步骤：

接口

// 租房（抽象角色）
public interface Rent {
    // 出租房屋
    void rent();
}

真实角色

// 房东（真实角色）
public class Landlord implements Rent{
    @Override
    public void rent() {
        System.out.println("房东要出租房子！");
    }
}

代理角色

// 代理（代理角色）
public class Proxy implements Rent{

    // 房东
    private Landlord landlord;

    public Proxy() {
    }

    public Proxy(Landlord landlord) {
        this.landlord = landlord;
    }

    @Override
    public void rent() {
        seeHouse();
        landlord.rent();
        contract();
        charge();
    }

    // 代理附属操作：看房、收费、签合同
    
    // 看房子
    public void seeHouse(){
        System.out.println("中介带你看房子");
    }

    // 收中介费
    public void charge(){
        System.out.println("收中介费");
    }

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

客户端

// 客户，房客
public class Client {
    public static void main(String[] args) {

        // 房东（真实角色）
        Landlord landlord = new Landlord();

        // 代理（中介）
        // 代理角色一般会有一些附属操作
        Proxy proxy = new Proxy(landlord);

        // 客户不用找房东，直接找中介租房
        proxy.rent();
    }
}

结果：

中介带你看房子
房东要出租房子！
签租赁合同
收中介费

UML类图：
加载图片！

静态代理模式好处：

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

缺点：

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

2.静态代理再理解

现有以下项目：
1.Service接口：

// 抽象角色
public interface UserService {
    void add();
    void delete();
    void update();
    void query();
}

2.Service实现：

// 真实角色
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("查询用户");
    }
}

增加需求：每次调用Service里的方法的时候，都增加一个日志。 如：

// 真实角色
public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("使用了增加方法");
        System.out.println("增加用户");
    }
    // 由于篇幅，其他几个方法暂时删除
}

// 显然这么做违反了开闭原则。

3.动态代理

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写好的。
动态代理分为两大类：基于接口的动态代理、基于类的动态代理。
- 基于接口：如JDK动态代理
- 基于类：cglib

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

动态代理的好处：

静态代理的好处，它都有
一个动态代理类代理的是一个接口，一般就是对应的一类业务。
一个动态代理类可以代理多个类，只要这些类实现同一接口即可。

代码：
1.真实角色

// 房东（真实角色）
public class Landlord implements Rent {
    @Override
    public void rent() {
        System.out.println("房东要出租房子！");
    }
}

2.抽象角色 – 接口

// 租房（抽象角色）
public interface Rent {

    // 出租房屋
    void rent();
}

3.代理角色处理程序（可动态生成代理角色的类）

// 以后会用这个类，自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler{

    // 被代理的接口
    private Rent rent;

    // 对应的getter方法
    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);

        charge();    // 代理附属操作

        return result;
    }

    // 代理类的附属操作
    // 看房子
    public void seeHouse(){
        System.out.println("中介带你看房子");
    }

    // 收中介费
    public void charge(){
        System.out.println("收中介费");
    }
}

4.客户 – 测试

// 客户，房客
public class Client {
    public static void main(String[] args) {

        // 房东（真实角色）
        Landlord landlord = new Landlord();

        // 代理角色处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();

        // 通过调用程序处理角色 来处理我们要调用的 接口对象
        pih.setRent(landlord);              // 设置要代理的对象
        Rent proxy = (Rent) pih.getProxy(); // 代理角色（动态生成）

        // 客户不用找房东，直接找中介租房
        proxy.rent();
    }
}

把代理角色处理程序封装成一个方法：

// 以后会用这个类，自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler{

    // 被代理的接口
    private Object target;

    // 对应的getter方法
    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 {
        // 动态代理的本质，就是使用反射机制来实现
        Object result = method.invoke(target, args);
        return result;
    }
}

测试：调用Service层进行增删改查操作
修改封装好的代理角色处理程序，添加生成日志操作

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 + "方法");
    }
}

测试：

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

3.代理模式

1.静态代理

2.静态代理 再理解

3.动态代理

把代理角色处理程序 封装成一个方法：

2.静态代理再理解

把代理角色处理程序封装成一个方法：