Java中的动态代理

前言

 

    学编程离不开设计模式，设计模式中有一个代理模式，最开始学代理模式并不知道它在Java的学习中，占据这么重要的地位，只觉得它是一个设计模式，没有想过它到底怎么用。后来才发现，代理模式是AOP实现的重要原理。

 

JDK的动态代理

 

    JDK的动态代理是对使用接口的类进行代理，它需要真实角色和代理角色。JDK动态代理涉及到java.lang.reflect包中的两个类：Proxy和InvocationHandler。其中InvocationHandler是一个接口，AOP通过实现该接口来定义横切逻辑，并通过反射机制调用目标类，动态的将横切代码切入业务逻辑。Proxy通过InvocationHandler来动态创建一个符合某个接口的实例，生成目标类的代理对象。

 

    JDK的动态代理类要实现InvocationHandler接口，在这个类里面有两个方法一个对象。这个对象是类私有的，表示调用的目标类对象；一个方法新建代理实例，这个方法是Proxy类来创建的，然后把这个目标实例赋给目标类对象，最后这个对象调用invoke方法；另一个方法就是invoke方法，这个方法就是代理类的逻辑，也就是代理类要做的事情。

 

 

public class SecurityHandler implements InvocationHandler {
	//定义调用的目标类对象
	private Object targetObject;
	//创建一个代理实例
	public Object createProxyInstance(Object targetObject) {
		this.targetObject = targetObject;
		return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), 
							   targetObject.getClass().getInterfaces(), 
							   this);
	}
	//代理类的执行过程
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		checkSecurity();
		
		//调用目标方法，代理模式思想的体现
		Object ret = method.invoke(targetObject, args);
		
		return ret;
	}
	//代理类要执行的内容
	private void checkSecurity() {
		System.out.println("-------checkSecurity-------");
	}		
}

 

 

            在Proxy类创建代理实例时，需要传入三个参数，一个是被代理的类，一个是被代理类实现的接口，一个是创建的实例对象。从传入参数即可看出，JDK的动态代理只能对实现接口的类创建代理类。

 

 

//被代理类实现的接口
public interface UserManager {

	public void addUser(String username, String password);
	
	public void delUser(int userId);
	
	public String findUserById(int userId);
	
	public void modifyUser(int userId, String username, String password);
}

//被代理类
public class UserManagerImpl implements UserManager {

	public void addUser(String username, String password) {
		System.out.println("---------UserManagerImpl.add()--------");
	}

	public void delUser(int userId) {
		System.out.println("---------UserManagerImpl.delUser()--------");
	}

	public String findUserById(int userId) {
		System.out.println("---------UserManagerImpl.findUserById()--------");
		return "张三";
	}

	public void modifyUser(int userId, String username, String password) {
		System.out.println("---------UserManagerImpl.modifyUser()--------");
	}
}

 

 

CGLIB的动态代理

    JDK的动态代理只能对实现接口的类创建代理类，那么不实现接口的类呢？这时就需要CGLIB来创建代理类了。CGLIB是对没有实现接口的类创建代理类，同时也能对实现接口的类强制使用CGLIB动态代理。

    CGLIB采用底层的字节码技术，可以为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，实现横切。

 

 

public class CglibProxy implements MethodInterceptor {
	//创建子类的对象
	private Enhancer enhancer = new Enhancer();
	//创建子类
	public Object getProxy(Class class) {
		enhancer.setSuperclass(class); //设置需要创建子类的类
		enhancer.setCallback(this); 
		return enhancer.create(); //通过字节码技术动态创建子类实例
	}

        //拦截父类所有方法的调用
	public Object intercept(Object obj, Method method, Object[] args, 
			MethodProxy proxy) throws Throwable {
		PerformanceMonitor.begin(obj.getClass().getName()+"."+method. getName());
		Object result=proxy.invokeSuper(obj, args);
		PerformanceMonitor.end();//通过代理类调用父类中的方法
		return result;
	}
}

 

 

     通过getProxy方法，传入要需要创建子类的类，然后通过代理对象enhancer的create方法创建子类实例。这个过程不需要被代理类的接口，所以CGLIB可以为不实现接口的类创建代理类。intercept方法则是拦截父类所有方法，加入相应代理类需要执行的内容，然后通过代理类调用父类中的方法。

 

总结

 

    JDK动态代理，不需要另外引入jar包，但是CGLIB实现动态代理，需要引入CGLIB的jar包。一般来说，使用接口编程更为灵活，所以多数会使用JDK实现的动态代理。动态代理是AOP实现的原理，通过动态代理可以实现安全性检查、日志记录、事务处理等等，这些其实也是AOP实现的实例。接触到一个知识点，并不是要局限的看它现在能做什么，而是要用发散性思维来思考，它将来还能做什么，多做这样的训练，才能更好的给知识织网。