注解与反射-蒲公英云

注解

什么是注解

Annotation(注解)是从JDK5.0开始引入的新技术
注解可以被其他程序（如：编译器等）读取，不是程序本身，可以对程序做出解释
注解以**“@注释名”**在代码中存在，还可以添加一些参数值
我们可以通过反射机制编程实现对这些元数据的访问

内置注解

@Override:定义在java.lang.Override中，此注释只适用于修辞方法，表示一个方法声明打算重写超类中的另外一个方法声明
@Deprecated:定义在java.lang.Deprecated中，此注释可以用于修辞方法，属性，类，表示不鼓励程序员使用这样的元素，通常是因为它很危险或者存在更好的选择
@SuppressWarnings:定义在java.lang.SuppressWarnings中，用来一直编译时的警告信息
- 与前面两个注释有所不同，你需要添加一个参数才能正确使用，这些参数都是已经定义好了的，我们选择性的实用就好了
  - @SuppressWarings(“all”)
  - @SuppressWarings(“unchecked”)
  - @SuppressWarings(“value={“unchecked”,deprecation})
  - 等等

元注解

元注解的作用是辅助注解其他注解，Java定义了4个标准的meta-annotation类型，他们被用来提供对其他的annotation类型作说明，在java.lang.annotation包中

@Target：用于描述注解的使用范围（即：被描述的注解可以用在什么地方）
@Retention：表示需要在什么级别保存该注释信息，用于描述注解的生命周期
- (SOURCE<CLASS<RUNTIME)
@Document：说明该注解将被包含在javadoc中
@Inherited：说明子类可以继承父类中的该注解

自定义注解

使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口

//自定义注解
public class Test01 {
    @MyAnnotation(age = 18)//如果自定义注解中没有默认值，则必须要输入值
    public void test(){
    }
}
@Target({
    ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{
    //注解的参数：参数类型+参数名();
    String name() default "";
    int age();
    int id() default -1;
    String[] schools() default {
    "lzj","hgd"};
}

反射

反射机制概述

Reflection(反射)是Java被视为动态语言的关键，反射机制允许程序在执行期借助于ReflectionAPI取得任何类的内部信息，并能直接操作任意对象的内部属性及方法
```
//通过反射获取类的class对象
Class c = Class.forName("java.lang.String");
```
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象(一个类只有一个Class对象) ，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以,我们形象的称之为:反射

正常方式：引入需要的“包类名称”—>通过new实例化—>取得实例化对象

反射方式：实例化对象—>getClass()方法—>得到完整的包类名称
优点：可以实现动态创建对象和编译，体现出很大的灵活性
缺点：对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求，这类操作总是慢于直接执行相同的操作

反射相关的主要API

java.lang.Class :代表一个类
java.lang.reflect.Method :代表类的方法
java.lang.eflect.Field :代表类的成员变量
java.lang.reflect.Constructor :代表类的构造器

Class类

对象照镜子后可以得到的信息:某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE都为其保留一个不变的Class类型的对象。一个Class对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。

Class 本身也是一个类
Class 对象只能由系统建立对象
一个加载的类在JVM中只会有一个Class实例
一个Class对象对应的是一个加载到JVM中的一个class文件
每个类的实例都会记得自己是由哪个Class实例所生成
通过Class可以完整地得到一个类中的所有被加载的结构
Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

获取Class类的实例

//若已知具体的类，通过class属性获取，该方法最为安全可靠，程序的性能最高
Class clazz = Person.class;
//一直某个类的实例，调用该实例的getClass()方法获取Class对象
Class clazz = person.getClass();
//已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取
Class clazz = Class.forName("demo01.Student");
//内置基本数据类型可以直接用类名.Type
Integer.Type

获取类运行时的结构

//获取类运行时的结构
public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class aClass = Class.forName("反射.Stud");
        //获得类的名字
        System.out.println(aClass.getName());//获得包名+类名
        System.out.println(aClass.getSimpleName());//获得类名
        //获得类的属性
        System.out.println("======================");
        Field[] fields = aClass.getFields();//只能找到public属性
        Field[] declaredFields = aClass.getDeclaredFields();//找到全部是属性
        //获得类的方法
        System.out.println("=====================");
        Method[] methods = aClass.getMethods();//获得本类及父类的所有方法
        Method[] declaredMethods = aClass.getDeclaredMethods();//获得本类的所有方法
        //获得构造器
        System.out.println("=====================");
        Constructor[] constructors = aClass.getConstructors();//获得全部的构造器
        Constructor[] declaredConstructors = aClass.getDeclaredConstructors();//获得本类全部的构造器
    }
}

通过反射动态的创建对象

public class User {
    private String name;
    private int id;
    private int age;
    public User() {
    }
    public User(String name, int id, int age) {
        this.name = name;
        this.id = id;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", age=" + age +
                '}';
    }
}
//动态的创建对象，通过反射
public class Test03 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //获得class对象
        Class<?> aClass = Class.forName("反射.User");
        //构造一个对象
        User user = (User) aClass.newInstance();//本质是调用了类的无参构造器
        System.out.println(user);
        //通过构造器创建对象
        Constructor<?> constructor = aClass.getDeclaredConstructor(String.class, int.class, int.class);
        User user1 = (User) constructor.newInstance("lzj", 01, 18);
        System.out.println(user1);
        //通过反射调用普通方法
        User user3 = (User) aClass.newInstance();
        //通过反射获取一个方法
        Method setName = aClass.getDeclaredMethod("setName", String.class);
        //invoke:激活的意思
        //（对象，“方法的值”）
        setName.invoke(user3,"lzj");
        System.out.println(user3.getName());
        //通过反射操作属性
        User user4 = (User) aClass.newInstance();
        Field name = aClass.getDeclaredField("name");
        //不能直接操作私有属性，我们需要关闭程序的安全检测，属性或方法的setAccessible(true)
        name.setAccessible(true);
        name.set(user4,"lzj");
        System.out.println(user4.getName());
    }
}

性能对比分析

public class Test4 {
    //普通方式调用
    public static void test01(){
        User user = new User();
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            user.getName();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("普通方法执行10亿次："+(endTime-startTime)+"ms");
    }
    //反射方式调用
    public static void test02() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        User user = new User();
        Class c1 = user.getClass();
        Method declaredMethod = c1.getDeclaredMethod("getName", null);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            declaredMethod.invoke(user,null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射调用方式执行10亿次："+(endTime-startTime)+"ms");
    }
    //反射方式调用，关闭检测
    public static void test03() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        User user = new User();
        Class c1 = user.getClass();
        Method declaredMethod = c1.getDeclaredMethod("getName", null);
        declaredMethod.setAccessible(true);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            declaredMethod.invoke(user,null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("关闭检测反射调用方式执行10亿次："+(endTime-startTime)+"ms");
    }
    public static void main(String[] args) throws IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        test01();
        test02();
        test03();
    }
}

通过反射操作注解

//反射操作注解
public class Test5 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class<?> c1 = Class.forName("反射.Student2");
        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //获得注解的value值
        TableLzj annotation = c1.getAnnotation(TableLzj.class);
        String value=annotation.value();
        System.out.println(value);
        //获得类指定的注解
        Field name = c1.getDeclaredField("name");
        FiledLzj annotation1 = name.getAnnotation(FiledLzj.class);
        System.out.println(annotation1.columnName());
        System.out.println(annotation1.length());
        System.out.println(annotation1.type());
    }
}
@TableLzj("db_student")
class Student2{
    @FiledLzj(columnName = "db_id",type = "int",length = 10)
    private int id;
    @FiledLzj(columnName = "db_age",type = "int",length = 10)
    private int age;
    @FiledLzj(columnName = "db_name",type = "varchar",length = 3)
    private String name;
    public Student2() {
    }
    public Student2(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student2{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableLzj{
    String value();
}
//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FiledLzj{
    String columnName();
    String type();
    int length();
}