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個方法都要使用到，并且要指明方法名
    //如果數(shù)組中只有一個數(shù)據(jù)，則{}可以省略
    @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);
            //獲取無參構(gòu)造方法
            Constructor con = clazz.getConstructor();
            //調(diào)用無參構(gòu)造方法創(chuàng)建對象
            obj = con.newInstance();
            //解析注解中的信息
            //注解放在屬性上面，首先獲取所有的屬性
            Field[] fields = clazz.getDeclaredFields();
            for(int i = 0;i<fields.length;i++){
                //根據(jù)屬性獲取屬性上面聲明的注解
                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();
                //根據(jù)set方法名字拿到set方法
                Method setMethod = clazz.getMethod(setMethodName.toString(),fieldType);
                //調(diào)用set方法，給對象賦值，如果屬性不是String類型，是基本類型的包裝類
                //如果屬性是Character類型，做單獨處理
                if (fieldType==Character.class){
                    //把字符串轉(zhuǎn)化為字符
                    Character c = values[0].toCharArray()[0];
                    setMethod.invoke(obj,c);
                }else{
                    //不是Character類型，而是String 或其他7種包裝類，調(diào)用包裝類的帶String參數(shù)的構(gòu)造方法，構(gòu)造值  比如；new Integer(String v)
                    setMethod.invoke(obj,fieldType.getConstructor(String.class).newInstance(values[0]));
                }
                //對于屬性為數(shù)組、集合、對象的情況，這里沒有做處理
            }
        } 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);
    }
}