public static void copy(Object src, Object dest) { Map<String, Method> getterMethodMap = ReflectUtils.getGetterMethods(src.getClass()); Map<String, Method> setterMethodMap = ReflectUtils.getSetterMethods(dest.getClass()); for (Map.Entry<String, Method> entry : setterMethodMap.entrySet()) { Method getter = getterMethodMap.get(entry.getKey()); if (getter == null) continue; try { Object obj = getter.invoke(src); if (obj != null) { entry.getValue().invoke(dest, obj); } } catch (Throwable t) { System.err.println("copy object exception, " + t.getMessage()); } } }
public Object copyOf(List<Object> list) { Object ret = Array.newInstance(elementMetaInfo.getType(), list.size()); for (int i = 0; i < list.size(); i++) { try { ReflectUtils.arraySet(ret, i, list.get(i)); } catch (Throwable e) { e.printStackTrace(); } } return ret; }
public FieldInvoke(Field field) { try { this.field = ReflectUtils.getFieldProxy(field); } catch (Throwable e) { e.printStackTrace(); } }
@Override public Map<String, Method> call(Class<?> key) { return getSetterMethods(key, null); }}); }
public static Object arrayGet(Object array, int index) { return getArrayProxy(array.getClass()).get(array, index); }
@Override public Map<String, Method> call(Class<?> key) { return getGetterMethods(key, null); }}); }
@Override public Map<String, Field> call(Class<?> key) { return getFields(key, null); }}); }
if (fieldGenericTypeBind != null) { propertyAccess.setField(fieldGenericTypeBind.getField()); propertyAccess.setFieldProxy(getFieldProxy(fieldGenericTypeBind.getField())); propertyAccess.setType(fieldGenericTypeBind.getType()); if (getter != null) { propertyAccess.setGetterMethod(getter.getMethod()); propertyAccess.setGetterMethodProxy(getMethodProxy(getter.getMethod())); propertyAccess.setType(getter.getType()); if (setter != null) { propertyAccess.setSetterMethod(setter.getMethod()); propertyAccess.setSetterMethodProxy(getMethodProxy(setter.getMethod())); propertyAccess.setType(setter.getType());
private Object getObjectProperty(Object current, String propertyName) { Object ret = null; try { ret = ReflectUtils.get(current, propertyName); } catch (Throwable e) { Config.LOG.error("get property error", e); } return ret; }
public static Map<String, Method> getSetterMethods(Class<?> clazz, BeanMethodFilter filter) { Map<String, Method> setMethodMap = new HashMap<String, Method>(); Method[] methods = clazz.getMethods(); for (Method method : methods) { method.setAccessible(true); if (method.getName().length() < 4 || !method.getName().startsWith("set") || Modifier.isStatic(method.getModifiers()) || !method.getReturnType().equals(Void.TYPE) || method.getParameterTypes().length != 1) continue; String propertyName = getPropertyName(method); if (filter == null || filter.accept(propertyName, method)) setMethodMap.put(propertyName, method); } return setMethodMap; }
public <T> T insertObject(Connection connection, Object object) { Class<?> t = object.getClass(); SQLMapper sqlMapper = defaultBeanProcessor.generateInsertSQL(t); Assert.notNull(sqlMapper, "the sql mapper must not be null"); Assert.notEmpty(sqlMapper.propertyMap, "the property map must not be empty"); Object[] params = new Object[sqlMapper.propertyMap.size()]; sqlMapper.propertyMap.forEach((property, index) -> { try { Object value = ReflectUtils.get(object, property); params[index] = value; } catch (Throwable ignored) { } }); T ret = this.insert(connection, sqlMapper.sql, params); if (ret != null) { Mapper idMapper = defaultBeanProcessor.getIdMapper(t); if (idMapper != null) { try { ReflectUtils.set(object, idMapper.propertyName, ret); } catch (Throwable ignored) { } } } return ret; }
/** * Invokes a object's "getter" method by property name * * @param obj The instance of a object * @param property The property name of this object * @return The value of this property * @throws Throwable A runtime exception */ public static Object get(Object obj, String property) throws Throwable { return getGetterMethod(obj.getClass(), property).invoke(obj); }
public MethodInvoke(Method method) { try { this.method = ReflectUtils.getMethodProxy(method); } catch (Throwable e) { e.printStackTrace(); } }
public static Method getSetterMethod(Class<?> clazz, String propertyName) { return getSetterMethods(clazz).get(propertyName); }
public static int arraySize(Object array) { return getArrayProxy(array.getClass()).size(array); }
public static Map<String, Method> getGetterMethods(Class<?> clazz) { return getterCache.computeIfAbsent(clazz, key -> getGetterMethods(key, null)); }
public static Map<String, Field> getFields(Class<?> clazz) { return propertyCache.computeIfAbsent(clazz, key -> getFields(key, null)); }
if (fieldGenericTypeBind != null) { propertyAccess.setField(fieldGenericTypeBind.getField()); propertyAccess.setFieldProxy(getFieldProxy(fieldGenericTypeBind.getField())); propertyAccess.setType(fieldGenericTypeBind.getType()); if (getter != null) { propertyAccess.setGetterMethod(getter.getMethod()); propertyAccess.setGetterMethodProxy(getMethodProxy(getter.getMethod())); propertyAccess.setType(getter.getType()); if (setter != null) { propertyAccess.setSetterMethod(setter.getMethod()); propertyAccess.setSetterMethodProxy(getMethodProxy(setter.getMethod())); propertyAccess.setType(setter.getType());
public int updateObject(Connection connection, Object object) { Class<?> t = object.getClass(); SQLMapper sqlMapper = defaultBeanProcessor.generateUpdateSQL(t, object); Assert.notNull(sqlMapper, "the sql mapper must not be null"); Assert.notEmpty(sqlMapper.propertyMap, "the property map must not be empty"); Object[] params = new Object[sqlMapper.propertyMap.size()]; sqlMapper.propertyMap.forEach((property, index) -> { try { Object value = ReflectUtils.get(object, property); params[index] = value; } catch (Throwable ignored) { } }); return this.update(connection, sqlMapper.sql, params); }
public static Map<String, Method> getSetterMethods(Class<?> clazz, BeanMethodFilter filter) { Map<String, Method> setMethodMap = new HashMap<>(); Method[] methods = clazz.getMethods(); for (Method method : methods) { method.setAccessible(true); if (Modifier.isStatic(method.getModifiers())) continue; if (Modifier.isAbstract(method.getModifiers())) continue; if (method.getName().length() < 4) continue; if (!method.getName().startsWith("set")) continue; if (!method.getReturnType().equals(Void.TYPE)) continue; if (method.getParameterTypes().length != 1) continue; String propertyName = getPropertyName(method); if (filter == null || filter.accept(propertyName, method)) { setMethodMap.put(propertyName, method); } } return setMethodMap; }