jdk动态和cglib动态详解
目录
静态
基于继承的方式实现静态
基于聚合的方式实现静态
继承与聚合方式实现的静态对比
动态
JDK动态
如何实现一个HashMap的动态类？
Cglib动态
JDK与Cglib动态对比？
动态和静态的区别？
Spring如何选择两种模式的？
总结
如上图，模式可分为动态和静态，我们比较常用的有动态中的jdk动态和Cglib，像spring框架、hibernate框架中都采用了JDK动态，下面将结合代码阐述两种模式的使用与区别。
静态
静态的对象和被对象在之前就已经确定，它们都实现相同的接口或继承相同的抽象类。静态模式一般由业务实现类和业务类组成，业务实现类里面实现主要的业务逻辑，业务类负责在业务方法调用的前后作一些你需要的处理，如日志记录、权限拦截等功能…实现业务逻辑与业务方法外的功能解耦，减少了对业务方法的入侵。静态又可细分为：基于继承的方式和基于聚合的方式实现。
场景：假设一个预减库存的操作，需要在预减的前后加日志记录（我这里是springboot项目）
基于继承的方式实现静态
/**
* 业务实现类接口
*/
public interface OrderService {
//减库存操作
void reduceStock();
}
/**
* 业务实现类
*/
@Slf4j
public class OrderServiceImpl implements OrderService {
@Override
public void reduceStock() {
try {
log.info("预减库存中……");
Thread.sleep(1000);
}catch (Exception e){
e.printStackTrace();
}
}
}
/**
* 类
*/
@Slf4j
public class OrderServiceLogProxy extends OrderServiceImpl{
@Override
public void reduceStock() {
log.info("预减库存开始……");
super.reduceStock();
log.info("预减库存结束……");
}
}
/**
* 测试继承方式实现的静态
*/
@Test
public void testOrderServiceProxy(){
OrderServiceLogProxy proxy = new OrderServiceLogProxy();
proxy.reduceStock();
}
输出结果
14:53:53.769 [main] INFO com.simons.cn.springbootdemo.proxy.OrderServiceLogProxy - 预减库存开始……
14:53:53.771 [main] INFO com.simons.cn.springbootdemo.proxy.OrderServiceImpl - 预减库存中……
14:53:54.771 [main] INFO com.simons.cn.springbootdemo.proxy.OrderServiceLogProxy - 预减库存结束……
可以看到，OrderServiceLogProxy已经实现了为OrderServiceImpl的，通过类的同名方法来增强了业务方法前后逻辑。
基于聚合的方式实现静态
聚合的意思就是把业务类引入到了类中，接口和业务实现类还是之前的OrderService、OrderServiceImpl，类改为如下：
/**
* 聚合方式实现静态：类中引入业务类
*/
@Slf4j
public class OrderServiceLogProxy2 implements OrderService {
private OrderServiceImpl orderService;
public OrderServiceLogProxy2(OrderServiceImpl orderService) {
this.orderService = orderService;
}
@Override
public void reduceStock() {
log.info("预减库存开始……");
orderService.reduceStock();
log.info("预减库存结束……");
}
}
/**
* 测试聚合方式实现的静态
*/
@Test
public void testOrderServiceProxy2() {
OrderServiceImpl orderService = new OrderServiceImpl();
OrderServiceLogProxy2 proxy2 = new OrderServiceLogProxy2(orderService);
proxy2.reduceStock();
}
测试输出结果和上面的结果是一致的。
继承与聚合方式实现的静态对比
结合上面的代码来看，如果此时需要叠加功能，我不仅要记录预减日志，还要增加权限拦截功能，这个时候如果采用继承的方式的话，就得新建一个类，里面包含日志和权限逻辑；那要是再增加一个功能，又要新增类；如果要改变下功能的执行顺序，还是得增加类，结合上面分析来看，这样做肯定是不妥的。但是如果使用聚合方式的方式呢？我们稍微改造下上面使用的聚合方式实现的静态代码：
首先是日志类代码
/**
* 聚合方式实现静态--日志记录功能叠加改造
*/
@Slf4j
public class OrderServiceLogProxy3 implements OrderService {
//注意，这里换成了接口
private OrderService orderService;
public OrderServiceLogProxy3(OrderService orderService) {
this.orderService = orderService;
}
@Override
public void reduceStock() {
log.info("预减库存开始……");
orderService.reduceStock();
log.info("预减库存结束……");
}
}
然后是新增的权限验证类代码
/**
* 聚合方式实现静态--日志记录功能叠加改造
*/
@Slf4j
public class OrderServicePermissionProxy implements OrderService {
//注意，这里换成了接口
private OrderService orderService;
public OrderServicePermissionProxy(OrderService orderService) {
this.orderService = orderService;
}
@Override
public void reduceStock() {
log.info("权限验证开始……");
orderService.reduceStock();
log.info("权限验证结束……");
}
}
测试用例
/**
* 测试聚合方式实现的静态-功能叠加
*/
@Test
public void testOrderServiceProxy3() {
OrderServiceImpl orderService = new OrderServiceImpl();
OrderServiceLogProxy2 logProxy2 = new OrderServiceLogProxy2(orderService);
OrderServicePermissionProxy permissionProxy = new OrderServicePermissionProxy(logProxy2);
permissionProxy.reduceStock();
}
测试结果
16:00:28.348 [main] INFO com.simons.cn.springbootdemo.proxy.OrderServicePermissionProxy - 权限验证开始……
16:00:28.365 [main] INFO com.simons.cn.springbootdemo.proxy.OrderServiceLogProxy2 - 预减库存开始……
16:00:28.365 [main] INFO com.simons.cn.springbootdemo.proxy.OrderServiceImpl - 预减库存中……
16:00:29.365 [main] INFO com.simons.cn.springbootdemo.proxy.OrderServiceLogProxy2 - 预减库存结束……
16:00:29.365 [main] INFO com.simons.cn.springbootdemo.proxy.OrderServicePermissionProxy - 权限验证结束……
接下来，如果你需要调换一下类逻辑执行顺序问题，你只需要在使用（像测试一样）时调换一下实例化顺序即可实现日志功能和权限验证的先后执行顺序了，而不需要像继承方式一样去不断的新建类。
动态
看完上面的静态，我们发现，静态模式的类，只是实现了特定类的，比如上面OrderServiceLogProxy实现的OrderServiceimpl的，如果我还有个UserService也许要日志记录、权限校验功能，又得写双份的UserServiceLogProxy、UserServicePermissionProxy类，里面的逻辑很多都是相同的，也就是说你类对象的方法越多，你就得写越多的重复的代码，那么有了动态就可以比较好的解决这个问题，动态就可以动态的生成类，实现对不同类下的不同方法的。
JDK动态
jdk动态是利用反射机制生成一个实现接口的匿名类，在调用业务方法前调用InvocationHandler处理。类必须实现InvocationHandler接口，并且，JDK动态只能实现了接口的类，没有实现接口的类是不能实现JDK动态。结合下面代码来看就比较清晰了。
import lombok.extern.slf4j.Slf4j;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* JDK动态实现，必须实现InvocationHandler接口
* InvocationHandler可以理解为事务处理器，所有切面级别的逻辑都在此完成
*/
@Slf4j
public class DynamicLogProxy implements InvocationHandler {
//需要的对象类
private Object target;
public DynamicLogProxy(Object target) {
this.target = target;
}
/**
* @param obj 对象
* @param method 对象方法
* @param args 方法参数
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object obj, Method method, Object[] args) throws Throwable {
log.info("这里是日志记录切面，日志开始……");
//使用方法的反射
Object invoke = method.invoke(target, args);
log.info("这里是日志记录切面，日志结束……");
return invoke;
}
}
使用时代码
/**
* 测试JDK动态实现的日志类
*/
@Test
public void testDynamicLogProxy() {
OrderServiceImpl orderService = new OrderServiceImpl();
Class<?> clazz = orderService.getClass();
DynamicLogProxy logProxyHandler = new DynamicLogProxy(orderService);
//通过Proxy.newProxyInstance(类加载器, 接口s, 事务处理器Handler) 加载动态
OrderService os = (OrderService) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), logProxyHandler);
os.reduceStock();
}
输出结果
16:35:54.584 [main] INFO com.simons.cn.springbootdemo.proxy.DynamicLogProxy - 这里是日志记录切面，日志开始……
16:35:54.587 [main] INFO com.simons.cn.springbootdemo.proxy.OrderServiceImpl - 预减库存中……
16:35:55.587 [main] INFO com.simons.cn.springbootdemo.proxy.DynamicLogProxy - 这里是日志记录切面，日志结束……
使用JDK动态类基本步骤：
1、编写需要被的类和接口（我这里就是OrderServiceImpl、OrderService）；
2、编写类（例如我这里的DynamicLogProxy），需要实现InvocationHandler接口，重写invoke方法；
3、使用Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)动态创建类对象，通过类对象调用业务方法。
那么这个时候，如果我需要在类中叠加功能，该如何是好？比如不仅要日志，还新增权限认证，思路还是上面的聚合方式实现静态里的那样，贴下代码，先新增权限认证类
import lombok.extern.slf4j.Slf4j;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* 基于JDK动态实现的权限认证类
*/
@Slf4j
public class DynamicPermissionProxy implements InvocationHandler{
private Object target;
public DynamicPermissionProxy(Object target) {
this.target = target;
}
/**
* @param obj 对象
* @param method 对象方法
* @param args 方法参数
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object obj, Method method, Object[] args) throws Throwable {
log.info("这里是权限认证切面，开始验证……");
Object invoke = method.invoke(target,args);
log.info("这里是权限认证切面，结束验证……");
return invoke;
}
}
然后使用时候，需要稍微改动下
/**
* 测试JDK动态实现的日志、权限功能类
*/
@Test
public void testDynamicLogAndPermissProxy() {
OrderServiceImpl orderService = new OrderServiceImpl();
Class<?> clazz = orderService.getClass();
DynamicLogProxy logProxyHandler = new DynamicLogProxy(orderService);
OrderService os = (OrderService) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), logProxyHandler);
//注：这里把日志类实例对象传入权限认证类中
DynamicPermissionProxy dynamicPermissionProxy = new DynamicPermissionProxy(os);
OrderService os2 = (OrderService)Proxy.newProxyInstance(os.getClass().getClassLoader(),os.getClass().getInterfaces(),dynamicPermissionProxy);
os2.reduceStock();
}
如上即可，后面还需要叠加功能类的话，按照上面的思路依次传入对象实例即可。
如何实现一个HashMap的动态类？
public class HashMapProxyTest {
public static void main(String[] args) {
final HashMap<String, Object> hashMap = new HashMap<>();
Map<String, Object> mapProxy = (Map<String, Object>) Proxy.newProxyInstance(HashMap.class.getClassLoader(), HashMap.class.getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return method.invoke(hashMap, args);
}
});
mapProxy.put("key1", "value1");
System.out.println(mapProxy);
}
}
Cglib动态
cglib是针对类来实现的，它会对目标类产生一个子类，通过方法拦截技术对过滤父类的方法调用。子类需要实现MethodInterceptor接口。另外，如果你是基于Spring配置文件形式开发，那你需要显示声明：
<aop:aspectj-autoproxy proxy-target-class="true"/>
如果你是基于SpringBoot开发，则一般在启动类头部显示的添加注解
@EnableAspectJAutoProxy(proxyTargetClass = true)
import lombok.extern.slf4j.Slf4j;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* 基于Cglib方式实现动态-日志功能
* 它是针对类实现的，类不用实现接口，CGlib对目标类产生一个子类，通过方法拦截技术拦截所有的方法调用
*/
@Slf4j
public class DynamicCglibLogProxy implements MethodInterceptor {
private Enhancer enhancer = new Enhancer();
public Object getProxyObj(Class clazz) {
//设置父类
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
enhancer.setUseCache(false);
return enhancer.create();
}
/**
* 拦截所有目标类的方法调用
*
* @param o 目标对象
* @param method 目标方法
* @param args 方法参数
* @param methodProxy 类实例
* @return
* @throws Throwable
*/
@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
log.info("这里是日志记录切面，日志开始……");
//类对象实例调用父类方法
Object result = methodProxy.invokeSuper(o, args);
log.info("这里是日志记录切面，日志结束……");
return result ;
}
}
测试用例
/**
* 测试Cglib实现的动态-日志功能
*/
@Test
public void testGclibDynamicLogProxy(){
DynamicCglibLogProxy dynamicCglibLogProxy = new DynamicCglibLogProxy();
OrderServiceImpl orderService = (OrderServiceImpl)dynamicCglibLogProxy.getProxyObj(OrderServiceImpl.class);
orderService.reduceStock();
}
输出结果
17:41:07.007 [main] INFO com.simons.cn.springbootdemo.proxy.DynamicCglibLogProxy - 这里是日志记录切面，日志开始……
17:41:07.038 [main] INFO com.simons.cn.springbootdemo.proxy.OrderServiceImpl - 预减库存中……
17:41:08.038 [main] INFO com.simons.cn.springbootdemo.proxy.DynamicCglibLogProxy - 这里是日志记录切面，日志结束……
JDK与Cglib动态对比？
1、JDK动态只能实现了接口的类，没有实现接口的类不能实现JDK的动态；
2、Cglib动态是针对类实现的，运行时动态生成被类的子类拦截父类方法调用，因此不能声明为final类型的类和方法；
动态和静态的区别？
1、静态在前就知道要的是哪个对象，而动态是运行时才知道；
2、静态一般只能一个类，而动态能实现了接口的多个类；
Spring如何选择两种模式的？
1、如果目标对象实现了接口，则默认采用JDK动态；
2、如果目标对象没有实现接口，则使用Cglib；
3、如果目标对象实现了接口，但强制使用了Cglib，则使用Cglib进行
我们可以结合源码来看下，上面的选择：
补充
Cglib实现的MethodInterceptor接口在spring-core包下，你可能需要要引入
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.1.0.RELEASE</version>
</dependency>
@Slf4j是lombok里提供的，而且如果你在intellij idea开发工具中使用还需要安装lombok插件
@Test是Junit包下的，你可能需要引入
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
总结
本篇文章就到这里了，希望可以给你带来一些帮助，也希望您能够多多关注无名的更多内容！