package com.jqmobile.core.utils.plain;
import java.lang.reflect.Field;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import com.jqmobile.core.orm.DBColumn;
import com.jqmobile.core.orm.exception.ORMException;
/**
* 对象处理UTILS工具类
* <p>
* 20130810 对象拷贝，按属性拷贝（安全风险，仅限内部使用）
*
* @author modi
*
*/
public final class BeanUtils {
private BeanUtils() {
}
//
public static BeanUtils getInstance() {
return new BeanUtils();
}
private static final Map<Class<?>, Field[]> map = new HashMap<Class<?>, Field[]>();
public static Field[] getAllFields_Cache(Class<?> c) {
synchronized (map) {
if (!map.containsKey(c)) {
map.put(c, getAllFields(c));
}
}
return map.get(c);
}
public static Field[] getAllFields(Class<?> c) {
List<Field> list = new ArrayList<Field>();
while (c != Object.class) {
list.addAll(Arrays.asList(c.getDeclaredFields()));
c = c.getSuperclass();
}
// List<Field> result = new ArrayList<Field>();
// for(Field f : list){
// if(f.getName().contains("$")){
// continue;
// }
// result.add(f);
// }
return list.toArray(new Field[list.size()]);
}
//
public interface ToFilter {
/**
* 字段转换拦截处理器
*
* @param from
* @param to
* @return 处理成功返回true（跳入下一次处理），处理失败返回false（继续本次处理）
* @throws Throwable
* 异常表示处理失败
*/
boolean filter(Field from, Field to) throws Throwable;
}
private final List<ToFilter> filters = new ArrayList<ToFilter>();
/**
* add filter
*
* @param filter
*/
public BeanUtils addFilter(ToFilter filter) {
filters.add(filter);
return this;
}
/**
* remove filter
*
* @param filter
*/
public void removeFilter(ToFilter filter) {
filters.remove(filter);
}
/**
* clear filter
*/
public void clear() {
filters.clear();
}
/**
* 对象拷贝
*
* @param from
* @param to
*/
public void to(Object from, Object to) {
Field[] fs = getAllFields(from.getClass());
Field[] ts = getAllFields(to.getClass());
L1: for (Field t : ts) {
for (Field f : fs) {
for (ToFilter filter : filters) {
try {
if (filter.filter(f, t)) {
continue L1;
}
} catch (Throwable e) {
}
}
if (t.getName().equals(f.getName())
&& t.getType().equals(f.getType())) {
t.setAccessible(true);
f.setAccessible(true);
try {
t.set(to, f.get(from));
} catch (Exception e) {
// e.printStackTrace();
Log.getLog(getClass()).e(e);
continue L1;
}
}
}
}
}
/**
* 用于万能对象与实体类之间的转换, 需要手动设置表名
*
* @param bean
* 万能对象或实体对象
* @return 万能对象或尸体对象
* @throws ORMException
* @throws IllegalAccessException
* @throws IllegalArgumentException
*/
@SuppressWarnings("unchecked")
public static <T> T copy(Object bean, Class<?> entityClass) throws ORMException {
if (bean != null) {
ModBean modiBean = new ModBean();
if (bean instanceof ModBean) {
// 初始化各属性值
modiBean = (ModBean) bean;
ModColumn mc = new ModColumn();
List<ModColumn> mcList = modiBean.getModiColumns();
T obj = null;
try {
obj = (T) entityClass.newInstance();
// 循环赋值
for (int i = 0; i < mcList.size(); i++) {
mc = mcList.get(i);
for (Field field : entityClass.getDeclaredFields()) {
field.setAccessible(true);
if (mc.getName().equals(field.getName())) {
System.out.println(field.getName());
if((field.getAnnotation(DBColumn.class)!=null)&&(field.getAnnotation(DBColumn.class).primaryId()||field.getAnnotation(DBColumn.class).id())){
if(field.getType().isAssignableFrom(String.class)){
field.set(obj, (UUIDUtils.getUUID((byte[]) mc.getValue()).toString()));
continue;
}else if(field.getType().isAssignableFrom(UUID.class)){
field.set(obj, (UUIDUtils.getUUID((byte[]) mc.getValue())));
continue;
}else{
throw new ORMException("类型映射错误，不支持此类型");
}
}
System.out.println(mc.getType().toString().toLowerCase());
if(mc.getType().toString().toLowerCase().equals("date")){
field.set(obj, ((Timestamp)mc.getValue()).getTime());
continue;
}
field.set(obj, mc.getValue());
}
}
}
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return obj;
} else {
// 传入实体类
Class<?> c = bean.getClass();
Field[] beanFields = c.getDeclaredFields();
for (int i = 0; i < beanFields.length; i++) {
Field field = beanFields[i];
field.setAccessible(true);
try {
Copy(beanFields[i], modiBean, bean);
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
return (T) modiBean;
}
}
return null;
}
/**
* 将对象属性转换成万能对象column列对象并添加到万能对象中
*
* @param field
* 对象中的属性对象
* @param modiBean
* 将要转换的万能对象
* @param bean
* 传入的实体bean
* @throws ORMException
*/
private static void Copy(Field field, ModBean modiBean, Object bean)
throws IllegalArgumentException, IllegalAccessException, ORMException {
// TODO Auto-generated method stub
ModColumn modiColumn = new ModColumn();
if(field.getAnnotation(DBColumn.class)!=null&&(field.getAnnotation(DBColumn.class).id()||field.getAnnotation(DBColumn.class).primaryId())){
modiColumn.setPaimaryId(true);
}
modiColumn.setName(field.getName());
FieldType type = getFieldType(field);
modiColumn.setType(type);
modiColumn.setValue(field.get(bean));
modiBean.addColumn(modiColumn);
}
/**
* INT,SHORT,
* LONG,
* DOUBLE,FLOAT,STRING,
* UUID,GUID,
* DATE
*
* @param field.getType()
* @return
* @throws ORMException
*/
private static FieldType getFieldType(Field field) throws ORMException {
String type=field.getType().toString().toUpperCase();
if (type.contains("INT")) {
return FieldType.INT;
} else if (type.contains("SHORT")) {
return FieldType.SHORT;
} else if (type.contains("LONG")) {
if(field.getAnnotation(DBColumn.class)!=null&&field.getAnnotation(DBColumn.class).date()){
return FieldType.DATE;
}
return FieldType.LONG;
} else if (type.contains("DOUBLE")) {
return FieldType.DOUBLE;
} else if (type.contains("FLOAT")) {
return FieldType.FLOAT;
} else if (type.contains("STRING")) {
return FieldType.STRING;
} else if (type.contains("UUID")) {
return FieldType.UUID;
} else{
throw new ORMException("类型映射错误，不支持此类型");
}
}
public static ModBean getModiBean(Object entityObject) throws ORMException {
// TODO Auto-generated method stub
return copy(entityObject, null);
}
}