（十）Spring之回顾反射机制

Spring学习目录

上一篇：（九）Spring之Bean的循环依赖问题

下一篇：（十一）手写简单的Spring框架

反射机制四要素

反射机制调用方法，一般涉及到4个要素：

• 调用哪个对象的
• 哪个方法
• 传什么参数
• 返回什么值

一般分为这几个步骤：

• 1.获取类
  通过forName方法，传一个类的全限定类名获取类

• 2.获取方法
  通过反射机制的getDeclaredMethod方法获取类的方法

	getDeclaredMethod：获取方法，两个参数
                String name参数：方法名
                Class<?>... parameterTypes：可变参数，一般传参数的Class类型。有多少个参数就必须写多少个参数。
1
2
3

• 3.实例化对象

通过getDeclaredConstructor获取构造方法，然后直接使用newInstance方法获取实例化对象，当然也可以直接使用newInstance方法调用类的构造订单，这个方法是过期了，但是现在也可以使用，当然直接使用的话是调用类的无参构造方法，要确保这个类有无参构造方法。如果不是直接使用，并且类有有参构造方法，当然有传参数。

            getDeclaredConstructor：获取构造方法，一个参数，一个返回值
                Class<?>... parameterTypes：可变参数，调用有参数构造方法时候
                return：返回，构造方法

                返回构造方法可以通过newInstance()调用。
1
2
3
4
5

• 4.调用方法
  通过invoke方法获取调用类的方法

            invoke：调用，两个参数，一个返回值
                Object obj：哪个对象
                Object... args：可变参数，传什么参数
                return：返回调用的返回值。
1
2
3
4

创建一个类，添加一些方法：

public class SomeService {
    public void doSome(){
        System.out.println("doSome()方法执行");
    }
    public String doSome(String s){
        System.out.println("doSome(String s)方法执行");
        return s;
    }
    public String doSome(String s,int i){
        System.out.println("doSome(String s,int i)方法执行");
        return s + i;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

通过反射机制调用类的方法：

public class ReflectTest {
    public static void main(String[] args) throws Exception {
        //1.获取类
        Class<?> clazz = Class.forName("com.review.reflect.SomeService");
        //2.获取方法
        Method doSome = clazz.getDeclaredMethod("doSome", String.class, int.class);
        //3.实例化对象
        
        //四要素：obj（哪个对象） doSome（哪个方法） "李四", 250（传什么参数） retValue（返回什么值）
        Constructor<?> declaredConstructor = clazz.getDeclaredConstructor();
        Object obj = declaredConstructor.newInstance();
        //4.调用方法
        Object retValue = doSome.invoke(obj, "李四", 250);
        System.out.println(retValue);

        Method doSome1 = clazz.getDeclaredMethod("doSome");
        Object retValue1 = doSome1.invoke(obj);
        System.out.println(retValue1);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Spring反射机制底层原理

需求：假设知道以下信息

• 1.知道类名：com.review.reflect.User
• 2.这个类是符合JavaBean规范，属性私有化，对外提供setter和getter方法。
• 3.知道一个属性名 age

使用反射机制调用相关方法，给User对象的age属性赋值。

分为几个步骤：

• 1.获取类
• 2.获取set方法名
• 3.获取属性类型
• 4.通过set方法名获取方法
• 5.准备对象
• 6.调用方法

User类：

public class User {
    private String name;
    private int age;

    public User() {
    }

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

实现程序：

public class UserTest {
    public static void main(String[] args) throws Exception {
        //知道的信息
        String className = "com.review.reflect.User";
        String propertyName = "age";

        //通过反射机制调用setAge()方法给属性赋值

        //1.获取类
        Class<?> clazz = Class.forName(className);
        //2.获取set方法名
        String setMethodName = "set" + propertyName.toUpperCase().charAt(0) + propertyName.substring(1);
        //3.获取属性类型
        Field field = clazz.getDeclaredField(propertyName);
        //4.通过set方法名获取方法
        Method setMethod = clazz.getDeclaredMethod(setMethodName, field.getType());
        //5.准备对象
        Object obj = clazz.newInstance();
        //6.调用方法
        setMethod.invoke(obj,20);

        System.out.println(obj);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25