在用各种框架的时候，注解是几乎都会遇到的，那么他的原理是怎么样的呢！来探究一下

1.我们用过很多注解比如下面的 jdk自带的注解

@Override 表示覆盖或重写父类的方法；

@Deprecated 表示该方法已经过时了。（当方法或是类上面有@Deprecated注解时，说明该方法或是类都已经过期不能再用，但不影响以前项目使用，提醒你新替代待的方法或是类。如果程序员不小心使用了它的元素,那么编译器会发出警告信息。）

@SuppressWarnings 表示忽略指定警告，比如@Suppvisewarnings("Deprecation")

2.注解的分类

        按运行机制（注解存在于程序的那个阶段）将注解分为三类：源码注解(只在源码存在，编译成class文件注解就不存在了)、编译注解(在class文件中也存在)、运行时注解(在运行阶段仍然起作用)

        按照来源来分，有如下三类：
1：JDK自带的注解（Java目前只内置了三种标准注解：@Override、@Deprecated、@SuppressWarnings，以及四种元注解：@Target、@Retention、@Documented、@Inherited）
2：第三方的注解——这一类注解是我们接触最多和作用最大的一类
3：自定义注解——也可以看作是我们编写的注解，其他的都是他人编写注解

        按照功能来分的，还有，元注解——注解的注解。

元注解是指注解的注解，包括@Retention @Target @Document @Inherited四种。

3.自定义注解

package club.jiajiajia.test;

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

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    public String a() default "aaa";
    public String b();
}

4.使用注解

package club.jiajiajia.test;
import club.jiajiajia.annbuliding.MyBeanFactory;
import club.jiajiajia.custom.Controller;
@MyAnnotation(b="bbb")
public class TestAnn {

}

5.注解的解析（用到了反射）

public class Main {

    public static void main(String[] args) {
        Class clazz = TestAnn.class;//获取带注解类的class对象
        //获取类上面的注解
        MyAnnotation ann=(MyAnnotation)clazz.getAnnotation(MyAnnotation.class);
        //得到了注解，我们就可以做一些事情了
        System.out.println(ann.a());
        System.out.println(ann.b());
    }
}

6.那么如果理解了注解的原理，那我们就可以大胆的想象一下spring的ioc容器时如何通过注解来扫描类和创建对象的了，做一个大胆的实验（前无古人，后无来者）

首先我们创建两个注解

AutoBuliding模拟spring中的Autowire

package club.jiajiajia.annbuliding;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AutoBuliding {
}

Klasses模拟spring中的Controller

package club.jiajiajia.annbuliding;
import java.lang.annotation.*;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Klasses {
}

创建一个扫描文件下的类的类

package club.jiajiajia.annbuliding;

import club.jiajiajia.Main;
import org.junit.Test;

import java.io.File;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * 扫描指定目录下的类
 */
public class Scanning {
    private List<String> classPaths = new ArrayList<String>();
    private Set<Class<?>>  clazz =new HashSet<>();
    private String basePack;
    private String classpath;

    public Scanning(String basicPathes){
        this.basePack = basicPathes.replace(".", File.separator);
        classpath = MyBeanFactory.class.getResource("/").getPath();
        try {
            searchClass();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    public void searchClass() throws ClassNotFoundException {
        doPath(new File(classpath + basePack));
        Class cls=null;
        for (String s : classPaths) {
            s = s.replace(classpath.replace("/","\\")
                    .replaceFirst("\\\\",""),"")
                    .replace("\\",".")
                    .replace(".class","");
            cls = Class.forName(s);
            clazz.add(cls);
        }
    }
    private void doPath(File file) {
        if (file.isDirectory()) {
            File[] files = file.listFiles();
            for (File f1 : files) {
                doPath(f1);
            }
        } else {
            if (file.getName().endsWith(".class")) {
                classPaths.add(file.getPath());
            }
        }
    }

    public Set<Class<?>> getClazz() {
        return clazz;
    }
}

创建一个解析注解的类（其中用到了一个Controller类，比如Controller类是从文件中扫描出来的）模拟 Spring 的applicationcontext

package club.jiajiajia.annbuliding;
import club.jiajiajia.custom.Controller;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/***
 * 自动装配对象
 */
public class MyBeanFactory {
    Map<String,Object> map=new HashMap();
    public MyBeanFactory(String path){
        Scanning s=new Scanning(path);
        Set<Class<?>> c= s.getClazz();
        for(Class<?> sc:c){
            buding(sc);
        }
    }
    public void buding(Class c){
        Klasses k=(Klasses)c.getAnnotation(Klasses.class);
        if(k!=null){//类上有注解
            if(!map.containsKey(c.getName())){//map里面没有包含类
                System.out.println("创建类");
                try {
                    Object o = c.newInstance();
                    map.put(c.getName(),o);
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
            Field[] fields = c.getDeclaredFields();
            for (Field field : fields) {//遍历类的所有的属性
                AutoBuliding a=field.getAnnotation(AutoBuliding.class);
                if(a!=null){//如果属性有注解
                    field.setAccessible(true);
                    if(map.containsKey(field.getGenericType().getTypeName())){//如果map里面有这个类
                        try {
                            field.set( map.get(c.getName()),map.get(field.getGenericType().getTypeName()));
                            //注入属性
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        }
                    }else{
                        try {
                            buding(Class.forName(field.getGenericType().getTypeName()));
                            field.set( map.get(c.getName()),map.get(field.getGenericType().getTypeName()));
                        } catch (ClassNotFoundException e) {
                            e.printStackTrace();
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
    public Object getBean(Class c){
        return map.get(c.getName());
    }
}

然后创建三个类，模拟 controller，service , dao

package club.jiajiajia.custom;

import club.jiajiajia.annbuliding.AutoBuliding;
import club.jiajiajia.annbuliding.Klasses;

@Klasses
public class Controller {

    @AutoBuliding
    private Service service;

    public void test(){
        System.out.println("经过controller");
        System.out.println(service.service());
    }
}

package club.jiajiajia.custom;

import club.jiajiajia.annbuliding.AutoBuliding;
import club.jiajiajia.annbuliding.Klasses;

@Klasses
public class Service {

    @AutoBuliding
    private Dao dao;

    public String service(){
        System.out.println("经过serviice");
        return dao.dao();
    }
}

package club.jiajiajia.custom;

import club.jiajiajia.annbuliding.Klasses;

@Klasses
public class Dao {
    public String dao(){
        System.out.println("经过dao");
        return "查出数据";
    }
}

测试类

package club.jiajiajia;
import club.jiajiajia.annbuliding.MyBeanFactory;
import club.jiajiajia.custom.Controller;
public class Main6 {

    public static void main(String[] args) {
        Controller c=(Controller)new MyBeanFactory("club.jiajiajia.custom").getBean(Controller.class);
        c.test();
    }
}

那么对外的表现形式就是

是不是很神奇，我们并没有手动创建对象，但是对象确是存在的，而且完美的注入到了对应的地方。