java注解的理解与运用

http://www.jiajiajia.club/weblog/blog/artical/90

http://www.jiajiajia.club/weblog/blog/artical/90

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

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四种。

 

@Target	表示该注解可以用于什么地方，可能的ElementType参数有： CONSTRUCTOR：构造器的声明 FIELD：域声明（包括enum实例） LOCAL_VARIABLE：局部变量声明 METHOD：方法声明 PACKAGE：包声明 PARAMETER：参数声明 TYPE：类、接口（包括注解类型）或enum声明
@Retention	表示需要在什么级别保存该注解信息。可选的RetentionPolicy参数包括： SOURCE：注解将被编译器丢弃 CLASS：注解在class文件中可用，但会被VM丢弃 RUNTIME：VM将在运行期间保留注解，因此可以通过反射机制读取注解的信息。
@Document	将注解包含在Javadoc中
@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模拟Controller

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

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

package club.jiajiajia.annbuliding;
import club.jiajiajia.custom.Controller;
import club.jiajiajia.custom.Service;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
public class MyBeanFactory {
    Map<String,Object> map=new HashMap();
    public MyBeanFactory(){
        buding(Controller.class);
    }
    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();
                        }
                    }
                }
                System.out.println(field.getGenericType().getTypeName());
            }
        }
    }
    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 Main {

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

那么对外的表现形式就是

 

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