一、代理模式介绍
代理模式是设计模式的一种，它提供了一种对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改原目标对象的前提下，提供额外的功能操作，拓展目标对象的功能。
模型
代理模式通常分为静态代理和动态代理，Spring中的AOP（面向切面编程）的实现就是依赖于动态代理，动态代理又可分为JDK动态代理和cglib动态代理。
二、静态代理
要求：静态代理需要代理对象和目标对象实现一样的接口。
优点：可以在不修改目标对象的前提下拓展目标对象的功能。
缺点：
- 代理类冗余：由于代理对象需要和目标对象实现一致的接口，会产生过多的代理类。
- 不易维护：一旦接口增加方法，目标对象也需要进行修改。
示例：
1.接口Waiter
public interface Waiter {
public void serve();
}
2.目标对象MyWaiter
public class MyWaiter implements Waiter{
public void serve() {
System.out.println("服务了。。。");
}
}
3.代理对象WaiterPoxy
public class WaiterPoxy implements Waiter{
Waiter waiter; //代理对象的类型已经明确为Waiter类型
public WaiterPoxy(Waiter waiter) {
super();
this.waiter = waiter;
}
public void serve() {
System.out.println("start....");
waiter.serve();
System.out.println("end....");
}
}
4.测试类TestProxy
public class TestProxy {
public static void main(String[] args) {
Waiter waiter = new WaiterPoxy(new MyWaiter());
waiter.serve();
}
}
5.输出结果
start....
服务了。。。
end....
三、JDK动态代理
JDK动态代理利用了JDK API，动态地在内存中构建代理对象，从而实现对目标对象的代理功能。动态代理又被称为JDK代理或接口代理。
静态代理与动态代理的区别主要在：
静态代理在编译时就已经实现，编译完成后代理类是一个实际的class文件
动态代理是在运行时动态生成的，即编译完成后没有实际的class文件，而是在运行时动态生成类字节码，并加载到JVM中
特点：
动态代理对象不需要实现接口，但是要求目标对象必须实现接口，否则不能使用动态代理。
JDK中生成代理对象主要涉及的类有：
- java.lang.reflect Proxy，主要方法为
static Object newProxyInstance(ClassLoader loader, //指定当前目标对象使用类加载器
Class<?>[] interfaces, //目标对象实现的接口的类型
InvocationHandler h //事件处理器
)
//返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
Object invoke(Object proxy, Method method, Object[] args)
// 在代理实例上处理方法调用并返回结果。
示例
1.接口类：Waiter
public interface Waiter {
public void serve();
}
2.目标对象MyWaiter
public class MyWaiter implements Waiter{
public void serve() {
System.out.println("1号服务了。。。。。。。。。。。。。");
}
}
3.动态代理对象
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class TestProxy {
public static void main(String[] args) {
ClassLoader loader = TestProxy.class.getClassLoader(); //类加载器
Class[] cs = {Waiter.class}; //等待代理的类的接口
Waiter target = new MyWaiter(); //待代理对象
MyInvocationHandler h = new MyInvocationHandler(target);//调用处理器
Waiter waiter = (Waiter)Proxy.newProxyInstance(loader, cs, h);
waiter.serve();
//以内部类的形式缩写成以下形式
// Proxy.newProxyInstance(TestProxy.class.getClassLoader(), new Class[]{Waiter.class}, new InvocationHandler() {
//
// public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// System.out.println("Hello!"); //增强内容
// Object result = method.invoke(target1, args); //调用对象的方法
// System.out.println("Bye!"); //增强内容
// return result;
// }
// });
}
}
/**
* 调用处理器，定义对代理对象的增强内容
* @author 86156
*
*/
class MyInvocationHandler implements InvocationHandler{
private Object target; //待代理对象为Object类型，表示可以代理所有的类
public MyInvocationHandler(Object target) {
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Hello!"); //增强内容
Object result = method.invoke(target, args); //调用对象的方法
System.out.println("Bye!"); //增强内容
return result;
}
}
四、cglib动态代理
cglib (Code Generation Library )是一个第三方代码生成类库，运行时在内存中动态生成一个子类对象从而实现对目标对象功能的扩展。
cglib特点
- JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。
如果想代理没有实现接口的类，就可以使用CGLIB实现。 - CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。
它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。 - CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。
不鼓励直接使用ASM，因为它需要你对JVM内部结构包括class文件的格式和指令集都很熟悉。
cglib与动态代理最大的区别就是
- 使用动态代理的对象必须实现一个或多个接口
- 使用cglib代理的对象则无需实现接口，达到代理类无侵入。
使用cglib需要引入cglib的jar包，如果你已经有spring-core的jar包，则无需引入，因为spring中包含了cglib。
- cglib的Maven坐标
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.2.5</version>
</dependency>
- 示例：保存用户功能的动态代理实现
1.目标对象：UserDao
public class UserDao{
public void save() {
System.out.println("保存数据");
}
}
2.代理对象：ProxyFactory
import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class ProxyFactory implements MethodInterceptor{
private Object target;//维护一个目标对象
public ProxyFactory(Object target) {
this.target = target;
}
//为目标对象生成代理对象
public Object getProxyInstance() {
//工具类
Enhancer en = new Enhancer();
//设置父类
en.setSuperclass(target.getClass());
//设置回调函数
en.setCallback(this);
//创建子类对象代理
return en.create();
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("开启事务");
// 执行目标对象的方法
Object returnValue = method.invoke(target, args);
System.out.println("关闭事务");
return null;
}
}
3.测试类：TestProxy
import org.junit.Test;
public class TestProxy {
@Test
public void testCglibProxy(){
//目标对象
UserDao target = new UserDao();
System.out.println(target.getClass());
//代理对象
UserDao proxy = (UserDao) new ProxyFactory(target).getProxyInstance();
System.out.println(proxy.getClass());
//执行代理对象方法
proxy.save();
}
}
4.输出结果
class com.cglib.UserDao
class com.cglib.UserDao$$EnhancerByCGLIB$$552188b6
开启事务
保存数据
关闭事务
五、总结
- 静态代理实现较简单，只要代理对象对目标对象进行包装，即可实现增强功能，但静态代理只能为一个目标对象服务，如果目标对象过多，则会产生很多代理类。
- JDK动态代理需要目标对象实现业务接口，代理类只需实现InvocationHandler接口。
- 动态代理生成的类为 lass com.sun.proxy.$Proxy4，cglib代理生成的类为class com.cglib.UserDao$$EnhancerByCGLIB$$552188b6。
- 静态代理在编译时产生class字节码文件，可以直接使用，效率高。
- 动态代理必须实现InvocationHandler接口，通过反射代理方法，比较消耗系统性能，但可以减少代理类的数量，使用更灵活。
- cglib代理无需实现接口，通过生成类字节码实现代理，比反射稍快，不存在性能问题，但cglib会继承目标对象，需要重写方法，所以目标对象不能为final类。
