目录
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类的常用方法:
方法名 | 说 明 |
---|---|
getFields() | 获得类的public类型的属性。 |
getDeclaredFields() | 获得类的所有属性 |
getField(String name) | 获得类的指定属性 |
getMethods() | 获得类的public类型的方法 |
getMethod (String name,Class [] args) | 获得类的指定方法 |
getConstrutors() | 获得类的public类型的构造方法 |
getConstrutor(Class[] args) | 获得类的特定构造方法 |
newInstance() | 通过类的无参构造方法创建对象 |
getName() | 获得类的完整名字 |
getPackage() | 获取此类所属的包 |
getSuperclass() | 获得此类的父类对应的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(); // 获取对象的class
Method 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;
}