admin 管理员组

文章数量: 1086866

【JavaLearn】#（19）反射、Class类、使用反射创建对象

1. 反射

1.1 反射引入

• 编译时，知道类或对象的具体信息，此时直接对类和对象进行操作即可

• 编译时不知道类或对象的具体信息，只有运行时知道，需要使用反射来实现

    	==> 比如驱动的类的名称放在 XML 文件中，属性和属性值也放在XML文件中，需要在运行时读取XML文件，动态获取类的信息
  

// 编码、编译时知道要创建哪个类的对象
Dog dog = new Dog();   // 创建对象
dog.age = 12;          // 操作属性
dog.eat();             // 执行方法// 编译时不知道类或对象的具体信息，只有`运行时`知道
String className = "com.lwclick.demo.Dog";
Class aClass = Class.forName(className);
// 使用反射创建对象，相当于  new Dog();
aClass.getConstructor().newInstance();

反射的作用：

• 动态创建对象
• 动态操作属性
• 动态调用方法

在JDK中，由以下类来实现 Java 的反射机制，都位于 java.lang.reflect 包中

• Class类：代表一个类
• Constructor类：代表类的构造方法
• Field类：类的成员变量
• Method类：类的成员方法

1.2 反射的入口—Class类

• Class类是Java反射机制的起源和入口
  • 继承自 Object 类
  • 存放类的结构信息
• 是所有类的共同的图纸
  • 所有的类都有类名、属性、方法、构造方法、包、父类、父接口等
• Class类的对象称为类对象

2. 认识 Class 类

// 获取一个类的类对象：Class信息（结构信息）
Class aClass = Class.forName("com.lwclick.java.Dog");// 从类对象中获取具体的结构信息：get
// 1. 获取最基本的信息=================【类信息】
System.out.println(aClass.getName());  // 全限定类名
System.out.println(aClass.getSimpleName());  // 类名
System.out.println(aClass.getSuperclass());  // 父类的类对象  class com.lwclick.java.Animal
System.out.println(Arrays.toString(aClass.getInterfaces()));// 2. 获取============================【成员变量】
Field[] fields = aClass.getFields(); // 获取所有的 public 属性，包括上级的
Field[] declaredFields = aClass.getDeclaredFields(); // 获取本类中，所有的属性（私有的也可获取）Field field = aClass.getField("nickName");  // public java.lang.String com.lwclick.java.Animal.nickName
Field declaredField = aClass.getDeclaredField("type");  // 获取本类中的，私有的属性// 3. 获取============================【成员方法】
Method[] methods = aClass.getMethods();  // 所有公共的
Method[] declaredMethods = aClass.getDeclaredMethods();  // 获取本类中，所有的方法
for (Method m : declaredMethods) {String methodName = m.getName();  // 方法名Class returnType = m.getReturnType();  // 返回值类型Class[] parameterTypes = m.getParameterTypes();   // 参数类型
}Method method = aClass.getMethod("guard");
Method method = aClass.getMethod("shout", String.class);  // 参数列表可变// 4. 获取============================【构造方法】
Constructor[] constructors = aClass.getConstructors(); // 获取【本类】中，所有public的构造方法
Constructor[] declaredConstructors = aClass.getDeclaredConstructors();   获取【本类】中，所有的构造方法Constructor constructor = aClass.getConstructor();  // 获取无参构造方法
Constructor declaredConstructor = aClass.getDeclaredConstructor(String.class, Integer.class);  // 获取有参构造方法

Class类的常用方法：

获取一个类的类对象方法：

• Class.forName(类的完整路径字符串) 【当编码时还不知道要操作的具体类，只能使用Class.forName()】
• 类名.class 【已经知道了要操作的类】
• 对象名.getClass() 【已经知道了要操作的类】

3. 使用反射创建对象

使用反射调用无参构造方法，创建对象

• 使用 Constructor 的 newInstance() 方法
• 使用 Class 的 newInstance() 方法

// 不使用反射
Dog dog = new Dog();// =======================================================================// 使用反射创建
// 1. 获取类的完整路径字符串（Properties、DOM4J等）
String className = "com.lwclick.domain.Dog";// 2. 根据完整路径字符串获取类的类对象
Class aClass = Class.forName(className);// 3. 从类对象中获取无参构造方法
Constructor constructor = aClass.getConstructor();// 4. 【使用反射创建对象】
Object o = constructor.newInstance();// 当为无参构造方式时，3  4步也可以合并为一步操作
Object o1 = aClass.newInstance();

使用反射调用有参构造方法，创建对象

• 只能使用 Constructor 的 newInstance(参数列表) 方法

// 不使用反射
Dog dog = new Dog("旺财", 4, "柴犬");// =======================================================================// 使用反射创建
String className = "com.lwclick.domain.Dog";
Class aClass = Class.forName(className);// 3. 从类对象中获取有参构造方法【公共的】
Constructor constructor = aClass.getConstructor(String.class, int.class, String.class);// 获取非 public 的构造方法 ！！！！
Constructor declaredConstructor = aClass.getDeclaredConstructor(String.class, int.class, String.class);
// 突破私有的限制
declaredConstructor.setAccessible(true);// 4. 【使用反射创建对象】
Object o = constructor.newInstance("旺财", 4, "柴犬");

4. 使用反射操作属性

• 先获取类对象
• 再使用反射操作属性，get()， set()

// 不使用反射
Dog dog = new Dog();
dog.nickName = "旺财";           // 赋值
String nickName = dog.nickName;  // 取值（使用getter操作，是调用方法）// =======================================================================String className = "com.lwclick.domain.Dog";
Class aClass = Class.forName(className);// 3. 使用反射创建对象
Object o = aClass.newInstance();// 4. 使用反射操作对象
// 先获取对象的属性
Field f = aClass.getDeclaredField("type"); // 非 public 的属性
f.setAccessible(true);
// 对属性进行操作
f.set(o, "柴犬");        // 赋值
Object type = f.get(o);  // 取值

5. 使用反射执行方法

invoke()常用

String className = "com.lwclick.domain.Dog";
Class aClass = Class.forName(className);// 3. 使用反射创建对象
Object o = aClass.newInstance();// 4. 获取对象的方法（无参的）
Method shout = aClass.getMethod("shout");
// 执行方法
shout.invoke(o);// 有参的方法
Method add = aClass.getMethod("add", int.class, int.class);
Object res = add.invoke(o, 10, 20);

使用反射执行方法时，操作的类对象，也可以不通过反射创建

Dog dog = new Dog();     // 先创建对象
Class aClass = dog.getClass();   // 获取对象的classMethod shout = aClass.getMethod("shout");

6. 使用反射操作泛型

没有泛型之前，Java的所有数据类型包括：

• primitive types：基本类型
• raw type：原始类型（不单指类，还包括数据、接口、注解、枚举等）

​ ==》 Class类的一个具体对象代表一个指定的原始类型和基本类型

泛型出现之后，扩充了数据类型：

• parameterized types（参数化类型，可以大概理解为带了泛型的原始类型）：就是平时用到的泛型 List<T>、Map<K, v>的 List 和 Map
• type variables（类型变量）：比如 List<T> 中的 T 等
• array types（数组类型）：带泛型的数组，比如 List<T> []
• WildcardType（通配符类型）：例如 List<? extends Number>

所以就无法通过 Class 来进行操作，为此Java就新增了 ParameterizedType、TypeVariable、GenericArrayType、WildcardType 几种类型来操作泛型的反射

6.1 获取方法的参数中的泛型

getGenericParameterTypes()， ((ParameterizedType) parameterType).getActualTypeArguments()

public void method1(Map<Integer, String> map, List<Integer> list, String str) {}public static void main(String[] args) throws NoSuchMethodException {Class aClass = TestGeneric.class;  // TestGeneric为类名// 获取 method1 方法的参数中的泛型类型Method m1 = aClass.getMethod("method1", Map.class, List.class, String.class);// 不带泛型的参数Type[] types = m1.getParameterTypes();System.out.println(types.length);for (Type type : types) {System.out.println(type);}// interface java.util.Map// interface java.util.List// class java.lang.String// 带泛型的参数Type[] parameterTypes = m1.getGenericParameterTypes();for (Type parameterType : parameterTypes) {System.out.println(parameterType);if (parameterType instanceof ParameterizedType) {// 【重点！！！需要强制类型转换】Type[] typeArguments = ((ParameterizedType) parameterType).getActualTypeArguments();   for (Type typeArgument : typeArguments) {System.out.println("          " + typeArgument);}}}// java.util.Map<java.lang.Integer, java.lang.String>//           class java.lang.Integer//           class java.lang.String// java.util.List<java.lang.Integer>//           class java.lang.Integer// class java.lang.String
}

6.2 获取方法的返回值类型中的泛型

getGenericReturnType()， ((ParameterizedType) genericReturnType).getActualTypeArguments()

public Map<Integer, String> method2() {return null;
}public static void main(String[] args) throws NoSuchMethodException {Class aClass = TestGeneric.class;Method m2 = aClass.getMethod("method2");// 不带泛型的Class returnType = m2.getReturnType();System.out.println(returnType);// interface java.util.Map// 带泛型的Type genericReturnType = m2.getGenericReturnType();System.out.println(genericReturnType);Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();for (Type typeArgument : actualTypeArguments) {System.out.println("       " + typeArgument);}// java.util.Map<java.lang.Integer, java.lang.String>//        class java.lang.Integer//        class java.lang.String
}

6.3 使用反射突破泛型限制

List<Integer> list = new ArrayList<>();
list.add(123);
list.add(456);
list.add(789);
list.add(123);System.out.println(list);     // [123, 456, 789, 123]// list.add("lwclick");    无法加入，有泛型限制// 使用反射突破泛型
Class aClass = list.getClass();
Method add = aClass.getMethod("add", Object.class);
add.invoke(list, "lwclick");
add.invoke(list, "true");System.out.println(list);    // [123, 456, 789, 123, lwclick, true]

7. 反射案例—提取 DBUtil 的 select()

提取员工管理系统案例中的 DBUtil 类的 select() 方法

7.1 认识ResultSetMetaData

利用 ResultSet 的 getMetaData() 方法可以获得 ResultSetMeta 对象，它存储了结果集 ResultSet 的 MetaData（“描述数据的数据”，一般翻译为“元数据”）

// 获得 ResultSetMetaData 对象
ResultSetMetaData rsmd = rs.getMetaData();// 返回此 ResultSet 对象中的列数
int num = rsmd.getColumnCount();// 获取每一列（数据库中的字段）的属性
for (int i = 0; i < num; i++) {rsmd.getColumnClassName(i + 1);   // 返回Java中对应的数据库字段的数据类型（全限定名称）rsmd.getColumnName(i + 1);        // 数据库中指定列的名字
}

7.2 提取 DBUtil 类中的 select() 方法

/*** 之前Dao层的，查询所有*/
public List<Employee> findAll() {Connection conn = null;PreparedStatement pstmt = null;ResultSet rs = null;List<Employee> employeeList = new ArrayList<>();try {conn = DBUtil.getConnection();String sql = "SELECT * FROM emp";pstmt = conn.prepareStatement(sql);rs = pstmt.executeQuery();while (rs.next()) {Employee emp = new Employee(rs.getInt("empno"), rs.getString("ename"),rs.getString("job"), rs.getInt("mgr"),rs.getDate("hireDate"), rs.getDouble("sal"),rs.getDouble("comm"), rs.getInt("deptno"));employeeList.add(emp);}} catch (SQLException throwables) {throwables.printStackTrace();} finally {DBUtil.closeAll(rs, pstmt, conn);}return employeeList;
}/** * 之前Dao层的，通过 empno 查询*/
public Employee findById(int empno) {Connection conn = null;PreparedStatement pstmt = null;ResultSet rs = null;Employee emp = null;try {conn = DBUtil.getConnection();String sql = "SELECT * FROM emp WHERE empno = ?";pstmt = conn.prepareStatement(sql);pstmt.setInt(1, empno);rs = pstmt.executeQuery();if (rs.next()) {emp = new Employee(rs.getInt("empno"), rs.getString("ename"),rs.getString("job"), rs.getInt("mgr"),rs.getDate("hireDate"), rs.getDouble("sal"),rs.getDouble("comm"), rs.getInt("deptno"));}} catch (SQLException throwables) {throwables.printStackTrace();} finally {DBUtil.closeAll(rs, pstmt, conn);}return emp;
}// ====================== 修改之后 ========================
public List<Employee> findAll() {Connection conn = null;PreparedStatement pstmt = null;ResultSet rs = null;List<Employee> employeeList = new ArrayList<>();try {conn = DBUtil.getConnection();String sql = "SELECT * FROM emp";pstmt = conn.prepareStatement(sql);rs = pstmt.executeQuery();while (rs.next()) {Employee emp = new Employee();// 获取每一列的值，并通过 setter 方法赋给 emp 对象  ！！！！！！修改的地方int empno = rs.getInt("empno");emp.setEmpno(empno);String ename = rs.getString("ename");emp.setEname(ename);String job = rs.getString("job");emp.setJob(job);// 。。。。。。。employeeList.add(emp);}} catch (SQLException throwables) {throwables.printStackTrace();} finally {DBUtil.closeAll(rs, pstmt, conn);}return employeeList;
}public Employee findById(int empno1)  {Connection conn = null;PreparedStatement pstmt = null;ResultSet rs = null;// 统一用list接收List<Employee> employeeList = new ArrayList<>();try {conn = DBUtil.getConnection();String sql = "SELECT * FROM emp WHERE empno = ?";pstmt = conn.prepareStatement(sql);pstmt.setInt(1, empno1);rs = pstmt.executeQuery();while (rs.next()) {Employee emp = new Employee();// 获取每一列的值，并通过 setter 方法赋给 emp 对象  ！！！！！！修改的地方int empno = rs.getInt("empno");emp.setEmpno(empno);String ename = rs.getString("ename");emp.setEname(ename);String job = rs.getString("job");emp.setJob(job);// 。。。。。。。employeeList.add(emp);}} catch (SQLException throwables) {throwables.printStackTrace();} finally {DBUtil.closeAll(rs, pstmt, conn);}Employee emp = null;if (employeeList.size() > 0) {// 只取第一个即可emp = employeeList.get(0);}return emp;
}

可以看到每次查询数据时，都是使用不同的sql，然后传递某些参数，因此可以提取出一个公共的查询方法放到 DBUtil 类中

/*** DBUtil 类的公共查询方法*/
public static List<Employee> executeQuery(String sql, Object[] params) {Connection conn = null;PreparedStatement pstmt = null;ResultSet rs = null;List<Employee> employeeList = new ArrayList<>();try {conn = DBUtil.getConnection();pstmt = conn.prepareStatement(sql);for (int i = 0; i < params.length; i++) {pstmt.setObject(i + 1, params[i]);}rs = pstmt.executeQuery();while (rs.next()) {Employee emp = new Employee();// 获取每一列的值，并通过 setter 方法赋给 emp 对象  ！！！！！！修改的地方int empno = rs.getInt("empno");emp.setEmpno(empno);String ename = rs.getString("ename");emp.setEname(ename);String job = rs.getString("job");emp.setJob(job);// 。。。。。。。employeeList.add(emp);}} catch (SQLException throwables) {throwables.printStackTrace();} finally {DBUtil.closeAll(rs, pstmt, conn);}return employeeList;
}/*** Dao层使用公共查询方法之后的  查询所有*/
public List<Employee> findAll() {String sql = "SELECT * FROM emp";Object[] params = {};return DBUtil.executeQuery(sql, params);
}/*** Dao层使用公共查询方法之后的  查询单个员工*/
public Employee findById(int empno1)  {String sql = "SELECT * FROM emp WHERE empno = ?";Object[] params = {empno1};List<Employee> employeeList = DBUtil.executeQuery(sql, params);Employee emp = null;if (employeeList.size() > 0) {// 只取第一个即可emp = employeeList.get(0);}return emp;
}

问题：此时又可以看到，每次查询到数据时，都需要将数据一一进行对应（此时是所有的数据），赋值给实体类对应的字段，而且此时 DButil 的查询，只能查询【员工表】的【所有的】数据

7.3 提取后的结果

• 使用反射解决只能创建 Employee 对象的问题（要根据运行时获取的信息来动态的创建对象）
• 使用泛型来解决返回的数据只能是员工列表的问题
• 使用 ResultSetMetaData 来解决可以查询其他表，以及某些字段的问题

public static <T> List<T> executeQuery(String sql, Object[] params, Class clazz) {Connection conn = null;PreparedStatement pstmt = null;ResultSet rs = null;List<T> list = new ArrayList<>();try {conn = DBUtil.getConnection();pstmt = conn.prepareStatement(sql);for (int i = 0; i < params.length; i++) {pstmt.setObject(i + 1, params[i]);}rs = pstmt.executeQuery();// 获取结果集的 ResultSetMetaData 对象ResultSetMetaData rsmd = rs.getMetaData();int count = rsmd.getColumnCount();while (rs.next()) {T entity = (T) clazz.newInstance();for (int i = 0; i < count; i++) {// 获取当前列的名称String columnName = rsmd.getColumnName(i + 1);// 获取当前列的值Object value = rs.getObject(columnName);// 获取 setter 方法名：通过 getColumnName() 方法获取数据库字段名，去对应实体类的setter方法String methodName = "set" + columnName.substring(0, 1).toUpperCase()+ columnName.substring(1).toLowerCase();// 获取参数的类型：通过 getColumnClassName() 方法获取数据库字段对应的Java类型的全限定类名Class parameterType = Class.forName(rsmd.getColumnClassName(i + 1));// 将当前列的值，赋给 entity 对象，调用 setter 方法Method setterMethod = clazz.getMethod(methodName, parameterType);setterMethod.invoke(entity, value);}list.add(emp);}} catch (Exception throwables) {throwables.printStackTrace();} finally {DBUtil.closeAll(rs, pstmt, conn);}return list;
}

本文标签： JavaLearn（19）反射Class类使用反射创建对象