深入理解Java中的注解Annotation

public @interface MyAnnatation {<!--{C}%3C!%2D%2D%20%2D%2D%3E-->}

public @interface MyAnnatation {
	int NUM = 9;//注解中写属性，很少见
	String test();//方法要求必须有返回值
}

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.*;

@Target({METHOD,CONSTRUCTOR,FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String[] value();//方法不是做事情 为了携带信息 搬运给该注解的解析者使用
    //按道理讲 注解定义者肯定和注解解析者是同一个人，而注解的使用者，它们无需定义和解析注解
    /*方法名刚好是value，并且只有一个方法，使用该注解的时候就可以不指定方法名*/
}

public class Person {
    @MyAnnotation("TOM")
    private String name;
}

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.*;

@Target({METHOD,FIELD})
@Retention(RetentionPolicy.SOURCE)
public @interface YouAnnotation {
    String [] value();
    int count();
    double price();
}

public class Student {
    //注解中有3个方法，则3个方法都要使用到，并且要指明方法名
    //如果数组中只有一个数据，则{}可以省略
    @YouAnnotation(value = "qa",count = 8,price = 9.9)
    private String name;
}

public class Demo {
    public static void main(String[] args) {
        Class<?> clazz = Person.class;
        try {
            Field field = clazz.getDeclaredField("name");
            MyAnnotation annotation = field.getAnnotation(MyAnnotation.class);
            Class<? extends MyAnnotation> aClass = annotation.getClass();
            Method method = aClass.getMethod("value");
            String[] values = (String[])method.invoke(annotation);
            System.out.println(Arrays.toString(values));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

package test_annotation;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * @author 乔澳
 * @version 1.0
 * @title: MySpringDemo
 * @projectName Demo1
 * @description:
 * @date 2020/8/17   18:22
 */
public class MySpringDemo {
    public Object getBean(String className){
        Object obj = null;
        Class<?> clazz = null;
        try {
            clazz = Class.forName(className);
            //获取无参构造方法
            Constructor con = clazz.getConstructor();
            //调用无参构造方法创建对象
            obj = con.newInstance();
            //解析注解中的信息
            //注解放在属性上面，首先获取所有的属性
            Field[] fields = clazz.getDeclaredFields();
            for(int i = 0;i<fields.length;i++){
                //根据属性获取属性上面声明的注解
                Annotation annotation = fields[i].getAnnotation(MyAnnotation.class);
                Class<?> aClass = annotation.getClass();
                Method aMethod = aClass.getMethod("value");
                //获取注解中的值
                String[] values = (String[]) aMethod.invoke(annotation);
                //获取属性名
                String fieldName = fields[i].getName();
                //要给属性赋值，属性是私有的，虽然反射可以操作私有属性，但是很不合理
                //我们利用字符串的拼接，得到set方法的名字，再拿到set方法给属性赋值
                String firstLetter = fieldName.substring(0,1).toUpperCase();//首字母大写
                String otherLetters = fieldName.substring(1);
                StringBuilder setMethodName = new StringBuilder("set");
                setMethodName.append(firstLetter);
                setMethodName.append(otherLetters);
                //拿到属性的类型，下面要用到
                Class<?> fieldType = fields[i].getType();
                //根据set方法名字拿到set方法
                Method setMethod = clazz.getMethod(setMethodName.toString(),fieldType);
                //调用set方法，给对象赋值，如果属性不是String类型，是基本类型的包装类
                //如果属性是Character类型，做单独处理
                if (fieldType==Character.class){
                    //把字符串转化为字符
                    Character c = values[0].toCharArray()[0];
                    setMethod.invoke(obj,c);
                }else{
                    //不是Character类型，而是String 或其他7种包装类，调用包装类的带String参数的构造方法，构造值  比如；new Integer(String v)
                    setMethod.invoke(obj,fieldType.getConstructor(String.class).newInstance(values[0]));
                }
                //对于属性为数组、集合、对象的情况，这里没有做处理
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return obj;
    }
}

package test_annotation;

public class Person {
    @MyAnnotation("Tom")
    private String name;
    @MyAnnotation("18")
    private Integer age;
    @MyAnnotation("男")
    private String sex;
    @MyAnnotation("A")
    private Character bloodType;//血型
    public Person(){}
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Character getBloodType() {
        return bloodType;
    }
    public void setBloodType(Character bloodType) {
        this.bloodType = bloodType;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", bloodType=" + bloodType +
                '}';
    }
}

package test_annotation;

public class TestMain {
    public static void main(String[] args) {
        MySpringDemo msd = new MySpringDemo();
        Person p = (Person) msd.getBean("test_annotation.Person");
        System.out.println(p);
    }
}