文章目录
一. 反射机制概述
1. 反射机制作用
通过Java语言中的反射机制可以操作字节码文件,可以读和修改字节码文件
- 通过反射机制可以操作代码片段(class文件)
- 让程序更加灵活
2. 反射机制的相关重要类在哪个包下?
- java.lang.reflect.*
反射机制的相关类?
- java.lang.Class:代表整个字节码,代表一个类型,代表整个类
- java.lang.reflect.Method:代表字节码中的方法字节码,代表类中的方法
- java.lang.reflect.Constructor:代表字节码中的构造方法字节码,代表类中的构造方法
- java.lang.reflect.Field:代表字节码中的属性字节码,代表类中的成员变量(静态变量+实例变量)
java.lang.Class:
public class User{
//Field
int no;
//Constructor
public User(){}
public User(int no){
this.no = no;
}
//Method
public void setNo(int no){
this.no = no;
}
public int getNo(){
return no;
}
}
3. 获取Class的三种方式
要操作一个类的字节码,需要首先获取到这个类的字节码,怎么获取java.lang.Class实例?
三种方式
- 第一种:Class c = Class.forName(“完整类名带包名”);
- 第二种:Class c = 对象.getClass();
- 第三种:Class c = 任何类型.class;
package com.pudding.reflect;
import java.util.Date;
public class ReflectTest01 {
public static void main(String[] args) {
/*
Class.forName()
1. 静态方法
2. 方法的参数是一个字符串
3. 字符串需要的是一个完整类名
4. 完整类名必须带有包名,java.lang包也不能省略
*/
Class c1 = null;
Class c2 = null;
try {
c1 = Class.forName("java.lang.String"); //c1代表String.class文件,或者说c1代表String类型
c2 = Class.forName("java.util.Date"); //c2代表Date类型
Class c3 = Class.forName("java.lang.Integer"); //c3代表Integer类型
Class c4 = Class.forName("java.lang.System"); //c4代表System类型
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//第二种方式
//java中任何一个对象都有一个方法:getClass()
String s = "abc";
Class x = s.getClass(); //x代表String.class字节码文件,x代表String类型
System.out.println(c1 == x); //true(判断对象内存地址相同)
Date time = new Date();
Class y = time.getClass();
System.out.println(c2 == y); //true(c2和y两个变量保存内存地址相同)
//第三种方式:java语言中任何一种类型,包括基本数据类型,它都有.class属性
Class z = String.class; //z代表String类型
Class k = Date.class; //k代表Date类型
Class f = int.class; //f代表int类型
Class e = double.class; //e代表double类型
System.out.println(x == z); //true
}
}
二. 通过反射实例化对象
package com.pudding.reflect;
import com.pudding.bean.User;
/*
获取到Class,能干什么?
通过Class的newInstance()方法来实例化对象
注意:newInstance()方法内部实际上调用了无参构造方法,必须保证无参构造存在才可以
后期的高级框架ssm...底层都是采用反射机制。所以反射机制很重要。
*/
public class ReflectTest02 {
public static void main(String[] args) {
//这是不使用反射机制,创建对象
//这种方式代码就写死了,只能创建一个User类型的对象
User user = new User();
System.out.println(user);
//这段代码是以反射机制的方式创建对象
//以下代码是灵活的,代码不需要改动,可以修改配置文件,配置文件修改之后,可以创建出不同的实例对象
try {
//通过反射机制,获取Class,通过Class来实例化对象
Class c = Class.forName("com.pudding.bean.User"); //c代表User类型
//newInstance()这个方法会调用User这个类的无参数构造方法,完成对象的创建
//重点是:newInstance()调用的是无参构造,必须保证无参构造是存在的!
Object obj = c.newInstance();
System.out.println(obj); //com.pudding.bean.User@1b6d3586
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
}
}
通过读取属性文件实例化对象
package com.pudding.reflect;
import java.io.FileReader;
import java.util.Properties;
/*
验证反射机制的灵活性
java代码写一遍,再不改变java源代码的基础之上,可以做到不同对象的实例化
非常之灵活(符合OCP开闭原则:对扩展开放,对修改关闭)
*/
public class ReflectTest03 {
public static void main(String[] args) throws Exception{
//通过IO流读取classinfo.properties文件
FileReader reader = new FileReader("反射机制/classinfo.properties");
//创建属性类对象Map
Properties pro = new Properties(); //key value都是String
//加载
pro.load(reader);
//关闭流
reader.close();
//通过key获取value
String className = pro.getProperty("className");
//通过反射机制实例化对象
Class c = Class.forName(className);
Object obj = c.newInstance();
System.out.println(obj);
}
}
1. Class.forName()发生了什么
package com.pudding.reflect;
/*
Class.forName()发生了什么?
如果只希望一个类的静态代码块执行,其他代码一律不执行
可以使用:Class.forName("完整类名"):这个方法执行会导致类加载,静态代码块执行
*/
public class ReflectTest04 {
public static void main(String[] args) {
try {
Class.forName("com.pudding.reflect.MyClass");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
class MyClass{
//静态代码块在类加载时执行,并且只执行一次
static {
System.out.println("MyClass类的静态代码块执行了!");
}
}
2. 获取类路径下文件的绝对路径
package com.pudding.reflect;
/*
研究一下文件路径的问题
怎么获取一个文件的绝对路径,以下讲解的这种方式是通用的。但是前提是:文件需要在类路径下,才能使用
*/
public class AboutPath {
public static void main(String[] args) throws Exception{
//这种方式的路径缺点是:移植性差,在IDEA中默认的当前路径是project的根
//这个代码假设离开了IDEA,换到其他位置,可能当前路径就不是project的根,这时路径就无效了
//FileReader reader = new FileReader("反射机制\\classinfo.properties");
//注意:使用以下通用方式的前提,这个文件必须在类路径下
//src下的都是类路径
//src是类的根路径
/*
解释:
Thread.currentThread() 当前线程对象
getContextClassLoader() 是线程对象的方法,可以获取到当前线程的类加载器对象
getResource()【获取资源】这是类加载器对象的方法,当前线程的类加载器默认从类的根路径下加载资源
*/
String path = Thread.currentThread().getContextClassLoader()
.getResource("classinfo2.properties").getPath();
System.out.println(path);
//采用以上代码可以拿到一个文件的绝对路径
///D:/IDEA/code/JavaSE/out/production/反射机制/classinfo2.properties
String path2 = Thread.currentThread().getContextClassLoader()
.getResource("src/com/pudding/bean/db.properties").getPath();
System.out.println(path2);
}
}
以流的形式直接返回
package com.pudding.reflect;
import java.io.FileReader;
import java.io.InputStream;
import java.util.Properties;
public class IoPropertiesTest {
public static void main(String[] args) throws Exception{
//获取一个文件的绝对路径
/*String path = Thread.currentThread().getContextClassLoader()
.getResource("classinfo2.properties").getPath();
FileReader reader = new FileReader(path);
*/
//直接以流的形式返回
InputStream reader = Thread.currentThread().getContextClassLoader()
.getResourceAsStream("classinfo2.properties");
Properties pro = new Properties();
pro.load(reader);
reader.close();
//通过key获取value
String className = pro.getProperty("className");
System.out.println(className); //com.pudding.bean.User
}
}
java.util包下提供了一个资源绑定器,便于获取属性配置文件中的内容
- 使用以下这种方式的时候,属性配置文件xxx.properties必须放到类路径下
package com.pudding.reflect;
import java.util.ResourceBundle;
public class ResourceBundleTest {
public static void main(String[] args) {
//资源绑定器,只能绑定xxx.properties文件。并且这个文件必须在类路径下。文件扩展名必须是properties
//并且在写路径的时候,路径后面的扩展名不用写
ResourceBundle bundle = ResourceBundle.getBundle("classinfo2");
String className = bundle.getString("className");
System.out.println(className);
}
}
三. 关于JDK中自带的类加载器
1. 什么是类加载器
专门负责加载类的命令/工具
ClassLoader
2. JDK中自带了3个类加载器
- 启动类加载器:rt.jar
- 扩展类加载器:ext/*.jar
- 应用类加载器:classpath
3. 假设有这样一段代码
String s = “abc”;
代码在开始执行之前,会将所需要的类全部加载到JVM中。
通过类加载器加载,看到以上代码类加载器会找到String.class文件
找到就加载,怎么加载的呢?
-
首先通过"启动类加载器"加载。
注意:启动类加载器专门加载:jre\lib\rt.jar rt.jar中都是JDK最核心的类库
-
如果通过"启动类加载器"加载不到的时候,会通过“扩展类加载器”加载
注意:扩展类加载器专门加载:jre\lib\ext.jar
-
如果通过“扩展类加载器”没有加载到,那么会通过“应用类加载器”加载
注意:应用类加载器专门加载:classpath中的类
4. Java中为了保证类加载的安全
使用双亲委派机制,优先从启动类加载器中加载,这个称为:父
“父”加载不到,再从扩展类加载器中加载,这个称为“母”。双亲委派
如果都加载不到,才会考虑从应用类加载器中加载,直到加载到为止
五. 反射属性(Field)
1. 获取Field
package com.pudding.reflect;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
/*
反射Student类当中的所有Field
*/
public class ReflectTest05 {
public static void main(String[] args) throws Exception{
//获取整个类
Class studentClass = Class.forName("com.pudding.bean.Student");
String className = studentClass.getName();
System.out.println("完整类名:"+ className); //完整类名:com.pudding.bean.Student
String simpleName = studentClass.getSimpleName();
System.out.println("简类名" + simpleName); //简类名Student
//获取类中所有的public修饰的Field
Field[] fields = studentClass.getFields();
System.out.println(fields.length); //测试数组中只有1个元素
//取出这个Field
Field f = fields[0];
//取出这个Field它的名字
String fieldName = f.getName();
System.out.println(fieldName);//no
//获取所有的Field
Field[] fs = studentClass.getDeclaredFields();
System.out.println(fs.length); //4
System.out.println("======================");
//遍历
for (Field field: fs) {
//获取属性的修饰符列表
int i = field.getModifiers(); //返回的修饰符是一个数字,每个数字是修饰符代号
System.out.println(i);
//将这个代号转换为字符串
String modifierString = Modifier.toString(i);
System.out.println(modifierString);
//获取属性的名字
Class fieldType = field.getType();
//String fieldName = fieldType.getName();
String fName = fieldType.getSimpleName();
System.out.println(fName);
//获取属性的名字
System.out.println(field.getName());
}
}
}
package com.pudding.bean;
/*
反射属性Field
*/
public class Student {
//Field翻译为字段,其实就是属性/成员
public int no; //Field对象
private String name;
protected int age;
boolean sex;
public static final double MATH_PI = 3.1415926;
}
反编译Field
- 通过反射机制,反编译一个类的属性Field
package com.pudding.reflect;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
public class ReflectTest06 {
public static void main(String[] args) throws Exception{
//创建这个是为了拼接字符串
StringBuilder s = new StringBuilder();
//Class studentClass = Class.forName("com.pudding.bean.Student");
Class studentClass = Class.forName("java.lang.String");
s.append(Modifier.toString(studentClass.getModifiers()) + " class " + studentClass.getSimpleName()+ "{\n");
Field[] fields = studentClass.getDeclaredFields();
for (Field field: fields) {
s.append("\t");
s.append(Modifier.toString(field.getModifiers()));
s.append(" ");
s.append(field.getType().getSimpleName());
s.append(" ");
s.append(field.getName());
s.append(";\n");
}
s.append("}");
System.out.println(s);
}
}
2. 通过反射机制访问对象属性
package com.pudding.reflect;
import com.pudding.bean.Student;
import java.lang.reflect.Field;
/*
怎么通过反射机制访问一个Java对象的属性?
给属性赋值set
获取属性的值get
*/
public class ReflectTest07 {
public static void main(String[] args) throws Exception{
//我们不使用反射机制,怎么去访问一个对象的属性呢?
Student s = new Student();
//给属性赋值
s.no = 1111;
//读取属性值
System.out.println(s.no);
//使用反射机制,怎么去访问一个对象的属性(set get)
Class studentClass = Class.forName("com.pudding.bean.Student");
Object obj = studentClass.newInstance(); //obj就是Student对象(底层调用无参构造方法)
//获取no属性(根据属性的名称来获取Field)
Field noFiled = studentClass.getDeclaredField("no");
//给obj对象(Student对象)的no属性赋值
/*
三要素:
要素1:obj对象
要素2:no属性
要素3:2222值
反射机制让代码复杂了,但是为了灵活,这也是值得的
*/
noFiled.set(obj,2222); //给obj对象的no属性赋值2222
//读取属性的值
/*
两个要素:获取obj对象的no属性的值
*/
System.out.println(noFiled.get(obj)); //2222
//可以访问私有属性吗?
Field nameField = studentClass.getDeclaredField("name");
//打破封装(反射机制的缺点:打破封装,可能会给不法分子留下机会)
nameField.setAccessible(true);
//给属性name赋值
nameField.set(obj,"jackson");
//获取属性name的值
System.out.println(nameField.get(obj));
}
}
六. 反射Method
1. 可变长度参数
语法是:类型…(一定是三个…)
- 可变长度参数要求的参数个数是:0~N个
- 可变长度参数在参数列表中必须在最后一个位置上,而且可变长度参数只能有1个
- 可变长度参数可以当做一个数组来看待
package com.pudding.reflect;
/*
可变长度参数:
int... args 这个就是可变长度参数
语法是:类型...(一定是三个...)
*/
public class ArgsTest {
public static void main(String[] args) {
m();
m(10);
m(10,20);
m2(100);
m2(100,"abc");
m2(100,"abc","def");
m3("ab","dc","fd");
String[] strs = {"a","b","c"};
//也可以传一个数组
m3(strs);
//直接传一个数组
m3(new String[]{"中","国","人"});
m3("中","国","人");
}
public static void m(int... args){
System.out.println("m方法执行了!");
}
public static void m2(int a, String... args1){
System.out.println("m2方法执行了!");
}
public static void m3(String... args){
//args有length属性,说明args是一个数组
//可以将可变长度参数当做一个数组来看待
for (int i = 0; i < args.length; i++) {
System.out.println(args[i]);
}
}
}
反射Method
package com.pudding.service;
public class UserService {
/**
* 登录方法
* @param name 用户名
* @param password 密码
* @return true表示登录成功
*/
public boolean login(String name, String password){
if ("admin".equals(name) && "123".equals(password)){
return true;
}
return false;
}
/**
* 退出系统方法
*/
public void logout(){
System.out.println("系统已经退出");
}
}
package com.pudding.reflect;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
/*
反射Method
*/
public class ReflectTest08 {
public static void main(String[] args) throws Exception{
//获取类
Class userServiceClass = Class.forName("com.pudding.service.UserService");
//获取所有的Method(包括私有的)
Method[] methods = userServiceClass.getDeclaredMethods();
System.out.println(methods.length); //2
//遍历Method
for (Method method : methods) {
//获取修饰符列表
System.out.println(Modifier.toString(method.getModifiers()));
//获取方法返回值类型
System.out.println(method.getReturnType().getSimpleName());
//获取方法名
System.out.println(method.getName());
//方法的修饰符列表(一个方法的参数可能会有多个)
Class[] parameterTypes = method.getParameterTypes();
for (Class parameterType : parameterTypes) {
System.out.println(parameterType.getSimpleName());
}
}
}
}
2. 反编译Method
package com.pudding.reflect;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class ReflectTest09 {
public static void main(String[] args) throws Exception{
StringBuilder s = new StringBuilder();
//获取类
Class userServiceClass = Class.forName("com.pudding.service.UserService");
s.append(Modifier.toString(userServiceClass.getModifiers()) + " class "+userServiceClass.getSimpleName()+"{\n");
Method[] methods = userServiceClass.getDeclaredMethods();
for (Method method : methods){
s.append("\t");
s.append(Modifier.toString(method.getModifiers()));
s.append(" ");
s.append(method.getReturnType().getSimpleName());
s.append(" ");
s.append(method.getName());
s.append("(");
//参数列表
Class[] parameterTypes = method.getParameterTypes();
for (Class parameterType : parameterTypes){
s.append(parameterType.getSimpleName());
s.append(",");
}
s.append("){}\n");
}
s.append("}");
System.out.println(s);
}
}
反射机制调用方法
- 反射机制,让代码很具有灵活性,可变化的内容都是写到配置文件当中,将来修改配置文件之后,创建的对象不一样了,调用的方法也不同了,但是java代码不需要做任何改动。
package com.pudding.reflect;
import com.pudding.service.UserService;
import java.lang.reflect.Method;
/*
反射机制如何调用一个对象方法
*/
public class ReflectTest10 {
public static void main(String[] args) throws Exception{
//不使用反射机制,怎么调用方法
//创建对象
UserService userService = new UserService();
//调用方法
boolean loginSuccess = userService.login("admin","123");
System.out.println(loginSuccess ? "登录成功" : "登录失败");
//使用反射机制来调用一个对象的方法该怎么做?
//创建类
Class userServiceClass = Class.forName("com.pudding.service.UserService");
//创建对象
Object obj = userServiceClass.newInstance();
//获取Method
Method loginMethod = userServiceClass.getDeclaredMethod("login",String.class,String.class);
//调用方法
/*
四要素:
loginMethod方法
obj对象
"admin","123"参数
retValue返回值
*/
Object retValue = loginMethod.invoke(obj,"admin","123");
System.out.println(retValue);
}
}
七. 反射Constructor
package com.pudding.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
/*
反编译一个类的Constructor构造方法
*/
public class ReflectTest11 {
public static void main(String[] args) throws Exception{
StringBuilder s = new StringBuilder();
Class vipClass = Class.forName("com.pudding.bean.Vip");
s.append(Modifier.toString(vipClass.getModifiers()));
s.append(" class ");
s.append(vipClass.getSimpleName());
s.append("{\n");
//拼接构造方法
Constructor[] constructors = vipClass.getDeclaredConstructors();
for (Constructor constructor : constructors) {
s.append("\t");
s.append(Modifier.toString(constructor.getModifiers()));
s.append(" ");
s.append(vipClass.getSimpleName());
s.append("(");
//拼接参数
Class[] parameterTypes = constructor.getParameterTypes();
for (Class parameterType : parameterTypes){
s.append(parameterType.getSimpleName());
s.append(",");
}
//删除最后下标位置上的支付
if (parameterTypes.length > 0){
s.deleteCharAt(s.length() - 1);
}
s.append("){}\n");
}
s.append("}");
System.out.println(s);
}
}
package com.pudding.bean;
public class Vip {
int no;
String name;
String birth;
boolean sex;
public Vip() {
}
public Vip(int no) {
this.no = no;
}
public Vip(int no, String name) {
this.no = no;
this.name = name;
}
public Vip(int no, String name, String birth) {
this.no = no;
this.name = name;
this.birth = birth;
}
public Vip(int no, String name, String birth, boolean sex) {
this.no = no;
this.name = name;
this.birth = birth;
this.sex = sex;
}
@Override
public String toString() {
return "Vip{" +
"no=" + no +
", name='" + name + '\'' +
", birth='" + birth + '\'' +
", sex=" + sex +
'}';
}
}
1. 反射机制调用构造方法
package com.pudding.reflect;
import com.pudding.bean.Vip;
import java.lang.reflect.Constructor;
public class ReflectTest13 {
public static void main(String[] args) throws Exception{
//不使用反射机制创建对象
Vip v1 = new Vip();
Vip v2 = new Vip(110,"zhangsan","2001-10-11",true);
//使用反射机制怎么创建对象?
Class c = Class.forName("com.pudding.bean.Vip");
//调用无参构造方法
Object obj = c.newInstance();
System.out.println(obj);
//调用有参构造方法
//第一步:先获取到这个有参构造方法
Constructor con = c.getDeclaredConstructor(int.class,String.class,String.class,boolean.class);
//第二步:调用构造方法new对象
Object newObj = con.newInstance(110,"jaclson","1999-11-21",true);
System.out.println(newObj);
//获取无参构造方法
Constructor con2 = c.getDeclaredConstructor();
Object newObj2 = con2.newInstance();
System.out.println(newObj2);
}
}
2. 获取父类和父接口
package com.pudding.reflect;
/*
给你一个类,怎么获取这个类的父类,已经实现了哪些接口?
*/
public class ReflcetTest14 {
public static void main(String[] args) throws Exception{
//String举例
Class stringClass = Class.forName("java.lang.String");
//获取String的父类
Class superClass = stringClass.getSuperclass();
System.out.println(superClass.getName()); //java.lang.Object
//获取String类实现的所有接口(一个类可以实现多个接口)
Class[] interfaces = stringClass.getInterfaces();
for (Class in : interfaces){
System.out.println(in.getName());
/*
java.io.Serializable
java.lang.Comparable
java.lang.CharSequence
*/
}
}
}