设计模式之代理模式

目录

1 代理模式的定义与特点

1.1 定义

1.2 优点

1.3 缺点

2 代理模式的结构与实现

2.1 结构

 2.2.1 静态代理

2.2.2 动态代理

---

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

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

1 代理模式的定义与特点

1.1 定义

由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。

1.2 优点

1、代理模式能将代理对象与真实被调用的目标对象分离。

2、一定程度上降低了系统的耦合度，扩展性好。

3、可以起到保护目标对象的作用。

4、可以对目标对象的功能增强。

1.3 缺点

1、代理模式会造成系统设计中类的数量增加。

2、在客户端和目标对象增加一个代理对象，会造成请求处理速度变慢。

3、增加了系统的复杂度。

那么如何解决以上提到的缺点呢？

可以使用动态代理方式

2 代理模式的结构与实现

2.1 结构

代理模式的结构比较简单，主要是通过定义一个继承抽象主题的代理来包含真实主题，从而实现对真实主题的访问

 2.2.1 静态代理

由程序员创建代理类或特定工具自动生成源代码再对其编译，在程序运行前代理类的 .class 文件就已经存在了。

代码实现

接口

package staticAent.demo2;

/**
 * @author Mr.Qing
 * @date 2021/11/9
 */
public interface userService {
    void add();
    void delete();
    void update();
    void query();
}

真实角色

package staticAent.demo2;

/**
 * @author Mr.Qing
 * @date 2021/11/9
 */
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("查询了一个用户");
    }
}

代理角色

package staticAent.demo2;

/**
 * @author Mr.Qing
 * @date 2021/11/9
 */
public class userServicePraxy implements userService{
    private userServiceImpl userService;

    public userServicePraxy() {
    }

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

    private void log(String msg){
        System.out.println("[debug]使用"+msg+"方法");
    }
}

测试

package staticAent.demo2;

/**
 * @author Mr.Qing
 * @date 2021/11/9
 */
public class Client {
    public static void main(String[] args) {
        userServiceImpl userService = new userServiceImpl();

        userServicePraxy userServicePraxy = new userServicePraxy(userService);
        userServicePraxy.add();
    }
}

结果

代理角色在真实角色的基础上，增加了方法，如果有很多角色需要被代理，那么需要写很多代理角色，会增加代码量，前面说到，动态代理可以解决

2.2.2 动态代理

在程序运行时，运用反射机制动态创建而成

代码实现

接口和真实角色和前面一样，只是在动态生成一个代理角色

package staticAent.demo3;

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

/**
 * @author Mr.Qing
 * @date 2021/11/9
 * 用这个类，自动生成代理类
 */
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;
    }

    private void log(String msg){
        System.out.println("[debug]使用"+msg+"方法");
    }
}

测试

package staticAent.demo3;

import staticAent.demo2.userServicePraxy;

/**
 * @author Mr.Qing
 * @date 2021/11/9
 */
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();

    }
}

结果