GOF23 设计模式之代理模式

一、代理模式是什么？

代理模式就是为其他对象提供一种代理以控制对被代理对象的访问，也就是我们常说的中介。这种类型的设计模式属于结构型模式。

二、结构图

三、代理分类

• 静态代理：通过代理类继承同一接口。
• 动态代理：JDK动态代理，cglib动态代理。

实现代码

• 静态代理
  UserHolder 继承User类，重写walk()方法，在打印“我正在行走。。。”的前后各加了一个方法。

 public interface Walk{
    void walk();
 }

 public class User implement Walk{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public void walk(){
        System.out.println("我正在行走。。。");
    }
}

 public class UserHolder implement Walk{
     
     public void walk(){
         beforeWalk();
         new User().walk();
         AfterWalk();
     }
     
     public void beforeWalk(){
         System.out.println("走之前运行的方法");
     }
     
     public void AfterWalk(){
         System.out.println("走之后运行的方法");
     }
 }

• JDK动态代理
  动态代理步骤：
  1.创建一个实现接口InvocationHandler的类，它必须实现invoke方法
  2.创建被代理的类以及接口
  3.通过Proxy的静态方法newProxyInstance(ClassLoaderloader, Class[] interfaces, InvocationHandler h)创建一个代理
  4.通过代理调用方法

public interface Subject {
    
    String SayHello(String name);

    String SayGoodBye();
}

public class RealSubject implements Subject {

    public String SayHello(String name) {
        return "hello " + name;
    }

    public String SayGoodBye() {
        return " good bye ";
    }
}

public class InvocationHandlerImpl implements InvocationHandler {

    private Object subject;
    
    public InvocationHandlerImpl(Object subject)
    {
        this.subject = subject;
    }

    /**
     * 该方法负责集中处理动态代理类上的所有方法调用。
     * 调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行
     *
     * @param proxy  代理类实例
     * @param method 被调用的方法对象
     * @param args   调用参数
     * @return
     * @throws Throwable
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
    {
        //在代理真实对象前我们可以添加一些自己的操作
        System.out.println("在调用之前，我要干点啥呢？");

        System.out.println("Method:" + method);

        //当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
        Object returnValue = method.invoke(subject, args);

        //在代理真实对象后我们也可以添加一些自己的操作
        System.out.println("在调用之后，我要干点啥呢？");

        return returnValue;
    }
}


public class DynamicProxyDemo {
    public static void main(String[] args) {
        //代理的真实对象
        Subject realSubject = new RealSubject();

        /**
         * InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
         * 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用.
         * 即：要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法
         */
        InvocationHandler handler = new InvocationHandlerImpl(realSubject);

        ClassLoader loader = realSubject.getClass().getClassLoader();
        Class[] interfaces = realSubject.getClass().getInterfaces();
        /**
         * 该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
         */
        Subject subject = (Subject) Proxy.newProxyInstance(loader, interfaces, handler);

        System.out.println("动态代理对象的类型："+subject.getClass().getName());

        String hello = subject.SayHello("jiankunking");
        System.out.println(hello);
//        String goodbye = subject.SayGoodBye();
//        System.out.println(goodbye);
    }

}

• cglib动态代理
  必须实现 MethodInterceptor 接口

public class HelloService{


    public HelloService() {
        System.out.println("HelloService构造");
    }

    /**
     * 该方法不能被子类覆盖,Cglib是无法代理final修饰的方法的
     */
    final public String sayOthers(String name) {
        System.out.println("HelloService:sayOthers>>"+name);
        return null;
    }

    public void sayHello() {
        System.out.println("HelloService:sayHello");
    }


    static class MyMethodInterceptor implements MethodInterceptor {
        /**
         * sub：cglib生成的代理对象
         * method：被代理对象方法
         * objects：方法入参
         * methodProxy: 代理方法
         */
        @Override
        public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
            System.out.println("======插入前置通知======");
            Object object = methodProxy.invokeSuper(proxy, args);
            System.out.println("======插入后者通知======");
            return object;
        }
    }


    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        // 设置enhancer对象的父类
        enhancer.setSuperclass(HelloService.class);
        // 设置enhancer的回调对象
        enhancer.setCallback(new MyMethodInterceptor());
        // 创建代理对象
        HelloService proxy = (HelloService)enhancer.create();
        // 通过代理对象调用目标方法
        proxy.sayHello();
    }

}