com.wichell.core.util.InstanceUtil Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of wichell-common Show documentation
Show all versions of wichell-common Show documentation
common project com.wichell.wichell jar
The newest version!
package com.wichell.core.util;
import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Vector;
import java.util.WeakHashMap;
import java.util.concurrent.ConcurrentHashMap;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import com.wichell.core.exception.DataParseException;
import com.wichell.core.exception.InstanceException;
import com.esotericsoftware.reflectasm.MethodAccess;
/**
* 实例辅助类
*
* @author Wichell
* @since 2012-07-18
*/
public final class InstanceUtil {
protected static Logger logger = LogManager.getLogger(InstanceUtil.class);
private InstanceUtil() {
}
/** 实例化并复制属性 */
public static final T to(Object orig, Class clazz) {
T bean = null;
try {
bean = clazz.newInstance();
PropertyUtils.copyProperties(bean, orig);
} catch (Exception e) {
}
return bean;
}
// Map --> Bean 1: 利用Introspector,PropertyDescriptor实现 Map --> Bean
public static T transMap2Bean(Map map, Class clazz) {
T bean = null;
try {
bean = clazz.newInstance();
BeanInfo beanInfo = Introspector.getBeanInfo(clazz);
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor property : propertyDescriptors) {
String key = property.getName();
if (map.containsKey(key)) {
Object value = map.get(key);
// 得到property对应的setter方法
Method setter = property.getWriteMethod();
setter.invoke(bean, TypeParseUtil.convert(value, property.getPropertyType(), null));
}
}
} catch (Exception e) {
logger.error("transMap2Bean Error ", e);
}
return bean;
}
// Bean --> Map 1: 利用Introspector和PropertyDescriptor 将Bean --> Map
public static Map transBean2Map(Object obj) {
Map map = newHashMap();
if (obj == null) {
return map;
}
try {
BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor property : propertyDescriptors) {
String key = property.getName();
// 过滤class属性
if (!key.equals("class")) {
// 得到property对应的getter方法
Method getter = property.getReadMethod();
Object value = getter.invoke(obj);
map.put(key, value);
}
}
} catch (Exception e) {
System.out.println("transBean2Map Error " + e);
}
return map;
}
/**
* @param oldBean
* @param newBean
* @return
*/
public static T getDiff(T oldBean, T newBean) {
if (oldBean == null && newBean != null) {
return newBean;
} else if (newBean == null) {
return null;
} else {
Class cls1 = oldBean.getClass();
try {
@SuppressWarnings("unchecked")
T object = (T)cls1.newInstance();
BeanInfo beanInfo = Introspector.getBeanInfo(cls1);
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor property : propertyDescriptors) {
String key = property.getName();
// 过滤class属性
if (!key.equals("class")) {
// 得到property对应的getter方法
Method getter = property.getReadMethod();
// 得到property对应的setter方法
Method setter = property.getWriteMethod();
Object oldValue = getter.invoke(oldBean);
Object newValue = getter.invoke(newBean);
if (newValue != null) {
if (oldValue == null) {
setter.invoke(object, newValue);
} else if (oldValue != null && !newValue.equals(oldValue)) {
setter.invoke(object, newValue);
}
}
}
}
return object;
} catch (Exception e) {
throw new DataParseException(e);
}
}
}
/**
* Return the specified class. Checks the ThreadContext classloader first,
* then uses the System classloader. Should replace all calls to
* Class.forName( claz ) (which only calls the System class
* loader) when the class might be in a different classloader (e.g. in a
* webapp).
*
* @param clazz
* the name of the class to instantiate
* @return the requested Class object
*/
public static final Class getClass(String clazz) {
/**
* Use the Thread context classloader if possible
*/
ClassLoader loader = Thread.currentThread().getContextClassLoader();
try {
if (loader != null) {
return Class.forName(clazz, true, loader);
}
/**
* Thread context classloader isn't working out, so use system
* loader.
*/
return Class.forName(clazz);
} catch (ClassNotFoundException e) {
throw new InstanceException(e);
}
}
/**
* 封装实体
*
* @param cls
* 实体类
* @param list
* 实体Map集合
* @return
*/
public static final List getInstanceList(Class cls, List list) {
List resultList = newArrayList();
E object = null;
for (Iterator iterator = list.iterator(); iterator.hasNext();) {
Map map = (Map)iterator.next();
object = newInstance(cls, map);
resultList.add(object);
}
return resultList;
}
/**
* 封装实体
*
* @param cls
* 实体类
* @param list
* 数据查询结果集
* @return
*/
public static final List getInstanceList(Class cls, ResultSet rs) {
List resultList = newArrayList();
try {
E object = cls.newInstance();
Field[] fields = cls.getDeclaredFields();
while (rs.next()) {
object = cls.newInstance();
for (int i = 0; i < fields.length; i++) {
String fieldName = fields[i].getName();
PropertyUtils.setProperty(object, fieldName, rs.getObject(fieldName));
}
resultList.add(object);
}
} catch (Exception e) {
throw new InstanceException(e);
}
return resultList;
}
/**
* 新建实例
*
* @param cls
* 实体类
* @param list
* 实体属性Map
* @return
*/
public static final E newInstance(Class cls, Map map) {
E object = null;
try {
object = cls.newInstance();
BeanUtils.populate(object, map);
} catch (Exception e) {
throw new InstanceException(e);
}
return object;
}
/**
* Return a new instance of the given class. Checks the ThreadContext
* classloader first, then uses the System classloader. Should replace all
* calls to Class.forName( claz ).newInstance() (which only
* calls the System class loader) when the class might be in a different
* classloader (e.g. in a webapp).
*
* @param clazz
* the name of the class to instantiate
* @return an instance of the specified class
*/
public static final Object newInstance(String clazz) {
try {
return getClass(clazz).newInstance();
} catch (Exception e) {
throw new InstanceException(e);
}
}
public static final K newInstance(Class cls, Object... args) {
try {
Class[] argsClass = null;
if (args != null) {
argsClass = new Class[args.length];
for (int i = 0, j = args.length; i < j; i++) {
argsClass[i] = args[i].getClass();
}
}
Constructor cons = cls.getConstructor(argsClass);
return cons.newInstance(args);
} catch (Exception e) {
throw new InstanceException(e);
}
}
public static Map> clazzMap = new HashMap>();
/**
* 新建实例
*
* @param className
* 类名
* @param args
* 构造函数的参数
* @return 新建的实例
*/
public static final Object newInstance(String className, Object... args) {
try {
Class newoneClass = clazzMap.get(className);
if (newoneClass == null) {
newoneClass = Class.forName(className);
clazzMap.put(className, newoneClass); // 缓存class对象
}
return newInstance(newoneClass, args);
} catch (Exception e) {
throw new InstanceException(e);
}
}
public static Map methodMap = new HashMap();
/**
* 执行某对象方法
*
* @param owner
* 对象
* @param methodName
* 方法名
* @param args
* 参数
* @return 方法返回值
*/
public static final Object invokeMethod(Object owner, String methodName, Object... args) {
Class ownerClass = owner.getClass();
String key = null;
if (args != null) {
Class[] argsClass = new Class[args.length];
for (int i = 0, j = args.length; i < j; i++) {
if (args[i] != null) {
argsClass[i] = args[i].getClass();
}
}
key = ownerClass + "_" + methodName + "_" + StringUtils.join(argsClass, ","); // 用于区分重载的方法
} else {
key = ownerClass + "_" + methodName; // 用于区分重载的方法
}
MethodAccess methodAccess = methodMap.get(key);
if (methodAccess == null) {
methodAccess = MethodAccess.get(ownerClass);
methodMap.put(key, methodAccess); // 缓存Method对象
}
return methodAccess.invoke(owner, methodName, args);
}
/**
* Constructs an empty ArrayList.
*/
public static final ArrayList newArrayList() {
return new ArrayList();
}
/**
* Constructs an empty ArrayList.
*/
@SuppressWarnings("unchecked")
public static final ArrayList newArrayList(E... e) {
ArrayList list = new ArrayList();
Collections.addAll(list, e);
return list;
}
/**
* Constructs an empty HashMap.
*/
public static final HashMap newHashMap() {
return new HashMap();
}
/**
* Constructs an empty HashSet.
*/
public static final HashSet newHashSet() {
return new HashSet();
}
/**
* Constructs an empty Hashtable.
*/
public static final Hashtable newHashtable() {
return new Hashtable();
}
/**
* Constructs an empty LinkedHashMap.
*/
public static final LinkedHashMap newLinkedHashMap() {
return new LinkedHashMap();
}
/**
* Constructs an empty LinkedHashSet.
*/
public static final LinkedHashSet newLinkedHashSet() {
return new LinkedHashSet();
}
/**
* Constructs an empty LinkedList.
*/
public static final LinkedList newLinkedList() {
return new LinkedList();
}
/**
* Constructs an empty TreeMap.
*/
public static final TreeMap newTreeMap() {
return new TreeMap();
}
/**
* Constructs an empty TreeSet.
*/
public static final TreeSet newTreeSet() {
return new TreeSet();
}
/**
* Constructs an empty Vector.
*/
public static final Vector newVector() {
return new Vector();
}
/**
* Constructs an empty WeakHashMap.
*/
public static final WeakHashMap newWeakHashMap() {
return new WeakHashMap();
}
/**
* Constructs an HashMap.
*/
public static final HashMap newHashMap(k key, v value) {
HashMap map = newHashMap();
map.put(key, value);
return map;
}
/**
* Constructs an LinkedHashMap.
*/
public static final LinkedHashMap newLinkedHashMap(k key, v value) {
LinkedHashMap map = newLinkedHashMap();
map.put(key, value);
return map;
}
/**
* Constructs an empty ConcurrentHashMap.
*/
public static final ConcurrentHashMap newConcurrentHashMap() {
return new ConcurrentHashMap();
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy