package com.td.masterdata.util;
import java.util.Iterator;
import java.util.Map;
import org.apache.commons.beanutils.PropertyUtils;
/**
* 扩展org.apache.commons.beanutils.BeanUtils<br>
*
* @author Wesley<br>
*
*/
public class BeanUtils extends org.apache.commons.beanutils.BeanUtils {
/**
* 将源对象中的值覆盖到目标对象中，仅覆盖源对象中不为NULL值的属性
*
* @param dest
* 目标对象，标准的JavaBean
* @param orig
* 源对象，可为Map、标准的JavaBean
* @throws BusinessException
*/
@SuppressWarnings("rawtypes")
public static void applyIf(Object dest, Object orig) throws Exception {
try {
if (orig instanceof Map) {
Iterator names = ((Map) orig).keySet().iterator();
while (names.hasNext()) {
String name = (String) names.next();
if (PropertyUtils.isWriteable(dest, name)) {
Object value = ((Map) orig).get(name);
if (value != null) {
PropertyUtils.setSimpleProperty(dest, name, value);
}
}
}
} else {
java.lang.reflect.Field[] fields = orig.getClass().getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
String name = fields[i].getName();
if (PropertyUtils.isReadable(orig, name) && PropertyUtils.isWriteable(dest, name)) {
Object value = PropertyUtils.getSimpleProperty(orig, name);
if (value != null) {
PropertyUtils.setSimpleProperty(dest, name, value);
}
}
}
}
} catch (Exception e) {
throw new Exception("将源对象中的值覆盖到目标对象中，仅覆盖源对象中不为NULL值的属性", e);
}
}
/**
* 将源对象中的值覆盖到目标对象中，仅覆盖源对象中不为NULL值的属性
*
* @param orig
* 源对象，标准的JavaBean
* @param dest
* 排除检查的属性，Map
*
* @throws BusinessException
*/
@SuppressWarnings("rawtypes")
public static boolean checkObjProperty(Object orig, Map dest) throws Exception {
try {
java.lang.reflect.Field[] fields = orig.getClass().getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
String name = fields[i].getName();
if (!dest.containsKey(name)) {
if (PropertyUtils.isReadable(orig, name)) {
Object value = PropertyUtils.getSimpleProperty(orig, name);
if (value == null) {
return true;
}
}
}
}
return false;
} catch (Exception e) {
throw new Exception("将源对象中的值覆盖到目标对象中，仅覆盖源对象中不为NULL值的属性", e);
}
}
}
package com.td.masterdata.util;
import java.util.Locale;
/**
* javaBean的基本构成字符串转换方法
*
* @author Wesley
*
*/
public class JavaBeanUtil {
private static final char SEPARATOR = '_';
/**
* 将属性样式字符串转成驼峰样式字符串<br>
* (例:branchNo -> branch_no)<br>
*
* @param inputString
* @return
*/
public static String toUnderlineString(String inputString) {
if (inputString == null)
return null;
StringBuilder sb = new StringBuilder();
boolean upperCase = false;
for (int i = 0; i < inputString.length(); i++) {
char c = inputString.charAt(i);
boolean nextUpperCase = true;
if (i < (inputString.length() - 1)) {
nextUpperCase = Character.isUpperCase(inputString.charAt(i + 1));
}
if ((i >= 0) && Character.isUpperCase(c)) {
if (!upperCase || !nextUpperCase) {
if (i > 0)
sb.append(SEPARATOR);
}
upperCase = true;
} else {
upperCase = false;
}
sb.append(Character.toLowerCase(c));
}
return sb.toString();
}
/**
* 将驼峰字段转成属性字符串<br>
* (例:branch_no -> branchNo )<br>
*
* @param inputString
* 输入字符串
* @return
*/
public static String toCamelCaseString(String inputString) {
return toCamelCaseString(inputString, false);
}
/**
* 将驼峰字段转成属性字符串<br>
* (例:branch_no -> branchNo )<br>
*
* @param inputString
* 输入字符串
* @param firstCharacterUppercase
* 是否首字母大写
* @return
*/
public static String toCamelCaseString(String inputString, boolean firstCharacterUppercase) {
if (inputString == null)
return null;
StringBuilder sb = new StringBuilder();
boolean nextUpperCase = false;
for (int i = 0; i < inputString.length(); i++) {
char c = inputString.charAt(i);
switch (c) {
case '_':
case '-':
case '@':
case '$':
case '#':
case ' ':
case '/':
case '&':
if (sb.length() > 0) {
nextUpperCase = true;
}
break;
default:
if (nextUpperCase) {
sb.append(Character.toUpperCase(c));
nextUpperCase = false;
} else {
sb.append(Character.toLowerCase(c));
}
break;
}
}
if (firstCharacterUppercase) {
sb.setCharAt(0, Character.toUpperCase(sb.charAt(0)));
}
return sb.toString();
}
/**
* 得到标准字段名称
*
* @param inputString
* 输入字符串
* @return
*/
public static String getValidPropertyName(String inputString) {
String answer;
if (inputString == null) {
answer = null;
} else if (inputString.length() < 2) {
answer = inputString.toLowerCase(Locale.US);
} else {
if (Character.isUpperCase(inputString.charAt(0)) && !Character.isUpperCase(inputString.charAt(1))) {
answer = inputString.substring(0, 1).toLowerCase(Locale.US) + inputString.substring(1);
} else {
answer = inputString;
}
}
return answer;
}
/**
* 将属性转换成标准set方法名字符串<br>
*
* @param property
* @return
*/
public static String getSetterMethodName(String property) {
StringBuilder sb = new StringBuilder();
sb.append(property);
if (Character.isLowerCase(sb.charAt(0))) {
if (sb.length() == 1 || !Character.isUpperCase(sb.charAt(1))) {
sb.setCharAt(0, Character.toUpperCase(sb.charAt(0)));
}
}
sb.insert(0, "set");
return sb.toString();
}
/**
* 将属性转换成标准get方法名字符串<br>
*
* @param property
* @return
*/
public static String getGetterMethodName(String property) {
StringBuilder sb = new StringBuilder();
sb.append(property);
if (Character.isLowerCase(sb.charAt(0))) {
if (sb.length() == 1 || !Character.isUpperCase(sb.charAt(1))) {
sb.setCharAt(0, Character.toUpperCase(sb.charAt(0)));
}
}
sb.insert(0, "get");
return sb.toString();
}
public static void main(String[] args) {
System.out.println(JavaBeanUtil.toUnderlineString("ISOCertifiedStaff"));
System.out.println(JavaBeanUtil.getValidPropertyName("CertifiedStaff"));
System.out.println(JavaBeanUtil.getSetterMethodName("userID"));
System.out.println(JavaBeanUtil.getGetterMethodName("userID"));
System.out.println(JavaBeanUtil.toCamelCaseString("iso_certified_staff", true));
System.out.println(JavaBeanUtil.getValidPropertyName("certified_staff"));
System.out.println(JavaBeanUtil.toCamelCaseString("site_Id"));
}
}
package com.td.masterdata.util;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Map工具类<br>
*
* @author Wesley<br>
*
*/
public class MapUtils extends org.apache.commons.collections.MapUtils {
/**
* 将Map转换为Object
*
* @param clazz
* 目标对象的类
* @param map
* 待转换Map
* @return
* @throws InstantiationException
* @throws IllegalAccessException
* @throws InvocationTargetException
*/
public static <T, V> T toObject(Class<T> clazz, Map<String, V> map) throws InstantiationException, IllegalAccessException, InvocationTargetException {
T object = clazz.newInstance();
return toObject(object, map);
}
/**
* 将Map转换为Object
*
* @param clazz
* 目标对象的类
* @param map
* 待转换Map
* @param toCamelCase
* 是否去掉下划线
* @return
* @throws InstantiationException
* @throws IllegalAccessException
* @throws InvocationTargetException
*/
public static <T, V> T toObject(Class<T> clazz, Map<String, V> map, boolean toCamelCase) throws InstantiationException, IllegalAccessException, InvocationTargetException {
T object = clazz.newInstance();
return toObject(object, map, toCamelCase);
}
/**
* 将Map转换为Object
*
* @param object
* 目标对象
* @param map
* 待转换Map
* @return
* @throws InstantiationException
* @throws IllegalAccessException
* @throws InvocationTargetException
*/
public static <T, V> T toObject(T object, Map<String, V> map) throws InstantiationException, IllegalAccessException, InvocationTargetException {
return toObject(object, map, false);
}
public static <T, V> T toObject(T object, Map<String, V> map, boolean toCamelCase) throws InstantiationException, IllegalAccessException, InvocationTargetException {
if (toCamelCase)
map = toCamelCaseMap(map);
BeanUtils.populate(object, map);
return object;
}
/**
* 对象转Map
*
* @param object
* 目标对象
* @return
* @throws IllegalAccessException
* @throws InvocationTargetException
* @throws NoSuchMethodException
*/
@SuppressWarnings("unchecked")
public static Map<String, String> toMap(Object object) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
return BeanUtils.describe(object);
}
/**
* 转换为Collection<Map<K, V>>
*
* @param collection
* 待转换对象集合
* @return 转换后的Collection<Map<K, V>>
* @throws IllegalAccessException
* @throws InvocationTargetException
* @throws NoSuchMethodException
*/
public static <T> Collection<Map<String, String>> toMapList(Collection<T> collection) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
List<Map<String, String>> retList = new ArrayList<Map<String, String>>();
if (collection != null && !collection.isEmpty()) {
for (Object object : collection) {
Map<String, String> map = toMap(object);
retList.add(map);
}
}
return retList;
}
/**
* 转换为Collection,同时为字段做驼峰转换<Map<K, V>>
*
* @param collection
* 待转换对象集合
* @return 转换后的Collection<Map<K, V>>
* @throws IllegalAccessException
* @throws InvocationTargetException
* @throws NoSuchMethodException
*/
public static <T> Collection<Map<String, String>> toMapListForFlat(Collection<T> collection) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
List<Map<String, String>> retList = new ArrayList<Map<String, String>>();
if (collection != null && !collection.isEmpty()) {
for (Object object : collection) {
Map<String, String> map = toMapForFlat(object);
retList.add(map);
}
}
return retList;
}
/**
* 转换成Map并提供字段命名驼峰转平行
*
* @param clazz
* 目标对象所在类
* @param object
* 目标对象
* @param map
* 待转换Map
* @throws NoSuchMethodException
* @throws InvocationTargetException
* @throws IllegalAccessException
*/
public static Map<String, String> toMapForFlat(Object object) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
Map<String, String> map = toMap(object);
return toUnderlineStringMap(map);
}
/**
* 将Map的Keys去下划线<br>
* (例:branch_no -> branchNo )<br>
*
* @param map
* 待转换Map
* @return
*/
public static <V> Map<String, V> toCamelCaseMap(Map<String, V> map) {
Map<String, V> newMap = new HashMap<String, V>();
for (String key : map.keySet()) {
safeAddToMap(newMap, JavaBeanUtil.toCamelCaseString(key), map.get(key));
}
return newMap;
}
/**
* 将Map的Keys转译成下划线格式的<br>
* (例:branchNo -> branch_no)<br>
*
* @param map
* 待转换Map
* @return
*/
public static <V> Map<String, V> toUnderlineStringMap(Map<String, V> map) {
Map<String, V> newMap = new HashMap<String, V>();
for (String key : map.keySet()) {
newMap.put(JavaBeanUtil.toUnderlineString(key), map.get(key));
}
return newMap;
}
}
分享到：
相关推荐
总之，Java Map到Bean的转换是通过反射和JavaBeans规范实现的，这是Java开发中常用的一种数据转换技巧。理解并熟练运用这些知识，能够帮助我们更高效地处理各种数据结构，提升代码的灵活性。在实际项目中，可以根据...
3. **Map与Bean互转**：此外，工具类还可能支持Map对象与Bean对象之间的转换。Map对象的键对应于Bean的属性名，值则对应属性值。这种转换可以帮助在不关心具体Bean结构的情况下，灵活地处理数据。 4. **数据拷贝**...
在Java编程中，Java Bean对象和Map...总的来说，Fastjson和BeanMap都是实用的工具，它们简化了Java Bean对象和Map之间的转换，使得数据操作更加灵活和高效。在实际开发中，可以根据项目需求和性能要求选择合适的方法。
在Java编程中，数据结构的转换是常见的...在处理大量数据转换时，自定义的转换工具类如`collectionUtils`能够极大提升开发效率，使代码更加简洁和易懂。理解和熟练运用这些技术，对于提高Java编程能力具有重要意义。
Apache Commons Lang、Dozer、ModelMapper等库提供了丰富的转换工具，简化了这一过程。 在实际应用中，比如“动态bean转换”，可能指的是将动态生成的bean对象转换为其他格式，如XML字符串或Map，以便进一步处理或...
总的来说，`JAVA-JSON工具转换类`这个主题涵盖了JSON数据处理的核心部分，包括JSON的序列化和反序列化，以及数据类型的转换。通过`json-lib`和`ezmorph`这两个库，开发者可以轻松地在Java程序中处理JSON数据，而`...
Gson可以自动处理数组和集合类型的转换，包括List、Set、Map等。 5. 深度复制对象： 通过将对象转换为JSON字符串，然后再转换回对象，可以实现对象的深度复制。 三、Gson与其它库的比较 1. Jackson：Jackson...
标题中的“复制bean的开源工具Dozer”指的是一个名为Dozer的Java库，它主要用于对象到对象的映射。在Java开发中，特别是在处理不同数据模型之间转换时，Dozer提供了一个方便、高效的解决方案。这个工具能够自动地将...
这里提到的`BeanUtilities`工具类就是这样一个专门为处理Java Bean对象提供便利的工具，它允许开发者根据请求数据自动填充Java Bean对象。在给定的压缩包文件中，包含了`commons-collections.jar`、`commons-...
本文将深入探讨如何使用JSON-lib库实现JSON与Java Bean、Map、List等数据结构之间的相互转换。 #### JSON-lib简介及安装 JSON-lib是早期非常流行的用于处理JSON的Java库之一。它提供了强大的功能，能够将JSON字符...
在Java世界中，JAXB（Java Architecture for XML Binding）是一个标准的API，用于将XML文档与Java对象之间进行互相...虽然JAXB不直接提供这个功能，但结合其他Java工具和库，我们可以实现高效且准确的XML到Map的转换。
在Java开发中，特别是在使用Spring框架时，将数据库中的数据转换为Map对象是一种常见的操作。这样做可以简化数据处理，使得数据以键值对的形式存储...在实际开发中，结合使用Java Bean和Map对象，可以达到最佳的效果。
它通过代码生成的方式，极大地提高了在Spring框架中进行对象复制的效率，相比传统的`Spring BeanUtils`或者`ModelMapper`等工具，MapStruct具有更高的性能和更简洁的API。本文将深入探讨MapStruct的工作原理、优点、...
3. 执行映射：在业务代码中，我们可以调用DozerUtil的`map`方法，传入源对象和目标类的Class类型，Dozer会自动完成复制。 ```java MySource src = ...; // 初始化源对象 MyDestination dest = DozerUtil.map(src, ...
在上述代码中，`SourceObject`和`TargetObject`是两个具有相似属性但不完全相同的类，`mapper.map()`方法将源对象转换为目标对象。 总之，Orika是一个强大且灵活的Java Bean映射框架，能够帮助开发者快速实现对象间...
在Java开发中，常常需要在Map和对象之间，以及Map和JSON之间进行转换。这样的转换在处理Web请求、数据存储和传输时非常常见。Java本身并没有提供直接的转换机制，但通过一些第三方库或反射机制，我们可以实现这些...
综上所述，JavaBean2Map是一个实用的工具，通过XML配置驱动的转换引擎，使得在JavaBean和Map之间灵活地进行数据转换成为可能。它的开源性质促进了社区参与和改进，使得这个工具更加健壮和适应各种需求。
本文档旨在详细介绍两种用于Java对象到JSON格式转换的工具类：`JsonUtilsForJsonLib` 和 `JsonUtils`。这两种工具类可以帮助开发者高效地完成对象到JSON的转换工作。 #### 二、`JsonUtils`工具类详解 `JsonUtils` ...