public static SqlExpression create(String name, String op, Object value) { op = Strings.trim(op.toUpperCase()); // NULL if (null == value) { SqlExpression re; // IS NULL if ("IS".equals(op) || "NOT IS".equals(op) || "IS NOT".equals(op)) { re = isNull(name); } // !!! else { throw Lang.makeThrow("null can only use 'IS' or 'NOT IS'"); } return re.setNot(op.startsWith("NOT") || op.endsWith("NOT")); } // IN else if ("IN".equals(op) || "NOT IN".equals(op)) { Class<?> type = value.getClass(); SqlExpression re; // 数组 if (type.isArray()) { re = _evalRange((Mirror<?>) Mirror.me(type.getComponentType()), name, value); } // 集合 else if (Collection.class.isAssignableFrom(type)) { Object first = Lang.first(value); if (null == first) return null; re = _evalRange((Mirror<?>) Mirror.me(first), name, value); } // Sql Range else { re = inSql(name, value.toString()); } return re.setNot(op.startsWith("NOT")); } // LIKE || IS else if ("LIKE".equals(op) || "NOT LIKEs".equals(op)) { String v = value.toString(); Like re; if (v.length() == 1) { re = like(name, v); } else { re = like(name, v.substring(1, v.length() - 1)); re.left(v.substring(0, 1)); re.right(v.substring(v.length() - 1, v.length())); } return re.ignoreCase(false).setNot(op.startsWith("NOT")); } // = else if ("=".equals(op)) { return eq(name, value); } // != else if ("!=".equals(op) || "<>".equals(op)) { // TODO 检查一下,原本是&&, 明显永远成立 return eq(name, value).setNot(true); } // Others return new SimpleExpression(name, op, value); }
/** * @param type 目标类型 * @return 判断当前对象是否能直接转换到目标类型,而不产生异常 */ public boolean canCastToDirectly(Class<?> type) { if (klass == type || type.isAssignableFrom(klass)) return true; if (klass.isPrimitive() && type.isPrimitive()) { if (this.isPrimitiveNumber() && Mirror.me(type).isPrimitiveNumber()) return true; } try { return Mirror.me(type).getWrapperClass() == this.getWrapperClass(); } catch (Exception e) { } return false; }
/** * 构建DataSource,子类可覆盖. 如果存在Druid,则使用之,否则使用内置的SimpleDataSource * * @param props 配置信息 * @return 目标DataSource */ protected DataSource buildDataSource(Properties props) { if (druidFactoryClass != null) { log.debug("build DruidDataSource by props"); Mirror<?> mirror = Mirror.me(druidFactoryClass); DataSource ds = (DataSource) mirror.invoke(null, "createDataSource", props); if (!props.containsKey("maxWait")) Mirror.me(ds).setValue(ds, "maxWait", 15 * 1000); return ds; } log.debug("build SimpleteDataSource by props"); return SimpleDataSource.createDataSource(props); }
private static boolean doMatchMethodParamsType(Class<?>[] paramTypes, Class<?>[] methodArgTypes) { if (paramTypes.length == 0 && methodArgTypes.length == 0) return true; if (paramTypes.length == methodArgTypes.length) { for (int i = 0; i < paramTypes.length; i++) if (!Mirror.me(paramTypes[i]).canCastToDirectly((methodArgTypes[i]))) return false; return true; } else if (paramTypes.length + 1 == methodArgTypes.length) { if (!methodArgTypes[paramTypes.length].isArray()) return false; for (int i = 0; i < paramTypes.length; i++) if (!Mirror.me(paramTypes[i]).canCastToDirectly((methodArgTypes[i]))) return false; return true; } return false; }
/** * 匹配一个函数声明的参数类型数组和一个调用参数数组 * * @param paramTypes 函数声明参数数组 * @param argTypes 调用参数数组 * @return 匹配类型 * @see org.nutz.lang.MatchType */ public static MatchType matchParamTypes(Class<?>[] paramTypes, Class<?>[] argTypes) { int len = argTypes == null ? 0 : argTypes.length; if (len == 0 && paramTypes.length == 0) return MatchType.YES; if (paramTypes.length == len) { for (int i = 0; i < len; i++) if (!Mirror.me(argTypes[i]).canCastToDirectly((paramTypes[i]))) return MatchType.NO; return MatchType.YES; } else if (len + 1 == paramTypes.length) { if (!paramTypes[len].isArray()) return MatchType.NO; for (int i = 0; i < len; i++) if (!Mirror.me(argTypes[i]).canCastToDirectly((paramTypes[i]))) return MatchType.NO; return MatchType.LACK; } return MatchType.NO; }
/** * @param type 类型 * @return 否为一个对象的外覆类 */ public boolean isWrapperOf(Class<?> type) { try { return Mirror.me(type).getWrapperClass() == klass; } catch (Exception e) { } return false; }
/** * 根据一个字段名和字段类型获取 Setter * * @param fieldName 字段名 * @param paramType 字段类型 * @return 方法 * @throws NoSuchMethodException 没找到 Setter */ public Method getSetter(String fieldName, Class<?> paramType) throws NoSuchMethodException { try { String setterName = "set" + Strings.capitalize(fieldName); try { return klass.getMethod(setterName, paramType); } catch (Throwable e) { try { return klass.getMethod(fieldName, paramType); } catch (Throwable e1) { Mirror<?> type = Mirror.me(paramType); for (Method method : klass.getMethods()) { if (method.getParameterTypes().length == 1) if (method.getName().equals(setterName) || method.getName().equals(fieldName)) { if (null == paramType || type.canCastToDirectly(method.getParameterTypes()[0])) return method; } } // 还是没有? 会不会是包装类型啊? if (!paramType.isPrimitive()) { Class<?> p = unWrapper(); if (null != p) return getSetter(fieldName, p); } throw new RuntimeException(); } } } catch (Throwable e) { throw Lang.makeThrow( NoSuchMethodException.class, "Fail to find setter for [%s]->[%s(%s)]", klass.getName(), fieldName, paramType.getName()); } }
/** * 根据Type生成Mirror, 如果type是 {@link ParameterizedType} 类型的对象<br> * 可以使用 getGenericsTypes() 方法取得它的泛型数组 * * @param type * @return */ @SuppressWarnings({"unchecked"}) public static <T> Mirror<T> me(Type type) { if (null == type) { return null; } Mirror<T> mir = (Mirror<T>) Mirror.me(Lang.getTypeClass(type)); mir.type = type; return mir; }
public <T> T toObject(Class<T> classOfT) { Mirror<T> mirror = Mirror.me(classOfT); T re = mirror.born(); Entry current = head; while (current != null) { mirror.setValue(re, current.name, current.value); current = current.next; } return re; }
/** * 关闭本DaoUp,将关闭DataSource并将dao和dataSource置为null!!! * * <p><b>只能在程序关闭时调用,严禁在每次Dao操作后调用!!</b> */ public synchronized void close() { if (dao == null) return; log.infof("shutdown DaoUp(name=%s)", name); try { Mirror.me(dataSource).invoke(dataSource, "close"); } catch (Throwable e) { } this.dataSource = null; this.dao = null; }
/** * 根据给定的一个方法,判断其是 Getter 还是 Setter * * <p>对于回调会接受三个参数 * * <pre> * callback(虚字段名, getter, setter) * </pre> * * 回调都会给一个参数,表示这个方法对应的虚拟字段名。所谓"虚拟字段",就比如 * * <ul> * <li>如果是 setAbc : 那么就是 "abc" * <li>如果是 getAbc : 那么就是 "abc" * <li>如果是 isAbc : 那么就是 "abc" * </ul> * * 而 getter 或者 setter 参数如果为 null,则表示本函数未发现对应的 getter|setter * * @param method 方法对象 * @param callback 回调, 如果为 null,则无视 * @param whenError 如果本方法即不是 Getter 也不是 Setter 的回调, 如果为 null,则无视 */ public static void evalGetterSetter( Method method, Callback3<String, Method, Method> callback, Callback<Method> whenError) { String name = method.getName(); Method getter = null; Method setter = null; // 是 getter if (name.startsWith("get") && method.getParameterTypes().length == 0) { name = Strings.lowerFirst(name.substring(4)); getter = method; // 寻找 setter try { setter = method .getDeclaringClass() .getMethod("set" + Strings.capitalize(name), method.getReturnType()); } catch (Exception e) { } } // 布尔的 getter else if (name.startsWith("is") && Mirror.me(method.getReturnType()).isBoolean() && method.getParameterTypes().length == 0) { name = Strings.lowerFirst(name.substring(3)); getter = method; // 寻找 setter try { setter = method .getDeclaringClass() .getMethod("set" + Strings.capitalize(name), method.getReturnType()); } catch (Exception e) { } } // 是 setter else if (name.startsWith("set") && method.getParameterTypes().length == 1) { name = Strings.lowerFirst(name.substring(4)); setter = method; // 寻找 getter try { getter = method.getDeclaringClass().getMethod("get" + Strings.capitalize(name)); } catch (Exception e) { } } // 虾米都不是,错! else { if (null != whenError) whenError.invoke(method); return; } // 最后调用回调 if (null != callback) callback.invoke(name, getter, setter); }
@SuppressWarnings("unchecked") public <T extends CommonManager> T copy() { String clazzName = this.getClass().getName().replace(ClassAgent.CLASSNAME_SUFFIX, ""); try { Mirror<T> mirror = (Mirror<T>) Mirror.me(Class.forName(clazzName)); return ClassUtil.copySameProperties(mirror.born(), this); } catch (ClassNotFoundException e) { log.error(e.getMessage(), e); return null; } }
@SuppressWarnings({"rawtypes", "unchecked"}) public void init() { List<LinkField> lfs = new ArrayList<LinkField>(); lfs.addAll(ones.getAll()); lfs.addAll(manys.getAll()); lfs.addAll(manymanys.getAll()); if (lfs.isEmpty()) return; if (log.isDebugEnabled()) log.debug("Found links , enable lazy!! -->" + type); Mirror<T> mirror = Mirror.me(type); List<InterceptorPair> interceptorPairs = new ArrayList<InterceptorPair>(); // 准备拦截器 for (LinkField lf : lfs) { String fieldName = lf.getName(); try { Method setter = mirror.getSetter(mirror.getField(fieldName)); LazyMethodInterceptor lmi = new LazyMethodInterceptor(setter, fieldName); interceptorPairs.add( new InterceptorPair( lmi, MethodMatcherFactory.matcher( "^(get|set)" + Strings.upperFirst(fieldName) + "$"))); } catch (Throwable e) { if (log.isWarnEnabled()) log.warn("Not setter found for LazyLoading ?!", e); } } // 生成Aop化的类 ClassAgent agent = new AsmClassAgent(); for (InterceptorPair interceptorPair : interceptorPairs) agent.addInterceptor( interceptorPair.getMethodMatcher(), interceptorPair.getMethodInterceptor()); Class lazyClass = agent.define(DefaultClassDefiner.defaultOne(), type); // 检查对象的创建方法 BornContext<T> bc = Borns.evalByArgTypes(type, ResultSet.class); if (null == bc) this.bornByDefault = Mirror.me(lazyClass).getBorningByArgTypes(); else this.bornByRS = bc.getBorning(); }
public Object run(List<Object> param) { Object obj = fetchVar(); Mirror<?> me = null; if (obj == null) throw new NullPointerException(); if (obj instanceof Class) { // 也许是个静态方法 me = Mirror.me(obj); try { return me.invoke(obj, right.toString(), param.toArray()); } catch (InvokingException e) { throw e; } catch (Throwable e) { if (Lang.unwrapThrow(e) instanceof NoSuchMethodException) { me = Mirror.me(obj.getClass().getClass()); return me.invoke(obj, right.toString(), param.toArray()); } throw Lang.wrapThrow(e); } } else { me = Mirror.me(obj); return me.invoke(obj, right.toString(), param.toArray()); } }
@SuppressWarnings("unchecked") private <F, T> Castor<F, T> find(Mirror<F> from, Class<T> toType) { Mirror<T> to = Mirror.me(toType, extractor); Class<?>[] fets = from.extractTypes(); Class<?>[] tets = to.extractTypes(); for (Class<?> ft : fets) { for (Class<?> tt : tets) { if (map.containsKey(Castor.fetchHash(ft, tt))) { return (Castor<F, T>) map.get(Castor.fetchHash(ft, tt)); } } } return null; }
public void destroy(NutConfig conf) { Markdowns.cache = null; // 非mysql数据库,或多webapp共享mysql驱动的话,以下语句删掉 try { Mirror.me(Class.forName("com.mysql.jdbc.AbandonedConnectionCleanupThread")) .invoke(null, "shutdown"); } catch (Throwable e) { } // 解决quartz有时候无法停止的问题 try { conf.getIoc().get(Scheduler.class).shutdown(true); } catch (Exception e) { } }
/** * 根据一个对象的字段 生成一个 Chain 对象 * * <p>这个对象可以是一个 POJO 或者是一个 Map。 * * <p>支持 FieldMatcher,即你可以通过 FieldMatcher 来指定你需要哪些字段加入 Chain * * @param obj 对象,可以是一个 POJO 或者是一个 Map * @param fm 指明可用字段,null 表示全部字段可用 * @return Chain 对象,null 表示对象中没有可用字段 * @see org.nutz.dao.FieldMatcher */ public static Chain from(Object obj, FieldMatcher fm) { if (null == obj) return null; Chain c = null; /* * Is Map */ if (obj instanceof Map<?, ?>) { for (Map.Entry<?, ?> en : ((Map<?, ?>) obj).entrySet()) { Object key = en.getKey(); if (null == key) continue; String name = key.toString(); if (null != fm && !fm.match(name)) continue; Object v = en.getValue(); if (null != fm) { if (null == v) { if (fm.isIgnoreNull()) continue; } else if (fm.isIgnoreBlankStr() && v instanceof String) { if (Strings.isBlank((String) v)) continue; } } if (c == null) { c = Chain.make(name, v); } else { c = c.add(name, v); } } } /* * Is POJO */ else { Mirror<?> mirror = Mirror.me(obj.getClass()); for (Field f : mirror.getFields()) { if (null != fm && !fm.match(f.getName())) continue; Object v = mirror.getValue(obj, f.getName()); if (null == v) { if (fm.isIgnoreNull()) continue; } else if (fm.isIgnoreBlankStr() && v instanceof String) { if (Strings.isBlank((String) v)) continue; } if (c == null) { c = Chain.make(f.getName(), v); } else { c = c.add(f.getName(), v); } } } return c; }
@SuppressWarnings("unchecked") private static <T extends Map<String, Object>> void obj2map( Object obj, T map, Map<Object, Object> memo) { if (null == obj || memo.containsKey(obj)) return; memo.put(obj, ""); Mirror<?> mirror = Mirror.me(obj.getClass()); Field[] flds = mirror.getFields(); for (Field fld : flds) { Object v = mirror.getValue(obj, fld); if (null == v) { map.put(fld.getName(), null); continue; } Mirror<?> mr = Mirror.me(fld.getType()); if (mr.isNumber() || mr.isBoolean() || mr.isChar() || mr.isStringLike() || mr.isEnum() || mr.isDateTimeLike()) { map.put(fld.getName(), v); } else if (memo.containsKey(v)) { map.put(fld.getName(), null); } else { T sub; try { sub = (T) map.getClass().newInstance(); } catch (Exception e) { throw Lang.wrapThrow(e); } obj2map(v, sub, memo); map.put(fld.getName(), sub); } } }
/** * 获得一个对象的长度。它可以接受: * * <ul> * <li>null : 0 * <li>数组 * <li>集合 * <li>Map * <li>一般 Java 对象。 返回 1 * </ul> * * 如果你想让你的 Java 对象返回不是 1 , 请在对象中声明 length() 函数 * * @param obj * @return 对象长度 */ public static int length(Object obj) { if (null == obj) return 0; if (obj.getClass().isArray()) { return Array.getLength(obj); } else if (obj instanceof Collection<?>) { return ((Collection<?>) obj).size(); } else if (obj instanceof Map<?, ?>) { return ((Map<?, ?>) obj).size(); } try { return (Integer) Mirror.me(obj.getClass()).invoke(obj, "length"); } catch (Exception e) { } return 1; }
/** * 将一个数组变成 Map * * @param mapClass Map 的类型 * @param array 数组 * @param keyFieldName 采用集合中元素的哪个一个字段为键。 * @return Map 对象 */ public static <T extends Map<Object, Object>> Map<?, ?> array2map( Class<T> mapClass, Object array, String keyFieldName) { if (null == array) return null; Map<Object, Object> map = createMap(mapClass); int len = Array.getLength(array); if (len > 0) { Object obj = Array.get(array, 0); Mirror<?> mirror = Mirror.me(obj.getClass()); for (int i = 0; i < len; i++) { obj = Array.get(array, i); Object key = mirror.getValue(obj, keyFieldName); map.put(key, obj); } } return map; }
protected String value2string(JsonEntityField jef, Object value) { Format df = jef.getDataFormat(); if (df == null) { Mirror mirror = Mirror.me(value); if (value instanceof Date) { df = format.getDateFormat(); } else if (mirror.isNumber()) { df = format.getNumberFormat(); } } if (df != null) { return df.format(value); } return value.toString(); }
/** * 转换一个 POJO 从一个指定的类型到另外的类型 * * @param src 源对象 * @param fromType 源对象类型 * @param toType 目标类型 * @param args 转换时参数。有些 Castor 可能需要这个参数,比如 Array2Map * @return 目标对象 * @throws FailToCastObjectException 如果没有找到转换器,或者转换失败 */ @SuppressWarnings({"unchecked", "rawtypes"}) public <F, T> T cast(Object src, Class<F> fromType, Class<T> toType, String... args) throws FailToCastObjectException { if (null == src) { // 原生数据的默认值 if (toType.isPrimitive()) { if (toType == int.class) return (T) Integer.valueOf(0); else if (toType == long.class) return (T) Long.valueOf(0L); else if (toType == byte.class) return (T) Byte.valueOf((byte) 0); else if (toType == short.class) return (T) Short.valueOf((short) 0); else if (toType == float.class) return (T) Float.valueOf(.0f); else if (toType == double.class) return (T) Double.valueOf(.0); else if (toType == boolean.class) return (T) Boolean.FALSE; else if (toType == char.class) return (T) Character.valueOf(' '); throw Lang.impossible(); } // 是对象,直接返回 null return null; } if (fromType == toType || toType == null || fromType == null) return (T) src; if (fromType.getName().equals(toType.getName())) return (T) src; if (toType.isAssignableFrom(fromType)) return (T) src; Mirror<?> from = Mirror.me(fromType, extractor); if (from.canCastToDirectly(toType)) // Use language built-in cases return (T) src; Castor c = find(from, toType); if (null == c) throw new FailToCastObjectException( String.format( "Can not find castor for '%s'=>'%s' in (%d) because:\n%s", fromType.getName(), toType.getName(), map.size(), "Fail to find matched castor")); try { return (T) c.cast(src, toType, args); } catch (FailToCastObjectException e) { throw e; } catch (Exception e) { throw new FailToCastObjectException( String.format( "Fail to cast from <%s> to <%s> for {%s} because:\n%s:%s", fromType.getName(), toType.getName(), src, e.getClass().getSimpleName(), e.getMessage()), Lang.unwrapThrow(e)); } }
/** * 将一个集合变成 Map。 * * @param mapClass Map 的类型 * @param coll 集合对象 * @param keyFieldName 采用集合中元素的哪个一个字段为键。 * @return Map 对象 */ public static <T extends Map<Object, Object>> Map<?, ?> collection2map( Class<T> mapClass, Collection<?> coll, String keyFieldName) { if (null == coll) return null; Map<Object, Object> map = createMap(mapClass); if (coll.size() > 0) { Iterator<?> it = coll.iterator(); Object obj = it.next(); Mirror<?> mirror = Mirror.me(obj.getClass()); Object key = mirror.getValue(obj, keyFieldName); map.put(key, obj); for (; it.hasNext(); ) { obj = it.next(); key = mirror.getValue(obj, keyFieldName); map.put(key, obj); } } return map; }
/** * 根据名称获取一个 Getter。 * * <p>比如,你想获取 abc 的 getter ,那么优先查找 getAbc(),如果没有则查找isAbc(),最后才是查找 abc()。 * * @param fieldName * @return 方法 * @throws NoSuchMethodException 没有找到 Getter */ public Method getGetter(String fieldName) throws NoSuchMethodException { String fn = Strings.capitalize(fieldName); String _get = "get" + fn; String _is = "is" + fn; for (Method method : klass.getMethods()) { if (method.getParameterTypes().length != 0) continue; if (_get.equals(method.getName())) return method; if (_is.equals(method.getName())) { if (!Mirror.me(method.getReturnType()).isBoolean()) throw new NoSuchMethodException(); return method; } if (fieldName.equals(method.getName())) return method; } throw Lang.makeThrow( NoSuchMethodException.class, "Fail to find getter for [%s]->[%s]", klass.getName(), fieldName); }
public Object calculate() { // 如果直接调用计算方法,那基本上就是直接调用属性了吧...我也不知道^^ Object obj = fetchVar(); if (obj == null) { throw new ElException("obj is NULL, can't call obj." + right); } if (obj instanceof Map) { Map<?, ?> om = (Map<?, ?>) obj; if (om.containsKey(right.toString())) { return om.get(right.toString()); } } if (obj instanceof Context) { Context sc = (Context) obj; if (sc.has(right.toString())) { return sc.get(right.toString()); } } Mirror<?> me = Mirror.me(obj); return me.getValue(obj, right.toString()); }
/** * 修改 get 后的值,以便修改查询的 DBObject * * @param val get 后的值 * @return 修改 get 后的值,这个值是 ejecting 从对象中取出的 */ public Object adaptForFormatQuery(Object val) { if (null == val) return null; // Mirror<?> vMirror = Mirror.me(val.getClass()); // 如果值为 Map,且自己的类型不是 Map,那么就是深入修改 Map 的各个修改器的键 ... if (vMirror.isMap() && !field.getMirror().isMap()) { final Map<String, Object> map = new HashMap<String, Object>(); Lang.each( val, true, new Each<Map.Entry<String, Object>>() { public void invoke(int index, Entry<String, Object> ele, int length) { String key = ele.getKey(); if (null != key && key.startsWith("$")) { map.put(key, adaptForFormatQuery(ele.getValue())); } } }); return map; } // 如果值为集合或者数组, 且自己不为集合或者数组,则生成个新数组返回 else if (vMirror.isContainer() && !field.getMirror().isContainer()) { int len = Lang.length(val); final Object array = Array.newInstance(Object.class, len); Lang.each( val, false, new Each<Object>() { public void invoke(int index, Object o, int length) { Array.set(array, index, adaptForFormatQuery(o)); } }); return array; } return adaptForGet(val, false); }
/** * 根据格式化字符串,生成一个指定的异常。 * * @param classOfT 异常类型, 需要有一个字符串为参数的构造函数 * @param format 格式 * @param args 参数 * @return 异常对象 */ public static <T extends Throwable> T makeThrow( Class<T> classOfT, String format, Object... args) { return Mirror.me(classOfT).born(String.format(format, args)); }
/** * 根据一个 Map,和给定的对象类型,创建一个新的 JAVA 对象 * * @param src Map 对象 * @param toType JAVA 对象类型 * @return JAVA 对象 * @throws FailToCastObjectException */ @SuppressWarnings({"unchecked", "rawtypes"}) public static <T> T map2Object(Map<?, ?> src, Class<T> toType) throws FailToCastObjectException { if (null == toType) throw new FailToCastObjectException("target type is Null"); // 类型相同 if (toType == Map.class) return (T) src; // 也是一种 Map if (Map.class.isAssignableFrom(toType)) { Map map; try { map = (Map) toType.newInstance(); map.putAll(src); return (T) map; } catch (Exception e) { throw new FailToCastObjectException("target type fail to born!", e); } } // 数组 if (toType.isArray()) return (T) Lang.collection2array(src.values(), toType.getComponentType()); // List if (List.class == toType) { return (T) Lang.collection2list(src.values()); } // POJO Mirror<T> mirror = Mirror.me(toType); T obj = mirror.born(); for (Field field : mirror.getFields()) { if (src.containsKey(field.getName())) { Object v = src.get(field.getName()); if (null == v) continue; Class<?> ft = field.getType(); Object vv = null; // 集合 if (v instanceof Collection) { Collection c = (Collection) v; // 集合到数组 if (ft.isArray()) { vv = Lang.collection2array(c, ft.getComponentType()); } // 集合到集合 else { // 创建 Collection newCol; Class eleType = Mirror.getGenericTypes(field, 0); if (ft == List.class) { newCol = new ArrayList(c.size()); } else if (ft == Set.class) { newCol = new LinkedHashSet(); } else { try { newCol = (Collection) ft.newInstance(); } catch (Exception e) { throw Lang.wrapThrow(e); } } // 赋值 for (Object ele : c) { newCol.add(Castors.me().castTo(ele, eleType)); } vv = newCol; } } // Map else if (v instanceof Map && Map.class.isAssignableFrom(ft)) { // 创建 final Map map; // Map 接口 if (ft == Map.class) { map = new HashMap(); } // 自己特殊的 Map else { try { map = (Map) ft.newInstance(); } catch (Exception e) { throw new FailToCastObjectException("target type fail to born!", e); } } // 赋值 final Class<?> valType = Mirror.getGenericTypes(field, 1); each( v, new Each<Entry>() { public void invoke(int i, Entry en, int length) { map.put(en.getKey(), Castors.me().castTo(en.getValue(), valType)); } }); vv = map; } // 强制转换 else { vv = Castors.me().castTo(v, ft); } mirror.setValue(obj, field, vv); } } return obj; }
/** * 判断两个对象是否相等。 这个函数用处是: * * <ul> * <li>可以容忍 null * <li>可以容忍不同类型的 Number * <li>对数组,集合, Map 会深层比较 * </ul> * * 当然,如果你重写的 equals 方法会优先 * * @param a1 比较对象1 * @param a2 比较对象2 * @return 是否相等 */ @SuppressWarnings("unchecked") public static boolean equals(Object a1, Object a2) { if (a1 == a2) return true; if (a1 == null && a2 == null) return false; if (a1 == null || a2 == null) return false; if (a1.equals(a2)) return true; Mirror<?> mr1 = Mirror.me(a1); if (mr1.isStringLike()) { return a1.toString().equals(a2.toString()); } if (mr1.isDateTimeLike()) { return a1.equals(a2); } if (mr1.isNumber()) { return a2 instanceof Number && a1.toString().equals(a2.toString()); } if (!a1.getClass().isAssignableFrom(a2.getClass()) && !a2.getClass().isAssignableFrom(a1.getClass())) return false; if (a1 instanceof Map && a2 instanceof Map) { Map<?, ?> m1 = (Map<?, ?>) a1; Map<?, ?> m2 = (Map<?, ?>) a2; if (m1.size() != m2.size()) return false; for (Entry<?, ?> e : m1.entrySet()) { Object key = e.getKey(); if (!m2.containsKey(key) || !equals(m1.get(key), m2.get(key))) return false; } return true; } else if (a1.getClass().isArray()) { if (a2.getClass().isArray()) { int len = Array.getLength(a1); if (len != Array.getLength(a2)) return false; for (int i = 0; i < len; i++) { if (!equals(Array.get(a1, i), Array.get(a2, i))) return false; } return true; } else if (a2 instanceof List) { return equals(a1, Lang.collection2array((List<Object>) a2, Object.class)); } return false; } else if (a1 instanceof List) { if (a2 instanceof List) { List<?> l1 = (List<?>) a1; List<?> l2 = (List<?>) a2; if (l1.size() != l2.size()) return false; int i = 0; for (Iterator<?> it = l1.iterator(); it.hasNext(); ) { if (!equals(it.next(), l2.get(i++))) return false; } return true; } else if (a2.getClass().isArray()) { return equals(Lang.collection2array((List<Object>) a1, Object.class), a2); } return false; } else if (a1 instanceof Collection && a2 instanceof Collection) { Collection<?> c1 = (Collection<?>) a1; Collection<?> c2 = (Collection<?>) a2; if (c1.size() != c2.size()) return false; return c1.containsAll(c2) && c2.containsAll(c1); } return false; }
/** * 用一个指定可抛出类型来包裹一个抛出对象。这个指定的可抛出类型需要有一个构造函数 接受 Throwable 类型的对象 * * @param e 抛出对象 * @param wrapper 包裹类型 * @return 包裹后对象 */ @SuppressWarnings("unchecked") public static <T extends Throwable> T wrapThrow(Throwable e, Class<T> wrapper) { if (wrapper.isAssignableFrom(e.getClass())) return (T) e; return Mirror.me(wrapper).born(e); }