Java动态代理一览笔录

public interface GoodsProivder {

	// 提供商品
	public void provider();
}

public class GoodsProivderImpl implements  GoodsProivder{
	@Override
	public void provider() {
		System.out.println("provider goods : Meizu MX6");
	}
}

public class SalesProxy implements GoodsProivder {

	private final GoodsProivder proivder;

	public SalesProxy(GoodsProivder proivder) {
		this.proivder = proivder;
	}

	// 提供商品
	public void provider() {
		System.out.println("欢迎您光临本店，您可以随意浏览和购买，祝您购物愉快...");
		this.proivder.provider();
		System.out.println("欢迎您的光临，再见！...");
	}
}

public class Test {

	public static void main(String[] args) {
		// 这里对于客户而言，销售代理是可见的，厂商是不可见的
		GoodsProivder proxy = new SalesProxy(new GoodsProivderImpl());
		proxy.provider();
	}
}

// 方法 1: 该方法用于获取指定代理对象所关联的调用处理器
static InvocationHandler getInvocationHandler(Object proxy) 
 
// 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象
static Class getProxyClass(ClassLoader loader, Class[] interfaces) 
 
// 方法 3：该方法用于判断指定类对象是否是一个动态代理类
static boolean isProxyClass(Class cl) 
 
// 方法 4： 该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, 
    InvocationHandler h)

// 该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象
// 第三个参数是被调用的方法参数。
Object invoke(Object proxy, Method method, Object[] args)

import io.flysium.standard.proxy.statics.GoodsProivder;

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

/**
 * 销售代理调用器
 *
 * @author Sven Augustus
 */
public class SalesInvocationHandler implements InvocationHandler {

	private Object target; // 委托类对象；

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

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// 这里可以做一下预处理
//		if(!proxy instanceof  GoodsProivder || !"provider".equals(method.getName())) {
//			throw new UnsupportedOperationException("不支持");
//		}
		System.out.println("欢迎您光临本店，您可以随意浏览和购买，祝您购物愉快...");
		Object result = method.invoke(this.target, args);
		System.out.println("欢迎您的光临，再见！...");
		return result;
	}
}

	public static void main(String[] args) {
//		GoodsProivder proxy = new SalesProxy(new GoodsProivderImpl());
		// 利用 功能实现类，以及调用器，生成代理类实例
		GoodsProivder proxy = (GoodsProivder) Proxy.newProxyInstance(GoodsProivder.class.getClassLoader(),
				new Class[]{GoodsProivder.class},
				new SalesInvocationHandler(new GoodsProivderImpl()));
		proxy.provider();
	}

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.5</version>
</dependency>

//设置产生的代理对象的父类
void setSuperclass(java.lang.Class superclass) 。
//设置CallBack接口的实例。一般为 MethodInterceptor
void setCallback(Callback callback) 
//设置多个CallBack接口的实例。一般为 MethodInterceptor
void setCallbacks(Callback[] callbacks) 
//设置方法回调过滤器。
void setCallbackFilter(CallbackFilter filter) 
//使用默认无参数的构造函数创建目标对象。
Object create() 
//使用有参数的构造函数创建目标对象。参数Class[] 定义了参数的类型，第二个Object[]是参数的值。
Object create(Class[], Object[]) 

// 该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是被代理类的对象实例，第二个参数是被调用的方法对象
// 第三个参数是被调用的方法参数，第四个参数是代理类实例。
Object intercept(Object target, Method method, Object[] args, MethodProxy proxy) throws Throwable

import io.flysium.standard.proxy.statics.GoodsProivder;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

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

/**
 * 销售方法拦截器接口
 *
 * @author Sven Augustus
 */
public class SalesMethodInterceptor implements MethodInterceptor {

	@Override
	public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy)
 throws Throwable {
		// 这里可以做一下预处理
//		if(!(target instanceof GoodsProivder) || !"provider".equals(method.getName())) {
//			return null;
//		}
		System.out.println("欢迎您光临本店，您可以随意浏览和购买，祝您购物愉快...");
		//Object result=proxy.invoke(target, args);
		Object result = proxy.invokeSuper(target, args);// 表示调用原始类的被拦截到的方法。
		System.out.println("欢迎您的光临，再见！...");
		return result;
	}
}

public static void main(String[] args) {
//		GoodsProivder proxy = new SalesProxy(new GoodsProivderImpl());
		// 利用 功能实现类，以及调用器，生成代理类实例
//		GoodsProivder proxy = (GoodsProivder) Proxy.newProxyInstance(GoodsProivder.class.getClassLoader(),
//				new Class[]{GoodsProivder.class},
//				new SalesInvocationHandler(new GoodsProivderImpl()));
		// cglib 中加强器
		Enhancer enhancer = new Enhancer();
		// 设置要创建动态代理的类
		enhancer.setSuperclass(GoodsProivderImpl.class);
		// 设置回调，这里相当于是对于代理类上所有方法的调用
		enhancer.setCallback(new SalesMethodInterceptor());
		// 创建动态代理类实例
		GoodsProivder proxy = (GoodsProivder) enhancer.create();
		proxy.provider();
	}

<dependency>
    <groupId>org.javassist</groupId>
    <artifactId>javassist</artifactId>
    <version>3.21.0-GA</version>
</dependency>

// 第一个参数Javassist动态生成的代理类实例，第二个参数是被调用的方法对象
// 第三个参数是为生成的代理类对方法的代理引用，第四个参数是被调用的方法参数
Object invoke(Object self, Method m, Method proceed, Object[] args) throws Throwable

import javassist.util.proxy.MethodHandler;

import java.lang.reflect.Method;

/**
 * @author Sven Augustus
 */
public class SaleMethodHandler implements MethodHandler {

	public Object invoke(Object self, Method m, Method proceed, Object[] args) throws Throwable {
		System.out.println("欢迎您光临本店，您可以随意浏览和购买，祝您购物愉快...");
		//Object result = m.invoke(delegate, args);
		Object result = proceed.invoke(self, args); // execute the original method.
		System.out.println("欢迎您的光临，再见！...");
		return result;
	}
}

public static void main(String[] args) throws IllegalAccessException, InstantiationException {
		ProxyFactory f = new ProxyFactory();
		// 设置被代理类
		f.setSuperclass(GoodsProivderImpl.class);
		// 设置方法过滤器
		f.setFilter(new MethodFilter() {
			public boolean isHandled(Method m) {
				// ignore finalize()
				return !m.getName().equals("finalize");
			}
		});
		// 创建代理类
		Class c = f.createClass();
		GoodsProivder proxy = (GoodsProivder) c.newInstance();
		// 设置方法调用处理器
		((Proxy) proxy).setHandler(new SaleMethodHandler());
		proxy.provider();
	}

Create JDK Proxy: 9 ms
Create CGLIB Proxy: 140 ms
Create JAVAASSIST Proxy: 62 ms
Create JAVAASSIST Bytecode Proxy: 98 ms
----------------
Run JDK Proxy Average: 776.0 ms
Run CGLIB Proxy Average: 223.4 ms
Run JAVAASSIST Proxy Average: 828.8 ms
Run JAVAASSIST Bytecode Proxy Average: 76.0 ms

Create JDK Proxy: 19 ms
Create CGLIB Proxy: 256 ms
Create JAVAASSIST Proxy: 124 ms
Create JAVAASSIST Bytecode Proxy: 127 ms
----------------
Run JDK Proxy Average: 117.6 ms
Run CGLIB Proxy Average: 129.2 ms
Run JAVAASSIST Proxy Average: 259.4 ms
Run JAVAASSIST Bytecode Proxy Average: 76.2 ms