12000+字Java反射,一起全面了解Java反射机制,为学习框架铺路

简介: 12000+字Java反射,一起全面了解Java反射机制,为学习框架铺路

文章目录


Java反射机制

理解Class类

获取Class类实例

类的加载过程

类加载器ClassLoader

创建运行时类的对象

获取运行时类的结构

调用运行时类的指定结构

动态代理


Java反射机制


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


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


程序经过javac.exe命令以后,会生成一个或多个字节码文件(.class结尾)。接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件

加载到内存中。此过程就称为类的加载。加载到内存中的类,我们就称为运行时类,此运行时类,就作为CLass的一个实例。换句话说,Class 的实例就对应着一个运行时类。


7abf45925afb4180b55d6e23e19f9fdf.png


Java反射机制提供的功能:


eb795adc0f9144e09601be9eb17b7ac3.png


反射相关的主要API:


dad8ef583e1d41568b29cd91d9a9a491.png


理解Class类


在Object类中定义了以下的方法,此方法将被所有子类继承:


public final Class getClass()


以上的方法返回值的类型是一个Class类,此类是Java反射的源头,实际上所谓反射从程序的运行结果来看也很好理解,即:可以通过对象反射求出所属类。


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

①Class 本身也是一个类。

②Class 对象只能由系统建立对象。

③一个加载的类在 JVM 中只会有一个Class实例。

④一个Class对象对应的是一个加载到JVM中的一个.class文件。

⑤通过Class可以完整地得到一个类中的所有被加载的结构。

⑥Class类是Reflection的根源,针对任何想动态加载、运行的类,唯有先获得相应的Class对象。


a07c2de5bbf5493587ef14d76906cb9c.png


获取Class类实例

加载到内存中的运行时类, 会缓存一 定的时间。在此时间之内,我们可以通过不同的方式来获取此运行时类。


import com.atyeman.java.Person;
/**
 * @Author: Yeman
 * @Date: 2021-09-29-22:39
 * @Description:
 */
public class ClassTest {
    public static void main(String[] args) throws ClassNotFoundException {
        //方式一:调用运行时类的属性:.class
        Class clazz1 = Person.class;
        System.out.println(clazz1);
        //方式二:通过运行时类的对象调用getClass()
        Person p2 = new Person();
        Class clazz2 = p2.getClass();
        System.out.println(clazz2);
        //方式三:调用Class的静态方法:forName(String,classPath)
        Class clazz3 = Class.forName("com.atyeman.java.Person");
        System.out.println(clazz3);
        //方式四:使用类的加载器ClassLoader
        ClassLoader classLoader = ClassTest.class.getClassLoader();
        Class clazz4 = classLoader.loadClass("com.atyeman.java.Person");
        System.out.println(clazz4);
        //比较,true则为同一个运行时类,也证明了就加载了一个而已
        System.out.println(clazz1 == clazz2 && clazz2 == clazz3 && clazz3==clazz4);
    }
}


78ed43d819ec4aea8b70adc2c584b8ad.png


哪些类型可以有Class对象?

①class:外部类,成员(成员内部类,静态内部类),局部内部类,匿名内部类

②interface:接口

③[]:数组

④enum:枚举

⑤annotation:注解@interface

⑥primitive type:基本数据类型

⑦void


Class c1 = Object.class;
Class c2 = Comparable.class;
Class c3 = String[].class;
Class c4 = int[][].class;
Class c5 = ElementType.class;
Class c6 = Override.class;
Class c7 = int.class;
Class c8 = void.class;
Class c9 = Class.class;
int[] a = new int[10];
int[] b = new int[100];
Class c10 = a.getClass();
Class c11 = b.getClass();
// 只要元素类型与维度一样,就是同一个Class
System.out.println(c10 == c11); //true


类的加载过程


当程序主动使用某个类时,如果该类还未被加载到内存中,则系统会通过如下三个步骤来对该类进行初始化。


2a7db7a18c95483cb681b25caece1acf.png


加载:将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构,然后生成一个代表这个类的java.lang.Class对象,作为方法区中类数据的访问入口(即引用地址)。所有需要访问和使用类数据只能通过该Class对象。这个加载的过程需要类加载器参与。


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


验证:确保加载类信息符合JVM规范,例如:以cafe开头,没有安全方面的问题。


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


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


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


public class ClassLoadingTest {
  public static void main(String[] args) {
  System.out.println(A.m);
  }
}
class A {
  static {
  m = 300;
  }
  static int m = 100;
}
//第二步:链接结束后m=0
//第三步:初始化后,m的值由<clinit>()方法执行决定
// 这个A的类构造器<clinit>()方法由类变量的赋值和静态代码块中的语句按照顺序合并产生,相当于
// <clinit>(){
// m = 300;
// m = 100;
// }


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

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

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

②new一个类的对象

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

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

⑤当初始化一个类,如果其父类没有被初始化,则先会初始化它的父类

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

①当访问一个静态域时,只有真正声明这个域的类才会被初始化

②当通过子类引用父类的静态变量,不会导致子类初始化

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

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


类加载器ClassLoader


74f7609422444879a156ceb124529706.png



类加载器的作用:

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

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


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


a4c3d1fbc6964cff9ff2e950c2d6788c.png


/**
 * @Author: Yeman
 * @Date: 2021-09-29-22:39
 * @Description:
 */
public class ClassTest {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.获取一个系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);
        //2.获取系统类加载器的父类加载器,即扩展类加载器
        ClassLoader parent1 = systemClassLoader.getParent();
        System.out.println(parent1);
        //3.获取扩展类加载器的父类加载器,即引导类加载器
        ClassLoader parent2 = parent1.getParent();
        System.out.println(parent2);
        //4.测试当前类由哪个类加载器进行加载
        Class<?> aClass = Class.forName("com.atyeman.java.Person");
        ClassLoader classLoader = aClass.getClassLoader();
        System.out.println(classLoader);
        //5.测试JDK提供的Object类由哪个类加载器加载
        ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader1); //null则表示是引导类加载器,无法被获取到
    }
}


import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
/**
 * @Author: Yeman
 * @Date: 2021-09-29-22:39
 * @Description:
 */
public class ClassTest {
    public static void main(String[] args) throws IOException {
        Properties pros = new Properties();
        //读取配置文件方式一
//        FileInputStream fis = new FileInputStream("ClassTest\\jdbc.properties");
//        pros.load(fis);
        //读取配置文件方式二,使用ClassLoader
        ClassLoader classLoader = ClassTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
        pros.load(is);
        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        System.out.println(user + password);
    }
}


创建运行时类的对象


public class NewInstanceTest {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        Class<Person> pc = Person.class;
        Person person = pc.newInstance();
        System.out.println(person);
    }
}


.

调用newInstance ()方法,创建对应的运行时类的对象。内部调用了运行时类的空参的构造器。


调用newInstance()方法正常地创建运行时类的对象,要求:

①运行时类必须提供空参的构造器

②空参的构造器的访问权限通常为public


在javabean中要求提供一个public的空参构造器。 原因:

①通过反射创建运行时类的对象

②子类继承此运行时类时,默认调用super()时,保证父类有此构造器


获取运行时类的结构


1、获取属性结构

public Field[] getFields():此Class及其父类、接口中声明为public的属性

public Field[] getDeclaredFields():此Class中声明的所有属性

Field方法中:

public int getModifiers():以整数形式返回此Field的修饰符,可以使用Modifier.toString(int modifier)还原

public Class<?> getType():得到Field的属性类型

public String getName():返回Field的名称


2、获取方法结构

public Method[] getMethods():此Class及其父类、接口中声明为public的方法

public Method[] getDeclaredMethods():此Class中声明的所有方法

Method类中:

public Class<?> getReturnType():取得全部的返回值

public Class<?>[] getParameterTypes():取得全部的参数

public int getModifiers():取得修饰符

public Class<?>[] getExceptionTypes():取得异常信息


3、获取构造器

public Constructor<T>[] getConstructors():此Class中声明为public的构造器

public Constructor<T>[] getDeclaredConstructors():此Class中所有构造器

Constructor类中:

取得修饰符::public int getModifiers()

取得方法名称: public String getName()

取得参数的类型:public Class<?>[] getParameterTypes()


4、其他

public Class<?>[] getInterfaces():此Class实现的所有接口

public Class<? Super T> getSuperclass():此Class的父类

Type getGenericSuperclass():此Class带泛型的父类

get Annotation(Class<T> annotationClass):此结构的注解

ParameterizedType:此Class的泛型类型

Package getPackage():此Class所在的包


调用运行时类的指定结构


1、调用指定属性

在反射机制中,可以直接通过Field类操作类中的属性,通过Field类提供的set()和

get()方法就可以完成设置和取得属性内容的操作。

public Field getField(String name):返回此Class对象表示的类或接口的指定的public的Field。(不通用,不常用)

public Field getDeclaredField(String name):返回此Class对象表示的类或接口的指定的Field。

在Field中:

public Object get(Object obj):取得指定对象obj上此Field的属性内容

public void set(Object obj,Object value):设置指定对象obj上此Field的属性内容


import java.lang.reflect.Field;
/**
 * @Author: Yeman
 * @Date: 2021-10-02-22:18
 * @Description:
 */
public class ReflectionTest {
    public static void main(String[] args) throws Exception {
        Class<Person> personClass = Person.class;
        Person person = personClass.newInstance();
        //获取指定的属性
        Field name = personClass.getDeclaredField("name"); //获取指定属性
        name.setAccessible(true); //非public的需要先进行此步,保证当前属性可以访问
        name.set(person,"叶绿体"); //设置,第一个参数是哪个对象,第二个参数是值
        String pName = (String) name.get(person); //获取,参数为哪个对象
        System.out.println(pName);
    }
}


2、调用指定方法

通过反射,调用类中的方法,通过Method类完成。步骤:

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

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


import java.lang.reflect.Method;
/**
 * @Author: Yeman
 * @Date: 2021-10-02-22:18
 * @Description:
 */
public class ReflectionTest {
    public static void main(String[] args) throws Exception {
        Class<Person> personClass = Person.class;
        Person person = personClass.newInstance();
        //获取指定的方法,第一个参数为哪个方法,后面参数为形参列表
        Method show = personClass.getDeclaredMethod("show", String.class);
        //设置可以被访问
        show.setAccessible(true);
        //进行具体使用操作invoke()方法,返回值同原方法一致
        //第一个参数为哪个对象,后面参数为传递的实参
        String nation = (String) show.invoke(person, "中国");
        System.out.println(nation);
    }
}


3、调用指定构造器(不常用)

与属性和方法类似。


动态代理


使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。静态代理特征是代理类和目标对象的类都是在编译期间确定下来,不利于程序的扩展。同时,每一个代理类只能为一个接口服务,这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能。


动态代理是指客户通过代理类来调用其它对象的方法,并且是在程序运行时根据需要动态创建目标类的代理对象。


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 * @Author: Yeman
 * @Date: 2021-10-03-19:33
 * @Description:
 */
interface Human {
    String getBelief();
    void eat(String food);
}
//某被代理类
class superMan implements Human {
    @Override
    public String getBelief() {
        return "I believe the light!";
    }
    @Override
    public void eat(String food) {
        System.out.println("吃" + food);
    }
}
//动态代理类
class ProxyFactory {
    //调用此方法,返回一个代理类的对象
    public static Object getProxyInstance(Object obj){ //obj即为被代理类
        MyInvocationHandle handle = new MyInvocationHandle();
        handle.bind(obj); //将被代理类告知
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),handle);
    }
}
//用来实现调用代理类对象的方法时候调用对应的被代理类对象中的同名同参方法
class MyInvocationHandle implements InvocationHandler {
    private Object obj; //被代理类的对象
    public void bind(Object obj){
        this.obj = obj;
    }
    //当代理类的对象调用方法a时,就会自动地调用如下的方法
    //将被代理类要执行的方法a的功能声明在invoke()中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //method:即为代理类对象调用的方法,此方法也就作为了被代理类对象调用的方法
        //obj:被代理类的对象
        return method.invoke(obj,args);
    }
}
public class ProxyTest {
    public static void main(String[] args) {
        superMan superMan = new superMan();
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan); //代理类对象
        String belief = proxyInstance.getBelief(); //当代理类对象调用方法时,调用的是被代理里中同名同参方法
        System.out.println(belief);
        proxyInstance.eat("火锅");
    }
}


Proxy :专门完成代理的操作类,是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类。


提供用于创建动态代理类和动态代理对象的静态方法:


eadcb98fe2d9459f9d1c69fec32881fb.png


动态代理步骤:


dda358853fdb4f7e80235640ed4d9d25.png541340a55ed94964befa01bd382f140e.pngedce280bfc6f43708a4dda5cae5da074.png1a75a60e74a74813990fdb27ef19cb14.png






相关文章
|
5天前
|
存储 Java 容器
Java一分钟之-高级集合框架:LinkedList与TreeSet
【5月更文挑战第17天】这篇博客对比了Java集合框架中的LinkedList和TreeSet。LinkedList是双向链表,适合中间插入删除,但遍历效率低且占用空间大;TreeSet基于红黑树,保证元素有序且不重复,插入删除速度较LinkedList慢但查找快。选择时需根据操作需求和性能考虑。
14 2
|
6天前
|
缓存 安全 Java
7张图带你轻松理解Java 线程安全,java缓存机制面试
7张图带你轻松理解Java 线程安全,java缓存机制面试
|
1天前
|
并行计算 安全 算法
探索Java并发编程:Fork/Join框架的应用与优化
在多核处理器普及的今天,并发编程已经成为提高程序性能的重要手段。Java提供了多种并发工具,其中Fork/Join框架是处理分治任务的强大工具。本文将深入探讨Fork/Join框架的核心原理、使用场景以及性能优化技巧,帮助开发者更好地利用这一框架解决实际问题。通过实例分析,我们将看到如何有效地使用Fork/Join框架来加速计算密集型任务,并提供一系列最佳实践,以确保高效和线程安全的并发执行。
|
1天前
|
存储 Java 容器
Java一分钟之-高级集合框架:LinkedList与TreeSet
【5月更文挑战第21天】本文对比了Java集合框架中的LinkedList和TreeSet。LinkedList是双向链表,实现List接口,适合中间插入删除,但遍历效率低;TreeSet基于红黑树,实现Set接口,保证元素有序且无重复,插入删除速度较LinkedList慢,但查找排序快。选择时应根据具体需求考虑操作频率和排序需求。
12 1
|
4天前
|
安全 Java 容器
Java一分钟之-高级集合框架:并发集合(Collections.synchronizedXXX)
【5月更文挑战第18天】Java集合框架的`Collections.synchronizedXXX`方法可将普通集合转为线程安全,但使用时需注意常见问题和易错点。错误的同步范围(仅同步单个操作而非迭代)可能导致并发修改异常;错误地同步整个集合类可能引起死锁;并发遍历和修改集合需使用`Iterator`避免`ConcurrentModificationException`。示例代码展示了正确使用同步集合的方法。在复杂并发场景下,推荐使用`java.util.concurrent`包中的并发集合以提高性能。
17 3
|
4天前
|
Java 开发者
Java一分钟之-高级集合框架:优先队列(PriorityQueue)
【5月更文挑战第18天】`PriorityQueue`是Java集合框架中的无界优先队列,基于堆数据结构实现,保证队头元素总是最小。常见操作包括`add(E e)`、`offer(E e)`、`poll()`和`peek()`。元素排序遵循自然排序或自定义`Comparator`。常见问题包括错误的排序逻辑、可变对象排序属性修改和混淆`poll()`与`peek()`。示例展示了自然排序和使用`Comparator`的排序方式。正确理解和使用`PriorityQueue`能提升应用性能。
37 6
|
4天前
|
存储 Java
Java一分钟之-高级集合框架:Queue与Deque接口
【5月更文挑战第18天】本文探讨Java集合框架中的`Queue`和`Deque`接口,两者都是元素序列的数据结构。`Queue`遵循FIFO原则,主要操作有`add/remove/element/peek`,空队列操作会抛出`NoSuchElementException`。`Deque`扩展`Queue`,支持首尾插入删除,同样需注意空`Deque`操作。理解并正确使用这两个接口,结合具体需求选择合适数据结构,能提升代码效率和可维护性。
29 4
|
5天前
|
安全 Java API
JAVA-不安全的反射--RCE
JAVA不安全的反射造成的RCE小案例
|
5天前
|
NoSQL 算法 Java
【redis源码学习】持久化机制,java程序员面试算法宝典pdf
【redis源码学习】持久化机制,java程序员面试算法宝典pdf
|
7天前
|
存储 安全 Java
24、使用 Java 官方教程学习:① 类变量和类方法详解;② 深入介绍 main() 方法
24、使用 Java 官方教程学习:① 类变量和类方法详解;② 深入介绍 main() 方法
42 1