Java研学-反射与内省

泰勒疯狂展开

于 2023-12-03 19:57:52 发布

阅读量650

点赞数 15

分类专栏： # Java研学文章标签： java 开发语言

本文链接：https://blog.csdn.net/zhlyxx/article/details/134765497

版权

Java研学专栏收录该内容

84 篇文章 3 订阅

订阅专栏

一反射机制

1 含义

通过指定类的字节码文件获取对应的字节码对象;通过该对象调用类中的成员

2 获取类的真实类型的方式

① 正射机制 – new关键字实例化对象

// Animal类
public class Animal{
	private String name;
	private int kg;
	......
}

// 实例化对象
public class Test{
	public static void main(String[] args) {
		......
		// 等号左侧在栈内存中，右侧在堆内存中
        Animal a=new Animal();
        ......
    }
}

方便理解,但当实例化对象过多的时候,容易造成内存溢出风险

② 反射机制

为了避免正射机制实例化对象容易造成内存溢出的风险，通过javac命令将编写好的.java文件编译成同名的.class文件;通过操作.class文件实现对指定类中的成员操作

3 反射机制的执行原理

// 三种获取方式
// 反射机制
Class cl=类名.class;
// Class类提供 -classPath是类路径 (包名.类名)
Class cl=Class.forName(String classPath);
// Object提供
Class cl=类对象.getClass();

// Class类对象可操作
字段    File类
方法    Method类
构造器  Constructor类

javac命令将指定的.java文件编译成对应的.class文件;java命令在jvm虚拟机中通过类加载器执行,因识别字节码数据复杂易造成用户显示部分乱码;故将指定的.class文件封装到Java定义好的Class中;通过Class对象获取类成员对象,实现操作

4 使用反射机制的前提是符合JavaBean规范

① 类必须使用public作为访问权限

② 类中的所有成员属性必须使用private作为访问权限

③ 必须提供公有的无参构造器

④ 必须提供公有的get/set方法

5 区分成员属性和成员字段

① 成员属性:类中get/set方法去掉get/set后,单词首字母小写与成员字段一致时,称这个为属性

② 成员字段:必须使用private修饰的变量名

③ 当成员字段的类型为Boolean/boolean ;对应的get方法会变成is开头

6 使用反射机制操作类成员

① 编写一个符合JavaBean规范的类（员工类）

public class Employee {
    private Long id;
    private String name;
    private Boolean isWork;

    public Employee() {
    }
    public Employee(Long id, String name, Boolean isWork) {
        this.id = id;
        this.name = name;
        this.isWork = isWork;
    }

    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Boolean getWork() {
        return isWork;
    }
    public void setWork(Boolean work) {
        isWork = work;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", isWork=" + isWork +
                '}';
    }
}

② 操作无参构造器

public class EmployeeTest {
    // 操作无参构造器进行赋值
    @Test
    public void NoC() throws Exception{
        // 通过反射机制获取Class类对象
        Class cl=Employee.class;
        // 通过Class类对象获取指定类的无参构造器
        Employee ep= (Employee) cl.newInstance();
        ep.setId(Long.valueOf(3366));
        ep.setName("大黄");
        ep.setWork(true);
        System.err.println(ep.toString());
    }
}

③ 操作有参构造器

public class EmployeeTest {
    // 操作有参构造器
    @Test
    public void HaveC() throws Exception{
        // 通过反射机制获取Class类对象
        Class cl=Employee.class;
        // 通过Class类对象调用方法获取指定参数的构造器（...表示可变参数）
        // public Constructor getConstructor(Class... paramType)
        Constructor constructor=cl.getConstructor(Long.class,String.class,Boolean.class);
        // 通过构造器为员工对象赋值(Constructor类提供的方法,为指定的有参构造器初始化值)
        // public T newInstance(Object... init)
        Employee ep= (Employee) constructor.newInstance(1L,"大白",false);
        System.out.println(ep.toString());
    }
}

④ 操作成员方法

public class EmployeeTest {
    // 操作有参方法
    @Test
    public void TestHaveMethod() throws Exception{
        // 获取Class对象   Class提供的方法
        Class cl=Class.forName("cn.tj.domain.Employee");
        // 通过Class类对象获取对应参数的方法字节码对象
        // public Method getDeclareMethod(String name,Class... paramType)
        // 根据指定方法名和方法参数获取指定方法，name Bean中的方法名 paramType方法对象的参数类型字节码对象
        Method setEpName=cl.getDeclaredMethod("setName",String.class);
        // 通过Method类对象调用方法进行操作,给指定方法传递参数值 obj 当前调用方法属于指定类 init 给方法传递参数值
        // public T invoke(Object obj,Object... init)
        Employee ep= (Employee) cl.newInstance();
        setEpName.invoke(ep,"小黑");
        System.err.println(ep.getName());
    }
}

⑤ 操作成员属性

public class EmployeeTest {
    // 操作成员属性
    @Test
    public void testField() throws Exception{
        // 获取Class类对象 Object类的getClass方法
        Class cl= new Employee().getClass(); //匿名对象
        // 通过Class类对象获取Field类对象 根据字段名获取字段描述
        // public Field getDeclareField(String FieldName)
        Field id =cl.getDeclaredField("id");
        // 操作私有成员前需要申请操作权限   Field类提供 默认false(无权限)
        // public void setAccessible(boolean flag)
        id.setAccessible(true);
        // 通过Field类对象为字段赋值  将参数设置给指定类的字段
        // public void set(Object obj,Object value)
        Employee ep= (Employee) cl.newInstance();
        // 私有化属性赋值，需要获取对应字段的set方法赋值，或者获取私有化成员权限
        id.set(ep,Long.valueOf(2)); //等价于ep.id=Long.valueOf(2);
        // public的字段 或者 获得权限的private字段 才可以通过打点赋值
        System.err.println(ep.getId());
    }
}

二内省机制

1 作用

由于反射机制对成员字段操作不方便(成员字段私有化,在获取权限后,才能操作);java提出内省机制解决该问题

2 实现原理:

反射机制强调不通过new关键字实例化对象,故不推荐有参构造器赋值,内省机制实现原理是获取对应字段的set方法进行赋值(私有化成员赋值有参构造器或set方法)

3 内省机制

作用:Java中提供的专门操作成员字段的方式

使用前提:类必须符合JavaBean规范

核心类 : Introspector

4 内省与反射的内在联系和适用场景

① 内在联系:

符合JavaBean规范才能使用

内省机制的底层实现原理依赖于反射

② 适用场景

当操作成员方法和构造器的时候使用反射机制

当只操作成员字段的时候使用内省

5 内省操作字段

public class EmployeeTest {
    @Test
    public void testFields() throws Exception{
        // 通过Introspector对象获取指定类信息([begin,end)的所有类信息)
        // public static BeanInfo(Class begin,Class end)
        BeanInfo bi= Introspector.getBeanInfo(Employee.class,Object.class);
        // bi 含有类中所有成员字段(字段多且类型不同),故返回存放任意类型的集合
        // public PropertyDescriptor[] getPropertyDescriptors()  获取类中所有属性的数组
        PropertyDescriptor[] pds=bi.getPropertyDescriptors();
        // 获取类对象
        Employee ep=Employee.class.newInstance();
        for (PropertyDescriptor pd:pds){
            Method set=pd.getWriteMethod();
            // 分别获取指定属性对象名，与成员字段对比
            // public String getName()  PropertyDescriptor类提供  获取属性名
            if("id".equals(pd.getName())){
                // 通过内省的set方法为id属性赋值
                // public Method getWriteMethod() - set方法
                // public Method getReadMethod() - get方法
                set.invoke(ep,Long.valueOf(1));
            }else if("name".equals(pd.getName())){
                set.invoke(ep,"小花");
            }else if("isWork"!=null){
                set.invoke(ep,true);
            }
        }
        System.err.println(ep);
    }
}

6 JavaBean与Map集合之间的相互转换的原因

① 存储数据形式类似

JavaBean: 字段名=值

Map集合 KEY=VALUE

② 存储数据特点类似

JavaBean中的字段名和Map集合中的KEY都不能重复

③ 只要见到名=值这种形式的存储数据,都可以用Map集合的形式转换存储;集合中KEY的泛型一般为String类型,表示的是名字,VALUE泛型一般是Object类型,赋值任意类型的值

// JavaBean转换Map集合
public class EmployeeTest {
    @Test
    public void javaBeanToMap()throws Exception{
        // 创建一个Map集合并赋值
        Map<String,Object> map=new HashMap<>();
        Employee ep=new Employee(1L,"橘子",true);
        // 通过内省获得类信息
        BeanInfo eps= Introspector.getBeanInfo(Employee.class, Object.class);
        // 获取字段数组
        PropertyDescriptor[] pds=eps.getPropertyDescriptors();
        for (PropertyDescriptor pd:pds) {
            // 分别取一个属性的key和value 放入Map集合中
            String key=pd.getName();
            Object value=pd.getReadMethod().invoke(ep);
            map.put(key,value);
        }
        System.err.println(map);
    }
}


// Map集合转JavaBean
public class EmployeeTest {
    @Test
    public void mapToJavaBean()throws Exception{
        // 创建一个Map集合并赋值
        Map<String,Object> map=new HashMap<>();
        map.put("id",66L);
        map.put("name","火龙果");
        map.put("isWork",false);
        // 通过内省获得类信息
        Employee ep=Employee.class.newInstance();
        BeanInfo eps= Introspector.getBeanInfo(Employee.class, Object.class);
        // 获取字段数组
        PropertyDescriptor[] pds=eps.getPropertyDescriptors();
        for (PropertyDescriptor pd:pds) {
            // 分别取一个属性的key和value 放入Map集合中
            String key=pd.getName();
            Object value=map.get(key);
            // 将值赋值给字段
            pd.getWriteMethod().invoke(ep,value);
        }
        System.err.println(ep);
    }
}