基於反射作的對象比對
前提java
因爲項目須要在一條記錄被更改後找到修改的內容而後記錄到數據庫，而後筆者找了不少網上資料木有找到因此本身寫了一個Java對象比較器，廢話很少說直接貼出代碼貼出個性，有什麼說的不對的還望各位網友指出。數據庫
代碼json
註解類 數組
package com.java.test;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@Retention(RetentionPolicy.RUNTIME) // 註解會在class字節碼文件中存在，在運行時能夠經過反射獲取到
@Documented//說明該註解將被包含在javadoc中
public @interface Remark
{
public String value();
}
比對後返回結果實體類工具
package com.java.test;
public class Result
{
public String key;
public String valueFront;
public String valueEnd;
public Result()
{
super();
}
public Result(String key, String valueFront, String valueEnd)
{
super();
this.key = key;
this.valueFront = valueFront;
this.valueEnd = valueEnd;
}
}
String 幫助類
測試
package com.java.test;
public class StringUtil {
/**
* 將首字母轉換大寫
* @param str
* @return
*/
public static String toUpInitial(String str){
if(!StringUtil.isBlank(str)){
return str.replaceFirst(str.substring(0, 1), str.substring(0, 1).toUpperCase());
}
return null;
}
/**
* 檢查字符串是不是空白：<code>null</code>、空字符串<code>""</code>或只有空白字符。
*
* <pre>
* StringUtil.isBlank(null) = true
* StringUtil.isBlank("") = true
* StringUtil.isBlank(" ") = true
* StringUtil.isBlank("bob") = false
* StringUtil.isBlank(" bob ") = false
* </pre>
*
* @param str
* 要檢查的字符串
*
* @return 若是爲空白, 則返回<code>true</code>
*/
public static boolean isBlank(String str) {
int length;
if ((null == str) || ((length = str.length()) == 0)) {
return true;
}
for (int i = 0; i < length; i++) {
if (!Character.isWhitespace(str.charAt(i))) {
return false;
}
}
return true;
}
}
對象實體類
this
package com.java.test;
public class AdminModule
{
private Integer moduleId;
@Remark("1235456")
private String moduleName;
private String moduleUrl;
private String moduleRemark;
public Integer getModuleId()
{
return moduleId;
}
@Remark("Test 註解測試")
public String getModuleName()
{
return moduleName;
}
public void setModuleName(String moduleName)
{
this.moduleName = moduleName;
}
public String getModuleUrl()
{
return moduleUrl;
}
public void setModuleUrl(String moduleUrl)
{
this.moduleUrl = moduleUrl;
}
}
反射工具類spa
package com.java.test;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import com.alibaba.fastjson.JSON;
public class ReflectUtil
{
public static boolean isClass(Object obj1, Object obj2)
{
try
{
if (obj1.getClass().equals(obj2.getClass()))
{
return true;
}
} catch (Exception e)
{
System.err.println(e.getMessage());
}
return false;
}
public static Map<String, String> getMethodNamesAndType(Object object)
{
Field[] fields = object.getClass().getDeclaredFields(); // 獲取實體類的全部屬性，返回Field數組
Map<String, String> map = new HashMap<String, String>();
for (Field field : fields)
{
map.put(field.getName(), field.getType().toString());
}
if (map.size() == 0)
{
return null;
}
return map;
}
public static String[] getMethodNames(Object object)
{
Field[] fields = object.getClass().getDeclaredFields(); // 獲取實體類的全部屬性，返回Field數組
List<String> list = new ArrayList<>();
for (Field field : fields)
{
list.add(field.getName());
}
if (list.size() == 0)
{
return null;
}
return list.toArray(new String[list.size()]);
}
public static Object methodValue(Object obj, String fieldName,Class<?> classType, Object value)
{
try
{
if(null != obj){
Class<? extends Object> ownerClass = obj.getClass();
if (null != classType)
{
Method method = ownerClass.getMethod(fieldName, new Class[] { classType });
return method.invoke(obj, new Object[] { value });
} else
{
Method method = ownerClass.getMethod(fieldName, new Class[] {});
return method.invoke(obj, new Object[] {});
}
}
} catch (Exception e)
{
System.err.println(e.getMessage());
}
return null;
}
public static Class getClassByClass(String str)
{
if (!StringUtil.isBlank(str))
{
switch (str)
{
case "java.lang.Integer":
return java.lang.Integer.class;
case "java.lang.String":
return java.lang.Integer.class;
case "java.lang.Byte":
return java.lang.Byte.class;
case "java.lang.Double":
return java.lang.Double.class;
case "java.lang.Character":
return java.lang.Character.class;
case "java.util.Date":
return java.util.Date.class;
case "java.util.Map":
return java.util.Map.class;
case "java.util.List":
return java.util.List.class;
case "java.lang.Boolean":
return java.lang.Boolean.class;
default:
return null;
}
}
return null;
}
public static Object getNewObject(String fileName)
{
Class<?> classType;
try
{
classType = Class.forName(fileName);
if(null != classType){
return classType.newInstance();
}
} catch (ClassNotFoundException | InstantiationException
| IllegalAccessException e)
{
e.printStackTrace();
}
return null;
}
public static List<Result> getChange(Object obj1, Object obj2)
{
try
{
if (isClass(obj1, obj2)){
if(null != obj1 && null != obj2){
Map<String, String> map = getMethodNamesAndType(obj1);
if(null != map && map.size() > 0){
List<Result> list = new ArrayList<>();
Result result = null;
for (String key : map.keySet())
{
// 方法名拼接
String fielName = "get" + StringUtil.toUpInitial(key); //經過get 方法獲取字段裏面的值
Object value1 = ReflectUtil.methodValue(obj1, fielName, null, null);
Object value2 = ReflectUtil.methodValue(obj2, fielName, null, null);
if (map.get(key).equals("java.util.List") // 判斷類型是否是集合
|| map.get(key).equals("java.util.MAP")
|| map.get(key).equals("java.util.SET"))
{
// TODO 集合更改未作處理
}else{
if(null == value1 || null == value2){
if(null == value1 ){
result = new Result(key, "", null == value2 ? "" : value2.toString().trim());
}else{
result = new Result(key, null == value1 ? "" : value1.toString().trim(), "");
}
}else{
if (!value1.toString().trim().equals(value2.toString().trim()))
{
result = new Result(key,
null == value1 ? "" : value1.toString().trim(),
null == value2 ? "" : value2.toString().trim());
}
}
}
if(!StringUtil.isBlank(result.getValueEnd()) && !StringUtil.isBlank(result.getValueFront())){
list.add(result);
}
}
return list;
}
}
}
} catch (Exception e)
{
System.err.println(e.getMessage());
}
return null;
}
public static Annotation getFieldAnnotation(Class<?> classType , String name ,Class<? extends Annotation> annotation) {
try
{
if(null!= classType && null != annotation && !StringUtil.isBlank(name)){
Field field = classType.getDeclaredField(name);
if(null != field){
if(field.isAnnotationPresent(annotation)){ //判斷是否有此註解
return field.getAnnotation(annotation);
}
}
}
} catch (Exception e)
{
System.err.println(e.getMessage());
}
return null;
}
public static Annotation getMethodAnnotation(Class<?> classType,Class<? extends Annotation> annotation,String name,Class[] parameterTypes ) {
try
{
if(null!= classType && !StringUtil.isBlank(name)){
Method method = classType.getDeclaredMethod(name, parameterTypes);
if(null != method){
if(method.isAnnotationPresent(annotation)){ //判斷是否有此註解
return method.getAnnotation(annotation);
}
}
}
} catch (Exception e)
{
System.err.println(e.getMessage());
}
return null;
}
@Test
public void test2() throws Exception{
AdminModule module1 = new AdminModule();
AdminModule module2 = new AdminModule();
module1.setModuleId(123);
module1.setModuleName("Test");
module1.setModuleUrl("sss123");
module2.setModuleId(123);
module2.setModuleName("Test1");
module2.setModuleUrl("sss123");
List<Result> list = ReflectUtil.getChange(module1, module2);
System.out.println("\n---------------------------------對象比對------------------------------- ");
System.out.println(JSON.toJSON(list));
System.out.println("\n-----------------------------------註解----------------------------- ");
Remark remark = (Remark) ReflectUtil.getFieldAnnotation(AdminModule.class, "moduleName",Remark.class );
Remark remark2 = (Remark) ReflectUtil.getMethodAnnotation(AdminModule.class, Remark.class, "getModuleName", new Class[]{}); //須要異常處理
System.out.println(remark.value());
System.out.println(remark2.value());
System.out.println("\n----------------------------------反射方法操做------------------------------ ");
AdminModule module = (AdminModule) ReflectUtil.getNewObject("com.java.test.AdminModule");
ReflectUtil.methodValue(module, "setModuleName", String.class, "反射測試");
System.out.println(JSON.toJSON(module));
Object obj = ReflectUtil.methodValue(module, "getModuleName", null, null);
System.out.println(obj);
}
}
相關文章
- 1. DataReader反射泛型對象
- 2. Class對象即反射
- 3. 面向對象7--反射
- 4. Java之反射——類對象
- 5. Java反射（一）——Class對象
- 6. 反射2：生成對象
- 7. 面向對象【十】反射
- 8. python -- 面向對象 - 反射
- 9. 反射創建對象
- 10. java8反射創建對象
- 更多相關文章...
- • C# 反射（Reflection） - C#教程
- • ASP ASPError 對象的屬性 - ASP 教程
- • ☆基於Java Instrument的Agent實現
- • 適用於PHP初學者的學習線路和建議
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. DataReader反射泛型對象
- 2. Class對象即反射
- 3. 面向對象7--反射
- 4. Java之反射——類對象
- 5. Java反射（一）——Class對象
- 6. 反射2：生成對象
- 7. 面向對象【十】反射
- 8. python -- 面向對象 - 反射
- 9. 反射創建對象
- 10. java8反射創建對象