反射机制— —框架设计的灵魂

最新推荐文章于 2022-08-16 04:05:21 发布

享受当下.26

最新推荐文章于 2022-08-16 04:05:21 发布

阅读量115

点赞数

文章标签： java spring

本文链接：https://blog.csdn.net/qq_57138944/article/details/124467390

版权

1.框架概述

半成品软件，可以在框架的基础上进行软件开发，简化代码。

2.反射概念

将类的各个组成部分封装为其他对象，这就是反射机制。

3.反射的好处

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

4.Java代码在计算机中经历的三个阶段

首先源代码通过javac编译生成 .class字节码文件，此时还储存在硬盘上。然后通过类加载器，将各个组成部分封装起来分为三个不同的对象，即内存中的class类对象来描述字节码文件。最后创建对象。

日常中当我们写代码的时候，需要调用（str.tostring() , str.charAt() ,等）某个方法时，会出现一个提示方法的表格，就用到了反射机制。因为所有的方法被封装起来放在在一个对象中。

5.获取Class对象的方式

1.Class.forName("全类名")：将字节码文件加载进内存，返回Class对象。（全类名及包名.类名）

多用于配置文件，将类名定义在配置文件中。读取文件，加载类

2.类名.class：通过类名的属性Class获取。

多用于参数的传递

3.对象.getClass()：getClass()方法在object类中定义着。

多用于对象的获取字节码的方式

6.代码演示

创建一个包，名为domain，里面创建Person类

public class Person {
    private String name;
    private int age;

    public String a;
    protected String b;
    String c;
    private String d;

    //无参构造方法
    public Person() {

    }
    //有参构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //Getter和Setter方法
    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 +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }

     public void eat(){
        System.out.println("eat....");
    }


    public void eat(String food){
        System.out.println("eat...."+food);
    }

}

创建一个包，名为reflect，里面创建ReflectDemo1类

//1.Class.forName("全类名")：将字节码文件加载进内存，返回Class对象。
//2.类名.class：通过类名的属性Class获取。
//3.对象.getClass()：getClass()方法在object类中定义着。

public class ReflectDemo1 {
    public static void main(String[] args) throws Exception {

       // 1.Class.forName("全类名")
        Class cls1=Class.forName("domain.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);
    }
}

运行结果

可能出现报错情况

错误原因：是包名或者类名出错了

解决方法：复制包名，类名。重写一下

比较三个对象

//==比较三个对象
        System.out.println(cls1==cls2);//true
        System.out.println(cls1==cls3);//true

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

7.Class对象功能

1.获取成员变量们

Field成员变量：

设置值：

获取值：

忽略访问权限修饰符的安全检查

setAccessible(true);//暴力反射

代码演示：

public class ReflectDemo2 {
    public static void main(String[] args) throws Exception {

        //获取Person的Class对象
        Class personClass= Person.class;

        //Field[] getFields()：获取所有public修饰的成员变量
        Field[] fields=personClass.getFields();
        for(Field field:fields){
            System.out.println(field);
        }
        System.out.println("------------------");

        //Field getField(String name):获取指定名称的的public修饰的成员变量
        Field a= personClass.getField("a");
        //获取成员变量a的值
        Person p=new Person();
        Object value=a.get(p);
        System.out.println(value);
        //设置a的值
        a.set(p,"张三");
        System.out.println(p);
        System.out.println("------------------");

        //Fiels[] getDeclaredFields():获取所有的成员变量,不考虑修饰符
        Field[] declaredFields=personClass.getDeclaredFields();
        for(Field declaredField:declaredFields){
            System.out.println(declaredField);
        }
         System.out.println("------------------");

        //Field getDeclaredField(String name):
        Field d=personClass.getDeclaredField("d");//使用私有的成员时会出现非法访问异常

        //忽略访问权限修饰符的安全检查
        d.setAccessible(true);//暴力反射

        Object value2=d.get(p);
        System.out.println(value2);
    }
}

结果：

结论：

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

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

3.Fiels[] getDeclaredFields():获取所有的成员变量,不考虑修饰符

2.获取构造方法们

Constructor构造方法

创建对象

如果使用空参数构造方法，操作可以简化：Class对象中的newInstance()方法

代码演示：

public class ReflectDemo3 {
    public static void main(String[] args) throws Exception {

        //获取Person的Class对象
        Class personClass= Person.class;

        //Constructor<T> getConstructor(类<?>... parameterType)
        Constructor constructor= personClass.getConstructor(String.class,int.class);
        System.out.println(constructor);

        //创建和初始化对象
        Object person=constructor.newInstance("张三",23);
        System.out.println(person);

        System.out.println("----------------");
        //如果使用空参数构造方法，操作可以简化：Class对象中的newInstance()方法
        Object o=personClass.newInstance();
        System.out.println(o);

    }
}

结果：

3.获取成员方法们

Method:对象方法

执行方法
获取方法名称

代码演示：

public class ReflectDemo4 {
    public static void main(String[] args) throws Exception{
        //获取Person的Class对象
        Class personClass= Person.class;

        //获取指定名称的方法
         Method eat_mothod=personClass.getMethod("eat");
         Person p=new Person();
         //执行方法
        eat_mothod.invoke(p);

        System.out.println("---------------");

        //获取指定名称和指定参数列表的方法
        Method eat_mothod2=personClass.getMethod("eat",String.class);
        //执行方法
        eat_mothod2.invoke(p,"饭");

        System.out.println("---------------");

        //获取所有public修饰放入方法
        //Object方法也包含其中
        Method[] methods=personClass.getMethods();
        for(Method method:methods){
            System.out.println(method);

            //获取方法名
            String name= method.getName();
            System.out.println(name);
            System.out.println("============");
        }

        System.out.println("---------------");

    }
}

结果：

4.获取类名

代码演示：

public class ReflectDemo4 {
    public static void main(String[] args) throws Exception{
        //获取Person的Class对象
        Class personClass= Person.class;

        //获取类名
        String className= personClass.getName();
        System.out.println(className);//全类名：包名. 类名

    }
}

结果：

8.案例

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

实现：

1.配置文件

2.反射

步骤：

1.将需要创建的对象的全类名和需要执行的方法定义在配置文件中

2.在程序中加载读取配置文件

3.使用反射技术来加载文件进内存

4.创建对象

5.执行方法

代码：

domain包下的Person类代码

public class Person {
    private String name;
    private int age;

    public String a;
    protected String b;
    String c;
    private String d;


    //无参构造方法
    public Person() {

    }
    //有参构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //Getter和Setter方法
    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 +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }
    public void eat(){
        System.out.println("eat....");
    }

    public void eat(String food){
        System.out.println("eat...."+food);
    }
}

domain包下的Student类代码

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

reflect包下的ReflectTest类代码

//假设的框架类
public class ReflectTest {
    public static void main(String[] args) throws Exception{
        //可以创建任意类的对象，可以执行任意方法

        //1.加载配置文件

        //1.1 创建Properties对象
        Properties pro = new Properties();

        //1.2 加载配置文件，转换为一个集合

        //1.2.1 获取class目录下的配置文件
        ClassLoader classLoader = ReflectTest.class.getClassLoader();
        InputStream is = ClassLoader.getSystemResourceAsStream("pro.properties");
        pro.load(is);

        //2.获取配置文件中定义的数据
        String className= pro.getProperty("className");
        String methodName= pro.getProperty("methodName");

        //3.加载该类进内存
        Class cls=Class.forName(className);

        //4.创建对象
        Object obj=cls.newInstance();

        //5.获取方法对象
        Method method=cls.getMethod(methodName);

        //6.执行方法
        method.invoke(obj);
        
    }
}

配置文件代码：

src包下的File配置文件代码

className=domain.Student
methodName=sleep

结果：

修改配置文件的代码：

src包下的File配置文件代码

className=domain.Person
methodName=eat

结果：

享受当下.26

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
反射机制— —框架设计的灵魂

1.框架概述半成品软件，可以在框架的基础上进行软件开发，简化代码。2.反射概念将类的各个组成部分封装为其他对象，这就是反射机制。3.反射的好处可以在程序运行过程中，操作这些对象。可以解耦，提高程序的可扩展性。4.Java代码在计算机中经历的三个阶段源代码通过javac编译生成 .class字节码文件，此时还储存在硬盘上。然后通过类加载器，将各个组成部分封装起来，...
复制链接

扫一扫