java注解的理解与运用

2019 精帖
2 1636

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

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模拟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();
    }
}

那么对外的表现形式就是

QQ截图20190116000143.png


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


留言(2)
加载更多
猜你喜欢