Java内省&PropertyEditor
1. 什么是内省?
内省(Introspector)是Java语言对JavaBean类属性、事件的处理方法。
例如类User中有属性name,那么必定有getName,setName方法,我们可以通过他们来获取或者设置值,这是常规操作。
Java提供了一套API来访问某个属性的getter/setter方法,这些API存放在java.beans中。
在计算机科学中,内省是指计算机程序在运行时(Run time)检查对象(Object)类型的一种能力,通常也可以称作运行时类型检查。
不应该将内省和反射混淆。相对于内省,反射更进一步,是指计算机程序在运行时(Run time)可以访问、检测和修改它本身状态或行为的一种能力。
内省和反射的区别:
反射是在运行状态把Java类中的各种成分映射成相应的Java类,可以动态的获取所有的属性以及动态调用任意一个方法,强调的是运行状态。
内省机制是通过反射来实现的,BeanInfo用来暴露一个bean的属性、方法和事件,以后我们就可以操纵该JavaBean的属性。
我自己的理解是:
内省更多的用在获取属性以及属性的的getter、setter方法,进行一些其他的操作。
反射更多的用在反射创建对象以及调用方法等操作。
2. 内省类库简介
比如User类:
package cn.qlq; public class User { private int age; private String name; private Address address; private boolean deleted; public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Address getAddress() { return address; } public void setAddress(Address address) { this.address = address; } public boolean isDeleted() { return deleted; } public void setDeleted(boolean deleted) { this.deleted = deleted; } } class Address { private String province; private String city; public String getProvince() { return province; } public void setProvince(String province) { this.province = province; } public String getCity() { return city; } public void setCity(String city) { this.city = city; } }
主要涉及的类库如下:
(1)Introspector类,可以获取BeanInfo类,常见的使用方法如下: (重要)
BeanInfo beanInfo = Introspector.getBeanInfo(user.getClass()); // 第二个参数代表停止的类,也就是如果有继承关系不获取第二个参数及其父类的信息 BeanInfo beanInfo2 = Introspector.getBeanInfo(user.getClass(), Object.class);
(2)BeanInfo类:通过上面的内省类获得 (重要)
BeanInfo beanInfo = Introspector.getBeanInfo(user.getClass(), Object.class);
作用1:获取BeanDescriptor一个全局的类描述信息
// 获取BeanDescriptor-一个全局的类描述信息 BeanDescriptor beanDescriptor = beanInfo.getBeanDescriptor(); System.out.println(beanDescriptor);
作用2:获取所有的PropertyDescriptor属性描述器(如果获取BeanInfo的时候第二个参数没传会获取从Object继承的信息)
private static void testBeanInfo2(User user) throws Exception { BeanInfo beanInfo = Introspector.getBeanInfo(user.getClass(), Object.class); // 获取PropertyDescriptor描述器 PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors(); for (PropertyDescriptor propertyDescriptor : propertyDescriptors) { // 获取属性类型 Class<?> propertyType = propertyDescriptor.getPropertyType(); // 获取属性名称 String name = propertyDescriptor.getName(); // 获取属性的读方法,getXXX Method readMethod = propertyDescriptor.getReadMethod(); // 获取属性的写方法,setXXX Method writeMethod = propertyDescriptor.getWriteMethod(); System.out.println(name); System.out.println(propertyType); System.out.println(readMethod.getName()); System.out.println(writeMethod.getName()); System.out.println("=============="); } }
结果:
address
class cn.qlq.Address
getAddress
setAddress
==============
age
int
getAge
setAge
==============
deleted
boolean
isDeleted
setDeleted
==============
name
class java.lang.String
getName
setName
==============
作用3: 获取MethodDescriptor描述器(如果获取BeanInfo的时候第二个参数没传会获取从Object继承的方法)
BeanInfo beanInfo = Introspector.getBeanInfo(user.getClass(), Object.class); // 获取MethodDescriptor描述器 MethodDescriptor[] methodDescriptors = beanInfo.getMethodDescriptors(); for (MethodDescriptor methodDescriptor : methodDescriptors) { Method method = methodDescriptor.getMethod(); System.out.println(method); }
结果:
public java.lang.String cn.qlq.User.getName()
public void cn.qlq.User.setAge(int)
public void cn.qlq.User.setName(java.lang.String)
public int cn.qlq.User.getAge()
public boolean cn.qlq.User.isDeleted()
public cn.qlq.Address cn.qlq.User.getAddress()
public void cn.qlq.User.setAddress(cn.qlq.Address)
public void cn.qlq.User.setDeleted(boolean)
作用4:获取EventSetDescriptor(这个不常用)
BeanInfo beanInfo = Introspector.getBeanInfo(user.getClass(), Object.class); // 获取EventSetDescriptor描述器 EventSetDescriptor[] eventSetDescriptors = beanInfo.getEventSetDescriptors(); for (EventSetDescriptor eventSetDescriptor : eventSetDescriptors) { System.out.println(eventSetDescriptor); }
(3)BeanDescriptor 一个全局的Bean描述信息,一般没啥用
BeanInfo beanInfo = Introspector.getBeanInfo(user.getClass(), Object.class); // 获取BeanDescriptor-一个全局的类描述信息 BeanDescriptor beanDescriptor = beanInfo.getBeanDescriptor(); System.out.println(beanDescriptor);
(4)PropertyDescriptor 属性描述器,可以获取到属性名称、属性的get方法以及set方法,进而做到修改方法。
其获取方式可以通过BeanInfo获取,也可以通过直接new的方式获取。
方式一:
BeanInfo beanInfo = Introspector.getBeanInfo(user.getClass(), Object.class); // 获取PropertyDescriptor描述器 PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors(); for (PropertyDescriptor propertyDescriptor : propertyDescriptors) { // 获取属性类型 Class<?> propertyType = propertyDescriptor.getPropertyType(); // 获取属性名称 String name = propertyDescriptor.getName(); // 获取属性的读方法,getXXX Method readMethod = propertyDescriptor.getReadMethod(); // 获取属性的写方法,setXXX Method writeMethod = propertyDescriptor.getWriteMethod(); System.out.println(name); System.out.println(propertyType); System.out.println(readMethod.getName()); System.out.println(writeMethod.getName()); System.out.println("=============="); }
方式二:通过直接new的方式
User user = new User(); user.setName("zhangsan"); PropertyDescriptor propertyDescriptor = new PropertyDescriptor("name", User.class); // 获取getter方法读取属性 Method readMethod = propertyDescriptor.getReadMethod(); Object invoke = readMethod.invoke(user); System.out.println(invoke); // 获取setter方法修改属性 Method writeMethod = propertyDescriptor.getWriteMethod(); writeMethod.invoke(user, "lisi"); System.out.println(user.getName());
结果:
zhangsan
lisi
如果属性不存在会报错如下:
Exception in thread "main" java.beans.IntrospectionException: Method not found: isNamess
at java.beans.PropertyDescriptor.<init>(PropertyDescriptor.java:107)
at java.beans.PropertyDescriptor.<init>(PropertyDescriptor.java:71)
at cn.qlq.Client.main(Client.java:14)
(5) MethodDescriptor 方法描述器,可以获取方法的名称、Method等信息
其获取方式可以通过BeanInfo获取
BeanInfo beanInfo = Introspector.getBeanInfo(user.getClass(), Object.class); // 获取MethodDescriptor描述器 MethodDescriptor[] methodDescriptors = beanInfo.getMethodDescriptors(); for (MethodDescriptor methodDescriptor : methodDescriptors) { System.out.println(methodDescriptor); Method method = methodDescriptor.getMethod(); }
3. 内省的应用
采用内省实现的JavaBean转Map和List<Bean>转List<Map>、Map转Bean、Maps转Beans、实现将1个bean的属性赋值给另1个bean(属性拷贝)
package cn.qs.utils; import java.beans.BeanInfo; import java.beans.Introspector; import java.beans.PropertyDescriptor; import java.lang.reflect.Method; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import org.apache.commons.lang3.ArrayUtils; public class BeanUtils { /** * 内省进行数据转换-javaBean转map * * @param obj * 需要转换的bean * @return 转换完成的map * @throws Exception */ public static <T> Map<String, Object> beanToMap(T obj, boolean putIfNull) throws Exception { Map<String, Object> map = new HashMap<>(); // 获取javaBean的BeanInfo对象 BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass(), Object.class); // 获取属性描述器 PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors(); for (PropertyDescriptor propertyDescriptor : propertyDescriptors) { // 获取属性名 String key = propertyDescriptor.getName(); // 获取该属性的值 Method readMethod = propertyDescriptor.getReadMethod(); // 通过反射来调用javaBean定义的getName()方法 Object value = readMethod.invoke(obj); if (value == null && !putIfNull) { continue; } map.put(key, value); } return map; } public static <T> List<Map<String, Object>> beansToMaps(List<T> objs, boolean putIfNull) throws Exception { return beansToMaps(objs, putIfNull, false); } public static <T> List<Map<String, Object>> beansToMaps(List<T> objs, boolean putIfNull, boolean addIndex) throws Exception { List<Map<String, Object>> result = new ArrayList<>(); Map<String, Object> beanToMap = null; int index = 0; for (Object obj : objs) { beanToMap = beanToMap(obj, putIfNull); if (addIndex) { beanToMap.put("index", ++index); } result.add(beanToMap); } return result; } /** * Map转bean * * @param map * map * @param clz * 被转换的类字节码对象 * @return * @throws Exception */ public static <T> T map2Bean(Map<String, Object> map, Class<T> clz) throws Exception { // new 出一个对象 T obj = clz.newInstance(); // 获取person类的BeanInfo对象 BeanInfo beanInfo = Introspector.getBeanInfo(clz, Object.class); // 获取属性描述器 PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors(); for (PropertyDescriptor propertyDescriptor : propertyDescriptors) { // 获取属性名 String key = propertyDescriptor.getName(); Object value = map.get(key); // 通过反射来调用Person的定义的setName()方法 Method writeMethod = propertyDescriptor.getWriteMethod(); writeMethod.invoke(obj, value); } return obj; } public static <T> List<T> maps2Beans(List<Map<String, Object>> maps, Class<T> clz) throws Exception { List<T> result = new ArrayList<>(); for (Map<String, Object> map : maps) { result.add(map2Bean(map, clz)); } return result; } /** * 复制origin的值到dest上 * * @param dest * 目标对象 * @param origin * 元对象 * @param setNull * 如果源对象属性为null是否拷贝 * @param excludeFieldNames * 排除的属性 */ public static <T> void copyProperties(T dest, T origin, boolean setNull, String[] excludeFieldNames) { try { // 获取person类的BeanInfo对象 BeanInfo destBeanInfo = Introspector.getBeanInfo(dest.getClass(), Object.class); // 获取目标属性描述器 PropertyDescriptor[] destBeanInfoPropertyDescriptors = destBeanInfo.getPropertyDescriptors(); for (PropertyDescriptor propertyDescriptor : destBeanInfoPropertyDescriptors) { // 获取属性名 String key = propertyDescriptor.getName(); if (ArrayUtils.contains(excludeFieldNames, key)) { continue; } // 获取该属性的值 Method readMethod = propertyDescriptor.getReadMethod(); // 如果源对象没有对应属性就跳过 Object srcValue = null; try { srcValue = readMethod.invoke(origin); } catch (Exception ignored) { // ignored continue; } // 如果源对象的值null且null不设置的时候跳过 if (srcValue == null && !setNull) { continue; } // 获取setter方法修改属性 Method writeMethod = propertyDescriptor.getWriteMethod(); writeMethod.invoke(dest, srcValue); } } catch (Exception ignored) { // ignored } } public static <T> void copyProperties(T dest, T origin) { copyProperties(dest, origin, false, null); } }
4. PropertyEditor
java.beans.PropertyEditor 属性编辑器位于jre中rt.lib 中。用于类型转换,可以理解为一个封装好的类型转换类。
1. 简单使用如下:
package pt; import lombok.Data; @Data public class MyUser { private String username; private int age; }
定义自己的转换器:
package pt; import java.awt.*; import java.beans.PropertyChangeListener; import java.beans.PropertyEditor; public class MyUserPropertyEditor implements PropertyEditor { private String text; private Object value; public MyUserPropertyEditor() { System.out.println("pt.MyUserPropertyEditor.MyUserPropertyEditor"); } @Override public void setValue(Object value) { this.value = value; } @Override public Object getValue() { MyUser myUser = new MyUser(); String[] split = this.text.split("-"); myUser.setAge(Integer.valueOf(split[1])); myUser.setUsername(split[0]); return myUser; } @Override public boolean isPaintable() { return false; } @Override public void paintValue(Graphics gfx, Rectangle box) { } @Override public String getJavaInitializationString() { System.out.println("pt.MyUserPropertyEditor.getJavaInitializationString"); return null; } @Override public String getAsText() { return text; } @Override public void setAsText(String text) throws IllegalArgumentException { this.text = text; } @Override public String[] getTags() { return new String[0]; } @Override public Component getCustomEditor() { return null; } @Override public boolean supportsCustomEditor() { return false; } @Override public void addPropertyChangeListener(PropertyChangeListener listener) { } @Override public void removePropertyChangeListener(PropertyChangeListener listener) { } }
测试如下:
package pt; import java.beans.PropertyEditor; import java.beans.PropertyEditorManager; public class Client2 { public static void main(String[] args) { PropertyEditorManager.registerEditor(MyUser.class, MyUserPropertyEditor.class); // 每次调用的时候会到缓存map 找,然后反射创建对象 PropertyEditor editor = PropertyEditorManager.findEditor(MyUser.class); editor.setValue("user1-25"); editor.setAsText("usertext1-225"); System.out.println(editor.getAsText()); System.out.println(editor.getValue()); PropertyEditor editor2 = PropertyEditorManager.findEditor(MyUser.class); System.out.println(editor2.getAsText()); } }
结果:
pt.MyUserPropertyEditor.MyUserPropertyEditor usertext1-225 MyUser(username=usertext1, age=225) pt.MyUserPropertyEditor.MyUserPropertyEditor null
debug 发现,我们注册以及查找的时候是从缓存查找的:com.sun.beans.finder.PropertyEditorFinder#find 源码如下:
// // Source code recreated from a .class file by IntelliJ IDEA // (powered by FernFlower decompiler) // package com.sun.beans.finder; import com.sun.beans.WeakCache; import com.sun.beans.editors.BooleanEditor; import com.sun.beans.editors.ByteEditor; import com.sun.beans.editors.DoubleEditor; import com.sun.beans.editors.EnumEditor; import com.sun.beans.editors.FloatEditor; import com.sun.beans.editors.IntegerEditor; import com.sun.beans.editors.LongEditor; import com.sun.beans.editors.ShortEditor; import java.beans.PropertyEditor; public final class PropertyEditorFinder extends InstanceFinder<PropertyEditor> { private static final String DEFAULT = "sun.beans.editors"; private static final String DEFAULT_NEW = "com.sun.beans.editors"; private final WeakCache<Class<?>, Class<?>> registry = new WeakCache(); public PropertyEditorFinder() { super(PropertyEditor.class, false, "Editor", new String[]{"sun.beans.editors"}); this.registry.put(Byte.TYPE, ByteEditor.class); this.registry.put(Short.TYPE, ShortEditor.class); this.registry.put(Integer.TYPE, IntegerEditor.class); this.registry.put(Long.TYPE, LongEditor.class); this.registry.put(Boolean.TYPE, BooleanEditor.class); this.registry.put(Float.TYPE, FloatEditor.class); this.registry.put(Double.TYPE, DoubleEditor.class); } public void register(Class<?> var1, Class<?> var2) { synchronized(this.registry) { this.registry.put(var1, var2); } } public PropertyEditor find(Class<?> var1) { Class var2; synchronized(this.registry) { var2 = (Class)this.registry.get(var1); } Object var3 = (PropertyEditor)this.instantiate(var2, (String)null); if (var3 == null) { var3 = (PropertyEditor)super.find(var1); if (var3 == null && null != var1.getEnumConstants()) { var3 = new EnumEditor(var1); } } return (PropertyEditor)var3; } protected PropertyEditor instantiate(Class<?> var1, String var2, String var3) { return (PropertyEditor)super.instantiate(var1, "sun.beans.editors".equals(var2) ? "com.sun.beans.editors" : var2, var3); } }
可以看到find 是从缓存中查找,查找到之后反射创建类实例。
2. JVM 提供了一个java.beans.PropertyEditorSupport, 我们可以选择该类并实现相关方法
(0) java.beans.PropertyEditorSupport 源码如下:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
/* * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package java.beans; import java.beans.*; /** * This is a support class to help build property editors. * <p> * It can be used either as a base class or as a delegate. */ public class PropertyEditorSupport implements PropertyEditor { /** * Constructs a <code>PropertyEditorSupport</code> object. * * @since 1.5 */ public PropertyEditorSupport() { setSource(this); } /** * Constructs a <code>PropertyEditorSupport</code> object. * * @param source the source used for event firing * @since 1.5 */ public PropertyEditorSupport(Object source) { if (source == null) { throw new NullPointerException(); } setSource(source); } /** * Returns the bean that is used as the * source of events. If the source has not * been explicitly set then this instance of * <code>PropertyEditorSupport</code> is returned. * * @return the source object or this instance * @since 1.5 */ public Object getSource() { return source; } /** * Sets the source bean. * <p> * The source bean is used as the source of events * for the property changes. This source should be used for information * purposes only and should not be modified by the PropertyEditor. * * @param source source object to be used for events * @since 1.5 */ public void setSource(Object source) { this.source = source; } /** * Set (or change) the object that is to be edited. * * @param value The new target object to be edited. Note that this * object should not be modified by the PropertyEditor, rather * the PropertyEditor should create a new object to hold any * modified value. */ public void setValue(Object value) { this.value = value; firePropertyChange(); } /** * Gets the value of the property. * * @return The value of the property. */ public Object getValue() { return value; } //---------------------------------------------------------------------- /** * Determines whether the class will honor the paintValue method. * * @return True if the class will honor the paintValue method. */ public boolean isPaintable() { return false; } /** * Paint a representation of the value into a given area of screen * real estate. Note that the propertyEditor is responsible for doing * its own clipping so that it fits into the given rectangle. * <p> * If the PropertyEditor doesn't honor paint requests (see isPaintable) * this method should be a silent noop. * * @param gfx Graphics object to paint into. * @param box Rectangle within graphics object into which we should paint. */ public void paintValue(java.awt.Graphics gfx, java.awt.Rectangle box) { } //---------------------------------------------------------------------- /** * This method is intended for use when generating Java code to set * the value of the property. It should return a fragment of Java code * that can be used to initialize a variable with the current property * value. * <p> * Example results are "2", "new Color(127,127,34)", "Color.orange", etc. * * @return A fragment of Java code representing an initializer for the * current value. */ public String getJavaInitializationString() { return "???"; } //---------------------------------------------------------------------- /** * Gets the property value as a string suitable for presentation * to a human to edit. * * @return The property value as a string suitable for presentation * to a human to edit. * <p> Returns null if the value can't be expressed as a string. * <p> If a non-null value is returned, then the PropertyEditor should * be prepared to parse that string back in setAsText(). */ public String getAsText() { return (this.value != null) ? this.value.toString() : null; } /** * Sets the property value by parsing a given String. May raise * java.lang.IllegalArgumentException if either the String is * badly formatted or if this kind of property can't be expressed * as text. * * @param text The string to be parsed. */ public void setAsText(String text) throws java.lang.IllegalArgumentException { if (value instanceof String) { setValue(text); return; } throw new java.lang.IllegalArgumentException(text); } //---------------------------------------------------------------------- /** * If the property value must be one of a set of known tagged values, * then this method should return an array of the tag values. This can * be used to represent (for example) enum values. If a PropertyEditor * supports tags, then it should support the use of setAsText with * a tag value as a way of setting the value. * * @return The tag values for this property. May be null if this * property cannot be represented as a tagged value. * */ public String[] getTags() { return null; } //---------------------------------------------------------------------- /** * A PropertyEditor may chose to make available a full custom Component * that edits its property value. It is the responsibility of the * PropertyEditor to hook itself up to its editor Component itself and * to report property value changes by firing a PropertyChange event. * <P> * The higher-level code that calls getCustomEditor may either embed * the Component in some larger property sheet, or it may put it in * its own individual dialog, or ... * * @return A java.awt.Component that will allow a human to directly * edit the current property value. May be null if this is * not supported. */ public java.awt.Component getCustomEditor() { return null; } /** * Determines whether the propertyEditor can provide a custom editor. * * @return True if the propertyEditor can provide a custom editor. */ public boolean supportsCustomEditor() { return false; } //---------------------------------------------------------------------- /** * Adds a listener for the value change. * When the property editor changes its value * it should fire a {@link PropertyChangeEvent} * on all registered {@link PropertyChangeListener}s, * specifying the {@code null} value for the property name. * If the source property is set, * it should be used as the source of the event. * <p> * The same listener object may be added more than once, * and will be called as many times as it is added. * If {@code listener} is {@code null}, * no exception is thrown and no action is taken. * * @param listener the {@link PropertyChangeListener} to add */ public synchronized void addPropertyChangeListener( PropertyChangeListener listener) { if (listeners == null) { listeners = new java.util.Vector<>(); } listeners.addElement(listener); } /** * Removes a listener for the value change. * <p> * If the same listener was added more than once, * it will be notified one less time after being removed. * If {@code listener} is {@code null}, or was never added, * no exception is thrown and no action is taken. * * @param listener the {@link PropertyChangeListener} to remove */ public synchronized void removePropertyChangeListener( PropertyChangeListener listener) { if (listeners == null) { return; } listeners.removeElement(listener); } /** * Report that we have been modified to any interested listeners. */ public void firePropertyChange() { java.util.Vector<PropertyChangeListener> targets; synchronized (this) { if (listeners == null) { return; } targets = unsafeClone(listeners); } // Tell our listeners that "everything" has changed. PropertyChangeEvent evt = new PropertyChangeEvent(source, null, null, null); for (int i = 0; i < targets.size(); i++) { PropertyChangeListener target = targets.elementAt(i); target.propertyChange(evt); } } @SuppressWarnings("unchecked") private <T> java.util.Vector<T> unsafeClone(java.util.Vector<T> v) { return (java.util.Vector<T>)v.clone(); } //---------------------------------------------------------------------- private Object value; private Object source; private java.util.Vector<PropertyChangeListener> listeners; }
(1)查看JVM的实现 com.sun.beans.editors.IntegerEditor
package com.sun.beans.editors; public class IntegerEditor extends NumberEditor { public IntegerEditor() { } public void setAsText(String var1) throws IllegalArgumentException { this.setValue(var1 == null ? null : Integer.decode(var1)); } }
package com.sun.beans.editors; import java.beans.PropertyEditorSupport; public abstract class NumberEditor extends PropertyEditorSupport { public NumberEditor() { } public String getJavaInitializationString() { Object var1 = this.getValue(); return var1 != null ? var1.toString() : "null"; } }
(2) 编写自己的类
package pt; import java.beans.PropertyEditorSupport; public class MyPrt extends PropertyEditorSupport { @Override public void setAsText(String text) throws IllegalArgumentException { MyUser myUser = new MyUser(); String[] split = text.split("-"); myUser.setAge(Integer.valueOf(split[1])); myUser.setUsername(split[0]); this.setValue(myUser); } }
(3) 测试:
package pt; import java.beans.PropertyEditor; import java.beans.PropertyEditorManager; public class Client2 { public static void main(String[] args) { PropertyEditorManager.registerEditor(MyUser.class, MyPrt.class); // 每次调用的时候会到缓存map 找,然后反射创建对象 PropertyEditor editor = PropertyEditorManager.findEditor(MyUser.class); editor.setAsText("usertext1-225"); System.out.println(editor.getAsText()); System.out.println(editor.getValue()); PropertyEditor editor2 = PropertyEditorManager.findEditor(MyUser.class); System.out.println(editor2.getAsText()); } }
结果:
MyUser(username=usertext1, age=225) MyUser(username=usertext1, age=225) null
总结:
如果通过BeanInfo操作属性的话,一般需要过滤掉Object继承的东西,也就是获取BeanInfo的时候如下:
BeanInfo beanInfo = Introspector.getBeanInfo(user.getClass(), Object.class);
关于反射的使用参考: https://www.cnblogs.com/qlqwjy/p/7551550.html