代理模式在开源代码中的应用

水深无声 2023-02-28 11:10 25阅读 0赞

代理模式的作用是为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访问该对象，从而限制、增强或修改该对象的一些特性。

由于静态代理会导致类文件大量增多，所以 Java 中动态代理使用的较多。

### **案例一** ###

JDK 中的动态代理的使用，实现 InvocationHandler 接口，只能代理接口的实现类

package com.xiongjun.proxy.dynamicproxy;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /**
     * JDK 自带动态代理
     * 
     * @author ConstXiong
     */
    public class JdkDynamicProxy implements InvocationHandler {
    
    	private Object target;
    	
    	public JdkDynamicProxy(Object target) {
    		this.target = target;
    	}
    
    	@SuppressWarnings("unchecked")
    	public <T> T getProxy() {
    		return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),
    				target.getClass().getInterfaces(), this);
    	}
    
    	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    		Object result = null;
    		long t1 = System.currentTimeMillis();
    		result = method.invoke(target, args);//目标类的方法调用，与结果获取
    		System.out.println("login cost time : " + (System.currentTimeMillis() - t1));
    		return result;
    	}
    
    }

客户端代码：

JdkDynamicProxy proxy = new JdkDynamicProxy(new ServiceImpl());
    Service jdkService = proxy.getProxy();
    jdkService.login("", "");

InvocationHandler 接口的源码，是被代理实例的处理程序实现，代理实例的方法调用会被关联到 invoke 方法

public interface InvocationHandler {
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
    }

代理实例通过 Proxy 类的静态工厂方法 newProxyInstance 创建

@CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);
        final Class<?>[] intfs = interfaces.clone();//复制接口的Class对象数组
        //校验权限
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
        //调用本地方法根据类加载器和Class对象数组，获取被代理对象的Class的对象
        Class<?> cl = getProxyClass0(loader, intfs);
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            //获取构造方法对象
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {//非public修改可见权限
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            return cons.newInstance(new Object[]{h});//创建被代理对象实例
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

### **案例二** ###

使用 cglib 类库完成动态代理，不要求被代理类必须实现接口

package com.xiongjun.proxy.dynamicproxy;
    
    import java.lang.reflect.Method;
    
    import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    
    /**
     * 使用 cglib 类库完成动态代理 
     * 
     * @author ConstXiong
     */
    public class CglibProxy implements MethodInterceptor {
    
    	private CglibProxy() {
    	}
    	
    	//单例模式获取代理类对象
    	private static CglibProxy proxy = new CglibProxy();
    	
    	public static CglibProxy getInstance() {
    		return proxy;
    	}
    	
    	
    	/**
    	 * 获取被代理后的目标类
    	 * @param clazz 目标类
    	 * @return
    	 */
    	@SuppressWarnings("unchecked")
    	public <T> T getProxy(Class<T> clazz) {
    		return (T) Enhancer.create(clazz, this);
    	}
    	
    	/**
    	 * 代理执行目标类方法
    	 */
    	public Object intercept(Object obj, Method method, Object[] args,
    			MethodProxy proxy) throws Throwable {
    		Object result = null;
    		long t1 = System.currentTimeMillis();
    		result = proxy.invokeSuper(obj, args);//目标类的方法调用，与结果获取
    		System.out.println("login cost time : " + (System.currentTimeMillis() - t1));
    		
    		return result;
    	}
     
    }

客户端代码：

Service cglibService = CglibProxy.getInstance().getProxy(ServiceImpl.class);
    cglibService.login("", "");

Cglib 借助 Enhancer 创建被代理对象实例，Enhancer 底层是借助 ASM 工具生成字节码，实例化对象的。

/**
     * Helper method to create an intercepted object.
     * For finer control over the generated instance, use a new instance of <code>Enhancer</code>
     * instead of this static method.
     * @param type class to extend or interface to implement
     * @param callback the callback to use for all methods
     */
    public static Object create(Class type, Callback callback) {
        Enhancer e = new Enhancer();
        e.setSuperclass(type);
        e.setCallback(callback);
        return e.create();
    }

### **案例三** ###

使用 Spring aop 中的 ProxyFactory 完成环绕代理

import java.util.Random;
     
    import org.aopalliance.intercept.MethodInterceptor;
    import org.aopalliance.intercept.MethodInvocation;
     
    /**
     * 使用 spring aop 完成环绕代理
     * @author ConstXiong
     */
    public class ServiceAroundAdvice implements MethodInterceptor {
    	
    	@Override
    	public Object invoke(MethodInvocation invocation) throws Throwable {
    		Object result = null;
    		long start = System.currentTimeMillis();//计时开始
    		result = invocation.proceed();//目标类的方法调用，与结果获取
    		long end = System.currentTimeMillis();//计时结束
    		System.out.println("耗时：" + (end - start) + "毫秒");//打印耗时
    		return result;
    	}
    	
    }

客户端代码：

ProxyFactory proxyFactory = new ProxyFactory(); //创建代理工厂类
    proxyFactory.setTarget(new ServiceImpl()); //设置被代理类
    proxyFactory.addAdvice(new ServiceAroundAdvice()); //添加增强器
    Service service = (Service) proxyFactory.getProxy(); //获取代理类
    service.login("ConstXiong", "123456");

Spring aop 创建代理对象实例的源码逻辑在这里，可以看出它根据情况使用了 JDK 动态代理和 Cglib 动态代理

@Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    	if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
    		Class<?> targetClass = config.getTargetClass();
    		if (targetClass == null) {
    			throw new AopConfigException("TargetSource cannot determine target class: " +
    					"Either an interface or a target is required for proxy creation.");
    		}
    		if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
    			return new JdkDynamicAopProxy(config);
    		}
    		return new ObjenesisCglibAopProxy(config);
    	}
    	else {
    		return new JdkDynamicAopProxy(config);
    	}
    }

--------------------

### 【Java学习资源】整理推荐 ###

*  [代理模式在开源代码中的应用][Link 1]
 *  [原型模式在开源代码中的应用][Link 2]
 *  [建造者模式在开源代码中的应用][Link 3]
 *  [工厂模式在开源代码中的应用][Link 4]
 *  [单例模式在开源代码中的应用][Link 5]
 *  [编码规范][Link 6]
 *  [设计模式][Link 7]
 *  [重构][Link 8]
 *  [设计原则][Link 9]
 *  [面向对象到底是什么][Link 10]
 *  [代码质量有哪些评判标准？][Link 11]

--------------------

### 【Java面试题与答案】整理推荐 ###

*  [基础与语法][Link 12]
 *  [集合][Link 13]
 *  [网络编程][Link 14]
 *  [并发编程][Link 15]
 *  [Web][]
 *  [安全][Link 16]
 *  [设计模式][Link 17]
 *  [框架][Link 18]
 *  [算法与数据结构][Link 19]
 *  [异常][Link 20]
 *  [文件解析与生成][Link 21]
 *  [Linux][]
 *  [MySQL][]
 *  [Oracle][]
 *  [Redis][]
 *  [Dubbo][]

[Link 1]: https://www.javanav.com/val/24468130d26e460187c9280b90146649.html
[Link 2]: https://www.javanav.com/val/ffd6d3d1ceed414daafeb3ce10794c60.html
[Link 3]: https://www.javanav.com/val/e8afb788fdc54712aaf981c705796b46.html
[Link 4]: https://www.javanav.com/val/6f367ed6ee894adb830987f11536141c.html
[Link 5]: https://www.javanav.com/val/838b98837f574aa6a09c840921984707.html
[Link 6]: https://www.javanav.com/val/2b9f8790e8564bc0a2cb36357a66502f.html
[Link 7]: https://www.javanav.com/val/90b430ff0cbc4ef997e64cf7a0e1e745.html
[Link 8]: https://www.javanav.com/val/d9095cb3712040c0bee8054732321d6d.html
[Link 9]: https://www.javanav.com/val/9916617e210c4e0eae8649874a2cedd5.html
[Link 10]: https://www.javanav.com/val/5a834b46cfd945f7be9c4ea652306fd4.html
[Link 11]: https://www.javanav.com/val/0cea6c7c082043ab83ad87a9c5a48d9d.html
[Link 12]: https://www.javanav.com/interview/93b0069472fd479393006c0e73043fc4.html
[Link 13]: https://www.javanav.com/interview/4147d95e693945e7a50345fd33ec817e.html
[Link 14]: https://www.javanav.com/interview/68a57ffc78de4133bb890bdd502ac418.html
[Link 15]: https://www.javanav.com/interview/36a24fa3258e45c89873f474ce914912.html
[Web]: https://www.javanav.com/interview/4e27cb63adb440c6825a159d35cf4010.html
[Link 16]: https://www.javanav.com/interview/03affb2ce3f04fda8853f714e5764906.html
[Link 17]: https://www.javanav.com/interview/07a32a9ff17a4006a53550ce658cafed.html
[Link 18]: https://www.javanav.com/interview/5c466456e9b54ab0a749b5948e51f1d3.html
[Link 19]: https://www.javanav.com/interview/943f917041ee4f05add24539f5b861b2.html
[Link 20]: https://www.javanav.com/interview/d3f058cfc05d4c6dadd821b622e84d36.html
[Link 21]: https://www.javanav.com/interview/67a50996c28f418e83b109ea42fc3eff.html
[Linux]: https://www.javanav.com/interview/00cccb81729540d1923bd0a0ef49533a.html
[MySQL]: https://www.javanav.com/interview/d311e78502a845f1a4bb307bd6aec2b3.html
[Oracle]: https://www.javanav.com/interview/5f29e9677edf4a16be3dce30d257c9ab.html
[Redis]: https://www.javanav.com/interview/066c62b3af4d4827b2243a822c3084a9.html
[Dubbo]: https://www.javanav.com/interview/9a3e7a7740324757abaab953f7ebc455.html