Java MetaObject.getSetterType方法代码示例

import org.apache.ibatis.reflection.MetaObject; //导入方法依赖的package包/类
@Override
public Class<?> getSetterType(String name) {
  PropertyTokenizer prop = new PropertyTokenizer(name);
  if (prop.hasNext()) {
    MetaObject metaValue = metaObject.metaObjectForProperty(prop.getIndexedName());
    if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
      return Object.class;
    } else {
      return metaValue.getSetterType(prop.getChildren());
    }
  } else {
    if (map.get(name) != null) {
      return map.get(name).getClass();
    } else {
      return Object.class;
    }
  }
}
 

import org.apache.ibatis.reflection.MetaObject; //导入方法依赖的package包/类
private Object prepareCompositeKeyParameter(ResultSet rs, ResultMapping resultMapping, Class<?> parameterType, String columnPrefix) throws SQLException {
  final Object parameterObject = instantiateParameterObject(parameterType);
  final MetaObject metaObject = configuration.newMetaObject(parameterObject);
  boolean foundValues = false;
  for (ResultMapping innerResultMapping : resultMapping.getComposites()) {
    final Class<?> propType = metaObject.getSetterType(innerResultMapping.getProperty());
    final TypeHandler<?> typeHandler = typeHandlerRegistry.getTypeHandler(propType);
    final Object propValue = typeHandler.getResult(rs, prependPrefix(innerResultMapping.getColumn(), columnPrefix));
    // issue #353 & #560 do not execute nested query if key is null
    if (propValue != null) {
      metaObject.setValue(innerResultMapping.getProperty(), propValue);
      foundValues = true;
    }
  }
  return foundValues ? parameterObject : null;
}
 

import org.apache.ibatis.reflection.MetaObject; //导入方法依赖的package包/类
private Object instantiateCollectionPropertyIfAppropriate(ResultMapping resultMapping, MetaObject metaObject) {
  final String propertyName = resultMapping.getProperty();
  Object propertyValue = metaObject.getValue(propertyName);
  if (propertyValue == null) {
    Class<?> type = resultMapping.getJavaType();
    if (type == null) {
      type = metaObject.getSetterType(propertyName);
    }
    try {
      if (objectFactory.isCollection(type)) {
        propertyValue = objectFactory.create(type);
        metaObject.setValue(propertyName, propertyValue);
        return propertyValue;
      }
    } catch (Exception e) {
      throw new ExecutorException("Error instantiating collection property for result '" + resultMapping.getProperty() + "'.  Cause: " + e, e);
    }
  } else if (objectFactory.isCollection(propertyValue.getClass())) {
    return propertyValue;
  }
  return null;
}
 

import org.apache.ibatis.reflection.MetaObject; //导入方法依赖的package包/类
public Class<?> getSetterType(String name) {
	PropertyTokenizer prop = new PropertyTokenizer(name);
	if (prop.hasNext()) {
		MetaObject metaValue = metaObject.metaObjectForProperty(prop
				.getIndexedName());
		if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
			return Object.class;
		} else {
			return metaValue.getSetterType(prop.getChildren());
		}
	} else {
		if (map.get(name) != null) {
			return map.get(name).getClass();
		} else {
			return Object.class;
		}
	}
}
 

import org.apache.ibatis.reflection.MetaObject; //导入方法依赖的package包/类
private TypeHandler<?>[] getTypeHandlers(TypeHandlerRegistry typeHandlerRegistry, MetaObject metaParam, String[] keyProperties) {
    TypeHandler<?>[] typeHandlers = new TypeHandler<?>[keyProperties.length];
    for (int i = 0; i < keyProperties.length; i++) {
        if (metaParam.hasSetter(keyProperties[i])) {
            Class<?> keyPropertyType = metaParam.getSetterType(keyProperties[i]);
            TypeHandler<?> th = typeHandlerRegistry.getTypeHandler(keyPropertyType);
            typeHandlers[i] = th;
        }
    }
    return typeHandlers;
}
 

import org.apache.ibatis.reflection.MetaObject; //导入方法依赖的package包/类
private void setCacheProperties(Cache cache) {
  if (properties != null) {
    MetaObject metaCache = SystemMetaObject.forObject(cache);
    for (Map.Entry<Object, Object> entry : properties.entrySet()) {
      String name = (String) entry.getKey();
      String value = (String) entry.getValue();
      if (metaCache.hasSetter(name)) {
        Class<?> type = metaCache.getSetterType(name);
        if (String.class == type) {
          metaCache.setValue(name, value);
        } else if (int.class == type
            || Integer.class == type) {
          metaCache.setValue(name, Integer.valueOf(value));
        } else if (long.class == type
            || Long.class == type) {
          metaCache.setValue(name, Long.valueOf(value));
        } else if (short.class == type
            || Short.class == type) {
          metaCache.setValue(name, Short.valueOf(value));
        } else if (byte.class == type
            || Byte.class == type) {
          metaCache.setValue(name, Byte.valueOf(value));
        } else if (float.class == type
            || Float.class == type) {
          metaCache.setValue(name, Float.valueOf(value));
        } else if (boolean.class == type
            || Boolean.class == type) {
          metaCache.setValue(name, Boolean.valueOf(value));
        } else if (double.class == type
            || Double.class == type) {
          metaCache.setValue(name, Double.valueOf(value));
        } else {
          throw new CacheException("Unsupported property type for cache: '" + name + "' of type " + type);
        }
      }
    }
  }
}
 

import org.apache.ibatis.reflection.MetaObject; //导入方法依赖的package包/类
private Object convertValue(MetaObject metaDataSource, String propertyName, String value) {
  Object convertedValue = value;
  Class<?> targetType = metaDataSource.getSetterType(propertyName);
  if (targetType == Integer.class || targetType == int.class) {
    convertedValue = Integer.valueOf(value);
  } else if (targetType == Long.class || targetType == long.class) {
    convertedValue = Long.valueOf(value);
  } else if (targetType == Boolean.class || targetType == boolean.class) {
    convertedValue = Boolean.valueOf(value);
  }
  return convertedValue;
}
 

import org.apache.ibatis.reflection.MetaObject; //导入方法依赖的package包/类
@Override
public Class<?> getSetterType(String name) {
  PropertyTokenizer prop = new PropertyTokenizer(name);
  if (prop.hasNext()) {
    MetaObject metaValue = metaObject.metaObjectForProperty(prop.getIndexedName());
    if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
      return metaClass.getSetterType(name);
    } else {
      return metaValue.getSetterType(prop.getChildren());
    }
  } else {
    return metaClass.getSetterType(name);
  }
}
 

import org.apache.ibatis.reflection.MetaObject; //导入方法依赖的package包/类
private List<UnMappedColumnAutoMapping> createAutomaticMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, String columnPrefix) throws SQLException {
  final String mapKey = resultMap.getId() + ":" + columnPrefix;
  List<UnMappedColumnAutoMapping> autoMapping = autoMappingsCache.get(mapKey);
  if (autoMapping == null) {
    autoMapping = new ArrayList<UnMappedColumnAutoMapping>();
    final List<String> unmappedColumnNames = rsw.getUnmappedColumnNames(resultMap, columnPrefix);
    for (String columnName : unmappedColumnNames) {
      String propertyName = columnName;
      if (columnPrefix != null && !columnPrefix.isEmpty()) {
        // When columnPrefix is specified,
        // ignore columns without the prefix.
        if (columnName.toUpperCase(Locale.ENGLISH).startsWith(columnPrefix)) {
          propertyName = columnName.substring(columnPrefix.length());
        } else {
          continue;
        }
      }
      final String property = metaObject.findProperty(propertyName, configuration.isMapUnderscoreToCamelCase());
      if (property != null && metaObject.hasSetter(property)) {
        final Class<?> propertyType = metaObject.getSetterType(property);
        if (typeHandlerRegistry.hasTypeHandler(propertyType, rsw.getJdbcType(columnName))) {
          final TypeHandler<?> typeHandler = rsw.getTypeHandler(propertyType, columnName);
          autoMapping.add(new UnMappedColumnAutoMapping(columnName, property, typeHandler, propertyType.isPrimitive()));
        } else {
          configuration.getAutoMappingUnknownColumnBehavior()
                  .doAction(mappedStatement, columnName, property, propertyType);
        }
      } else{
        configuration.getAutoMappingUnknownColumnBehavior()
                .doAction(mappedStatement, columnName, (property != null) ? property : propertyName, null);
      }
    }
    autoMappingsCache.put(mapKey, autoMapping);
  }
  return autoMapping;
}
 

import org.apache.ibatis.reflection.MetaObject; //导入方法依赖的package包/类
private TypeHandler<?>[] getTypeHandlers(TypeHandlerRegistry typeHandlerRegistry, MetaObject metaParam, String[] keyProperties, ResultSetMetaData rsmd) throws SQLException {
  TypeHandler<?>[] typeHandlers = new TypeHandler<?>[keyProperties.length];
  for (int i = 0; i < keyProperties.length; i++) {
    if (metaParam.hasSetter(keyProperties[i])) {
      Class<?> keyPropertyType = metaParam.getSetterType(keyProperties[i]);
      TypeHandler<?> th = typeHandlerRegistry.getTypeHandler(keyPropertyType, JdbcType.forCode(rsmd.getColumnType(i + 1)));
      typeHandlers[i] = th;
    }
  }
  return typeHandlers;
}
 

import org.apache.ibatis.reflection.MetaObject; //导入方法依赖的package包/类
protected void setValue(String keyProperty,
		Configuration configuration, Object param, Object key) {

	MetaObject metaParam = configuration
			.newMetaObject(param);

	Class<?> keyPropertyType = metaParam
			.getSetterType(keyProperty);

	if (keyPropertyType.isPrimitive()) {
		if (keyPropertyType.getName() == "int") {
			metaParam.setValue(keyProperty,
					((Number) key).intValue());
		} else {
			metaParam.setValue(keyProperty,
					((Number) key).longValue());
		}
	} else {
		if (keyPropertyType == Integer.class) {
			metaParam.setValue(keyProperty,
					((Number) key).intValue());
		} else if (keyPropertyType == Long.class) {
			metaParam.setValue(keyProperty,
					((Number) key).longValue());
		} else {
			metaParam.setValue(keyProperty,
					key);
		}
	}
}
 

import org.apache.ibatis.reflection.MetaObject; //导入方法依赖的package包/类
public Class<?> getSetterType(String name) {
	PropertyTokenizer prop = new PropertyTokenizer(name);
	if (prop.hasNext()) {
		MetaObject metaValue = metaObject.metaObjectForProperty(prop
				.getIndexedName());
		if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
			return metaClass.getSetterType(name);
		} else {
			return metaValue.getSetterType(prop.getChildren());
		}
	} else {
		return metaClass.getSetterType(name);
	}
}