动态网站开发与全程实例pdf/seo外链建设的方法有

Spring整合Mybaits的步骤

引入依赖

在Spring整合Mybaits的时候需要引入一个中间依赖包mybatis-spring

<dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.5</version>
</dependency>
<dependency><groupId>org.mybatis</groupId><artifactId>mybatis-spring</artifactId><version>2.0.2</version>
</dependency>

添加spring配置

为了整合mybatis，需要在spring的配置文件中引入mybtis的配置，这些配置通过两个类实现，SqlSessionFactoryBean以及MapperFactoryBean；SqlSessionFactoryBean负责加载mybatis-config文件以及注入数据源，MapperFactoryBean负责加载mapper接口

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:aop="http://www.springframework.org/schema/aop"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd
"><bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource"   destroy-method="close"><property name="driverClassName" value="com.mysql.jdbc.Driver"></property><property name="username" value="root"></property><property name="password" value="husj0423"></property><property name="url" value="jdbc:mysql://localhost:3306/test"></property><property name="initialSize" value="1"></property><property name="maxTotal" value="20"></property><property name="maxIdle" value="5"></property><property name="minIdle" value="2"></property></bean><bean id="userService" class="com.handerh.spring.test.aop.db.jdbc.UserServiceImpl"><property name="dataSource" ref="dataSource"></property></bean><bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="configLocation" value="sqlmap/mybatis-config.xml"></property><property name="dataSource" ref="dataSource"></property></bean><bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean"><property name="mapperInterface" value="mapper.UserMapper"></property><property name="sqlSessionFactory" ref="sqlSessionFactory"></property></bean></beans>

添加Mybatis配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configurationPUBLIC "-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd">
<!-- mybatis的主配置文件 -->
<configuration>
<!-- 指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件 -->
<mappers><mapper resource="sqlmap/UserMapper.xml"/>
</mappers>
</configuration>

测试

public static void main(String[] args) {ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring-mabatis.xml");UserMapper userMapper = (UserMapper) applicationContext.getBean("userMapper");User user = userMapper.selectByPrimaryKey(6);
}

Spring整合Mybaits源码分析

在Spring与Myabtis整合的配置文件中，配置了两个重要的beanSqlSessionFactoryBean以及MapperFactoryBean，接下来主要分析这两个类是如何将mybatis整合到Spring中

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="configLocation" value="sqlmap/mybatis-config.xml"></property><property name="dataSource" ref="dataSource"></property>
</bean><bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean"><property name="mapperInterface" value="mapper.UserMapper"></property><property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
</bean>

SqlSessionFactoryBean

可以看到它实现了两个非常重要的接口：

• InitializingBean：实现此接口的bean会在初始化时调用afterPropertiesSet方法进行bean的逻辑初始化

• FactoryBean：一旦某个Bean实现此接口，那么通过getBean获取bean时实际上获取的是此类的getObject返回的实例

SqlSessionFactoryBean的初始化

在实例化SqlSessionFactoryBean会调用afterPropertiesSet方法，在该方法最终会调用buildSqlSessionFactory函数来创建SqlSessionFactory；根据spring配置文件中注入的属性configLocation构造XMLConfigBuilder并且进行解析。Spring不仅可以通过configLocation的方式整合Mybatis的配置，还可以将Mybatis的配置直接整合到Spring配置文件中进行属性注入，并通过targetConfiguration来承载属性，最终使用sqlSessionFactoryBuilder实例根据解析的configuration创建SqlSessionFactory

protected SqlSessionFactory buildSqlSessionFactory() throws Exception {final Configuration targetConfiguration;XMLConfigBuilder xmlConfigBuilder = null;
if (this.configuration != null) {targetConfiguration = this.configuration;if (targetConfiguration.getVariables() == null) {targetConfiguration.setVariables(this.configurationProperties);} else if (this.configurationProperties != null) {targetConfiguration.getVariables().putAll(this.configurationProperties);}
} else if (this.configLocation != null) {xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);targetConfiguration = xmlConfigBuilder.getConfiguration();
} else {targetConfiguration = new Configuration();Optional.ofNullable(this.configurationProperties).ifPresent(targetConfiguration::setVariables);
}Optional.ofNullable(this.objectFactory).ifPresent(targetConfiguration::setObjectFactory);
Optional.ofNullable(this.objectWrapperFactory).ifPresent(targetConfiguration::setObjectWrapperFactory);
Optional.ofNullable(this.vfs).ifPresent(targetConfiguration::setVfsImpl);// 类别名
if (hasLength(this.typeAliasesPackage)) {scanClasses(this.typeAliasesPackage, this.typeAliasesSuperType).stream().filter(clazz -> !clazz.isAnonymousClass()).filter(clazz -> !clazz.isInterface()).filter(clazz -> !clazz.isMemberClass()).forEach(targetConfiguration.getTypeAliasRegistry()::registerAlias);
}if (!isEmpty(this.typeAliases)) {Stream.of(this.typeAliases).forEach(typeAlias -> {targetConfiguration.getTypeAliasRegistry().registerAlias(typeAlias);LOGGER.debug(() -> "Registered type alias: '" + typeAlias + "'");});
}//Mybatis插件，可以修改Mybatis内部的允许规则
if (!isEmpty(this.plugins)) {Stream.of(this.plugins).forEach(plugin -> {targetConfiguration.addInterceptor(plugin);LOGGER.debug(() -> "Registered plugin: '" + plugin + "'");});
}//定义类型处理器
if (hasLength(this.typeHandlersPackage)) {scanClasses(this.typeHandlersPackage, TypeHandler.class).stream().filter(clazz -> !clazz.isAnonymousClass()).filter(clazz -> !clazz.isInterface()).filter(clazz -> !Modifier.isAbstract(clazz.getModifiers())).filter(clazz -> ClassUtils.getConstructorIfAvailable(clazz) != null).forEach(targetConfiguration.getTypeHandlerRegistry()::register);
}if (!isEmpty(this.typeHandlers)) {Stream.of(this.typeHandlers).forEach(typeHandler -> {targetConfiguration.getTypeHandlerRegistry().register(typeHandler);LOGGER.debug(() -> "Registered type handler: '" + typeHandler + "'");});
}if (!isEmpty(this.scriptingLanguageDrivers)) {Stream.of(this.scriptingLanguageDrivers).forEach(languageDriver -> {targetConfiguration.getLanguageRegistry().register(languageDriver);LOGGER.debug(() -> "Registered scripting language driver: '" + languageDriver + "'");});
}
Optional.ofNullable(this.defaultScriptingLanguageDriver).ifPresent(targetConfiguration::setDefaultScriptingLanguage);if (this.databaseIdProvider != null) {// fix #64 set databaseId before parse mapper xmlstry {targetConfiguration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));} catch (SQLException e) {throw new NestedIOException("Failed getting a databaseId", e);}
}Optional.ofNullable(this.cache).ifPresent(targetConfiguration::addCache);if (xmlConfigBuilder != null) {try {xmlConfigBuilder.parse();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();}
}
// SpringManagedTransactionFactory 事务工厂
targetConfiguration.setEnvironment(new Environment(this.environment,this.transactionFactory == null ? new SpringManagedTransactionFactory() : this.transactionFactory,this.dataSource));// mapper文件解析
if (this.mapperLocations != null) {if (this.mapperLocations.length == 0) {LOGGER.warn(() -> "Property 'mapperLocations' was specified but matching resources are not found.");} else {for (Resource mapperLocation : this.mapperLocations) {if (mapperLocation == null) {continue;}try {XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),targetConfiguration, mapperLocation.toString(), targetConfiguration.getSqlFragments());xmlMapperBuilder.parse();} catch (Exception e) {throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);} finally {ErrorContext.instance().reset();}LOGGER.debug(() -> "Parsed mapper file: '" + mapperLocation + "'");}}
} else {LOGGER.debug(() -> "Property 'mapperLocations' was not specified.");
}return this.sqlSessionFactoryBuilder.build(targetConfiguration);
}

获取SqlSessionFactoryBean的实例

当通过getBean方法获取对应SqlSessionFactoryBean实例时，其实获取到的是getObject返回的初始化后的SqlSessionFactory

public SqlSessionFactory getObject() throws Exception {if (this.sqlSessionFactory == null) {afterPropertiesSet();}return this.sqlSessionFactory;
}

MapperFactoryBean

MapperFactoryBean的继承体系如下：

可以看到MapperFactoryBean也实现了InitializingBean以及FactoryBean接口，同样的在通过getBean初始化bean实例的前也会调用afterPropertiesSet方法

afterPropertiesSet校验

public final void afterPropertiesSet() throws IllegalArgumentException, BeanInitializationException {// Let abstract subclasses check their configuration.checkDaoConfig();// Let concrete implementations initialize themselves.try {initDao();}catch (Exception ex) {throw new BeanInitializationException("Initialization of DAO failed", ex);}
}

这里的checkDaoConfig()方法主要时做一个验证，校验mapperInterface这个属性是否有值，同时将mapperInterface放入到Mybatis的MapperRegistry中。

getObject获取mapper实例

afterPropertiesSet方法主要是做了一个校验逻辑，真正获取mapper实例的逻辑在getObject方法中

public T getObject() throws Exception {return getSqlSession().getMapper(this.mapperInterface);
}
public SqlSession getSqlSession() {return this.sqlSessionTemplate;
}

看到这里其实就是通过SqlSession来创建Mapper实例了，但是这个SqlSession不是独立使用时的DefaultSqlSession，而是SqlSessionTemplate，这个SqlSessionTemplate是什么时候注入的呢，看上面的类图发现SqlSessionTemplate继承了qlSessionDaoSupport,这个类中有一个属性SqlSessionTemplate，还包含一个set方法setSqlSessionFactory，这个方法完成了SqlSessionTemplate的创建，如下：

public abstract class SqlSessionDaoSupport extends DaoSupport {private SqlSessionTemplate sqlSessionTemplate;public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {if (this.sqlSessionTemplate == null || sqlSessionFactory != this.sqlSessionTemplate.getSqlSessionFactory()) {this.sqlSessionTemplate = createSqlSessionTemplate(sqlSessionFactory);}}
}

而我们在Spring配置文件中刚好配置为MapperFactoryBean注入了SqlSessionFactory，通过SqlSessionFactory创建SqlSessionTemplate从而完成mapper实例的创建

<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean"><property name="mapperInterface" value="mapper.UserMapper"></property><property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
</bean>

SqlSessionTemplate获取mapper实例

public <T> T getMapper(Class<T> type) {return getConfiguration().getMapper(type, this);
}

通过获取Mybatis配置来创建mapper实例，最终调用的是MapperRegistry.getMapper

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory)this.knownMappers.get(type);if (mapperProxyFactory == null) {throw new BindingException("Type " + type + " is not known to the MapperRegistry.");} else {try {//动态代理创建mapper对象，这里的sqlSession是sqlSessionTemplatereturn mapperProxyFactory.newInstance(sqlSession);} catch (Exception var5) {throw new BindingException("Error getting mapper instance. Cause: " + var5, var5);}}
}

mapper代理对象的执行

获取到mapper代理对象之后，就可以执行方法调用了。看一下SqlSessionTemplate中的方法：

public <T> T selectOne(String statement) {return this.sqlSessionProxy.selectOne(statement);
}public <T> T selectOne(String statement, Object parameter) {return this.sqlSessionProxy.selectOne(statement, parameter);
}public int insert(String statement, Object parameter) {return this.sqlSessionProxy.insert(statement, parameter);
}public int update(String statement) {return this.sqlSessionProxy.update(statement);
}

发现所有的增删改方法都是通过sqlSessionProxy来实现的，这个对象则是在初始化SqlSessionTemplate时生成的一个代理对象：

public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,PersistenceExceptionTranslator exceptionTranslator) {this.sqlSessionFactory = sqlSessionFactory;this.executorType = executorType;this.exceptionTranslator = exceptionTranslator;this.sqlSessionProxy = (SqlSession) newProxyInstance(SqlSessionFactory.class.getClassLoader(),new Class[] { SqlSession.class }, new SqlSessionInterceptor());
}

对于JDK动态代理生成的对象方法的调用都说在Invocationhandler中完成的，SqlSessionInterceptor实现了Invocationhandler接口：

private class SqlSessionInterceptor implements InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 1.获取SqlSessionSqlSession sqlSession = getSqlSession(SqlSessionTemplate.this.sqlSessionFactory,SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);try {// 2. 执行目标方法Object result = method.invoke(sqlSession, args);if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {sqlSession.commit(true);}return result;} catch (Throwable t) {Throwable unwrapped = unwrapThrowable(t);if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {// release the connection to avoid a deadlock if the translator is no loaded. See issue #22closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);sqlSession = null;Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException) unwrapped);if (translated != null) {unwrapped = translated;}}throw unwrapped;} finally {//3.关闭sqlSessionif (sqlSession != null) {closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);}}
}

在SqlSessionInterceptor有一个获取SqlSession的操作，来看一下：

public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType,PersistenceExceptionTranslator exceptionTranslator) {//获取SqlSessionHolder，如果是同一个事物，Spring会保证在改事物中获取到的SqlSession是同一个SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);//从SqlSession中获取SqlSessionSqlSession session = sessionHolder(executorType, holder);if (session != null) {return session;}//通过SqlSessionFactory创建DefaultSqlSessionLOGGER.debug(() -> "Creating a new SqlSession");session = sessionFactory.openSession(executorType);//如果开启了事物会将该SqlSession注册到SessionHolder中registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);return session;
}

这段代码的主要逻辑就是创建SqlSession来完成mapper的执行，如果加入了Spring的事物管理，则需要保证在同一个事物中获取到的SqlSession是同一个（事物的提交以及回滚），到这里Mybatis与Spring整合的核心逻辑就已经完成了，另外，Spring为了简化Mapper接口的注册，加入了包扫描，减少在Spring配置文件中的mapper配置。

MapperScannerConfigurer

在Spring配置文件加入如下配置，就不需要为每一个Mapper接口再配置MapperFactoryBean了

<bean  id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer"><property name="basePackage" value="mapper"></property>
</bean>

我们来了解一下MapperScannerConfigurer是如何实现的。先看一下它的继承结构：

发现MapperScannerConfigurer实现了BeanDefinitionRegistryPostProcessor，InitializingBean两个接口，不过MapperScannerConfigurer的afterPropertiesSet方法中没有去做任何的逻辑处理，主要逻辑都是在postProcessBeanDefinitionRegistry方法中实现的(实现了BeanDefinitionRegistryPostProcessor接口)，这个接口在容器启动的时候(AbstractApplicationContext.refresh())会被调用：

invokeBeanFactoryPostProcessors(beanFactory);
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());}

看一下MapperScannerConfigurer中postProcessBeanDefinitionRegistry的处理逻辑：

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);scanner.setAddToConfig(this.addToConfig);scanner.setAnnotationClass(this.annotationClass);scanner.setMarkerInterface(this.markerInterface);scanner.setSqlSessionFactory(this.sqlSessionFactory);scanner.setSqlSessionTemplate(this.sqlSessionTemplate);scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);scanner.setResourceLoader(this.applicationContext);scanner.setBeanNameGenerator(this.nameGenerator);scanner.setMapperFactoryBeanClass(this.mapperFactoryBeanClass);if (StringUtils.hasText(lazyInitialization)) {scanner.setLazyInitialization(Boolean.valueOf(lazyInitialization));}scanner.registerFilters();// 对指定路径完成扫描scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));}

doScan扫描

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {Assert.notEmpty(basePackages, "At least one base package must be specified");Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();for (String basePackage : basePackages) {// 扫描basePackage下的java文件Set<BeanDefinition> candidates = findCandidateComponents(basePackage);for (BeanDefinition candidate : candidates) {// 解析该bean是否包含scope注解 默认为singleScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);candidate.setScope(scopeMetadata.getScopeName());// 生成bean名称 默认首字母小写String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);if (candidate instanceof AbstractBeanDefinition) {postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);}if (candidate instanceof AnnotatedBeanDefinition) {//检测常用注解：Primary LazyAnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);}// 检测该bean是否已经注册if (checkCandidate(beanName, candidate)) {BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);// 如果当前bean需要被代理 则需要进一步处理definitionHolder =AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);// bean的注册beanDefinitions.add(definitionHolder);registerBeanDefinition(definitionHolder, this.registry);}}}return beanDefinitions;
}

processBeanDefinitions构造MapperFactoryBean类型的bean

关键代码就下面两行，生成一个MapperFactoryBean类型的Bean，其中的mapperInterface属性，通过构造函数时将代理的beanClassName传入，这样通过包扫描就可以生成许多的MapperFactoryBean类型的Bean，简化Mapper接口的注册

private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
GenericBeanDefinition definition;for (BeanDefinitionHolder holder : beanDefinitions) {definition = (GenericBeanDefinition) holder.getBeanDefinition();String beanClassName = definition.getBeanClassName();// 构造函数时使用Mapper自身的类，因为MapperFactoryBean中的属性mapperInterface通过构造函数传入，以便进行代理definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName); // issue #59// 实际上该Bean类型为MapperFactoryBeandefinition.setBeanClass(this.mapperFactoryBeanClass);}
} 

总结

spring整合mybatis分为两个方面，一个是加载配置以及mapper实例的初始化，这一块主要通过SqlSessionFactoryBean以及MapperFactoryBean来实现，另一方面是执行流程，通过SqlSessionTemplate以及SqlSessionInterceptor实现

• SqlSessionFactoryBean：实现了InitiallizeBean，初始化时执行afterProperties方法，根据spring配置文件中的dataSource以及configLocations创建SqlSessionFactory
• MapperFactoryBean：实现了FactoryBean，在获取bean对象时实际上走的是getObject方法，通过sqlSessionTemplate获取mapper实例
• SqlSessionTemplate：通过实现SqlSessionDaoSupport接口注入SqlSessionFactory对象时，完成SqlSessionTemplate对象的初始化；它在创建mapper对象时还是通过mybatis原生的配置类来完成的。
• SqlSessionInterceptor：mapper实例在执行增删改时最终会调用到SqlSession的增删改方法，也就是SqlSessionTemplate的一些方法，这些方法都是通过sqlSessionProxy的一个代理对象来完成的，这个代理对象通过SqlSessionInterceptor创建，在执行具体的方法时会走到SqlSessionInterceptor的invoke方法中，这个方法中才会创建真正的SqlSession负责执行增删改方法，同时将SqlSession与事务关联，如果是同一个事物，Spring会保证在改事物中获取到的SqlSession是同一个。