BeanUtils
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`,可以根据具体需求选择合适的方法。
Java BeanUtils使用方法详解

介绍BeanUtils工具类是方便我们对JavaBean进行操作的工具,在java开发中很实用,比如属性拷贝,简化了操作,提高了开发效率,下面就来详细了解一下吧!!!BeanUtils对JavaBean的常用操作1.BeanUtils可以对javaBean的属性进行赋值。
2.BeanUtils可以将一个MAP集合的数据拷贝到一个javabean对象中。
3.BeanUtils可以对javaBean的对象进行赋值。
BeanUtils使用步骤步骤一:项目中导入commons-beanutils.jar包步骤二:在项目中就可以使用对javaBean的一些相关操作,比如:1).给对象赋值:BeanUtils.setProperty(对象,属性名,属性值);2).把一个javaBean的属性拷贝到另一个javaBean对象中:BeanUtils.copyProperties(源对象,新对象);...BeanUtils常用方法常用方法描述copyProperties(Objectdest,Objectorig) 对象拷贝copyProperty(Objectbean,Stringname,Objectvalue) 指定属性拷贝到指定的对象中cloneBean(Objectbean) 对象的克隆populate(Objectbean,Map<String,?etendsObject>prope rties)将map数据拷贝到javabean中(map的key要与javabean的属性名称一致)setProperty(Objectbean,Stringname,Objectvalue) 设置指定属性的值案例1.创建一个学生实体类(Student.java)publicclassStudent{privateStringname;privateintage;privateStringse;publicStudent(){}get和set省略}2.测试BeanUtils的常见用法@TestpublicvoidBeanUtilsTest()throwsEception{Map<String,Object>map=newHashMap<String,Object>(); map.put("name","张三");map.put("age",12);map.put("se","男");//将map数据拷贝到Student中Studentstu=newStudent();BeanUtils.populate(stu,map);//Student[name=张三,age=12,se=男]System.out.println(stu);//对象的拷贝Studentstu1=newStudent();BeanUtils.copyProperties(stu,stu1);//Student[name=张三,age=12,se=男]System.out.println(stu1);//拷贝指定的属性Studentstu2=newStudent();BeanUtils.copyProperty(stu2,"name","李四");//Student[name=李四,age=0,se=null]System.out.println(stu2);//设置指定的属性BeanUtils.setProperty(stu2,"se","女");//Student[name=李四,age=0,se=女]System.out.println((stu2);//克隆对象Objectobject=BeanUtils.cloneBean(stu2);//Animal[name=李四,age=0,se=女]System.out.println(object);}注意事项:BeanUtils在进行数据拷贝中,不管数据是否有值,会直接覆盖,这样就会存在有些需求无法满足的情况,不如说当拷贝的值为null时,不允许覆盖,可以进行如下操作:publicstaticString[]getNullPropertyNames(Objectsource){finalBeanWrappersrc=newBeanWrapperImpl(source);java.beans.PropertyDescriptor[]pds=src.getPropertyDescriptors();Set<String>emptyNames=newHashSet<String>();for(java.beans.PropertyDescriptorpd:pds){ObjectsrcValue=src.getPropertyValue(pd.getName());if(srcValue==null)emptyNames.add(pd.getName());}String[]result=newString[emptyNames.size()];returnemptyNames.toArray(result);}BeanUtils.copyProperties(源对象,新对象,getNullPropertyNames(源对象));。
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方法,可以一次复制整个对象的属性。
BeanUtils工具类

BeanUtils⼯具类⼀.BeanUtils 概述BeanUtils 是阿帕奇提供的⼀套专门⽤于将⼀些数据封装到java对象中的⼯具类;名词:javaBean:特定格式的java类称为javaBean;要求:1:javaBean这个类要实现Serializable接⼝;(在实际开发中,通常省略了)2:javaBean必须有public权限的空参数的构造⽅法;3:javaBean必须有属性对应的getXxx与setter⽅法;⼆.BeanUtils 的使⽤Beanutils 有2个依赖jar包;commons-beanutils-1.8.3.jar和commons-logging-1.1.1.jar;BeanUtils 有2个核⼼类:BeanUtils,ConvertUtils 类;使⽤步骤:1:下载解压;2:复制核⼼jar包到⼯程中;(有2个)3:添加到本地;(add to build path)4:使⽤核⼼类;三.BeanUtils 常⽤⽅法public static void setProperty(Object bean,String name,Object value)throws IllegalAccessException,InvocationTargetException{}:向bean对象的name属性中保存value值;public static String getProperty(Object bean,String name)throws IllegalAccessException,InvocationTargetException,NoSuchMethodException{}:从bean对象中获取name属性的值; public static String[] getArrayProperty(Object bean,String name)throws IllegalAccessException,InvocationTargetException,NoSuchMethodException{}:从bean对象中获取name属性的数组类型的值;[注:getProperty⽅法就只认String类型和String[]数组类型,其它类型它会⾃动帮你转成这两个类型,使⽤时需时刻想到String类型,⽤""包裹属性]public static void populate(Object bean,Map properties)throws IllegalAccessException,InvocationTargetException{}:将properties集合中的数据,根据key与bean的属性名(实际上是匹配setXxx⽅法) 匹配,匹配成功,则赋值,匹配失败不操作;代码演⽰1:(以下代码全在Eclipse中实现)1//创建beanUtilsDemo01包2package beanUtilsDemo01;34import java.util.Arrays;56public class Person {7// 属性8private String name;9private int age;10private String[] hobby;1112// 构造⽅法13public Person() {14super();15 }1617public Person(String name, int age, String[] hobby) {18super(); = name;20this.age = age;21this.hobby = hobby;22 }2324// getter/setter25public String getName() {26return name;27 }2829public void setName(String name) { = name;31 }3233public int getAge() {34return age;35 }3637public void setAge(int age) {38this.age = age;41public String[] getHobby() {42return hobby;43 }4445public void setHobby(String[] hobby) {46this.hobby = hobby;47 }4849// 覆写toString/equal/hashcode50 @Override51public String toString() {52return "Person [name=" + name + ", age=" + age + ", hobby="53 + Arrays.toString(hobby) + "]";54 }5556 @Override57public int hashCode() {58final int prime = 31;59int result = 1;60 result = prime * result + age;61 result = prime * result + Arrays.hashCode(hobby);62 result = prime * result + ((name == null) ? 0 : name.hashCode());63return result;64 }6566 @Override67public boolean equals(Object obj) {68if (this == obj) {69return true;70 }71if (obj == null) {72return false;73 }74if (!(obj instanceof Person)) {75return false;76 }77 Person other = (Person) obj;78if (age != other.age) {79return false;80 }81if (!Arrays.equals(hobby, other.hobby)) {82return false;83 }84if (name == null) {85if ( != null) {86return false;87 }88 } else if (!name.equals()) {89return false;90 }91return true;92 }9394 }95//创建beanUtilsDemo01包96package beanUtilsDemo01;9798import java.util.Arrays;99100import mons.beanutils.BeanUtils;101102//BeanUtils常⽤⽅法练习103104public class Demo01BeanUtils {105106public static void main(String[] args) throws Exception {107// 实例化对象108 Person p = new Person();109// 借⽤BeanUtils⼯具类向Person对象赋值110 BeanUtils.setProperty(p, "name", "Rose");111 BeanUtils.setProperty(p, "age", 22);112 BeanUtils.setProperty(p, "hobby", new String[] { "eating", "sleeping", 113 "kissing" });114// 打印对象115 System.out.println(p);116// 获取各属性值117 String[] hobby = BeanUtils.getArrayProperty(p, "hobby");118 System.out.println(Arrays.toString(hobby));119 String name = BeanUtils.getProperty(p, "name");120 System.out.println(name);121 String age = BeanUtils.getProperty(p, "age");122 System.out.println(age);125 }126代码演⽰2:封装map集合中的数据1package beanUtilsDemo01;23import ng.reflect.InvocationTargetException;4import java.util.HashMap;5import java.util.Map;67import mons.beanutils.BeanUtils;89//借⽤BeanUtils将Map中的数据封装到javabean中1011public class Demo02BeanUtils {1213public static void main(String[] args) throws IllegalAccessException,14 InvocationTargetException {15// 实例化对象16 Person p = new Person();17// 准备MAP集合18 Map<String, Object> map = new HashMap<>();19// 向map中添加数据20 map.put("name", "jack");21 map.put("age", 23);22 map.put("hobbyy", new String[] { "eating", "sleeping", "painting" });23// 将map集合中的数据封装到javabean中24 BeanUtils.populate(p, map);25 System.out.println(p);26 }27 }28代码演⽰3:与以上利⽤同⼀个Person类1package beanUtilsDemo01;23import java.util.HashMap;4import java.util.Map;56import mons.beanutils.BeanUtils;78//利⽤BeanUtils⼯具类⾃定义⼯具类:要求传⼊任⼀类型的字节码⽂件和属性的map集合,返回实例化对象 9class MyBeanUtils {10public static <T> T popu(Class<T> c, Map map) throws Exception { //泛型11 Object obj = c.newInstance();12 BeanUtils.populate(obj, map);13return (T) obj; //向下转型14 }15 }1617public class MyTest {18public static void main(String[] args) throws Exception {19 Map<String, Object> map = new HashMap<>();20 map.put("name", "rose");21 map.put("age", "18");22 Person p = MyBeanUtils.popu(Person.class, map);23 System.out.println(p);24 }2526 }27代码演⽰4:需准备⼀个User类,和以上的Person类,及data.xml⽂件1package beanutilcase;23import java.util.HashMap;4import java.util.List;7import mons.beanutils.BeanUtils;8import org.dom4j.Document;9import org.dom4j.Element;10import org.dom4j.io.SAXReader;1112public class Demo {1314public static void main(String[] args) throws Exception {15 Person p = new Person();16 User u = new User();17// 创建解析器对象18 SAXReader sax = new SAXReader();19// 读取⽂档,并获取根节点20 Document doc = sax.read("data.xml");21 Element root = doc.getRootElement();22// 获取根节点下的⼀级⼦元素23 List<Element> listFirst = root.elements();24// 迭代25for (Element e : listFirst) {26// 获取⼀级⼦元素的属性值27 String path = e.attributeValue("className");28// 根据路径(属性)获取字节码⽂件29 Class c = Class.forName(path);30// 获取⼆级⼦元素31 List<Element> listSecond = e.elements();32// 定义map集合装属性值33 Map<String, Object> map = new HashMap<>(); 34for (Element es : listSecond) {35// 获取⼆级⼦元素的两个属性值36 String name = es.attributeValue("name");37 String value = es.attributeValue("value");38 map.put(name, value);39 }40// 利⽤beanutils⼯具类进⾏封装41// 判断是否为person42if (path.matches(".*Person$")) {43 BeanUtils.populate(p, map);44 } else {45 BeanUtils.populate(u, map);46 }47 }48 System.out.println(p);49 System.out.println(u);50 }5152 }53。
beanutils copyproperties拷贝规则

beanutils copyproperties拷贝规则摘要:1.BeanUtils 简介2.copyProperties 拷贝规则3.应用示例正文:1.BeanUtils 简介BeanUtils 是一个Java 库,它提供了将Java 对象转换为XML 或JSON 格式的简单方法。
同时,BeanUtils 也支持将XML 或JSON 格式的数据转换为Java 对象。
BeanUtils 的使用可以大大简化Java 对象与XML 或JSON 格式之间的数据转换工作。
2.copyProperties 拷贝规则copyProperties 是BeanUtils 中的一个方法,用于拷贝一个对象的属性到另一个对象。
拷贝规则如下:- 如果源对象的属性值为null,那么目标对象的对应属性值也会被设置为null。
- 如果源对象的属性值为空字符串,那么目标对象的对应属性值也会被设置为空字符串。
- 对于基本数据类型,如int、float、boolean 等,直接进行值拷贝。
- 对于引用类型,如对象、数组等,会进行深度拷贝。
3.应用示例以下是一个使用BeanUtils 的copyProperties 方法进行对象属性拷贝的示例:```javaimport com.alibaba.beanutils.BeanUtils;public class Main {public static void main(String[] args) {Person source = new Person();source.setName("张三");source.setAge(25);source.setAddress(new Address("北京市", "朝阳区"));Person target = new Person();BeanUtils.copyProperties(source, target);System.out.println(target.getName()); // 输出:张三System.out.println(target.getAge()); // 输出:25System.out.println(target.getAddress().getCity()); // 输出:北京市}}```在这个示例中,我们创建了两个Person 对象,并通过BeanUtils 的copyProperties 方法将source 对象的属性拷贝到target 对象。
beanutil map转实体方法
一、背景介绍在Java开发中,经常需要将Map类型转换成实体类对象,以便于进行数据的操作和处理。
而Apache Commons BeanUtils提供了一种方便快捷的方法,可以帮助我们实现Map到实体的转换。
二、BeanUtils简介1. Apache Commons BeanUtils是一个开源的Java类库,提供了许多实用的工具方法,用于简化Java编程中的一些常见任务。
其中就包括了Map到实体的转换。
2. BeanUtils中的BeanUtils类提供了很多静态方法,可以实现不同类型对象之间的相互转换,其中就包括了Map到实体的转换方法。
三、Map到实体的转换方法1. 使用BeanUtils.populate()方法进行转换BeanUtils.populate()方法是BeanUtils类中用于Map到实体转换的核心方法,其原型如下:```javapublic static void populate(Object bean, Map properties)```该方法接收两个参数,第一个参数是目标实体对象,第二个参数是源Map对象。
方法的作用是将源Map中的属性值设置到目标实体对象中对应的属性上。
2. 转换示例下面是一个简单的示例代码,演示了如何使用BeanUtils.populate()方法将Map转换成实体对象:```java// 创建一个Map对象Map<String, Object> map = new HashMap<>();map.put("id", 1);map.put("name", "张三");// 创建一个空的实体对象User user = new User();// 调用BeanUtils.populate()方法进行转换BeanUtils.populate(user, map);// 现在user对象已经包含了从map中获取的属性值```四、转换注意事项1. 属性名称要一致在进行Map到实体的转换时,要求Map中的键值对对应的属性名在目标实体类中存在,并且名称要一致。
BeanUtils——JavaBean相互转换及字典翻译
BeanUtils——JavaBean相互转换及字典翻译JavaBean相互转换在升级公司架构过程中,发现有⼤量Entity与DTO相互转换的问题,并且其中还伴随DTO中的数据字典翻译,所以特意写个⼯具类,主要利⽤spring提供的BeanUtils⼯具类,⽤redis翻译字典其中功能包括:翻译JavaBean中带有@CacheFormat的属性/*** 翻译当前类中需要翻译的字典值** @param source 待翻译的对象*/public static <T> void dataFormatter(T source) {//判断原对象是否为nullAssert.notNull(source, "待翻译的原对象不能为null");//获取所有属性并翻译字典Field[] declaredFields = source.getClass().getDeclaredFields();//翻译字典:找出所有含有@CacheFormatter的属性Stream<Field> fieldStream = Arrays.stream(declaredFields)//排除没有注解@CacheFormatter的字段.filter(field -> field.isAnnotationPresent(CacheFormat.class));//翻译doFormatter(fieldStream, source, source.getClass());}翻译List中带有@CacheFormat的属性/*** 翻译当前集合类中需要翻译的字典值** @param sources 待翻译的集合对象*/public static <T> void dataFormatter(List<T> sources) {//当翻译的集合为空时,返回空的集合if (sources == null || sources.isEmpty()) {return;}Class targetClass = sources.get(0).getClass();//获取所有属性并翻译字典Field[] declaredFields = targetClass.getDeclaredFields();//翻译字典:找出所有含有@CacheFormat的属性集合List<Field> formatterFields = Arrays.stream(declaredFields)//排除没有注解@CacheFormat的字段.filter(field -> field.isAnnotationPresent(CacheFormat.class)).collect(Collectors.toList());//循环列表(并⾏操作)sources.parallelStream().forEach(target -> {//翻译doFormatter(formatterFields.stream(), target, targetClass);});}Entity 与DTO互转/*** 把原对象转换成⽬标类的对象,并翻译⽬标类的属性字典* 只针对⽬标类没有范型或者范型与原对象⼀样* @param source 原对象* @param targetClass ⽬标类* @return ⽬标对象*/public static <T> T dataConvert(Object source, Class<T> targetClass) {Assert.isTrue(source != null && targetClass != null, "原对象或⽬标class不能为null");T target = BeanUtils.instantiateClass(targetClass);//把⽬标对象的属性设置成原对象中对应的属性BeanUtils.copyProperties(source, target);dataFormatter(target);return target;}/*** 实体属性互转** @param source 原对象* @param target ⽬标对象* @return ⽬标对象*/public static <T> T dataObjConvert(Object source, T target) {Assert.isTrue(source != null && target != null, "待转换的原对象或⽬标对象不能为null");//转换BeanUtils.copyProperties(source, target);//翻译dataFormatter(target);return target;}List与List互转/*** 批量把原对象转换成⽬标对象,并翻译⽬标对象的属性字典* 如果想返回指定类型的集合即List的⼦类,参考{@link HyBeanUtils#dataConverts2}** @param sources 原对象集合* @param targetClass ⽬标对象的类* @return 返回转换后的⽬标集合*/public static <T, E> List<T> dataConverts(List<E> sources, Class<T> targetClass) {Assert.notNull(targetClass, "转换的⽬标Class不能为null");//当翻译的集合为空时,返回空的集合if (sources == null || sources.isEmpty()) {List<T> targetList = new ArrayList<>();return targetList;}//获取原集合的类型Class<? extends List> aClass = sources.getClass();//⽬标集合List<T> targetList = BeanUtils.instantiateClass(aClass);//把⽬标对象的属性设置成原对象中对应的属性(并⾏操作)sources.parallelStream().forEach(item -> {T target = BeanUtils.instantiateClass(targetClass);BeanUtils.copyProperties(item, target);targetList.add(target);});//翻译字典dataFormatter(targetList);return targetList;}这个是List转换的升级版 T与T互转,这⾥的T是List的⼦类之所以写这个,就是为了解决mybatis的Page转换问题/*** 返回指定类型的⽅法,这⾥的类型必须是List的⼦类* 批量把原对象转换成⽬标对象,并翻译⽬标对象的属性字典,** @param sources 原对象集合* @param targetClass ⽬标对象的类* @param returnType 返回值类型* @return 返回转换后的⽬标集合*/public static <T, E, R extends List<T>> R dataConverts2(List<E> sources, Class<T> targetClass, Class<R> returnType) { Assert.notNull(targetClass, "转换的⽬标Class不能为null");Assert.notNull(returnType, "返回值类型Class不能为null");//当翻译的集合为空时,返回空的集合if (sources == null || sources.isEmpty()) {return null;}//⽬标集合R targetList = BeanUtils.instantiateClass(returnType);//把⽬标对象的属性设置成原对象中对应的属性(并⾏操作)sources.parallelStream().forEach(item -> {T target = BeanUtils.instantiateClass(targetClass);BeanUtils.copyProperties(item, target);targetList.add(target);});//翻译字典dataFormatter(targetList);return targetList;}上述所⽤到的公共⽅法/*** 对⽬标类需要翻译的字段进⾏翻译** @param stream* @param target ⽬标对象* @param targetClass ⽬标对象类*/private static <T> void doFormatter(Stream<Field> stream, Object target, Class<T> targetClass) {//排除⽬标对象中字段值为null的字段stream.filter(field -> {PropertyDescriptor propertyDescriptor = BeanUtils.getPropertyDescriptor(targetClass, field.getName());Object invoke = null;try {invoke = propertyDescriptor.getReadMethod().invoke(target, new Object[]{});} catch (IllegalAccessException e) {logger.warn("待翻译的字段的get是⽆法访问的", e);} catch (InvocationTargetException e) {logger.warn("调⽤待翻译的字段的get⽅法时报错", e);} catch (Exception e) {logger.warn("确保属性有get,set⽅法", e);}return invoke != null;//遍历需要翻译的字段}).forEach(field -> {CacheFormat annotation = field.getAnnotation(CacheFormat.class);//缓存系统编号,如果不指定则默认为当前系统编号String systemCode = "system_code";if (StringUtils.isNotBlank(annotation.systemCode())) {systemCode = annotation.systemCode();}//缓存key,如果不指定,则默认为字段名称String key = annotation.key();if (StringUtils.isBlank(key)) {key = field.getName();}//判断注解@CacheFormatter是否指定把字典翻译到另⼀个字段上String formatterField = annotation.destination();if (StringUtils.isBlank(formatterField)) {//当注解中不指定其他字段时,默认翻译到加注解的属性上formatterField = field.getName();}try {PropertyDescriptor orginPropertyDescriptor = BeanUtils.getPropertyDescriptor(targetClass, field.getName());Object value = orginPropertyDescriptor.getReadMethod().invoke(target, new Object[]{});//设置⽬标字段值PropertyDescriptor propertyDescriptor = BeanUtils.getPropertyDescriptor(targetClass, formatterField);//取缓存String cacheValue = RedisUtils.hget(systemCode +":valueset:" + key, value + "");//如果数据字典中查询不到,则取业务缓存中取if (StringUtils.isBlank(cacheValue)) {cacheValue = RedisUtils.hget(systemCode + ":valueset:" + key, value + "");}Assert.hasLength(cacheValue, "在缓存" + key + "中没有找到" + value + "对应的缓存");//设置缓存值到属性字段中propertyDescriptor.getWriteMethod().invoke(target, cacheValue);} catch (IllegalAccessException e) {logger.warn("待翻译的字段的set是⽆法访问的", e);} catch (InvocationTargetException e) {logger.warn("调⽤待翻译的字段的set⽅法时报错", e);} catch (Exception e) {e.printStackTrace();logger.warn("调⽤待翻译的字段的set⽅法时报错,推测类型不匹配", e);}});}注解 CacheFormat@Target(ElementType.FIELD)@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface CacheFormat {/*** 缓存key* @return*/String key();/*** 指定翻译值存放字段, 例如:userType的翻译结果放到userTypeName上* @return*/String destination() default "";/*** 系统编号* @return*/String systemCode() default "";注意:该翻译只关注第⼀层即当前对象的属性,并不会递归翻译⽐如:当前类有⼀个属性为对象实例,该对象也有被@CacheFormat注解的属性这时该⼯具类不会去翻译这个属性中的属性,需要开发者先⽤当前⼯具类转换该属性然后再设置到⽬标类中。
beanutils 用法
beanutils 用法Beanutils是一个开源的Java类库,提供了一组可以对JavaBean进行操作的工具类。
它可以简化JavaBean的属性赋值、属性拷贝和动态创建对象等操作。
本文将详细介绍beanutils的用法,包括属性赋值、属性拷贝、动态创建对象和处理集合等功能。
一、属性赋值属性赋值是beanutils的一个常见用法,它能够通过反射来设置JavaBean 的属性值。
下面是一个示例:User user = new User();BeanUtils.setProperty(user, "name", "John");在这个示例中,我们创建了一个User对象,并使用BeanUtils的setProperty方法来设置其属性值。
其中,第一个参数是要设置属性值的对象,第二个参数是要设置的属性名称,第三个参数是属性值。
除了使用setProperty方法,我们还可以使用copyProperties方法来实现属性赋值。
copyProperties方法可以将一个对象的属性值复制到另一个对象上,如下所示:User user1 = new User();User user2 = new User();user1.setName("John");BeanUtils.copyProperties(user2, user1);在这个示例中,我们创建了两个User对象,并将user1对象的属性值复制到user2对象上。
通过copyProperties方法,我们可以方便地实现对象属性的复制。
二、属性拷贝属性拷贝是beanutils的另一个重要功能,它可以将一个对象的属性值拷贝到另一个对象的相应属性上。
下面是一个示例:User user = new User();Map<String, Object> properties = new HashMap<>(); properties.put("name", "John");BeanUtils.populate(user, properties);在这个示例中,我们创建了一个User对象,并使用populate方法将Map 中的属性值拷贝到user对象上。
BeanUtils的使用
设a,b为对象BeanUtils.copyProperties(a, b);如果这里的BeanUtils是org.springframework.beans.BeanUtils,a拷贝到b。
如果BeanUtils是mons.beanutils.BeanUtils,b拷贝到a。
、BeanUtils.copyProperties 和populate的实现方法是将源bean(也可以是Map)中的每个element在转换器(Converter)的帮助下,将转换的结果设置到目标bean对应的属性中。
例如在HTTP应用中需要从http request中抽取数据,http request传递过来的都是String 或是String数组类型的变量而目标类型可能是各种各样的,例如http request会有一个name=visitDate,value='2009-05-13'的参数,而目标bean 的visitDate属性的类型是java.util.Date。
BeanUtils的copyProperties和populate需要在转换器(converter)的配合下实现源和目标对象之间的数据类型的转换。
在BeanUtils.copyProperties的javadoc中说明的(Copy property values from the origin bean to the destination bean for all cases where the property names are the same——只要属性名相同就可以从源bean中拷贝值到目标bean 中)这句话提供到功能就是要通过转换器才能实现的。
在BeanUtils的copyProperties和populate的使用过程中Converter是一个非常重要的概念,它提供了强大的扩展能力。
/****************************************************************/ public interface Converter {public Object convert(Class type, Object value);}/*********************************************************** *****/convert方法的参数type是目标转换的类型,参数value是被转换的值,返回值就是转换以后的结果。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
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一个属性的值。
它将property分成3种类型:Simple——简单类型,如Stirng、Int……Indexed——索引类型,如数组、arrayList……Maped——这个不用说也该知道,就是指Map啦,比如HashMap……访问不同类型的数据可以直接调用函数getProperty和setProperty。
它们都只有2个参数,第一个是JavaBean对象,第二个是要操作的属性名。
Company c = new Company();c.setName("Simple");对于Simple类型,参数二直接是属性名即可//SimpleSystem.out.println(BeanUtils.getProperty(c, "name"));对于Map类型,则需要以“属性名(key值)”的形式//MapSystem.out.println(BeanUtils.getProperty(c, "address (A2)"));HashMap am = new HashMap();am.put("1","234-222-1222211");am.put("2","021-086-1232323");BeanUtils.setProperty(c,"telephone",am);System.out.println(BeanUtils.getProperty(c, "telephone (2)"));对于Indexed,则为“属性名[索引值]”,注意这里对于ArrayList和数组都可以用一样的方式进行操作。
//indexSystem.out.println(BeanUtils.getProperty(c, "otherInfo[2]"));BeanUtils.setProperty(c, "product[1]", "NOTES SERVER");System.out.println(BeanUtils.getProperty(c, "product[1]"));当然这3种类也可以组合使用啦!//nestSystem.out.println(BeanUtils.getProperty(c, "employee[1].name"));3、此外,还有一个很重要的方法copyProperty,可以直接进行Bean之间的clone。
Company c2 = new Company();BeanUtils.copyProperties(c2, c);但是这种copy都是浅拷贝,复制后的2个Bean的同一个属性可能拥有同一个对象的ref,这个在使用时要小心,特别是对于属性为自定义类的情况。
4、最后还有populate,它用于将一个map的值填充到一个bean中,其函数原型如下:public void populate(ng.Object bean,java.util.Map properties)throws ng.IllegalAccessException,ng.reflect.InvocationTargetException在struts中这个函数被用于从http request中取得参数添加到FormBean,目前好像我也没有看到这个函数还有什么其他的用途?!以后想到再说吧:PzyDynaBean它实现一个动态的Bean,可以直接往里面加入属性,作为一个JavaBean一样使用,也可以用上面的BeanUtils或get/set方法进行操作,而不用事先定义一个标准的JavaBean类啦:)记得在J2ee设计模式中有一种Value Object的模式,用于在MVC各层之间传递数据,避免直接传递大业务对象引起的性能问题,为了避免在项目中出现很多Bean类,在书中提供了一个动态Value Object的实现(通过扩展Map)。
这里LazyDynaBean则可以作为一种更加成熟、稳定的实现来使用。
呵呵,原来曾打算自己写一个类似的value object类的,现在看来可以直接用这个啦:P言归正传,LazyBean的确提供了一个很不错的DynaBean的实现。
而且就像它的名字中表述的那样,它的确是为我这样的懒人考虑的很周到,用起来几乎不需要写什么多余的代码^_^,下面就看看使用的例子吧!//这里使用LazyDynaMap,它是LazyBean的一个轻量级实现LazyDynaMap dynaBean1 = new LazyDynaMap();dynaBean1.set("foo", "bar"); // simpledynaBean1.set("customer", "title", "Mr"); // mappeddynaBean1.set("address", 0, "address1"); // indexedSystem.out.println(dynaBean1.get("address",0));Map myMap = dynaBean1.getMap(); // retrieve the MapSystem.out.println(myMap.toString());上面的例子可以看到,它可以在set时自动增加bean的property(既赋值的同时增加Bean中的property),同时也支持3中类型的property,并且LazyDynaMap还可以导出为map。
对于这个类还有两个重要的Field要注意:returnnull——指定在get方法使用了一个没有定义过的property时,DynaBean的行为。
//取的字段的信息dynaBean1.setReturnNull(true);//设为ture。
若Bean中没有此字段,返回null//默认为false。
若Bean中没有此字段,自动增加一个:)System.out.println(dynaBean1.get("aaa"));//此时返回nullRestricted——指定是否允许改变这个bean的property。
//MutableDynaClass.setRestricted设为true后,字段不可再增删和修改.//默认为false,允许增删和修改dynaBean1.setRestricted(true);dynaBean1.set("test","error");//这里会出错!通过设置这两个属性,可以防止意外修改DynaBean的property。
在设计架构时,你可以在后台从数据表或xml文件自动产生DynaBean,在传到控制层和表示层之前设置上述属性使其Bean结构不允许修改,如此就不可能无意中修改Bean包含的属性……这样既可以享用它的便利,有可以防止由此引入的错误可能,设计者实在深得偷懒的精髓啊!!!!!3. 其他3.1.BeanUtils和PropertyUtils这两个类几乎有一摸一样的功能,唯一的区别是:BeanUtils在对Bean赋值是会进行类型转化。