转载:http://www.iteye.com/topic/801577
很多同学提出,因中文文档缺乏,导致对文章中的介绍看的不是很明白,更多的只是想了解具体的使用即可。所以趁势写了这篇博文,主要是将cglib中的几个工具类和常用的Reflect ,BeanUtils做一个对比,顺便也介绍一下cglib的相关用法,一举两得,望大家多多支持。
正题:
1. 首先定义一份Pojo Bean ,后续的测试主要围绕这个进行。
- public static class CopyBean {
- private int intValue;
- private boolean boolValue;
- private float floatValue;
- private double doubleValue;
- private long longValue;
- private char charValue;
- private byte byteValue;
- private short shortValue;
- private Integer integerValue;
- private Boolean boolObjValue;
- private Float floatObjValue;
- private Double doubleObjValue;
- private Long longObjValue;
- private Short shortObjValue;
- private Byte byteObjValue;
- private BigInteger bigIntegerValue;
- private BigDecimal bigDecimalValue;
- private String stringValue;
- ......// 一堆的setter/getter方法
- }
说明: 该copyBean基本包含了java的所有原型对象,基本对象,和常用的BigDecimal,BigInteger,总共17个属性。
2. 定义测试模板 (模板模式)
定义一个TestCallback接口。
- interface TestCallback {
- String getName();
- CglibPerformanceTest.CopyBean call(CglibPerformanceTest.CopyBean source);
- }
定义测试的模板方法
private static final DecimalFormat integerFormat = new DecimalFormat("#,###");
- public static void testTemplate(TestCallback callback, CopyBean source, int count) {
- int warmup = 10;
- // 先进行预热,加载一些类,避免影响测试
- for (int i = 0; i < warmup; i++) {
- callback.call(source);
- }
- restoreJvm(); // 进行GC回收
- // 进行测试
- long start = System.nanoTime();
- for (int i = 0; i < count; i++) {
- callback.call(source);
- }
- long nscost = (System.nanoTime() - start);
- System.out.println(callback.getName() + " total cost=" + integerFormat.format(nscost) + "ns , each cost="
- + nscost / count + "ns");
- restoreJvm();// 进行GC回收
- }
说明:
- 为了测试更加精确,避免因为在一次的循环中进行处理,jvm内存,GC,Class装载对测试的影响,有一个warmup的过程,先执行少量的测试方法,这里是执行10次
- 避免jvm内存GC对测试id影响,这里有restoreJvm强制进行一次jvm GC
restoreJvm相关方法:
private static void restoreJvm() {
- int maxRestoreJvmLoops = 10;
- long memUsedPrev = memoryUsed();
- for (int i = 0; i < maxRestoreJvmLoops; i++) {
- System.runFinalization();
- System.gc();
- long memUsedNow = memoryUsed();
- // 如果多次GC后内存稳定了,就退出
- if ((ManagementFactory.getMemoryMXBean().getObjectPendingFinalizationCount() == 0)
- && (memUsedNow >= memUsedPrev)) {
- break;
- } else {
- memUsedPrev = memUsedNow;
- }
- }
- }
- private static long memoryUsed() {
- Runtime rt = Runtime.getRuntime();
- return rt.totalMemory() - rt.freeMemory();
- }
3. 准备原始的CopyBean数据
- private static CopyBean getBean() {
- CopyBean bean = new CopyBean();
- bean.setIntValue(1);
- bean.setBoolValue(false);
- bean.setFloatValue(1.0f);
- bean.setDoubleValue(1.0d);
- bean.setLongValue(1l);
- bean.setCharValue('a');
- bean.setShortValue((short) 1);
- bean.setByteValue((byte) 1);
- bean.setIntegerValue(new Integer("1"));
- bean.setBoolObjValue(new Boolean("false"));
- bean.setFloatObjValue(new Float("1.0"));
- bean.setDoubleObjValue(new Double("1.0"));
- bean.setLongObjValue(new Long("1"));
- bean.setShortObjValue(new Short("1"));
- bean.setByteObjValue(new Byte("1"));
- bean.setBigIntegerValue(new BigInteger("1"));
- bean.setBigDecimalValue(new BigDecimal("1"));
- bean.setStringValue("1");
- return bean;
- }
4. 执行相关测试
测试环境说明:
- 操作系统 Linux ccbu-156-49 2.6.18-131.el5.customxen #1 SMP Tue Sep 15 15:46:11 CST 2009 x86_64 x86_64 x86_64 GNU/Linux
- 虚拟8cpu , 5G内存
- jdk 1.6.0_18
- jvm 参数
-
- -server -Xmx2g -Xms2g -Xmn512m -XX:PermSize=196m -Xss256k -XX:+UseConcMarkSweepGC -XX:+CMSParallelRemarkEnabled -XX:+UseCMSCompactAtFullCollection -XX:LargePageSizeInBytes=128m -XX:+UseFastAccessorMethods -XX:+UseCMSInitiatingOccupancyOnly -XX:CMSInitiatingOccupancyFraction=70
第一测试主要是一个对象的全部属性进行拷贝
- BeanCopier (cglib)
- PropertyUtils (apache-common)
- BeanUtils (apache-common)
1. BeanCopier (cglib)
-
- // beanCopier测试
- final BeanCopier beanCopier = BeanCopier.create(CopyBean.class, CopyBean.class, false);
- final CopyBean beanCopierTarget = new CopyBean();//new一次,避免new对象产生的代价影响测试结果
- testTemplate(new TestCallback() {
- public String getName() {
- return "BeanCopier";
- }
- public CopyBean call(CopyBean source) {
- beanCopier.copy(source, beanCopierTarget, null);
- return beanCopierTarget;
- }
- }, bean, testCount);
2. PropertyUtils (apache-common)
-
- <span style="background-color: rgba(0, 0, 0, 0);">// PropertyUtils测试
- final CopyBean propertyUtilsTarget = new CopyBean();
- testTemplate(new TestCallback() {
- public String getName() {
- return "PropertyUtils";
- }
- public CopyBean call(CopyBean source) {
- try {
- PropertyUtils.copyProperties(propertyUtilsTarget, source);
- } catch (Exception e) {
- e.printStackTrace();
- }
- return propertyUtilsTarget;
- }
- }, bean, testCount);</span>
3. BeanUtils (apache-common)
-
- <span style="background-color: rgba(0, 0, 0, 0);">// BeanUtils测试
- final CopyBean beanUtilsTarget = new CopyBean();
- testTemplate(new TestCallback() {
- public String getName() {
- return "BeanUtils";
- }
- public CopyBean call(CopyBean source) {
- try {
- BeanUtils.copyProperties(beanUtilsTarget, source);
- } catch (Exception e) {
- e.printStackTrace();
- }
- return beanUtilsTarget;
- }
- }, bean, testCount);</span>
测试结果:
测试次数:testCount = 1000 * 1000 = 100万次
- BeanCopier total cost=36,626,000ns , each cost=36ns
- PropertyUtils total cost=18,173,767,000ns , each cost=18173ns
- BeanUtils total cost=31,236,079,000ns , each cost=31236ns
从这个结果可以看出, BeanCopier是PropertyUtils的504倍, PropertyUtils是BeanUtils的1.71倍, BeanCopier是PropertyUtils的861.84倍,差了近3个数量级。
第二测试主要是一个对象的单个属性进行拷贝
- BulkBean (cglib)
- BeanMap (cglib)
- FastClass/FastMethod (cglib)
- 未处理的jdk reflect (jdk)
- 处理的jdk reflect (jdk)
1. BulkBean
- // 测试BulkBean
- final BulkBean bulkBean = BulkBean.create(bean.getClass(), new String[] { getMethodName },
- new String[] { setMethodName }, new Class[] { Integer.class });
- final CopyBean bulkBeanTarget = new CopyBean();
- testTemplate(new TestCallback() {
- @Override
- public String getName() {
- return "BulkBean";
- }
- @Override
- public CopyBean call(CopyBean source) {
- Object[] result = bulkBean.getPropertyValues(source); // 先调用getter
- bulkBean.setPropertyValues(bulkBeanTarget, result); // 再调用setter
- return bulkBeanTarget;
- }
- }, bean, testCount);
2. BeanMap
- // 测试BeanMap
- final BeanMap sourceMap = BeanMap.create(bean); // 预先创建对象
- final BeanMap targetMap = BeanMap.create(new CopyBean());
- final CopyBean beanMapTarget = new CopyBean();
- testTemplate(new TestCallback() {
- @Override
- public String getName() {
- return "BeanMap";
- }
- @Override
- public CopyBean call(CopyBean source) {
- targetMap.setBean(beanMapTarget); // 将目标对象设置于beanMap
- Object obj = sourceMap.get(fieldName);
- targetMap.put(fieldName, obj);
- return beanMapTarget;
- }
- }, bean, testCount);
3. FastClass/FastMethod
- // 测试FastClass
- final FastClass fastClass = FastClass.create(bean.getClass());
- final FastMethod setFastMetod = fastClass.getMethod(setMethodName, new Class[] { Integer.class });
- final FastMethod getFastMetod = fastClass.getMethod(getMethodName, new Class[] {});
- final CopyBean fastClassTarget = new CopyBean();
- testTemplate(new TestCallback() {
- @Override
- public String getName() {
- return "FastClass";
- }
- @Override
- public CopyBean call(CopyBean source) {
- try {
- Object field = getFastMetod.invoke(source, new Object[] {});// 调用get方法
- setFastMetod.invoke(fastClassTarget, new Object[] { field });// 调用set方法赋值
- } catch (Exception e) {
- e.printStackTrace();
- }
- return fastClassTarget;
- }
- }, bean, testCount);
4. 未处理的jdk reflect
- try {
- // 进行method对象cache,真实应用中一般都会cache method对象
- final Method getMethod = bean.getClass().getMethod(getMethodName, new Class[] {});
- final Method setMethod = bean.getClass().getMethod(setMethodName, new Class[] { Integer.class });
- // 测试未优化过的Reflect
- final CopyBean reflect1Target = new CopyBean();
- testTemplate(new TestCallback() {
- @Override
- public String getName() {
- return "未优化过的Reflect";
- }
- @Override
- public CopyBean call(CopyBean source) {
- try {
- Object field = getMethod.invoke(source, new Object[] {});
- setMethod.invoke(reflect1Target, new Object[] { field });
- } catch (Exception e) {
- e.printStackTrace();
- }
- return reflect1Target;
- }
- }, bean, testCount);
- } catch (Exception e1) {
- e1.printStackTrace();
- }
- }
5. 处理过的jdk reflect
- try {
- // 进行method对象cache,真实应用中一般都会cache method对象
- final Method getMethod = bean.getClass().getMethod(getMethodName, new Class[] {});
- final Method setMethod = bean.getClass().getMethod(setMethodName, new Class[] { Integer.class });
- // 测试优化过的Reflect
- getMethod.setAccessible(true);// 设置不进行access权限检查
- setMethod.setAccessible(true);// 设置不进行access权限检查
- final CopyBean reflect2Target = new CopyBean();
- testTemplate(new TestCallback() {
- @Override
- public String getName() {
- return "优化过的Reflect";
- }
- @Override
- public CopyBean call(CopyBean source) {
- try {
- Object field = getMethod.invoke(source, new Object[] {});
- setMethod.invoke(reflect2Target, new Object[] { field });
- } catch (Exception e) {
- e.printStackTrace();
- }
- return reflect2Target;
- }
- }, bean, testCount);
- } catch (Exception e1) {
- e1.printStackTrace();
- }
测试结果:
测试次数:testCount = 1000 * 1000 * 100 = 1亿次
- BulkBean total cost=2,125,759,000ns , each cost=21ns
- BeanMap total cost=2,730,912,000ns , each cost=27ns
- FastClass total cost=2,576,470,000ns , each cost=25ns
- 未处理过的Reflect total cost=2,882,755,000ns , each cost=28ns
- 处理过的Reflect total cost=2,792,828,000ns , each cost=27ns
测试结果,性能相差不多,差距不大,这也可以说明jdk对reflect调用的优化已经做的很棒了。
相关推荐
8. **性能对比**:相对于JDK的动态代理,CGLib在某些场景下性能更优,因为它避免了接口调用的额外开销。然而,由于涉及到字节码操作,CGLib在初始化阶段可能比JDK代理慢。 9. **使用示例**:创建一个动态代理通常...
五、CGlib与Java反射动态代理的对比 虽然Java自带的反射API提供了简单的动态代理实现,但仅限于实现了接口的类。对于没有接口的类,CGlib提供了一种更灵活的解决方案。然而,CGlib的性能通常稍逊于Java反射API,...
Java 动态代理是 Java 编程语言中的一种强大工具,广泛应用于 Spring AOP、Hibernate 数据查询、测试框架的后端 mock、RPC 远程调用、Java 注解对象获取、日志、用户鉴权、全局性异常处理、性能监控等领域。...
本示例"JDKProxy"着重于对比两种常见的动态代理技术:JDK的接口代理和CGLIB的类代理。这两种代理方式在Java应用程序中都有广泛的应用,例如在AOP(面向切面编程)框架如Spring中。 首先,我们来深入了解一下JDK的...
- **CGLib(Code Generation Library)**:当原对象没有实现接口或者为了性能考虑时,可以使用CGLib库来生成代理对象。CGLib是基于字节码操作的库,能够动态地生成一个子类,然后通过子类实现对原对象的代理。 - *...
5. **对比CGLIB** - 虽然JDK动态代理方便易用,但它只适用于实现了接口的对象。对于没有接口或者接口过多的情况,可以使用CGLIB库,它通过字节码技术创建代理对象,不局限于接口。 6. **性能考虑** - 动态代理...
这两个版本可能用于测试或对比不同版本的功能和性能。 7. **junit-4.10.jar**:JUnit是Java开发中最常用的单元测试框架,这里可能是为了在开发或测试EasyExcel的相关功能时进行自动化测试。 这些库的组合使用,...
- **Beef平台**:Beef是一个流行的XSS攻击框架,用于演示和测试XSS漏洞。 ##### 8.2.1 IP频率限制与信誉度模型 - **IP频率限制**:通过限制同一IP地址在单位时间内发起的请求次数来防止DDoS攻击。 - **IP信誉度模型...
实际性能测试表明,EF的大部分操作都要快于Hiberante和MyBatis, 部分操作速度甚至数十倍于上述框架。 EF在极限插入模式下,甚至刷新了每秒10万条写入的记录。远远超过了其他框架。 一个初步的性能测试:测试代码...
Java面试题是程序员在求职过程中经常会遇到的一种考核方式,它主要测试候选人在Java编程语言方面的基础知识、编程能力、设计模式、并发处理、框架应用、数据库操作等多方面的能力。以下是一些Java面试中常见的知识点...
1. JUnit测试:单元测试的编写与断言。 2. Maven与Gradle:构建工具的使用与项目管理。 3. Docker与Kubernetes:容器化技术及其在部署中的应用。 以上就是基于标题“java面试的一些题,下载自msdn”所涉及的主要...
CGLib 是一个强大的高性能的代码生成库,它被 Spring 框架用来实现 AOP 功能。 **3. Log4j 日志库:** ``` <groupId>log4j <artifactId>log4j <version>1.2.14 <scope>provided ``` 日志记录工具,用于记录...
9. **与反射的对比**: 相比 Java 反射,Javaassist 在运行时动态修改类的性能更好,因为它直接操作字节码,而反射则需要解析类结构。 在实际开发中,Javaassist 常常用于以下场景: - **AOP 框架**: 如 Spring AOP...
2. O/R Mapping的优点包括提高开发效率、增强代码的可维护性、提升系统性能以及保持对数据库供应商的独立性。 二、Hibernate的优势: 1. 开源:Hibernate是一个开放源码的项目,允许开发者自由查看和修改其源代码。...
- **优势分析**:使用Spring的IoC容器管理对象,可以显著减少代码量,提高可维护性和可测试性。 #### AOP底层实现机制 **AOP**(Aspect Oriented Programming,面向切面编程)是Spring框架中的一个重要特性,用于...
6. **JAVA反射和动态代理**:了解如何在运行时获取类信息、创建对象和调用方法,以及CGLIB和Java动态代理的应用。 7. **JVM**:理解JVM的工作原理,包括类加载机制、内存模型、调优策略等。 接下来是数据库部分,...
- 接口与抽象类:对比两者的区别,何时选择使用接口,何时选择抽象类。 - CopyOnWriteArrayList和ConcurrentHashMap:线程安全的集合实现,适合多线程环境。 3. **多线程** - Thread类与Runnable接口:创建线程...
【Java深复制与浅复制】 ...以上仅是部分知识点,更多如静态代理、动态代理、CGLIB与JDK代理、静态关键字、CAS单点登录原理等未展开详述。这些知识涵盖JavaEE开发的多个方面,对于理解和优化JavaEE应用至关重要。
对比来看,使用Hibernate可以大大简化这些过程,通过配置文件和注解就能完成数据持久化,降低了代码的复杂性。 ### 五、Hibernate的一对多和多对多关系配置 1. **一对一(OneToOne)**:一个实体对应另一个实体的...
11. **AOP 底层实现**:AOP(面向切面编程)通常通过动态代理实现,如JDK动态代理和CGLIB,可以为多个对象动态地生成代理类。 12. **Maven指令**:maven install构建本地库,maven test执行测试,git make install...