注解和反射

目录

注解

1.什么是注解

注解 (英文名Annotation)

是从JDK5.0开始引入的一个新的技术, 格式为 @注解名 的形式在代码中存在, 还有一些可以添加一些参数值. 例如;@SuppressWarnings("all")

2. 内置注解

  • @Override注解定义在java.lang.Override 中, 此注解用于修辞方法, 表示一个方法声明打算重写超类(父类)中的方法
  • @Deprecated 注解定义在java.lang.Deprecated 中, 此注解用于修辞方法, 属性, 类. 表示不鼓励程序员去使用, 通常是因为它可能存在危险或者存在更好的选择
  • @SuppressWarnings 定义在java.lang.SuppressWarnings 中, 用来抑制编译时的警告信息

3. 元注解

// @Target 表示注解可以使用在哪些地方
@Target(ElementType.METHOD)

// 表示注解在什么时候还有效(一般都写RUNTIME)
// 运行时>class>sources
// 运行时>编译后>源代码
@Retention(value = RetentionPolicy.RUNTIME)

// Documented 表示是否将注解生成在javaDOC文档中
@Documented

// 子类可以继承父类的注解
@Inherited

// 定义一个注解
@interface Aaron{
}

4. 自定义注解

4.1 注解的参数

自定义注解时,可以设置参数. 参数格式为 参数类型 参数名(); 例如: String name(); 在使用时如果没有默认值,则必须传递参数

// 自定义注解
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
    // 注解的参数: 参数类型 + 参数名();
    String name();
}

//使用注解
public class test{
    @MyAnnotation2(name = "zpk")
    public void test(){}
}

4.2 注解的默认值

如果注解已经自定义了默认值, 参数可以不用写.如下:

//自定义注解
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
    // 注解的参数: 参数类型 + 参数名();
    String name();
    int age() default 0;
    int id() default -1; //如果默认值为-1 ,代表不存在
    
    String[] school();
}

// 使用注解
public class test{
    // 因为注解里面 已经 有了默认值 default 0; 所以age的属性可写可不写
    @MyAnnotation2(name = "zpk",school = {"清华大学","北京大学"})
    public void test(){}
}

4.3 当注解只有一个参数时

如果说注解里只有一个值,建议使用value做参数名, 因为使用value做参数名, 写参数的时候就可以省略参数名

例如:

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

//使用注解
public class test(){
    @MyAnnotation3("zpk")
    public void test1(){}
}

反射

1. 反射概述

Reflection(反射) 是java被视为动态语言的关键, 反射机制允许程序在执行时期间借助Reflection的API获取任何类的内部信息, 并直接操作任意对象的内部属性及方法. 例如:

Class c = Class.forName("java.lang.String");

加载完类之后, 在堆内存的方法去就产生了一个class类型的对象(一个类只有一个Class对象, 这个对象就包含了完整的类的结构信息, 我们可以通过这个对象看到类的结构. 这个对象就像一面镜子, 透过这个镜子,可以看待类的结构,所以我们形象的称之为: 反射

2. 获得反射对象

public class test1 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的对象
        Class c1 = Class.forName("com.aaron.Reflection.User");
        System.out.println(c1); // 输出: class com.aaron.Reflection.User

        // 一个类在内存中只有一个Class对象
        // 一个类被加载后, 类的整个结构都会封装在Class对象中
        Class c2 = Class.forName("com.aaron.Reflection.User");
        Class c3 = Class.forName("com.aaron.Reflection.User");
        Class c4 = Class.forName("com.aaron.Reflection.User");
        
        // 因为一个类只有一个Class对象,所以他们的hashCode时相同的
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        System.out.println(c4.hashCode());
    }
}

class User{
    private int id;
    private String name;
    private int age;
    //... 省略有参无参构造方法,get-set方法,toString方法
}

3. Class类获取对象的几种方式

3.1 对象照镜子后可以获得那些信息?

  • 某个类的属性
  • 方法和构造器
  • 某个类实现了那些接口等

对于每个类而言,JRE都为其保留了一个不变的Class对象.一个对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息

方法名 功能说明
static ClassforName(String name) 返回指定类名的Class对象
Obiect ne'wInstance() 调用缺省构造函数, 返回Class对象的一个实例
getName() 返回此Class对象所表示的实体 (类,接口,
数组类或void) 的名称
Class getSupperClass() 返回当前对象的父类Class对象
Class[] getInterfaces() 返回当前类的所有接口
ClassLoader getClassLoader() 返回该类的加载器
Constructor[] getConstructor() 返回一个包含Constructor对象的数组
Method getMethod(String name,Class.. T) 返回一个Method对象, 此对象的形参类型为
paramType
Field[] getDelaredFielda() 返回Field对象的一个数组

3.2 获取Class实例 (5种)

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

    Class clazz = Person.class;

  • 已知某个类的实例可以调用实力的getClass()方法获取

    Class clazz = person.getClass();

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

    Class clazz = Class.forName("com.zpk.demo.Person");

  • 8种基本类型的封装类都有一个Type属性

    Class clazz = Integer.Type;

  • 通过子类获取

    // 例如Student对象继承了Person对象
//所以可以使用Student对象获取父类Person的Class对象
Class clazz = Student.class.getSuperClass();

4. 那些类型可以有Class对象

注意: 数组在同一维度的才是同一个Class对象

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

5. 类的加载内存分析

5.1 类的加载分为三部分

(加载,链接,初始化)

  • -加载: 将class字节码内容加载到内存中, 并将这些静态数据转换成方法运行时的数据结构,然后生成一个代表这个类的数据结构,然后生成一个java.lang.Class对象
  • 链接: 将java类的二进制代码合并到JVM的运行状态之中的过程.
    • 验证: 确保加载类的信息符合JVM的规范, 没有安全方面的问题
    • 准备; 正式为变量 (static) 分配内存并设置默认初始值的阶段, 这些内存将在方法区进行分配
    • 解析: 虚拟机常量池的符号引用, (常量名) 替换为直接引用的( 地址) 的过程
  • 初始化
    • 执行类构造器的() 方法的过程. 类构造器()方法由编译期间自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并产生的.(类构造器是构造类的信息, 不是构造该类对象的构造器)
    • 当初始化一个类的时候,如果发现其父类还没有进行初始化,则需要先触发父类的初始化.
    • 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步.

5.2 代码示例:

public class Test2 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.m);
    }
}

/*
 * 1.加载到内存,会产生一个Class类
 * 2.链接, 链接结束后m获得一个默认值 m = 0;
 * 3.初始化
 *      <clinit>(){
 *          System.sout.println("A类的静态代码初始化");
 *          m = 300;
 *          m = 100;
 *      }
 *  最终结果: m = 100;
 */
class A{
    static {
        System.out.println("A类的静态代码初始化");
        m = 300;
    }
    static int m = 100;
    public A(){
        System.out.println("A类的无参构造方法");
    }
}

代码运行结果:

A类的静态代码初始化
A类的无参构造方法
100

6. 类加载器

6.1 什么时候会发生类初始化

  • 类的主动引用 (一定会发生类的初始化)
    • 当虚拟机启动时,先初始化main方法所在的类
    • new 一个类的对象
    • 调用类的静态成员(除了final常量)和静态方法
    • 使用java.lang.reflect包的方法对类进行反射调用
    • 当初始化一个类, 如果其父类没有被初始化,则会先初始化其父类
  • 类的被动调用 (不会发生类的初始化)
    • 当访问一个静态域时,只有真正声明这个域的类才会被初始化,如: 当通过子类引用父类的静态变量,不会导致子类被初始化
    • 通过数组定义类引用,不会触发此类的初始化
    • 引用常量不会触发此类的初始化(常量在链接阶段就存入调用类的常量池中了)

6.2 类加载器的作用

  • 类加载的作用: 将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构,然会在堆中生成一个代表这个类的java.lang.Class对象,作为此方法区中类数据的访问入口,类加载器是用来把类(class)装载进内存的,JVM定义了如下类型加加载器

    • **引导类加载器: ** 用c++编写的,是JVM自带的类加载器,负责JVM平台的核心库(java核心库: rt.jar),用来装在核心类库,该加载器无法直接获取
    • **扩展类加载器: ** 负责jre/lib/ext目录下的jar包或 -D java.ext.dirs 指定目录下的jar包装入工作库
    • **系统类加载器: ** 负责java -classpath 或 -D java.class.path所指的目录下的类与jar包,装入工作库, 是最常用的加载器

    检查类是否已经装在顺序: 系统->扩展->引导

    尝试加载类顺序: 引导->扩展->系统

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

代码示例 (引导类加载器(核心类库)使用c/c++所编写,输出为null)

public class Test3 {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取系统类的加载器
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
        System.out.println(classLoader); // sun.misc.Launcher$AppClassLoader@18b4aac2
        //获取系统类加载器的父类加载器-->扩展类加载器
        ClassLoader parent = classLoader.getParent();
        System.out.println(parent); // sun.misc.Launcher$ExtClassLoader@1540e19d
        // 获取扩展类加载器的父类加载器,根加载器(c/c++)
        ClassLoader paremt1 = parent.getParent();
        System.out.println(paremt1); // null
        //测试当前类是那个类加载器加载的
        classLoader = Class.forName("aaron.Reflection.Test3").getClassLoader();
        System.out.println(classLoader); // sun.misc.Launcher$AppClassLoader@18b4aac2
        // 测试JDK内置类是谁加载的
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader); // null
        //如何获得系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
        /*
        结果:
        D:\Development\jdk_1.8.131\jre\lib\charsets.jar;
        D:\Development\jdk_1.8.131\jre\lib\deploy.jar;
        D:\Development\jdk_1.8.131\jre\lib\ext\access-bridge-64.jar;
        D:\Development\jdk_1.8.131\jre\lib\ext\cldrdata.jar;
        D:\Development\jdk_1.8.131\jre\lib\ext\dnsns.jar;
        D:\Development\jdk_1.8.131\jre\lib\ext\jaccess.jar;
        D:\Development\jdk_1.8.131\jre\lib\ext\jfxrt.jar;
        D:\Development\jdk_1.8.131\jre\lib\ext\localedata.jar;
        D:\Development\jdk_1.8.131\jre\lib\ext\nashorn.jar;
        D:\Development\jdk_1.8.131\jre\lib\ext\sunec.jar;
        D:\Development\jdk_1.8.131\jre\lib\ext\sunjce_provider.jar;
        D:\Development\jdk_1.8.131\jre\lib\ext\sunmscapi.jar;
        D:\Development\jdk_1.8.131\jre\lib\ext\sunpkcs11.jar;
        D:\Development\jdk_1.8.131\jre\lib\ext\zipfs.jar;
        D:\Development\jdk_1.8.131\jre\lib\javaws.jar;
        D:\Development\jdk_1.8.131\jre\lib\jce.jar;
        D:\Development\jdk_1.8.131\jre\lib\jfr.jar;
        D:\Development\jdk_1.8.131\jre\lib\jfxswt.jar;
        D:\Development\jdk_1.8.131\jre\lib\jsse.jar;
        D:\Development\jdk_1.8.131\jre\lib\management-agent.jar;
        D:\Development\jdk_1.8.131\jre\lib\plugin.jar;
        D:\Development\jdk_1.8.131\jre\lib\resources.jar;
        D:\Development\jdk_1.8.131\jre\lib\rt.jar;
        D:\Development\workspace\注解测试\out\production\testModel;
        C:\other\idea\lib\idea_rt.jar
         */
    }
}

7. 获取类运行时的结构

代码演示:

public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
    Class c1 = Class.forName("aaron.Reflection.User");
    // 获得类的全名
    c1.getName();
    //获得类的简单名字(不包括包名)
    c1.getSimpleName();
    // 获得类的属性
    Field[] fields = c1.getFields(); // 只能获取public属性
    fields = c1.getDeclaredFields(); // 获取全部属性

    // 获得指定属性
    Field name = c1.getDeclaredField("name");
    // 获得本类public的方法
    c1.getMethods();
    // 获得本类所有的方法
    c1.getDeclaredMethods();
    // 获得指定方法,此方法的第二个参数是getName()方法的参数,没有则为null
    c1.getMethod("getName",null);
    c1.getMethod("setName", String.class);
    // 获得指定构造器
    Constructor[] constructors = c1.getConstructors(); // 获得所有public 的构造方法
    constructors = c1.getDeclaredConstructors(); // 获得所有的构造方法
}

8. 动态创建对象的执行方法

实例代码:

public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
    // 获取class对象
    Class c1 = Class.forName("aaron.Reflection.User");
    // 构造一个对象
    User user = (User) c1.newInstance(); // 本质是调用了类的无参构造器
    System.out.println(user); //输出: User{id=0, name='null', age=0}
    // 通过构造器创建对象
    Constructor constructor = c1.getDeclaredConstructor(int.class,String.class,int.class);
    User user1 = (User) constructor.newInstance(1,"zpk",20);
    System.out.println(user1); //输出: User{id=1, name='zpk', age=20}

    //通过反射调用普通方法
    User user2 = (User) c1.newInstance();
    //通过反射获取一个方法
    Method setName = c1.getMethod("setName", String.class);
    // invoke : 激活的意思 , 其参数为 ( 对象, "方法的值" )
    setName.invoke(user2,"zpk");
    System.out.println(user2.getName());

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

}

9. 创建对象方式的性能问题

以执行一个对象的方法十亿次的时间差对比结果

  • 1, 普通方式 new 一个对象最快 -> 9ms
  • 2.反射方式关闭安全检测速度一般 -> 1894ms (name.setAccessible(true)😉
  • 3.反射不关闭安全检测速度最慢 -> 4762ms

10. 练习反射操作注解

// 练习反射操作注解
public class Test6 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c = Class.forName("aaron.Reflection.Student");
        // 通过反射获得注解
        Annotation[] annotations = c.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

        // 获得注解value的值
        TableZpk annotation = (TableZpk) c.getAnnotation(TableZpk.class);
        System.out.println(annotation.value());

        // 获得类指定的注解
        Field f = c.getDeclaredField("name");
        FieldZpk annotation1 = f.getAnnotation(FieldZpk.class);
        System.out.println(annotation1.columnName()); //获得name属性注解的columnName的值
        System.out.println(annotation1.length()); //获得name属性注解的length的值
        System.out.println(annotation1.type()); //获得name属性注解的type的值
    }

}

@TableZpk("db_student")
class Student{
    @FieldZpk(columnName = "db_id",type = "int",length = 10)
    private int id;
    @FieldZpk(columnName = "db_age",type = "int",length = 10)
    private int age;
    @FieldZpk(columnName = "db_name",type = "varcher",length = 10)
    private String name;
	// ... 省略无参有参构造方法,toString,get-set方法
}

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

/**
 * 属性的注解
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldZpk{
    String columnName();
    String type();
    int length();
}
posted @ 2020-04-10 10:13  zpk-aaron  阅读(201)  评论(0)  编辑  收藏  举报