CGLIB子类代理和JDK动态代理示例和比较

Cglib代理，也叫做子类代理。在内存中构建一个子类对象从而实现对目标对象功能的扩展。
比较：
JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类，就可以使用CGLIB实现。
CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。
CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。
Cglib子类代理：
1)需要引入cglib – jar文件，但是spring的核心包中已经包括了cglib功能，所以直接添加spring-core的依赖即可

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.3.10.RELEASE</version>
</dependency>

2）引入功能包后，就可以在内存中动态构建子类
3）代理的类不能为final， 否则报错。
4） 目标对象的方法如果为final/static,那么就不会被拦截，即不会执行目标对象额外的业务方法。
在Spring的AOP编程中，
如果加入容器的目标对象有实现接口，用JDK代理；
如果目标对象没有实现接口，用Cglib代理；
下面开始CGLIB代理的示例
先写一个UserDao

package xin.sun.proxy.cglib;

/**
* @author Ginkgo
*/
public class UserDao {

public void save() {
System.out.println("UserDao . save");
}
}

再写一个代理工厂ProxyFactory，实现CGLIB中的MethodInterceptor接口

package xin.sun.proxy.cglib;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
* @author Ginkgo
*/
public class ProxyFactory implements MethodInterceptor {

/**
* 被代理对象
*/
private Object target;

/**
* 构造器
*
* @param target
*/
public ProxyFactory(Object target) {
this.target = target;
}

/**
* 获取代理对象实例
*
* @return Object 代理对象实例
*/
public Object getProxyInstance() {

/**
* 工具类
*/
Enhancer enhancer = new Enhancer();
/**
* 设置父类
*/
enhancer.setSuperclass(target.getClass());
/**
* 设置回调对象
*/
enhancer.setCallback(this);
/**
* 创建子类代理对象，并返回
*/
return enhancer.create();
}

/**
* 重写拦截方法
*
* @param o           代理对象
* @param method      委托类方法
* @param objects     方法参数
* @param methodProxy 代理方法的MethodProxy对象
* @return Object 目标方法执行结果
* @throws Throwable
*/
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

System.out.println("开始事务...");

/**
* 方法执行结果
*/
Object result = method.invoke(target,objects);

System.out.println("结束事务...");

return result;
}
}

再写一个入口类Portal来测试

package xin.sun.proxy.cglib;

/**
* @author Ginkgo
*/
public class Portal {

public static void main(String[] args) {
ProxyFactory proxyFactory = new ProxyFactory(new UserDao());
UserDao proxyInstance = (UserDao) proxyFactory.getProxyInstance();
proxyInstance.save();
}
}

运行结果：

开始事务...
UserDao . save
结束事务...

然后再看看JDK动态代理

先写一个接口IOrderDao和实现类OrderDaoImpl

package xin.sun.proxy.dynamic;

/**
* @author Ginkgo
*/
public interface IOrderDao {

/**
* 保存对象
*
* @param obj
*/
void save(Object obj);
}

-----------------------------------------------------------------------------------------------------

package xin.sun.proxy.dynamic;

/**
* @author Ginkgo
*/
public class OrderDaoImpl implements IOrderDao {
@Override
public void save(Object obj) {
System.out.println("OrderDaoImpl -> save " + obj);
}
}

再写一个代理工厂ProxyFactory，实现InvocationHandler接口

package xin.sun.proxy.dynamic;

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

/**
* @author Ginkgo
*/
public class ProxyFactory implements InvocationHandler {

/**
* 被代理对象
*/
private Object target;

/**
* 构造器
*
* @param target
*/
public ProxyFactory(Object target) {
this.target = target;
}

/**
* desc:获取代理对象
*
* @return java.lang.Object
* @author Ginkgo
*/
public Object getProxyInstance() {

Object proxyInstance = Proxy
.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
return proxyInstance;
}

/**
* 重写调用方法
*
* @param proxy
* @param method
* @param args
* @return Object 方法执行结果
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

System.out.println("开始事务 ...");

Object result = method.invoke(target, args);

System.out.println("结束事务 ...");

return result;
}
}

在写一个Portal入口类测试一下

package xin.sun.proxy.dynamic;

/**
* @author Ginkgo
*/
public class Portal {

public static void main(String[] args) {

ProxyFactory proxyFactory = new ProxyFactory(new OrderDaoImpl());
IOrderDao proxyInstance = (IOrderDao) proxyFactory.getProxyInstance();
proxyInstance.save("test");
}
}

运行结果

开始事务 ...
OrderDaoImpl -> save test
结束事务 ...