不说废话直接上代码
/**
 * @author Sihan Liu
 */
public class MineBeanUtils {
	
    private static final String ERROR_CODE = "-1";

    /**
     * 合并该类和对应父类的所有Fields
     * @param object object
     * @return List<Field>
     */
    public static List<Field> mergeAllFields(Object object) {
        Class<?> clazz = object.getClass();
        List<Field> fields = new ArrayList<>();

        //排除父级元素,可自定义
        while (clazz != null && !Object.class.getName().equals(clazz.getName())) {
            fields.addAll(Arrays.asList(clazz.getDeclaredFields()));
            clazz = clazz.getSuperclass();
        }
        return fields;
    }

    /**
     * 获取对象中被注解标记的字段值(可修改为返回List<Object>)
     * @param t 对象
     * @param clazz 注解
     * @return 值
     */
    public static Object getByAnnotation(Object t, Class<? extends Annotation> clazz) {
        List<Field> fields = mergeAllFields(t);

        Object value = null;
        for (Field declaredField : fields) {
            declaredField.setAccessible(true);
            if (Modifier.isFinal(declaredField.getModifiers())) {
                continue;
            }
            String object;
            Object targetObject = getTargetObjectValue(declaredField, t);
            if (targetObject == null) {
                object = ERROR_CODE;
            } else {
                object = targetObject.toString();
            }

            Object annotation = declaredField.getAnnotation(clazz);
            if (annotation != null) {
            	//如果多个字段被一个注解标记,在这里修改即可
                value = object;
            }
        }

        if (value == null || ERROR_CODE.equals(value)) {
            throw new RuntimeException("无法获取" + clazz.getSimpleName() + "注解,请检查");
        }

        return value;
    }

    /**
     * 设置对象中被注解标记的字段值
     * @param t 对象
     * @param value 值
     * @param clazz 注解
     */
    public static void setByAnnotation(Object t, Object value, Class<? extends Annotation> clazz) {
        List<Field> fields = mergeAllFields(t);

        for (Field declaredField : fields) {
            declaredField.setAccessible(true);
            if (Modifier.isFinal(declaredField.getModifiers())) {
                continue;
            }

            Object annotation = declaredField.getAnnotation(clazz);
            if (annotation != null) {
                setTargetObjectValue(declaredField, t, value);
                break;
            }
        }
    }

    /**
     * 通过内省机制获取字段值
     * @param declaredField 字段
     * @param t 对象
     * @return 值
     */
    public static Object getTargetObjectValue(Field declaredField, Object t) {
        Object object;
        try {
            PropertyDescriptor propDesc = new PropertyDescriptor(declaredField.getName(), t.getClass());
            object = propDesc.getReadMethod().invoke(t);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("获取对应数据失败");
        }
        return object;
    }

    /**
     * 通过内省机制设置字段值
     * @param declaredField 字段
     * @param t 对象
     * @param value 值
     */
    public static void setTargetObjectValue(Field declaredField, Object t, Object value) {
        try {
            PropertyDescriptor propDesc = new PropertyDescriptor(declaredField.getName(), t.getClass());
            propDesc.getWriteMethod().invoke(t, value);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("写入对应数据失败");
        }
    }
}

1.定义

注解是Annonation接口的一个子接口，注解的作用是为当前读取该注解的程序提供判断依据。注解的具体实现类是Java运行时生成的动态代理类，通过反射获取注解时，返回的是Java运行时生成的动态代理对象。

2.常见注解及其意义

注解包括自定义的注解、JDK内置注解和第三方框架提供的注解

2.1 JDK内置注解

元注解

修饰注解的注解

@Target：表明作用范围，包括类、接口、字段、方法、参数、构造函数、局部变量、注解等
	
@Retention：生命周期，包括SOURCE（被编译器丢弃）、CLASS（在class文件可用，会被JVM丢去）、RUNTIME（JVM使用，作为运行时的判断依据）
	
@Documented：被该注解修饰的注解会生成到javadoc中
	
@Inherited：可以让注解被“继承”，让子类Class对象使用getAnnotations获取父类中被@Inherited修饰的对象
	
@Repeatable：JDK1.8新加入的元注解，表示在同一位置上重复相同的注解
JDK内置注解

@Override：表明此方法覆盖了父类的方法，生命周期为SOURCE
	
@Deprecated：用于标明已经过时的方法和类，生命周期为RUNTIME
	
@SuppressWarning：用于有选择的关闭编译器对类、方法和成员变量的警告，生命周期为SOURCE
2.2 第三方框架提供的注解

Spring IOC相关：@Configuration/@Bean/@Autowired/@Qualifier/@Resource
	
Spring MVC相关：@Controller/@Service/@Repository/@Component/@RequestBody/@ResponseBody/@ResController
	
Spring AOP相关：@Before/@After/@AfterReturning/@AfterThrowing/@Around

@Retention(RetentionPolicy.RUNTIME) // 注解会在class字节码文件中存在，在运行时可以通过反射获取到  
@Target({ElementType.FIELD,ElementType.METHOD})//定义注解的作用目标**作用范围字段、枚举的常量/方法  
@Documented//说明该注解将被包含在javadoc中  
public @interface FieldMeta {  
  
    /** 
     * 是否为序列号 
     * @return 
     */  
    boolean id() default false;  
    /** 
     * 字段名称 
     * @return 
     */  
    String name() default "";  
    /** 
     * 是否可编辑 
     * @return 
     */  
    boolean editable() default true;  
    /** 
     * 是否在列表中显示 
     * @return 
     */  
    boolean summary() default true;  
    /** 
     * 字段描述 
     * @return 
     */  
    String description() default "";  
    /** 
     * 排序字段 
     * @return 
     */  
    int order() default 0;  
}  

实体类：

[java] view plain copy print?
public class Anno {  
  
    @FieldMeta(id=true,name="序列号",order=1)  
    private int id;  
    @FieldMeta(name="姓名",order=3)  
    private String name;  
    @FieldMeta(name="年龄",order=2)  
    private int age;  
      
    @FieldMeta(description="描述",order=4)  
    public String desc(){  
        return "java反射获取annotation的测试";  
    }  
      
    public int getId() {  
        return id;  
    }  
    public void setId(int id) {  
        this.id = id;  
    }  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public int getAge() {  
        return age;  
    }  
    public void setAge(int age) {  
        this.age = age;  
    }  
      
}  

获取到注解的帮助类：

[java] view plain copy print?
public class SortableField {  
  
    public SortableField(){}  
      
    public SortableField(FieldMeta meta, Field field) {  
        super();  
        this.meta = meta;  
        this.field = field;  
        this.name=field.getName();  
        this.type=field.getType();  
    }  

public SortableField(FieldMeta meta, String name, Class<?> type) {  
        super();  
        this.meta = meta;  
        this.name = name;  
        this.type = type;  
    }  

private FieldMeta meta;  
    private Field field;  
    private String name;  
    private Class<?> type;  
      
    public FieldMeta getMeta() {  
        return meta;  
    }  
    public void setMeta(FieldMeta meta) {  
        this.meta = meta;  
    }  
    public Field getField() {  
        return field;  
    }  
    public void setField(Field field) {  
        this.field = field;  
    }  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public Class<?> getType() {  
        return type;  
    }  
  
    public void setType(Class<?> type) {  
        this.type = type;  
    }  

}  

运行时获取注解，首先创建一个基类：

[java] view plain copy print?
public class Parent<T> {  
  
    private Class<T> entity;  
  
    public Parent() {  
        init();  
    }  
  
    @SuppressWarnings("unchecked")  
    public List<SortableField> init(){  
        List<SortableField> list = new ArrayList<SortableField>();  
        /**getClass().getGenericSuperclass()返回表示此 Class 所表示的实体（类、接口、基本类型或 void） 
         * 的直接超类的 Type(Class<T>泛型中的类型)，然后将其转换ParameterizedType。。 
         *  getActualTypeArguments()返回表示此类型实际类型参数的 Type 对象的数组。 
         *  [0]就是这个数组中第一个了。。 
         *  简而言之就是获得超类的泛型参数的实际类型。。*/  
        entity = (Class<T>)((ParameterizedType)this.getClass().getGenericSuperclass())  
                .getActualTypeArguments()[0];  
//      FieldMeta filed = entity.getAnnotation(FieldMeta.class);  
          
        if(this.entity!=null){  
              
            /**返回类中所有字段，包括公共、保护、默认（包）访问和私有字段，但不包括继承的字段 
             * entity.getFields();只返回对象所表示的类或接口的所有可访问公共字段 
             * 在class中getDeclared**()方法返回的都是所有访问权限的字段、方法等； 
             * 可看API 
             * */  
            Field[] fields = entity.getDeclaredFields();  
//            
            for(Field f : fields){  
                //获取字段中包含fieldMeta的注解  
                FieldMeta meta = f.getAnnotation(FieldMeta.class);  
                if(meta!=null){  
                    SortableField sf = new SortableField(meta, f);  
                    list.add(sf);  
                }  
            }  
              
            //返回对象所表示的类或接口的所有可访问公共方法  
            Method[] methods = entity.getMethods();  
              
            for(Method m:methods){  
                FieldMeta meta = m.getAnnotation(FieldMeta.class);  
                if(meta!=null){  
                    SortableField sf = new SortableField(meta,m.getName(),m.getReturnType());  
                    list.add(sf);  
                }  
            }  
            //这种方法是新建FieldSortCom类实现Comparator接口，来重写compare方法实现排序  
//          Collections.sort(list, new FieldSortCom());  
            Collections.sort(list, new Comparator<SortableField>() {  
                @Override  
                public int compare(SortableField s1,SortableField s2) {  
                    return s1.getMeta().order()-s2.getMeta().order();  
//                  return s1.getName().compareTo(s2.getName());//也可以用compare来比较  
                }  
                  
            });  
        }  
        return list;  
          
    }  
}  
创建子类继承基类：

[java] view plain copy print?
public class Child extends Parent<Anno>{  
  
}  

测试类：

[java] view plain copy print?
public class TestAnnotation {  
  
    @SuppressWarnings({ "unchecked", "rawtypes" })  
    public static void main(String[] args) {  
        Parent c = new Child();  
        List<SortableField> list = c.init();//获取泛型中类里面的注解  
        //输出结果  
        for(SortableField l : list){  
            System.out.println("字段名称："+l.getName()+"\t字段类型："+l.getType()+  
                    "\t注解名称："+l.getMeta().name()+"\t注解描述："+l.getMeta().description());  
        }  
    }  
}

大部分头次接触注解的人，应该都是从框架开始的吧，之前感觉注解很神秘，也没有了解过如何基于注解的开发，最近忙里偷闲，学习了一下注解的原理及应用。简单地说，注解就是在类、字段、方法上打一个标记，在之后的代码中，可以通过反射获取到被打上标记的类、字段、方法，方便做一些逻辑处理，而这些处理内容是你自己编写的，所以注解提供的仅仅是一个标记而已，下面贴上一个注解的应用，场景是通过jdbc获取数据库中的行数据Map<String,String>,将该Map转换为相应的POJO
首先是注解的声明，
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Column {

	String name();
}
这里name为该注解的属性，使用时按照格式：@Column(name="xxx")
public class UserDO {
	
	@Column(name = "name")
	private String userName;
	
	@Column(name = "title")
	private String userTitle;
	
	private int loginTimes;
	
	private String empId;

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	public String getUserTitle() {
		return userTitle;
	}

	public void setUserTitle(String userTitle) {
		this.userTitle = userTitle;
	}

	public int getLoginTimes() {
		return loginTimes;
	}

	public void setLoginTimes(int loginTimes) {
		this.loginTimes = loginTimes;
	}

	public String getEmpId() {
		return empId;
	}

	public void setEmpId(String empId) {
		this.empId = empId;
	}
}
之后是POJO，只有2个属性被打上了注解。


import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.lang.StringUtils;

public class ConvertionService {

	private static List<Field> findFields(Class <?>clazz) {
		List<Field> fieldList = new ArrayList<Field>();
		Set<String>fieldNames = new HashSet<String>();
        Class <?>clazzTemp = clazz;
        while(clazzTemp != Object.class) {
        	Field []fields = clazzTemp.getDeclaredFields();
        	for(Field field : fields) {
        		if(!fieldNames.contains(field.getName())) {//同名属性子类覆盖
        			fieldList.add(field);
        			fieldNames.add(field.getName());
        		}
        	}
            clazzTemp = clazzTemp.getSuperclass();
        }
        return fieldList;
	}
	
	@SuppressWarnings("unchecked")
	public static <T> T convertMapToBean(Map<String , String>row , Class<T>clazz) 
				throws InstantiationException, IllegalAccessException {
		Object object = clazz.newInstance();
		List<Field>list = findFields(clazz);
		for(Field field : list) {
			if (!Modifier.isStatic(field.getModifiers()) && !Modifier.isFinal(field.getModifiers())) {//过滤static和final修饰的变量
				if(!field.isAccessible()) field.setAccessible(true);//如果是private变量，放开访问的权限
				Column columnAnnotation = field.getAnnotation(Column.class);
				if(columnAnnotation != null) {
					String value = row.get(columnAnnotation.name());//通过annotation注解的名称来获取对应的值
					Class <?>fieldType = field.getType();
					if(fieldType == String.class) {
						field.set(object, value);
					}else if(fieldType == Integer.class) {
						field.set(object, getInteger(value));
					}else if(fieldType == int.class) {
						field.setInt(object, getInt(value));
					}else if(fieldType == Long.class) {
						field.set(object, getLongWrapper(value));
					}else if(fieldType == long.class) {
						field.setLong(object , getLong(value));
					}/*
						继续的数据类型大家可以自己补充
					*/
				}else {
					/*没有annotation的代码交给大家自己去完成了*/
				}
			}
		}
		return (T)object;
	}
	
	public static Integer getInteger(String value) {
        if (StringUtils.isEmpty(value)) return null;
        return Integer.valueOf(value);
    }

    public static int getInt(String value) {
        if (StringUtils.isEmpty(value)) return 0;
        return Integer.valueOf(value);
    }

    public static Long getLongWrapper(String value) {
        if (StringUtils.isEmpty(value)) return null;
        return Long.valueOf(value);
    }

    public static long getLong(String value) {
        if (StringUtils.isEmpty(value)) return 0;
        return Long.valueOf(value);
    }
}
通过注解及反射，将Map<String,String>转化为相应的POJO的方法
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

public class TestMain {

	public static void main(String []args)
			throws InstantiationException, IllegalAccessException {
		@SuppressWarnings({ "unchecked", "serial" })
		List<HashMap<String , String>>list = Arrays.asList(
				new HashMap<String , String>() {
					{
						put("name" , "xieyuooo");
						put("title" , "小胖");
					}
				},
				new HashMap<String , String>() {
					{
						put("name" , "ffff");
						put("title" , "标题2");
					}
				}
		);
		List<UserDO>users = new ArrayList<UserDO>(list.size());
		for(HashMap<String , String> row : list) {
			users.add(ConvertionService.convertMapToBean(row, UserDO.class));
		}
		System.out.println();
		//这里大家可以将users的列表进行输出
	}
}
测试类的入口方法