zhouxy108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-07-21 15:09:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

enhance aop

Browse Source
This commit is contained in:
Looly
2019-09-27 23:20:43 +08:00
parent 5b5645cbbb
commit 45609bc22b
8 changed files with 280 additions and 250 deletions
Download Patch File Download Diff File Expand all files Collapse all files

273
hutool-core/src/main/java/cn/hutool/core/util/ReflectUtil.java
View File

@@ -1,13 +1,5 @@
package cn.hutool.core.util;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.exceptions.UtilException;
@@ -15,27 +7,43 @@ import cn.hutool.core.lang.Assert;
import cn.hutool.core.lang.Filter;
import cn.hutool.core.lang.SimpleCache;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* 反射工具类
*
*
* @author Looly
* @since 3.0.9
*/
public class ReflectUtil {
/** 构造对象缓存 */
/**
* 构造对象缓存
*/
private static final SimpleCache<Class<?>, Constructor<?>[]> CONSTRUCTORS_CACHE = new SimpleCache<>();
/** 字段缓存 */
/**
* 字段缓存
*/
private static final SimpleCache<Class<?>, Field[]> FIELDS_CACHE = new SimpleCache<>();
/** 方法缓存 */
/**
* 方法缓存
*/
private static final SimpleCache<Class<?>, Method[]> METHODS_CACHE = new SimpleCache<>();
// --------------------------------------------------------------------------------------------------------- Constructor
/**
* 查找类中的指定参数的构造方法，如果找到构造方法，会自动设置可访问为true
*
* @param <T> 对象类型
* @param clazz 类
*
* @param <T> 对象类型
* @param clazz 类
* @param parameterTypes 参数类型，只要任何一个参数是指定参数的父类或接口或相等即可，此参数可以不传
* @return 构造方法，如果未找到返回null
*/
@@ -51,7 +59,7 @@ public class ReflectUtil {
pts = constructor.getParameterTypes();
if (ClassUtil.isAllAssignableFrom(pts, parameterTypes)) {
// 构造可访问
constructor.setAccessible(true);
setAccessible(constructor);
return (Constructor<T>) constructor;
}
}
@@ -60,8 +68,8 @@ public class ReflectUtil {
/**
* 获得一个类中所有构造列表
*
* @param <T> 构造的对象类型
*
* @param <T> 构造的对象类型
* @param beanClass 类
* @return 字段列表
* @throws SecurityException 安全检查异常
@@ -80,7 +88,7 @@ public class ReflectUtil {
/**
* 获得一个类中所有字段列表，直接反射获取，无缓存
*
*
* @param beanClass 类
* @return 字段列表
* @throws SecurityException 安全检查异常
@@ -91,11 +99,12 @@ public class ReflectUtil {
}
// --------------------------------------------------------------------------------------------------------- Field
/**
* 查找指定类中是否包含指定名称对应的字段，包括所有字段（包括非public字段），也包括父类和Object类的字段
*
*
* @param beanClass 被查找字段的类,不能为null
* @param name 字段名
* @param name 字段名
* @return 是否包含字段
* @throws SecurityException 安全异常
* @since 4.1.21
@@ -103,12 +112,12 @@ public class ReflectUtil {
public static boolean hasField(Class<?> beanClass, String name) throws SecurityException {
return null != getField(beanClass, name);
}
/**
* 查找指定类中的所有字段（包括非public字段），也包括父类和Object类的字段， 字段不存在则返回<code>null</code>
*
*
* @param beanClass 被查找字段的类,不能为null
* @param name 字段名
* @param name 字段名
* @return 字段
* @throws SecurityException 安全异常
*/
@@ -126,7 +135,7 @@ public class ReflectUtil {
/**
* 获得一个类中所有字段列表，包括其父类中的字段
*
*
* @param beanClass 类
* @return 字段列表
* @throws SecurityException 安全检查异常
@@ -143,8 +152,8 @@ public class ReflectUtil {
/**
* 获得一个类中所有字段列表，直接反射获取，无缓存
*
* @param beanClass 类
*
* @param beanClass 类
* @param withSuperClassFieds 是否包括父类的字段列表
* @return 字段列表
* @throws SecurityException 安全检查异常
@@ -170,8 +179,8 @@ public class ReflectUtil {
/**
* 获取字段值
*
* @param obj 对象
*
* @param obj 对象
* @param fieldName 字段名
* @return 字段值
* @throws UtilException 包装IllegalAccessException异常
@@ -185,8 +194,8 @@ public class ReflectUtil {
/**
* 获取字段值
*
* @param obj 对象
*
* @param obj 对象
* @param field 字段
* @return 字段值
* @throws UtilException 包装IllegalAccessException异常
@@ -195,8 +204,8 @@ public class ReflectUtil {
if (null == obj || null == field) {
return null;
}
field.setAccessible(true);
Object result = null;
setAccessible(field);
Object result;
try {
result = field.get(obj);
} catch (IllegalAccessException e) {
@@ -207,6 +216,7 @@ public class ReflectUtil {
/**
* 获取所有字段的值
*
* @param obj bean对象
* @return 字段值数组
* @since 4.1.17
@@ -227,16 +237,16 @@ public class ReflectUtil {
/**
* 设置字段值
*
* @param obj 对象
*
* @param obj 对象
* @param fieldName 字段名
* @param value 值，值类型必须与字段类型匹配，不会自动转换对象类型
* @param value 值，值类型必须与字段类型匹配，不会自动转换对象类型
* @throws UtilException 包装IllegalAccessException异常
*/
public static void setFieldValue(Object obj, String fieldName, Object value) throws UtilException {
Assert.notNull(obj);
Assert.notBlank(fieldName);
final Field field = getField(obj.getClass(), fieldName);
Assert.notNull(field, "Field [{}] is not exist in [{}]", fieldName, obj.getClass().getName());
setFieldValue(obj, field, value);
@@ -244,8 +254,8 @@ public class ReflectUtil {
/**
* 设置字段值
*
* @param obj 对象
*
* @param obj 对象
* @param field 字段
* @param value 值，值类型必须与字段类型匹配，不会自动转换对象类型
* @throws UtilException UtilException 包装IllegalAccessException异常
@@ -253,19 +263,20 @@ public class ReflectUtil {
public static void setFieldValue(Object obj, Field field, Object value) throws UtilException {
Assert.notNull(obj);
Assert.notNull(field, "Field in [{}] not exist !", obj.getClass().getName());
field.setAccessible(true);
if(null != value) {
setAccessible(field);
if (null != value) {
Class<?> fieldType = field.getType();
if(false == fieldType.isAssignableFrom(value.getClass())) {
if (false == fieldType.isAssignableFrom(value.getClass())) {
//对于类型不同的字段，尝试转换，转换失败则使用原对象类型
final Object targetValue = Convert.convert(fieldType, value);
if(null != targetValue) {
if (null != targetValue) {
value = targetValue;
}
}
}
try {
field.set(obj, value);
} catch (IllegalAccessException e) {
@@ -274,17 +285,18 @@ public class ReflectUtil {
}
// --------------------------------------------------------------------------------------------------------- method
/**
* 获得指定类本类及其父类中的Public方法名<br>
* 去重重载的方法
*
*
* @param clazz 类
* @return 方法名Set
*/
public static Set<String> getPublicMethodNames(Class<?> clazz) {
final HashSet<String> methodSet = new HashSet<String>();
final HashSet<String> methodSet = new HashSet<>();
final Method[] methodArray = getPublicMethods(clazz);
if(ArrayUtil.isNotEmpty(methodArray)) {
if (ArrayUtil.isNotEmpty(methodArray)) {
for (Method method : methodArray) {
methodSet.add(method.getName());
}
@@ -294,7 +306,7 @@ public class ReflectUtil {
/**
* 获得本类及其父类所有Public方法
*
*
* @param clazz 查找方法的类
* @return 过滤后的方法列表
*/
@@ -304,8 +316,8 @@ public class ReflectUtil {
/**
* 获得指定类过滤后的Public方法列表
*
* @param clazz 查找方法的类
*
* @param clazz 查找方法的类
* @param filter 过滤器
* @return 过滤后的方法列表
*/
@@ -331,8 +343,8 @@ public class ReflectUtil {
/**
* 获得指定类过滤后的Public方法列表
*
* @param clazz 查找方法的类
*
* @param clazz 查找方法的类
* @param excludeMethods 不包括的方法
* @return 过滤后的方法列表
*/
@@ -348,8 +360,8 @@ public class ReflectUtil {
/**
* 获得指定类过滤后的Public方法列表
*
* @param clazz 查找方法的类
*
* @param clazz 查找方法的类
* @param excludeMethodNames 不包括的方法名列表
* @return 过滤后的方法列表
*/
@@ -365,8 +377,8 @@ public class ReflectUtil {
/**
* 查找指定Public方法 如果找不到对应的方法或方法不为public的则返回<code>null</code>
*
* @param clazz 类
*
* @param clazz 类
* @param methodName 方法名
* @param paramTypes 参数类型
* @return 方法
@@ -379,17 +391,17 @@ public class ReflectUtil {
return null;
}
}
/**
* 查找指定对象中的所有方法（包括非public方法），也包括父对象和Object类的方法
*
*
* <p>
* 此方法为精准获取方法名，即方法名和参数数量和类型必须一致，否则返回<code>null</code>。
* </p>
*
* @param obj 被查找的对象，如果为{@code null}返回{@code null}
*
* @param obj 被查找的对象，如果为{@code null}返回{@code null}
* @param methodName 方法名，如果为空字符串返回{@code null}
* @param args 参数
* @param args 参数
* @return 方法
* @throws SecurityException 无访问权限抛出异常
*/
@@ -402,12 +414,12 @@ public class ReflectUtil {
/**
* 忽略大小写查找指定方法，如果找不到对应的方法则返回<code>null</code>
*
*
* <p>
* 此方法为精准获取方法名，即方法名和参数数量和类型必须一致，否则返回<code>null</code>。
* </p>
*
* @param clazz 类，如果为{@code null}返回{@code null}
*
* @param clazz 类，如果为{@code null}返回{@code null}
* @param methodName 方法名，如果为空字符串返回{@code null}
* @param paramTypes 参数类型，指定参数类型如果是方法的子类也算
* @return 方法
@@ -420,12 +432,12 @@ public class ReflectUtil {
/**
* 查找指定方法 如果找不到对应的方法则返回<code>null</code>
*
*
* <p>
* 此方法为精准获取方法名，即方法名和参数数量和类型必须一致，否则返回<code>null</code>。
* </p>
*
* @param clazz 类，如果为{@code null}返回{@code null}
*
* @param clazz 类，如果为{@code null}返回{@code null}
* @param methodName 方法名，如果为空字符串返回{@code null}
* @param paramTypes 参数类型，指定参数类型如果是方法的子类也算
* @return 方法
@@ -437,12 +449,12 @@ public class ReflectUtil {
/**
* 查找指定方法 如果找不到对应的方法则返回<code>null</code>
*
*
* <p>
* 此方法为精准获取方法名，即方法名和参数数量和类型必须一致，否则返回<code>null</code>。
* </p>
*
* @param clazz 类，如果为{@code null}返回{@code null}
*
* @param clazz 类，如果为{@code null}返回{@code null}
* @param ignoreCase 是否忽略大小写
* @param methodName 方法名，如果为空字符串返回{@code null}
* @param paramTypes 参数类型，指定参数类型如果是方法的子类也算
@@ -467,15 +479,15 @@ public class ReflectUtil {
}
return null;
}
/**
* 按照方法名查找指定方法名的方法，只返回匹配到的第一个方法，如果找不到对应的方法则返回<code>null</code>
*
*
* <p>
* 此方法只检查方法名是否一致，并不检查参数的一致性。
* </p>
*
* @param clazz 类，如果为{@code null}返回{@code null}
*
* @param clazz 类，如果为{@code null}返回{@code null}
* @param methodName 方法名，如果为空字符串返回{@code null}
* @return 方法
* @throws SecurityException 无权访问抛出异常
@@ -484,15 +496,15 @@ public class ReflectUtil {
public static Method getMethodByName(Class<?> clazz, String methodName) throws SecurityException {
return getMethodByName(clazz, false, methodName);
}
/**
* 按照方法名查找指定方法名的方法，只返回匹配到的第一个方法，如果找不到对应的方法则返回<code>null</code>
*
*
* <p>
* 此方法只检查方法名是否一致（忽略大小写），并不检查参数的一致性。
* </p>
*
* @param clazz 类，如果为{@code null}返回{@code null}
*
* @param clazz 类，如果为{@code null}返回{@code null}
* @param methodName 方法名，如果为空字符串返回{@code null}
* @return 方法
* @throws SecurityException 无权访问抛出异常
@@ -501,15 +513,15 @@ public class ReflectUtil {
public static Method getMethodByNameIgnoreCase(Class<?> clazz, String methodName) throws SecurityException {
return getMethodByName(clazz, true, methodName);
}
/**
* 按照方法名查找指定方法名的方法，只返回匹配到的第一个方法，如果找不到对应的方法则返回<code>null</code>
*
*
* <p>
* 此方法只检查方法名是否一致，并不检查参数的一致性。
* </p>
*
* @param clazz 类，如果为{@code null}返回{@code null}
*
* @param clazz 类，如果为{@code null}返回{@code null}
* @param ignoreCase 是否忽略大小写
* @param methodName 方法名，如果为空字符串返回{@code null}
* @return 方法
@@ -535,13 +547,13 @@ public class ReflectUtil {
/**
* 获得指定类中的Public方法名<br>
* 去重重载的方法
*
*
* @param clazz 类
* @return 方法名Set
* @throws SecurityException 安全异常
*/
public static Set<String> getMethodNames(Class<?> clazz) throws SecurityException {
final HashSet<String> methodSet = new HashSet<String>();
final HashSet<String> methodSet = new HashSet<>();
final Method[] methods = getMethods(clazz);
for (Method method : methods) {
methodSet.add(method.getName());
@@ -551,8 +563,8 @@ public class ReflectUtil {
/**
* 获得指定类过滤后的Public方法列表
*
* @param clazz 查找方法的类
*
* @param clazz 查找方法的类
* @param filter 过滤器
* @return 过滤后的方法列表
* @throws SecurityException 安全异常
@@ -566,7 +578,7 @@ public class ReflectUtil {
/**
* 获得一个类中所有方法列表，包括其父类中的方法
*
*
* @param beanClass 类
* @return 方法列表
* @throws SecurityException 安全检查异常
@@ -583,8 +595,8 @@ public class ReflectUtil {
/**
* 获得一个类中所有方法列表，直接反射获取，无缓存
*
* @param beanClass 类
*
* @param beanClass 类
* @param withSuperClassMethods 是否包括父类的方法列表
* @return 方法列表
* @throws SecurityException 安全检查异常
@@ -610,7 +622,7 @@ public class ReflectUtil {
/**
* 是否为equals方法
*
*
* @param method 方法
* @return 是否为equals方法
*/
@@ -624,7 +636,7 @@ public class ReflectUtil {
/**
* 是否为hashCode方法
*
*
* @param method 方法
* @return 是否为hashCode方法
*/
@@ -634,7 +646,7 @@ public class ReflectUtil {
/**
* 是否为toString方法
*
*
* @param method 方法
* @return 是否为toString方法
*/
@@ -643,10 +655,11 @@ public class ReflectUtil {
}
// --------------------------------------------------------------------------------------------------------- newInstance
/**
* 实例化对象
*
* @param <T> 对象类型
*
* @param <T> 对象类型
* @param clazz 类名
* @return 对象
* @throws UtilException 包装各类异常
@@ -662,9 +675,9 @@ public class ReflectUtil {
/**
* 实例化对象
*
* @param <T> 对象类型
* @param clazz 类
*
* @param <T> 对象类型
* @param clazz 类
* @param params 构造函数参数
* @return 对象
* @throws UtilException 包装各类异常
@@ -682,7 +695,7 @@ public class ReflectUtil {
final Class<?>[] paramTypes = ClassUtil.getClasses(params);
final Constructor<T> constructor = getConstructor(clazz, paramTypes);
if (null == constructor) {
throw new UtilException("No Constructor matched for parameter types: [{}]", new Object[] { paramTypes });
throw new UtilException("No Constructor matched for parameter types: [{}]", new Object[]{paramTypes});
}
try {
return constructor.newInstance(params);
@@ -693,8 +706,8 @@ public class ReflectUtil {
/**
* 尝试遍历并调用此类的所有构造方法，直到构造成功并返回
*
* @param <T> 对象类型
*
* @param <T> 对象类型
* @param beanClass 被构造的类
* @return 构造后的对象
*/
@@ -706,7 +719,7 @@ public class ReflectUtil {
// ignore
// 默认构造不存在的情况下查找其它构造
}
final Constructor<T>[] constructors = getConstructors(beanClass);
Class<?>[] parameterTypes;
for (Constructor<T> constructor : constructors) {
@@ -714,24 +727,24 @@ public class ReflectUtil {
if (0 == parameterTypes.length) {
continue;
}
constructor.setAccessible(true);
setAccessible(constructor);
try {
return constructor.newInstance(ClassUtil.getDefaultValues(parameterTypes));
} catch (Exception e) {
} catch (Exception ignore) {
// 构造出错时继续尝试下一种构造方式
continue;
}
}
return null;
}
// --------------------------------------------------------------------------------------------------------- invoke
/**
* 执行静态方法
*
* @param <T> 对象类型
*
* @param <T> 对象类型
* @param method 方法（对象方法或static方法都可）
* @param args 参数对象
* @param args 参数对象
* @return 结果
* @throws UtilException 多种异常包装
*/
@@ -742,16 +755,16 @@ public class ReflectUtil {
/**
* 执行方法<br>
* 执行前要检查给定参数：
*
*
* <pre>
* 1. 参数个数是否与方法参数个数一致
* 2. 如果某个参数为null但是方法这个位置的参数为原始类型，则赋予原始类型默认值
* </pre>
*
* @param <T> 返回对象类型
* @param obj 对象，如果执行静态方法，此值为<code>null</code>
*
* @param <T> 返回对象类型
* @param obj 对象，如果执行静态方法，此值为<code>null</code>
* @param method 方法（对象方法或static方法都可）
* @param args 参数对象
* @param args 参数对象
* @return 结果
* @throws UtilException 一些列异常的包装
*/
@@ -774,19 +787,17 @@ public class ReflectUtil {
/**
* 执行方法
*
* @param <T> 返回对象类型
* @param obj 对象，如果执行静态方法，此值为<code>null</code>
*
* @param <T> 返回对象类型
* @param obj 对象，如果执行静态方法，此值为<code>null</code>
* @param method 方法（对象方法或static方法都可）
* @param args 参数对象
* @param args 参数对象
* @return 结果
* @throws UtilException 一些列异常的包装
*/
@SuppressWarnings("unchecked")
public static <T> T invoke(Object obj, Method method, Object... args) throws UtilException {
if (false == method.isAccessible()) {
method.setAccessible(true);
}
setAccessible(method);
try {
return (T) method.invoke(ClassUtil.isStatic(method) ? null : obj, args);
@@ -797,11 +808,11 @@ public class ReflectUtil {
/**
* 执行对象中指定方法
*
* @param <T> 返回对象类型
* @param obj 方法所在对象
*
* @param <T> 返回对象类型
* @param obj 方法所在对象
* @param methodName 方法名
* @param args 参数列表
* @param args 参数列表
* @return 执行结果
* @throws UtilException IllegalAccessException包装
* @since 3.1.2
@@ -813,4 +824,18 @@ public class ReflectUtil {
}
return invoke(obj, method, args);
}
/**
* 设置方法为可访问（私有方法可以被外部调用）
*
* @param <T> AccessibleObject的子类，比如Class、Method、Field等
* @param accessibleObject 可设置访问权限的对象，比如Class、Method、Field等
* @since 4.6.8
*/
public static <T extends AccessibleObject> T setAccessible(T accessibleObject) {
if (null != accessibleObject && false == accessibleObject.isAccessible()) {
accessibleObject.setAccessible(true);
}
return accessibleObject;
}
}