动态代理Proxy

动态代理：个人理解，通过第三方创建你想要的对象，由第三方管理你的对象。且你想执行对象的方法，也会有一个类似于（真正方法执行前和后都有）拦截器的功能，在执行你需要调用的方法的前后做一些操作。

需要理解两个类：

Proxy：可以理解为第三方，相当于把你想创建的类的外面进行了一个封装，你想创建一个类的实例对象，你告诉Proxy一些类的信息：这个类实现了哪些接口（数组对象），被代理的对象一定要实现某一个或多个接口（这也是动态代理的缺陷之一），以及这个类的处理对象（接口实现类）。然后由Proxy来帮你创建并在这个类的方法前后加了一些自己的想法（aop），最后把这个实例对象返回给你。

 

api：

Proxy.newProxyInstance（ClassLoader，Class<?>[] interfaces, InvocationHandler h）

参数解释：

ClassLoader:创建一个类的实例对象，必须要先加载这个类，加载类需要类加载器，这个类加载器随便获取一个就行， 没有要求.

interfaces：这是一个类对象数组。表示被代理的类所实现的接口有哪些。

InvocationHandler: 想象成一个执行者，你想执行对象的某个方法，但是线程其实并没有直接执行这个方法，而是告诉这个执行者，我要执行这个方法。那么这个方法怎么执行？，这个问题由执行者对象，也就是这个参数对象的功能。实际上执行的是InvocationHandler对象的invoke（）方法。ok，再想，执行者要执行一个方法需要哪些信息才能执行呢？三点，调用方法的是谁，是调用那个方法，这个方法有哪些参数。那么这三个就是我们定义自己的InvocationHandler类时重写invoke方法要处理的三个参数，invoke（Object arg0, Method method, Object[] arg2）。

 

例子：代理service类，同时加上事务管理

//接口类

package cn.itcast.service;

public interface UserService {
	void save();
	void delete();
	void update();
	void find();
}


//实现类
package cn.itcast.service;

public class UserServiceImpl implements UserService {
	@Override
	public void save() {
		System.out.println("保存用户!");
		//int i = 1/0;
	}
	@Override
	public void delete() {
		System.out.println("删除用户!");
	}
	@Override
	public void update() {
		System.out.println("更新用户!");
	}
	@Override
	public void find() {
		System.out.println("查找用户!");
	}
}

//InvocationHandler类

public class UserServiceProxyFactory implements InvocationHandler {
	
	public UserServiceProxyFactory(UserService us) {
		super();
		this.us = us;
	}

	private UserService us;
	
	public UserService getUserServiceProxy(){
		//生成动态代理
		UserService usProxy = (UserService) Proxy.newProxyInstance(UserServiceProxyFactory.class.getClassLoader(),
									UserServiceImpl.class.getInterfaces(), 
									this);
		//返回
		return usProxy;
		
	}

	@Override
	public Object invoke(Object arg0, Method method, Object[] arg2) throws Throwable {
		System.out.println("打开事务!");
		Object invoke = method.invoke(us, arg2);
		System.out.println("提交事务!");
		return invoke;
	}

}

//测试类
public class Demo {
	
	@Test
	//动态代理
	public void fun1(){
		UserService us = new UserServiceImpl();
		
		UserServiceProxyFactory factory = new UserServiceProxyFactory(us);
		
		UserService usProxy = factory.getUserServiceProxy();
		
		usProxy.save();
		
		//代理对象与被代理对象实现了相同的接口
		//代理对象 与 被代理对象没有继承关系
		System.out.println(usProxy instanceof UserServiceImpl );//false
	}
	
	@Test
	public void fun2(){
		
		UserServiceProxyFactory2 factory = new UserServiceProxyFactory2();
		
		UserService usProxy = factory.getUserServiceProxy();
		
		usProxy.save();
		
		//判断代理对象是否属于被代理对象类型
		//代理对象继承了被代理对象=>true
		System.out.println(usProxy instanceof UserServiceImpl );//true
	}
}

备注：在demo创建InvocationHandler类对象时候，要将实现类对象传入，这样invock方法在开启事务后执行的操作才知道要执行具体哪个实现类的操作。接口的方法没有实现类。

 

 

个人觉得比较好理解的动态代理的例子：http://www.importnew.com/27772.html