投稿
  1. 半码博客首页
  2. 后端开发
  3. Java
  4. Java自学入门

注解和反射(主流框架底层实现）

飞熊 • • Java自学入门 • 阅读 93

在人生的道路上，不管是潇洒走一回，或者是千山独行，皆须是自己想走的路，虽然，有的人并不是很快就能找到自己的方向和道路，不过，只要坚持到底，我相信，就一定可以找到自己的路，只要找到路，就不必怕路途遥远了。

导读：本篇文章讲解 注解和反射(主流框架底层实现），希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com，来源：原文

注解和反射：框架底层实现机制

1.注解 Java.Annotation：注释comment（人）和注解（机器）

1.1 注解入门

  • java5.0引入
  • 作用：本身非程序，对程序做出解释（对代码有检测、约束的作用）
  • 可以被其他程序（编译器读取） +反射=程序动态性
  • 格式：以“@注释名”在代码中存在，可以添加参数，

@SupressWarnings(value=“unchecked”)

  • 哪里使用：附加在package,class,method,field等。相当于给这些元素添加额外信息。通过反射机制编程实现对这些元数据的访问。

1.2内置注解

java.lang.SupressWarnings:抑制编译时警告信息，需要添加参数才能使用，参数已定义好

@SupressWarnings(“all”)

@SuppressWarnings(value = “unchecked”)

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

1.3元注解

  • 作用：注解其他注解，java定义了4个meta-annotation类型，被用来对其他Annotation类型做说明
  • 这些类型和支持的类在
  • @Target：描述注解的使用范围
  • @Retention：需要在什么级别保存该注释信息，描述注解的生命周期（source（源码）<class（类上）<runtime（运行时））一般用runtime，框架使用，自定义注解也是这个。
  • @Documented:注解将包含在javadoc中
  • @Inherited：说明子类可以继承父类中的该注解

1.4自定义注解：使用@interface自定义注解时，自动继承java.lang.annotation.Annotation接口

  • @interface用来声明一个注解，格式public @interface 注解名，类里面只能有一个public.
  • 其中每个方法是声明了一个配置参数
  • 方法的名称就是参数的名称
  • 返回值类型就是参数的类型（返回值只能是引用类型，Class,String,enum）
  • 可以通过default来声明参数的默认值
  • 只有一个参数成员，名为value
  • 注解元素必须有值，定义注解元素时，经常使用空字符串，0作为默认值。
public class Demo01 {
    //注解可以显示赋值，如果没有默认值，必须给注解赋值
    @quit(age =1,name={"A","B"})     //value="zk"
    public void test(){}
    @quit1("C")             //可省略value=
    public void test2(){}
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@interface quit{
    //参数类型   参数名()
    String value() default "";
    int age();
    int num() default -1;//如果默认值为-1，代表不存在,同index
    String[] name();
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@interface quit1{
    String value();     //只有一个参数，默认为value
}

2.反射机制（Java.Reflection）使java静态语言转为动态语言

2.1 Java反射机制概述：获取注解、泛型

2.1.1 动态语言：运行时可以改变结构的语言：如新函数、对象、或代码可以被引进，已有函数可以被删除或结构上发生变化。运行时代码可以根据某些条件改变自身结构

  • Object-C，C#，JS，PHP，Python：变量类型在运行时发生变化。

2.1.2 静态语言：运行时结构不可变的语言。如：java,C,C++

  • java不是动态语言，但可称之为“准准态语言”。即java有一定动态性，可以用发射来获取类似动态语言特性。java动态性使编程更加灵活。增加了不安全性

2.1.3 Java Reflection

  • Reflection(反射)使Java动态化的关键，反射机制让程序在运行期间用Reflection API取得类的内部消息，能直接操作对象的内部属性和方法。

Class<?> string = Class.forName(“java.lang.String”);

  • 加载完类后，在堆内存方法区产出了一个Class类型对象（一个类只有一个Class对象），这个对象包含了类的完整结构信息（私有信息）。可以通过这个对象看到类的结构，即为反射：

正常：引入包->new实例化->取得实例化对象

反射：实例化对象->getClass()方法->完整包类结构

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

2.1.4 优缺点

  • 优点：实现动态创建对象和编译，体现灵活性
  • 性能有影响。反射是一种解释操作，可以告诉JVM，做什么满足要求。这些操作慢于直接执行相同的操作
//通过反射获取类的class对象
Class c1 = Class.forName("com.zk.reflectiondemo.Persion");
System.out.println(c1+"::"+c1.hashCode());
Class c2 = Class.forName("com.zk.reflectiondemo.Persion");
System.out.println(c2+"::"+c2.hashCode());

//一个类在内存中只有一个Class对象
//类被加载后，类的整个结构都会被封装在Class对象中

2.1.5 API

  • java.lang.Class:代表一个类
  • java.lang.reflect.Method:类的方法
  • …

2.1.6 Class类：Object类中定义了下面方法,被所有子类继承

public final native Class<?> getClass()

Class(描述类的类)->Person->xx(对象)

  • 方法返回值的类型是Class类，此类事Java反射源头，反射是从程序运行结果机对象反射求出类的名称。

  • 通过Class对象可以得到：类的相关信息（类实现了那些接口）。对于每个类。JRE为其保留一个不变的Class类型的对象。一个Class对象包含（class/interface/enum/annotation/private type/method）等信息。

  • Class本身事个类，Class对象只能有系统建立

  • 一个加载的类在JVM中只会有一个.class文件

  • 每个实例都会知道自己是从那个Class实例生成。

  • 通过Class可以完整得到类中所有被加载的结构

  • Class类是Reflection的根源，针对要动态加载，运行的类，只有先获得相应的Class对象

2.1.7 常用方法

public static Class<?> forName(String className) //返回指定类名name的Class对象

public T newInstance() //调用缺省构造函数，返回Class对象的一个实例

public String getName() //返回此Class对象所标识的实体（类，接口，数组或void）的名称

public native Class<? super T> getSuperclass()

public Class<?>[] getInterfaces()//返回该Class对象的接口

public ClassLoader getClassLoader() //返回该类的类加载器

public Constructor<?>[] getConstructors() //返回一个包含某些Constructor对象的数组

public Method getMethod(String name, Class<?>… parameterTypes) //返回Method 对象，此对象的形参类型为paramType

public Field[] getFields() //返回Field对象的一个数组

2.2 理解Class类并获取Class：JVM类加载机制

2.2.1 java内存

  • 堆：存放new的对象和数组；被所有线程共享，不会存放别的对象引用
  • 栈：存放基本变量类型（包含这个基本类型的具体数值），引用对象的变量的变量（会存在这个引用的堆里面的具体地址）
  • 方法区：可被所有线程共享，包含了所有的class和static变量

2.2.2 类的加载：使用某个类时，若该类没加载到内存中，系统会通过下面三个步骤堆该类进行初始化。

  • 类的加载（Load）:将类的class文件读入内存，并创建一个Class对象。此过程由类加载器完成。
    • 字节码内容加载到内存中，将静态数据转换为方法区（特殊的堆）的运行时数据结构，生成一个代表这个类的Class对象（堆）
  • 类的链接（Link）：将类的二进制数据合并到JRE中。
    • 验证:确保加载的类信息符合JVM规范，没有安全方面的问题
    • 准备：正式为类变量（static）分配内存并设置类变量默认初始值阶段，这些内存都将在方法区中进行分配
    • 解析：虚拟机常量池内的符合引用（常量名）替换为直接引用（地址的过程）
  • 类的初始化（Initialize）:JVM负责对类进行初始化。
    • 执行类构造器()方法的过程。类构造器方法是由编译器自动收集类中的（static）类变量的赋值动作和静态代码块（static）中的语句合并产生的。（类构造器时构造类信息的，不是构造该类对象的构造器）
    • 当初始化一个类时，若发现父类还没有初始化，先触发父类的初始化。
    • 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步
public class TestDemo02 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.num);
        /*
        * 1.加载到内存方法区，产生一个类对应的Class对象（堆）
        * 2.链接，链接过程 m=0
        * 初始化
        * <clinit>()
        * 顺序执行静态区方法
        * System.out.println("A静态方法执行");
        * num = 200;
        * num = 500*/
    }
}
class A{
    static {
        System.out.println("A静态方法执行");
        num = 200;
    }
    static int num = 500;

    public A() {
        System.out.println("A构造方法执行");
    }
}

2.2.3 类的初始化场景

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

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

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

  • 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类访问父类的静态变量，不会导致子类初始化
  • 通过数组定义类引用，不会触发类的初始化
  • 引用常量不会触发此类的初始化（常量在链接阶段就存入调入类的常量池中了）
public class TestDemo02 {
    static {
        System.out.println("主类静态方法被初始化");
    }
    public static void main(String[] args) {
        /*A a = new A();
        System.out.println(A.num);*/
        //System.out.println(A.numP);
        

        A[] as = new A[5];
        System.out.println(A.PI);
    }
}
class P {
    static int numP = 999;
    static {
        System.out.println("父类静态方法执行");
    }
}
class A extends P{
    static {
        System.out.println("子类静态方法执行");
        num = 200;
    }
    static int num = 500;
    static final double PI = 3.14;
    public  A() {
        System.out.println("子类构造方法执行");
    }
    public static void B(){
        System.out.println("子类的静态方法B被使用");
    }
}

2.3 类加载与ClassLoader：底层机制

  • 源码->Javac编译器字节码文件(.class文件)->类加载器加载->字节码校验器->解释器->JVM->操作系统

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

  • 类缓存：标准的J2SE类加载器可以按要求查找类，一但某个类被加载到类加载器中，将维持缓存一段时间，不过JVM垃圾回收机制可以回收这些Class对象。提高效率

2.3.1 类加载器的作用：把类加载到内存中。JVM规定的如下类型的类加载器

  • 引导类加载器：C++编写，jvm自带的类加载器，用来加载java核心类库（rt.jar）无法直接获取
  • 扩展类加载器：负责将jre/lib/ext目录下的jar包或-D java.ext.dirs指定目录下的jar包装入工作库
  • 系统类加载器：负责java -classpath或java.class.path所指的目录下的类与jar包装入工作，是最常见的加载器。项目里面的jar包加载到jvm中

2.3.2 双亲委派机制（检查自定义类（重名）是否在高级的类加载器中以存在）多重检查保证安全性

  • 从右到左检查类是否加载

  • Bootstap ClassLoader->Extension ClassLoader->System/App ClassLoader->自定义类加载器

  • 从左到右尝试加载类

//获取系统加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
System.out.println(systemClassLoader);
//获取父类-扩展类加载器
ClassLoader parent = systemClassLoader.getParent();
System.out.println(parent);
//获取父类-核心类加载器
parent = parent.getParent();
System.out.println(parent);
//测试当前类是那个类加载器加载的
ClassLoader classLoader = Class.forName("com.zk.reflectiondemo.TestDemo03").getClassLoader();
System.out.println(classLoader);
//测试JDK内置类的加载器
classLoader = Class.forName("java.lang.String").getClassLoader();
System.out.println(classLoader);
//获得系统类加载器可以加载的路径
System.out.println(System.getProperty("java.class.path"));

2.4 创建运行时类的对象：new/clone/运行时创建Hook钩子：外挂性质

  • 元素类型和维度一样，就是同一个Class
  • 得知具体的类，通过类的class属性获取，此方法安全可靠，程序性能最高
  • 得知类的实例，调用getClass()获取Class对象
  • 得知类全名，得知类路径，可通过Class类的静态方法forName()获取，抛出ClassNotFoundException异常
  • 内置基本数据包装器类型可以直接使用类名.Type
  • 还可以用ClassLoader
Class c1 = Class.forName("com.zk.reflectiondemo.Persion");
System.out.println(c1+"::"+c1.hashCode());
Persion persion = new Persion();
Class<? extends Persion> c3 = persion.getClass();
System.out.println(c3+"::"+c3.hashCode());
Class<Persion> c4 = Persion.class;
System.out.println(c4+"::"+c4.hashCode());

2.4.1 那些类型可以有Class对象

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

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

  • Field、Method（全部方法）、Constructor（全部构造器）、Superclass(所继承的父类)、Interface（实现的全部接口）、Annotation
Class c1 = Class.forName("com.zk.reflectiondemo.Persion");
c1 = Persion.class;
System.out.println(c1.getName());               //获得包名 + 类名
System.out.println(c1.getSimpleName());         //只获得类名
System.out.println("================================");
//获得类的属性
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);
}
System.out.println("");
Field love = c1.getField("love");   //获得特定的public属性
System.out.println(love);
Field age = c1.getDeclaredField("love");   //获得特定的全部属性
System.out.println(age);
System.out.println("================================");
Method[] methods = c1.getMethods();   //获得本类和父类的全部public方法
for (Method method : methods) {
    System.out.println("正常："+method);
}
methods = c1.getDeclaredMethods();  //获得本类的全部方法
for (Method method : methods) {
    System.out.println("本类："+method);
}
System.out.println("");
//获取特定的方法
//重载
Method getName = c1.getMethod("getName", null);
System.out.println(getName);
Method setName = c1.getMethod("setName", String.class);
System.out.println(setName);
//获取构造器
System.out.println("================================");
Constructor[] constructors = c1.getConstructors();  //获得本类的public构造器
for (Constructor constructor : constructors) {
    System.out.println(constructor);
}
constructors = c1.getDeclaredConstructors();  //获得本类的全部构造器
for (Constructor constructor : constructors) {
    System.out.println(constructor);
}
System.out.println("");
Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, char.class, String.class);
System.out.println("指定："+declaredConstructor);

2.5.1 使用Class对象

  • 创建了类的对象，调用Class对象的newInstance()方法
    • 类必须有一个无参构造器
    • 类的构造器访问权限要足够

没有无参构造器如何创建对象？操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以是实例化操作。

  • 用Class类的getDeclaredConstructor(Class parnmeterTypes)取到本类的指定形参类型构造器

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

  • 通过Constructor实例化对象

Class c1 = Class.forName("com.zk.reflectiondemo.Persion");
//此反射，使用无参构造器创建对象
Persion persion = (Persion) c1.newInstance();
System.out.println(persion);

//通过有参构造器反射创建一个对象
Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, char.class, String.class);
persion = (Persion)constructor.newInstance("zk", 12, '男', "高新区");
System.out.println(persion);
System.out.println("===============================");
//通过反射调用普通方法
Persion persion2 = (Persion) c1.newInstance();
Method setAddr = c1.getDeclaredMethod("setAddr", String.class);
//invoke:激活的意思
//（对象，"方法的值"）
setAddr.invoke(persion2,"未央区");
System.out.println(persion2.getAddr());
//通过反射调用属性
Persion persion3 = (Persion) c1.newInstance();
Field name = c1.getDeclaredField("name");
//不能直接操作私有属性，需要关闭程序的安全检查，属性或方法的setAccessible(true)
name.setAccessible(true);
name.set(persion3,"张三");
System.out.println(persion3.getName());

public Object invoke(Object obj, Object… args) //激活

  • Object 对应原方法的返回值，若无返回值，此时返回null
  • 若原方法为静态方法，此时形参Object obj 可为null
  • 若原方法形参列表为空，此时形参Object[] args 可为null
  • 若原方法声明为private，需要调用此invoke()方法前，显示调用方法对象的setAccessible(true)方法，关闭安全检查，可访问private方法。false为打开检查开关。—提高反射效率，代码中需要别频繁调用，则设置为true.
Class c1 = Class.forName("com.zk.reflectiondemo.Persion");
//此反射，使用无参构造器创建对象
Persion persion = (Persion) c1.newInstance();
System.out.println(persion);

//通过有参构造器反射创建一个对象
Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, char.class, String.class);
persion = (Persion)constructor.newInstance("zk", 12, '男', "高新区");
System.out.println(persion);
System.out.println("===============================");
//通过反射调用普通方法
Persion persion2 = (Persion) c1.newInstance();
Method setAddr = c1.getDeclaredMethod("setAddr", String.class);
//invoke:激活的意思
//（对象，"方法的值"）
setAddr.invoke(persion2,"未央区");
System.out.println(persion2.getAddr());
//通过反射调用属性
Persion persion3 = (Persion) c1.newInstance();
Field name = c1.getDeclaredField("name");
//不能直接操作私有属性，需要关闭程序的安全检查，属性或方法的setAccessible(true)
name.setAccessible(true);
name.set(persion3,"张三");
System.out.println(persion3.getName());

2.6 调用运行时类的指定结构

2.6.1 反向操作泛型：Java采用泛型擦出机制来引入泛型（约束机制），Java中的范型仅仅是给编译器Javac使用的确保数据的安全性和免去强制类型转换问题，但是一旦编译完成，所有和泛型相关的类型JVM-GC全部擦除

2.6.2 为了通过反射操作这些类型，Java新增了ParameterizedType,GenericArrayType,TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原类型齐名的类型。

  • ParameterizedType：表示一种参数化类型，比如Collection
  • GenericArrayType:标识一种元素类型是参数化类型或者类型变量的数组类型
  • TypeVariable：是各种类型变量的公共父接口
  • WildcardType：代表一种通配符类型表达式。
public static void main(String[] args) throws NoSuchMethodException {
    //获得参数泛型例子
    Method test01 = TestDemo06.class.getMethod("test01", Map.class, List.class);
    Type[] genericParameterTypes = test01.getGenericParameterTypes();
    for (Type genericParameterType : genericParameterTypes) {
        System.out.println(genericParameterType);
        if (genericParameterType instanceof ParameterizedType) {
            Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }
    System.out.println("");
    //获得返回值参数泛型的例子
    Method test02 = TestDemo06.class.getMethod("test02", null);
    Type genericReturnType = test02.getGenericReturnType();
    if (genericReturnType instanceof ParameterizedType) {
        Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
        for (Type actualTypeArgument : actualTypeArguments) {
            System.out.println(actualTypeArgument);
        }
    }
}
//获得参数泛型例子
public void test01(Map<String,Persion> map,List<String> list){
    System.out.println("获得参数泛型例子");
}
//获得返回值参数泛型的例子
public Map<String,Persion> test02(){
    System.out.println("获得返回值参数泛型的例子");
    return null;
}

2.6.3 获取操作注解

public class TestDemo07 {
    public static void main(String[] args) throws NoSuchFieldException {
        Class<People> peopleClass = People.class;
        //通过反射类获取注解
        Annotation[] annotations = peopleClass.getAnnotations();
        System.out.println(annotations);
        TableAnnotion annotation = peopleClass.getAnnotation(TableAnnotion.class);
        //通过反射获取类注解值
        System.out.println(annotation.value());

        //通过反射类获取字段注解
        Field name = peopleClass.getDeclaredField("sex");
        ColumnAnnotion annotation1 = name.getAnnotation(ColumnAnnotion.class);
        //通过反射类获取字段注解值
        System.out.println(annotation1.columnName());
        System.out.println(annotation1.type());
        System.out.println(annotation1.length());
    }

}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableAnnotion{
    String value();
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface ColumnAnnotion{
    String columnName();
    String type();
    int length();
}

@TableAnnotion("人们")
class People{
    @ColumnAnnotion(columnName = "name",type = "varchar",length = 50)
    private String name;
    @ColumnAnnotion(columnName = "age",type = "int",length = 5)
    private int age;
    @ColumnAnnotion(columnName = "sex",type = "char",length = 2)
    private char sex;

    public People() {
    }

    public People(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    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 char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

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

下一篇：java语法-04-JDK8新特性-函数式编程

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由半码博客整理，本文链接：https://www.bmabk.com/index.php/post/123978.html

赞 (0)
飞熊的头像飞熊bm
0 0

相关推荐

发表回复

登录后才能评论
半码博客——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！