Java中的反射：框架设计的灵魂

布满荆棘的人生 2023-07-12 06:21 5阅读 0赞

反射：框架设计的灵魂

框架：半成品软件。可以在框架的基础上进行软件开发，简化编码  
反射：将类的各个组成部分封装为其他对象，这就是反射机制  
好处：

1.  可以在程序运行过程中，操作这些对象。
2.  可以解耦，提高程序的可扩展性。

获取Class对象的方式：

1.  Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象  
    多用于配置文件，将类名定义在配置文件中。读取文件，加载类
2.  类名.class：通过类名的属性class获取  
    多用于参数的传递
3.  对象.getClass()：getClass()方法在Object类中定义着。  
    多用于对象的获取字节码的方式

结论：  
同一个字节码文件(\*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。

例如我们有一个Person类

public class Person { 
        private String name;
        private int age;
        public Person(){ 
        }
        public Person(String name, int age) { 
            this.name = name;
            this.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;
        }
        @Override
        public String toString() { 
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

我们写一个Demo用三种方式来获取Class对象

public class Demo1 { 
        public static void main(String [] args) throws Exception { 
            //1、Class.forName("类名")
            Class cls1 = Class.forName("man.Person");
            System.out.println(cls1);
            //2、类名。class
            Class cls2= Person.class;
            System.out.println(cls2);
            //3、对象.getClass()
            Person p = new Person();
            Class cls3=p.getClass();
            System.out.println(cls3);
        }
    }

Class对象功能：

获取功能：

1.  获取成员变量们  
    Field\[\] getFields() ：获取所有public修饰的成员变量

Field getField(String name) 获取指定名称的 public修饰的成员变量

Field\[\] getDeclaredFields() 获取所有的成员变量，不考虑修饰符

Field getDeclaredField(String name)

1.  获取构造方法们  
    Constructor<?>\[\] getConstructors()  
    Constructor getConstructor(类<?>… parameterTypes)  
    Constructor getDeclaredConstructor(类<?>… parameterTypes)  
    Constructor<?>\[\] getDeclaredConstructors()
2.  获取成员方法们：  
    Method\[\] getMethods()  
    Method getMethod(String name, 类<?>… parameterTypes)  
    Method\[\] getDeclaredMethods()  
    Method getDeclaredMethod(String name, 类<?>… parameterTypes)
3.  获取全类名  
    String getName() \* Field：成员变量  
    操作：
4.  设置值  
    void set(Object obj, Object value)
5.  获取值  
    get(Object obj)
6.  忽略访问权限修饰符的安全检查  
    setAccessible(true):暴力反射  
    Constructor:构造方法  
    创建对象：  
    T newInstance(Object… initargs)

如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法\* Method：方法对象  
执行方法：  
Object invoke(Object obj, Object… args)

获取方法名称：  
String getName:获取方法名

同样对于上面的Person类我们对其新增带参数和不带参数的sleep方法并且写一个Demo来获取这些成员变量，构造方法以及成员方法

Person.java

public class Person { 
        private String name;
        private int age;
        public String a;
        protected String b;
        String c;
        private String d;
        public Person(){ 
        }
        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;
        }
        public Person(String name, int age) { 
            this.name = name;
            this.age = age;
        }
        public void eat(){ 
            System.out.println("eat...");
        }
        public void eat(String food){ 
            System.out.println("eat..."+food);
        }
    
        @Override
        public String toString() { 
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", a='" + a + '\'' +
                    ", b='" + b + '\'' +
                    ", c='" + c + '\'' +
                    ", d='" + d + '\'' +
                    '}';
        }
    }

Demo2.java代码如下：

public class Demo2 { 
        public static void main(String [] args) throws Exception { 
            Class<Person> personClass = Person.class;
            //获取成员变量
            Field[] fields = personClass.getFields();
            for(Field field:fields) { 
                System.out.println(field);
            }
            System.out.println("--------------");
    
            Field a = personClass.getField("a");//获取a的值
            Person p = new Person();
            Object value=a.get(p);
            System.out.println(value);
    
            a.set(p, "zhangsan");//设置a的值
            System.out.println(p);
            System.out.println("=============");
            //获取所有成员变量
            Field[] declaredFields = personClass.getDeclaredFields();
            for (Field declaredField : declaredFields) { 
                System.out.println(declaredField);
            }
            Field d = personClass.getDeclaredField("d");
            d.setAccessible(true);//暴力反射
            Object value2 = d.get(p);
            System.out.println(value2);
    
            //获取构造方法
            Constructor<Person> constructor = personClass.getConstructor(String.class, int.class);
            System.out.println(constructor);
            Object person = constructor.newInstance("张三", 23);
            System.out.println(person);
            System.out.println("=======");
    
            Constructor<Person> constructor1 = personClass.getConstructor();
            System.out.println(constructor1);
            Object person1 = constructor1.newInstance();
            System.out.println(person1);
    
            //获取成员方法
            Method eat_method = personClass.getMethod("eat");
            Person p1 = new Person();
            eat_method.invoke(p1);
    
            Method eat_method1 = personClass.getMethod("eat",String.class);
            eat_method1.invoke(p1,"饭");
            System.out.println("---------");
            Method[] methods = personClass.getMethods();
            for (Method method : methods) { 
                System.out.println(method);
            }
    
        }
    }

运行结果如下：

> public java.lang.String man.Person.a  
> \-------------- null Person\{name=‘null’, age=0, a=‘zhangsan’, b=‘null’, c=‘null’, d=‘null’\}  
> ============= private java.lang.String man.Person.name private int man.Person.age public java.lang.String man.Person.a protected  
> java.lang.String man.Person.b java.lang.String man.Person.c private  
> java.lang.String man.Person.d null public  
> man.Person(java.lang.String,int) Person\{name=‘张三’, age=23, a=‘null’,  
> b=‘null’, c=‘null’, d=‘null’\}  
> ======= public man.Person() Person\{name=‘null’, age=0, a=‘null’, b=‘null’, c=‘null’, d=‘null’\} eat… eat…饭  
> \--------- public java.lang.String man.Person.toString() public java.lang.String man.Person.getName() public void  
> man.Person.setName(java.lang.String) public void  
> man.Person.eat(java.lang.String) public void man.Person.eat() public  
> void man.Person.setAge(int) public int man.Person.getAge() public  
> final void java.lang.Object.wait() throws  
> java.lang.InterruptedException public final void  
> java.lang.Object.wait(long,int) throws java.lang.InterruptedException  
> public final native void java.lang.Object.wait(long) throws  
> java.lang.InterruptedException public boolean  
> java.lang.Object.equals(java.lang.Object) public native int  
> java.lang.Object.hashCode() public final native java.lang.Class  
> java.lang.Object.getClass() public final native void  
> java.lang.Object.notify() public final native void  
> java.lang.Object.notifyAll()

## 案例 ##

需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法

实现：
    		1. 配置文件
    		2. 反射
    	步骤：
    		1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
    		2. 在程序中加载读取配置文件
    		3. 使用反射技术来加载类文件进内存
    		4. 创建对象
    		5. 执行方法

为了实现创建任意类的对象，并且执行其中任意方法，我们再原有Person.java文件基础上新增Student.java,代码如下：

public class Student { 
        public void sleep(){ 
            System.out.println("sleep...");
        }
    }

那么我们需要在src目录下添加pro.properties文件并写入以下配置信息

> className=man.Student  
> methodName=sleep

接着我们来写这个案例ReflectTest.java,代码如下

public class ReflectTest { 
        public static void main(String [] args) throws Exception { 
            //加载配置文件
            Properties pro = new Properties();
            ClassLoader classLoader = ReflectTest.class.getClassLoader();
            InputStream is = classLoader.getResourceAsStream("pro.properties");
            pro.load(is);
            //获取配置文件中定义的数据
            String className = pro.getProperty("className");
            String methodName = pro.getProperty("methodName");
            //加载该类进内存
            Class cls = Class.forName(className);
            Object obj = cls.newInstance();
            Method method = cls.getMethod(methodName);
            method.invoke(obj);
    
        }
    }

这样我们只需改变配置文件中的信息而不需要去改变任何代码就可以实现类以及类中的方法,整个目录结构如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXp1b3Bpbmc_size_16_color_FFFFFF_t_70]![在这里插入图片描述][20200307171752744.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXp1b3Bpbmc_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200307171535645.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXp1b3Bpbmc=,size_16,color_FFFFFF,t_70
[20200307171752744.png]: https://img-blog.csdnimg.cn/20200307171752744.png