个人中心
gpt4 book ai didi

java的反射用不好试试内省?

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 32 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章java的反射用不好试试内省?由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

Java的内省机制是什么？

内省（Introspection ）在心理学中，它是心理学基本研究方法之一。内省法又称自我观察法。它是发生在内部的，我们自己能够意识到的主观现象。也可以说是对于自己的主观经验及其变化的观察。正因为它的主观性，内省法自古以来就成为心理学界长期的争论。争论于它是否客观，是否可靠。另外内省也可看作自我反省，也是儒家强调的自我思考。从这个角度说它可以应用于计算机领域，例如Java内省机制和cocoa内省机制.

Java语言内省（Introspector）是Java语言对Bean类属性、事件的一种缺省处理方法。例如类A中有属性name,那我们可以通过getName,setName来得到其值或者设置新的值。通过getName/setName来访问name属性，这就是默认的规则。Java中提供了一套API用来访问某个属性的getter/setter方法，通过这些API可以使你不需要了解这个规则（但你最好还是要搞清楚），这些API存放于包java.beans中。一般的做法是通过类Introspector来获取某个对象的BeanInfo信息，然后通过BeanInfo来获取属性的描述器（PropertyDescriptor），通过这个属性描述器就可以获取某个属性对应的getter/setter方法，然后我们就可以通过反射机制来调用这些方法.

以上就是百科的解释。Java的内省最终是用Java的反射实现的。那为什么不直接用反射，要使用内省呢?

使用内省替代直接使用反射可以防止破坏类的封装

我们定义一个人的类型，其中包括年龄和是否成年两个属性。在修改年龄属性的时候会同时修改是否成年的属性。我们假设18岁和18岁以上就是成年，否则就是未成年.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.text.MessageFormat;
class Person {
     /**
      * 18岁成年
      */
     private static final int ADULT_AGE = 18 ;
     /**
      * 年龄
      */
     private int     age;
     /**
      * 是否成年
      */
     private boolean adult;
     public int getAge() {
         return age;
     }
     public void setAge( int age) {
         this .age = age;
         this .adult = age >= ADULT_AGE;
     }
     public boolean isAdult() {
         return adult;
     }
     public String toString() {
         return MessageFormat.format( "age：{0}，adult：{1}" , age, adult);
     }
}
/**
  * @author 二当家的白帽子 https://le-yi.blog.csdn.net/
  */
public class Test {
     /**
      * 利用反射修改对象属性
      * @param o
      * @param fieldName
      * @param value
      * @throws NoSuchFieldException
      * @throws IllegalAccessException
      */
     public static void changeObjectFieldByReflection(Object o, String fieldName, Object value) throws NoSuchFieldException, IllegalAccessException {
         Field field = o.getClass().getDeclaredField(fieldName);
         field.setAccessible( true );
         field.set(o, value);
     }
     /**
      * 利用内省修改对象属性
      * @param o
      * @param fieldName
      * @param value
      * @throws NoSuchFieldException
      * @throws IllegalAccessException
      */
     public static void changeObjectFieldByIntrospector(Object o, String fieldName, Object value) throws IntrospectionException, InvocationTargetException, IllegalAccessException {
         PropertyDescriptor pd = new PropertyDescriptor(fieldName, o.getClass());
         pd.getWriteMethod().invoke(o, value);
     }
     public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IntrospectionException, InvocationTargetException {
         Person p = new Person();
         changeObjectFieldByReflection(p, "age" , 20 );
         System.out.println( "反射修改属性破坏类的封装，使其内部状态错误：" );
         System.out.println(p);
         changeObjectFieldByIntrospector(p, "age" , 18 );
         System.out.println( "内省修改属性未破坏类的封装：" );
         System.out.println(p);
     }
}

java的反射用不好试试内省?

可以看到，反射由于是直接修改属性，所以破坏了类中封装的逻辑(20岁却不是成年).

而内省由于修改属性还是调用了set方法，也就是说和正常修改对象属性调用了相同的方法，所以类的封装性不会遭到破坏.

当然由于内省其实本质也是反射，可以说是封装了反射，所以如果反射用的正确，也是安全的，我们可以根据属性名去获取相应的set和get方法，然后再去调用，但是这种情况下内省使用起来就更方便，毕竟没有必要重复发明一个车轮子，圆形轮子已经是很多年很多年智慧的结晶了.

那么问题来了，既然内省就是调用set和get方法，那我为什么不直接调用set和get方法，而要使用内省呢?

使用内省也一样可以写出通用的工具 。

既然内省可以动态获取信息，那就和反射一样，可以实现出通用工具或者框架哦。我们这里实现一个可以拷贝任意类型两个对象的属性值的工具方法.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.MessageFormat;
class Person {
     /**
      * 18岁成年
      */
     private static final int ADULT_AGE = 18 ;
     /**
      * 名字
      */
     private final String  name;
     /**
      * 身高
      */
     private       int     height;
     /**
      * 年龄
      */
     private       int     age;
     /**
      * 是否成年
      */
     private       boolean adult;
     public Person(String name) {
         this .name = name;
     }
     public String getName() {
         return name;
     }
     public int getHeight() {
         return height;
     }
     public void setHeight( int height) {
         this .height = height;
     }
     public int getAge() {
         return age;
     }
     public void setAge( int age) {
         this .age = age;
         this .adult = age >= ADULT_AGE;
     }
     public boolean isAdult() {
         return adult;
     }
     public String toString() {
         return MessageFormat.format( "name：{0}，height：{1}，age：{2}，adult：{3}" , name, height, age, adult);
     }
}
/**
  * @author 二当家的白帽子 https://le-yi.blog.csdn.net/
  */
public class Test {
     /**
      * 将orig的可读属性值拷贝到dest的可写属性中
      * @param dest
      * @param orig
      * @param <T>
      * @throws IntrospectionException
      * @throws InvocationTargetException
      * @throws IllegalAccessException
      */
     public static <T> void copyProperties(T dest, T orig) throws IntrospectionException, InvocationTargetException, IllegalAccessException {
         BeanInfo beanInfo = Introspector.getBeanInfo(orig.getClass());
         PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
         for (PropertyDescriptor pd : pds) {
             Method rm = pd.getReadMethod();
             Method wm = pd.getWriteMethod();
             if (rm != null
                 && wm != null ) {
                 Object value = rm.invoke(orig);
                 wm.invoke(dest, value);
             }
         }
     }
     public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IntrospectionException, InvocationTargetException {
         Person p2 = new Person( "二当家的" );
         p2.setAge( 18 );
         p2.setHeight( 180 );
         System.out.println(p2);
         Person p1 = new Person( "大当家的" );
         System.out.println(p1);
         System.out.println( "将二当家的可读属性值拷贝给大当家的可写属性：" );
         copyProperties(p1, p2);
         System.out.println(p1);
     }
}

java的反射用不好试试内省?

可以看到，名字没有被拷贝，其他的属性值都顺利拷贝了。这也是我们期望的结果.

内省很好的保证了类的封装性，同时又具有动态获取对象属性，和动态修改对象属性的能力.

总结

和反射一样，一般的程序可能也用不到写内省的代码。但是像apache的beanutils这样方便的工具，如果没有反射也没有内省，我真的想不出如何实现呢。哪怕永远不需要用内省，了解机制对我们都有着莫大的好处.

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注我的更多内容！ 。

原文链接：https://blog.csdn.net/leyi520/article/details/118676211 。

最后此篇关于java的反射用不好试试内省?的文章就讲到这里了,如果你想了解更多关于java的反射用不好试试内省?的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

32 4 0
文章推荐： GitLabCI模板库的流水线优化实践
文章推荐： Java--装箱和拆箱详解
文章推荐： 微信红包200元图片 微信红包200整人表情包设置教程
文章推荐： python项目--使用Tkinter的日历GUI应用程序
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com