设计模式之代理模式

代理模式

百度百科定义：定义:代理模式给某一个对象提供一个代理对象,并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。

学习意义

为什么要学习代理模式?因为这就是SpringAOP的底层！【SpringAOP和SpringMVC】

现实意义：

在有些情况下，一个客户不能或者不想直接访问另一个对象，这时需要找一个中介帮忙完成某项任务，这个中介就是代理对象。例如，购买火车票不一定要去火车站买，可以通过 12306 网站或者去火车票代售点买。又如找女朋友、找保姆、找工作等都可以通过找中介完成。

软件设计意义：

在软件设计中，使用代理模式的例子也很多，例如，要访问的远程对象比较大（如视频或大图像等），其下载要花很多时间。还有因为安全原因需要屏蔽客户端直接访问真实对象，如某单位的内部数据库等。

代理模式分类

• 静态代理
• 动态代理

静态代理

角色分析：

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

代理实例

先看问题：

我们需要租房子。于是有了下面的代码。

方式一：直接租房

• 租房接口类

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

• 房东类

/**房东*/
public class Host implements Rent{
    //这里如果不适用代理模式也完全可以不适用上面的接口就可以实现了
    @Override
    public void rent(){
        System.out.println("房东出租房子！");
    }
}

• 租房类

/**租客*/
public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        host.rent();
    }
}

问题：在上面的代码中，我们肯定可以租到房子，但是现实却是我们并不知道谁会出租房子，我们要是租房子，肯定是更多的来源是需要中介来进行代理租房的。

• 中介代理

/**
 * @author:pier 2021/11/12
 **/
/**中介*/
public class Proxy implements Rent{
    private Host host;
    public Proxy(){

    }
    /**接受房东的访客*/
    public Proxy(Host host){
        this.host=host;
    }
    /**帮房东出租房子，并拿到该租客的客户*/
    @Override
    public void rent() {
        host.rent();
    }
    /**下面时实现一些房东不方便的操作！！！*/
    /**带租客看房*/
    public void SeeHouse(){
        System.out.println("中介带你逛其他别墅");
    }
    /**收中介费*/
    public void Fare(){
        System.out.println("中介收中介费");
    }
    /**签租赁合同*/
    public void HeTong(){
        System.out.println("签租赁合同");
    }
}

• 改进后的租客类，主要是加了注释

/**租客*/
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.SeeHouse();
        //签合同
        proxy.HeTong();
        //租房到手
        proxy.rent();
    }
}

• 代理模式的好处

可以是真实角色的操作更加纯粹！不用去关注一些公共业务

公共业务就交给代理角色！实现了业务的分工

公共业务发生扩展时，方便集中管理

• 代理模式的缺点

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

• 总结步骤
  • 接口——Rent类
  • 真实角色——房东类
  • 代理角色——中介类
  • 客户端访问代理角色——租客类
• 做个小练习

先做一个拥有增删改查功能的接口实现类。再实现对类的日志打印。

• 接口类

public interface UserService {
    /**增*/
    public void add();
    /**删*/
    public void delete();
    /**改*/
    public void update();
    /**查*/
    public void query();
}

• 实现类

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

这里思考一下，打印日志？就是让我们去再每一个调用方法时添加一个调用什么方法的打印。我们可以直接再每个方法里面去直接添加一个打印输出就可了。但我们可以吗？不！切记 千万不要直接去修改源代码，在公司里面是大忌！你的代码可脆弱了，一碰容易坏，所以千万不能动，这也是OOP七大原则中的开闭原则，所以我们只能重写原来的代码，于是我的修改如下。

public class UserServiceProxy implements UserService{
    /**使用代理的方式，调用原来的接口方法使用*/
    private 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("[message]:使用了"+msg+"方法");
    }
}

• 实现类

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

动态代理

• 动态代理和静态代理角色一样
• 动态代理的代理类是动态生成的，不是我们直接写好的
• 动态代理分为两大类：基于接口的动态管理，基于类的动态管理
  • 基于接口——JDK动态管理【我们这里使用原生jdk】
  • 基于类：cglib
  • Java字节码实现：javasist

需要两个类：Proxy ：代理，InvocationHandler  ：调用处理程序

• InvocationHandler（Java.lang,reflect）反射包下面的接口

InvocationHandler是由代理实例的调用处理程序实现的接口。

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

• Proxy（java.lang.reflect）反射包下面的类

Proxy提供了动态代理类和实例的静态方法，他也是由这些方法创建的所有动态代理类的超类。

小提一下，这个动态代理如果不是很理解的小伙伴，建议去看一下反射，深入了解。

理论再多，不是实操一下！话不多说，看代码。

初级动态代理

• 接口

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

• 房东

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

• j代理类

重点！！！！！核心！！！！

/**
 * @author:pier 2021/11/12
 **/
/**使用这个类自动生成代理类*/
public class ProxyInvocationHandler implements InvocationHandler {
    /**被代理的接口*/
    private Rent rent;
    public void setRent(Rent rent){
        this.rent=rent;
    }

    public Object getProxy(){
        /*
        * this.getClass().getClassLoader()
        * rent.getClass().getInterfaces()定义的接口
        * this指类本身
        * 我们使用时只需要修改这个不同的接口就可以了，即修改rent*/
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
    }

    /**处理代理实例，并返回结果（核心）*/
    @Override
    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable {
        /*method是反射包下面的方法
        * method执行的时上面接口的方法
        * 动态代理的本质，就是使用反射实现！
        * */
        seeHouse();
        Object result = method.invoke(rent,args);
        fare();
        return null;
    }
    public void seeHouse(){
        System.out.println("中介带看房子");
    }
    public void fare(){
        System.out.println("中介收中介费");
    }
}

• 实现类

/**
 * @author:pier 2021/11/12
 **/
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();
    }
}

请看一下上面得代码没有出现任何关于看房子贺收中介费得方法叭，甚至里面连调用他们两得invoke方法都没有再代码中出现，这才叫代理，我们就是中介公司老总，买房子，是你们这群打工人去干得事！呵呵！！

试试升级版

上面的代码我们看的虽然感觉懂了，但是貌似也不会用呀，怎么办呢？

别慌，下面由本博主带大家写一个似乎看的懂得“万能”代码。

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

/**
 * @author:pier 2021/11/12
 **/

/**使用这个类自动生成代理类
 * @author pipi*/
public class ProxyInvocationHandler implements InvocationHandler {
    /**被代理的接口*/
    private Object target;
    public void setTarget(Object target){
        this.target=target;
    }

    public Object getTarget(){
        /*
        * this.getClass().getClassLoader()
        * rent.getClass().getInterfaces()定义的接口
        * this指类本身
        * 我们使用时只需要修改这个不同的接口就可以了，即修改target*/
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    /**处理代理实例，并返回结果（核心）*/
    @Override
    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable {
        /*method是反射包下面的方法
        * method执行的时上面接口的方法
        * 动态代理的本质，就是使用反射实现！
        * */
        Object result = method.invoke(target,args);
        return null;
    }
}

• 小试一下添加日志得代码。

public class Client {
    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService = new UserServiceImpl();
        //代理角色
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(userService);
        UserService proxy = (UserService) pih.getTarget();
        //因为是通用得代码，便没有直接再代理里面用，客户要什么我们给什么才是我们得目的！！
        proxy.delete();
    }
}

• 结果
  

代理模式，恐怖如斯！骚年！加油！！！！