SuifengFlying

公告

欢迎来到我的博客，这里记录生活与技术。

了解更多

1310 字

7 分钟

Java反射机制

2026-07-28

JavaSE

Java

/

JavaSE

/

反射

Java反射机制#

反射的概念#

在运行时加载、探知、使用编译期间完全未知的classes

加载类#

Class类#

所有加载的类也是一个对象，这些对象共有的行为特征抽象为Class类，加载的类就是一个一个的Class对象

如何获得Class对象#

Class.forName(“包名.类型”) ：

1
 //获得Person类的类对象
2
 try {
3
    Class cls = Class.forName("com.hyxy.Person");
4
 } catch (ClassNotFoundException e) {
5
    e.printStackTrace();
6
 }

使用场景：编译环境中没有Person类时

类名.class ：编译的字节码文件中，默认有一个静态的class属性，存储了这个类的对象

1
 //获得Person类的类对象
2
 Class cls = Person.class;

使用场景：编译环境中有Person类，最直接的方式

对象.getClass方法

1
 //获得Person类的类对象
2
 Person p = new Person();
3
 Class cls = p.getClass();

使用场景：编译环境中有类，现在持有一个对象，但是不知道这个对象的类型，要获得这个对象的类对象

1
 public static void method(Object obj){
2
    //获得参数obj的类对象
3
    Class cls = obj.getClass();
4
 }

Class类的方法#

getName方法 : 包名+类名
getSimpleName方法：获取类名
newInstance方法：创建类对象对应类的对象，这个方法实质还是调用了类无参构造器，已过时（后续要获得构造器对象来创建对象）
getDeclaredField(String name) ：通过名字获得属性对象
getDeclaredFields : 获得所有属性，得到的是属性数组（Field[]）
getDeclaredMethod(String methodName,Class … parameterType) : 通过方法名和参数类型列表获得一个方法对象
getDeclaredConstructor(Class … parameterType) : 通过参数类型列表获得一个构造器

Field类#

每个Field对象就是类中的某个属性的实例，Field对象中包含属性名、属性类型、属性值的属性

对属性的操作包括：对象属性的赋值和取值操作

方法：

设置属性可访问： setAccessable
设置对象的属性值： set(Object obj,Object value)
获取对象的属性值： get(Object obj)

实例：获取学生类的姓名、年龄、序号三个属性对象，对某个学生对象的三个属性复制、获取某个学生对象的三个属性值

1
 package com.hyxy;
2
 import java.lang.reflect.Field;
3
 public class Test {
4
    public static void main(String[] args) {
5
        try {
6
            //Student的类对象
7
            Class stuCls = Class.forName("com.hyxy.Student");
8
            //创建一个Student对象
9
            Object obj = stuCls.newInstance();
10
            //通过属性名获取三个属性对象
11
            Field fleld1 = stuCls.getDeclaredField("name");
12
            Field fleld2 = stuCls.getDeclaredField("age");
13
            Field fleld3 = stuCls.getDeclaredField("no");
14
            //设置这个属性是可访问
15
            fleld1.setAccessible(true);
16
            //为obj对象（Student对象）的name属性赋值为tom
17
            fleld1.set(obj,"tom");
18
            System.out.println(fleld1.get(obj));
19
        } catch (ClassNotFoundException e) {
20
            e.printStackTrace();
21
        } catch (NoSuchFieldException e) {
22
            e.printStackTrace();
23
        } catch (IllegalAccessException e) {
24
            e.printStackTrace();
25
        } catch (InstantiationException e) {
26
            e.printStackTrace();
27
        }
28
    }
29
}

Method类#

每个对象代表了类中一个一个方法实例，对方法的操作主要是执行方法

方法：

invoke方法：执行方法，需要传入实参

1
 public class Test {
2
    public static void main(String[] args) {
3
        try {
4
            //Student的类对象
5
            Class stuCls = Class.forName("com.hyxy.Student");
6
            //创建一个Student对象
7
            Object obj = stuCls.newInstance();
8
            //获得student对象的study()方法
9
            Method method1 = stuCls.getDeclaredMethod("study");
10
            //获得student对象的study(String lession,int time)方法
11
            Method method2 = stuCls.getDeclaredMethod("study",String.class,int.class);
12
            //获得student对象的study(int time,String lession)方法
13
            Method method3 = stuCls.getDeclaredMethod("study",int.class,String.class);
14
            //执行method1方法
15
            method1.invoke(obj);
16
            //执行method2方法，传入的字符串是"abc"，传入的时间是24
17
            method2.invoke(obj,"abc",24);
18
        } catch (ClassNotFoundException e) {
19
            e.printStackTrace();
20
        }  catch (IllegalAccessException e) {
21
            e.printStackTrace();
22
        } catch (InstantiationException e) {
23
            e.printStackTrace();
24
        } catch (NoSuchMethodException e) {
25
            e.printStackTrace();
26
        } catch (InvocationTargetException e) {
27
            e.printStackTrace();
28
        }
29
    }
30
 }

Constructor构造器#

方法：

newInstance方法：调用构造器创建对象，需要传入实参

实例：

1
 public class Test {
2
    public static void main(String[] args) {
3
        try {
4
            //Student的类对象
5
            Class stuCls = Class.forName("com.hyxy.Student");
6
            //获得构造器
7
            Constructor constructor = stuCls.getDeclaredConstructor(String.class,int.class,int.class);
8
            Object obj = constructor.newInstance("tom",20,110011);
9
            Student student = (Student)obj;
10
            System.out.println(student.getName()+","+student.getAge()+","+student.getNo());
11
        } catch (ClassNotFoundException e) {
12
            e.printStackTrace();
13
        }  catch (IllegalAccessException e) {
14
            e.printStackTrace();
15
        } catch (InstantiationException e) {
16
            e.printStackTrace();
17
        } catch (NoSuchMethodException e) {
18
            e.printStackTrace();
19
        } catch (InvocationTargetException e) {
20
            e.printStackTrace();
21
        }
22
    }
23
 }

反射实现通用DAO的二层封装#

DAO的二层封装：每个表都要写一个对应的DAO，原因是每个表的SQL语句是不同的，那么通过反射技术，将VO对象的类名作为表名、属性名作为列表，就可以动态的拼出每个表的SQL语句了，通过反射就可以用一个DAO实现SQL语句的封装，在通用DAO中要完成的事情：

获得VO参数的类对象
获得VO参数对象的类名和所有属性名
拼写SQL语句
使用JDBC执行SQL语句

实现DAO：

1
 package com.hyxy.dao;
2
 import com.hyxy.vo.T_User;
3
 import org.apache.commons.dbutils.QueryRunner;
4
import java.lang.reflect.Field;
5
import java.sql.Connection;
6
import java.sql.SQLException;
7
import java.util.ArrayList;
8
import java.util.List;
9
import java.util.Map;
10
public class CommonDao {
11
    public int insert(Object obj,String pkName,boolean isAutoIncre){
12
        Class cls = obj.getClass();
13
        //类名作为表名
14
        String tableName = cls.getSimpleName();
15
        String columnJoinStr = "";
16
        String wenhaoJoinStr = "";
17
        Field[] flelds = cls.getDeclaredFields();
18
        List<String> columnNameList = new ArrayList<>();
19
        List<String> wenhaoList = new ArrayList<>();
20
        List<Object> valueList = new ArrayList<>();
21
        String[] names = new String[columnNameList.size()];
22
        for(Field fleld:flelds){
23
            fleld.setAccessible(true);
24
            columnNameList.add(fleld.getName());
25
            if(fleld.getName().equals(pkName)&&isAutoIncre){
26
                wenhaoList.add("default");
27
            }else{
28
                wenhaoList.add("?");
29
                try {
30
                    valueList.add(fleld.get(obj));
31
                } catch (IllegalAccessException e) {
32
                    e.printStackTrace();
33
                }
34
            }
35
        }
36
        columnJoinStr = String.join(",",columnNameList.toArray(names));
37
        wenhaoJoinStr = String.join(",",wenhaoList.toArray(new String[wenhaoList.size()]));
38
        String sql = "insert into "+tableName+"("+columnJoinStr+") " +
39
                "values("+wenhaoJoinStr+")";
40
        System.out.println(sql);
41
        Connection conn = DBUtil.getConnection();
42
        QueryRunner queryRunner = new QueryRunner();
43
        int result = 0;
44
        try {
45
            result = queryRunner.execute(conn,sql,valueList.toArray());
46
        } catch (SQLException e) {
47
            e.printStackTrace();
48
        }
49
        return result;
50
    }
51
    public int update(Object obj,String pkName){
52
        return 0;
53
    }
54
    public int delete(Class cls,String pkName,Object pkValue){
55
        return 0;
56
    }
57
    public Object queryById(Class cls,String pkName,Object pkValue){
58
        return null;
59
    }
60
    public List<Object> query(Class cls, Map<String,Object> map){
61
        return null;
62
    }
63
    public static void main(String[] args) {
64
        CommonDao commonDao = new CommonDao();
65
        T_User user = new T_User();
66
        user.setUsername("test123");
67
        user.setPwd("123456");
68
        user.setEmail("4324342@qq.com");
69
        commonDao.insert(user,"id",true);
70
    }
71
}

Java反射机制

https://mizuki.mysqil.com/posts/4反射/

作者

SuifengFlying

发布于

2026-07-28

许可协议

CC BY-NC-SA 4.0

MySQL基础

4 / 5

JDBC Java注解

欢迎来到 SuifengFlying!