Java注解和反射

注解和反射

注解

Java.Annotation

Annotation作用：

• 对程序做出解释
• 可以被其他程序（比如编译器）读取

Annotation格式：

​ @注释名；还可以添加一些参数，如：@SuppressWarnings(value=“unchecked”)

Annotation在哪里作用：

​ package、class、method等

内置注解

@Override 重写

@Deprecated 不推荐

@SuppressWarnings() 镇压警告,@SuppressWarnings(“all”)

元注解

解释其他注解 的注解

4个标准的meta-annotation类型

• @Tagret：描述注释的使用范围（类、方法。。。）
• @Retention：表示需要再说明级别保存该注释信息，用于描述注解的生命周期
  • SOURCE（源码时） < CLASS < RUNTIME（一般是这个）
• @Document：说明该注解，将被包含在javadoc中
• @Inherited：说明子类可以继承父类中的该注解

通过反射机制，实现对这些注解的访问

// 测试元注解
@MyAnnotation
public class TestAnnotation {
    @MyAnnotation
    public void test() {

    }
}

// 表示我们的注解可以放在哪些地方
@Target(value = {ElementType.METHOD,ElementType.TYPE})
// 表示我们的注解在什么地方还有效
// runtime > class > sources
@Retention(value = RetentionPolicy.RUNTIME)
// 表示是否将我们的注解生成在Javadoc中
@Documented
// 表示子类可以继承父类的注解
@Inherited
// 定义一个注解
@interface MyAnnotation{

}

自定义注解

使用 @interface 自定义注解

格式：public @interface 注解名 {定义内容}

配置参数：方法实际上是，声明了一个配置参数

​ 方法的名称：参数的名称

​ 返回值类型：参数的类型（只能是基本类型，或Class,String,enum）

​ default：来声明参数的默认值

​ 如果只有一个参数成员，一般参数名为value（如果只有一个参数，且参数名为value，可省略）

​ 且必须要有值，default设置默认值（0，空字符串）

// 自定义注解
public class Test02 {
    // 注解可以显式赋值，如果没有默认值，我们就必须给注解参数赋值
    @MyAnnotation2(age = 18)
    public void test() {
    }

    // 如果只有一个参数，且参数名为value，可省略
    @MyAnnotation3("ff")
    public void test2(){}
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2 {
    // 注解的参数 格式：参数类型+参数名（）；
    String name() default "";// default设置默认值
    int age() ;
    int id() default -1;// 如果默认值为-1 ，代表不存在

    String[] schools() default {"LCU","UCLA"};
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
    
    String value();
}

反射

Java.Reflection

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

静态语言：运行时不可改变结构

通过反射可以使java具有一定的动态性，反射机制允许程序在执行期间借助Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

反射：加载完类之后，堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了这个类的完整结构信息，我们可以通过这个对象看到类的结构。

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

反射方式：实例化对象——》getClass()方法——》得到完整的“包类”名称

优点：可以动态的创建的创建对象和编译，灵活性高

缺点：对性能有影响。反射基本上是一种解释操作，我们告诉JVM，我们想要做什么，并且它满足我们的要求。所以这类操作总是慢于 直接执行相同的操作。

Class类

Class getClass() 返回Class类。（通过对象反射求出类的名称）

方法	描述
static Class forName(String name)	返回指定类名name的Class对象
Object newInstance()	调用缺省构造函数，返回Class对象的一个实例
getName()	返回此Class对象所表示的实体（类、接口、数组或void）的名称
Class getSuperClass()	返回 当前Class对象的父类的Class对象
Class[] getinterfaces()	获取当前Class对象的接口
ClassLoader getClassLoader()	返回该类的类加载器
Constructor[] getConstrucotors()	返回一个包含某些Constructor对象的数组
Method getMothed(String name,Class…T)	返回一个Method对象，此对象的形参类型为paramType
Field[] getDeclaredFields()	返回Field对象的一个数组

获取Class类的实例

Person person = new Student();
// 方式一：通过对象获得
Class c1 = person.getClass();
System.out.println(c1.hashCode());
// 方式二：forname获取
Class c2 = Class.forName("com.company.reflection.Student");
System.out.println(c2.hashCode());
// 方式三：通过类名.class获取
Class c3 = Student.class;
System.out.println(c3.hashCode());
// 方式四：基本内置类型的包装类都有一个Type属性
Class c4 = Integer.TYPE;
System.out.println(c4);

// 获取父类Class对象
Class c5 = c1.getSuperclass();
System.out.println(c5);

哪些类型可以有Class对象

• class :外部类，成员（成员内部类、静态内部类）、局部内部类、匿名内部类
• interface：接口
• [] ：数组
• enum：枚举
• annotation：注解@interface
• primitive type：基本数据类型
• void

// 所有类型的class
public class TestClass {
    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

        // 只要元素类型与维度一样，就是同一个Class
        int[] a = new int[10];
        int[] b = new int[1000];
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());
    }
}

类的加载

加载：将class文件字节码内容加载到内存中，并将这些静态数据转换称方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象

链接：将类的二进制数据合并到 JRE 中

• 验证：符合JVM规范，安全问题
• 准备：类变量（static）分配内存，设置初始值（方法区）
• 解析：引用类型的引用替换为真实类型引用

初始化：执行类构造器()方法。类构造器()方法是编译期将类中所有类变量赋值动作和静态代码块中的语句合并而产生的。

若父类还没有初始化，需先初始化父类

()方法是线程安全的

public class Test01 {
    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("静态代码块初始化");
            m = 300;
            m =100;
            }
            m =100;
        */
    }
}

class A{
    static {
        System.out.println("静态代码块初始化");
        m = 300;
    }
    static int m =100;
    public A(){
        System.out.println("A类的无参构造初始化");
    }
}

什么时候发生类初始化

• 类的主动引用（一定会发生类的初始化）
  • main方法
  • new一个类的对象
  • 调用类的静态成员和静态方法
  • 进行反射调用
  • 初始化一个类，需先初始化父类
• 类的被动引用（不会发送类的初始化）
  • 访问一个静态域；如：通过子类引用父类的静态变量，不会导致子类初始化
  • 通过数组定义类引用
  • 引用常量（常量在链接阶段就存入调用类的常量池中了）

// 测试类什么时候会初始化
public class Test06 {
    static {
        System.out.println("main类被加载");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        // 1.主动引用
        //Son son = new Son();
        // 反射也会产生主动引用
        //Class.forName("com.company.reflection.Son");

        // 不会产生类的初始化的方法
        //System.out.println(Son.b);

        //Son[] as = new Son[4];

        System.out.println(Son.N);

    }
}
class Father{
    static int b = 2;
    static {
        System.out.println("父类被加载");
    }
}
class Son extends Father{
    static {
        System.out.println("子类被加载");
        m = 300;
    }
    static int m = 100;
    static final int N = 1;
}

类加载器

作用：将class文件字节码内容加载到内存中，将这些静态数据转换为方法区的运行时数据结构，然后在堆中生成一个代表这个类的Class对象，作为方法区中类数据的访问入口

类缓存：某个类被加载到类加载器中，会维持加载（缓存）一段时间。gc可以回收。

Bootstrap Classloader

​ 引导类加载器，c/c++；负责java平台核心库，该类加载器无法直接获取。它并不是 java.lang.ClassLoader 的子类，而是由 JVM 自身实现的。

Extension Classloader

​ 扩展类加载器，负责加载jre/lib/ext目录下的jar包

System Classloader

​ 系统类加载器，负责加载classpath目录下的类和jar包；他们的父类是ClassLoader

package com.company.reflection;

public class Test07 {
    public static void main(String[] args) throws ClassNotFoundException {
        // 获取系统类加载器
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
        System.out.println(classLoader);
        // 获取系统类加载器的父类加载器--》扩展类加载器
        ClassLoader parent = classLoader.getParent();
        System.out.println(parent);
        // 获取扩展类加载器的父类加载器--》根加载器（c/c++)
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

        // 测试当前类是哪个加载器加载的
        ClassLoader classLoader1 = Class.forName("com.company.reflection.Test07").getClassLoader();
        System.out.println(classLoader1);
        // 测试JDK内部的类是谁加载的
        classLoader1 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader1);

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

        // 双亲委派机制：自定义类，不会覆盖rt等包中的类

        /**
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\charsets.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\deploy.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\access-bridge-64.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\cldrdata.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\dnsns.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\jaccess.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\jfxrt.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\localedata.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\nashorn.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunec.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunjce_provider.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunmscapi.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunpkcs11.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\zipfs.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\javaws.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\jce.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\jfr.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\jfxswt.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\jsse.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\management-agent.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\plugin.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\resources.jar;
         * C:\Program Files\Java\jdk1.8.0_181\jre\lib\rt.jar;
         * D:\IdeaProjects\DEMO01\out\production\DEMO01;
         * D:\Program Files\JetBrains\IntelliJ IDEA 2020.2.2\lib\idea_rt.jar
         */
    }

}

获取运行时类的完整结构

package com.company.reflection;

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

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

        //User user = new User();
        //c1 = user.getClass();

        // 获得类的名字
        System.out.println(c1.getName());// 包名+类名
        System.out.println(c1.getSimpleName());// 类名

        // 获得类的属性
        Field[] fields = c1.getFields(); // 只能找到public属性

        fields = c1.getDeclaredFields(); // 找到全部的属性
        for (Field field : fields) {
            System.out.println(field);
        }
        // 获得指定属性的值
        Field name = c1.getDeclaredField("name");
        System.out.println(name);

        // 获得类的方法
        // 获得本类及其父类的全部public的方法
        Method[] methods = c1.getMethods();
        for (Method method : methods) {
            System.out.println("public----"+method);
        }
        // 获得本类的所有方法
        methods = c1.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println("all----"+method);
        }
        // 获得指定方法
        // 重载，所以需要参数
        Method getName = c1.getMethod("getName", null);
        Method setName = c1.getMethod("setName", String.class);
        System.out.println(getName);
        System.out.println(setName);
        System.out.println("===========");
        // 获得指定的构造器
        // public方法
        Constructor[] constructors = c1.getConstructors();
        for (Constructor constructor1 : constructors) {
            System.out.println(constructor1);
        }
        // 全部
        Constructor[] declaredConstructors = c1.getDeclaredConstructors();
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }
        // 获得指定的构造器
        Constructor constructor = c1.getDeclaredConstructor(String.class, int.class);
        System.out.println(constructor);

    }
}

动态创建对象

有了Class对象后，调用Class对象的newInstance()方法

• 类必须有无参构造器

• 有权限访问无参构造器

  // invoke：激活
  // （对象，”方法的值“）
  setName.invoke(user3,“javaKing”);

// 通过反射，动态的创建对象
public class Test09 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        // 获得class对象
        Class c1 = Class.forName("com.company.reflection.User");
        // 构造一个对象
        //User user = (User)c1.newInstance();// 本质上是调用了无参构造器
        //System.out.println(user);

        // 通过构造器创建对象
        //Constructor constructor = c1.getDeclaredConstructor(String.class, int.class);
        //User user2 = (User)constructor.newInstance("名字",001);
        //System.out.println(user2);

        // 通过反射调用普通方法
        User user3 = (User)c1.newInstance();
        // 通过反射获取一个方法,根据名字，参数类型
        Method setName = c1.getDeclaredMethod("setName", String.class);
        // invoke：激活
        // （对象，”方法的值“）
        setName.invoke(user3,"javaKing");
        System.out.println(user3.getName());

        // 通过反射操作属性
        User user4 = (User)c1.newInstance();
        Field name = c1.getDeclaredField("name");
        // 不能直接操作私有属性，我们需要关闭程序的安全检测:属性或方法的setAccessible(true)
        name.setAccessible(true); //关闭方法安全检查的开关
        name.set(user4,"javaKing2");
        System.out.println(user4.getName());
    }
}

性能分析

// 分析性能问题
public class Test10 {
    // 普通方式调用
    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("普通方式执行十亿次："+(endTime-startTime)+"ms");

    }
    // 反射方式调用
    public static void test02() throws Exception {
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName", null);

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(user,null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射方式执行十亿次："+(endTime-startTime)+"ms");

    }
    // 反射方式调用 关闭检测
    public static void test03() throws Exception {
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName", null);
        getName.setAccessible(true);

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(user,null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射方式，关闭检测执行十亿次："+(endTime-startTime)+"ms");
    }

    public static void main(String[] args) throws Exception {
        test01();
        test02();
        test03();
    }
}

获取泛型信息

ParameterizedType：表示一种参数化类型，

// 通过反射获取泛型
public class Test11 {
    public void test01(Map<String,User> map, List<User> list) {
        System.out.println("test01");
    }

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

    public static void main(String[] args) throws NoSuchMethodException {
        Method method = Test11.class.getMethod("test01", Map.class, List.class);
        // 获得泛型的参数类型
        Type[] types = method.getGenericParameterTypes();
        for (Type type : types) {
            System.out.println("----"+type);
            // 如果属于参数化类型
            if (type instanceof ParameterizedType){
                // 强转成参数化类型，获得真实参数信息
                Type[] typeArguments = ((ParameterizedType) type).getActualTypeArguments();
                for (Type typeArgument : typeArguments) {
                    System.out.println(typeArgument);
                }
            }
        }
        Method method2 = Test11.class.getMethod("test02", null);
        // 获得返回值的泛型
        Type type2 = method2.getGenericReturnType();
            System.out.println("----"+type2);
            // 如果属于参数化类型
            if (type2 instanceof ParameterizedType){
                // 强转成参数化类型，获得真实参数信息
                Type[] typeArguments = ((ParameterizedType) type2).getActualTypeArguments();
                for (Type typeArgument : typeArguments) {
                    System.out.println(typeArgument);
                }
        }

反射操作注解

ORM

Object relationship Mapping --> 对象关系映射

• 类和表结构对应
• 属性和字段对应
• 对象和表数据对应

getAnnotations

getAnnotation

// 反射操作注解
public class Test12 {
    public static void main(String[] args) throws Exception {
        Class c1 = Class.forName("com.company.reflection.Student2");

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

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

        // 获得类指定的注解,获取类中的属性
        java.lang.reflect.Field name = c1.getDeclaredField("name");
        Field annotation = name.getAnnotation(Field.class);
        System.out.println(annotation.columnName());
        System.out.println(annotation.length());
        System.out.println(annotation.type());
    }
}
// 模拟表
@Table("db_student")
class Student2 {
    @Field(columnName = "db_id",type = "int",length = 10)
    private int id;
    @Field(columnName = "db_age",type = "int",length = 10)
    private int age;
    @Field(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;
    }

    @Override
    public String toString() {
        return "Student2{" +
                "id=" + id +
                ", age=" + age +
                ", 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;
    }
}

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

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