设计模式·代理模式

1、代理模式定义

为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式类图

Subject：定义代理对象要实现的方法
RealSubject：被代理类，实现Subject接口
SubjectProxy：代理类，客户端通过代理类操作达到实现代理方法

入下定义接口

public interface Subject {
    void fun1();
    void fun2();
}

被代理类

public class RealSubject implements Subject {
    private String name;

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

    @Override
    public void fun1() {
        System.out.println(name + "执行fun1()");
    }

    @Override
    public void fun2() {
        System.out.println(name + "执行fun2()");
    }
}

代理类

public class SubjectProxy implements Subject {
    private Subject subject;

    public SubjectProxy(String name) {
        subject = new RealSubject(name);
    }

    @Override
    public void fun1() {
        this.subject.fun1();
    }

    @Override
    public void fun2() {
        this.subject.fun2();
    }
}

使用入下

public class Main {
    public static void main(String[] args) {
        SubjectProxy proxy = new SubjectProxy("李四");
        proxy.fun1();
        proxy.fun2();
    }
}

输出

李四执行fun1()
李四执行fun2()

2、动态代理

概念：在运行阶段指定代理的对象，不需要向上面静态代理的栗子一样编写SubjectProxy代理类

动态代理类图

动态代理使用到了java中的InvocationHandler和Proxy类，具体实现看下面栗子
定义要被代理的对象要实现的接口

public interface Subject {
    void doSomething();
}

定义要被代理的对象

public class RealSubject implements Subject {
    @Override
    public void doSomething() {
        System.out.println("do Something ......");
    }
}

定义InvocationHandler

public class MyInvocationHandler implements InvocationHandler {
    private final Object obg;

    public MyInvocationHandler(Object obg) {
        this.obg = obg;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return method.invoke(obg, args);
    }
}

动态代理使用入下

public class Main {
    public static void main(String[] args) {
        //常规使用
        Subject subject = new RealSubject();
        InvocationHandler handler = new MyInvocationHandler(subject);
        Subject proxy = (Subject) Proxy.newProxyInstance(
                subject.getClass().getClassLoader(),
                new Class[]{Subject.class},
                handler
        );
        proxy.doSomething();
    }
}

输出入下

do Something ......

3、基于动态代理实现切面编程(AOP)

把上面的MyInvocationHandler改造一下就能够实现在方法执行前的切入点，执行其他操作

public class MyInvocationHandler implements InvocationHandler {
    Object obj;

    public MyInvocationHandler(Object obj) {
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (method.getName().equalsIgnoreCase("doSomething")) {
            System.out.println("调用doSomething前....");
        }
        return method.invoke(this.obj, args);
    }
}

输出

调用doSomething前....
do Something ......

相关栗子代码动态代理示例代码

最后编辑于：2021.01.07 17:11:36