序

• 此文是Java数据对象转换工具系列的最后1篇。

• 本文(Apache Commons BeanUtils)主要参考自：

Apache Commons BeanUtils: JavaBean操作的艺术 – Segmentfaul

概述：Apache Commons BeanUtils：Java数据对象转换工具、对象属性操纵助手

Apache Commons BeanUtils， 这货简直就是处理JavaBean的利器，用起来又方便又快捷。
不管是属性拷贝、类型转换，还是动态访问，BeanUtils都能轻松应对。

BeanUtils是啥？

• Apache Commons BeanUtils，简单来说，就是一套Java库，专门用来操作Java Beans。
• 什么是 Java Beans？

嗯，它其实就是遵循特定规范的Java数据模型类，比如有无参构造器、属性私有、公共的getter和setter方法。
这些 Beans 在 Java 世界里可是处处可见，无论是Web开发还是桌面应用，它们都扮演着重要角色。

为啥要用BeanUtils？

• 操作Java Bean虽然不难，但手动去写一堆getter和setter很麻烦，是不是觉得有点啰嗦？

特别是要处理一堆类似的操作，比如复制属性啊，类型转换啊，要写大量的价值不高的代码

• 这时候，BeanUtils就闪亮登场了。

它能让这些操作变得简单快捷，代码更加整洁，提高开发效率。

怎么用起来？

Step1 引入依赖(Maven)

先来看看如何把BeanUtils加入到咱们的项目里。
一般来说，用Maven或者Gradle这样的构建工具是最方便的。
例如，用Maven的话，只需在pom.xml文件里添加如下依赖：

<dependency>
    <groupId>commons-beanutils</groupId>
    <artifactId>commons-beanutils</artifactId>
    <version>${commons-beansutils.version}</version> <!-- 使用最新稳定版本 : 1.9.4-->
</dependency>

加完这个依赖后，咱们就可以在项目中自由使用BeanUtils的各种功能了。

Step2 API的调用

参见下一章节。

核心功能概览

PropertyUtils：操控属性的基础

PropertyUtils主要用来操作Bean的属性。比如说，咱们可以通过它来获取或设置属性的值。它更像是BeanUtils的基石，为BeanUtils提供了基本的属性操作功能。

BeanUtils：PropertyUtils的超级版

• 如果说PropertyUtils是基础版，那BeanUtils就是加强版。

它在PropertyUtils的基础上增加了很多实用的功能，比如属性的复制。这可是在实际开发中超级常用的。

• BeanUtils的常用方法？

方法	说明
cloneBean(Object bean)	对象的克隆
copyProperties(Object dest, Object orig)	对象的拷贝
copyProperty(Object bean, String name, Object value)	拷贝指定的属性值到指定的bean
setProperty(Object bean, String name, Object value)	设置指定属性的值
populate(Object bean, Map<String,? extends Object> properties)	将map数据拷贝到javabean中（map的key要与javabean的属性名称一致

• BeanUtils与PropertyUtils的区别？

BeanUtils与PropertyUtils这两个类几乎有一样的功能，唯一的区别是：BeanUtils在对Bean赋值是会进行类型转化。

举例来说，也就是在copyProperty时只要属性名相同，就算类型不同，BeanUtils也可以进行copy；
而PropertyBeanUtils则可能会报错！！
当然2个Bean之间的同名属性的类型必须是可以转化的，否则用BeanUtils一样会报错。

若实现了org.apache.commons.beanutils.Converter接口则可以自定义类型之间的转化。
由于不做类型转化，用PropertyUtils在性能上会有很大提高！

ConvertUtils：类型转换的神器

在处理JavaBean的时候，经常会遇到属性类型转换的需求。

这时候，ConvertUtils就能派上用场了。它能自动帮咱们处理各种类型之间的转换，省心省力。

代码示例：基本使用

来，咱们看个简单的例子。假设有个人物类（Person），用BeanUtils给它设置属性。

import org.apache.commons.beanutils.BeanUtils;

public class Demo {
    public static void main(String[] args) {
        Person person = new Person();
        try {
            // 使用BeanUtils设置属性
            BeanUtils.setProperty(person, "name", "张三");
            BeanUtils.setProperty(person, "age", 30);

            // 获取并打印属性
            String name = BeanUtils.getProperty(person, "name");
            String age = BeanUtils.getProperty(person, "age");
            System.out.println("姓名: " + name + ", 年龄: " + age);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


class Person {
    private String name;
    private int age;
    // 省略getter和setter方法
}

在这个例子中，咱们用BeanUtils给Person类的name和age属性赋值，然后又获取这些值并打印出来。

深入PropertyUtils

PropertyUtils的核心功能

• PropertyUtils主要提供了读取和设置JavaBean属性的功能。

这听起来很基础，但在实际开发中却非常有用。
举个例子，如果咱们需要从一个对象中读取某个属性的值，或者要把值设置到对象的某个属性上，用PropertyUtils就能轻松搞定。

读取属性：获取对象属性的艺术

咱们来看看如何使用PropertyUtils读取属性值。
假设有个User类，有name和age这两个属性，现在要读取这些属性的值。

import org.apache.commons.beanutils.PropertyUtils;

public class PropertyUtilsDemo {
    public static void main(String[] args) {
        User user = new User();
        user.setName("李雷");
        user.setAge(25);

        try {
            // 读取属性值
            String name = (String) PropertyUtils.getProperty(user, "name");
            Integer age = (Integer) PropertyUtils.getProperty(user, "age");
            System.out.println("姓名: " + name + ", 年龄: " + age);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class User {
    private String name;
    private int age;

    // 省略getter和setter方法
}

在这个例子中，通过PropertyUtils.getProperty方法轻松获取了User对象的name和age属性值。

设置属性：给对象属性赋值的智慧

• 接下来，如果咱们想要设置对象的属性值，PropertyUtils同样能派上用场。

比如现在要把User的name改成“韩梅梅”，age改成30。

public class PropertyUtilsDemo {
    public static void main(String[] args) {
        User user = new User();

        try {
            // 设置属性值
            PropertyUtils.setProperty(user, "name", "韩梅梅");
            PropertyUtils.setProperty(user, "age", 30);

            // 验证结果
            System.out.println("姓名: " + user.getName() + ", 年龄: " + user.getAge());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // User类和前面一样，这里就不重复了
}

在这个例子里，用PropertyUtils.setProperty方法给User对象的属性赋了新值，然后打印出来，确保一切正常。

动态属性操作：灵活性的体现

• PropertyUtils的魔力还不止于此。

它还支持动态属性操作，这意味着咱们可以在运行时动态地读取和设置属性，而不必在编码时就确定属性名。这在处理动态数据结构时特别有用。

import java.util.HashMap;
import java.util.Map;

public class DynamicPropertyDemo {
    public static void main(String[] args) {
        Map<String, Object> map = new HashMap<>();
        map.put("username", "小明");
        map.put("age", 20);

        try {
            // 动态读取属性
            String username = (String) PropertyUtils.getProperty(map, "username");
            Integer age = (Integer) PropertyUtils.getProperty(map, "age");
            System.out.println("用户名: " + username + ", 年龄: " + age);

            // 动态设置属性
            PropertyUtils.setProperty(map, "age", 21);
            System.out.println("更新后年龄: " + map.get("age"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，创建了一个Map，然后用PropertyUtils来动态地处理这个Map中的数据。
这样的灵活性在处理JSON数据或者动态表单数据时特别有优势。

BeanUtils的高级应用

现在要和大家探讨的是BeanUtils的一些高级应用，特别是属性复制和动态Bean操作。
这些功能在实际开发中非常有用，可以让代码更加简洁和高效。

属性复制/copyProperties方法：简化数据迁移

• 属性复制是BeanUtils的一大亮点。

在实际开发中，经常会遇到从一个对象复制属性到另一个对象的场景，尤其是在处理类似DTO（数据传输对象）和Entity（实体）转换的时候。
如果手动一个属性一个属性地复制，既麻烦又容易出错。
这时候，BeanUtils的copyProperties方法就能大显身手了。

看看怎么用这个功能：

import org.apache.commons.beanutils.BeanUtils;

public class CopyPropertiesDemo {
    public static void main(String[] args) {
        UserDTO userDTO = new UserDTO("王小明", 28);
        UserEntity userEntity = new UserEntity();

        try {
            // 从DTO复制到实体
            BeanUtils.copyProperties(userEntity, userDTO);

            // 验证结果
            System.out.println("用户实体：姓名 - " + userEntity.getName() + ", 年龄 - " + userEntity.getAge());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class UserDTO {
    private String name;
    private int age;

    UserDTO(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 省略getter和setter方法
}

class UserEntity {
    private String name;
    private int age;

    // 省略getter和setter方法
}

在这个例子中，从一个UserDTO对象复制属性到UserEntity对象。这样一来，所有的属性就自动从DTO转移到实体上了，省时省力。

populate方法 : 为对象属性赋值

public class App {
    public static void main( String[] args ) {
        Dog dog = new Dog();
        Map<String, Object> map = new HashMap<>();
        map.put("age",2);
        map.put("name","huahua");
        try {
            BeanUtils.populate(dog,map);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } finally {
        }
        System.out.println("dog:"+dog);//dog:Dog{name='huahua', age=2}
    }
}

//Dog 类：
public class Dog {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

cloneBean方法：拷贝对象

// Animal 类
public class Animal {
    private String name;
    private String type;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", type='" + type + '\'' +
                ", age=" + age +
                '}';
    }
}

//测试类
public class App
{
    public static void main( String[] args ) throws IllegalAccessException,InvocationTargetException
    {
        // copyProperties 方法
        Animal animal = new Animal();
        animal.setName("mimi");
        animal.setType("dog");
        animal.setAge(2);
        Dog dog = new Dog();
        BeanUtils.copyProperties(dog,animal);
        System.out.println("将 animal 值赋给 dog：");
        System.out.println(dog);
        //如果被copy对象缺少目标对象中的某些属性，那么目标对象中的对应值为 null
        Animal animal1 = new Animal();
        BeanUtils.copyProperties(animal1,dog);
        System.out.println("将 dog 值赋给 animal1 对象：");
        System.out.println(animal1);

        // copyProperty 方法
        animal.setName("huahua");
        BeanUtils.copyProperty(dog,"name",animal.getName());
        System.out.println("改变 animal name属性，并赋给 dog：");
        System.out.println(dog);

        // setProperty 方法
        BeanUtils.setProperty(dog,"age",3);
        System.out.println("给 dog 的 age 属性赋值：");
        System.out.println(dog);

        // cloneBean 方法
        try {
            Animal animal2 = (Animal)BeanUtils.cloneBean(animal1);
            System.out.println("通过 animal1 克隆 animal2 对象：");
            System.out.println(animal2);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }
}

out

将 animal 值赋给 dog：
Dog{name='mimi', age=2}
将 dog 值赋给 animal1 对象：
Animal{name='mimi', type='null', age=2}
改变 animal name属性，并赋给 dog：
Dog{name='huahua', age=2}
给 dog 的 age 属性赋值：
Dog{name='huahua', age=3}
通过 animal1 克隆 animal2 对象：
Animal{name='mimi', type='null', age=2}

动态Bean操作：更多的可能性(DynaBean/DynaClass/LazyDynaBean/LazyDynaClass)

• 动态Bean操作是BeanUtils中另一个很酷的功能。它允许咱们在运行时动态创建和操作Bean，这在处理不确定的数据结构或者动态生成对象的场景下特别有用。

import org.apache.commons.beanutils.DynaBean;
import org.apache.commons.beanutils.DynaClass;
import org.apache.commons.beanutils.LazyDynaBean;
import org.apache.commons.beanutils.LazyDynaClass;

public class DynamicBeanDemo {
    public static void main(String[] args) {
        // 创建一个动态Bean
        DynaClass dynaClass = new LazyDynaClass();
        DynaBean dynaBean = new LazyDynaBean(dynaClass);

        try {
            // 动态添加属性
            dynaBean.set("name", "李华");
            dynaBean.set("age", 30);

            // 读取属性值
            String name = (String) dynaBean.get("name");
            Integer age = (Integer) dynaBean.get("age");
            System.out.println("动态Bean：姓名 - " + name + ", 年龄 - " + age);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这个例子里，创建了一个动态Bean，然后给它添加了name和age两个属性。这种方式的灵活性非常高，可以根据需要动态定义和操作对象的属性。

ConvertUtils的威力

• ConvertUtils，这个小玩意儿主要负责类型转换，特别是在处理JavaBean的属性时，经常会遇到需要把一种类型转换成另一种类型的情况。ConvertUtils就是用来解决这类问题的。

类型转换：简化而高效

• 在Java开发中，类型转换无处不在。

比如从字符串转换成整数，或者从整数转换成布尔值等等。
这些操作听起来简单，但如果每次都手动写转换代码，不仅麻烦，而且容易出错。
ConvertUtils提供了一种统一的解决方案，可以自动完成这些转换，简化开发流程。

使用ConvertUtils进行基本转换

案例： convert 方法的使用

来看看ConvertUtils的基本使用方法。假设现在有个字符串表示的年龄，需要把它转换成整数类型。

import org.apache.commons.beanutils.ConvertUtils;

public class ConvertUtilsDemo {
    public static void main(String[] args) {
        // 字符串转换为整数
        String ageStr = "25";
        Integer age = (Integer) ConvertUtils.convert(ageStr, Integer.class);
        System.out.println("转换后的年龄: " + age);
    }
}

在这个例子中，使用了ConvertUtils的convert方法，轻松地把字符串”25″转换成了整数。

自定义类型转换器

• 但ConvertUtils的真正魅力在于它的可扩展性。

如果咱们需要处理一些特殊的转换，比如把字符串转换成日期类型，或者把数字转换成自定义的枚举类型，这时就可以自定义转换器。

import org.apache.commons.beanutils.Converter;
import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.beanutils.converters.DateTimeConverter;

public class CustomConverterDemo {
    public static void main(String[] args) {
        // 自定义转换器：字符串转日期
        DateTimeConverter dtConverter = new DateTimeConverter() {
            @Override
            protected Class<?> getDefaultType() {
                return java.util.Date.class;
            }
        };
        ConvertUtils.register(dtConverter, java.util.Date.class);

        // 使用自定义转换器
        String dateStr = "2023-12-25";
        java.util.Date date = (java.util.Date) ConvertUtils.convert(dateStr, java.util.Date.class);
        System.out.println("转换后的日期: " + date);
    }
}

在这个例子里，注册了一个自定义的日期转换器，用来把字符串转换成java.util.Date类型。这样的自定义转换器让ConvertUtils的功能更加强大和灵活。

综合案例：处理复杂转换

• 实际开发中，咱们可能会遇到更复杂的转换需求。

比如，有一个用户信息的字符串，里面包含了姓名、年龄和生日，咱们需要把这些信息提取出来，转换成相应的数据类型。

public class ComplexConversionDemo {
    public static void main(String[] args) {
        // 假设有这样一个用户信息字符串
        String userInfo = "张三,30,1993-04-15";

        // 分割字符串
        String[] parts = userInfo.split(",");

        // 转换各个部分
        String name = parts[0];
        Integer age = (Integer) ConvertUtils.convert(parts[1], Integer.class);
        java.util.Date birthday = (java.util.Date) ConvertUtils.convert(parts[2], java.util.Date.class);

        // 输出结果
        System.out.println("姓名: " + name + ", 年龄: " + age + ", 生日: " + birthday);
    }
}

在这个例子中，处理了一个包含多种数据类型的字符串，并且使用ConvertUtils轻松完成了类型转换。

性能分析

性能

• 虽然BeanUtils提供了很多便利的功能，但这些功能的背后可能会有一定的性能代价。

例如，在复制大量属性或频繁操作Bean时，性能问题可能会浮现。
这不是说BeanUtils性能差，而是任何便捷的功能都可能有性能成本，了解这一点对于写出高效的代码很重要。

BeanUtils的性能分析

• BeanUtils在进行属性复制或类型转换时，会使用反射机制。

反射机制虽然提供了极大的灵活性，但与直接访问属性相比，它在性能上通常会慢一些。
这是因为：反射需要在运行时解析类的元数据，这个过程比直接执行编译过的Java代码要慢。

最佳实践与总结

实际应用中的考量

• 数据量和频率：在处理小量数据或不频繁的操作时，BeanUtils带来的性能影响可以忽略不计。但在大批量数据处理或高频调用场景下，性能差异可能变得显著。
• 功能与性能的平衡：在选择使用BeanUtils时，需要权衡其提供的便利性和可能的性能代价。如果性能是关键因素，可能需要考虑替代方案或优化代码。

最佳实践

1. 合理使用反射：BeanUtils依赖于反射来操作JavaBean的属性。虽然反射很强大，但也不是万能的。在性能敏感的场景下，考虑直接使用getter和setter方法。
2. 避免过度依赖：虽然BeanUtils可以简化很多操作，但并不意味着所有属性操作都应该通过它来完成。评估每种情况，如果手动操作更简单明了，就没必要强行使用BeanUtils。
3. 处理异常：BeanUtils的方法可能会抛出异常。妥善处理这些异常，不仅可以避免程序崩溃，还能帮助定位问题。
4. 自定义转换器的使用：当遇到BeanUtils内置转换器无法满足需求时，可以自定义转换器。但要确保自定义转换器的正确性和效率。
5. 利用缓存提高性能：如果在高频率操作的场景中使用BeanUtils，考虑使用缓存机制来存储反射结果，以提高性能。

常见错误

1. 忽略了null值的处理：在复制属性时，BeanUtils会将源对象的null值也复制过去。在某些情况下，这可能会覆盖目标对象的现有值。要特别注意这一点。
2. 不正确的数据类型：在使用ConvertUtils进行类型转换时，如果源数据类型和目标数据类型不匹配，可能会导致转换错误或数据丢失。
3. 反射性能问题：忽视BeanUtils基于反射的特性可能会导致性能问题，特别是在大数据量或高频率操作的场景中。
4. 异常处理不当：BeanUtils操作可能会抛出多种异常。忽略这些异常的正确处理，可能会导致程序中断或隐蔽的bug。

总结

• 在本文中，我们深入探讨了Apache Commons BeanUtils库，一个在Java开发中不可或缺的工具。

从基本介绍到高级应用，本文全面覆盖了BeanUtils的核心功能，包括PropertyUtils和ConvertUtils的使用，突出了它们在处理JavaBean属性时的便利性和灵活性。

• 我们首先概述了BeanUtils的基础知识，强调了它在简化JavaBean操作中的作用。随后，详细探讨了PropertyUtils和BeanUtils的高级功能，如属性复制和动态Bean操作，展示了它们如何在数据转换和处理中提供高效的解决方案。特别是在涉及自定义类型转换器和处理复杂类型转换的场景中，BeanUtils显示出其强大的功能。

最后希望大家能够学有所获，提升效率，简化开发！

Y 推荐文献

• [Java EE] 企业级Java Web应用的概念辨析： POJO(PO / DTO / VO) | BO/DO | DAO – 博客园/千千寰宇

• Spring BeanUtils：Java数据对象转换工具、对象属性操纵助手 – 博客园/千千寰宇

含：Spring BeanUtils 与 Apache Commons BeanUtils 的比较

• Apache Commons

• https://commons.apache.org/proper/commons-beanutils/

X 参考文献

• Apache Commons BeanUtils: JavaBean操作的艺术 – Segmentfault 【推荐】

2023.12.25

• 常用的工具类之 Apache Commons BeanUtils 简单使用与部分原理解析 – CSDN

来源链接：https://www.cnblogs.com/johnnyzen/p/18822005