1 import org.apache.commons.lang3.StringUtils;
2 import org.apache.commons.lang3.Validate;
3 import org.apache.poi.ss.formula.functions.T;
4 import org.slf4j.Logger;
5 import org.slf4j.LoggerFactory;
6
7 import java.lang.reflect.*;
8 import java.util.HashMap;
9 import java.util.Map;
10
11 /**
12 * ClassName: Reflections
13 * @Description: 反射工具类.提供调用getter/setter方法, 访问私有变量, 调用私有方法, 获取泛型类型Class,被AOP过的真实类等工具函数.
14 * @author
15 * @date 2015年9月9日 下午1:02:26
16 */
17 public class Reflections {
18 private static final String SETTER_PREFIX = "set";
19
20 private static final String GETTER_PREFIX = "get";
21
22 private static final String CGLIB_CLASS_SEPARATOR = "$$";
23
24 private static Logger logger = LoggerFactory.getLogger(Reflections.class);
25
26 /**
27 * @Description: 调用Getter方法.
28 * @param obj
29 * @param propertyName
30 * @return
31 * @return Object
32 * @throws
33 * @author feifei.liu
34 * @date 2015年9月25日 下午7:55:46
35 */
36 public static Object invokeGetter(Object obj, String propertyName) {
37 String getterMethodName = GETTER_PREFIX + StringUtils.capitalize(propertyName);
38 return invokeMethod(obj, getterMethodName, new Class[] {}, new Object[] {});
39 }
40
41 /**
42 * @Description: 调用Setter方法, 仅匹配方法名。
43 * @param obj
44 * @param propertyName
45 * @param value
46 * @return void
47 * @throws
48 * @author feifei.liu
49 * @date 2015年9月25日 下午7:55:59
50 */
51 public static void invokeSetter(Object obj, String propertyName, Object value) {
52 String setterMethodName = SETTER_PREFIX + StringUtils.capitalize(propertyName);
53 invokeMethodByName(obj, setterMethodName, new Object[] { value });
54 }
55
56 /**
57 * @Description: 直接读取对象属性值, 无视private/protected修饰符, 不经过getter函数.
58 * @param obj
59 * @param fieldName
60 * @return
61 * @return Object
62 * @throws
63 * @author feifei.liu
64 * @date 2015年9月25日 下午7:56:13
65 */
66 public static Object getFieldValue(final Object obj, final String fieldName) {
67 Field field = getAccessibleField(obj, fieldName);
68
69 if (field == null) {
70 throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + obj + "]");
71 }
72
73 Object result = null;
74 try {
75 result = field.get(obj);
76 } catch (IllegalAccessException e) {
77 logger.error("不可能抛出的异常{}", e.getMessage());
78 }
79 return result;
80 }
81
82 /**
83 * @Description: 直接设置对象属性值, 无视private/protected修饰符, 不经过setter函数.
84 * @param obj
85 * @param fieldName
86 * @param value
87 * @return void
88 * @throws
89 * @author feifei.liu
90 * @date 2015年9月25日 下午7:56:26
91 */
92 public static void setFieldValue(final Object obj, final String fieldName, final Object value) {
93 Field field = getAccessibleField(obj, fieldName);
94
95 if (field == null) {
96 throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + obj + "]");
97 }
98
99 try {
100 /*if("false".equals(value) || "true".equals(value)){
101 Boolean b = new Boolean(value.toString());
102 boolean b1 = b.booleanValue();
103 field.set(obj, b1);
104 }else{
105 field.set(obj, value);
106 }*/
107 field.set(obj, value);
108 } catch (IllegalAccessException e) {
109 logger.error("不可能抛出的异常:{}", e.getMessage());
110 }
111 }
112
113 /**
114 * @Description: 直接调用对象方法, 无视private/protected修饰符.
115 * 用于一次性调用的情况，否则应使用getAccessibleMethod()函数获得Method后反复调用. 同时匹配方法名+参数类型.
116 * @param obj
117 * @param methodName
118 * @param parameterTypes
119 * @param args
120 * @return
121 * @return Object
122 * @throws
123 * @author feifei.liu
124 * @date 2015年9月25日 下午7:56:33
125 */
126 public static Object invokeMethod(final Object obj, final String methodName, final Class<?>[] parameterTypes,
127 final Object[] args) {
128 Method method = getAccessibleMethod(obj, methodName, parameterTypes);
129 if (method == null) {
130 throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + obj + "]");
131 }
132
133 try {
134 return method.invoke(obj, args);
135 } catch (Exception e) {
136 throw convertReflectionExceptionToUnchecked(e);
137 }
138 }
139
140 /**
141 * @Description: 直接调用对象方法, 无视private/protected修饰符，
142 * 用于一次性调用的情况，否则应使用getAccessibleMethodByName()函数获得Method后反复调用.
143 * 只匹配函数名，如果有多个同名函数调用第一个.
144 * @param obj
145 * @param methodName
146 * @param args
147 * @return
148 * @return Object
149 * @throws
150 * @author feifei.liu
151 * @date 2015年9月25日 下午7:56:57
152 */
153 public static Object invokeMethodByName(final Object obj, final String methodName, final Object[] args) {
154 Method method = getAccessibleMethodByName(obj, methodName);
155 if (method == null) {
156 throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + obj + "]");
157 }
158
159 try {
160 return method.invoke(obj, args);
161 } catch (Exception e) {
162 throw convertReflectionExceptionToUnchecked(e);
163 }
164 }
165
166 /**
167 * @Description: 循环向上转型, 获取对象的DeclaredField, 并强制设置为可访问.
168 * 如向上转型到Object仍无法找到, 返回null.
169 * @param obj
170 * @param fieldName
171 * @return
172 * @return Field
173 * @throws
174 * @author feifei.liu
175 * @date 2015年9月25日 下午7:57:39
176 */
177 public static Field getAccessibleField(final Object obj, final String fieldName) {
178 Validate.notNull(obj, "object can't be null");
179 Validate.notBlank(fieldName, "fieldName can't be blank");
180 for (Class<?> superClass = obj.getClass(); superClass != Object.class; superClass = superClass
181 .getSuperclass()) {
182 try {
183 Field field = superClass.getDeclaredField(fieldName);
184 makeAccessible(field);
185 return field;
186 } catch (NoSuchFieldException e) {// NOSONAR
187 // Field不在当前类定义,继续向上转型
188 }
189 }
190 return null;
191 }
192
193 /**
194 * @Description: 循环向上转型, 获取对象的DeclaredMethod,并强制设置为可访问. 如向上转型到Object仍无法找到, 返回null.
195 * 匹配函数名+参数类型.
196 * 用于方法需要被多次调用的情况. 先使用本函数先取得Method,然后调用Method.invoke(Object obj, Object...args).
197 * @param obj
198 * @param methodName
199 * @param parameterTypes
200 * @return
201 * @return Method
202 * @throws
203 * @author feifei.liu
204 * @date 2015年9月25日 下午7:57:57
205 */
206 public static Method getAccessibleMethod(final Object obj, final String methodName,
207 final Class<?>... parameterTypes) {
208 Validate.notNull(obj, "object can't be null");
209 Validate.notBlank(methodName, "methodName can't be blank");
210
211 for (Class<?> searchType = obj.getClass(); searchType != Object.class; searchType = searchType
212 .getSuperclass()) {
213 try {
214 Method method = searchType.getDeclaredMethod(methodName, parameterTypes);
215 makeAccessible(method);
216 return method;
217 } catch (NoSuchMethodException e) {
218 // Method不在当前类定义,继续向上转型
219 }
220 }
221 return null;
222 }
223
224 /**
225 * @Description: 循环向上转型, 获取对象的DeclaredMethod,并强制设置为可访问. 如向上转型到Object仍无法找到, 返回null. 只匹配函数名.
226 * 用于方法需要被多次调用的情况. 先使用本函数先取得Method,然后调用Method.invoke(Object obj, Object...args)
227 * @param obj
228 * @param methodName
229 * @return
230 * @return Method
231 * @throws
232 * @author feifei.liu
233 * @date 2015年9月25日 下午7:58:48
234 */
235 public static Method getAccessibleMethodByName(final Object obj, final String methodName) {
236 Validate.notNull(obj, "object can't be null");
237 Validate.notBlank(methodName, "methodName can't be blank");
238
239 for (Class<?> searchType = obj.getClass(); searchType != Object.class; searchType = searchType
240 .getSuperclass()) {
241 Method[] methods = searchType.getDeclaredMethods();
242 for (Method method : methods) {
243 if (method.getName().equals(methodName)) {
244 makeAccessible(method);
245 return method;
246 }
247 }
248 }
249 return null;
250 }
251
252 /**
253 * @Description: 改变private/protected的方法为public，尽量不调用实际改动的语句，避免JDK的SecurityManager抱怨
254 * @param method
255 * @return void
256 * @throws
257 * @author feifei.liu
258 * @date 2015年9月25日 下午7:59:24
259 */
260 public static void makeAccessible(Method method) {
261 if ((!Modifier.isPublic(method.getModifiers()) || !Modifier.isPublic(method.getDeclaringClass().getModifiers()))
262 && !method.isAccessible()) {
263 method.setAccessible(true);
264 }
265 }
266
267 /**
268 * @Description: 改变private/protected的成员变量为public，尽量不调用实际改动的语句，避免JDK的SecurityManager抱怨
269 * @param field
270 * @return void
271 * @throws
272 * @author feifei.liu
273 * @date 2015年9月25日 下午7:59:40
274 */
275 public static void makeAccessible(Field field) {
276 if ((!Modifier.isPublic(field.getModifiers()) || !Modifier.isPublic(field.getDeclaringClass().getModifiers())
277 || Modifier.isFinal(field.getModifiers())) && !field.isAccessible()) {
278 field.setAccessible(true);
279 }
280 }
281
282 /**
283 * @Description: 通过反射, 获得Class定义中声明的泛型参数的类型, 注意泛型必须定义在父类处 如无法找到, 返回Object.class. eg.
284 * @param clazz
285 * @return
286 * @return Class<T>
287 * @throws
288 * @author feifei.liu
289 * @date 2015年9月25日 下午7:59:53
290 */
291 @SuppressWarnings({ "unchecked", "rawtypes" })
292 public static <T> Class<T> getClassGenricType(final Class clazz) {
293 return getClassGenricType(clazz, 0);
294 }
295
296 /**
297 * @Description: 通过反射, 获得Class定义中声明的父类的泛型参数的类型. 如无法找到, 返回Object.class.
298 * @param clazz
299 * @param index
300 * @return
301 * @return Class
302 * @throws
303 * @author feifei.liu
304 * @date 2015年9月25日 下午8:00:07
305 */
306 @SuppressWarnings("rawtypes")
307 public static Class getClassGenricType(final Class clazz, final int index) {
308
309 Type genType = clazz.getGenericSuperclass();
310
311 if (!(genType instanceof ParameterizedType)) {
312 logger.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType");
313 return Object.class;
314 }
315
316 Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
317
318 if ((index >= params.length) || (index < 0)) {
319 logger.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: "
320 + params.length);
321 return Object.class;
322 }
323 if (!(params[index] instanceof Class)) {
324 logger.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
325 return Object.class;
326 }
327
328 return (Class) params[index];
329 }
330
331 /**
332 * @Description: 通过反射，获得当前对象类型
333 * @param instance
334 * @return
335 * @return Class<?>
336 * @throws
337 * @author feifei.liu
338 * @date 2015年9月25日 下午8:00:29
339 */
340 @SuppressWarnings("rawtypes")
341 public static Class<?> getUserClass(Object instance) {
342 Validate.notNull(instance, "Instance must not be null");
343 Class clazz = instance.getClass();
344 if ((clazz != null) && clazz.getName().contains(CGLIB_CLASS_SEPARATOR)) {
345 Class<?> superClass = clazz.getSuperclass();
346 if ((superClass != null) && !Object.class.equals(superClass)) {
347 return superClass;
348 }
349 }
350 return clazz;
351
352 }
353
354 /**
355 * @Description: 将反射时的checked exception转换为unchecked exception.
356 * @param e
357 * @return
358 * @return RuntimeException
359 * @throws
360 * @author feifei.liu
361 * @date 2015年9月25日 下午8:01:08
362 */
363 public static RuntimeException convertReflectionExceptionToUnchecked(Exception e) {
364 if ((e instanceof IllegalAccessException) || (e instanceof IllegalArgumentException)
365 || (e instanceof NoSuchMethodException)) {
366 return new IllegalArgumentException(e);
367 } else if (e instanceof InvocationTargetException) {
368 return new RuntimeException(((InvocationTargetException) e).getTargetException());
369 } else if (e instanceof RuntimeException) {
370 return (RuntimeException) e;
371 }
372 return new RuntimeException("Unexpected Checked Exception.", e);
373 }
374
375 /**
376 * @Description: 循环向上，获取对象声明的字段
377 * @author xiaopeng.ma
378 * @date 2017/3/23 17:03
379 */
380 public static Map<String, String> getAllDeclaredField(T t) {
381 Map<String, String> map = new HashMap<>();
382 if (t != null) {
383 Class<?> clazz = t.getClass();
384 for (; Object.class != clazz; clazz.getSuperclass()) {
385 Field[] declaredFields = clazz.getDeclaredFields();
386 for (Field declaredField : declaredFields) {
387 map.put(declaredField.getName(), declaredField.getClass().getSimpleName());
388 }
389 }
390 }
391 return map;
392 }
393
394 }
浙公网安备 33010602011771号