private void resolveTypeHandler() {
if (resultMapping.typeHandler == null && resultMapping.javaType != null) {
Configuration configuration = resultMapping.configuration;
TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
resultMapping.typeHandler =
typeHandlerRegistry.getTypeHandler(resultMapping.javaType, resultMapping.jdbcType);
}
}
/** {@inheritDoc} */
public Configuration get() {
final Configuration configuration = new Configuration(environment);
configuration.setLazyLoadingEnabled(lazyLoadingEnabled);
configuration.setAggressiveLazyLoading(aggressiveLazyLoading);
configuration.setMultipleResultSetsEnabled(multipleResultSetsEnabled);
configuration.setUseGeneratedKeys(useGeneratedKeys);
configuration.setUseColumnLabel(useColumnLabel);
configuration.setCacheEnabled(cacheEnabled);
configuration.setDefaultExecutorType(defaultExecutorType);
configuration.setAutoMappingBehavior(autoMappingBehavior);
configuration.setObjectFactory(objectFactory);
configuration.setObjectWrapperFactory(objectWrapperFactory);
configuration.setDefaultScriptingLanguage(defaultScriptingLanguageType);
configuration.setMapUnderscoreToCamelCase(mapUnderscoreToCamelCase);
configuration.setCallSettersOnNulls(callSettersOnNulls);
configuration.setDefaultStatementTimeout(defaultStatementTimeout);
try {
if (databaseIdProvider != null) {
configuration.setDatabaseId(databaseIdProvider.getDatabaseId(dataSource));
}
for (Map.Entry<String, Class<?>> alias : typeAliases.entrySet()) {
configuration.getTypeAliasRegistry().registerAlias(alias.getKey(), alias.getValue());
}
for (Map.Entry<Class<?>, TypeHandler<?>> typeHandler : typeHandlers.entrySet()) {
registerTypeHandler(configuration, typeHandler.getKey(), typeHandler.getValue());
}
for (TypeHandler<?> typeHandler : mappingTypeHandlers) {
configuration.getTypeHandlerRegistry().register(typeHandler);
}
for (Class<?> mapperClass : mapperClasses) {
if (!configuration.hasMapper(mapperClass)) {
configuration.addMapper(mapperClass);
}
}
for (Interceptor interceptor : plugins) {
configuration.addInterceptor(interceptor);
}
if (failFast) {
configuration.getMappedStatementNames();
}
} catch (Throwable cause) {
throw new ProvisionException(
"An error occurred while building the org.apache.ibatis.session.Configuration", cause);
} finally {
ErrorContext.instance().reset();
}
return configuration;
}
/**
* 对SQL参数(?)设值, 参考org.apache.ibatis.executor.parameter.DefaultParameterHandler。
*
* @param ps 表示预编译的 SQL 语句的对象。
* @param mappedStatement MappedStatement
* @param boundSql SQL
* @param parameterObject 参数对象
* @throws java.sql.SQLException 数据库异常
*/
@SuppressWarnings("unchecked")
public static void setParameters(
PreparedStatement ps,
MappedStatement mappedStatement,
BoundSql boundSql,
Object parameterObject)
throws SQLException {
ErrorContext.instance()
.activity("setting parameters")
.object(mappedStatement.getParameterMap().getId());
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
if (parameterMappings != null) {
Configuration configuration = mappedStatement.getConfiguration();
TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
MetaObject metaObject =
parameterObject == null ? null : configuration.newMetaObject(parameterObject);
for (int i = 0; i < parameterMappings.size(); i++) {
ParameterMapping parameterMapping = parameterMappings.get(i);
if (parameterMapping.getMode() != ParameterMode.OUT) {
Object value;
String propertyName = parameterMapping.getProperty();
PropertyTokenizer prop = new PropertyTokenizer(propertyName);
if (parameterObject == null) {
value = null;
} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
value = parameterObject;
} else if (boundSql.hasAdditionalParameter(propertyName)) {
value = boundSql.getAdditionalParameter(propertyName);
} else if (propertyName.startsWith(ForEachSqlNode.ITEM_PREFIX)
&& boundSql.hasAdditionalParameter(prop.getName())) {
value = boundSql.getAdditionalParameter(prop.getName());
if (value != null) {
value =
configuration
.newMetaObject(value)
.getValue(propertyName.substring(prop.getName().length()));
}
} else {
value = metaObject == null ? null : metaObject.getValue(propertyName);
}
@SuppressWarnings("rawtypes")
TypeHandler typeHandler = parameterMapping.getTypeHandler();
if (typeHandler == null) {
throw new ExecutorException(
"There was no TypeHandler found for parameter "
+ propertyName
+ " of statement "
+ mappedStatement.getId());
}
typeHandler.setParameter(ps, i + 1, value, parameterMapping.getJdbcType());
}
}
}
}
public DefaultResultSetHandler(
Executor executor,
MappedStatement mappedStatement,
ParameterHandler parameterHandler,
ResultHandler resultHandler,
BoundSql boundSql,
RowBounds rowBounds) {
this.executor = executor;
this.configuration = mappedStatement.getConfiguration();
this.mappedStatement = mappedStatement;
this.rowBounds = rowBounds;
this.parameterHandler = parameterHandler;
this.boundSql = boundSql;
this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
this.objectFactory = configuration.getObjectFactory();
this.resultHandler = resultHandler;
}
public InlineParameterMapParser(Configuration configuration) {
this.configuration = configuration;
this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
this.typeAliasRegistry = configuration.getTypeAliasRegistry();
}
/**
* Build a {@code SqlSessionFactory} instance.
*
* <p>The default implementation uses the standard MyBatis {@code XMLConfigBuilder} API to build a
* {@code SqlSessionFactory} instance based on an Reader.
*
* @return SqlSessionFactory
* @throws IOException if loading the config file failed
*/
protected SqlSessionFactory buildSqlSessionFactory() throws IOException {
Configuration configuration;
XMLConfigBuilder xmlConfigBuilder = null;
if (this.configLocation != null) {
xmlConfigBuilder =
new XMLConfigBuilder(
this.configLocation.getInputStream(), null, this.configurationProperties);
configuration = xmlConfigBuilder.getConfiguration();
} else {
if (this.logger.isDebugEnabled()) {
this.logger.debug(
"Property 'configLocation' not specified, using default MyBatis Configuration");
}
configuration = new Configuration();
configuration.setVariables(this.configurationProperties);
}
if (this.objectFactory != null) {
configuration.setObjectFactory(this.objectFactory);
}
if (this.objectWrapperFactory != null) {
configuration.setObjectWrapperFactory(this.objectWrapperFactory);
}
if (hasLength(this.typeAliasesPackage)) {
String[] typeAliasPackageArray =
tokenizeToStringArray(
this.typeAliasesPackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
for (String packageToScan : typeAliasPackageArray) {
configuration
.getTypeAliasRegistry()
.registerAliases(
packageToScan, typeAliasesSuperType == null ? Object.class : typeAliasesSuperType);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Scanned package: '" + packageToScan + "' for aliases");
}
}
}
if (!isEmpty(this.typeAliases)) {
for (Class<?> typeAlias : this.typeAliases) {
configuration.getTypeAliasRegistry().registerAlias(typeAlias);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Registered type alias: '" + typeAlias + "'");
}
}
}
if (!isEmpty(this.plugins)) {
for (Interceptor plugin : this.plugins) {
configuration.addInterceptor(plugin);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Registered plugin: '" + plugin + "'");
}
}
}
if (hasLength(this.typeHandlersPackage)) {
String[] typeHandlersPackageArray =
tokenizeToStringArray(
this.typeHandlersPackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
for (String packageToScan : typeHandlersPackageArray) {
configuration.getTypeHandlerRegistry().register(packageToScan);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Scanned package: '" + packageToScan + "' for type handlers");
}
}
}
if (!isEmpty(this.typeHandlers)) {
for (TypeHandler<?> typeHandler : this.typeHandlers) {
configuration.getTypeHandlerRegistry().register(typeHandler);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Registered type handler: '" + typeHandler + "'");
}
}
}
if (xmlConfigBuilder != null) {
try {
xmlConfigBuilder.parse();
if (this.logger.isDebugEnabled()) {
this.logger.debug("Parsed configuration file: '" + this.configLocation + "'");
}
} catch (Exception ex) {
throw new NestedIOException("Failed to parse config resource: " + this.configLocation, ex);
} finally {
ErrorContext.instance().reset();
}
}
if (this.transactionFactory == null) {
this.transactionFactory = new SpringManagedTransactionFactory();
}
Environment environment =
new Environment(this.environment, this.transactionFactory, this.dataSource);
configuration.setEnvironment(environment);
if (this.databaseIdProvider != null) {
try {
configuration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));
} catch (SQLException e) {
throw new NestedIOException("Failed getting a databaseId", e);
}
}
ArrayList<Resource> listado_resources = new ArrayList<Resource>();
if (!isEmpty(this.mapperLocations1)) {
for (Resource resource : this.mapperLocations1) {
listado_resources.add(resource);
}
}
if (!isEmpty(this.mapperLocations2)) {
for (Resource resource : this.mapperLocations2) {
listado_resources.add(resource);
}
}
if (!isEmpty(this.mapperLocations3)) {
for (Resource resource : this.mapperLocations3) {
listado_resources.add(resource);
}
}
if (!isEmpty(this.mapperLocations4)) {
for (Resource resource : this.mapperLocations4) {
listado_resources.add(resource);
}
}
this.mapperLocations = new Resource[listado_resources.size()];
int index = 0;
for (Resource resource : listado_resources) {
this.mapperLocations[index] = resource;
index++;
}
if (!isEmpty(this.mapperLocations)) {
for (Resource mapperLocation : this.mapperLocations) {
if (mapperLocation == null) {
continue;
}
// //log.info("Mapa cargado: " + mapperLocation);
try {
XMLMapperBuilder xmlMapperBuilder =
new XMLMapperBuilder(
mapperLocation.getInputStream(),
configuration,
mapperLocation.toString(),
configuration.getSqlFragments());
xmlMapperBuilder.parse();
} catch (Exception e) {
throw new NestedIOException(
"Failed to parse mapping resource: '" + mapperLocation + "'", e);
} finally {
ErrorContext.instance().reset();
}
if (this.logger.isDebugEnabled()) {
this.logger.debug("Parsed mapper file: '" + mapperLocation + "'");
}
}
} else {
if (this.logger.isDebugEnabled()) {
this.logger.debug(
"Property 'mapperLocations' was not specified or no matching resources found");
}
}
return this.sqlSessionFactoryBuilder.build(configuration);
}
@SuppressWarnings("unchecked")
private <T> void registerTypeHandler(
Configuration configuration, Class<?> type, TypeHandler<?> handler) {
configuration.getTypeHandlerRegistry().register((Class<T>) type, (TypeHandler<T>) handler);
}