14 代理模式

代理模式

代理模式，最后一个结构型模式 主要目的是控制对象的访问，比如防火墙。 通过一个代理层不让用户直接访问原始对象，访问代理对象。 所有的操作都有代理对象来进行。 这样在执行原有逻辑之前就可以进行一些处理，之后也可以进行一些处理。 类如Spring 的 AOP。

静态代理

接口

/**
 * 书的抽象行为
 */
interface Book {
    void read();
    void close();
}

具体的书

/**
 * 一本具体的书
 */
class HistoricalRecords implements Book {

    private String name;

    public HistoricalRecords(String name) {
        this.name = name;
    }

    @Override
    public void read() {
        System.out.printf("%s 正在阅读史记\n",name);
    }

    @Override
    public void close() {
        System.out.printf("%s 不读史记了\n",name);
    }
}

代理类

/**
 * 代理对象，代理具体的书
 * （静态代理）
 * 局限性：只能代理该接口的类，其他的类不能代理，需要重新创建对应的代理类。
 */
class BookProxy implements Book{
    private Book book;

    public BookProxy(Book book) {
        this.book = book;
    }

    @Override
    public void read() {
        System.out.println("读书前判断是否有资格");
        book.read();
        System.out.println("读书后处理");

    }

    @Override
    public void close() {
        System.out.println("不读书之前进行处理");
        book.close();
        System.out.println("不读书后进行处理");
    }
}

jdk动态代理(简单实现)

接口

interface DBook{
    String read(String name,Integer year);
    void close();
}

接口的一个实现对象

class ddBook implements DBook{
    @Override
    public String read(String name,Integer year) {
        String str = name+"死读书"+year+"年";
        System.out.println(str);
        return str;
    }
    @Override
    public void close() {
        System.out.println("读死书");
    }
}

动态代理

/**
 * 动态代理
 * 可以代理任意对象，可以使用反射或者是cglib技术实现，这里使用反射简单实现
 */
class ProxyInvocationHandler implements InvocationHandler{
    private Object target;

    public ProxyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 拦截所有方法
        // 方法执行前处理
        System.out.printf("入参列表：%s\n",args);
        Object invoke = method.invoke(target, args);
        // 方法执行后处理
        System.out.printf("返回值对象：%s\n",invoke);
        return invoke;
    }
    public Object getProxy(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),this);
    }
}

简单使用

/**
 * @author tx
 * @version 1.0
 * @date 2024/1/9 10:30
 * @description:
 * 代理模式，最后一个结构型模式
 * 主要目的是控制对象的访问，比如防火墙。
 * 通过一个代理层不让用户直接访问原始对象，访问代理对象。
 * 所有的操作都有代理对象来进行。
 * 这样在执行原有逻辑之前就可以进行一些处理，之后也可以进行一些处理。
 * 类如Spring 的 AOP。
 */
public class ProxyPattern {
    public static void main(String[] args) {
        // 静态代理
        System.out.println("静态代理---------------------------------");
        Book book = new BookProxy(new HistoricalRecords("小明"));
        book.read();
        book.close();

        // 动态代理
        System.out.println("动态代理---------------------------------");
        ProxyInvocationHandler dynamicProxy = new ProxyInvocationHandler(new ddBook());
        DBook proxy = (DBook) dynamicProxy.getProxy();
        proxy.read("小王",19);
        proxy.close();
    }
}

效果打印

demo

package structuralpattern;

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

/**
 * @author tx
 * @version 1.0
 * @date 2024/1/9 10:30
 * @description:
 * 代理模式，最后一个结构型模式
 * 主要目的是控制对象的访问，比如防火墙。
 * 通过一个代理层不让用户直接访问原始对象，访问代理对象。
 * 所有的操作都有代理对象来进行。
 * 这样在执行原有逻辑之前就可以进行一些处理，之后也可以进行一些处理。
 * 类如Spring 的 AOP。
 */
public class ProxyPattern {
    public static void main(String[] args) {
        // 静态代理
        System.out.println("静态代理---------------------------------");
        Book book = new BookProxy(new HistoricalRecords("小明"));
        book.read();
        book.close();

        // 动态代理
        System.out.println("动态代理---------------------------------");
        ProxyInvocationHandler dynamicProxy = new ProxyInvocationHandler(new ddBook());
        DBook proxy = (DBook) dynamicProxy.getProxy();
        proxy.read("小王",19);
        proxy.close();
    }
}

/**
 * 书的抽象行为
 */
interface Book {
    void read();

    void close();
}
/**
 * 代理对象，代理具体的书
 * （静态代理）
 * 局限性：只能代理该接口的类，其他的类不能代理，需要重新创建对应的代理类。
 */
class BookProxy implements Book{
    private Book book;

    public BookProxy(Book book) {
        this.book = book;
    }

    @Override
    public void read() {
        System.out.println("读书前判断是否有资格");
        book.read();
        System.out.println("读书后处理");

    }

    @Override
    public void close() {
        System.out.println("不读书之前进行处理");
        book.close();
        System.out.println("不读书后进行处理");
    }
}

/**
 * 一本具体的书
 */
class HistoricalRecords implements Book {

    private String name;

    public HistoricalRecords(String name) {
        this.name = name;
    }

    @Override
    public void read() {
        System.out.printf("%s 正在阅读史记\n",name);
    }

    @Override
    public void close() {
        System.out.printf("%s 不读史记了\n",name);
    }
}

/**
 * 动态代理----------------------------------------------
 */
interface DBook{
    String read(String name,Integer year);
    void close();
}
class ddBook implements DBook{
    @Override
    public String read(String name,Integer year) {
        String str = name+"死读书"+year+"年";
        System.out.println(str);
        return str;
    }
    @Override
    public void close() {
        System.out.println("读死书");
    }
}
/**
 * 动态代理
 * 可以代理任意对象，可以使用反射或者是cglib技术实现，这里使用反射简单实现
 */
class ProxyInvocationHandler implements InvocationHandler{
    private Object target;

    public ProxyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 拦截所有方法
        // 方法执行前处理
        System.out.printf("入参列表：%s\n",args);
        Object invoke = method.invoke(target, args);
        // 方法执行后处理
        System.out.printf("返回值对象：%s\n",invoke);
        return invoke;
    }
    public Object getProxy(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),this);
    }
}