【随笔】【自定义注解+反射】

自定义注解：

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface Title {

    /**
     * 表头名称
     */
    String value();
}

对象使用注解：

@Data
class CoolMan{
    @Title("name")
    private String name;
    @Title("age")
    private Integer age;
}

反射场景：

import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import com.alibaba.fastjson.JSONObject;

import lombok.Data;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.PropertyAccessorFactory;
import org.springframework.core.convert.ConversionService;
import org.springframework.format.support.DefaultFormattingConversionService;


public class TestDemo {

    private static final ConversionService conversionService = new DefaultFormattingConversionService();

    public static void main(String[] args) {
        Map<String,String>  record = new HashMap<>(16);
        record.put("name","zx");
        record.put("age","26");

        CoolMan parse = parse(CoolMan.class, record);

        System.out.println("RES="+ JSONObject.toJSONString(parse));
    }

    public static <T> T parse( Class<T> entityClass, Map<String,String>  record){

        Map<String, String> fieldMappings = getFieldMappings(entityClass);
        //属性名称
        Collection<String> values = fieldMappings.values();
        T entity;
        try {
            entity = entityClass.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            throw new IllegalArgumentException(entityClass.getName() + " can not be initiated");
        }

        BeanWrapper beanWrapper = PropertyAccessorFactory.forBeanPropertyAccess(entity);
        beanWrapper.setConversionService(conversionService);


        fieldMappings.forEach((field, title) -> {
            String value = record.get(title);
            beanWrapper.setPropertyValue(field, value);
        });

        return entity;


    }

    private static final ConcurrentHashMap<Class<?>, Map<String, String>> CACHE = new ConcurrentHashMap<>();

    public static Map<String, String> getFieldMappings(Class<?> clazz) {
        return CACHE.computeIfAbsent(clazz, c -> {

            Field[] fieldArray = clazz.getDeclaredFields();
            List<Field> fields = new LinkedList<>(Arrays.asList(fieldArray));


            Map<String, String> mappings = new HashMap<>();
            for (Field field : fields) {
                Title title = field.getAnnotation(Title.class);
                if (title != null) {
                    mappings.put(field.getName(), title.value());
                }
                mappings.put(field.getName(), title.value());
            }
            return mappings;
        });
    }
}