基于ReflectASM+注解开发对象转换工具

已于 2022-05-31 22:30:53 修改
阅读量471 收藏 1
点赞数 2
分类专栏： 笔记 文章标签： java
于 2022-05-31 22:26:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuhao192/article/details/125074651
版权

基于ReflectASM+注解开发对象转换工具

开发原因

在项目对接数据中，会遇到了对外标准和内部标准对象转换问题，需要将上报的数据对象转换为我们项目中标准数据对象，当两边数据标准一致时，比较常见的方式，就是new一个标准的对象，set和get对接数据；或者orika复制对象。第一种方法，就会有长篇幅的set和get方法代码出现，代码不够简洁；也容易遗漏字段的赋值，orika代码简洁，一行代码就可以实现对象的转换。而当标准不一致时题，比如在对接文档中，性别字段为 personGender ，而在我们标准中字段却为gender ，对于这种问题，还是只能回到第一种方法，在代码中set和get，除了这两种情况外，还有上报数据类型和我们标准的类型不一致、上报数据格式为字符串，标准的类型是Integer，针对这个问题，采用了一个基于ReflectASM+注解开发了一个代码转换工具，解决对象转换问题，实现注解配置，一行代码转换的功能。

ReflectASM 是一个非常小的 Java 类库，通过ASM框架操作字节码生成来提供高性能的反射处理，自动为 get/set 字段提供访问类，访问类使用字节码操作而不是 Java 的反射技术，因此非常快。

这里为什么使用ReflectASM ，并不是使用 Java 的反射技术，反射的性能一直是存在诟病，相比于直接调用速度上差了很多。ReflectASM 的调用速度在两者时间，比直接调用慢，但是比使用反射快很多，可以参考，ReflectASM 官方提供的基于 Java 7u3测试结果

截取图片_20220527115729

这里，我们可以测试一下java的直接赋值、反射和ReflectASM 的赋值

    Class<Person> clazz = Person.class;
    Method method = clazz.getMethod("setPersonName", String.class);
    method.setAccessible(true);

    MethodAccess methodAccess = MethodAccess.get(Person.class);

    Person person = new Person();
    //次数
    int times = 1000000;
    // case0: 直接赋值
    long startTime0 = System.currentTimeMillis();
    for (int i = 0; i < times; i++) {
        person.setPersonName("qingshui");
    }
    System.out.println("直接赋值 : " + (System.currentTimeMillis() - startTime0));

    // case1:  java反射
    long startTime1 = System.currentTimeMillis();
    for (int i = 0; i < times; i++) {
        method.invoke(person, "qingshui");
    }
    System.out.println("java 反射 : " + (System.currentTimeMillis() - startTime1));

    // case2: reflectasm
    long startTime2 = System.currentTimeMillis();
    for (int i = 0; i < times; i++) {
        methodAccess.invoke(person, "setPersonName", "qingshui");
    }
    System.out.println("reflectasm 赋值方法 : " + (System.currentTimeMillis() - startTime2));

测试结果

直接赋值 : 16
java 反射 : 24
reflectasm 赋值方法 : 18

可以看到当遍历次数为100w次时，ReflectASM 和直接赋值差距并不是很大

流程图

截取图片_20220527142531

实现

同属性名字段的转换

我们使用A代表源对象、B代表目标对象，在ReflectASM中，MethodAccess为类的方法访问对象，可以通过MethodAccess获取类的各类方法的索引(下标)，ReflectASM主要使用调用方法和获取索引，再赋值两种方式操作，其中使用索引的速度最快

MethodAccess access = MethodAccess.get(SomeClass.class);
//直接调用目标方法赋值
access.invoke(someObject, "setName", "abc");
//获取下标赋值
 Integer setIndex = = access.getIndex("setName");
 access.invoke(someObject, setIndex, "abc");

测试ReflectASM两种赋值方式

// case2: reflectasm
long startTime2 = System.currentTimeMillis();
for (int i = 0; i < times; i++) {
    methodAccess.invoke(person, "setPersonName", "qingshui");
}
System.out.println("reflectasm 赋值方法 : " + (System.currentTimeMillis() - startTime2));

// case3: reflectasm 索引
int index2 = methodAccess.getIndex("setPersonName");
long startTime3 = System.currentTimeMillis();
for (int i = 0; i < times; i++) {
    methodAccess.invoke(person, index2, "qingshui");
}
System.out.println("reflectasm  索引 : " + (System.currentTimeMillis() - startTime3));

测试结果:

reflectasm 赋值方法 : 24
reflectasm  索引 : 16

回到主题，当A和B的字段的属性名、类型都一致时，如何进行复制操作

 private static final String GET_METHOD = "get";

 private static final String SET_METHOD = "set";

//Object A 方法访问对象
MethodAccess sAccess = MethodAccess.get(A.getClass());
//获取到A的全部字段
List<Field> fields = getFields(A);
//Object B 方法访问对象    
MethodAccess tAccess =  MethodAccess.get(B.getClass());
for (Field field : fields) {
    String fieldName=field.getName();
    //并且属性名称为 name 为getName 
    //StringUtils.capitalize 字符首字母大写
    Integer getIndex = sAccess.getIndex(GET_METHOD + StringUtils.capitalize(fieldName));
    //获取当前数据的值
    Object value = sAccess.invoke(A, getIndex);
    //如果当前的值为空，直接跳过
    if (isNullValue(value)) {
        continue;
    }
    Integer setIndex = tAccess.getIndex(SET_METHOD + StringUtils.capitalize(fieldName));
    tAccess.invoke(orig, setIndex, value);   
}

其中getFields()和isNullValue()可以从附件中查找代码块，当两个属性一致时，步骤如下

  1. 获取A的全部字段(包括父类字段)
  2. 遍历A字段，获取A的get方法的索引
  3. 结合步骤2获取到的索引，获取到A对应字段的值，如何值为空，就没必要进行赋值操作
  4. 获取B中set方法的索引
  5. 集合步骤4的索引，赋值B对象对应字段的值

不同属性名的字段转换

当A源对象和B目标对象的字段不一样时，比如想把A的personName字段的值复制到B的name字段，这里便需要使用之前提到的注解辅助帮忙

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Trans {
    /**
     * 转换字段
     */
    String value();
}

在需要转换的字段上，添加注解

@Trans(value = "name")
private String personName;

代码实现

 private static final String GET_METHOD = "get";

 private static final String SET_METHOD = "set";

//Object A 方法访问对象
MethodAccess sAccess = MethodAccess.get(A.getClass());
//获取到A的全部字段
List<Field> fields = getFields(A);
//Object B 方法访问对象    
MethodAccess tAccess =  MethodAccess.get(B.getClass());
for (Field field : fields) {
    String fieldName=field.getName();
    //并且属性名称为 name 为getName 
    //StringUtils.capitalize 字符首字母大写
    Integer getIndex = sAccess.getIndex(GET_METHOD + StringUtils.capitalize(fieldName));
    //获取当前数据的值
    Object value = sAccess.invoke(A, getIndex);
    //如果当前的值为空，直接跳过
    if (isNullValue(value)) {
        continue;
    }
    String transFieldName;
    //如果存在自定义的注解
    Trans transValue;
    if ((transValue = field.getAnnotation(Trans.class)) != null) {
       transFieldName = transValue.value();
    }else{
        transFieldName=fieldName;
    }
    Integer setIndex = tAccess.getIndex(SET_METHOD + StringUtils.capitalize(transFieldName));
    tAccess.invoke(B, setIndex, value);   
}

在同属性名字段的基础上，添加了一个判断流程

  1. 字段是否存在Trans注解，如果存在注解，则将获取注解配置的value属性值

不同类型的字段

在上个方法中，通过注解的方式解决了字段的类型一致，仅方法属性名不一致的复制，如果当A源对象和B目标对象的字段类型也不一样，该如何处理？这里便需要扩展注解的内容，增加一个目标类型的配置

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Trans {
    /**
     * 转换字段
     */
    String value();

    /**
     * 转换目标的字段类型
     */
    TransType type() default TransType.STRING;

}

public enum TransType {
    /**
     * 字符格式
     */
    STRING,
    /**
     * 整数
     */
    INTEGER

}

这里以Stirng字符格式的值复制给Integer的字段为例子

在需要转换的字段上，添加注解

@Trans(value = "gender",type = TransType.INTEGER)
private String personGender;

代码实现：

 private static final String GET_METHOD = "get";

 private static final String SET_METHOD = "set";

//Object A 方法访问对象
MethodAccess sAccess = MethodAccess.get(A.getClass());
//获取到A的全部字段
List<Field> fields = getFields(A);
//Object B 方法访问对象    
MethodAccess tAccess =  MethodAccess.get(B.getClass());
for (Field field : fields) {
    String fieldName=field.getName();
    //并且属性名称为 name 为getName 
    //StringUtils.capitalize 字符首字母大写
    Integer getIndex = sAccess.getIndex(GET_METHOD + StringUtils.capitalize(fieldName));
    //获取当前数据的值
    Object value = sAccess.invoke(A, getIndex);
    //如果当前的值为空，直接跳过
    if (isNullValue(value)) {
        continue;
    }
    String transFieldName;
    //如果存在自定义的注解
    Trans transValue;
    TransType type;
    if ((transValue = field.getAnnotation(Trans.class)) != null) {
       transFieldName = transValue.value();
       type = transValue.type();
    }else{
        transFieldName=fieldName;
    }
    Object sourceValue;
    //获取到set方法的下标
    Integer setIndex;
    if(type!=null){
         switch (type) {
           case STRING:
                  sourceValue = String.valueOf(value);
                  setIndex = tAccess.getIndex(SET_METHOD + StringUtils.capitalize(transFieldName), String.class);
                  break;
           case INTEGER:
                  sourceValue = Integer.parseInt(String.valueOf(value));
                  setIndex = tAccess.getIndex(SET_METHOD + StringUtils.capitalize(transFieldName), Integer.class);
                  break;  
    }else{
          setIndex = tAccess.getIndex(SET_METHOD + StringUtils.capitalize(transFieldName));     
    }
    tAccess.invoke(B, setIndex, sourceValue);   
}

在上个方法的基础上，增加一个TransType类型的处理，根据TransType获取到目标对象对应的字段、类型的索引，然后再赋值给该字段值，由于TransType的默认值为TransType.STRING;，如果需要将源对象的Integer复制到目标对象Integer时，使用到注解时，需要这样配置

@Trans(value = "gender",type = TransType.INTEGER)
private Integer personGender;

扩展

以上，只是一个简单的转换对象工具的实现，在实际项目中，还需要对这个工具类进行扩展

时间格式处理

这个扩展主要是为了支持Stirng字符格式的值。转换为Date格式，这里涉及到了时间字符的格式化处理，还是要扩展注解的内容

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Trans {
    /**
     * 转换字段
     */
    String value();

    /**
     * 转换目标的字段类型
     */
    TransType type() default TransType.STRING;
	/**
     * 时间格式
     */
    String dateFormat() default "yyyy-MM-dd HH:mm:ss";
}

public enum TransType {
    /**
     * 字符格式
     */
    STRING,
    /**
     * 整数
     */
    INTEGER,
     /**
     * 时间格式
     */
    DATE
}

字段的注解配置

@Trans(value = "startTime", type = TransType.DATE, dateFormat = "yyyy-MM-dd")
private String startTime;

代码实现

 private static final String GET_METHOD = "get";

 private static final String SET_METHOD = "set";

//Object A 方法访问对象
MethodAccess sAccess = MethodAccess.get(A.getClass());
//获取到A的全部字段
List<Field> fields = getFields(A);
//Object B 方法访问对象    
MethodAccess tAccess =  MethodAccess.get(B.getClass());
for (Field field : fields) {
    String fieldName=field.getName();
    //并且属性名称为 name 为getName 
    //StringUtils.capitalize 字符首字母大写
    Integer getIndex = sAccess.getIndex(GET_METHOD + StringUtils.capitalize(fieldName));
    //获取当前数据的值
    Object value = sAccess.invoke(A, getIndex);
    //如果当前的值为空，直接跳过
    if (isNullValue(value)) {
        continue;
    }
    String transFieldName;
    //如果存在自定义的注解
    Trans transValue;
    TransType type;
    if ((transValue = field.getAnnotation(Trans.class)) != null) {
       transFieldName = transValue.value();
       type = transValue.type();
    }else{
        transFieldName=fieldName;
    }
    //需要复制的值
    Object sourceValue;
    //获取到set方法的下标
    Integer setIndex;
    if(type!=null){
         switch (type) {
           case DATE:
                  String formats = transValue.dateFormat();
                 //转换时间格式
                  sourceValue = DateUtil.formatStrToDate(String.valueOf(value), format);
                  setIndex = tAccess.getIndex(SET_METHOD + StringUtils.capitalize(transFieldName), Date.class);
                  break;
           case STRING:
                  sourceValue = String.valueOf(value);
                  setIndex = tAccess.getIndex(SET_METHOD + StringUtils.capitalize(transFieldName), String.class);
                  break;
           case INTEGER:
                  sourceValue = Integer.parseInt(String.valueOf(value));
                  setIndex = tAccess.getIndex(SET_METHOD + StringUtils.capitalize(transFieldName), Integer.class);
                  break;  
    }else{
          setIndex = tAccess.getIndex(SET_METHOD + StringUtils.capitalize(transFieldName));     
    }
    tAccess.invoke(B, setIndex, sourceValue);   
}

通过注解的dateFormat属性，扩展工具对字符格式化为时间的处理

处理非基类的List转换List

在实际中，我们会遇到一个List<C.class>转换为另一个List<D.class>的情况，这里还是要继续扩展注解，比如，需要把List<Person> persons转换 List<User> users

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Trans {
    /**
     * 转换字段
     */
    String value();

    /**
     * 转换目标的字段类型
     */
    TransType type() default TransType.STRING;
	/**
     * 时间格式
     */
    String dateFormat() default "yyyy-MM-dd HH:mm:ss";
    /**
     * 转换字段格式
     */
    Class<?> toFieldClass() default String.class;
}

public enum TransType {
    /**
     * 字符格式
     */
    STRING,
    /**
     * 整数
     */
    INTEGER,
     /**
     * 时间格式
     */
    DATE,
     /**
     * 集合
     */
    LIST
}

字段的注解配置

@Trans(value = "users", toFieldClass = User.class)
private List<Person> persons;

@Data
public class Person {
    @Trans(value = "name")
    private String personName;
    
    @Trans(value = "gender",type = TransType.INTEGER)
    private String personGender;
    
    @Trans(value = "startTime", type = TransType.DATE, dateFormat = "yyyy-MM-dd")
    private String startTime;
}

在代码实现中，需要增加如下代码处理

/**
     * TransToExpress::TransToExpress
     * <p>转换数据内容到目标数据
     * <p>HISTORY: 2021/9/13 qingshui : Created.
     *
     * @param dest 源数据
     * @param orig 目标数据
     * @return Object 目标对象
 */
public static Object transToExpress(Object dest, Object orig) {
````取值、判断空值

    Class<?> toFieldClass = transValue.toFieldClass();
    //集合并且非基类转换
    if (value instanceof List && !baseClass(toFieldClass)) {
       listNotBaseClassTypeToList(orig, (List<?>) value, transValue);
       return;
    }
`````处理非集合的代码
}
  

/*==============  private method =============*/


/**
     * TransToExpress::listNotBaseClassTypeToList
     * <p>TO:非基础类型的集合转换成目标的集合
     * <p>HISTORY: 2021/11/12 qingshui : Created.
     *
     * @param orig       目标值
     * @param value      转换的集合
     * @param transValue 注解
*/
private static void listNotBaseClassTypeToList(Object orig, List<?> value, Trans transValue) {
    String fieldName = transValue.value();
    Class<?> toFieldClass = transValue.toFieldClass();
    List<?> values = transListToListExpress(toFieldClass, value);
    //处理赋值 
    invokeTargetValue(orig, fieldName, values, TransType.LIST);
}

/**
     * TransToExpress:: transListToListExpress
     * <p>list集合转list
     * <p>通过ConstructorAccess构造函数，构造对象，便利调用transToExpress方法
     * <p>HISTORY: 2021/9/16 qingshui : Created.
     *
     * @param orig  目标的对象的class对象
     * @param value 转换之前的值
     * @return List<Object>  返回转换后的对象集合
*/
private static List<Object> transListToListExpress(Class<?> orig, List<?> value) {
    List<Object> values = new ArrayList<>();
    //从缓存获取到构造对象
    ConstructorAccess<?> access = ConstructorAccess.get(orig);
    for (Object dest : value) {
        Object newOrig = access.newInstance();
        values.add(transToExpress(dest, newOrig));
    }
    return values;
}

/**
     * TransToExpress:: baseClass
     * <p>判断传入的是不是基础类型和系统类
     * <p>HISTORY: 2021/9/17 qingshui : Created.
     *
     * @param className 类名
     * @return boolean  true 是的 false 不是
*/
private static boolean baseClass(Class<?> className) {
    // org.springframework.util.ClassUtils 方法
    return className.equals(String.class) || ClassUtils.isPrimitiveOrWrapper(className);
}


/**
     * TransToExpress:: invokeTargetValue
     * <p>使用asm对目标的对象进行赋值操作、
     * <p>HISTORY: 2021/9/15 qingshui : Created.
     *
     * @param orig      目标的对象值
     * @param fieldName 赋值的字段名称
     * @param value     目标值
     * @param type      转换的类型，这里其实可以不传入该值进行推断，也能获取到，考虑传入类型，可以准确定位到方法的下标
 */
private static void invokeTargetValue(Object orig, String fieldName, Object value, TransType type) {
    try {
        MethodAccess tAccess = getMethodAccess(orig);
        //获取到set方法的下标
        Object sourceValue;

        Integer setIndex;
        switch (type) {
            case DATE:
                sourceValue = value;
                setIndex = tAccess.getIndex(SET_METHOD + StringUtils.capitalize(fieldName), Date.class);
                break;
            case STRING:
                sourceValue = String.valueOf(value);
                setIndex = tAccess.getIndex(SET_METHOD + StringUtils.capitalize(fieldName), String.class);
                break;
            case INTEGER:
                sourceValue = Integer.parseInt(String.valueOf(value));
                setIndex = tAccess.getIndex(SET_METHOD + StringUtils.capitalize(fieldName), Integer.class);
                break;
            case LIST:
 				//增加一个list对象的赋值
                sourceValue = value;
                setIndex = tAccess.getIndex(SET_METHOD + StringUtils.capitalize(fieldName), List.class);
                break;
            default:
                setIndex = tAccess.getIndex(SET_METHOD + StringUtils.capitalize(fieldName));
                sourceValue = value;
        }
        //赋值
        tAccess.invoke(orig, setIndex, sourceValue);
    } catch (IllegalArgumentException e) {
        //打印日志
        log.error("TransToExpress.invokeTargetValue fieldName: {} \n Exception :{}", fieldName, e.getMessage());
    }
}

处理非基类的集合类型转换，步骤如下

  1. 判断当前的需要转换的值是否为List，并且转换的目标类toFieldClass是否为基类，如何是基类的转换，直接调用invokeTargetValue 进行转换，不需要特殊的处理
  2. 使用ConstructorAccess构建目标类对象
  3. 遍历value，调用transToExpress方法转换源对象A转换为目标对象B，递归调用,transToExpress方法(工具类的入口)

优化

使用缓存

由于在代码中会频繁使用MethodAccess、Field、ConstructorAccess等对象，所以在实际项目中，会使用map缓存，增加复用，提高效率

    /**
     * 方法的的缓存
     */
    private static final Map<Class<?>, MethodAccess> ACCESS_MAP = new HashMap<>(64);

    /**
     * 字段的缓存
     */
    private static final Map<Class<?>, List<Field>> FIELDS_MAP = new HashMap<>(64);

    /**
     * 下标的缓存
     */
    private static final Map<String, Integer> INDEX_MAP = new HashMap<>(64);

    /**
     * 构建对象方法的的缓存
     */
    private static final Map<Class<?>, ConstructorAccess<?>> CONSTRUCTOR_ACCESS_MAP = new HashMap<>(64);

//使用缓存的例子 case1
public static Object transToExpress(Object dest, Object orig) {
    //缓存
    MethodAccess sAccess = getMethodAccess(dest);
    //拿到类的源对象的全部属性
    List<Field> fields = getFields(dest);
    for (Field field : fields) {
        //获取字段值的所在的下标
        String getKey = dest.getClass().getName() + GET_METHOD + field.getName();
        Integer getIndex = INDEX_MAP.get(getKey);
        if (getIndex == null) {
            getIndex = sAccess.getIndex(GET_METHOD + StringUtils.capitalize(field.getName()));
            INDEX_MAP.put(getKey, getIndex);
        }
    }     
}

//使用缓存的例子 case2
 private static void invokeTargetValue(Object orig, String fieldName, Object value, TransType type) {
        try {
            MethodAccess tAccess = getMethodAccess(orig);
            //获取到set方法的下标
            Object sourceValue;
            String setKey = orig.getClass().getName() + SET_METHOD + fieldName;
            Integer setIndex = INDEX_MAP.get(setKey);
            switch (type) {
                case DATE:
                    sourceValue = value;
                    if (setIndex == null) {
                        //获取到赋值方法的下标
                        setIndex = tAccess.getIndex(SET_METHOD + StringUtils.capitalize(fieldName), Date.class);
                        INDEX_MAP.put(setKey, setIndex);
                    }
                    break;
                case STRING:
                    sourceValue = String.valueOf(value);
                    if (setIndex == null) {
                        setIndex = tAccess.getIndex(SET_METHOD + StringUtils.capitalize(fieldName), String.class);
                        INDEX_MAP.put(setKey, setIndex);
                    }
                    break;
                case INTEGER:
                    sourceValue = Integer.parseInt(String.valueOf(value));
                    if (setIndex == null) {
                        setIndex = tAccess.getIndex(SET_METHOD + StringUtils.capitalize(fieldName), Integer.class);
                        INDEX_MAP.put(setKey, setIndex);
                    }
                    break;
                case LIST:
                    sourceValue = value;
                    if (setIndex == null) {
                        setIndex = tAccess.getIndex(SET_METHOD + StringUtils.capitalize(fieldName), List.class);
                        INDEX_MAP.put(setKey, setIndex);
                    }
                    break;
                default:
                    if (setIndex == null) {
                        setIndex = tAccess.getIndex(SET_METHOD + StringUtils.capitalize(fieldName));
                        INDEX_MAP.put(setKey, setIndex);
                    }
                    sourceValue = value;
            }
            //赋值
            tAccess.invoke(orig, setIndex, sourceValue);
        } catch (IllegalArgumentException e) {
            //打印日志
 			log.error("TransToExpress.invokeTargetValue fieldName: {} \n Exception :{}", fieldName, e.getMessage());
        }
    }


/*==============  private method =============*/
  

/**
     * TransToExpress:: getMethodAccess
     * <p>TO:获取到对象的方法的句柄
     * <p>HISTORY: 2021/11/12 qingshui : Created.
     *
     * @param object 对象
     * @return MethodAccess  返回方法的句柄
*/
private static MethodAccess getMethodAccess(Object object) {
    MethodAccess sAccess = ACCESS_MAP.get(object.getClass());
    if (sAccess == null) {
        sAccess = MethodAccess.get(object.getClass());
        ACCESS_MAP.put(object.getClass(), sAccess);
    }
    return sAccess;
}

  /**
     * TransToExpress:: getDestFields
     * <p>TO:获取到源对象的字段值
     * <p>HISTORY: 2021/11/12 qingshui : Created.
     *
     * @param dest 源对象
     * @return List<Field>   字段属性.
     */
private static List<Field> getFields(Object dest) {
    List<Field> fields = FIELDS_MAP.get(dest.getClass());
    if (fields == null) {
        fields = TransUtil.getFields(dest.getClass());
        FIELDS_MAP.put(dest.getClass(), fields);
    }
    return fields;
}

总结

文章大部分代码以参考为主(项目问题，完整代码无法贴出)，在实际项目，我们扩展这个工具类其他功能，比如增加主键自定义格式化、图片上传的自定义处理、赋值额外字段等功能，在开发这个工具类的过程中，逐步完善工具，丰富功能，体验到了开发轮子魅力所在，不过，最大成就感还是来自这行代码

//一行代码转换对象
TransToExpress.transToExpress(person, user)

附件

    /*==============  private method =============*/

    /**
     *  <p>TO:获取一个类的全部字段信息
     *  <p>HISTORY: 2022/2/28 qingshui : Created.
     *  @param    objClass 目标类
     *  @return    List<Field> 字段的信息
     */
    private static List<Field> getFields(Class<?> objClass) {
        List<Field> fieldList = new ArrayList<>();
        while (null != objClass) {
            fieldList.addAll(Arrays.asList(objClass.getDeclaredFields()));
            objClass = objClass.getSuperclass();
        }
        return fieldList;
    }
    
    /**
     * <p>TO:判断当前字符是否是空值,这里直接转拆箱转换为String，或者判断其他对象是不是null值
     * <p>HISTORY: 2021/11/12 qingshui : Created.
     *
     * @param value 需要判断的值
     * @return Boolean true
     */
    private static boolean isNullValue(Object value) {
        if (value instanceof String) {
            return StringUtils.isBlank((String) value);
        }
        return null == value;
    }
清水雅然君
关注
专栏目录
java里面的lang包源码-reflectasm:高性能Java反射
06-05
java里面的lang包源码 请使用支持。 概述 ReflectASM 是一个非常小的 Java 库，它通过使用代码生成来提供高性能的反射。 生成访问类以设置/获取字段、调用方法或创建新实例。 访问类使用字节码而不是 Java 的反射，因此速度要快得多。 它还可以通过字节码访问原始字段以避免装箱。 表现 这些基准测试的源代码包含在项目中。 以上图表是在 Oracle 的 Java 7u3 服务器虚拟机上生成的。 安装 要在 maven 中使用reflectasm，请在您的 pom.xml 中使用以下代码段 < dependency > < groupId >com.esotericsoftware</ groupId > < artifactId >reflectasm</ artifactId > < version >1.11.9</ version > </ dependency > 用法 使用 ReflectASM 进行方法反射： SomeClass someObject = ... MethodAccess access = MethodAccess . get( SomeC
reflectasm-1.11.3.jar
05-28
javaEE、javaweb常用jar包导入到eclipse或者idea中可以使用，需要其他版本请留言看到后我会上传资源给大家下载
通过自定义注解实现对象转换insertsql
weixin_41934671的博客
01-10 644
  1.首先写一个自定义注解类 package annoction; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Retention;  import java.lang.annotation.Target;  imp...
ReflectASM 高性能反射库教程
最新发布
gitblog_00738的博客
08-12 288
ReflectASM 高性能反射库教程 reflectasmHigh performance Java reflection项目地址:https://gitcode.com/gh_mirrors/re/reflectasm 项目介绍 ReflectASM 是一个非常小的高性能 Java 反射库，通过使用 ASM 字节码技术动态生成访问类来避免传统的 Java 反射调用。由于直接使用字节码，Ref...
meethigher-基于Java注解实现的对象转换(深拷贝)
meethigher的博客
10-25 348
使用过SpringBoot的，自然都知道BeanUtils.copy的强大之处，该篇文章简单记录使用注解实现对象转换。
【反射】使用反射来获取注解原数据信息-类信息-方法信息等
weixin_33747129的博客
09-22 449
项目结构 代码位置：https://github.com/ssslinppp/reflectdemo 自定义注解 ClassAnnotation.java @Documented @Target({ElementType.TYPE}) @Retention(RUNTIME) public @interface ClassAnnotation { String classAlias() d...
reflect反射 & Annotation注解
qq_42219543的博客
11-02 350
类加载器的基本概念：          类加载器（class loader）用来加载 Java 类到 Java 虚拟机中。一般来说，Java 虚拟机 使用 Java 类的方式如下：Java 源程序（.java ）在经过 Java 编译器编译之后就被转换成 Java 字节代码（.class ）。类加载器负责读取 Java 字节代码，并转换成 java.lang.Class 类 的一个实例。每个这样...
reflectasm-1.11.3-API文档-中文版.zip
07-05
赠送jar包：reflectasm-1.11.3.jar； 赠送原API文档：reflectasm-1.11.3-javadoc.jar； 赠送源代码：reflectasm-1.11.3-sources.jar； 赠送Maven依赖信息文件：reflectasm-1.11.3.pom； 包含翻译后的API文档：...
reflectasm-1.11.3-API文档-中英对照版.zip
07-03
赠送jar包：reflectasm-1.11.3.jar； 赠送原API文档：reflectasm-1.11.3-javadoc.jar； 赠送源代码：reflectasm-1.11.3-sources.jar； 赠送Maven依赖信息文件：reflectasm-1.11.3.pom； 包含翻译后的API文档：...
reflectasm-1.07-shaded.jar
07-04
<value>file:///root/apache-hive-1.2.1-bin/lib/minlog-1.2.jar,file:///root/apache-hive-1.2.1-bin//lib/objenesis-1.2.jar,file:///root/apache-hive-1.2.1-bin//lib/reflectasm-1.07-shaded.jar ...
Java高性能反射工具包ReflectASM
hellojoy的博客
02-29 1098
https://blog.csdn.net/HUXU981598436/article/details/90634602 ReflectASM使用字节码生成的方式实现了更为高效的反射机制。执行时会生成一个存取类来 set/get字段，访问方法或创建实例。一看到ASM就能领悟到ReflectASM会用字节码生成的方式，而不是依赖于Java本身的反射机制来实现的，所以它更快，并...
reflectasm java 高性能反射工具
互联网编程爱好者
03-18 519
reflectasm java 高性能反射工具
Java反射工具包reflectasm
zsj777的专栏
09-10 429
1、 <dependency> <groupId>com.esotericsoftware</groupId> <artifactId>reflectasm</artifactId> <version>1.11.9</version> </dependency> 1、实体类 package com.redisson;
Java-反射性能优化和工具包ReflectASM
weixin_40017062的博客
08-29 1344
1、Class.forName反射方法比较耗时，可以先把Class.forName返回的Class对象缓存起来，下次使用直接读取缓存，提高效率 2、ReflectASM通过字节码生成的方式实现了更为高效的反射机制。 3、ConstructorAccess反射来调用构造方法、 4、FieldAccess反射获取属性 5、MethodAccess反射调用方法 6、reflectASM效率明显高于Java反射获取
ReflectASM的使用
weixin_34000916的博客
10-15 493
2019独角兽企业重金招聘Python工程师标准>>> ...
reflectasm --反射工具
客人
01-28 530
&lt;!-- 反射工具 --&gt; &lt;dependency&gt; &lt;groupId&gt;org.db4j&lt;/groupId&gt; &lt;artifactId&gt;reflectasm&lt;/artifactId&gt; &lt;version&gt;1.11.4-2&lt;/version&gt; &lt;/depende
Reflect工具类（自己写的小玩意，作个纪念）
tavor的专栏
09-01 1984
 package cn.edu.sdu.tavor;import java.lang.reflect.Constructor;import java.lang.reflect.Field;import java.lang.reflect.Method;import java.lang.reflect.Modifier;import java.util.ArrayList;import ja
基于reflectasm打造自己的通用bean工具
weixin_33892359的博客
12-20 301
　　业务场景： 在很多的业务系统中，erp，crm系统中，有许多的对象信息都是拆开来的，例如一个商品，那可能他的商品名称，商品等主要信息放在一个表（衍生出来一个对象），他的附属信息（商品图片，规格，价格等）可能会在其他的多个表（对象）中，这个时候一般我们想到的操作是： 1.将主要的对象查询出来 2.利用主要对象和其他附属信息的关联字段来查询主对象关联的附属信息对象列表 3.将查询到的附属信...
Java注解——反射机制访问注解
m0_47005019的博客
07-20 234
RetentionPolicy.SOURCE当前注解仅保留在源代码中，编译后的字节码文件中没有该注解。注解被大量应用与反射中，可以辅助反射机制做更多灵活的操作。Java注解又称Java标注，是在JDK5时引入的新特性。RetentionPolicy.CLASS保留到编译后的字节码文件中，但是反射机制不可访问。该注解可以传递的参数为ElementType类型，用来表示可标注的位置。如果不指定@Target,则当前注解可以被应用在任何注解可使用的位置上。当前注解的保留级别，有三个可选值。...
reflectasm-1.11.3中文API文档及资源包
ReflectASM 是一个高性能的反射库，由 Esoteric Software 公司开发，主要用于 Java 语言。它提供了一种轻量级的方法来访问和修改 Java 对象的字段，而无需生成大量的代理代码，这在性能关键的应用中非常有用。...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值