在前边的博客中分析了mybatis解析properties标签,《 mybatis源码配置文件解析之一:解析properties标签 》。下面来看解析settings标签的过程。
在mybatis的核心配置文件(mybatis-config.xml)文件中,有关于settings标签的配置,如下
<settings> <!-- 设置日志输出为LOG4J --> <setting name="logImpl" value="STDOUT_LOGGING" /> <!--将以下画线方式命名的数据库列映射到 Java 对象的驼峰式命名属性中--> <setting name= "mapUnderscoreToCamelCase" value="true" /> </settings>
上面只简单的给出settings标签的配置,settings标签配置在<configuration>标签中,是<configuration>标签的子标签。在settings标签中可以配置setting子标签,上面是我的一个配置,是以name-value键值对的放式进行配置。这里有个问题setting标签中的name怎么配置,共有多少配置?
上面,看到了settings标签的配置方式,下面看其解析过程,在XMLConfigBuilder类中的parseConfiguration方法中有关于该标签的解析,
private void parseConfiguration(XNode root) { try { //issue #117 read properties first //解析properties标签 propertiesElement(root.evalNode("properties")); //解析settings标签,1、把<setting>标签解析为Properties对象 Properties settings = settingsAsProperties(root.evalNode("settings")); /*2、对<settings>标签中的<setting>标签中的内容进行解析,这里解析的是<setting name="vfsImpl" value=","> * VFS是mybatis中用来表示虚拟文件系统的一个抽象类,用来查找指定路径下的资源。上面的key为vfsImpl的value可以是VFS的具体实现,必须 * 是权限类名,多个使用逗号隔开,如果存在则设置到configuration中的vfsImpl属性中,如果存在多个,则设置到configuration中的仅是最后一个 * */ loadCustomVfs(settings); //解析别名标签,例<typeAlias alias="user" type="cn.com.bean.User"/> typeAliasesElement(root.evalNode("typeAliases")); //解析插件标签 pluginElement(root.evalNode("plugins")); //解析objectFactory标签,此标签的作用是mybatis每次创建结果对象的新实例时都会使用ObjectFactory,如果不设置 //则默认使用DefaultObjectFactory来创建,设置之后使用设置的 objectFactoryElement(root.evalNode("objectFactory")); //解析objectWrapperFactory标签 objectWrapperFactoryElement(root.evalNode("objectWrapperFactory")); //解析reflectorFactory标签 reflectorFactoryElement(root.evalNode("reflectorFactory")); settingsElement(settings); // read it after objectFactory and objectWrapperFactory issue #631 //解析environments标签 environmentsElement(root.evalNode("environments")); databaseIdProviderElement(root.evalNode("databaseIdProvider")); typeHandlerElement(root.evalNode("typeHandlers")); //解析<mappers>标签 mapperElement(root.evalNode("mappers")); } catch (Exception e) { throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e); } }
上面便是parseConfiguration方法,在此方法中下面的方法对settings进行了解析,
//解析settings标签,1、把<setting>标签解析为Properties对象 Properties settings = settingsAsProperties(root.evalNode("settings"));
调用settingsAsProperties方法,从方法名中可以看出要把settings标签中的内容解析到Proerties对象中,因为settings标签中是name-value的配置,刚好解析到Properties中以键值对的形式存储。下面是settingsAsProperties方法,
private Properties settingsAsProperties(XNode context) { if (context == null) { return new Properties(); } //把<setting name="" value="">标签解析为Properties对象 Properties props = context.getChildrenAsProperties(); // Check that all settings are known to the configuration class MetaClass metaConfig = MetaClass.forClass(Configuration.class, localReflectorFactory); //如果获取的配置的<setting name="" value="">信息,name不在metaConfig中,则会抛出异常 //这里metaConfig中的信息是从Configuration类中解析出来的,包含set方法的属性 //所以在配置<setting>标签的时候,其name值可以参考configuration类中的属性,配置为小写 for (Object key : props.keySet()) { //从metaConfig的relector中的setMethods中判断是否存在该属性,setMethods中存储的是可写的属性, //所以这里要到setMethods中进行判断 if (!metaConfig.hasSetter(String.valueOf(key))) { throw new BuilderException("The setting " + key + " is not known. Make sure you spelled it correctly (case sensitive)."); } } return props; }
解析子标签也就是settings标签中的setting标签,使用下面的方法进行解析,
//把<setting name="" value="">标签解析为Properties对象 Properties props = context.getChildrenAsProperties();
调用了getChildrenAsProperties方法,
public Properties getChildrenAsProperties() { Properties properties = new Properties(); for (XNode child : getChildren()) { String name = child.getStringAttribute("name"); String value = child.getStringAttribute("value"); if (name != null && value != null) { properties.setProperty(name, value); } } return properties; }
该方法就是解析<settings></settings>标签中的<setting></setting>标签,取出标签中的name和value属性,存储到Properties对象中且返回。
我们再看上面的settingsAsProperties方法,调用上述getChildrenAsProperties方法获得Properties对象后又进行了其他操作。
在本文开篇提到一个问题,setting标签中的name值怎么配置,答案是可以参考mybatis的官方文档,在官方文档中有详细的解释,再有就是分析源码,继续往下看。
在settingsAsProperties方法中看下面一行代码,
// Check that all settings are known to the configuration class MetaClass metaConfig = MetaClass.forClass(Configuration.class, localReflectorFactory);
上面这行代码就解析了setting标签中的name可以配置的所有值。再看代码上的注释,是不是豁然开朗。该方法有两个参数,一个是Configuration.class,一个是localReflectorFactory,看localReflectorFactory,
private final ReflectorFactory localReflectorFactory = new DefaultReflectorFactory();
使用了DefaultReflectorFactory,看其默认构造方法
默认构造方法仅初始化了classCacheEnabled和relectorMap两个属性。后过来继续看MetaClass.forClass方法,
public static MetaClass forClass(Class<?> type, ReflectorFactory reflectorFactory) { return new MetaClass(type, reflectorFactory); }
该方法返回的是一个MetaClass的对象,
private MetaClass(Class<?> type, ReflectorFactory reflectorFactory) { this.reflectorFactory = reflectorFactory; this.reflector = reflectorFactory.findForClass(type); }
重点看reflectorFactory.findForClass方法,这里reflectorFactory是DefaultReflectorFactory的一个实例。下面是DefaultReflectorFactory的findForClass方法,
@Override public Reflector findForClass(Class<?> type) { if (classCacheEnabled) { // synchronized (type) removed see issue #461 Reflector cached = reflectorMap.get(type); if (cached == null) { cached = new Reflector(type); reflectorMap.put(type, cached); } return cached; } else { return new Reflector(type); } }
上面方法中,重点看new Reflector(type)这句方法,
public Reflector(Class<?> clazz) { type = clazz; //解析默认的构造方法,及无参构造方法 addDefaultConstructor(clazz); //解析clazz中的get方法,这里的clazz指的是Configuration.class addGetMethods(clazz); //解析clazz中的set方法,这里的clazz指的是Configuration.class addSetMethods(clazz); addFields(clazz); readablePropertyNames = getMethods.keySet().toArray(new String[getMethods.keySet().size()]); writeablePropertyNames = setMethods.keySet().toArray(new String[setMethods.keySet().size()]); for (String propName : readablePropertyNames) { caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName); } for (String propName : writeablePropertyNames) { caseInsensitivePropertyMap.put(propName.toUpperCase(Locale.ENGLISH), propName); } }
此方法完成的功能是解析clazz(包含其父类)的构造方法、getXX方法、setXX方法、字段,通过一个类的Class对象获取。
addDefaultConstructor(clazz)如下,
private void addDefaultConstructor(Class<?> clazz) { //获得该类的声明的构造方法 Constructor<?>[] consts = clazz.getDeclaredConstructors(); //对构造方法进行循环 for (Constructor<?> constructor : consts) { //判断构造方法的参数是否为0,为0代表为默认的无参构造方法 if (constructor.getParameterTypes().length == 0) { //如果是私有的(修饰符为private),这里需要设置可见。 if (canAccessPrivateMethods()) { try { constructor.setAccessible(true); } catch (Exception e) { // Ignored. This is only a final precaution, nothing we can do. } } if (constructor.isAccessible()) { this.defaultConstructor = constructor; } } } }
上面方法获得传入的Class对象所以构造方法,把默认的无参构造方法赋给defaultConstructor。
addGetMethods(clazz)如下,
private void addGetMethods(Class<?> cls) { Map<String, List<Method>> conflictingGetters = new HashMap<String, List<Method>>(); //使用反射的放上获得cls的所有方法 Method[] methods = getClassMethods(cls); //把所有的方法放入conflictingGetters中,key为属性名,value为List<Method> for (Method method : methods) { //方法的参数大于0,则结束本次循环,因为这里解析的是get方法,get方法默认不应该有参数 if (method.getParameterTypes().length > 0) { continue; } String name = method.getName(); //如果以get或is开头,且方法名称分别大于3和2,则说明是get方法 if ((name.startsWith("get") && name.length() > 3) || (name.startsWith("is") && name.length() > 2)) { //通过方法名转化为属性名,如,getUserName--userName name = PropertyNamer.methodToProperty(name); addMethodConflict(conflictingGetters, name, method); } } /**处理一个属性多个get方法的情况,即conflictingGetter方法中一个key对应的value的长度大于1的情况,如下 *key propertyName *value list<Method> 其长度大于1 */ resolveGetterConflicts(conflictingGetters); }
获取所有以get和is开头的方法,调用addMethodConflict方法,这里的方法名直译过来是添加冲突的方法,这里冲突怎么理解,我们看addMethodConflict方法,
private void addMethodConflict(Map<String, List<Method>> conflictingMethods, String name, Method method) { //根据字段名取方法 List<Method> list = conflictingMethods.get(name); if (list == null) { list = new ArrayList<Method>(); conflictingMethods.put(name, list); } list.add(method); }
这里是根据get和is开头的方法获取属性名作为键值,并且使用list作为value进行存储,为什么使用list那,我们看下面的方法
public void getUser(){} public User getuser(){} public List<User> getUser(){} public void getUser(String id){}
上面三个方法都会以user为键进行存储,但是其方法名是一样的,所以这里要存储为list,即存储多个Method对象。
我们知道一个字段的属性的get或set方法,不可能出现上面的情况,所以针对上面的情况需要做处理,这里调用resolveGetterConflicts(conflicttingGetters),
private void resolveGetterConflicts(Map<String, List<Method>> conflictingGetters) { //遍历conflictingGetters for (Entry<String, List<Method>> entry : conflictingGetters.entrySet()) { Method winner = null; String propName = entry.getKey(); //循环value这里value是一个List<Method>类型 for (Method candidate : entry.getValue()) { if (winner == null) { winner = candidate; continue; } //获得get方法的返回值类型 Class<?> winnerType = winner.getReturnType(); Class<?> candidateType = candidate.getReturnType(); //如果winnerType和candidateType相等, if (candidateType.equals(winnerType)) { if (!boolean.class.equals(candidateType)) { throw new ReflectionException( "Illegal overloaded getter method with ambiguous type for property " + propName + " in class " + winner.getDeclaringClass() + ". This breaks the JavaBeans specification and can cause unpredictable results."); } else if (candidate.getName().startsWith("is")) { winner = candidate; } } else if (candidateType.isAssignableFrom(winnerType)) { // OK getter type is descendant } else if (winnerType.isAssignableFrom(candidateType)) { winner = candidate; } else { throw new ReflectionException( "Illegal overloaded getter method with ambiguous type for property " + propName + " in class " + winner.getDeclaringClass() + ". This breaks the JavaBeans specification and can cause unpredictable results."); } } addGetMethod(propName, winner); } }
上面的方法处理了上面提到的一个属性存在多个get方法的情况,最后调用addGetMethod方法,
private void addGetMethod(String name, Method method) { if (isValidPropertyName(name)) { getMethods.put(name, new MethodInvoker(method)); Type returnType = TypeParameterResolver.resolveReturnType(method, type); getTypes.put(name, typeToClass(returnType)); } }
上面的方法把信息放到了getMethods和getTyps中,分别存储了get方法和返回值。
上面分析了Reflector中的addGetMethods方法,addSetMethods方法和其处理过程类似,最终把set方法和返回值放到了setMethods和setTypes中。
addFileds(clazz)方法即是处理clazz中的属性,
private void addFields(Class<?> clazz) { Field[] fields = clazz.getDeclaredFields(); for (Field field : fields) { if (canAccessPrivateMethods()) { try { field.setAccessible(true); } catch (Exception e) { // Ignored. This is only a final precaution, nothing we can do. } } if (field.isAccessible()) { //检查是否存在set方法,如果不存在添加该field if (!setMethods.containsKey(field.getName())) { // issue #379 - removed the check for final because JDK 1.5 allows // modification of final fields through reflection (JSR-133). (JGB) // pr #16 - final static can only be set by the classloader int modifiers = field.getModifiers(); if (!(Modifier.isFinal(modifiers) && Modifier.isStatic(modifiers))) { addSetField(field); } } //检查是否存在get方法,如果不存在添加该field if (!getMethods.containsKey(field.getName())) { addGetField(field); } } } //添加父类的field if (clazz.getSuperclass() != null) { addFields(clazz.getSuperclass()); } }
获得field之后,判断是否在getMethods和setMethods中,如果不在则进行添加,只看addSetField方法,
private void addSetField(Field field) { if (isValidPropertyName(field.getName())) { setMethods.put(field.getName(), new SetFieldInvoker(field)); Type fieldType = TypeParameterResolver.resolveFieldType(field, type); setTypes.put(field.getName(), typeToClass(fieldType)); } }
从上面看到如果一个field不存在set方法,则生成一个SetFieldInvoker把该对象放入setMethods,从这里可以看出一个setting配置的name值在configuration中可以没有set方法。同理也可以没有get方法。
上面分析完了settingsAsProperties方法中的下面这行代码,
MetaClass metaConfig = MetaClass.forClass(Configuration.class, localReflectorFactory);
把Configuration中的构造方法、get方法、set方法、field放入了metaConfig中的reflector对象中的下列属性
private final String[] readablePropertyNames; private final String[] writeablePropertyNames; private final Map<String, Invoker> setMethods = new HashMap<String, Invoker>(); private final Map<String, Invoker> getMethods = new HashMap<String, Invoker>(); private final Map<String, Class<?>> setTypes = new HashMap<String, Class<?>>(); private final Map<String, Class<?>> getTypes = new HashMap<String, Class<?>>(); private Constructor<?> defaultConstructor;
上面分析完了MetaClass.forClass方法,下面看如何对setting标签配置的name进行校验
for (Object key : props.keySet()) { //从metaConfig的relector中的setMethods中判断是否存在该属性,setMethods中存储的是可写的属性, //所以这里要到setMethods中进行判断 if (!metaConfig.hasSetter(String.valueOf(key))) { throw new BuilderException("The setting " + key + " is not known. Make sure you spelled it correctly (case sensitive)."); } }
遍历从setting标签解析出来的Properties对象,调用metaConfig.hasSetter方法,
public boolean hasSetter(String name) { PropertyTokenizer prop = new PropertyTokenizer(name); if (prop.hasNext()) { if (reflector.hasSetter(prop.getName())) { MetaClass metaProp = metaClassForProperty(prop.getName()); return metaProp.hasSetter(prop.getChildren()); } else { return false; } } else { return reflector.hasSetter(prop.getName()); } }
看hasSetter的定义
public boolean hasSetter(String propertyName) { return setMethods.keySet().contains(propertyName); }
可以看到是判断setMethods是否存在该key,也就是已set方法为表标准,只要在setMethods中,便可以在<setting>标签的name中配置,具体配置值还需要看其类型。
上面分析了mybatis的核心配置文件中<settings>标签的解析及子标签中name属性的配置值是怎么取的。如果要扩展核心文件配置中的setting标签的name属性值,需要在configuration中进行配置,及其他操作。
原创不易,有不正之处欢迎指正。