根据泛型得到实例对象，想要T t = new T()；? 或者想要T.class ?

Myth丶恋晨 2022-10-09 03:10 124阅读 0赞

最近在写代码的过程中发行很多代码逻辑非常的相似，可以说80%的相似，而不同的就是具体的对象不同，整体的逻辑都相同。

于是想要进行简化开发，抽取公用。在过程中遇到了一些问题。

例如有些时候我想要直接：`T t = JSONObject.paresObject(json,T.class)`但是实际上是做不到的，因为这样是得不到`.class`的。  
如果是通过方法`T t`传入进去，那么在`t`不为null的情况下，可以使用 `t.getClass()`  
但是真正需要用的的时候，例如

<T> void getT(List<T> tList){ 
    	// 在tList不为0的情况下，可以使用下面得到getClass，但是很多时候事与愿违
        T entity = JSONObject.parseObject("", tList.get(0).getClass());
    }

例如：

<T> void getT(XXX<T> x){ 
    	T t = null;//可能想要得到T.class。下面会报空指针异常
    	T entity = JSONObject.parseObject("", t.getClass);
    	// 或者想要 T t = new T(); //这些都是不允许直接这样做的。参考后面的案例进行操作即可做到在这种形式下得到实例对象T t;
    }

--------------------

总共分两种情形：`泛型在类上、泛型在接口上`

可以复制下面的代码到`IDEA`中，运行一下main即可看到效果

import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    // 顶级接口
    interface BaseMapper<T> { 
    }
    // 继承顶级接口
    interface MyBaseMapper1<T> extends BaseMapper<T> { 
    }
    // 实现顶级接口
    class MyBaseMapper2<T> implements BaseMapper<T> { 
    }
    
    // 实现的方式
    class XXXMapper1 implements MyBaseMapper1<User> { 
    }
    
    // 继承的方式
    class XXXMapper2 extends MyBaseMapper2<User> { 
    }
    
    class User { 
        private int age = 12;
    
        @Override
        public String toString() { 
            return "User{" +
                    "age=" + age +
                    '}';
        }
    }
    
    /** * 泛型工具类，可以根据泛型得到泛型的实例 或者 泛型的类型 */
    public class Main{ 
    
        public static void main(String[] args) { 
            System.out.println(getClassByInterfaceT(new XXXMapper1()));
            System.out.println(getEntityByInterfaceT(new XXXMapper1()));
            System.out.println("=========");
            System.out.println(getClassByClassT(new XXXMapper2()));
            System.out.println(getEntityByClassT(new XXXMapper2()));
        }
    
        /** * 得到泛型(继承baseMapper) */
        public static <T> Class<T> getClassByClassT(BaseMapper<T> baseMapper) { 
            Type genericSuperclass = baseMapper.getClass().getGenericSuperclass();
            // 强转成 参数化类型 实体.
            ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
            // 获取超类的泛型类型数组. 即SuperClass<User>的<>中的内容, 因为泛型可以有多个, 所以用数组表示
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            Type genericType = actualTypeArguments[0];
            Class<T> clazz = (Class<T>) genericType;
            return clazz;
        }
    
    
        /** * 根据BaseMapper抽象类得到泛型的实例 * * @param baseMapper 带泛型的实例 * @return 泛型的实例对象 */
        public static <T> T getEntityByClassT(BaseMapper<T> baseMapper) { 
            Class<T> clazz = getClassByClassT(baseMapper);
            T e = null;
            try { 
                if (clazz != null) { 
                    e = clazz.newInstance();
                }
            } catch (InstantiationException instantiationException) { 
                instantiationException.printStackTrace();
            } catch (IllegalAccessException illegalAccessException) { 
                illegalAccessException.printStackTrace();
            }
            return e;
        }
    
    
        /** * 获取泛型的类型(实现baseMapper) */
        public static <T> Class<T> getClassByInterfaceT(BaseMapper<T> baseMapper) { 
            Type[] genericInterfaces = baseMapper.getClass().getGenericInterfaces();
            if (genericInterfaces.getClass().isAssignableFrom(ParameterizedType[].class)) { 
                for (Type genericInterface : genericInterfaces) { 
                    ParameterizedType parameterizedType = (ParameterizedType) genericInterface;
                    Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                    Type type = actualTypeArguments[0];
                    if (type instanceof Class) { 
                        return (Class<T>) type;
                    }
                }
            }
            return null;
        }
    
        /** * 获取实例对象，（实现baseMapper） * 根据接口中的泛型返回对应的实体,例如 XXXMapper implements HcBaseMapper<T> */
        public static <T> T getEntityByInterfaceT(BaseMapper<T> baseMapper) { 
            Class<T> clazz = getClassByInterfaceT(baseMapper);
            T e = null;
            try { 
                if (clazz != null) { 
                    e = clazz.newInstance();
                }
            } catch (InstantiationException instantiationException) { 
                instantiationException.printStackTrace();
            } catch (IllegalAccessException illegalAccessException) { 
                illegalAccessException.printStackTrace();
            }
            return e;
        }
    
    }

执行结果：  
路径

class top.yumbo.User
    User{ age=12}
    =========
    class top.yumbo.User
    User{ age=12}