Spirng之静态代理、动态代理、以及cglib代理

Proxy,表示代理!提供了对目标对象另外的访问方式,即通过代理访问目标对象

一、静态代理

特点：

         1.目标对象必须要实现接口

         2.代理对象要实现与目标对象一样的接口

缺点:

         1.代理对象，需要依赖目标对象的接口! 如果接口功能变化，目标对象变化，会引入代理对象的变化!

         2.对每一个目标对象，都要分别写一个代理类，麻烦！

静态代理的代码测试：

package spring_ioc.d_static;
public interface IUserDao {
	void find();
	void save();
}

package spring_ioc.d_static;
public class UserDao implements IUserDao {
	@Override
	public void find() {
		// TODO Auto-generated method stub
			System.out.println("模拟:保存用户!");
	}
	@Override
	public void save() {
		// TODO Auto-generated method stub
			System.out.println("模拟:查询用户!");
	}
}

package spring_ioc.d_static;
//静态代理:代理对象需要实现与目标对象一样的接口
public class UserDaoProxy implements IUserDao{
	//代理对象的内部维护了一个目标对象
	private IUserDao target = new UserDao();
	@Override
	public void find() {
		// TODO Auto-generated method stub
		target.find();
	}
	@Override
	public void save() {
		// TODO Auto-generated method stub
		System.out.println("代理对象的操作:事务开启!");
		target.save();
		System.out.println("代理对象的操作:事务提交!");
	}
	public static void main(String[] args) {
		UserDaoProxy proxy = new UserDaoProxy();
		proxy.save();
	}
}

测试结果:

二、动态代理

1. 通常说的动态代理,就是指jdk代理!因为是通过jdk的api在运行时期动态的生成代理对象的!

2.目标对象一定要实现接口,代理对象不用实现接口!

JDK生成代理对象的Api:

static Object

newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

参数loader :

当前目标对象使用的类加载器！

参数interfaces : 

当前目标对象实现的接口

参数 h:

接口类型，事件处理器

当执行目标对象方法的时候，会触发事件； 把当前执行的方法(method对象),传入事件处理器方法参数中,  这样就可以根据业务逻辑,判断是否执行目标对象方法或扩展功能！
代码测试：

package spring_ioc.e_dynamic;
public interface IUserDao {
	void find();
	void sava();
}

package spring_ioc.e_dynamic;
public class UserDao implements IUserDao {
	@Override
	public void find() {
		// TODO Auto-generated method stub
			System.out.println("模拟:查询用户!");
	}
	@Override
	public void sava() {
		// TODO Auto-generated method stub
			System.out.println("模拟:保存用户!");
	}
}

package spring_ioc.e_dynamic;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//代理工厂给多个目标对象生成代理对象
public class ProxyFactory {
	//接收一个目标对象
	private Object target;
	public ProxyFactory(Object target) {
		this.target = target;
	}
	//返回对目标对象target代理后的对象(proxy)
	public Object getProxyInstance(){
		Object proxy = Proxy.newProxyInstance(
				target.getClass().getClassLoader(),//目标对象使用的类加载器
				target.getClass().getInterfaces(),//目标对象实现的所有接口
				new InvocationHandler() {//执行代理对象方法的时候触发
					@Override
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {
						// TODO Auto-generated method stub
						//获取当前执行方法的方法名
						String methodName = method.getName();
						//方法的返回值
						Object result = null;
						//判断
						if("find".equals(methodName)){
							//直接调用目标对象的方法
							result = method.invoke(target, args);
						}else{
							System.out.println("开启事务!");
							//执行目标对象的方法
							result = method.invoke(target, args);
							System.out.println("提交事务!");
						}
						return result;
					}
				}
		);						
			return proxy;				
	}
}

package spring_ioc.e_dynamic;
public class App {
	public static void main(String[] args) {
		//创建目标对象
		IUserDao target = new UserDao();
		System.out.println("目标对象:"+target.getClass());//目标对象:class spring_ioc.e_dynamic.UserDao
		
		//创建代理对象
		IUserDao proxyInstance = (IUserDao)new ProxyFactory(target).getProxyInstance();
		System.out.println("代理对象:"+proxyInstance.getClass());//代理对象:class $Proxy0
		
		//执行代理对象的方法
		proxyInstance.find();//模拟:查询用户!
		
		proxyInstance.sava();
		/*
		 * 	开启事务!
			模拟:保存用户!
			提交事务!
		 */
	}
}

测试结果:

三、cglib代理

cglib代理也叫”子类代理”

如果目标对象没有实现接口,就不能使用jdk提供的代理,可以以子类的方式实现!

在运行时期动态在内存中构建一个子类对象的方法,从而对目标对象扩展,这种就是cglib代理!

Spring也支持cglib代理,核心包中已经包含此功能!

l  JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类，就可以使用CGLIB实现。

l   CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他    们提供方法的interception（拦截）。

l   CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

如：

         public class UserDao {}

       public  class  $Cglib_my_class  extends  UserDao {}

代码测试：

package spring_ioc.f_cglib;
public interface IUserDao {
	void find();
	void save();
}

package spring_ioc.f_cglib;
public class UserDao implements IUserDao {
	@Override
	public void find() {
		// TODO Auto-generated method stub
			System.out.println("模拟:保存用户!");
	}
	@Override
	public void save() {
		// TODO Auto-generated method stub
			System.out.println("模拟:查询用户!");
	}
}

package spring_ioc.f_cglib;
import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodProxy;
//cglib代理:代理工厂给多个目标对象生成代理对象
public class ProxyFactory implements org.springframework.cglib.proxy.MethodInterceptor{
	//接收一个目标对象
	private static Object target;
	public ProxyFactory(Object target) {
		this.target = target;
	}
	//返回对目标对象target代理后的子类对象
	public Object getProxyInstance(){
	//对目标对象target生成子类对象
	//字节码生成工具类
		Enhancer en = new Enhancer();
	//设置父类
		en.setSuperclass(target.getClass());
	//设置回调函数
		en.setCallback(this);
	//创建子类对象
		return en.create();
	}
	@Override
	public Object intercept(Object arg0, Method arg1, Object[] arg2,
			MethodProxy arg3) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("开启事务！");
		Object result = arg1.invoke(target, arg2);
		System.out.println("提交事务！");
		return result;
	}
}

package spring_ioc.f_cglib;
public class App {
	public static void main(String[] args) {
		//创建目标对象
		UserDao target = new UserDao();
		System.out.println("目标对象:"+target.getClass());
		
		//代理对象
		UserDao proxy = (UserDao)new ProxyFactory(target).getProxyInstance();
		System.out.println("代理对象:"+proxy.getClass());
		
		//执行代理对象的方法
		proxy.save();
	}
}

测试结果:

总结：

         1.目标对象可以不实现接口

         2.目标类不能为final，如果为final报错

         3.方法如果为final/static, 不会被代理拦截!会直接执行目标对象方法!

代理总结:

在SpringAop编程中,

         如果目标对象有实现接口,spring使用jdk提供的代理生成代理对象!

         如果目标对象没有实现接口,使用cglib代理!

         如果目标没有实现接口且为final, 不能进行aop编程,报错!不能生成代理!

参考资料:传智播客袁杰老师关于Sping代理的讲解!