学习目标:

熟悉类加载过程与类加载器
熟练掌握类加载时机
掌握如何获取字节码文件对象
掌握使用配置文件
掌握Class,Constructor,Field,Method使用
熟悉了解自定义类加载器与双亲委派模型(有能力的同学掌握)

类加载#

过程#

加载
- 通过类加载器(ClassLoader)加载.class文件,读取到内存
- 在这个过程中,生成这个类所对应的字节码文件对象(java.lang.Class)
链接
- 验证: 对字节码文件格式的验证(aced babe 咖啡宝贝魔法数字)
- 准备: 给类的静态成员分配内存并赋予默认初始值
  - 1 static int a =10;
- 解析: 把符号引(用一组符号来描述被引用的目标)用转化为直接引用(真实的地址)
class Student{ String name; int age; Subject subject;

}

class Subject{ String name; }
初始化
- 给静态成员赋真实的值, 并且执行静态代码块中的内容

类加载器#

分类#

Bootstrap ClassLoader 根/启动类加载器
- 负责Java运行时核心类的加载，JDK中JRE的lib目录下rt.jar
Extension ClassLoader 扩展类加载器(JDK9之后更替为Platform ClassLoader 平台类加载器: 负责加载JDK平台本身的类库，这些类库位于JDK的 lib 目录下非核心模块，但不包括核心的 java.*)
- 负责JRE的扩展目录中jar包的加载，在JDK中JRE的lib目录下ext目录
Application ClassLoader 系统类加载器/应用加载器
- 这是加载用户类路径（Classpath）上的类的类加载器，也是 Java 应用的默认类加载器。负责加载自己定义的Java类

1
package _23reflect.com.cskaoyan._01introduction;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/22 11:42
7
 **/
8

9
public class Demo {
10
    public static void main(String[] args) {
11
        // 查看类加载器
12
        // 系统类加载器
13
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
14
        System.out.println(systemClassLoader);
15

16
        // 扩展类加载器/平台类加载器
17
        ClassLoader parent = systemClassLoader.getParent();
18
        System.out.println(parent);
19

20
        // 根类加载器 null 不是java写的
21
        ClassLoader parent1 = parent.getParent();
22
        System.out.println(parent1);
23

24
        // 看一下加载路径
25
        System.out.println(System.getProperty("java.class.path")
26
                .replace(";", System.lineSeparator()));
27

28

29
    }
30
}

双亲委派模型#

什么是双亲委派#

双亲委派模型的工作过程是:

如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个加载请求(它的搜索范围中没有找到所需的类)时，子加载器才会尝试自己去加载。

双亲委派模型对于保证Java程序的稳定运作很重要，但它的实现却非常简单，实现双亲委派的代码都集中在java.lanq.ClassLoader的loadClass()方法之中

先检查类是否已经被加载过
若没有加载则调用父加载器的loadClass()方法，若父加载器为空则默认使用启动类加载器作为父加载器。
如果父类加载失败，抛出ClassNotFoundException异常后，再调用自己的findClass()方法进行加载。

为什么需要双亲委派#

使用双亲委派模型来组织类加载器之间的关系，有一个显而易见的好处就是Java类随着它的类加载器一起具备了一种带有优先级的层次关系。

例如类java.lang.Object，它存放在rt,jar之中，无论哪一个类加载器要加载这个类，最终都是委派给处于模型最顶端的启动类加载器进行加载，因此Obiect类在程序的各种类加载器环境中都是同一个类。

相反，如果没有使用双亲委派模型，由各个类加载器自行去加载的话，如果用户自己编写了一个称为java.lang.Object的类，并放在程序的ClassPath中，那系统中将会出现多个不同的Obiect类，Java类型体系中最基础的行为也就无法保证，应用程序也将会变得一片混乱

JDK1.8

类加载时机#

创建类的实例(首次创建该类对象)

访问类的静态变量(首次)

调用类的静态方法(首次)

加载某个类的子类，会先触发父类的加载

直接使用java.exe命令来运行某个主类，也就是执行了某个类的main()方法

使用反射方式来强制创建某个类或接口对应的java.lang.Class对象

java代码的3个阶段#

反射#

什么是反射#

获取运行时类信息的一种手段

反射的起点是字节码文件对象

获取字节码文件对象的几种方式#

对象.getClass()
类名.class
Class.forName(String className) 全限定名
ClassLoader里的loadClass(String className)

注意:

无论通过什么方式获取的字节码文件对象都是同一个

Demo

1
package _23reflect.com.cskaoyan._02cls;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/24 9:58
7
 **/
8
/*
9
获取字节码文件对象的几种方式
10
 */
11
public class Demo {
12
    public static void main(String[] args) throws ClassNotFoundException {
13
        // 对象.getClass
14
        A a = new A();
15
        Class<? extends A> c1 = a.getClass();
16

17
        // 类名.class
18
        Class<A> c2 = A.class;
19

20
        System.out.println(c1 == c2);
21

22
        // Class.forName(全限定名)
23
        Class<?> c3 = Class.forName("_23reflect.com.cskaoyan._02cls.A");
24

25
        System.out.println(c1 == c3);
26

27
        // ClassLoader.loadClass(String className)
28
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
29
        Class<?> c4 = systemClassLoader.loadClass("_23reflect.com.cskaoyan._02cls.A");
30
        System.out.println(c1 == c4);
31

32
    }
33
}
34

35
class A{
36

37
}

注意

1
package _23reflect.com.cskaoyan._02cls;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/24 10:08
7
 **/
8

9
public class Demo2 {
10
    public static void main(String[] args) throws ClassNotFoundException {
11
        // 类名.class
12
        // 没有执行静态代码块
13
        //Class<B> c1 = B.class;
14

15
        // Class.forName()
16
        // 执行静态代码块
17
        Class<?> c2 = Class.forName("_23reflect.com.cskaoyan._02cls.B");
18

19
    }
20
}
21

22
class B{
23
    static {
24
        System.out.println("静态代码块执行了!");
25
    }
26
}

关于Class#

Class 类的实例表示正在运行的 Java 应用程序中的类和接口

Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。

配置文件(.properties)#

配置文件的几种格式.properties .xml .yml

配置文件的作用: 放配置信息的 (数据库的, 第三方服务的配置信息)

.properties的格式键值对(key-value) key=value key是不能重复的

注释是# 文件里面全是String

获取配置信息

Properties类

Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。

构造方法

Properties() 创建一个无默认值的空属性列表。

成员方法

void	load(InputStream inStream) 从输入流中读取属性列表（键和元素对）。
void	load(Reader reader) 按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。

String	getProperty(String key) 用指定的键在此属性列表中搜索属性。

1
package _23reflect.com.cskaoyan._03config;
2

3
import java.io.FileInputStream;
4
import java.io.IOException;
5
import java.util.Properties;
6

7
/**
8
 * @description:
9
 * @author: 景天
10
 * @date: 2022/10/24 10:27
11
 **/
12

13
public class Demo {
14
    public static void main(String[] args) throws IOException {
15
        // 创建Properties对象
16
        Properties properties = new Properties();
17
        // load
18
        properties.load(new FileInputStream("config.properties"));
19

20
        // 获取属性值
21
        // getProperty(String key)
22
        String port = properties.getProperty("port");
23
        String user = properties.getProperty("user");
24
        String password = properties.getProperty("password");
25
        String host = properties.getProperty("host");
26
        System.out.println(port);
27
        System.out.println(password);
28
        System.out.println(user);
29
        System.out.println(host);
30

31
    }
32
}

1
package _23reflect.com.cskaoyan._03config;
2

3
import java.io.FileInputStream;
4
import java.io.IOException;
5
import java.io.InputStream;
6
import java.net.URL;
7
import java.util.Properties;
8

9
/**
10
 * @description:
11
 * @author: 景天
12
 * @date: 2022/10/24 10:27
13
 **/
14

15
public class Demo2 {
16
    public static void main(String[] args) throws IOException {
17
        // 创建Properties对象
18
        Properties properties = new Properties();
19

20
        // 通过类加载器
21
        URL systemResource = ClassLoader.getSystemResource("");
22
        System.out.println(systemResource);
23

24
        InputStream in = ClassLoader.getSystemResourceAsStream("config.properties");
25

26

27
        // load
28
        properties.load(in);
29

30
        // 获取属性值
31
        // getProperty(String key)
32
        String port = properties.getProperty("port");
33
        String user = properties.getProperty("user");
34
        String password = properties.getProperty("password");
35
        String host = properties.getProperty("host");
36
        System.out.println(port);
37
        System.out.println(password);
38
        System.out.println(user);
39
        System.out.println(host);
40

41

42

43
    }
44
}

有中文的情况

1
package _23reflect.com.cskaoyan._03config;
2

3
import java.io.FileInputStream;
4
import java.io.IOException;
5
import java.io.InputStreamReader;
6
import java.util.Properties;
7

8
/**
9
 * @description:
10
 * @author: 景天
11
 * @date: 2022/10/24 11:26
12
 **/
13

14
public class Demo3 {
15
    public static void main(String[] args) throws IOException {
16
        // 创建Properties对象
17
        Properties properties = new Properties();
18

19
        // load
20
        properties.load(
21
                new InputStreamReader(
22
                        new FileInputStream("config.properties"),"GBK"));
23

24
        // 获取属性
25
        String user = properties.getProperty("user");
26
        System.out.println(user);
27
    }
28
}

通过反射获取构造方法(Constructor)#

通过反射获取所有构造方法

1
Constructor[] getConstructors()
2
Constructor[] getDeclaredConstructors()

获取指定构造方法

1
Constructor<T> getConstructor(Class<?>... parameterTypes)
2
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)

使用Constructor创建对象

1
Person p = new Person("zs",20,true)
2
newInstance(参数列表)

暴力破解

1
setAccessible(true)

1
package _23reflect.com.cskaoyan._04api;
2

3
import java.lang.reflect.Constructor;
4
import java.lang.reflect.InvocationTargetException;
5

6
/**
7
 * @description:
8
 * @author: 景天
9
 * @date: 2022/10/24 11:34
10
 **/
11

12
public class ConstructorTest {
13
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
14
        // 反射技术的起点 获取字节码文件对象
15
        Class<?> stuCls = Class.forName("_23reflect.com.cskaoyan.bean.Person");
16

17
        System.out.println("获取所有的public的构造方法----");
18
        // Constructor[] getConstructors()
19
        Constructor<?>[] constructors = stuCls.getConstructors();
20
        for (Constructor<?> constructor : constructors) {
21
            System.out.println(constructor);
22
        }
23

24
        System.out.println("获取所有的构造方法----");
25

26
        //Constructor[] getDeclaredConstructors()
27
        Constructor<?>[] declaredConstructors = stuCls.getDeclaredConstructors();
28
        for (Constructor<?> constructor : declaredConstructors) {
29
            System.out.println(constructor);
30
        }
31
        System.out.println("获取指定的public的构造方法----");
32
        // Constructor<T> getConstructor(Class<?>... parameterTypes)
33
        Constructor<?> constructor = stuCls.getConstructor(String.class, int.class, boolean.class);
34
        //Constructor<?> constructor = stuCls.getConstructor(String.class, int.class);
35
        // java.lang.NoSuchMethodException
36

37

38
        System.out.println(constructor);
39
        System.out.println("获取指定的构造方法----");
40
        //Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
41
        Constructor<?> declaredConstructor = stuCls.getDeclaredConstructor(String.class, int.class);
42
        System.out.println(declaredConstructor);
43

44
        // 使用构造方法对象创建对象
45
        // newInstance
46
        Object o = constructor.newInstance("zs", 20, true);
47
        System.out.println(o);
48

49
        // java.lang.IllegalAccessException
50
        // setAccessible(true)  忽略java语法检查
51
        declaredConstructor.setAccessible(true);
52
        Object o1 = declaredConstructor.newInstance("ls", 21);
53
        System.out.println(o1);
54

55

56
    }
57
}

通过反射获取成员变量(Field)#

通过反射获取所有成员变量

1
Field[] getFields()
2
Field[] getDeclaredFields()

获取指定成员变量

1
Field getField(String name)
2
Field getDeclaredField(String name)

通过Field读写对象的成员变量(可暴力破解)

1
Object get(Object obj)：获取值，传入对象
2
void set(Object obj, Object value)：赋值，传入对象

1
package _23reflect.com.cskaoyan._04api;
2

3
import _23reflect.com.cskaoyan.bean.Person;
4

5
import java.lang.reflect.Constructor;
6
import java.lang.reflect.Field;
7

8
/**
9
 * @description:
10
 * @author: 景天
11
 * @date: 2022/10/24 14:25
12
 **/
13
/*
14
反射获取成员变量
15

16
 */
17
public class FieldTest {
18
    public static void main(String[] args) throws Exception{
19
        // 获取字节码文件对象
20
        Class<?> personCls = Class.forName("_23reflect.com.cskaoyan.bean.Person");
21
        System.out.println("获取所有的public的成员变量------");
22
        // Field[] getFields()
23
        Field[] fields = personCls.getFields();
24
        for (Field field : fields) {
25
            System.out.println(field);
26
        }
27
        System.out.println("获取所有的成员变量------");
28

29
        //Field[] getDeclaredFields()
30
        Field[] declaredFields = personCls.getDeclaredFields();
31
        for (Field field : declaredFields) {
32
            System.out.println(field);
33
        }
34
        System.out.println("获取指定的public的成员变量------");
35
        // Field getField(String name)
36
        Field nameField = personCls.getField("name");
37
        System.out.println(nameField);
38
        System.out.println("获取指定的成员变量------");
39

40
        //Field getDeclaredField(String name)
41
        Field ageField = personCls.getDeclaredField("age");
42
        System.out.println(ageField);
43

44
        // 给成员变量赋值 获取成员变量的值
45
        //void set(Object obj, Object value)：赋值，传入对象
46
        Constructor<?> declaredConstructor = personCls.getDeclaredConstructor();
47
        // 实例化对象
48
        Object o = declaredConstructor.newInstance();
49
        nameField.set(o, "zs");
50
        System.out.println(o);
51

52
        ageField.setAccessible(true);
53
        ageField.set(o, 22);
54
        System.out.println(o);
55
        // Object get(Object obj)：获取值，传入对象
56
        Object o1 = nameField.get(o);
57
        System.out.println(o1);
58
    }
59
}

通过反射获取方法(Method)#

获取所有成员方法

1
Method[] getMethods()// 父类的也能获取到
2
Method[] getDeclaredMethods()

获取指定的成员方法

1
Method getMethod(String name, Class<?>... parameterTypes)
2
Method getDeclaredMethod(String name, Class<?>... parameterTypes)

利用Method调用对象的方法

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

1
package _23reflect.com.cskaoyan._04api;
2

3
import _23reflect.com.cskaoyan.bean.Person;
4

5
import java.lang.reflect.Constructor;
6
import java.lang.reflect.Method;
7

8
/**
9
 * @description:
10
 * @author: 景天
11
 * @date: 2022/10/24 14:39
12
 **/
13
/*
14
通过反射获取方法
15
 */
16
public class MethodTest {
17
    public static void main(String[] args) throws Exception{
18
        // 获取字节码文件对象
19
        Class<?> personCls = Class.forName("_23reflect.com.cskaoyan.bean.Person");
20

21
        System.out.println("获取所有的public的方法----");
22
        // Method[] getMethods()
23
        Method[] methods = personCls.getMethods();
24
        for (Method method : methods) {
25
            System.out.println(method);
26
        }
27
        System.out.println("获取所有的方法----");
28

29
        //Method[] getDeclaredMethods()
30
        Method[] declaredMethods = personCls.getDeclaredMethods();
31
        for (Method method : declaredMethods) {
32
            System.out.println(method);
33
        }
34

35
        System.out.println("获取指定的public的方法----");
36
        // Method getMethod(String name, Class<?>... parameterTypes)
37
        Method eatMethod1 = personCls.getMethod("eat");
38
        System.out.println(eatMethod1);
39

40
        System.out.println("获取指定的方法----");
41

42
        //Method getDeclaredMethod(String name, Class<?>... parameterTypes)
43
        Method eatMethod2 = personCls.getDeclaredMethod("eat", String.class);
44
        System.out.println(eatMethod2);
45

46
        //Person p = new Person();
47
        //p.eat();
48

49
        // 反射调用方法
50
        // Object invoke(Object obj, Object... args)
51
        Constructor<?> declaredConstructor = personCls.getDeclaredConstructor();
52
        Object o = declaredConstructor.newInstance();
53
        Object invoke = eatMethod1.invoke(o);
54
        System.out.println(invoke);
55

56
        eatMethod2.setAccessible(true);
57
        eatMethod2.invoke(o, "apple");
58

59
    }
60
}

补充#

其他API#

可以通过Class直接实例化 , 但是要有一个无参构造方法

1
package _23reflect.com.cskaoyan._04api;
2

3
import java.lang.reflect.Constructor;
4

5
/**
6
 * @description:
7
 * @author: 景天
8
 * @date: 2022/10/24 11:48
9
 **/
10

11
public class Demo {
12
    public static void main(String[] args) throws Exception{
13
        Class<?> c = Class.forName("_23reflect.com.cskaoyan._04api.A");
14

15
        // 通过class对象直接实例化对象
16
        Object o = c.newInstance();
17
        System.out.println(o);
18
    }
19
}
20

21
class A {
22
    int a;
23

24
    public A(int a) {
25
        this.a = a;
26
    }
27

28
    public A() {
29
    }
30
}

其他API

1
package _23reflect.com.cskaoyan.bean;
2

3
/**
4
 * @description:
5
 * @author: 景天
6
 * @date: 2022/10/24 11:31
7
 **/
8

9
public class Person {
10
    // 定义成员变量
11
    public  String name;
12
    private int age;
13
    boolean gender;
14

15
    // 构造方法
16

17
    public Person(String name, int age, boolean gender) {
18
        this.name = name;
19
        this.age = age;
20
        this.gender = gender;
21
    }
22

23
    private Person(String name, int age) {
24
        this.name = name;
25
        this.age = age;
26
    }
27

28
    public Person() {
29
    }
30

31
    // 定义成员方法
32

33
    @Override
34
    public String toString() {
35
        return "Person{" +
36
                "name='" + name + '\'' +
37
                ", age=" + age +
38
                ", gender=" + gender +
39
                '}';
40
    }
41

42
    public String eat(){
43
        System.out.println("eat food!");
44
        return "吃了";
45
    }
46

47
    private void eat(String food){
48
        System.out.println("eat " + food);
49
    }
50
}
51

52

53
package _23reflect.com.cskaoyan._05add;
54

55
import java.lang.reflect.Field;
56
import java.lang.reflect.Method;
57
import java.lang.reflect.Modifier;
58

59
/**
60
 * @description:
61
 * @author: 景天
62
 * @date: 2022/10/24 14:57
63
 **/
64

65
public class OtherApi {
66
    public static void main(String[] args) throws Exception{
67
        // 获取字节码文件对象
68
        Class<?> c = Class.forName("_23reflect.com.cskaoyan.bean.Person");
69
        //Class<?> c = Class.forName("java.io.OutputStream");
70
        // 获取全限定类名
71
        System.out.println(c.getName());
72
        // 获取简单名称
73
        System.out.println("c.getSimpleName() = " + c.getSimpleName());
74
        // 获取父类
75
        Class<?> superclass = c.getSuperclass();
76
        System.out.println("superclass = " + superclass.getSimpleName());
77

78
        // 获取实现的接口
79
        Class<?>[] interfaces = c.getInterfaces();
80
        for (Class<?> i : interfaces) {
81
            System.out.println(i);
82
        }
83
        // 获取类加载器
84
        ClassLoader classLoader = c.getClassLoader();
85
        System.out.println("classLoader = " + classLoader);
86

87
        // 获取name这个成员变量对象
88
        Field nameField = c.getDeclaredField("name");
89
        // 获取权限修饰符
90
        int modifiers = nameField.getModifiers();
91
        System.out.println(modifiers);
92
        // static String toString(int mod)
93
        // 返回描述指定修饰符中的访问修饰符标志的字符串。
94
        String s = Modifier.toString(modifiers);
95
        System.out.println("s = " + s);
96

97
        // 获取eat(String s)方法对象
98
        Method eatMethod = c.getDeclaredMethod("eat", String.class);
99
        Class<?> returnType = eatMethod.getReturnType();
100
        System.out.println("returnType = " + returnType);
101
        Class<?>[] parameterTypes = eatMethod.getParameterTypes();
102
        for (Class<?> parameterType : parameterTypes) {
103
            System.out.println(parameterType.getSimpleName());
104
        }
105
    }
106
}

反射应用场景#

通过反射获取注解信息

动态代理

ORM(Object Relational Mapping)框架, 数据库框架

类加载#

过程#

类加载器#

分类#

双亲委派模型#

什么是双亲委派#

为什么需要双亲委派#

类加载时机#

java代码的3个阶段#

反射#

什么是反射#

获取字节码文件对象的几种方式#

关于Class#

配置文件(.properties)#

通过反射获取构造方法(Constructor)#

通过反射获取成员变量(Field)#

通过反射获取方法(Method)#

补充#

其他API#

反射应用场景#

文章分享

文章目录

Java 基础语法：反射

类加载#

过程#

类加载器#

分类#

双亲委派模型#

什么是双亲委派#

为什么需要双亲委派#

类加载时机#

java代码的3个阶段#

反射#

什么是反射#

获取字节码文件对象的几种方式#

关于Class#

配置文件(.properties)#

通过反射获取构造方法(Constructor)#

通过反射获取成员变量(Field)#

通过反射获取方法(Method)#

补充#

其他API#

反射应用场景#

文章分享

文章目录