spring 整合 mybatis 中数据源的几种配置方式

2021-10-10 01:11:29

　　因为spring 整合mybatis的过程中，有好几种整合方式，尤其是数据源那块，经常看到不一样的配置方式，总感觉有点乱，所以今天有空总结下。

　　一、采用org.mybatis.spring.mapper.MapperScannerConfigurer

　　其实逆向工程也是这种方式

　　1、数据源配配置文件

 <?xml version="1.0" encoding="UTF-8"?>

 <beans xmlns="http://www.springframework.org/schema/beans"

     xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"

     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd

     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd

     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

     <!-- 加载配置文件 -->

     <context:property-placeholder location="classpath:resource/*.properties" />

     <!-- 数据库连接池 -->

     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"

         destroy-method="close">

         <property name="driverClassName" value="${jdbc.driver}" />

         <property name="url" value="${jdbc.url}" />

         <property name="username" value="${jdbc.username}" />

         <property name="password" value="${jdbc.password}" />

         <property name="maxActive" value="10" />

         <property name="minIdle" value="5" />

     </bean>

     <!-- sqlsessionFactory -->

     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">

         <property name="configLocation" value="classpath:mybatis/SqlMapConfig.xml"></property>

         <property name="dataSource" ref="dataSource"></property>

     </bean>

     <!-- 加载mapper代理对象 -->

     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">

         <property name="basePackage" value="com.jdd.mapper"></property>

         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>

     </bean>

 </beans>

　　2、DAO文件

 package com.jdd.mapper;

 import com.jdd.pojo.Employee;

 import java.util.List;

 public interface EmployeeMapper {

     public Employee getEmployeeById(int id);

     public List<Employee> findAllEmployees();

 }

　　3、Mapper.xml 文件

 <?xml version="1.0" encoding="UTF-8" ?>

 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

 <mapper namespace="com.jdd.mapper.EmployeeMapper">

     <select id="getEmployeeById" parameterType="int" resultType="com.jdd.pojo.Employee">

         <![CDATA[

             select * from employee where id = #{id};

         ]]>

     </select>

     <select id="findAllEmployees" resultType="com.jdd.pojo.Employee">

         <![CDATA[

             select * from employee where status='1';

         ]]>

     </select>

 </mapper>

　　这样在service类里就可以直接注入dao接口了

 package com.jdd.service.impl;

 import com.jdd.mapper.EmployeeMapper;

 import com.jdd.pojo.Employee;

 import com.jdd.service.EmployeeService;

 import org.springframework.beans.factory.annotation.Autowired;

 import org.springframework.stereotype.Service;

 import java.util.List;

 @Service("employeeService")

 public class EmployeeServiceImpl implements EmployeeService{

     @Autowired

     private EmployeeMapper employeeMapper;

     @Override

     public Employee getEmployeeById(int id) {

         return employeeMapper.getEmployeeById(id);

     }

     @Override

     public List<Employee> findAllEmployees() {

         return employeeMapper.findAllEmployees();

     }

 }

　　二、采用抽象类org.mybatis.spring.support.SqlSessionDaoSupport，给它注入 sqlSessionFactory的方式

　　1、数据源配置文件

 <?xml version="1.0" encoding="UTF-8"?>

 <beans xmlns="http://www.springframework.org/schema/beans"

     xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"

     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd

     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd

     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

     <!-- 加载配置文件 -->

     <context:property-placeholder location="classpath:resource/*.properties" />

     <!-- 数据库连接池 -->

     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"

         destroy-method="close">

         <property name="driverClassName" value="${jdbc.driver}" />

         <property name="url" value="${jdbc.url}" />

         <property name="username" value="${jdbc.username}" />

         <property name="password" value="${jdbc.password}" />

         <property name="maxActive" value="10" />

         <property name="minIdle" value="5" />

     </bean>

     <!-- sqlsessionFactory -->

     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">

         <property name="configLocation" value="classpath:mybatis/SqlMapConfig.xml"></property>

         <property name="dataSource" ref="dataSource"></property>

         <property name="mapperLocations" value="classpath:com/jdd/mapper/*.xml"></property>

     </bean>

 </beans>

　　2、baseDao类

 package com.hd.dao;

 import org.apache.ibatis.session.SqlSessionFactory;

 import org.mybatis.spring.support.SqlSessionDaoSupport;

 import javax.annotation.Resource;

 public abstract class BaseDao extends SqlSessionDaoSupport {

     @Resource

     public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {

         super.setSqlSessionFactory(sqlSessionFactory);

     }

 }

　　3、接口 EmployeeDao.java 类

 package com.hd.dao;

 import com.hd.pojo.Employee;

 import java.util.List;

 public interface EmployeeDao {

     Employee getEmployeeById(int id);

     List<Employee> findAllEmployees();

 }

　　4、dao实现类 EmployeeDaoImpl

 package com.hd.dao.impl;

 import com.hd.dao.BaseDao;

 import com.hd.dao.EmployeeDao;

 import com.hd.pojo.Employee;

 import org.springframework.stereotype.Repository;

 import java.util.List;

 @Repository("employeeDao")

 public class EmployeeDaoImpl extends BaseDao implements EmployeeDao {

     @Override

     public Employee getEmployeeById(int id) {

         return this.getSqlSession().selectOne("com.jdd.dao.EmployeeDao.getEmployeeById", id);

     }

     @Override

     public List<Employee> findAllEmployees() {

         return this.getSqlSession().selectList("com.jdd.dao.EmployeeDao.findAllEmployees");

     }

 }

　　5、这样就可以在service类里注入 employeeDao了

　　三、采用 org.mybatis.spring.SqlSessionTemplate 模板类

　　1、数据源文件

 <?xml version="1.0" encoding="UTF-8"?>

 <beans xmlns="http://www.springframework.org/schema/beans"

     xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"

     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd

     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd

     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

     <!-- 加载配置文件 -->

     <context:property-placeholder location="classpath:resource/*.properties" />

     <!-- 数据库连接池 -->

         <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"

         destroy-method="close">

         <property name="driverClassName" value="${jdbc.driver}" />

         <property name="url" value="${jdbc.url}" />

         <property name="username" value="${jdbc.username}" />

         <property name="password" value="${jdbc.password}" />

         <property name="maxActive" value="10" />

         <property name="minIdle" value="5" />

     </bean>

     <!-- sqlsessionFactory -->

     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">

         <property name="configLocation" value="classpath:mybatis/SqlMapConfig.xml"></property>

         <property name="dataSource" ref="dataSource"></property>

         <property name="mapperLocations" value="classpath:com/jdd/mapper/*.xml"></property>

     </bean>

     <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">

         <constructor-arg index="0" ref="sqlSessionFactory"/>

     </bean>

 </beans>

　　2、 basedao.java 类

 package com.hd.dao;

 import org.mybatis.spring.SqlSessionTemplate;

 import javax.annotation.Resource;

 public abstract class BaseDao {

     public SqlSessionTemplate sqlSessionTemplate;

     @Resource

     public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {

         this.sqlSessionTemplate = sqlSessionTemplate;

     }

 }

　　3、接口 EmployeeDao.java 类

 package com.hd.dao;

 import com.hd.pojo.Employee;

 import java.util.List;

 public interface EmployeeDao {

     Employee getEmployeeById(int id);

     List<Employee> findAllEmployees();

 }

　　4、dao实现类 EmployeeDaoImpl

 package com.hd.dao.impl;

 import com.hd.dao.BaseDao;

 import com.hd.dao.EmployeeDao;

 import com.hd.pojo.Employee;

 import org.springframework.stereotype.Repository;

 import java.util.List;

 @Repository("employeeDao")

 public class EmployeeDaoImpl extends BaseDao implements EmployeeDao {

     @Override

     public Employee getEmployeeById(int id) {

         return sqlSessionTemplate.selectOne("com.jdd.dao.EmployeeDao.getEmployeeById", id);

     }

     @Override

     public List<Employee> findAllEmployees() {

         return sqlSessionTemplate.selectList("com.jdd.dao.EmployeeDao.findAllEmployees");

     }

 }

　　5、同样现在也可以在service类里直接注入 employeeDao使用了。

　　注：这里basedao的注入比较灵活，也可以注入 SqlSessionFactory，然后再setter方法里创建 SqlSessionTemplate，如下：

 package com.hd.dao;

 import org.apache.ibatis.session.SqlSessionFactory;

 import org.mybatis.spring.SqlSessionTemplate;

 import javax.annotation.Resource;

 public abstract class BaseDao {

     public SqlSessionTemplate sqlSessionTemplate;

     @Resource

     public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {

         sqlSessionTemplate = new SqlSessionTemplate(sqlSessionFactory);

     }

 }

　　其实不管是采用继承SqlSessionDaoSupport类，注入 sqlSessionFactory的方式，还是直接注入 SqlSessionTemplate 的方式，本质上是一样的。

　　如果你采用注入 sqlSessionFactory的方式，它在底层也是通过sqlSessionFactory 来创建 SqlSessionTemplate ，然后通过其api来操作。

　　不信给你们看下 SqlSessionDaoSupport 的源码：

 //

 // Source code recreated from a .class file by IntelliJ IDEA

 // (powered by Fernflower decompiler)

 //

 package org.mybatis.spring.support;

 import org.apache.ibatis.session.SqlSession;

 import org.apache.ibatis.session.SqlSessionFactory;

 import org.mybatis.spring.SqlSessionTemplate;

 import org.springframework.dao.support.DaoSupport;

 import org.springframework.util.Assert;

 public abstract class SqlSessionDaoSupport extends DaoSupport {

     private SqlSession sqlSession;

     private boolean externalSqlSession;

     public SqlSessionDaoSupport() {

     }

     public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {

         if (!this.externalSqlSession) {

             this.sqlSession = new SqlSessionTemplate(sqlSessionFactory);

         }

     }

     public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {

         this.sqlSession = sqlSessionTemplate;

         this.externalSqlSession = true;

     }

     public SqlSession getSqlSession() {

         return this.sqlSession;

     }

     protected void checkDaoConfig() {

         Assert.notNull(this.sqlSession, "Property 'sqlSessionFactory' or 'sqlSessionTemplate' are required");

     }

 }

　　同样 SqlSessionTemplate 继承了 SqlSession 接口，因此不管操作哪个效果都一样

 //

 // Source code recreated from a .class file by IntelliJ IDEA

 // (powered by Fernflower decompiler)

 //

 package org.mybatis.spring;

 import java.lang.reflect.InvocationHandler;

 import java.lang.reflect.Method;

 import java.lang.reflect.Proxy;

 import java.sql.Connection;

 import java.util.List;

 import java.util.Map;

 import org.apache.ibatis.exceptions.PersistenceException;

 import org.apache.ibatis.executor.BatchResult;

 import org.apache.ibatis.reflection.ExceptionUtil;

 import org.apache.ibatis.session.Configuration;

 import org.apache.ibatis.session.ExecutorType;

 import org.apache.ibatis.session.ResultHandler;

 import org.apache.ibatis.session.RowBounds;

 import org.apache.ibatis.session.SqlSession;

 import org.apache.ibatis.session.SqlSessionFactory;

 import org.springframework.dao.support.PersistenceExceptionTranslator;

 import org.springframework.util.Assert;

 public class SqlSessionTemplate implements SqlSession {

     private final SqlSessionFactory sqlSessionFactory;

     private final ExecutorType executorType;

     private final SqlSession sqlSessionProxy;

     private final PersistenceExceptionTranslator exceptionTranslator;

     public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {

         this(sqlSessionFactory, sqlSessionFactory.getConfiguration().getDefaultExecutorType());

     }

     public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType) {

         this(sqlSessionFactory, executorType, new MyBatisExceptionTranslator(sqlSessionFactory.getConfiguration().getEnvironment().getDataSource(), true));

     }

     public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {

         Assert.notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");

         Assert.notNull(executorType, "Property 'executorType' is required");

         this.sqlSessionFactory = sqlSessionFactory;

         this.executorType = executorType;

         this.exceptionTranslator = exceptionTranslator;

         this.sqlSessionProxy = (SqlSession)Proxy.newProxyInstance(SqlSessionFactory.class.getClassLoader(), new Class[]{SqlSession.class}, new SqlSessionTemplate.SqlSessionInterceptor());

     }

     public SqlSessionFactory getSqlSessionFactory() {

         return this.sqlSessionFactory;

     }

     public ExecutorType getExecutorType() {

         return this.executorType;

     }

     public PersistenceExceptionTranslator getPersistenceExceptionTranslator() {

         return this.exceptionTranslator;

     }

     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 <K, V> Map<K, V> selectMap(String statement, String mapKey) {

         return this.sqlSessionProxy.selectMap(statement, mapKey);

     }

     public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey) {

         return this.sqlSessionProxy.selectMap(statement, parameter, mapKey);

     }

     public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds) {

         return this.sqlSessionProxy.selectMap(statement, parameter, mapKey, rowBounds);

     }

     public <E> List<E> selectList(String statement) {

         return this.sqlSessionProxy.selectList(statement);

     }

     public <E> List<E> selectList(String statement, Object parameter) {

         return this.sqlSessionProxy.selectList(statement, parameter);

     }

     public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {

         return this.sqlSessionProxy.selectList(statement, parameter, rowBounds);

     }

     public void select(String statement, ResultHandler handler) {

         this.sqlSessionProxy.select(statement, handler);

     }

     public void select(String statement, Object parameter, ResultHandler handler) {

         this.sqlSessionProxy.select(statement, parameter, handler);

     }

     public void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {

         this.sqlSessionProxy.select(statement, parameter, rowBounds, handler);

     }

     public int insert(String statement) {

         return this.sqlSessionProxy.insert(statement);

     }

     public int insert(String statement, Object parameter) {

         return this.sqlSessionProxy.insert(statement, parameter);

     }

     public int update(String statement) {

         return this.sqlSessionProxy.update(statement);

     }

     public int update(String statement, Object parameter) {

         return this.sqlSessionProxy.update(statement, parameter);

     }

     public int delete(String statement) {

         return this.sqlSessionProxy.delete(statement);

     }

     public int delete(String statement, Object parameter) {

         return this.sqlSessionProxy.delete(statement, parameter);

     }

     public <T> T getMapper(Class<T> type) {

         return this.getConfiguration().getMapper(type, this);

     }

     public void commit() {

         throw new UnsupportedOperationException("Manual commit is not allowed over a Spring managed SqlSession");

     }

     public void commit(boolean force) {

         throw new UnsupportedOperationException("Manual commit is not allowed over a Spring managed SqlSession");

     }

     public void rollback() {

         throw new UnsupportedOperationException("Manual rollback is not allowed over a Spring managed SqlSession");

     }

     public void rollback(boolean force) {

         throw new UnsupportedOperationException("Manual rollback is not allowed over a Spring managed SqlSession");

     }

     public void close() {

         throw new UnsupportedOperationException("Manual close is not allowed over a Spring managed SqlSession");

     }

     public void clearCache() {

         this.sqlSessionProxy.clearCache();

     }

     public Configuration getConfiguration() {

         return this.sqlSessionFactory.getConfiguration();

     }

     public Connection getConnection() {

         return this.sqlSessionProxy.getConnection();

     }

     public List<BatchResult> flushStatements() {

         return this.sqlSessionProxy.flushStatements();

     }

     private class SqlSessionInterceptor implements InvocationHandler {

         private SqlSessionInterceptor() {

         }

         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

             SqlSession sqlSession = SqlSessionUtils.getSqlSession(SqlSessionTemplate.this.sqlSessionFactory, SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);

             Object unwrapped;

             try {

                 Object result = method.invoke(sqlSession, args);

                 if (!SqlSessionUtils.isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {

                     sqlSession.commit(true);

                 }

                 unwrapped = result;

             } catch (Throwable var11) {

                 unwrapped = ExceptionUtil.unwrapThrowable(var11);

                 if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {

                     SqlSessionUtils.closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);

                     sqlSession = null;

                     Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException)unwrapped);

                     if (translated != null) {

                         unwrapped = translated;

                     }

                 }

                 throw (Throwable)unwrapped;

             } finally {

                 if (sqlSession != null) {

                     SqlSessionUtils.closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);

                 }

             }

             return unwrapped;

         }

     }

 }

码农公寓

相关文章