修改类型转换

schbrain-canal-client/src/main/java/com/schbrain/canal/client/core/MethodArgumentResolver.java

 package com.schbrain.canal.client.core;
 
+import cn.hutool.core.convert.Convert;
+import cn.hutool.core.convert.ConvertException;
 import com.schbrain.canal.client.event.ResolverCanalEvent;
 import com.schbrain.canal.client.exception.CanalClientException;
 import com.schbrain.canal.client.exception.ReflectionException;
+import com.schbrain.canal.client.reflector.DefaultObjectFactory;
 import com.schbrain.canal.client.reflector.DefaultReflectorFactory;
 import com.schbrain.canal.client.reflector.Reflector;
 import com.schbrain.canal.client.reflector.ReflectorFactory;
-import com.schbrain.canal.client.reflector.DefaultObjectFactory;
 import com.schbrain.canal.client.transfer.ObjectFactory;
 import com.schbrain.canal.client.type.TypeHandler;
 import com.schbrain.canal.client.type.TypeHandlerRegister;
@@ -18,11 +20,13 @@ import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.text.ParseException;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 /**
  * @author zhuyf
- * @date 2022/6/21
  */
 @Slf4j
 public class MethodArgumentResolver {
@@ -35,45 +39,40 @@ public class MethodArgumentResolver {
 
     /**
      * 获取参数类
-     * @param event
-     * @return
      */
     public Class getArgumentClass(ResolverCanalEvent<?> event) {
         if (!classNameMappingClass.containsKey(event)) {
-            //接口泛型缓存
+            // 接口泛型缓存
             boolean cache = interfaceGeneric(event);
-            if(!cache){
-                //继承类泛型缓存
+            if (!cache) {
+                // 继承类泛型缓存
                 cache = extendGeneric(event);
             }
-            if(!cache){
+            if (!cache) {
                 CanalClientException e = new CanalClientException(event.getClass() + "generic get exception");
-                log.error("generic get exception",e);
+                log.error("generic get exception", e);
                 throw e;
             }
         }
         return classNameMappingClass.get(event);
     }
 
-
     /**
      * 接口泛型缓存
-     * @param event
-     * @return
      */
-    private boolean interfaceGeneric(ResolverCanalEvent<?> event){
+    private boolean interfaceGeneric(ResolverCanalEvent<?> event) {
         Type[] types = event.getClass().getGenericInterfaces();
-        if(types == null || types.length == 0){
+        if (types == null || types.length == 0) {
             return false;
         }
         for (Type type : types) {
-            if(!(type instanceof ParameterizedType)){
+            if (!(type instanceof ParameterizedType)) {
                 continue;
             }
-            ParameterizedType parameterized  = (ParameterizedType)type;
+            ParameterizedType parameterized = (ParameterizedType) type;
             Type rawType = parameterized.getRawType();
-            if(rawType.equals(ResolverCanalEvent.class)){
-                Class clazz = (Class)parameterized.getActualTypeArguments()[0];
+            if (rawType.equals(ResolverCanalEvent.class)) {
+                Class clazz = (Class) parameterized.getActualTypeArguments()[0];
                 classNameMappingClass.put(event, clazz);
                 return true;
             }
@@ -81,63 +80,66 @@ public class MethodArgumentResolver {
         return false;
     }
 
-    private boolean extendGeneric(ResolverCanalEvent<?> event){
+    private boolean extendGeneric(ResolverCanalEvent<?> event) {
         Class c = event.getClass();
-        while(true){
+        while (true) {
             Type type = c.getGenericSuperclass();
-            if(type instanceof ParameterizedType){
-                ParameterizedType parameterizedType = (ParameterizedType)type;
+            if (type instanceof ParameterizedType) {
+                ParameterizedType parameterizedType = (ParameterizedType) type;
                 Type[] types = parameterizedType.getActualTypeArguments();
-                if(types!= null && types.length>0){
+                if (types != null && types.length > 0) {
                     classNameMappingClass.put(event, (Class) types[0]);
                     return true;
                 }
             }
             c = c.getSuperclass();
-            if(type.equals(Object.class)){
+            if (type.equals(Object.class)) {
                 break;
             }
         }
         return false;
     }
 
-    public List<EditMetaInfo> resolver(ResolverCanalEvent event, Dml dml) throws InvocationTargetException, IllegalAccessException, ParseException,ReflectionException {
+    public List<EditMetaInfo> resolver(ResolverCanalEvent event, Dml dml) throws InvocationTargetException, IllegalAccessException, ParseException, ReflectionException {
         Class c = getArgumentClass(event);
-        List<EditMetaInfo> editMetaInfos=new ArrayList<>();
+        List<EditMetaInfo> editMetaInfos = new ArrayList<>();
         List<Dml.Row> datas = dml.getData();
         for (Dml.Row row : datas) {
             EditMetaInfo metaInfo = new EditMetaInfo();
-            Object after = columnsConvertObject(c,row.getData());
+            Object after = columnsConvertObject(c, row.getData());
             metaInfo.setAfter(after);
-            Object before = columnsConvertObject(c,row.getOld());
+            Object before = columnsConvertObject(c, row.getOld());
             metaInfo.setBefore(before);
             editMetaInfos.add(metaInfo);
         }
         return editMetaInfos;
     }
 
-
-    public Object columnsConvertObject(Class c,Map<String,Object> columns) throws ReflectionException, InvocationTargetException, IllegalAccessException, ParseException {
-        if(columns==null||columns.isEmpty()){
+    public Object columnsConvertObject(Class c, Map<String, Object> columns) throws ReflectionException, InvocationTargetException, IllegalAccessException, ParseException {
+        if (columns == null || columns.isEmpty()) {
             return null;
         }
-        Reflector classesReflector= reflectorFactory.findForClass(c);
+        Reflector classesReflector = reflectorFactory.findForClass(c);
         Object o = objectFactory.create(c);
-        for (String columnName: columns.keySet()) {
-            String filedName= MapUnderscoreToCamelCase.convertByCache(columnName);
-            Object value=columns.get(columnName);
-            if(value==null){
+        for (String columnName : columns.keySet()) {
+            String filedName = MapUnderscoreToCamelCase.convertByCache(columnName);
+            Object value = columns.get(columnName);
+            if (value == null) {
                 continue;
             }
             if (!classesReflector.hasGetter(filedName)) {
                 continue;
             }
-            Type setterType= classesReflector.getSetterType(filedName);
-            TypeHandler typeHandler= TypeHandlerRegister.getTypeHandler(setterType);
-            if(typeHandler==null){
-                log.error("未适配到typeHandle{},name:{},value:{},",setterType,filedName,value);
+            Type setterType = classesReflector.getSetterType(filedName);
+            try {
+                classesReflector.getSetInvoker(filedName).invoke(o, new Object[]{Convert.convert(setterType, value)});
+            } catch (ConvertException convertException) {
+                TypeHandler typeHandler = TypeHandlerRegister.getTypeHandler(setterType);
+                if (typeHandler == null) {
+                    log.error("未适配到typeHandle{},name:{},value:{},", setterType, filedName, value);
+                }
+                classesReflector.getSetInvoker(filedName).invoke(o, new Object[]{typeHandler.convert(value)});
             }
-            classesReflector.getSetInvoker(filedName).invoke(o,new Object[]{typeHandler.convert(value)});
         }
         return o;
     }