spring-mybatis与原生mybatis使用对比分析

原生mybatis使用方法:

String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session = sqlSessionFactory.openSession();
try {
      Employee employee = new Employee(null, "doubi", "1", "ddd@sys.com");
      EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
      mapper.addEmp(employee);
      session.commit();
} finally {
   session.close();
}

spring使用方法,直接注入即可

@Autowired
EmployeeMapper employeeMapper

那么spring为我们做了什么?下面研究一下mybatis-spring.jar这个jar包

首先来看一下如何使用spring整合mybatis,下面是使用spring-mybatis的四种方法:

方法一:(使用MapperFactoryBean)

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  <property name="dataSource" ref="dataSource"/>
  <property name="configLocation" value="classpath:mybatis-config.xml"></property>
  <!-- 自动扫描mapping.xml文件 -->
  <property name="mapperLocations" value="classpath:mapper/*.xml"></property>
</bean>
<!--上面生成sqlSessionFactory的几个方法基本相同-->
<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
 <property name="mapperInterface" value="org.mybatis.spring.sample.mapper.UserMapper" />
 <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

这样做的缺点是每一个mapper接口都要在xml里配置一下

方法二:采用接口org.apache.ibatis.session.SqlSession的实现类 org.mybatis.spring.SqlSessionTemplate

mybatis中, sessionFactory可由SqlSessionFactoryBuilder.来创建。MyBatis-Spring 中,使用了SqlSessionFactoryBean来替代。SqlSessionFactoryBean有一个必须属性dataSource,另外其还有一个通用属性configLocation(用来指定mybatis的xml配置文件路径)。

SqlSessionFactoryBean即相当于原生mybatis中的SqlSessionFactoryBuilder

<!-- spring和MyBatis完美整合,不需要mybatis的配置映射文件 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  <property name="dataSource" ref="dataSource" />
  <property name="configLocation" value="classpath:sqlMapConfig.xml"/>
  <!-- 自动扫描mapping.xml文件,**表示迭代查找,也可在sqlMapConfig.xml中单独指定xml文件-->
  <property name="mapperLocations" value="classpath:com/hua/saf/**/*.xml" />
</bean>
<!-- mybatis spring sqlSessionTemplate,使用时直接让spring注入即可 -->
<bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
  <constructor-arg index="0" ref="sqlSessionFactory"></constructor-arg>
</bean>
//使用方法:
@Repositorypublic class UserDao{  @Resource  private SqlSessionTemplate sqlSessionTemplate;    public User getUser(int id) {    return sqlSessionTemplate.selectOne(this.getClass().getName() + ".getUser", 1);  }  }

为什么可以这样写,来看一下SqlSessionTemplate

public class SqlSessionTemplate implements SqlSession { private final SqlSessionFactory sqlSessionFactory; private final ExecutorType executorType; private final SqlSession sqlSessionProxy; private final PersistenceExceptionTranslator exceptionTranslator; /**  * Constructs a Spring managed SqlSession with the {@code SqlSessionFactory}  * provided as an argument.  *  * @param sqlSessionFactory  */ public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {  this(sqlSessionFactory, sqlSessionFactory.getConfiguration().getDefaultExecutorType()); }
........省略......
  public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,   PersistenceExceptionTranslator exceptionTranslator) {  notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");  notNull(executorType, "Property 'executorType' is required");  this.sqlSessionFactory = sqlSessionFactory;  this.executorType = executorType;  this.exceptionTranslator = exceptionTranslator;  this.sqlSessionProxy = (SqlSession) newProxyInstance(    SqlSessionFactory.class.getClassLoader(),    new Class[] { SqlSession.class },    new SqlSessionInterceptor()); }
}

如上面代码所示,SqlSessionTemplate类实现了原生Mybatis中的SqlSession接口,实际上它就是原生mybatis中的SqlSession

方法三:采用抽象类 org.mybatis.spring.support.SqlSessionDaoSupport 提供SqlSession

<!-- spring和MyBatis完美整合,不需要mybatis的配置映射文件 -->
  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="configLocation" value="classpath:sqlMapConfig.xml"/>
    <!-- 自动扫描mapping.xml文件,**表示迭代查找,也可在sqlMapConfig.xml中单独指定xml文件-->
    <property name="mapperLocations" value="classpath:com/hua/saf/**/*.xml" />
  </bean>
public class BaseDao extends SqlSessionDaoSupport{ //使用sqlSessionFactory @Autowired  private SqlSessionFactory sqlSessionFactory;
@Autowired  public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory)
{
super.setSqlSessionFactory(sqlSessionFactory);
}  /**  * 执行insert操作  * @param statement  * @return  */ public int insert(String statement) {
return getSqlSession().insert(statement); } /**  * 执行insert操作  * @param statement  * @param parameter  * @return  */ public int insert(String statement, Object parameter) {
return getSqlSession().insert(statement, parameter); }
public int update(String statement)
{  return getSqlSession().update(statement);
}
public int update(String statement, Object parameter) {  return getSqlSession().update(statement, parameter); }
public int delete(String statement)
{
return getSqlSession().delete(statement);
}
public int delete(String statement, Object parameter) {
return getSqlSession().delete(statement, parameter); }  /**  * 获取一个list集合  * @param statement  * @return  */ public List<?> selectList(String statement) {  return getSqlSession().selectList(statement); }  /**  * 根据参数 获取一个list集合  * @param statement  * @param parameter  * @return  */ public List<?> selectList(String statement, Object parameter) {  return getSqlSession().selectList(statement, parameter); }  public Map<?, ?> selectMap(String statement, String mapKey) {  return getSqlSession().selectMap(statement, mapKey); } public Map<?, ?> selectMap(String statement, Object parameter, String mapKey) {  return getSqlSession().selectMap(statement, parameter, mapKey); }  /**  * 获取Object对象  * @param statement  * @return  */ public Object selectOne(String statement) {  return getSqlSession().selectOne(statement); }  /**  * 获取connection, 以便执行较为复杂的用法  * @return  */ public Connection getConnection() {  return getSqlSession().getConnection(); } }

如上代码,一个Dao类继承了SqlSessionDaoSupport类后,就可以在类中注入SessionFact
ory,进而通过getSqlSession()获取当前SqlSession

下面是 SqlSessionDaoSupport的源码 ,它是一个抽象类,并拥有sqlSession属性,在setSqlSessionFactory方法中实例化了该sqlSession:

public abstract class SqlSessionDaoSupport extends DaoSupport
{
private SqlSession sqlSession; private boolean externalSqlSession;
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()
{
notNull(this.sqlSession, "Property 'sqlSessionFactory' or 'sqlSessionTemplate' are required"); }}

方法四:(也是 最常见的使用方法 ,使用MapperScannerConfigurer,它将会查找类路径下的映射器并自动将它们创建成MapperFactoryBean)

由于直接使用MapperFactoryBean会在配置文件中配置大量mapper,因此这里使用包扫描的方式通过注解获取该bean

<!-- spring和MyBatis完美整合,不需要mybatis的配置映射文件 -->
  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <!-- 自动扫描mapping.xml文件,**表示迭代查找 -->
    <property name="mapperLocations" value="classpath:com/hua/saf/**/*.xml" />
  </bean>
  <!-- DAO接口所在包名,Spring会自动查找其下的类 ,包下的类需要使用@MapperScan注解,否则容器注入会失败 -->
  <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.hua.saf.*" />
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
  </bean>
//使用如下代码,即可完成注入
@Resource
private UserDao userDao;

下面看一下MapperScannerConfigurer这个类:

public class MapperScannerConfigurer implements BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware { private String basePackage; private boolean addToConfig = true; private SqlSessionFactory sqlSessionFactory; private SqlSessionTemplate sqlSessionTemplate; private String sqlSessionFactoryBeanName; private String sqlSessionTemplateBeanName; private Class<? extends Annotation> annotationClass; private Class<?> markerInterface; private ApplicationContext applicationContext; private String beanName; private boolean processPropertyPlaceHolders; private BeanNameGenerator nameGenerator;
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {  if (this.processPropertyPlaceHolders) {   processPropertyPlaceHolders();  }  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.registerFilters();  scanner.scan(StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS)); }
ClassPathMapperScanner :
public Set<BeanDefinitionHolder> doScan(String... basePackages) {  Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);  if (beanDefinitions.isEmpty()) {   logger.warn("No MyBatis mapper was found in '" + Arrays.toString(basePackages) + "' package. Please check your configuration.");  } else {   for (BeanDefinitionHolder holder : beanDefinitions) {    GenericBeanDefinition definition = (GenericBeanDefinition) holder.getBeanDefinition();    if (logger.isDebugEnabled()) {     logger.debug("Creating MapperFactoryBean with name '" + holder.getBeanName()        + "' and '" + definition.getBeanClassName() + "' mapperInterface");    }    // the mapper interface is the original class of the bean    // but, the actual class of the bean is MapperFactoryBean    definition.getPropertyValues().add("mapperInterface", definition.getBeanClassName());    definition.setBeanClass(MapperFactoryBean.class);    definition.getPropertyValues().add("addToConfig", this.addToConfig);    boolean explicitFactoryUsed = false;    if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {     definition.getPropertyValues().add("sqlSessionFactory", new RuntimeBeanReference(this.sqlSessionFactoryBeanName));     explicitFactoryUsed = true;    } else if (this.sqlSessionFactory != null) {     definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);     explicitFactoryUsed = true;    }    if (StringUtils.hasText(this.sqlSessionTemplateBeanName)) {     if (explicitFactoryUsed) {      logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");     }     definition.getPropertyValues().add("sqlSessionTemplate", new RuntimeBeanReference(this.sqlSessionTemplateBeanName));     explicitFactoryUsed = true;    } else if (this.sqlSessionTemplate != null) {     if (explicitFactoryUsed) {      logger.warn("Cannot use both: sqlSessionTemplate and sqlSessionFactory together. sqlSessionFactory is ignored.");     }     definition.getPropertyValues().add("sqlSessionTemplate", this.sqlSessionTemplate);     explicitFactoryUsed = true;    }    if (!explicitFactoryUsed) {     if (logger.isDebugEnabled()) {      logger.debug("Enabling autowire by type for MapperFactoryBean with name '" + holder.getBeanName() + "'.");     }     definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);    }   }  }  return beanDefinitions; }

总结:spring-mybatis与原生Mybatis相比,如下概念:

1)SqlSessionFactory类在两者中都存在

2)前者用SqlSessionFactoryBean生成SqlSessionFactory,后者则使用SqlSessionFactoryBuilder;

3)前者使用SqlSessionTemplate,后者使用SqlSession,实际上前者实现了后者

4)MapperFactoryBean中实现了原生mybatis中下面的步骤,因此通过该类可以直接获取到一个mapper接口的实现对象

EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);

总结

以上所述是小编给大家介绍的spring-mybatis与原生mybatis使用对比分析,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对我们网站的支持!

您可能感兴趣的文章:

  • SpringMVC与Mybatis集合实现调用存储过程、事务控制实例
  • SpringMvc+Mybatis+Pagehelper分页详解
  • Spring Boot MyBatis 连接数据库配置示例
  • springboot + mybatis配置多数据源示例
  • Spring Boot 集成Mybatis实现主从(多数据源)分离方案示例
  • 详解Spring Boot整合Mybatis实现 Druid多数据源配置
  • 基于SpringBoot与Mybatis实现SpringMVC Web项目
  • Spring Boot整合MyBatis操作过程
(0)

相关推荐

  • springboot + mybatis配置多数据源示例

    在实际开发中,我们一个项目可能会用到多个数据库,通常一个数据库对应一个数据源. 代码结构: 简要原理: 1)DatabaseType列出所有的数据源的key---key 2)DatabaseContextHolder是一个线程安全的DatabaseType容器,并提供了向其中设置和获取DatabaseType的方法 3)DynamicDataSource继承AbstractRoutingDataSource并重写其中的方法determineCurrentLookupKey(),在该方法中使用Da

  • SpringMVC与Mybatis集合实现调用存储过程、事务控制实例

    在SSM框架中经常会用到调用数据库中的存储过程.以及事务控制,下面以保存某单据为例,介绍一下: 1.Oracle中存储过程代码如下(主要逻辑将单据编码自动加1,并将该单据编码返回): CREATE OR REPLACE PROCEDURE "UPDATE_DJBHZT" (p_GSID in varchar2, p_TBLNAME in varchar2, NewRecNo out Number) as begin update BHDJ set BHDJ02 = BHDJ02+1 w

  • 基于SpringBoot与Mybatis实现SpringMVC Web项目

    一.热身 一个现实的场景是:当我们开发一个Web工程时,架构师和开发工程师可能更关心项目技术结构上的设计.而几乎所有结构良好的软件(项目)都使用了分层设计.分层设计是将项目按技术职能分为几个内聚的部分,从而将技术或接口的实现细节隐藏起来. 从另一个角度上来看,结构上的分层往往也能促进了技术人员的分工,可以使开发人员更专注于某一层业务与功能的实现,比如前端工程师只关心页面的展示与交互效果(例如专注于HTML,JS等),而后端工程师只关心数据和业务逻辑的处理(专注于Java,Mysql等).两者之间

  • Spring Boot MyBatis 连接数据库配置示例

    最近比较忙,没来得及抽时间把MyBatis的集成发出来,其实mybatis官网在2015年11月底就已经发布了对SpringBoot集成的Release版本,示例代码:spring-boot_jb51.rar 前面对JPA和JDBC连接数据库做了说明,本文也是参考官方的代码做个总结. 先说个题外话,SpringBoot默认使用 org.apache.tomcat.jdbc.pool.DataSource 现在有个叫 HikariCP 的JDBC连接池组件,据说其性能比常用的 c3p0.tomca

  • 详解Spring Boot整合Mybatis实现 Druid多数据源配置

    一.多数据源的应用场景 目前,业界流行的数据操作框架是 Mybatis,那 Druid 是什么呢? Druid 是 Java 的数据库连接池组件.Druid 能够提供强大的监控和扩展功能.比如可以监控 SQL ,在监控业务可以查询慢查询 SQL 列表等.Druid 核心主要包括三部分: 1. DruidDriver 代理 Driver,能够提供基于 Filter-Chain 模式的插件体系. 2. DruidDataSource 高效可管理的数据库连接池 3. SQLParser 当业务数据量达

  • SpringMvc+Mybatis+Pagehelper分页详解

    最近公司需要做一个告警页面的功能,需要分页,查了很多资料发现PageHelper比较合适 故写一篇从零开始的PageHelper使用的教程,也记录下忙活一天的东西 1.首先需要在项目中添加PageHelper的依赖,这里我用的Maven添加 <dependency> <groupId>com.github.pagehelper</groupId> <artifactId>pagehelper</artifactId> <version>

  • Spring Boot 集成Mybatis实现主从(多数据源)分离方案示例

    本文将介绍使用Spring Boot集成Mybatis并实现主从库分离的实现(同样适用于多数据源).延续之前的Spring Boot 集成MyBatis.项目还将集成分页插件PageHelper.通用Mapper以及Druid. 新建一个Maven项目,最终项目结构如下: 多数据源注入到sqlSessionFactory POM增加如下依赖: <!--JSON--> <dependency> <groupId>com.fasterxml.jackson.core<

  • Spring Boot整合MyBatis操作过程

    1.加入mybatis-spring-boot-stater的Maven依赖 <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.1.1</version> </dependency> 2.配置数据源 在src/main/re

  • spring-mybatis与原生mybatis使用对比分析

    原生mybatis使用方法: String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); SqlSession session = sqlSessionFac

  • hibernate和mybatis对比分析

    第一章     Hibernate与MyBatis Hibernate 是当前最流行的O/R mapping框架,它出身于sf.net,现在已经成为Jboss的一部分. Mybatis 是另外一种优秀的O/R mapping框架.目前属于apache的一个子项目. MyBatis 参考资料官网:http://www.mybatis.org/core/zh/index.html Hibernate参考资料: http://docs.jboss.org/hibernate/core/3.6/refe

  • Fluent Mybatis,原生Mybatis,Mybatis Plus三者功能对比

    目录 三者实现对比 使用fluent mybatis 来实现上面的功能 换成mybatis原生实现效果 换成mybatis plus实现效果 生成代码编码比较 fluent mybatis生成代码设置 mybatis plus代码生成设置 FluentMybatis特性一览 三者对比总结 Fluent Mybatis介绍和源码 使用fluent mybatis可以不用写具体的xml文件,通过java api可以构造出比较复杂的业务sql语句,做到代码逻辑和sql逻辑的合一. 不用再需要在Dao中

  • Mybatis通过Spring完成代理类注入的流程分析

    流程分析 首先,使用mybatis的时候会定义mapper接口的基础包,一般我们会用@MapperScanner这个注解,来看下这个注解 来看下这个MapperScannerRegistrar类 这个类实现了ImportBeanDefinitionRegistrar也就是spring注册beanDefined时候需用到,这个重写了一下,这个方法里,前面的话是一些基础属性的赋值,最重要的是这个方法 根据basePackages去进行扫描,来跟下这个方法 首先会调用父类生成一个BeanDefinit

  • Spring Boot环境下Mybatis Plus的快速应用操作

    一.简介 Mybatis-Plus(简称MP)是一个 Mybatis 的一个增强工具,在 Mybatis 的基础上只做增强不做改变,为简化开发.提高效率而生.其愿景是成为Mybatis最好的搭档,将开发效率翻倍,由于受到学习研究深入限制,本例只进行Mybatis Plus在Spring Boot环境下的基本应用(如Select.Insert.Update.Delete等基本操作,其中还包括动态生成组合查询与更新的动态SQL语句). 特性: 无侵入:Mybatis-Plus 在 Mybatis 的

  • Spring利用注解整合Mybatis的方法详解

    目录 一.环境准备 步骤1:数据库相关 步骤2:导入jar包 步骤3:创建模型类 步骤4:创建Dao接口和实现类 步骤5:创建Service接口和实现类 步骤6:添加jdbc.properties文件 步骤7:添加Mybatis核心配置文件 步骤8:编写测试程序 二.整合思路分析 三.整合步骤 步骤1:导入整合jar包 步骤2:创建数据源配置类 步骤3:创建Mybatis配置类 步骤4:创建Spring主配置类 步骤5:编写运行程序 一.环境准备 步骤1:数据库相关 建库建表 创建spring_

  • java原生序列化和Kryo序列化性能实例对比分析

    简介 最近几年,各种新的高效序列化方式层出不穷,不断刷新序列化性能的上限,最典型的包括: 专门针对Java语言的:Kryo,FST等等 跨语言的:Protostuff,ProtoBuf,Thrift,Avro,MsgPack等等 这些序列化方式的性能多数都显著优于hessian2(甚至包括尚未成熟的dubbo序列化).有鉴于此,我们为dubbo引入Kryo和FST这 两种高效Java序列化实现,来逐步取代hessian2.其中,Kryo是一种非常成熟的序列化实现,已经在Twitter.Group

  • Spring boot怎么整合Mybatis

    最近刚接触spring boot,正是因为他的及简配置方便开发,促使我下定决心要用它把之前写的项目重构,那么问题来了,spring boot怎么整合mybatis呢,下面几个配置类来搞定. 在我的代码当中是实现了数据库读写分离的,所以代码仅做参考,如有需要可以加我微信:benyzhous [后续更新] 1.文件结构 DataBaseConfiguration.Java用来获取数据库连接配置信息,配置从application.properties中读取 MybatisConfiguration.j

  • MyBatis接口的简单实现原理分析

    用过MyBatis3的人可能会觉得为什么MyBatis的Mapper接口没有实现类,但是可以直接用? 那是因为MyBatis使用Java动态代理实现的接口. 这里仅仅举个简单例子来说明原理,不是完全针对MyBatis的,这种思想我们也可以应用在其他地方. 定义一个接口 public interface MethodInterface { String helloWorld(); } 实现动态代理接口 public class MethodProxy<T> implements Invocati

  • Spring Boot + Kotlin整合MyBatis的方法教程

    前言 最近使用jpa比较多,再看看mybatis的xml方式写sql觉得不爽,接口定义与映射离散在不同文件中,使得阅读起来并不是特别方便. 因此使用Spring Boot去整合MyBatis,在注解里写sql 参考<我的第一个Kotlin应用> 创建项目,在build.gradle文件中引入依赖 compile "org.mybatis.spring.boot:mybatis-spring-boot-starter:$mybatis_version" compile &qu

随机推荐