功能：Java注解的介绍和反射使用

一、注解

1、注解介绍

java注解（Annotation），又称为java标注，是jdk5.0引入的一种机制。

Java 语言中的类、方法、变量、参数和包等都可以被标注，对这些代码段进行解释，编译时生成class时，标注也可以被编译。在运行时，java可以通过反射获取到注解内容，进行一些骚操作，进而简化开发。

2、注解分类

Java 定义了一些注解，有些比较常见

@Override：检查方法是否重写父类方法

@Deprecated：标记方法过时

@SuppressWarnings：忽略警告

元注解，标注注解的注解，一切注解的开始

@Retention：使用范围，是只在代码中，还是编入class文件中，或者是在运行时可以通过反射访问

@Documented：标记这些注解是否包含在用户文档中

@Target：作用范围，可以标记哪些代码块，方法，类或者是字段等其他

@Inherited：标记这个注解是继承于哪个注解类

java7后加入的注解

@SafeVarargs：Java 7 开始支持，忽略任何使用参数为泛型变量的方法或构造函数调用产生的警告

@FunctionalInterface：Java 8 开始支持，标识一个匿名函数或函数式接口

@Repeatable：Java 8 开始支持，标识某注解可以在同一个声明上使用多次

3、自定义注解

1）定义语法

@Documented

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

public @interface MyAnnotation {

    String value() default "";

    String[] params() default {};

}

如上：

@Documented：此注解将包含在用户文档中

@Target： ElementType.Type是说，该注解可以在类、接口（包含注解）、枚举上使用

@Retention：此注解将编译至class文件中，在运行时，会被虚拟机读取使用

和定义接口不同的是，注解的定义前添加@号

如果是字段名是value，则使用注解时可以省略字段名

2）RetentionPolicy，作用范围枚举

package java.lang.annotation;

public enum RetentionPolicy {

    SOURCE,  // Annotation信息仅存在于编译器处理期间，编译后该注解不存在

    CLASS,   // 编译器将Annotation存储于类对应的class文件中

    RUNTIME  // 编译器将Annotation存储于class文件中，并且可由JVM读入

}

3）ElementType，使用范围枚举

package java.lang.annotation;

public enum ElementType {

    // 类，接口（包括注解），枚举

    TYPE,

    // 字段，包括枚举字段

    FIELD,

    // 方法

    METHOD,

    // 方法参数，括号内的形参

    PARAMETER,

    // 构造方法

    CONSTRUCTOR,

    // 局部变量

    LOCAL_VARIABLE,

    // 注解

    ANNOTATION_TYPE,

    // 包

    PACKAGE,

    // Type parameter declaration，@since 1.8

    TYPE_PARAMETER,

    // Use of a type，@since 1.8

    TYPE_USE

}

二、java反射

1、反射介绍

1）反射是什么

简单的来说，反射就是运行时才知道操作的类是什么，并且在运行阶段有虚拟机进行实例化，可知道内部所有的（包括private私有的）属性和方法，这种机制叫做反射

java之所以有了这种机制，才会成为一门准动态语言

动态语言和静态语言的区别

动态语言：是指一类在运行时，也可以改变程序结构的语言，加入新的函数，对象，甚至是代码都可以被引入，可以根据某些条件改变自身结构

主要语言有：C#、JavaScript、PHP、Python

静态语言：相对于动态语言，在运行时结构不可改变的语言就是静态语言
主要语言有：Java、C、C++

在java有了反射之后，java就可以称为准动态语言，反射使得java有了一定的动态性，我们可以通过这种机制，让编程更加灵活，玩出骚操作。

2）简单明白反射作用

在程序开发之初，程序员往往都知道自己需要使用到某些类，这样实例化对象是没问题的，程序也是可以正常访问的，如下

程序员知道要把东西给学生，所以new Student()进行实例化

public class SomeThingTest {

    public static void main(String[] args) {

        Student student = new Student();

        student.give("一个红包");

    }

}

abstract class Person {

    public abstract void give(String some);

}

class Student extends Person{

    @Override

    public void give(String some) {

        System.out.println("给了学生：" + some);

    }

}

class Teacher extends Person{

    @Override

    public void give(String some) {

        System.out.println("给了老师：" + some);

    }

}

那程序员不知道要把东西交给谁呢？程序进行不下去了，所以为了解决此类问题，反射机制诞生了，如下

运行结果相差不大，但内部实现机制完全不一致

public class SomeThingTest {

    public static void main(String[] args) throws Exception {

        Class cls = Class.forName("com.banmoon.something.Teacher");

        Method giveMethod = cls.getMethod("give", String.class);

        Object teacher = cls.newInstance();

        giveMethod.invoke(teacher, "一个苹果");

    }

}

问题：com.banmoon.something.Teacher，这段字符串还不是程序员写死的，就算内部是反射实现的，那这样岂不是多此一举？

非也非也，我给大家看一段常用的配置文件，大家就明白了
spring:

datasource:

     type: com.alibaba.druid.pool.DruidDataSource

 driver-class-name: com.mysql.jdbc.Driver

 url: jdbc:mysql://127.0.0.1:3306/test

 username: root

 password: 1234
熟悉吗，那个数据库连接驱动和数据库连接池，那些开发框架的程序员，他们可不知道我们使用的是什么数据库和什么连接池，所以在我们指定对应的驱动路径后，java虚拟机才反射去获取对应的驱动实例。

这样一来，可以说反射机制是框架设计的灵魂，若没有反射，也没有如此丰富全面的java框架，庞大的java生态系统

2、反射使用

1）反射获取Class对象

在java中，万物皆对象。所以类在反射出来后产生的对象便是Class

获取反射的3种方式，其中2、3种方法的使用是在编码阶段都清楚类的前提下使用的

使用Class对象的静态方法，forName()，根据类的全路径进行加载

通过类名.class获取该类的Class对象

使用实例对象.getClass()获取该类的Class对象
public class SomeThingTest {

    public static void main(String[] args) throws ClassNotFoundException {

        Class cla1 = Class.forName("java.lang.String");

        Class cla2 = String.class;

        Class cla3 = "abc".getClass();

    }

}
问题：以下cla3和cla4是否为同个对象？
public class SomeThingTest {

    public static void main(String[] args) throws ClassNotFoundException {

        Class cla3 = "abc".getClass();

        Class cla4 = new String("123").getClass();

        System.out.println(cla3.hashCode());

        System.out.println(cla4.hashCode());

    }

}

哪些类型可以有Class对象

class：普通类，内部类，静态内部类，局部内部类，匿名内部类

interface：接口

[]：数组

enum：枚举

annotation：注解

基本数据类型：int等

void

2）反射获取类的属性和方法

2.1）写几个类

abstract class Person implements Serializable {

    private String name;

    public Person() {

    }

    public Person(String name) {

        this.name = name;

    }

    public abstract void give(String some);

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

}

class Student extends Person{

    @Override

    public void give(String some) {

        System.out.println("给了学生：" + some);

    }

    public static void staticMothed(){

        System.out.println("静态方法");

    }

}

class Teacher extends Person{

    public String subject;

    public String getPost() {

        return post;

    }

    public void setPost(String post) {

        this.post = post;

    }

    private String post;

    public Teacher() {

    }

    private Teacher(String name, String subject, String post) {

        super(name);

        this.subject = subject;

        this.post = post;

    }

    @Override

    public void give(String some) {

        System.out.println("给了老师：" + some);

    }

    public void teach(String content){

        System.out.println("教学方法一");

    }

    private void teach(String content, Person person){

        System.out.println("教学方法二");

    }

}

2.2）反射使用

import java.io.Serializable;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

public class SomeThingTest {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {

        // 获取Teacher类的class对象

        Class teacherClass = Teacher.class;

        // 获取Teacher类的名字

        System.out.println(teacherClass.getName());

        System.out.println(teacherClass.getSimpleName());

        System.out.println("============= 分割线 ==============");

        // 获取Teacher类的属性，只能获取到public权限的

        Field[] fieldArr = teacherClass.getFields();

        for (Field field : fieldArr) {

            System.out.println(field);

        }

        System.out.println("============= 分割线 ==============");

        // 获取Teacher类的属性，可以获取所有权限的属性

        fieldArr = teacherClass.getDeclaredFields();

        for (Field field : fieldArr) {

            System.out.println(field);

        }

        System.out.println("============= 分割线 ==============");

        // 获取Teacher类的方法，只能获取到public权限的，且可以获取到继承父类的方法

        Method[] methodArr = teacherClass.getMethods();

        for (Method method : methodArr) {

            System.out.println(method);

        }

        System.out.println("============= 分割线 ==============");

        // 获取Teacher类的方法，可以获取所有权限的方法，获取不到继承父类的方法

        methodArr = teacherClass.getDeclaredMethods();

        for (Method method : methodArr) {

            System.out.println(method);

        }

        System.out.println("============= 分割线 ==============");

        // 指定获取Teacher类的方法

        System.out.println(teacherClass.getMethod("teach", String.class));

        System.out.println(teacherClass.getDeclaredMethod("teach", String.class, Person.class));

        System.out.println("============= 分割线 ==============");

        // 获取Teacher类的构造器，只能获取到public权限的

        Constructor[] constructorArr = teacherClass.getConstructors();

        for (Constructor constructor : constructorArr) {

            System.out.println(constructor);

        }

        System.out.println("============= 分割线 ==============");

        // 获取Teacher类的构造器，可以获取所有权限的构造器

        constructorArr = teacherClass.getDeclaredConstructors();

        for (Constructor constructor : constructorArr) {

            System.out.println(constructor);

        }

        System.out.println("============= 分割线 ==============");

        // 拥有无参构造器时，直接进行实例化，不推荐

        Teacher teacher = (Teacher) teacherClass.newInstance();

        // 指定获取Teacher类的构造器，并实例化对象

        Constructor constructor = teacherClass.getConstructor();

        teacher = (Teacher) constructor.newInstance();

        System.out.println(String.format("姓名：%s，职务：%s，科目：%s", teacher.getName(), teacher.getPost(), teacher.subject));

        constructor = teacherClass.getDeclaredConstructor(String.class, String.class, String.class);

        constructor.setAccessible(true);// 设置访问权限，为true时可访问私有private

        teacher = (Teacher) constructor.newInstance("半月无霜", "教导主任", "计算机");

        System.out.println(String.format("姓名：%s，职务：%s，科目：%s", teacher.getName(), teacher.getPost(), teacher.subject));

        System.out.println("============= 分割线 ==============");

        // 调用方法

        Method teachMethod = teacherClass.getDeclaredMethod("teach", String.class, Person.class);

        teachMethod.setAccessible(true);// 设置访问权限，为true时可访问私有private

        teachMethod.invoke(teacherClass.newInstance(), "教学", new Student());

    }

}

3）反射获取注解

3.1）写两个注解和类

import lombok.Data;

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)

@interface MyClassInfo{

    String value();

}

@Target(ElementType.FIELD)

@Retention(RetentionPolicy.RUNTIME)

@interface MyFieldInfo{

    String value();

    String mappingType();

}

@Data

@MyClassInfo("用户类")

class User{

    @MyFieldInfo(value = "主键ID", mappingType = "int")

    private Integer id;

    @MyFieldInfo(value = "用户名", mappingType = "varchar")

    private String username;

    @MyFieldInfo(value = "密码", mappingType = "varchar")

    private String password;

}

3.2）反射使用注解

public class SomeThingTest {

    public static void main(String[] args) {

        Class<User> userClass = User.class;

        Annotation[] annotationArr = userClass.getDeclaredAnnotations();

        for (Annotation annotation : annotationArr) {

            System.out.println(annotation);

        }

        MyClassInfo myClassInfo = userClass.getAnnotation(MyClassInfo.class);

        System.out.println(myClassInfo.value());

        Field[] fieldArr = userClass.getDeclaredFields();

        for (Field field : fieldArr) {

            MyFieldInfo myFieldInfo = field.getDeclaredAnnotation(MyFieldInfo.class);

            System.out.println(String.format("%s[value：%s，mappingType：%s]", field.getName(), myFieldInfo.value(), myFieldInfo.mappingType()));

        }

    }

}

4）反射获取泛型

4.1）写两个泛型的方法

public class Person{

    public void setList(List<String> list){

    }

    public Map<String, Object> returnMap() {

        return null;

    }

}

4.2）反射使用泛型

public class SomeThingTest {

    public static void main(String[] args) throws NoSuchMethodException {

        Method setList = Person.class.getDeclaredMethod("setList", List.class);

        Type[] genericParameterTypes = setList.getGenericParameterTypes();

        for (Type genericParameterType : genericParameterTypes) {

            System.out.println(genericParameterType);

            if (genericParameterType instanceof ParameterizedType){

                // 获取List中的泛型

                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();

                for (Type actualTypeArgument : actualTypeArguments) {

                    System.out.println(actualTypeArgument.getTypeName());

                }

            }

        }

        System.out.println("============= 分割线 ==============");

        Method returnMap = Person.class.getDeclaredMethod("returnMap");

        Type type = returnMap.getGenericReturnType();

        System.out.println(type);

        if (type instanceof ParameterizedType){

            // 获取Map中的泛型

            Type[] actualTypeArguments = ((ParameterizedType) type).getActualTypeArguments();

            for (Type actualTypeArgument : actualTypeArguments) {

                System.out.println(actualTypeArgument.getTypeName());

            }

        }

    }

}

5）在线JDK8API文档

现在，已经知道了反射使用，去剖析框架源码时的你真帅

附上jdk8的在线API文档，祝你前程似锦