详叙BeanWrapper和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操作的工具。关于它的数据转换使用了如下两种机制:
PropertyEditor
:隶属于Java Bean规范。PropertyEditor
只提供了String <-> Object
的转换。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
的三重身份:
- Bean包裹器
- 属性访问器(PropertyAccessor)
- 属性编辑器注册表(PropertyEditorRegistry)
从源码中继续分析还能再得出如下两个结论:
- 它给属性赋值调用的是Method方法,如
readMethod.invoke
和writeMethod.invoke
- 它对Bean的操作,大都委托给
CachedIntrospectionResults
去完成~
因此若想了解它,必然主要是要先了解java.beans.PropertyDescriptor
和org.springframework.beans.CachedIntrospectionResults
,首当其冲的自然还有Java内省
。
Java内省Introspector
首先可以先了解下JavaBean的概念:一种特殊的类,主要用于传递数据信息。这种类中的方法主要用于访问私有的字段,且方法名符合某种命名规则。如果在两个模块之间传递信息,可以将信息封装进JavaBean中,这种对象称为“值对象”(Value Object
),或“VO
”。
因此JavaBean都有如下几个特征:
- 属性都是私有的;
- 有无参的public构造方法;
- 对私有属性根据需要提供公有的getXxx方法以及setXxx方法;
- getters必须有返回值没有方法参数;setter值没有返回值,有方法参数;
符合这些特征的类,被称为JavaBean;JDK中提供了一套API用来访问某个属性的getter/setter方法,这些API存放在java.beans
中,这就是内省(Introspector)
。
内省和反射的区别
反射:Java反射机制是在运行中,对任意一个类,能够获取得到这个类的所有属性和方法;它针对的是任意类
内省(Introspector):是Java语言对JavaBean类属性、事件的处理方法
- 反射可以操作各种类的属性,而内省只是通过反射来操作
JavaBean
的属性 - 内省设置属性值肯定会调用seter方法,反射可以不用(反射可直接操作属性Field)
- 反射就像照镜子,然后能看到.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
类的一些主要方法描述如下:
- getPropertyType(),获得属性的Class对象;
- getReadMethod(),获得用于读取属性值的方法;
- getWriteMethod(),获得用于写入属性值的方法;
- setReadMethod(Method readMethod),设置用于读取属性值的方法;
- 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还是非常之简便的。
最后,上一张比较丑的结构图,画一画属性编辑器、类型转换器、属性解析器、属性访问器大致的一个关系(此图不喜勿碰):
总结
BeanWrapper
接口,作为Spring内部的一个核心接口,正如其名,它是bean的包裹类,即在内部中将会保存该bean的实例,提供其它一些扩展功能。
Spring对Bean的属性存取都是通过BeanWrapperImpl
实现的,BeanWrapperImpl
和Bean
是一对一的关系,BeanWrapperImpl
通过属性的读方法和写方法来存取Bean
属性的。为了更加深刻的了解BeanWrapper
,下篇文章会深入分析Spring BeanFactory
对它的应用~
知识交流
The last:如果觉得本文对你有帮助,不妨点个赞呗。当然分享到你的朋友圈让更多小伙伴看到也是被作者本人许可的~
若对技术内容感兴趣可以加入wx群交流:Java高工、架构师3群
。
若群二维码失效,请加wx号:fsx641385712
(或者扫描下方wx二维码)。并且备注:"java入群"
字样,会手动邀请入群
![在这里插入图片描述](https://img-blog.csdnimg.cn/20190703175020107.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Y2NDEzODU3MTI=,size_16,color_FFFFFF,t_70,pic_center =300x)
详叙BeanWrapper和PropertyDescriptor的更多相关文章
- [Python3] 003 变量类型概述 & 数字类型详叙
目录 0. 变量类型概述 1. 数字类型详叙 1.1 整数 1.1.1 常用进制 1.1.2 少废话,上例子 1.2 浮点数 1.2.1 使用浮点数时可以"偷懒" 1.2.2 科学 ...
- 【小家Spring】聊聊Spring中的数据绑定 --- BeanWrapper以及内省Introspector和PropertyDescriptor
#### 每篇一句 > 千古以来要饭的没有要早饭的,知道为什么吗? #### 相关阅读 [[小家Spring]聊聊Spring中的数据转换:Converter.ConversionService ...
- C# PPT 为形状设置三维效果
在PPT中,形状是非常重要的元素.3-D形状,立体多元,给人耳目一新的感觉.在幻灯片中添加3-D效果形状,必然会为PPT的整体效果增色不少.为形状设置三维格式时,可设置棱台,轮廓线,表面效果等. 本篇 ...
- Url路径重写的原理
ASP.net的地址重写(URLRewriter)实现原理及代码示例 吴剑 2007-01-01 原创文章,转载必需注明出处:http://www.cnblogs.com/wu-jian/ 概述 访问 ...
- JQuery 实现页面无刷新
对于JQuery实现页面无刷新的效果,即:应用这个JQuery这个组件,可以实现在页面上加载数据库中的数据信息,但是并没有给用户页面刷新的感觉,这样既可以有效的进行数据交互,也可以不妨碍用户的其他操作 ...
- Java 7 中 NIO.2 的使用——第二节 元数据文件的属性
如果你有很多疑问关于一个文件或目录,它是否是隐藏的,它的大小是多少,谁拥有它,你可以从元数据中得到这些信息.所谓的元数据,就是描述数据的数据. NIO.2组织了这些原数据的属性的概念,并提供了java ...
- c++中实现委托
成员函数指针与高性能的C++委托(上篇) 撰文:Don Clugston 引子 标准C++中没有真正的面向对象的函数指针.这一点对C++来说是不幸的,因为面向对象的指针(也叫做"闭包(clo ...
- JAVA_用_JCO连接_SAP,实现调用SAP_的_RFC_函数(整理)(附一篇看起来比较全面的说明)(JCO报错信息)
// 获取RFC返回的字段值 11 JCoParameterList exportParam = function.getExportParameterList(); 12 String exPara ...
- asp.net学习之SqlDataSource
原文:asp.net学习之SqlDataSource 通过 SqlDataSource 控件,可以使用 Web 服务器控件访问位于关系数据库中的数据.其中可以包括 Microsoft SQL Serv ...
随机推荐
- C# 获取当前月份天数的三种方法总结
方法一: //最有含量的一种 int days = System.Threading.Thread.CurrentThread.CurrentUICulture.Calendar.GetDaysInM ...
- Docker笔记02-日志平台ELK搭建
OS: Centos7 准备工作: 虚拟机中安装Centos, 搭建Docker环境 ELK简介: 略 文档地址 https://elk-docker.readthedocs.io/ 需要注意的是在B ...
- Java Date Calendar DateFormat Details
From https://www.ntu.edu.sg/home/ehchua/programming/java/DateTimeCalendar.html Date and Time - Creat ...
- C++的 RTTI 观念和用途(非常详细)
自从1993年Bjarne Stroustrup [注1 ]提出有关C++ 的RTTI功能之建议﹐以及C++的异常处理(exception handling)需要RTTI:最近新推出的C++ 或多或少 ...
- jQuery.media.js的使用方法
该插件可以播放多种类型的多媒体文件包括:Flash, Quicktime, Windows Media Player, Real Player, MP3, Silverlight, PDF等,前提 ...
- 海康威视频监控设备Web查看系统(一):概要篇
声明:本系列文章只提供交流与学习使用.文章中所有涉及到海康威视设备的SDK均可在海康威视官方网站下载得到.文章中所有除官方SDK意外的代码均可随意使用,任何涉及到海康威视公司利益的非正常使用由使用者自 ...
- 2019年5月23日 AY 程序员调侃语录
我是AY,杨洋,做wpf开发的,最近得了一种病,程序员患得患失综合征.同事说,我年纪在变大,技术跟不上.业余之间,我原创了写了一些语录,给大家中午休息,累疲惫的时候,开心放松下. 1.有很多公司找我谈 ...
- 宜信开源|数据库审核软件Themis的规则解析与部署攻略
一.介绍 Themis是宜信公司DBA团队开发的一款数据库审核产品,可帮助DBA.开发人员快速发现数据库质量问题,提升工作效率.其名称源自希腊神话中的正义与法律女神.项目取此名称,寓意此平台对数据库质 ...
- win7 docker安装文件及安装问题
最近在玩爬虫,需要装docker,但是官网对于win7版本,只支持docker tool box,在官网找了半天才找到安装包,特此上传百度网盘,方便各位下载 链接:https://pan.baidu. ...
- 管理分布式session的四种方式。
应用服务器的高可用架构设计最为理想的是服务无状态,但实际上业务总会有状态的,以session记录用户信息的例子来讲,未登入时,服务器没有记入用户信息的session访问网站都是以游客方式访问的,账号密 ...