注解与反射学习笔记

注解与反射

注解

注解是什么

Annotation的

  • Annotation的作用:

    不是程序本身,可以对程序做出解释(这一点和(common)没什么区别)

    可以被其他程序(比如:编译器等)读取

  • Annotation的格式:

    注解是以“@注释名”在代码中存在的,还可以添加一些参数值,例如:@SuppressWarning(value=“unchecked”)

  • Annotation使用位置:

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

内置注解

  • @Override:定义在java.lang.Override中,此注释只适用于修饰方法,表示一个方法声明打算重写超类中的另一个方法声明

  • @Deprecated:定义在java.lang.Deprecated中,此注释可以修饰方法,属性,类。 表示此方法已废弃、暂时可用,但以后此类或方法都不会再更新、后期可能会删除,建议后来人不要调用此方法。

  • @SuppressWarnings:定义在java.lang.SuppressWarnings中,用来抑制编译时的警告信息,与前注解不同,你需要添加一个参数才可以正确使用,这些参数都是已经定义好的

    @SuppressWarnings(“all”)/@SuppressWarnings("unchecked")/@@SuppressWarnings(value={"unchecked","deprecation"}) ......等等

 package com.aly.annotation;
 
 import java.util.ArrayList;
 import java.util.List;
 
 /**
  * @author aly
  * @version 1.0
  * @date 2020/10/22 9:18
  */
 //什么是注解
 public class Test01 extends Object {
 
     //重写的注解
     @Override
     public String toString() {
         return super.toString();
    }
 
     //Deprecated 不推荐程序员使用,但是可以使用,或者存在更好的方式
     @Deprecated
     public static void test() {
         System.out.println("Deprecated");
    }
 
     @SuppressWarnings("all")
     public void test1() {
         List<String> list = new ArrayList<String>();
    }
 
     public static void main(String[] args) {
         test();
    }
 
 }

image-20201022092246269

 

元注解

  • 元注解的作用就是负责注解其他注解,Java定义了4个标准的meta-annotation类型,他们被用来提供对其他annotation类型作说明

  • 这些类型和它们所支持的类在java.lang.annotation包中可以找到.(@Target,@Retention,@Documented,@Inherited

    @Target:用于描述注解的使用范围(即:被描述的注解可以用在什么地方)

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

    SOUERCE<CLASS<RUNTIME

    @Document:说明该注解将被包含在javadoc中

    @Inherited:说明子类可以继承父类中的注解

 package com.aly.annotation;
 
 import java.lang.annotation.*;
 
 /**
  * @author aly
  * @version 1.0
  * @date 2020/10/22 9:24
  */
 //测试元注解
 public class Test02 {
 
     @MyAnnotation
     public void test() {
 
    }
 }
 
 //定义一个注解
 //Target 表示我们的注解可以用在什么地方
 @Target(value = {ElementType.METHOD, ElementType.TYPE})
 //Documented 表示是否将我们的注解生成在Javadoc中
 @Documented
 //Retention 表示我们的注解在什么地方有效
 @Retention(value = RetentionPolicy.RUNTIME)
 //Inherited 子类可以继承父类的注解
 @Inherited
 @interface MyAnnotation {
 
 }

 

自定义注解

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

  • 分析

    @interface用来声明注解,格式:public @interface 注解名{定义内容}

    其中的每一个方法实际上声明了一个配置参数

    方法的名称就是参数的名称

    返回值类型就是参数的类型(返回值只有基本数据类型,Class,String,enum)

    可以通过default来声明参数的默认值

    如果只有一个参数成员,一般参数名为value

    注解元素必须要有值,我们定义注解元素时,经常使用空字符串,0作为返回值

 package com.aly.annotation;
 
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
  * @author aly
  * @version 1.0
  * @date 2020/10/22 11:15
  */
 //自定义注解
 public class Test03 {
 
     //注解可以显示赋值 如果没有默认值 我们就必须给注解赋值
     @MyAnnotation2(age = 121)
     public void test() {
 
    }
 
     //只有一个参数时 而且字段名 必须为value 则可以省略参数名
     @MyAnnotation3("lkk")
     public void test1() {
 
    }
 }
 
 //能在什么使用
 @Target({ElementType.TYPE, ElementType.METHOD})
 //在什么时候有效
 @Retention(RetentionPolicy.RUNTIME)
 @interface MyAnnotation2 {
     //注解的参数:参数类型+参数名()
     String name() default "aly";
 
     int id() default 1;
 
     String[] schools() default {"重邮", "重大"};
 
     int age();
 }
 
 //能在什么使用
 @Target({ElementType.TYPE, ElementType.METHOD})
 //在什么时候有效
 @Retention(RetentionPolicy.RUNTIME)
 @interface MyAnnotation3 {
 
     //只有一个参数 并为value 则可以省略 其他的参数名都不准省略
     String value();
 }

 

 

反射机制

Java Reflection

  • Reflection(反射)是Java被视为动态语言的关键,反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息,并能直接操作任意对象内部属性及方法

     Class c = Class.forName("java.lang.String")
  • 加载类完成之后,在堆内存的方法区就产生了一个Class类型的对象(一个类只有一个Class对象),这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子,透过这个镜子看到类的结构,所以,我们形象的称之为:反射通过反射可以获得类的所有信息 通过反射调用方法的效率比直接调用的效率要至少慢一倍以上

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

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

     package com.aly.reflection;
     
     /**
      * @author aly
      * @version 1.0
      * @date 2020/10/22 14:27
      */
     
     //什么叫做反射
     public class Test01 {
     
         public static void main(String[] args) {
             try {
                 //通过反射获取类的Class对象
                 Class c1 = Class.forName("com.aly.reflection.Test01");
                 Class c2 = Class.forName("com.aly.reflection.Test01");
                 Class c3 = Class.forName("com.aly.reflection.Test01");
                 Class c4 = Class.forName("com.aly.reflection.Test01");
     
                 //一个类在内存中只有一个Class对象
                 //一个类被加载后,类的整个结构都会被封装在Class对象中
                 System.out.println(c1.hashCode());
                 System.out.println(c2.hashCode());
                 System.out.println(c3.hashCode());
                 System.out.println(c4.hashCode());
            } catch (ClassNotFoundException e) {
                 e.printStackTrace();
            }
        }
     }
     
     //创建一个实体类:pojo entity
     class User {
         String userName;
         String password;
     
         @Override
         public String toString() {
             return "User{" +
                     "userName='" + userName + '\'' +
                     ", password='" + password + '\'' +
                     ", age=" + age +
                     '}';
        }
     
         public User() {
        }
     
         public User(String userName, String password, int age) {
             this.userName = userName;
             this.password = password;
             this.age = age;
        }
     
         public String getUserName() {
             return userName;
        }
     
         public void setUserName(String userName) {
             this.userName = userName;
        }
     
         public String getPassword() {
             return password;
        }
     
         public void setPassword(String password) {
             this.password = password;
        }
     
         public int getAge() {
             return age;
        }
     
         public void setAge(int age) {
             this.age = age;
        }
     
         int age;
     
     }

    image-20201022144228145

     

Class类

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

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

Class类的常用方法

方法名功能说明
static ClassforName(String name) 返回指定类名的Class对象
Object newInstance() 调用缺省构造函数,返回Class对象的一个实例
getName() 返回此Class对象所表示的实体(类,接口,数组类或void)的名称
Class getSuperClass() 返回当前Class对象的父类Class对象
Class[] getinterfaces() 获取当前Class对象的接口
ClassLoader getClassLoader() 获取该类的类加载器
Constructor[] getConstructors() 返回一个包含某些Constructor对象的数组
Method getMethod(String name,Class...T) 返回一个Method对象,此对象的形参类型为paramType
Field getDelaredFields() 返回Field对象的一个数组

获取Class类的实例

  • 若已知具体的类,通过类的class属性获取,该方法最为安全可靠,程序性能最高

 Class clazz = Person.class;
  • 已知某个类的实例,调用该实例的getClass()方法获取class对象

 Class clazz = Person.getClass();
  • 已知一个类的全类名,且该类在类路径下,可通过Class类的静态方法forName()获取,可能抛出ClassNotFoundException

 Class clazz = Class.forName("demo01.Student");
  • 内置基本数据类型可以直接用类名.TYPE

    package com.aly.reflection;
    
    /**
     * @author aly
     * @version 1.0
     * @date 2020/10/22 14:53
     */
    
    public class Test02 {
    
        public static void main(String[] args) throws ClassNotFoundException {
            Person c5 = new Student();
            System.out.println("这个人是" + c5.name);
    
            //方式一:通过对象获得
            Class c6 = c5.getClass();
    
            //方式二:通过forName获得
            Class c1 = Class.forName("com.aly.reflection.Student");
            System.out.println(c1.hashCode());
    
            //方式三:通过类名.class获得
            Class c2 = Student.class;
            System.out.println(c2.hashCode());
    
            //方式四:基本内置类型的包装类都有一个TYPE类型
            Class c3 = Integer.TYPE;
            System.out.println(c3);
    
            //获得父类类型
            Class c4 = c1.getSuperclass();
            System.out.println(c4);
        }
    }
    
    class Person {
        public String name;
    
        public Person() {
        }
    
        public Person(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }
    
    class Teacher extends Person {
        public Teacher() {
            this.name = "老师";
        }
    }
    
    class Student extends Person {
        public Student() {
            this.name = "学生";
        }
    }

image-20201022153718898

 

类加载内存分析

Java内存分析

  • 堆:存放new的对象和数组 可以被所有的线程共享,不会存放别的对象引用

  • 栈:存放基本变量类型(会包含这个基本类型的具体数值) 引用对象的变量(会存放这个引用在堆里面的具体地址)

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

package com.aly.reflection;

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/22 16:05
 */

public class Test03 {

    public static void main(String[] args) {
        /**
         1.加载到内存,会产生一个类对应的class对象
         2.链接,链接结束后 m =0
         3.初始化
         <clinit>(){
         System.out.println("A类静态代码块初始化");
         m=100
         m=300
         }
         */
        A a = new A();
        System.out.println(A.m);
    }
}

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

    /**
     * m=100
     * m=300
     */
    static int m = 300;

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

image-20201022161806999

 

类的加载与ClassLoader的理解

  • 加载:将class字节码内容加载到内存中,并将这些静态数据装换成方法区的运行时数据结构,然后生成代表这个类的java.lang.class对象

  • 链接:将Java类的二进制代码合并到JVM的运行状态之中的过程

    验证:确保加载的类信息符合JVM规范,没有安全方面的问题

    准备:正式为类变量(static)分配内存并设置类变量默认初始值的阶段,这些内存都将在方法区中进行分配

    解析:虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程

  • 初始化:

    执行类构造器<clinit>()方法的过程。类构造器<clinit>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。(类构造器是构造类信息的,不是构造该类的构造器)

    当初始化一个类的时候,如果发现其父类还没有进行初始化,则需要先触发其父类的初始化

    虚拟机会保证一个类<clinit>()方法在多线程环境中被正确加锁和同步

    什么时候会发生类初始化

    1. 类的主动引用(一定会发生类的初始化)

      • 当虚拟机启动,先初始化main方法所在的类

      • new一个类的对象

      • 调用类的静态成员(除了final常量)和静态方法

      • 使用java.lang.reflect包的方法对类进行反射调用

      2.类的被动引用(不会发生类的初始化)

      • 当访问一个静态域时,只有真正声明这个域的类才能被初始化。如:当通过子类引用父类的静态变量,不会导致子类初始化

      • 通过数组定义类引用,不会触发该类的初始化

      • 引用常量不会触发此类的初始化(常量在链接阶段就存入调用类的常量池了)

package com.aly.reflection;

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/22 16:31
 */
public class Test04 {

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

    public static void main(String[] args) throws ClassNotFoundException {
        //1.主动引用
//        Father father = new Son();

        //反射也会产生主动引用
//        Class.forName("com.aly.reflection.Son");

        //不会产生类的引用方法
//        System.out.println(Son.c);
        Son[] sons = new Son[5];

        //不会产生加载
//        System.out.println(Son.M);
    }
}

class Father {

    static int c = 2;

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

class Son extends Father {

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

    static int m = 10;
    static final int M = 10;
}

类加载器的作用

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

  • 类缓存:标准的JavaSE类加载器可以按要求查找类,但一旦某个类被加载到类加载器中,它将维持加载(缓存)一段时间。不过JVM垃圾回收机制可以回收这些Class对象

image-20201022182630815

 

类加载器作用是用来把类(class)装载进内存的。JVM规范定义了如下类型的类加载器:

image-20201022183009232

package com.aly.reflection;

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/22 18:31
 */
public class Test05 {
    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);

        //测试当前类是哪个加载器加载的
        Class aClass = Class.forName("com.aly.reflection.Test05");
        System.out.println(aClass.getClassLoader());

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

        //如何获取系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
        //C:\Program Files\Java\jdk1.8.0_162\jre\lib\charsets.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\deploy.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\ext\access-bridge-64.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\ext\cldrdata.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\ext\dnsns.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\ext\jaccess.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\ext\jfxrt.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\ext\localedata.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\ext\nashorn.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\ext\sunec.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\ext\sunjce_provider.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\ext\sunmscapi.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\ext\sunpkcs11.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\ext\zipfs.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\javaws.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\jce.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\jfr.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\jfxswt.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\jsse.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\management-agent.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\plugin.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\resources.jar;
        // C:\Program Files\Java\jdk1.8.0_162\jre\lib\rt.jar;
        // D:\alydm\zjyfs\out\production\zjyfs;D:\IDEA\IntelliJ IDEA 2020.1.2\lib\idea_rt.jar

    }
}

image-20201022184207270

 

获取运行时类的对象

获取运行时的完整结构

  • 通过反射获取运行时类的完整结构 Field/Method/Construtor/SuperClass/Interface/Annotation

    1.实现的全部接口 2.所继承的父类 3.全部的构造器 4.全部的方法 5.全部的Field 6.注解

    package com.aly.reflection;
    
    import javax.swing.plaf.IconUIResource;
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    
    /**
     * @author aly
     * @version 1.0
     * @date 2020/10/22 19:07
     */
    //获取类的信息
    public class Test06 {
        public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
            Class aClass = Class.forName("com.aly.reflection.User");
    
            //获取类的名字
            System.out.println(aClass.getName());//获取包名+类名
            System.out.println(aClass.getSimpleName());//获取类名
    
            //获得类的属性
            System.out.println("===========================");
            Field[] fields = aClass.getFields();//只找到了public属性
            for (Field field : fields) {
                System.out.println("getFields==" + field);
            }
    
            System.out.println("===========================");
    
            fields = aClass.getDeclaredFields();//找到全部属性
            for (Field field : fields) {
                System.out.println("getDeclaredFields==" + field);
            }
    
            //获得指定属性的值
            System.out.println("===========================");
            Field userName = aClass.getField("userName");//只能获得public的属性
            System.out.println(userName);
    
            System.out.println("===========================");
            Field age = aClass.getDeclaredField("age");//可以获得private属性
            System.out.println(age);
    
            //获得类的方法
            System.out.println("===========================");
            Method[] methods = aClass.getMethods();//获得本类及父类的全部public方法
            for (Method method : methods) {
                System.out.println("正常的:" + method);
            }
    
            methods = aClass.getDeclaredMethods();//获取本类的所有方法
            for (Method method : methods) {
                System.out.println("getDeclaredMethods:" + method);
            }
    
            //获得指定的方法
            System.out.println("===========================");
            Method getAge = aClass.getMethod("getAge", null);
            Method setAge = aClass.getMethod("setAge", int.class);
            System.out.println(getAge);
            System.out.println(setAge);
    
            //获取构造器
            System.out.println("===========================");
            Constructor[] constructors = aClass.getConstructors();
            for (Constructor constructor : constructors) {
                System.out.println(constructor);
            }
    
            constructors = aClass.getDeclaredConstructors();
            for (Constructor constructor : constructors) {
                System.out.println("##"+constructor);
            }
    
            //获取指定的构造器
            System.out.println("===========================");
            Constructor constructor = aClass.getConstructor(String.class, String.class, int.class);
            System.out.println(constructor);
        }
    }

image-20201022193128581

 

动态创建对象执行方法

创建类的对象

  • 创建类的对象:调用Class对象的newInstance()方法

    • 类必须有一个无参数的构造器

    • 类的构造器的访问权限需要足够

  • 没有无参的构造器也能创建对象,只要在操作的时候明确调用类中的构造器,并将参数传递进去之后,才可以实例化操作。步骤如下:

    1.通过Class类的getDeclaredConstructor(Class....parameterTypes)取得本类的指定形参类型的构造器

    2.向构造器的形参中传递一个对象数组进去,里面包含了构造器中所需的各个参数

    3.通过Construtor实例化对象

调用指定的方法

通过反射,调用类中的方法,通过Method类完成

  1. 通过Class类的getMethod(String name,Class....parateterTypes)方法取得一个Method对象,并设置此方法操作时所需要的参数类型

  2. 之后使用Object invoke(Object object,Object[] args)进行调用,并向方法中传递要设置的obj对象的参数信息

image-20201022202055363

Object invoke(Object obj,Object... args)

  • Object对应原方法的返回值,若原方法无返回值,此时返回null

  • 若原方法若为静态方法,此时形参Object obj可为null

  • 若原方法形参列表为空,则Object[] args为null

  • 若原方法声明private,则需要在调用此invoke()方法前,显示调用方法对象的setAccessible(true)方法,则可访问private的方法

setAccessible

  • Method和Field/Constructor对象都有setAccessible()方法

  • setAccessible作用是启动和禁用访问安全检查的开关

  • 参数值为true则指示反射的对象在使用时应该取消Java语言访问检查

    • 提高反射的效率。如果代码中必须用反射,而该句代码需要频繁的使用,那么请设置为true

    • 使用原本无法访问的私有成员也可以访问

  • 参数值为false则指示反射的对象应该实施Java语言访问检查

package com.aly.reflection;

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

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/22 19:52
 */
//通过反射动态的创建对象
public class Test07 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //获得Class对象
        Class aClass = Class.forName("com.aly.reflection.User");

        //构造一个对象
        System.out.println("====================");
        User user = (User)aClass.newInstance();//本质调用了类的无参构造函数
        System.out.println(user);

        //通过构造器创建对象
        System.out.println("====================");
        Constructor declaredConstructor = aClass.getDeclaredConstructor(String.class, String.class, int.class);
        User user1 = (User) declaredConstructor.newInstance("aly", "lkk", 14);
        System.out.println(user1);

        //通过反射调用普通方法
        System.out.println("====================");
        User user2 = (User) aClass.newInstance();
        //通过反射获取方法
        Method setUserName = aClass.getMethod("setUserName", String.class);
        //invoke:激活的意思
        //(对象,“方法的值”)
        setUserName.invoke(user2,"aly");
        System.out.println(user2.getUserName());

        //通过反射操作属性
        System.out.println("====================");
        User user3 = (User) aClass.newInstance();
        Field age = aClass.getDeclaredField("age");
        //不能直接操作私有属性,我们需要关闭程序的安全检测,通过属性或者方法的setAccessible(true)
        age.setAccessible(true);
        age.set(user3,18);
        System.out.println(user3.getAge());
    }
}

image-20201022203121087

 

性能对比分析

package com.aly.reflection;

import javax.jws.soap.SOAPBinding;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/22 20:38
 */
//对比性能
public class Test08 {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        test();
        test1();
        test2();
    }

    //普通方式
    static void test() {
        User user = new User();

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 1000000000; i++) {
            user.getUserName();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("普通方式:" + (endTime - startTime) + "ms");

    }

    //反射方式
    static void test1() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
        Class userClass = User.class;
        User user = (User) userClass.newInstance();
        Method getUserName = userClass.getMethod("getUserName", null);
        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 1000000000; i++) {
            getUserName.invoke(user, null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射方式:" + (endTime - startTime) + "ms");

    }

    //反射方式调用,关闭检测
    static void test2() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException, InstantiationException {
        Class userClass = User.class;
        User user = (User) userClass.newInstance();
        Method getUserName = userClass.getMethod("getUserName", null);
        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 1000000000; i++) {
            getUserName.setAccessible(true);
            getUserName.invoke(user, null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射方式调用,关闭检测:" + (endTime - startTime) + "ms");
    }
}

image-20201022224950144

 

反射操作注解

getAnnotation getAnnotations

package com.aly.reflection;

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

/**
 * @author aly
 * @version 1.0
 * @date 2020/10/22 23:11
 */
//联系反射操作注解
public class Test09 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class aClass = Class.forName("com.aly.reflection.Student2");

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

        //获得注解的value的值
        TableAly tableAly = (TableAly) aClass.getAnnotation(TableAly.class);
        System.out.println(tableAly.value());

        //获得属性注解
        Field name = aClass.getDeclaredField("name");
        FieldAly annotation = (FieldAly) name.getAnnotation(FieldAly.class);
        System.out.println(annotation.length());
        System.out.println(annotation.name());
        System.out.println(annotation.type());
    }
}


@TableAly("db_student")
class Student2 {

    @FieldAly(name = "columnName", length = 10, type = "String")
    String name;

    @FieldAly(name = "columnAge", length = 10, type = "int")
    int age;

    @FieldAly(name = "columnId", length = 10, type = "int")
    int id;

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

    public Student2() {
    }

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


//定义注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableAly {
    String value();
}

//定义注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldAly {
    String name();

    int length();

    String type();
}

 

posted @ 2021-02-27 15:01  秋分的秋刀鱼  阅读(52)  评论(0)    收藏  举报