Java poi 删除将文档中所有标注删除掉

转载

数据侠客行 2024-12-21 19:07:38

文章标签 java 反射 System Java 文章分类 Java 后端开发

Java_注解和反射

Java当中的注解与反射，这一部分知识，个人感觉还是比较重要的。因为在之后要学习的SSM（Spring、SpringMVC、Mybatis）框架当中会经常的用到这一部分知识（尤其是注解，Mybatis中不太明显），建议大家好好学习一下。
此外，由于博主水平有限，所以能写出的文章的质量可能不高，请大家酌情观看。如果大家在阅读博客的时候发现有什么错误，或者是有更好的解决方案，欢迎大家在评论区里留言。

一、注解（Annotation）

1.1 基本概念

注解是从JDK5.0之后引进的一门技术
作用：

不是程序本身，可以对程序作出解释
可以被其他程序（比如：编译器）读取

格式：

@注解名（参数值）
举例：@SuppressWarning(value =“unchecked”)

使用位置：

附加在package、class、method、field等上面，相当于添加了额外的辅助信息，可以通过反射机制编程对这些元数据进行访问

1.2 内置注解

@override : java.lang.Override之中，只适用于修辞方法，表示打算重写某个方法

@Deprecated：java.lang.Deprecated之中，适用于修辞方法、属性、类，表示不鼓励程序员使用这些元素，通常是因为其危险或者有更好的选择

@SuppressWarnings ： java.lang.SuppressWarnings之中，用来抑制编译时的警告信息，这个是有参数的

package annotation.demo1;

import java.util.ArrayList;
import java.util.List;

public class Test01 {
    @SuppressWarnings("all")    // 镇压警告的注解
    public static void main(String[] args){
        List list = new ArrayList();
    }
}

1.3 元注解

作用：负责解释其他的注解，Java定义了4个标准的meta-annotation类型，他们被用来提供对其他的注解进行说明
这些类型都在java.lang.annotaton中找到
分别是：

@Target: 用于描述注解使用的范围
@Retention:表示需要在什么级别保存该注释信息，用于描述注解的生命周期

（SOURCE < CLASS < RUNTIME），一般是RUNTIME

@Document: 说明该注解将被包含在javadoc当中
@Inherited: 说明子类可以继承父类中的该注解

package annotation.demo1;

import java.lang.annotation.*;

// 测试元注解
public class Test02 {

  @MyAnnotation
    public void Test(String str){

    }

}

// 自定义注解
@Target(value = {ElementType.METHOD,ElementType.TYPE})
@Retention(value = RetentionPolicy.RUNTIME)         // 表示在那个级别还有效

@Documented
@Inherited
@interface MyAnnotation{

}

1.4 自定义注解

使用@interface进行注解，表示自动继承了java.lang.annotation.Annotation接口
分析：

@interface用来声明一个注解，格式：public @interface 注解名{定义内容}
其中的每一个方法实际上是声明了一个配置参数
方法的名称就是参数的名称
返回值类型就是参数的类型（只能是基本类型或者String\class\enum）
可以通过default来声明参数的默认值
如果只有一个参数成员，一般的参数名称为value
注解元素必须要有值，我们自定义注解元素时，经常使用空字符串，作为默认值

package annotation.demo1;

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

// 自定义注解
public class Test03 {

    // 如果注解里有参数，那么一定要有值，否则报错
    // 或者在注解当中添加一个默认值default
    @MyAnnotation2(name = "" , schools = "Hua")
    public void test03(){
        
    }
    
}

// 下面是注解
@Target(value = {ElementType.TYPE,ElementType.METHOD})
@Retention(value = RetentionPolicy.RUNTIME)
@interface MyAnnotation2{

    // 注解的参数 ： 参数类型 + 参数名称
    String name()  ;
    String name2 () default "" ;
    int age () default 0 ;
    int id() default -1 ;  // 如果默认值是-1 ， 表示不存在
    
    String[] schools();
 
}

// 如果注解当中只有一个值，建议用value命名，因为可以在调用的时候不写参数名称
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
    String value();
}

二、反射（Refection）

动态语言

是一类在运行时可以改变其结构的语言

例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或者是其他结构上的变化。通俗来讲就是代码在运行的时候可以根据某些条件改变自身结构

主要动态语言：Object-C、C#、JavaScript、PHP、Python等

静态语言

与动态语言相对，运行时结构不可以改变的语言。如Java 、C、C++
Java不是动态语言，但Java可以说是准动态语言。即Java有一定的动态性，我们可以利用反射机制获得类似于动态语言的特性。Java的动态性让编程的时候更加灵活！

2.1 反射概述

反射是Java被视为动态语言的关键，反射机制允许程序在执行时借助于Reflection API取得任何内部类的相关信息，并能直接操作任意对象的内部属性及其方法。
格式：Class c = new Class.forName(“java.lang.String”)
加载完类之后，在堆内存的方法区之中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息（包括类名、方法、成员变量等，特别地，private修饰的成员也能够直接访问，甚至可以操纵）。这个对象就像是一面镜子，透过这个镜子看到类的结构，所以，我们称这种方法为反射。

正常方式：引入包类 —> 通过new进行实例化 —> 取得实例化对象

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

2.2 反射机制

Java反射机制提供的功能

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和成员方法
在运行时获取泛型信息
在运行时调用任意一个对象的成员变量和成员方法
在运行时处理注解
生成动态代理
…

反射机制的优缺点：

优点：可以实现动态创建对象和编译，体现出相当大的灵活性
缺点：对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望它做什么并且它能够满足我们的要求。这类操作总是慢于直接执行相同的操作（基于这个原因，在没有什么特殊情况时，不得使用反射）

反射的API：

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

package refection ;

import java.util.Objects;

// 反射
public class Test {
    @SuppressWarnings("all")
    public static void main(String[] args) throws ClassNotFoundException {

        // 创建对象，实际上时需要泛型的，但是没有，用不到，直接去掉。  看着难受就强行镇压黄色的提示
      Class c1 = Class.forName("refection.User");


      // 一个类在内存中只有一个Class对象，可以进行验证
        // 验证的方式：多次获取，看哈希码是否相同
        // 一个类被加载之后，类的整个结构都会被封装在Class对象中
        Class c2 = Class.forName("refection.User");
        Class c3 = Class.forName("refection.User");
        Class c4 = Class.forName("refection.User");

        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        System.out.println(c4.hashCode());

    }

}


// 实体类：pojo、entity类
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 +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return id == user.id &&
                age == user.age &&
                Objects.equals(name, user.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, id, age);
    }
}

2.3 获得class对象的几种方式

获取class对象的方式一共有三种:

方式一：通过对象获得
方式二：通过反射forName获得
方式三：通过类名.class获得
方式四：通过内置的基本数据类型的包装类
方式五：通过ClassLoader(后面讲解)

package refection ;

import java.util.Objects;

public class Test02 {
    @SuppressWarnings("all")
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("这个人是" + person.name);

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

       //  - 方式二：通过反射forName获得
        Class c2 = Class.forName("refection.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);
        System.out.println(c4.hashCode());


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

    }
}


class Person {
    public String name ;

    public Person (){
    }

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

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
}

class Student extends Person{
    public Student(){
        this.name = "学生" ;
    }
}

class Teacher extends Person{
    public Teacher(){
        this.name = "教师" ;
    }

}

2.4 所有类型的class对象

哪些类型可以有Class对象？

1、class：外部类、成员（成员内部类、静态内部类），局部内部类、匿名内部类
2、interface : 接口
3、[ ] ：数组
4、enum ：枚举
5、annotation : 注解@interface
6、primitive type : 基本数据类型
7、void 方法

package refection;

import java.lang.annotation.ElementType;

// 所有类型的Class
@SuppressWarnings("all")
public class Test03 {
    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 ;
        Class c9 = 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);

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

        // 一个类只有一个Class对象
        // 只要元素类型和维度一样，那么两个数组就是一个对象
        // 需求：验证上一行的文字的真实性
        int []a = new int [20] ;
        int []b = new int [200] ;
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());

    }

}

2.5 类的加载与ClassLoader的理解

加载：将class文件字节码内容加载到内存中，并将这些静态数据转化成方法区的运行时数据结构，然后生成一个java.lang.Class对象
链接：将Java类的二进制代码合并到JVM的运行状态之中的过程。

验证：确保加载的类符合JVM规范，没有安全方面的问题
准备：正式为变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行合并
解析: 虚拟机常量池内的符号引用（常量名）替换为引用（地址）的过程

初始化：

执行类构造器() 方法的过程。类构造器()方法是由编译器自动收集类中所有变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造信息的，不是构造该类对象的构造器）
当初始化一个类的时候，如果发现其父类还没初始化，则需要先触发其父类的初始化。
虚拟机会保证一个类的方法在多线程环境中被正确加锁和同步。

package refection;

public class Test04 {
    @SuppressWarnings("all")
    public static void main(String[] args){
        A a = new A();
        System.out.println(A.M);
        System.out.println(a.M);
    }
}

class A{

    static {
        System.out.println("A类被加载");
    }
    static final int M = 100 ;
}

2.6 类的初始化

类的主动引用（一定会发生类的初始化）

当虚拟机启动，先初始化main方法所在的类
new一个新的类的对象
调用类的静态成员（除了final常量）和静态方法
使用java.lang.reflect包的方法对类进行反射调用
当初始化一个类，如果其父类没有被初始化，则会先初始化它的父类

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

当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化
通过数组定义类引用，不会触发此类的初始化
引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池之中了）

package refection;

public class Test05 {

    static {
        System.out.println("Main方法被加载");
    }

// 测试类什么时候会被初始化
    public static void main(String[] args) throws ClassNotFoundException {
        // 1、主动引用
    //    Son son = new Son();
//        Main方法被加载
//                父类被加载
//        子类被加载

        // 反射也会产生主动引用
     //   Class c1 = Class.forName("refection.Son");
//        Main方法被加载
//                父类被加载
//        子类被加载


        // 不会产生类的引用的方法
//        System.out.println(Son.b);
        //Main方法被加载
        //父类被加载


        // Son []array = new Son[5] ;
        //Main方法被加载

        System.out.println(Son.M);
//        Main方法被加载
//        1

    }

}

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 ;
}

2.7 类加载器

类加载的作用：将class文件字节码内容加载到内存当中，并将这些静态数据转换成方法区的运行数据结构，然后在堆内存当中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
类内存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器当中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象
作用：将类加载到内存当中。JVM定义了以下的类加载器

引导类加载器：C++编写，JVM自带的类加载器，负责Java平台的核心类库。该加载器无法直接获取
扩展类加载器：负责jre/lib/ext目录下的jar包或_D java.ext.dirs 指定目录下的额 jar 包装入工作库
系统类加载器：负责java -classpath或D java.class.path所指目录下的类与jar包装入工作，是最常用的类加载器。

package refection;

public class Test06 {
    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++）
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);                        // 获取不到，返回值位null

        // 获取当前类加载器
        ClassLoader classLoader = Class.forName("refection.Test06").getClassLoader();
        System.out.println(classLoader);            // 当前是系统的类加载器

        // 测试JDK内部的类是谁加载的
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);            // 根路径下的类加载器

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

        /**C:\Program Files\Java\jdk1.8.0_281\jre\lib\charsets.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\deploy.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\ext\access-bridge-64.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\ext\cldrdata.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\ext\dnsns.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\ext\jaccess.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\ext\jfxrt.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\ext\localedata.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\ext\nashorn.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\ext\sunec.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\ext\sunjce_provider.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\ext\sunmscapi.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\ext\sunpkcs11.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\ext\zipfs.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\javaws.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\jce.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\jfr.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\jfxswt.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\jsse.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\management-agent.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\plugin.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\resources.jar;
         * C:\Program Files\Java\jdk1.8.0_281\jre\lib\rt.jar;
         * E:\Project  For Study\Java01\out\production\Java01;
         * D:\Software\For Work\Idea\IntelliJ IDEA2020(64bit)\idea\IntelliJ IDEA 2020.1\lib\idea_rt.jar
         */


    }

}

2.8 获取运行时类的完整结构

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

Field、Method、Constructor、Supperclass、Interface、Annotation
实现的全部接口
所继承的父类
全部的构造器
全部的方法
全部的Field
注解
…

package refection;

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

// 获得类的名称
public class Test07 {
    @SuppressWarnings("all")
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("refection.User");

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

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

        System.out.println("—————————————————————————————————————————————");
        fields = c1.getDeclaredFields();    //找到全部的属性
        for (Field field : fields) {
            System.out.println(field);
        }

        System.out.println("——————————————————————————————————————————————");
        // 获得指定属性的值
        Field name = c1.getDeclaredField("name");     // getDeclaredField 需要输入一个属性字段
        System.out.println(name);


        System.out.println("——————————————————————————————————————————————");
        //获得类的方法
        Method []methods = c1.getMethods();
        for (Method method : methods) {
            System.out.println("正常的:" + method);
        }

        methods = c1.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println("getDeclaredMethods:" + method);
        }

        // 获取指定方法
        Method getName = c1.getMethod("getName",null);
        Method setName = c1.getMethod("setName", String.class);
        System.out.println(getName);
        System.out.println(setName);


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

        Constructor []constructors1 = c1.getDeclaredConstructors();
        for (Constructor constructor : constructors1) {
            System.out.println( "#" + constructor);
        }

        Constructor constructor = c1.getDeclaredConstructor(String.class , int.class , int.class);
        System.out.println("指定：" + constructor);        // 指定全参构造
        constructor = c1.getDeclaredConstructor();
        System.out.println("指定：" + constructor);        // 指定无参构造
    }
}

2.9 动态创建对象执行方法

首先需要创建对象

Class c1 = Class.forName(“位置”) ;

再者运用无参构造或者全参构造创建一个对象

无参：newInstance（）；
全参：获取构造器，填入参数

通过反射调用普通的方法

获取一个方法： invoke(“对象” ,“方法的值”)；
获取属性Field

解决权限不够的问题：关闭安全属性
变量名.setAccessible(true);
传入值：属性名.set();

package refection;

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

// 反射的综合应用
public class Test08 {
    /**
     * - 首先需要创建对象
     *   - Class c1 = Class.forName("位置") ;
     * - 再者运用无参构造或者全参构造创建一个对象
     *   - 无参：newInstance（）；
     *   - 全参：获取构造器，填入参数
     * - 通过反射调用普通的方法
     *   - 获取一个方法： invoke("对象" ,"方法的值")；
     *   - 获取属性Field
     *     - 解决权限不够的问题：关闭安全属性
     *     - 变量名.setAccessible(true);
     *     - 传入值：属性名.set();
     * */

    @SuppressWarnings("all")
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        // 创建对象
        Class c1 = Class.forName("refection.User");

        // 无参构造
        User user = (User)c1.newInstance();
        System.out.println(user);

        // 全参构造
        Constructor constructor = c1.getDeclaredConstructor(String.class , int.class , int.class);
        User user1 = (User)constructor.newInstance("张三" , 1 , 18);
        System.out.println(user1);

        // 通过反射调用方法
        User user2 = (User)c1.newInstance();
        Method setName = c1.getDeclaredMethod("setName", String.class);
        setName.invoke(user2 , "张三2");
        System.out.println(user2.getName());

        // 通过反射操作属性
        User user3 = (User)c1.newInstance();
        Field name = c1.getDeclaredField("name");
        name.setAccessible(true);
        name.set(user3 , "张三3");
        System.out.println(user3.getName());


    }

}

2.10 性能对比分析

package refection;

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

// 性能对比测试
@SuppressWarnings("all")
public class Test09 {
    // 用两种方式调用一个方法10亿次，看看所需要的时间

    // 普通的方式
    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 ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class c1 = Class.forName("refection.User");

        User user = (User)c1.newInstance();
        Method getName = c1.getDeclaredMethod("getName" );

        long startTime = System.currentTimeMillis();

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

        long endTime = System.currentTimeMillis();

        System.out.println("通过反射运行10亿次所需要的时间为：" + (endTime - startTime) + "ms");
    }


    // 关闭检测
    public static void test03() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class c1 = Class.forName("refection.User");

        User user = (User)c1.newInstance();
        Method getName = c1.getDeclaredMethod("getName" );
        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("关闭检测运行10亿次所需要的时间为：" + (endTime - startTime) + "ms");
    }

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        test01();
        test02();
        test03();
    }

    /**普通方式运行10亿次所需要的时间为：4ms
     通过反射运行10亿次所需要的时间为：2258ms
     关闭检测运行10亿次所需要的时间为：1151ms*/
    
}

2.11 获取泛型信息

使用较少

Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性以及免去强制类型转换的问题，但是，一旦编译完成，所有和泛型有关的类型会全部擦除
为了能够通过反射来操作这些类型，Java新加了Parameterized Type ， GenericArray Type，TypeVariable和WildcardType 几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型
Parameterized Type : 表示一种参数化类型，比如Collection，String是参数化类型
GenericArray Type:表示一种元素类型是参数化类型或者类型变量的数组类型
TypeVariable：是各种类型变量的公共父接口
WildcardType ：代表一种通配符类型表达式

package refection;

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 Test10 {

    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 = Test10.class.getDeclaredMethod("test01", Map.class, List.class);

        // 通过反射获取参数信息
        Type []type = method.getGenericParameterTypes();
        for (Type type1 : type) {
            System.out.println("#" + type1);

            //如果获取到的这个泛型是 ParameterizedType ， 那么进行进行强转 ， 然后输出
            if(type1 instanceof ParameterizedType){
                // 整体打印（针对于多个泛型参数的集合的方法而言）
               // System.out.println(type1);
                
                // 分别打印(针对于多个泛型参数的集合的方法而言)
                Type []types = ((ParameterizedType)type1).getActualTypeArguments();
                for (Type type2 : types) {
                    System.out.println(type2);
                }
            }
        }

    }

}

2.12 获取注解信息

练习ORM

package refection;


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

@SuppressWarnings("all")
public class Test11 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("refection.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);

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

}


@Table("db_student")
class Student2{
    @File(columnName = "db_name" , type = "varchar" , length = 3)
        private String name ;
    @File(columnName = "db_id" , type = "int " , length = 10)
        private int id ;
    @File(columnName = "db_age" , type = "int " , length = 10)
        private int age ;

        public Student2() {
        }

        public Student2(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 "Student2{" +
                    "name='" + name + '\'' +
                    ", id=" + id +
                    ", age=" + age +
                    '}';
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            refection.Student2 student2 = (refection.Student2) o;
            return id == student2.id &&
                    age == student2.age &&
                    Objects.equals(name, student2.name);
        }

        @Override
        public int hashCode() {
            return Objects.hash(name, id, age);
        }
    }


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


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

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。