Bean复制的几种框架性能比较(Apache BeanUtils、PropertyUtils,Spring BeanUtils,Cglib BeanCopier)
平
5
4
1
0
10000 次测验 BeanUtil.copyProperties PropertyUtils.copyProperties org.springframework.beans.BeanUtils.copyProperties BeanCopier.create 10000 次反转测验 BeanUtil.copyProperties PropertyUtils.copyProperties org.springframework.beans.BeanUtils.copyProperties BeanCopier.create
10 次测验 BeanUtil.copyProperties PropertyUtils.copyProperties org.springframework.beans.BeanUtils.copyProperties BeanCopier.create 第一次 54 4 12 0 第二次 57 4 10 0 第三次 50 4 11 0
使用的测试类 public class TestMain { @param public static main(String[] args) { FromBean fb = FromBean(); fb.setAddress("北京市朝阳区大屯路"); fb.setAge(20); fb.setMoney(30000.111); fb.setIdno("110330219879208733"); fb.setName("测试"); IMethodCallBack beanutilCB = IMethodCallBack() {
public class FromBean { private String name; private int age; private String address; private String idno; private double money; public double getMoney() { return money; } public void setMoney(double money) { this.money = money; } public String getName() { return name; } public void setName(String name) { = name; } public int getAge() { return age; } public void setAge(int age) {
@Override public String getMethodName() { return "BeanUtil.copyProperties"; } @Override public ToBean callMethod(FromBean frombean) throws Exception { ToBean toBean = ToBean(); BeanUtils.copyProperties(toBean, frombean); return toBean;
} }; IMethodCallBack propertyCB = IMethodCallBack() {
@Override public String getMethodName() { return "PropertyUtils.copyProperties"; } @Override public ToBean callMethod(FromBean frombean) throws Exception { ToBean toBean = ToBean(); PropertyUtils.copyProperties(toBean, frombean); return toBean; } }; IMethodCallBack springCB = IMethodCallBack() {
org.springframework.beans.BeanUtils.copyProperties(frombean, toBean); return toBean; } }; IMethodCallBack cglibCB = IMethodCallBack() { BeanCopier bc = BeanCopier.create(FromBean.class, ToBean.classfalse); @Override public String getMethodName() {
return "BeanCopier.create"; } @Override public ToBean callMethod(FromBean frombean) throws Exception { ToBean toBean = ToBean(); bc.copy(frombean, toBean, return toBean; } }; // 数量较少的时候，测试性能 BenchmarkTest bt = BenchmarkTest(10); bt.benchmark(beanutilCB, fb); bt.benchmark(propertyCB, fb); bt.benchmark(springCB, fb); bt.benchmark(cglibCB, fb); // 测试一万次性能测试 BenchmarkTest bt10000 = BenchmarkTest(10000); bt10000.benchmark(beanutilCB, fb); bt10000.benchmark(propertyCB, fb); bt10000.benchmark(springCB, fb); bt10000.benchmark(cglibCB, fb); // 担心因为顺序问题影响测试结果 BenchmarkTest bt1000R = BenchmarkTest(10000); bt1000R.benchmark(cglibCB, fb); bt1000R.benchmark(springCB, fb); bt1000R.benchmark(propertyCB, fb); bt1000R.benchmark(beanutilCB, fb); } } 进行了三次测试，最后的结果如下：
10 次 10000 次 10000 次反转 BeanCopier.create 41 28 10
性能测试就到这里，数据也展示如上，后续会继续编写剩余两篇文 章，这一片关注性能，后面的一篇是就每种方式的使用上的差异进行详解，最 后一篇想进行探讨是什么早就了这四种方式的性能差异。
比较的是四种复制的方式，分别为 Apache 的 BeanUtils 和 PropertyUtils,Spring 的 BeanUtils,Cglib 的 BeanCopier。做法是在 Eclipse 新建了一个 Project，专门用于专门测试几种 代码的性能。具体的代码如下： 一个 FromBean 和一个 ToBean，两个的代码基本上一样，除了类名称不一样，所以只 是贴出来了一份。
@Override public String getMethodName() { return "org.springframework.beans.BeanUtils.copyProperties"; } @Override public ToBean callMethod(FromBean frombean) throws Exception { ToBean toBean = ToBean();
Bean 复制的几种框架性能比较（ Apache BeanUtils 、 PropertyUtils,Spring BeanUtils,Cglib BeanCopier）
作为一个新员工，一个首要的工作就是阅读别人的代码，阅读代 码的诸多好处就不说了，我就直奔主题，通过预读代码，发现了几种实现两个 不同类型的 Bean 之间实现值复制的几种方式，上网查询后发现性能上会有差 异，于是就萌生自己深入了解几种实现的想法。第一步就是先本着实事求是的 原则去探求一下大家总结出来的性能差异是否正确。
this.age = age; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } public String getIdno() { return idno; } public void setIdno(String idno) { this.idno = idno; } } 一个用于测试的 BenchmarkTest 类，为了减少重复代码，写了一个策略模 式 public class BenchmarkTest { private count; public BenchmarkTest( count) { .count = count; System.out.println("性能测试" + .count + "=================="public benchmark(IMethodCallBack m, FromBean frombean) { begin = java.util.Date().getTime(); ToBean tobean = ; System.out.println(m.getMethodName() + "开始进行测试" ( i = 0; i < count; i++) { tobean = m.callMethod(frombean); } end = java.util.Date().getTime(); System.out.println(m.getMethodName() + "耗时" + (end begin)); System.out.println(tobean.getAddress()); System.out.println(tobean.getAge()); System.out.println(tobean.getIdno()); System.out.println(tobean.getMoney()); System.out.println(tobean.getName());
Java后端开发框架比较与选择
Java后端开发框架比较与选择随着互联网的发展，Java成为了最受欢迎的后端开发语言之一。
众多的Java后端开发框架也应运而生。
然而，选择一个适合自己的框架并不容易。
本文将介绍几种比较流行的Java后端开发框架并进行比较，以帮助读者选择适合自己的框架。
一、Spring框架Spring是Java后端开发中应用最广泛的框架之一。
它由Rod Johnson于2002年创建，目的是简化企业级Java开发。
Spring框架提供了各种模块，如Spring MVC、Spring Data、Spring Security和Spring Batch。
其中，Spring MVC是基于模型-视图-控制器（MVC）设计模式的Web框架，Spring Data用于简化与数据库的交互，Spring Security将安全性集成到应用程序中，Spring Batch提供了对长时间运行的批处理作业的支持。
优点：1.依赖注入：Spring框架的最大特色之一就是依赖注入（DI）。
它允许开发人员更容易地管理应用程序中的对象和组件。
2.面向切面编程：Spring框架可以让开发人员使用面向切面编程（AOP）实现横向切面的功能（如事务管理、安全性和日志记录等）。
3.轻量级：Spring框架是一个轻量级框架，可以处理大多数的Web应用程序。
缺点：1.学习门槛高：Spring框架有很多模块和相关的技术，初学者需要花费一定的时间来学习。
2.代码复杂度高：使用Spring框架编写代码相对复杂，需要开发人员掌握多种技术（如注解、XML配置和AOP等）。
二、Struts框架Struts框架是一个基于MVC设计模式的Web框架。
它由Apache Software Foundation创建，旨在简化开发人员构建大型Web应用程序的过程。
它包括一个控制器、模型和视图，以及一些工具和库。
优点：1.易于学习：Struts框架非常容易学习，并且提供了丰富的文档和教程。
beanutil常用的方法
beanutil常⽤的⽅法Apache Common BeanUtil是⼀个常⽤的在对象之间复制数据的⼯具类，著名的web开发框架struts就是依赖于它进⾏ActionForm的创建。
BeanUtil最常⽤的类是mons.beanutils.BeanUtils。
BeanUtils最常⽤的⽅法为：1. public void copyProperties(ng.Object dest, ng.Object orig)把orig中的值copy到dest中.2. public java.util.Map describe(ng.Object bean)把Bean的属性值放⼊到⼀个Map⾥⾯。
3. public void populate(ng.Object bean, java.util.Map properties)把properties⾥⾯的值放⼊bean中。
4. public void setProperty(ng.Object bean, ng.String name, ng.Object value)设置Bean对象的名称为name的property的值为value.5. public String getProperty(ng.Object bean, ng.String name)取得bean对象中名为name的属性的值。
详细的使⽤⽅法可以参见官⽅⽹站：Apache Common BeanUtil的常见使⽤场景。
<!--[if !supportLists]-->1. <!--[endif]-->同类之间不同对象要求进⾏数据复制。
User user1 = …;User user2 = …;BeanUtils. copyProperties(user2,user1);<!--[if !supportLists]-->2. <!--[endif]-->不同类不同对象之间的数据复制。
beanutils copyproperties拷贝规则
BeanUtils的`copyProperties`方法用于将一个JavaBean对象的属性值拷贝到另一个JavaBean对象中。
拷贝的规则如下：1. 属性名匹配：`copyProperties`方法会尝试将源对象中的属性值拷贝到目标对象中，属性名在两个对象中需要匹配，不区分大小写。
2. 类型匹配：如果属性名匹配，BeanUtils会尝试将源对象中的属性值转换为目标对象中对应属性的数据类型。
如果类型不匹配，BeanUtils会尝试执行类型转换。
例如，将字符串转换为整数或日期。
3. 嵌套属性：BeanUtils可以处理嵌套属性。
如果源对象和目标对象都有嵌套属性，BeanUtils会尝试递归地将嵌套属性的值拷贝到目标对象中。
4. 忽略null值：默认情况下，`copyProperties`方法会忽略源对象中的空属性（null值），不会覆盖目标对象中已有的非空属性。
5. 类型不匹配时的处理：如果属性的数据类型不匹配，BeanUtils会尝试使用合适的类型转换器进行转换。
如果没有适用的转换器，或者转换失败，可能会抛出异常。
6. 属性拷贝的方向：`copyProperties`方法是从源对象到目标对象的单向拷贝。
它将源对象中的属性值拷贝到目标对象中，不会反过来拷贝。
请注意，BeanUtils的`copyProperties`方法通常用于将一个JavaBean对象的属性值拷贝到另一个JavaBean对象中，但它不会处理复杂的转换逻辑或自定义拷贝规则。
如果需要更复杂的属性映射和转换逻辑，可能需要编写自定义代码来完成。
此外，BeanUtils 还提供了其他用于属性拷贝的方法，如`copyProperty`和`populate`，可以根据具体需求选择合适的方法。
beanutil.copyproperties 枚举类
beanutil.copyproperties 枚举类Java中的`BeanUtils.copyProperties`方法是一种用于在两个Java Bean 之间进行属性拷贝的工具。
然而，当两个Bean中存在枚举类型的属性时，需要特别处理才能正确拷贝枚举属性。
枚举类是一种定义了一组常量的特殊类型，它提供了一种可读性强且类型安全的方式来表示相关的常量值。
在Java中，我们可以使用`enum`关键字来定义枚举类。
假设我们有一个名为`Color`的枚举类，其中定义了红、绿、蓝三个颜色常量：```javapublic enum Color {RED, GREEN, BLUE;}```现在，我们有一个`SourceBean`和一个`TargetBean`，它们都有一个名为`color`的属性，类型分别为`Color`枚举类型。
我们希望使用`BeanUtils.copyProperties`将`SourceBean`的属性值拷贝到`TargetBean`中，但是由于枚举类型的特殊性，直接使用`BeanUtils.copyProperties`会出现类型不匹配的错误。
为了解决这个问题，我们可以通过自定义转换器来实现枚举属性的拷贝。
首先，定义一个`EnumConverter`类实现`Converter`接口：```javaimport mons.beanutils.Converter;public class EnumConverter implements Converter {@SuppressWarnings("unchecked")@Overridepublic <T> T convert(Class<T> type, Object value) {if (value instanceof Enum) {return (T) Enum.valueOf((Class<Enum>) type, value.toString());}return null;}}```在`EnumConverter`类中，我们将输入的值（`value`）转换为枚举类型（`type`），然后返回相应的枚举常量。
BeanUtils
1. 概述第一次接触BeanUtils是在学习Struts的过程中，在Struts中它被大量用于处理FormBean。
BeanUtils主要提供了对于JavaBean进行各种操作，BeanUtils一共分4个包：Ø mons.beanutilsØ mons.beanutils.convertersØ mons.beanutils.localeØ mons.beanutils.locale.converters其中上面两个是BeanUtils的默认实现，它没有针对本地化的任何处理，这个可以提高执行效率。
但是若你的程序对于本地化有要求的话，那还是使用下面2个包比较安全。
2. mons.beanutils这个包主要提供用于操作JavaBean的工具类，Jakarta-Common-BeanUtils的主要功能都在这个包里实现。
下面分别介绍几个主要的工具类：2.1.BeanUtil1、首先，我先定义一个JavaBean作为之后例子的操作对象。
public class Company{private String name;private HashMap address = new HashMap();private String[] otherInfo;private ArrayList product;private ArrayList employee;private HashMap telephone;public Company(){}public String getName(){return name;}public void setName(String name){ = name;}public String getAddress(String type){return address.get(type).toString();}public void setAddress(String type, String address) {this.address.put(type,address);}public String[] getOtherInfo(){return otherInfo;}public void setOtherInfo(String[] otherInfo){this.otherInfo = otherInfo;public ArrayList getProduct(){return product;}public void setProduct(ArrayList product) {this.product = product;}public ArrayList getEmployee(){return employee;}public void setEmployee(ArrayList employee) {this.employee = employee;}public HashMap getTelephone(){return telephone;}public void setTelephone(HashMap telephone) {this.telephone = telephone;}2、BeanUtils可以直接get和set一个属性的值。
beanutils的copyproperties枚举类 -回复
beanutils的copyproperties枚举类-回复BeanUtils是Apache Commons库中的一个组件，它提供了一些方便的方法来进行Java Bean属性之间的复制。
在BeanUtils中，`copyProperties`方法是一个非常有用的方法，可以用于将一个Java Bean对象的属性复制到另一个Java Bean对象中。
这个方法接受两个参数，目标对象和源对象，它会自动匹配两个对象中的属性，并将源对象中的属性值复制到目标对象中。
这个方法可以非常方便地进行对象之间的属性复制，减少了手动编写属性赋值的代码。
首先，我们需要在项目中引入BeanUtils库。
可以使用Maven来管理项目的依赖，将以下代码添加到项目的pom.xml文件中：xml<dependency><groupId>commons-beanutils</groupId><artifactId>commons-beanutils</artifactId><version>1.9.4</version></dependency>完成引入库之后，我们可以开始使用`copyProperties`方法。
下面是一个示例代码：javaimport org.apachemons.beanutils.BeanUtils;import org.apachemons.beanutils.PropertyUtils;public class Main {public static void main(String[] args) throws Exception { 创建源对象User sourceUser = new User("Alice", 20, "alice@example");创建目标对象User targetUser = new User();使用copyProperties方法进行属性复制BeanUtils.copyProperties(targetUser, sourceUser);输出目标对象的属性值System.out.println(targetUser.getName()); 输出：AliceSystem.out.println(targetUser.getAge()); 输出：20System.out.println(targetUser.getEmail()); 输出：alice@example}}class User {private String name;private int age;private String email;省略getter和setter方法...}在上面的示例中，我们创建了一个名为`User`的Java Bean类，它包含了其中的三个属性：name、age和email。
Java框架性能比较
Java框架性能比较Java作为一种强大的编程语言，广泛应用于各种软件开发领域。
而在Java开发中，框架的选择对于项目的成功与否起着至关重要的作用。
不同的框架在性能上有着各自的优势和劣势。
本文将对几种常见的Java框架进行性能比较，以帮助读者在实际开发中做出明智的选择。
一、Spring框架Spring框架是目前广泛应用的Java开发框架之一。
它提供了一个轻量级的容器，可以管理对象的生命周期并且解决了常见的依赖关系问题。
Spring的模块化设计使得开发者可以按需选择所需的功能模块，从而减小了内存消耗和启动时间。
Spring框架的优势在于其灵活性和可扩展性，能够满足各种复杂的开发需求。
然而，由于Spring框架的庞大复杂性，其性能在一定程度上受到了影响。
相比于其他框架，Spring框架的启动时间较长，对于一些对性能要求较高的系统可能不太适用。
此外，Spring框架还需要依赖其他核心库，增加了项目的复杂度。
二、Hibernate框架Hibernate框架是用于Java与数据库交互的重要工具。
它提供了一个面向对象的数据访问层，将Java对象映射到数据库表格中。
Hibernate框架的优势在于其简化了数据的持久化操作，并且提供了一套灵活的查询语言（HQL）。
然而，Hibernate框架在性能上存在一定的问题。
由于其ORM（对象关系映射）特性，Hibernate在数据读取和写入方面的性能相对较低。
同时，对于较复杂的对象关系，Hibernate的查询性能也有一定影响。
三、Spring Boot框架Spring Boot框架是基于Spring框架的增强版本，旨在简化开发过程。
它提供了一种快速构建独立应用程序的方式，并且自动配置了大部分常用的功能和组件。
Spring Boot的优势在于其简单易用的特点，它减少了开发者的配置工作，提高了开发效率。
然而，Spring Boot框架相对于Spring框架来说，在性能上存在一定的劣势。
beanutilscopyproperties用法
beanutilscopyproperties用法beanutilscopyproperties用法详解beanutilscopyproperties是Apache Commons BeanUtils库中的一个方法，它的作用是将一个Java对象的属性值拷贝到另一个对象中。
这个方法提供了一种方便且快捷的方式来实现对象之间的属性拷贝，可以帮助开发人员减少大量的重复工作，提高代码的重用性和可维护性。
在本文中，我将详细介绍beanutilscopyproperties的用法，并提供一些示例代码来演示如何使用它。
第一步：导入BeanUtils库要使用beanutilscopyproperties方法，首先需要导入Apache Commons BeanUtils库。
可以从官方网站（第二步：创建源对象和目标对象在使用beanutilscopyproperties方法之前，我们需要创建源对象和目标对象。
源对象是需要从中拷贝属性值的对象，而目标对象是需要将属性值拷贝到其中的对象。
这两个对象可以属于同一个类，也可以属于不同的类，只要它们的属性名称和类型相匹配即可。
下面是一个示例源对象的类定义：javapublic class SourceObject {private String name;private int age;省略getter和setter方法}下面是一个示例目标对象的类定义：javapublic class TargetObject {private String name;private int age;省略getter和setter方法}第三步：拷贝属性值一旦创建了源对象和目标对象，就可以使用beanutilscopyproperties方法来拷贝属性值了。
该方法需要传入两个参数：目标对象和源对象。
它会将源对象的属性值拷贝到目标对象中，如果属性名称在源对象和目标对象中都存在，则进行拷贝操作。
如果属性名称只存在于源对象或目标对象中的某一个，则不进行拷贝操作。
beanutils.copyproperties 用法
beanutils.copyproperties 用法BeanUtils库是Apache Commons系列库中的一个子模块，它提供了一组便捷的API，可以复制或转换Java Bean 对象属性，使得程序员能够更加方便地在不同的对象中交换数据。
BeanUtils.copyProperties()是BeanUtils库中最常用的方法之一，本文就来介绍一下它的用法。
一、BeanUtils.copyProperties()方法简介BeanUtils.copyProperties()方法的作用是从源对象复制属性值到目标对象，它的方法签名如下：``` public static void copyProperties(Object dest, Object orig) ```其中dest表示目标对象，orig表示源对象，该方法会将源对象中与目标对象属性名相同的属性值复制到目标对象中，并且不考虑属性之间的类型差异，如果目标对象中没有源对象中的某个属性名，则对目标对象不做任何更改。
该方法通过Java反射实现，可以实现对任意JavaBean 对象的属性复制，非常方便易用。
二、BeanUtils.copyProperties()方法的使用1. 简单的Java Bean属性复制我们先来看一个最简单的例子：```java public class SourceBean { private String name; private int age; // 省略getter/setter }public class DestBean { private String name; private int age; // 省略getter/setter }public static void main(String[] args) throws Exception { SourceBean sourceBean = new SourceBean(); sourceBean.setName("Michael Jordan"); sourceBean.setAge(58);DestBean destBean = new DestBean(); BeanUtils.copyProperties(destBean, sourceBean);System.out.println(destBean.getName()); System.out.println(destBean.getAge()); } ```该程序中，我们创建了两个JavaBean对象：`SourceBean`和`DestBean`，它们具有相同的属性名和类型，并且DestBean对象的属性为空。
java中beanutils copy引用类型
一、概述在Java编程中，我们经常需要将一个对象的属性值复制到另一个对象中。
BeanUtils是Apache Commons库中的一个工具类，它提供了一个方便的方法来完成这项任务。
在这篇文章中，我们将介绍BeanUtils的copy方法，重点讨论它在复制引用类型属性时的用法和注意事项。
二、BeanUtils的copy方法BeanUtils提供了一个copy方法，用于从一个对象复制属性到另一个对象。
该方法有多个重载形式，可以根据需要选择合适的重载版本来实现属性复制。
一般来说，copy方法可以完成基本类型和字符串类型属性的复制，但在复制引用类型属性时需要特殊处理。
三、复制引用类型属性1. 使用BeanUtils.copyProperty方法复制引用类型属性对于引用类型属性，我们不能简单地将源对象的引用赋给目标对象，因为这样会导致两个对象共享同一个引用，从而引起意外的属性修改。
为了解决这个问题，我们可以使用BeanUtils.copyProperty方法来复制引用类型属性。
```javaclass Source {private List<String> list;// getter and setter}class Target {private List<String> list;// getter and setter}Source source = new Source();source.setList(Arrays.asList("a", "b", "c"));Target target = new Target();BeanUtils.copyProperty(target, "list", newArrayList<>(source.getList()));// 现在target的list属性拥有了source的list属性的拷贝```2. 使用BeanUtils.copyProperties方法复制引用类型属性除了copyProperty方法，BeanUtils还提供了copyProperties方法，可以一次复制整个对象的属性。