设计模式之代理模式

最新推荐文章于 2024-05-16 17:20:27 发布

游戏人日常

最新推荐文章于 2024-05-16 17:20:27 发布

阅读量137

点赞数

分类专栏：设计模式一点一滴文章标签： Java 动态代理 Cglib Android

本文链接：https://blog.csdn.net/song_shui_lin/article/details/93870059

版权

设计模式一点一滴专栏收录该内容

6 篇文章 0 订阅

订阅专栏

序言

在看Retrofit源码时，我们会发现里面是使用了Java的动态代理的。以前也接触过动态代理，平常不用，时间就久了就会慢慢淡忘。所以平常多总结，任何知识点也是如此。

作用

为其他的对象提供一种代理来控制这个对象的访问。
增强目标对象的功能

静态代理

开发者接口

public interface IDeveloper {
    void writeCode();
}

Android开发者

public class AndroidDeveloper implements IDeveloper {

     @Override
	 public void writeCode() {
   		 System.out.println("Write Android Code");
	 }
}

测试

public class DevelopTest {

    public static void main(String arg[]){
    	IDeveloper developer=new AndroidDeveloper();
    	developer.writeCode();
	}
}

运行结果：

Write Android Code

现在麻烦的是，如果以后上级领导说，写代码前必须写注释写文档。那我们就需要修改AndroidDeveloper这个类，这就不符合 “开闭原则”（对扩展开放，对修改关闭）。所以我们可以创建个代理类，以不修改原始类中的代码来实现增强。

代理类

	public class DeveloperProxy implements IDeveloper {
	private  IDeveloper developer;

	public DeveloperProxy(IDeveloper developer){
    	this.developer=developer;
	}

	@Override
	public void writeCode() {
   		System.out.println("write Document or Note");
    	developer.writeCode();
	}
}

测试

public class DevelopTest {

	public static void main(String arg[]){
    
       IDeveloper developer=new AndroidDeveloper();
       DeveloperProxy proxy=new DeveloperProxy(developer);
       proxy.writeCode();
    }
}

运行结果：

write Document or Note
Write Android Code

可以看到我们在没有修改AndroidDevelop这个类，通过代理类来实现增强。

总结：

被代理的类（AndroidDeveloper）和代理类（DeveloperProxy）实现了同一个接口，然后在代理类中引入AndroidDeveloper对象的引用。
可以不改变被代理的类，来增强功能。

优点：

代理使客户端不需操作被代理的类（AndroidDeveloper），只需要操作代理类（DeveloperProxy）就行了（解耦合）。

缺点：

代理类跟被代理的类需要实现同样的接口，代理类跟被代理的类也实现了相同的方法，这样就出现大量的重复代码，接口增加一个方法，代理和被代理类就同时实现这个方法，增加代码维护的复杂度。
代理类只能代理一种类型（IDeveloper）的对象，如果代理多种类型的对象，那肯定为每一种对象进行代理，这种的情况静态代理就做不了了。
即静态代理类只能为特定的接口服务，如果为多个接口服务，那必须建立多个代理类。

动态代理

开发者接口（需要动态代理的接口）

public interface IDeveloper {
    void writeCode();
}

Android开发者（动态代理的实际对象）

public class AndroidDeveloper implements IDeveloper {

     @Override
	 public void writeCode() {
   		 System.out.println("Write Android Code");
	 }
}

代理方法被调用前后执行的操作抽象出来。

public interface Before {

    public void before();
}


public interface After {

    void after();
}

创建自己的调用处理器，统一来处理和过滤一些消息。

public class InvocationHandlerImpl implements InvocationHandler {

private Object targetObject; //需要代理的对象

Before before; 

After after;

public Before getBefore() {
    return before;
}
public void setBefore(Before before) {
    this.before = before;
}

public After getAfter() {
    return after;
}

public void setAfter(After after) {
    this.after = after;
}

public  InvocationHandlerImpl(Object targetObject){
    this.targetObject=targetObject;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    /* 代理方法执行前 执行其他的操作*/
    if (before!=null){
        before.before();
    }
    Object result=method.invoke(targetObject,args);
    /* 代理方法执行后 执行其他的操作*/
    if (after!=null){
        after.after();
    }
    return result;
}
}

测试

public class DevelopTest {

public static void main(String arg[]){

    final IDeveloper p=new AndroidDeveloper();//需要代理的对象
    InvocationHandlerImpl invocationHandler=new InvocationHandlerImpl(p);
    invocationHandler.setBefore(new Before() {
        @Override
        public void before() {
            System.out.println("write Document or Note ");
        }
    });
    invocationHandler.setAfter(new After() {
        @Override
        public void after() {
            System.out.println("Review Code ");
        }
    });

    IDeveloper proxy= (IDeveloper) Proxy.newProxyInstance(p.getClass().getClassLoader(), new Class[]{IDeveloper.class},invocationHandler);
    proxy.writeCode();
}
}

运行结果：

write Document or Note
Write Android Code
Review Code

说明：

当 proxy.writeCode()执行时，会回调到这个InvocationHandlerImpl中的invoke方法。
InvocationHandler中的invode方法中的三个参数 1：代理对象（proxy） 2：方法对象（writeCode） 3：方法参数
newProxyInstance方法中的三个参数 1: 类加载器 2：代理所实现的接口 3：表示的是当动态代理对象调用方法时，会关联到这个对象上

JDK动态代理实现的步骤：

创建被代理的类和以及实现的接口；
创建一个实现接口InvocationHandler的类。实现invoke方法；
调用Proxy的newProxyInstance 静态方法，动态生成代理类；
通过代理对象调用目标方法，然后会转发到invoke方法；

总结：

动态代理类在程序运行时动态生成，不需要写代理类源代码；
被代理的类必须实现接口，代理的类没有实现接口的就不行（原因是Java不能进行多继承，只能实现多接口）；
基于Java内部的反射机制来实现；

Cglib 代理

Android开发者（动态代理的实际对象不需实现任何接口）

public class AndroidDeveloperr {

	 public void writeCode() {
   		 System.out.println("Write Android Code");
	 }
}

代理方法被调用前后执行的操作抽象出来。

public interface Before {

    public void before();
}


public interface After {

    void after();
}

创建自己的方法拦截器，统一来处理和过滤一些消息。

public class MethodInterceptorImpl implements MethodInterceptor {

Before before;

After after;

public Before getBefore() {
    return before;
}
public void setBefore(Before before) {
    this.before = before;
}

public After getAfter() {
    return after;
}

public void setAfter(After after) {
    this.after = after;
}

@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

    if (before!=null){
        before.before();
    }
     Object result=methodProxy.invokeSuper(o,args);

    if (after!=null){
        after.after();
    }
    return result;
}
}

测试

public class DevelopTest {

public static void main(String arg[]){
    MethodInterceptorImpl methodInterceptor=new MethodInterceptorImpl();
    methodInterceptor.setBefore(new Before() {
        @Override
        public void before() {
            System.out.println("write Document or Note ");
        }
    });
    methodInterceptor.setAfter(new After() {
        @Override
        public void after() {
            System.out.println("Review Code ");
        }
    });
    Enhancer enhancer=new Enhancer();//创建增强类
    enhancer.setSuperclass(AndroidDeveloper.class);//设置继承被代理类
    enhancer.setCallback(methodInterceptor);//设置回调
    AndroidDeveloper androidDeveloper= (AndroidDeveloper) enhancer.create();//生成代理对象
    androidDeveloper.writeCode();//在调用代理方法时，会回调到我们设置的方法拦截器上所拦截
}
}

运行结果：