转载

【小家Spring】聊聊Spring中的数据绑定 --- BeanWrapper以及内省Introspector和PropertyDescriptor

每篇一句

千古以来要饭的没有要早饭的，知道为什么吗？

相关阅读

【小家Spring】聊聊Spring中的数据转换：Converter、ConversionService、TypeConverter、PropertyEditor 【小家Spring】聊聊Spring中的数据绑定 --- 属性访问器PropertyAccessor和实现类DirectFieldAccessor的使用

对Spring感兴趣可扫码加入wx群： Java高工、架构师3群 （文末有二维码）

前言

这篇文章需要依赖于对属性访问器 PropertyAccessor 的理解，也就是上篇文章的内容： 【小家Spring】聊聊Spring中的数据绑定 --- 属性访问器PropertyAccessor和实现类DirectFieldAccessor的使用

如果说上篇文章所说的 PropertyAccessor 你没有接触过和听过，那么本文即将要说的重点： BeanWrapper 你应该多少有所耳闻吧~ BeanWrapper 可以简单的把它理解为：一个方便开发人员 使用字符串 来对 Java Bean 的属性执行get、set操作的工具。关于它的数据转换使用了如下两种机制：

  1. PropertyEditor ：隶属于 Java Bean规范 。 PropertyEditor 只提供了 String <-> Object 的转换。
  2. ConversionService ：Spring自3.0之后提供的替代PropertyEditor的机制（ BeanWrapper 在Spring的第一个版本就存在了~）

    按照Spring官方文档的说法，当容器内没有注册 ConversionService 的时候，会退回使用 PropertyEditor 机制。言外之意：首选方案是 ConversionService

    其实了解的伙伴应该知道，这不是 BeanWrapper 的内容，而是父接口 PropertyAccessor 的内容~

BeanWrapper

官方解释：Spring低级JavaBeans基础设施的中央接口。通常来说并不直接使用 BeanWrapper ，而是借助 BeanFactory 或者 DataBinder 来一起使用~ 

//@since 13 April 2001  很清晰的看到，它也是个`PropertyAccessor`属性访问器
public interface BeanWrapper extends ConfigurablePropertyAccessor {

    // @since 4.1
    void setAutoGrowCollectionLimit(int autoGrowCollectionLimit);
    int getAutoGrowCollectionLimit();


    Object getWrappedInstance();
    Class<?> getWrappedClass();

    // 获取属性们的PropertyDescriptor  获取属性们
    PropertyDescriptor[] getPropertyDescriptors();
    // 获取具体某一个属性~
    PropertyDescriptor getPropertyDescriptor(String propertyName) throws InvalidPropertyException;
}复制代码

BeanWrapper 相当于一个代理器，Spring委托 BeanWrapper 完成Bean属性的填充工作。关于此接口的实现类，简单的说它只有唯一实现类： BeanWrapperImpl

BeanWrapperImpl

它作为 BeanWrapper 接口的默认实现，它足以满足所有的典型应用场景，它会缓存Bean的内省结果而提高效率。

在Spring2.5之前，此实现类是非public的，但在2.5之后给public了并且还提供了工厂： PropertyAccessorFactory 帮助第三方框架能快速获取到一个实例~ 

public class BeanWrapperImpl extends AbstractNestablePropertyAccessor implements BeanWrapper {

    // 缓存内省结果~
    @Nullable
    private CachedIntrospectionResults cachedIntrospectionResults;
    // The security context used for invoking the property methods.
    @Nullable
    private AccessControlContext acc;

    // 构造方法都是沿用父类的~
    public BeanWrapperImpl() {
        this(true);
    }
    ... 
    private BeanWrapperImpl(Object object, String nestedPath, BeanWrapperImpl parent) {
        super(object, nestedPath, parent);
        setSecurityContext(parent.acc);
    }


    // @since 4.3  设置目标对象~~~
    public void setBeanInstance(Object object) {
        this.wrappedObject = object;
        this.rootObject = object;
        this.typeConverterDelegate = new TypeConverterDelegate(this, this.wrappedObject);
        // 设置内省的clazz
        setIntrospectionClass(object.getClass());
    }

    // 复写父类的方法  增加内省逻辑
    @Override
    public void setWrappedInstance(Object object, @Nullable String nestedPath, @Nullable Object rootObject) {
        super.setWrappedInstance(object, nestedPath, rootObject);
        setIntrospectionClass(getWrappedClass());
    }

    // 如果cachedIntrospectionResults它持有的BeanClass并不是传入的clazz 那就清空缓存 重新来~~~
    protected void setIntrospectionClass(Class<?> clazz) {
        if (this.cachedIntrospectionResults != null && this.cachedIntrospectionResults.getBeanClass() != clazz) {
            this.cachedIntrospectionResults = null;
        }
    }
    private CachedIntrospectionResults getCachedIntrospectionResults() {
        if (this.cachedIntrospectionResults == null) {
            // forClass此方法：生成此clazz的类型结果，并且缓存了起来~~
            this.cachedIntrospectionResults = CachedIntrospectionResults.forClass(getWrappedClass());
        }
        return this.cachedIntrospectionResults;
    }
    ...

    // 获取到此属性的处理器。此处是个BeanPropertyHandler 内部类~
    @Override
    @Nullable
    protected BeanPropertyHandler getLocalPropertyHandler(String propertyName) {
        PropertyDescriptor pd = getCachedIntrospectionResults().getPropertyDescriptor(propertyName);
        return (pd != null ? new BeanPropertyHandler(pd) : null);
    }
    @Override
    protected BeanWrapperImpl newNestedPropertyAccessor(Object object, String nestedPath) {
        return new BeanWrapperImpl(object, nestedPath, this);
    }
    @Override
    public PropertyDescriptor[] getPropertyDescriptors() {
        return getCachedIntrospectionResults().getPropertyDescriptors();
    }

    // 获取具体某一个属性的PropertyDescriptor 
    @Override
    public PropertyDescriptor getPropertyDescriptor(String propertyName) throws InvalidPropertyException {
        BeanWrapperImpl nestedBw = (BeanWrapperImpl) getPropertyAccessorForPropertyPath(propertyName);
        String finalPath = getFinalPath(nestedBw, propertyName);
        PropertyDescriptor pd = nestedBw.getCachedIntrospectionResults().getPropertyDescriptor(finalPath);
        if (pd == null) {
            throw new InvalidPropertyException(getRootClass(), getNestedPath() + propertyName, "No property '" + propertyName + "' found");
        }
        return pd;
    }
    ...

    // 此处理器处理的是PropertyDescriptor 
    private class BeanPropertyHandler extends PropertyHandler {
        private final PropertyDescriptor pd;

        // 是否可读、可写  都是由PropertyDescriptor 去决定了~
        // java.beans.PropertyDescriptor~~
        public BeanPropertyHandler(PropertyDescriptor pd) {
            super(pd.getPropertyType(), pd.getReadMethod() != null, pd.getWriteMethod() != null);
            this.pd = pd;
        }
        ...
        @Override
        @Nullable
        public Object getValue() throws Exception {
            ...
            ReflectionUtils.makeAccessible(readMethod);
            return readMethod.invoke(getWrappedInstance(), (Object[]) null);
        }
        ...
    }
}复制代码

从继承体系上，首先我们应该能看出来 BeanWrapperImpl 的三重身份：

  1. Bean包裹器
  2. 属性访问器（PropertyAccessor）
  3. 属性编辑器注册表（PropertyEditorRegistry）

从源码中继续分析还能再得出如下两个结论：

  1. 它给属性赋值调用的是Method方法，如 readMethod.invoke 和 writeMethod.invoke
  2. 它对Bean的操作，大都委托给 CachedIntrospectionResults 去完成~

因此若想了解它，必然主要是要先了解 java.beans.PropertyDescriptor 和 org.springframework.beans.CachedIntrospectionResults ，首当其冲的自然还有 Java内省 。

Java内省 Introspector

首先可以先了解下 JavaBean的概念 ：一种特殊的类，主要用于传递数据信息。这种类中的方法主要用于访问私有的字段，且方法名 符合某种命名规则 。如果在两个模块之间传递信息，可以将信息封装进JavaBean中，这种对象称为“值对象”( Value Object )，或“ VO ”。

因此JavaBean都有如下几个特征：

  1. 属性都是私有的；
  2. 有无参的public构造方法；
  3. 对私有属性根据需要提供 公有的 getXxx方法以及setXxx方法；
  4. getters必须有返回值没有方法参数；setter值没有返回值，有方法参数；

符合这些特征的类，被称为JavaBean；JDK中提供了一套API用来访问某个属性的getter/setter方法，这些API存放在 java.beans 中，这就是 内省(Introspector) 。

==内省和反射的区别==

反射：Java反射机制是在运行中，对任意一个类，能够获取得到这个类的所有属性和方法；它针对的是 任意类 内省（Introspector） ：是Java语言对JavaBean类属性、事件的处理方法

  1. 反射可以操作 各种类的属性 ，而内省只是通过反射来操作 JavaBean 的属性
  2. 内省设置属性值肯定会调用seter方法，反射可以不用（反射可直接操作属性Field）
  3. 反射就像照镜子，然后能看到.class的所有，是客观的事实。内省更像主观的判断：比如看到getName()内省就会认为这个类中有name字段，但事实上并不一定会有name；通过内省可以获取bean的getter/setter

既然反射比内省比内省强大这么多， 那内省用在什么时候场景呢 ？下面给出一个示例来说明它的用武之地： 

// 就这样简单几步，就完成了表单到User对象的封装~
    public void insertUser(HttpServletRequest request) throws Exception {
        User user = new User();

        // 遍历：根据字段名去拿值即可（此处省略判空、类型转换等细节，不在本文讨论范围）
        PropertyDescriptor[] pds = Introspector.getBeanInfo(User.class).getPropertyDescriptors();
        for (PropertyDescriptor pd : pds) {
            pd.getWriteMethod().invoke(user, request.getParameter(pd.getName()));
        }
    }复制代码

通过内省可以很轻松的将form表单的内容填充进对象里面，比反射轻松省力多了。其实像MyBatis这种框架，底层都用到了Java的内省机制。

内省的API主要有Introspector、BeanInfo、PropertyDescriptor等，下面就以他三为例来操作一个JavaBean：

@Getter
@Setter
@ToString
public class Child {

    private String name;
    private Integer age;
    
}复制代码

使用 Introspector + BeanInfo ： 

public static void main(String[] args) throws IntrospectionException {
        BeanInfo beanInfo = Introspector.getBeanInfo(Child.class);

        BeanDescriptor beanDescriptor = beanInfo.getBeanDescriptor();
        MethodDescriptor[] methodDescriptors = beanInfo.getMethodDescriptors();
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();

        // 打印
        System.out.println(beanDescriptor);
        System.out.println("------------------------------");
        Arrays.stream(methodDescriptors).forEach(x -> System.out.println(x));
        System.out.println("------------------------------");
        Arrays.stream(propertyDescriptors).forEach(x -> System.out.println(x));
        System.out.println("------------------------------");
    }复制代码

输入内容如下：

java.beans.BeanDescriptor[name=Child; beanClass=class com.fsx.bean.Child]
------------------------------
java.beans.MethodDescriptor[name=getClass; method=public final native java.lang.Class java.lang.Object.getClass()]
java.beans.MethodDescriptor[name=getName; method=public java.lang.String com.fsx.bean.Child.getName()]
java.beans.MethodDescriptor[name=setAge; method=public void com.fsx.bean.Child.setAge(java.lang.Integer)]
java.beans.MethodDescriptor[name=setName; method=public void com.fsx.bean.Child.setName(java.lang.String)]
java.beans.MethodDescriptor[name=getAge; method=public java.lang.Integer com.fsx.bean.Child.getAge()]
java.beans.MethodDescriptor[name=wait; method=public final void java.lang.Object.wait() throws java.lang.InterruptedException]
java.beans.MethodDescriptor[name=notifyAll; method=public final native void java.lang.Object.notifyAll()]
java.beans.MethodDescriptor[name=notify; method=public final native void java.lang.Object.notify()]
java.beans.MethodDescriptor[name=wait; method=public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException]
java.beans.MethodDescriptor[name=hashCode; method=public native int java.lang.Object.hashCode()]
java.beans.MethodDescriptor[name=wait; method=public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException]
java.beans.MethodDescriptor[name=equals; method=public boolean java.lang.Object.equals(java.lang.Object)]
java.beans.MethodDescriptor[name=toString; method=public java.lang.String com.fsx.bean.Child.toString()]
------------------------------
java.beans.PropertyDescriptor[name=age; propertyType=class java.lang.Integer; readMethod=public java.lang.Integer com.fsx.bean.Child.getAge(); writeMethod=public void com.fsx.bean.Child.setAge(java.lang.Integer)]
java.beans.PropertyDescriptor[name=class; propertyType=class java.lang.Class; readMethod=public final native java.lang.Class java.lang.Object.getClass()]
java.beans.PropertyDescriptor[name=name; propertyType=class java.lang.String; readMethod=public java.lang.String com.fsx.bean.Child.getName(); writeMethod=public void com.fsx.bean.Child.setName(java.lang.String)]
------------------------------复制代码

可以看到 getMethodDescriptors() 它把父类的 MethodDescriptor 也拿出来了。而 PropertyDescriptor 中比较特殊的是因为有 getClass() 方法，因此class也算是一个 PropertyDescriptor ，但是它没有 writeMethod 哦~

关于 BeanInfo ，Spring在3.1提供了一个类 ExtendedBeanInfo 继承自它实现了功能扩展，并且提供了 BeanInfoFactory 来专门生产它~~~（实现类为：`ExtendedBeanInfoFactory`）

但是如果只想拿某一个属性的话，使用 Introspector 就不是那么方便了，下面介绍更为常用的 PropertyDescriptor 来处理某一个属性~

PropertyDescriptor 属性描述器

属性描述符描述了Java bean通过 一对访问器方法导出 的一个属性。上面的示例此处用 PropertyDescriptor 试试： 

public static void main(String[] args) throws IntrospectionException {
        PropertyDescriptor age = new PropertyDescriptor("age", Child.class);
        System.out.println(age.getPropertyType()); //class java.lang.Integer
        System.out.println(age.getDisplayName()); //age


        // 最重要的两个方法~~~
        System.out.println(age.getReadMethod()); //public java.lang.Integer com.fsx.bean.Child.getAge()
        System.out.println(age.getWriteMethod()); //public void com.fsx.bean.Child.setAge(java.lang.Integer)
    }复制代码

可以看到它可以实现更加细粒度的控制。将 PropertyDescriptor 类的一些主要方法描述如下：

  1. getPropertyType()，获得属性的Class对象；
  2. getReadMethod()，获得用于读取属性值的方法；
  3. getWriteMethod()，获得用于写入属性值的方法；
  4. setReadMethod(Method readMethod)，设置用于读取属性值的方法；
  5. setWriteMethod(Method writeMethod)，设置用于写入属性值的方法。

---

CachedIntrospectionResults

Spring如果需要依赖注入那么就必须依靠Java内省这个特性了，说到 Spring IOC与JDK内省的结合 那么就不得不说一下Spring中的 CachedIntrospectionResults 这个类了。它是Spring提供的专门用于缓存JavaBean的 PropertyDescriptor 描述信息的类，不能被应用代码直接使用。

它的缓存信息是被静态存储起来的（应用级别），因此对于 同一个类型的 被操作的 JavaBean 并不会都创建一个新的 CachedIntrospectionResults ，因此，这个类使用了工厂模式，使用私有构造器和一个静态的 forClass 工厂方法来获取实例。 

public final class CachedIntrospectionResults {
    
    // 它可以通过在spring.properties里设置这个属性，来关闭内省的缓存~~~
    public static final String IGNORE_BEANINFO_PROPERTY_NAME = "spring.beaninfo.ignore";
    private static final boolean shouldIntrospectorIgnoreBeaninfoClasses = SpringProperties.getFlag(IGNORE_BEANINFO_PROPERTY_NAME);

    // 此处使用了SpringFactoriesLoader这个SPI来加载BeanInfoFactory,唯一实现类是ExtendedBeanInfoFactory
    /** Stores the BeanInfoFactory instances. */
    private static List<BeanInfoFactory> beanInfoFactories = SpringFactoriesLoader.loadFactories(
            BeanInfoFactory.class, CachedIntrospectionResults.class.getClassLoader());

    static final Set<ClassLoader> acceptedClassLoaders = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
    static final ConcurrentMap<Class<?>, CachedIntrospectionResults> strongClassCache = new ConcurrentHashMap<>(64);
    static final ConcurrentMap<Class<?>, CachedIntrospectionResults> softClassCache = new ConcurrentReferenceHashMap<>(64);

    // 被包裹类的BeanInfo~~~也就是目标类
    private final BeanInfo beanInfo;
    // 它缓存了被包裹类的所有属性的属性描述器PropertyDescriptor。
    private final Map<String, PropertyDescriptor> propertyDescriptorCache;



    ... // 其它的都是静态方法
    // 只有它会返回一个实例，此类是单例的设计~  它保证了每个beanClass都有一个CachedIntrospectionResults 对象，然后被缓存起来~
    static CachedIntrospectionResults forClass(Class<?> beanClass) throws BeansException { ... }
}复制代码

本处理类的核心内容是Java内省 getBeanInfo() 以及 PropertyDescriptor ~注意：为了使此内省缓存生效，有个前提条件请保证了：

  • 确保将Spring框架的Jar包和你的应用类使用的是同一个 ClassLoader 加载的，这样在 任何情况下 会允许随着应用的生命周期来清楚缓存。

因此对于web应用来说，Spring建议给web容器注册一个 IntrospectorCleanupListener 监听器来防止多 ClassLoader 布局，这样也可以 有效的利用caching 从而提高效率~

监听器的配置形如这样（此处以web.xml里配置为例）：

<listener>
    <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
</listener>复制代码

说明：请保证此监听器配置在第一个位置，比 ContextLoaderListener 还靠前~ 此监听器能有效的防止内存泄漏问题~~~（因为内省的缓存是应用级别的全局缓存，很容易造成泄漏的~）

其实流行框架比如 struts, Quartz 等在使用JDK的内省时，存在没有释的内存泄漏问题~

---

DirectFieldAccessFallbackBeanWrapper

说完了 BeanWrapperImpl ，可以看看它的子类 DirectFieldAccessFallbackBeanWrapper ，他就像 BeanWrapperImpl 和 DirectFieldAccessor 的结合体。它先用 BeanWrapperImpl.getPropertyValue() ，若抛出异常了（毕竟内省不是十分靠谱，哈哈）再用 DirectFieldAccessor ~~~此子类在`JedisClusterConnection`有被使用到过，比较简单没啥太多好说的~

PropertyAccessorFactory

Spring2.5 后提供的快速获取 PropertyAccessor 两个重要实现类的工厂。 

public final class PropertyAccessorFactory {
    private PropertyAccessorFactory() {
    }
    // 生产一个BeanWrapperImpl（最为常用）
    public static BeanWrapper forBeanPropertyAccess(Object target) {
        return new BeanWrapperImpl(target);
    }
    // 生产一个DirectFieldAccessor
    public static ConfigurablePropertyAccessor forDirectFieldAccess(Object target) {
        return new DirectFieldAccessor(target);
    }

}复制代码

BeanWrapper使用Demo

说了这么多，是时候实战一把了~

// 省略Apple类和Size类，有需要的请参照上篇文章（加上@Getter、@Setter即可

    public static void main(String[] args) {
        Apple apple = new Apple();

        BeanWrapper beanWrapper = PropertyAccessorFactory.forBeanPropertyAccess(apple);

        // ================当作一个普通的PropertyAccessor来使用  默认情况下字段也都必须有初始值才行~===================
        // 设置普通属性
        beanWrapper.setPropertyValue("color", "红色"); //请保证对应字段有set方法才行，否则抛错：Does the parameter type of the setter match the return type of the getter?
        // 设置嵌套属性（注意：此处能够正常work是因为有= new Size()，
        // 否则报错：Value of nested property 'size' is null 下同~）
        beanWrapper.setPropertyValue("size.height", 10);

        // 设置集合/数组属性
        beanWrapper.setPropertyValue("arrStr[0]", "arrStr");
        beanWrapper.setPropertyValue("arrStr[1]", "arrStr1"); // 注意：虽然初始化时初始化过数组了，但是仍以此处的为准
        // =========打印输出
        System.out.println(apple); //Apple(color=红色, size=Size(height=10, width=null), arrStr=[arrStr, arrStr1], listStr=[], map={}, listList=[[]], listMap=[{}])


        // 当作BeanWrapper使用
        PropertyDescriptor[] propertyDescriptors = beanWrapper.getPropertyDescriptors();
        PropertyDescriptor color = beanWrapper.getPropertyDescriptor("color");
        System.out.println(propertyDescriptors.length); // 8
        System.out.println(color); //org.springframework.beans.GenericTypeAwarePropertyDescriptor[name=color]

        System.out.println(beanWrapper.getWrappedClass()); //class com.fsx.bean.Apple
        System.out.println(beanWrapper.getWrappedInstance()); //Apple(color=红色, size=Size(height=10...
    }复制代码

上面代码能够清晰的表示了通过 BeanWrapper 来操作JavaBean还是非常之简便的。

最后，上一张比较丑的结构图，画一画属性编辑器、类型转换器、属性解析器、属性访问器大致的一个关系（此图不喜勿碰）： 【小家Spring】聊聊Spring中的数据绑定 --- BeanWrapper以及内省Introspector和PropertyDescriptor

总结

BeanWrapper 接口，作为Spring内部的一个 核心接口 ，正如其名，它是bean的包裹类，即在内部中将会保存该bean的实例，提供其它一些扩展功能。

Spring对Bean的属性存取都是通过 BeanWrapperImpl 实现的， BeanWrapperImpl 和 Bean 是一对一的关系， BeanWrapperImpl 通过属性的 读方法 和 写方法 来存取 Bean 属性的。为了更加深刻的了解 BeanWrapper ，下篇文章会深入分析Spring BeanFactory 对它的应用~

知识交流

==The last：如果觉得本文对你有帮助，不妨点个赞呗。当然分享到你的朋友圈让更多小伙伴看到也是被 作者本人许可的~ ==

**若对技术内容感兴趣可以加入wx群交流：`Java高工、架构师3群`。若群二维码失效，请加wx号： fsx641385712 （或者扫描下方wx二维码）。并且备注： "java入群" 字样，会手动邀请入群** 【小家Spring】聊聊Spring中的数据绑定 --- BeanWrapper以及内省Introspector和PropertyDescriptor

原文  https://juejin.im/post/5d2c545f5188252f567a7264
正文到此结束
所属分类： Spring

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 springcloud-demo Hive教程 Ant教程 ANTLR教程 SpringCloud java实例教程 XStream教程 Hazelcast教程 Elastic-Job-Lite 深入浅出MyBatis SVN教程 ibaties教程 rabittmq教程 solr教程 Hadoop教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 java-demo Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 如何将Spring Cloud Task发布Data Flow上执行？
  2. 2 Spring Cloud Data Flow快速入门Demo
  3. 3 Spring Cloud Consul实现选举机制
  4. 4 Spring Boot集成ShedLock实现分布式定时任务
  5. 5 利用oss进行数据库和网站图片备份
  6. 6 Spring Cloud Stream实现数据流处理
  7. 7 Python3访问MySQL数据库快速入门Demo
  8. 8 Github开源项目作者可以免费申请 JetBrains 全家桶
  9. 9 Spring Cloud Vault快速入门Demo
  10. 10 Spring Cloud Gateway快速入门Demo
网站信息
  • 文章总数：82,716 篇
  • 文件总数：284,297 个
  • 标签总数：2,396 个
  • 分类总数：85 个
  • 留言数量：2,560 条
  • 在线人数：663 人
  • 运行天数：4,411天
  • 最后更新：2024年11月24日17点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG