Java注解与反射

注解

什么是注解

1. Annotation是从JDK5.0开始引入的新技术；
2. 作用

• 不是程序本身，可以对程序做出解释（同注释comment）；
• 可以被其他程序（如：编译器）读取。

3. 格式

“@注解名” 还可以添加一些参数值

如@SuppressWarnings(value = “unchecked”)

4. 可以附加在package、class、method、field等上面使用，相当于给他们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些元数据的访问。

内置注解

1. @Override

定义在java.lang.Override中，只适用于修饰方法，表示一个方法声明打算重写超类中的另一个方法声明。

2. @Deprecated

定义在java.lang.Deprecated中，可以用于修饰方法、属性、类，表示不建议程序员使用，但可以使用，通常因为他很危险或者存在更好的选择。

3. @SuppressWarnings

定义在java.lang.SuppressWarnings中，用来抑制编译时的警告信息，需要添加一个参数（定义好了的）

例如：

• @SuppressWarnings(“all”)
• @SuppressWarnings(“unchecked”)
• @SuppressWarnings(value = {“unchecked”,“deprecation”})等等

元注解

1. 作用：负责注解其他注解Java定义了4个标准的meta-annotation类型

2. 如下：

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

自定义注解

1. @interface 定义注解，自动继承了java.lang.annotation.Annotation接口
2. 分析

• 其中的每一个方法实际上是声明了一个配置参数
• 方法的名称即为参数的名称
• 返回值类型就是参数的类型（返回值只能是基本类型、Class、String、enum）
• 可以通过default声明参数的默认值
• 如果只有一个参数成员，一般参数名位value
• 注解元素必须要有值，我们定义注解元素时，经常使用空字符串，0作为默认值

实例

package com.man.annotation;

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

public class Test {
    @MyAnnotation("you")
    public void show(){}

    @MyAnnotation2()//由于每个参数都给了默认值，所以这里不会报错
    public void show2(){}

    @MyAnnotation2(name = "alice",age = 19)
    public void show3(){}
}

//自定义注解
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{
    //注解的参数：参数类型 + 参数名()
    String value();//参数只有一个时可以用value来表示参数，这样在使用时可以省略“value=”
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
    String name() default "";//给出默认值
    int age() default 18;
    String[] college() default {"上大,武大"};
}

反射

反射概述

静态语言VS动态语言

动态语言：在运行时可以改变其语言结构的语言

静态语言：与动态语言相对应的，运行时结构不可变的语言就是静态语言

Java不是动态语言，但Java可称为“准动态语言”，可以利用反射机制获得类似动态语言的特性

Java Reflection

反射是Java被视为动态语言的关键

反射机制：程序执行期间借助Reflection API取得任意类的内部信息，并能直接操作任意对象的内部属性及方法。

优缺点

优点：可实现动态创建对象和编译，体现出很大的灵活性

缺点：对性能有影响

package com.man.ref;

//什么叫反射
public class Demo01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获得类的Class对象
        Class c1 = Class.forName("com.man.ref.Student");
        System.out.println(c1);

        //一个类在内存中只有一个Class对象
        //一个类被加载后，类的整个结构都会被封装在Class对象中
        Class c2 = Class.forName("com.man.ref.Student");
        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
    }
}

//实体类 pojo entity
class Student{
    private String name;
    private int age;
    private int id;

    public Student() {
    }

    public Student(String name, int age, int id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                '}';
    }
}

Class类

一个类只有一个Class对象，相当于一面镜子，是反射机制的关键

正常方式：

引入需要的“包装”名称—>通过new实例化—>取得实例化对象

反射方法：

实例化对象—>getClass()方法—>得到完整的“包装”名称

Class类的常用方法

• static Class forName(String name) 返回指定类名name的Class对象
• Object newInstance() 调用缺省构造函数，返回Class对象的一个实例
• getName() 返回此Class对象所表示的实体的名称
• Class getSuperClass()
• Class[] getInterfaces()
• ClassLoader getClassLoader()
• Constructor[] getConstructors()
• Method getMethod(String name,Class…T)
• Field[] getDeclaredFields()

获得Class类

1. 已知具体类，获得该类的Class

Class c1 = Person.class;

2. 已知类的实例，通过getClass()方法

Class c1 = person.getClass();

3. 已知类的全名，且该类在类路径下

Class c1 = Class.forName("com.man.ref.User");

4. 内置基本数据类型可直接使用类名.Type
5. 还可以利用ClassLoader

package com.man.ref;

//测试获得Class的方式有哪些
public class Demo02 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new User();
        System.out.println("这个人是"+person.name);

        //方式一：通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1.hashCode());

        //方式二：forName获得
        Class c2 = Class.forName("com.man.ref.User");
        System.out.println(c2.hashCode());

        //方式三：通过类名获得
        Class c3 = User.class;
        System.out.println(c3);

        //方式四：通过基本内置类的包装类的Type属性（比较特殊），只有内置类才有
        Class c4 = Integer.TYPE;
        System.out.println(c4);

        //获得父类的Class
        Class c5 = c1.getSuperclass();
        System.out.println(c5);
    }
}

class Person{
    public String name;

    public Person(String name) {
        this.name = name;
    }

    public Person() {
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

class User extends Person{
    public User() {
        this.name = "用户";
    }
}

class Provider extends Person{
    public Provider() {
        this.name = "厂商";
    }
}

哪些类型可以有Class对象

• class：外部类、内部类
• interface：接口
• 数组
• enum：枚举
• annotation：注解
• primitive type：基本类型
• void

package com.man.ref;

import java.lang.annotation.ElementType;

//哪些类型可以有Class对象
public class Demo03 {
    public static void main(String[] args) {
        Class c1 = Object.class; //类
        Class c2 = Comparable.class; //接口
        Class c3 = String[].class; //一维数组
        Class c4 = int[][].class; //二维数组
        Class c5 = Override.class; //注解
        Class c6 = ElementType.class; //枚举类型
        Class c7 = Integer.class; //基本类型
        Class c8 = void.class;  //void
        Class c9 = Class.class; //Class

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);

        //只要元素类型与维度一样就是一个Class
        int[] a = new int[10];
        int[] b = new int[100];

        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());
    }
}

类加载内存分析

Java内存分析

堆：存放new的对象、数组，可被所有线程共享

栈：存放基本变量（包含具体数值），引用对象的变量（存放该引用在堆里的具体地址）

方法区：可以被所有线程共享，包含所有的class和static变量

类的加载过程

加载—>链接—>初始化

加载：将class加载到内存，静态数据加载方法区的运行时的数据结构

初始化：执行()方法

什么时候发生类初始化

类的主动引用：

• 当虚拟机启动，初始化main类

• new

• 调用静态成员（除final）和静态方法

• 反射调用类

• 初始化父类

类的被动引用（不会发生类的初始化）

• 通过子类引用父类的static对象，不会使子类初始化
• 通过数组定义类引用，不会使本类初始化
• 引用常量，不会使本类初始化

package com.man.ref;

//类加载内存分析
public class Demo04 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.m);

        /*
        1.加载到内存， 会生成一个对应类的Class对象
        2.链接， 链接结束后 m = 0
        3.初始化
                <clinit()>{
                        System.out.println("A类静态代码初始化");
                        m = 100;
                        m = 300;
                   }
                   最终 m = 300
         */
    }
}

class A{
    static {
        System.out.println("A类静态代码初始化");
        m = 100;
    }

    static int m =300;

    public A(){
        System.out.println("A类的无参构造方法");
    }
}

package com.man.ref;

//测试类什么时候会初始化
public class Demo05 {
    public static void main(String[] args) throws ClassNotFoundException {
        System.out.println("Main类被加载");

        //1.主动引用
//        Son son = new Son();

        //2.反射也会主动引用
//        Class.forName("com.man.ref.Son");

        //不会产生类的引用的方法
//        System.out.println(Son.b);//不会对子类产生任何影响

        //2.
//        Son[] array = new Son[5];//通过数组定义类的引用，不会触发此类的初始化

        //3.
        System.out.println(Son.M);//引用常量不会触发此类的初始化，常量在链接阶段就存入调用类的常量池中了
    }
}

class Father{

    static int b = 2;

    static {
        System.out.println("父类被加载");
    }

}

class Son extends Father{

    static {
        System.out.println("子类被加载");
    }

    static int m = 100;
    static final int M = 1;

}

类加载器

作用

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.class对象，作为方法区中类数据的访问入口。（把类（class）装载进内存的）

加载器类别：

• Bootstap ClassLoader 引导类加载器

• Extension ClassLoader 扩展类加载器

• System ClassLoader 系统类加载器

• 自定义类加载器

自底向上检查类是否已装载

自顶向下尝试加载类

package com.man.ref;

//类加载器
public class Demo06 {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);

        //获取系统类的加载器的父类加载器----扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);

        //获取扩展类加载器的父类加载器----根加载器(C/C++写的，不会显示出来null)
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

        //测试当前类是哪个类加载器加载的
        ClassLoader classLoader = Class.forName("com.man.ref.Demo06").getClassLoader();
        System.out.println(classLoader);

        //测试JDK内置类是谁加载的
        ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader1);

        //如何获得系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));

        //双亲委派机制
        // 不要定义和已有的类同名的类


        /*
        D:\jdk1.8\jre\lib\charsets.jar;
        D:\jdk1.8\jre\lib\deploy.jar;
        D:\jdk1.8\jre\lib\ext\access-bridge-64.jar;
        D:\jdk1.8\jre\lib\ext\cldrdata.jar;
        D:\jdk1.8\jre\lib\ext\dnsns.jar;
        D:\jdk1.8\jre\lib\ext\jaccess.jar;
        D:\jdk1.8\jre\lib\ext\jfxrt.jar;
        D:\jdk1.8\jre\lib\ext\localedata.jar;
        D:\jdk1.8\jre\lib\ext\nashorn.jar;
        D:\jdk1.8\jre\lib\ext\sunec.jar;
        D:\jdk1.8\jre\lib\ext\sunjce_provider.jar;
        D:\jdk1.8\jre\lib\ext\sunmscapi.jar;
        D:\jdk1.8\jre\lib\ext\sunpkcs11.jar;
        D:\jdk1.8\jre\lib\ext\zipfs.jar;
        D:\jdk1.8\jre\lib\javaws.jar;
        D:\jdk1.8\jre\lib\jce.jar;
        D:\jdk1.8\jre\lib\jfr.jar;
        D:\jdk1.8\jre\lib\jfxswt.jar;
        D:\jdk1.8\jre\lib\jsse.jar;
        D:\jdk1.8\jre\lib\management-agent.jar;
        D:\jdk1.8\jre\lib\plugin.jar;
        D:\jdk1.8\jre\lib\resources.jar;
        D:\jdk1.8\jre\lib\rt.jar;
        D:\JavaCode\reflection\out\production\reflection;
        D:\idea_ultimate\IntelliJ IDEA 2021.1.1\lib\idea_rt.jar
         */
    }
}

获取类的运行时结构

通过反射获取类运行时的完整结构

package com.man.ref;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

//获得类的信息
public class Demo07 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("com.man.ref.Student");

        //1.获得类的名字
        System.out.println(c1.getName());//具体类名 包名+类名
        System.out.println(c1.getSimpleName());//获得简单名字

        //2.获得类的属性
        Field[] fields = c1.getFields();//获得public属性
        for (Field field : fields) {
            System.out.println(field);
        }

        System.out.println("=====================");
        fields = c1.getDeclaredFields();//获得全部属性，包括私有的
        for (Field field : fields) {
            System.out.println(field);
        }

        //3.获得指定属性的值
        Field name = c1.getDeclaredField("name");
        System.out.println(name);

        System.out.println("=====================");

        //4.获得类的方法
        Method[] methods = c1.getMethods();//获得本类及其父类的全部public方法
        for (Method method : methods) {
            System.out.println(method);
        }

        System.out.println("=====================");
        methods = c1.getDeclaredMethods();//获得本类的所有方法
        for (Method method : methods) {
            System.out.println(method);
        }

        //5.获得指定方法 需要第二个参数的原因：Java中有方法重载，根据类型判断是哪个方法
        Method getName = c1.getMethod("getName", null);
        Method setName = c1.getMethod("setName", String.class);
        System.out.println(getName);
        System.out.println(setName);

        System.out.println("======================");
        //6.获得构造器
        Constructor[] constructors = c1.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        System.out.println("******************");

        constructors = c1.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        //获得指定的构造器
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        System.out.println("指定:"+declaredConstructor);

    }
}

动态创建对象

方法一（必须有无参构造器）：

调用Class对象的newInstance()方法

方法二（可以没有无参构造器）：

1. 通过Class类的getDeclaredConstructor(…)取得本类的指定形参类型的构造器
2. 向构造器的形参中传递一个对象数组
3. 通过Constructor实例化对象

package com.man.ref;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

//通过反射动态创建对象
public class Demo08 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //获得Class对象
        Class c1 = Class.forName("com.man.ref.Student");

        //构造一个对象
        Student student =(Student)c1.newInstance();//本质是调用了 无参构造器
        System.out.println(student);

        //没有无参构造器时可 通过构造器创建对象
        Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        Student s =(Student)constructor.newInstance("alice", 18, 101);
        System.out.println(s);

        //通过反射调用普通方法
        Student student1 = (Student) c1.newInstance();
        //通过反射获得一个方法
        Method method = c1.getDeclaredMethod("setName", String.class);

        //激活方法
        method.invoke(student1,"alice");
        System.out.println(student1.getName());

        //通过反射操作属性
        Student student2 = (Student) c1.newInstance();
        Field name = c1.getDeclaredField("name");

        //取消安全检测   可以操作私有属性  如果没有取消安全检测则不能操作私有属性
        name.setAccessible(true);

        name.set(student2,"jack");
        System.out.println(student2.getName());
    }
}

package com.man.ref;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

//分析性能问题
public class Test01 {
    public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
        test01();
        test02();
        test03();
    }

    //普通方法调用
    public static void test01(){
        Student student = new Student();

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 100000000; i++) {
            student.getName();
        }

        long endTime = System.currentTimeMillis();

        System.out.println("普通方法的时间："+(endTime - startTime));
    }

    //通过反射调用
    public static void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Student student = new Student();
        Class c1 = student.getClass();

        //获得方法
        Method getName = c1.getDeclaredMethod("getName", null);

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 100000000; i++) {
            getName.invoke(student,null);
        }

        long endTime = System.currentTimeMillis();

        System.out.println("反射方法的时间："+(endTime - startTime));
    }

    //通过反射调用  关闭检测
    public static void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Student student = new Student();
        Class c1 = student.getClass();

        //获得方法
        Method getName = c1.getDeclaredMethod("getName", null);
        //关闭检测
        getName.setAccessible(true);

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 100000000; i++) {
            getName.invoke(student,null);
        }

        long endTime = System.currentTimeMillis();

        System.out.println("反射方法关闭检测的时间："+(endTime - startTime));
    }
}

通过反射调用指定方法

1. 通过Class类的getMethod(…)获得Method对象
2. 用Object invoke(…)调用

获取泛型

ParameterizedType：一种参数化类型

GenericArrayType：一种元素类型是参数化类型或类型变量的数组类型

TypeVariable：各种类型变量的公共接口

WildcardType：一种通配符类型表达式

package com.man.ref;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

//通过反射操作泛型
public class Test02 {
    public void test01(Map<String,Student> map, List<Student> list){
        System.out.println("test01");
    }

    public Map<String,Student> test02(){
        System.out.println("test02");
        return null;
    }

    public static void main(String[] args) throws Exception{
        Method test01 = Test02.class.getMethod("test01", Map.class, List.class);

        Type[] genericParameterTypes = test01.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println(genericParameterType);
            System.out.println("====================");
            if (genericParameterType instanceof ParameterizedType) {
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }
            }
        }

        System.out.println("**********************");

        Method test02 = Test02.class.getMethod("test02");
        Type genericReturnType = test02.getGenericReturnType();
        if (genericReturnType instanceof ParameterizedType) {
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }

    }
}

获取注解信息

getAnnotations()

package com.man.ref;

import java.lang.annotation.*;
import java.lang.reflect.Field;

//练习反射操作数据
public class Test03 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {

        Class c1 = Class.forName("com.man.ref.Student1");

        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

        //获得注解的value值
        TableMan tableMan = (TableMan)c1.getAnnotation(TableMan.class);
        String value = tableMan.value();
        System.out.println(value);

        //获得类指定的注解
        Field name = c1.getDeclaredField("name");
        FieldMan annotation = name.getAnnotation(FieldMan.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());
    }
}

//实体类
@TableMan("db_Student")
class Student1{

    @FieldMan(columnName = "db_name",type = "varchar",length = 3)
    private String name;

    @FieldMan(columnName = "db_age",type = "int",length = 10)
    private int age;

    @FieldMan(columnName = "db_id",type = "int",length = 10)
    private int id;

    public Student1() {
    }

    public Student1(String name, int age, int id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "Student1{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                '}';
    }
}

//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableMan{
    String value();
}

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldMan{
    String columnName();
    String type();
    int length();
}