Spring boot怎么整合Mybatis

最近刚接触spring boot,正是因为他的及简配置方便开发,促使我下定决心要用它把之前写的项目重构,那么问题来了,spring boot怎么整合mybatis呢,下面几个配置类来搞定。

在我的代码当中是实现了数据库读写分离的,所以代码仅做参考,如有需要可以加我微信:benyzhous

【后续更新】

1、文件结构

DataBaseConfiguration.Java用来获取数据库连接配置信息,配置从application.properties中读取

MybatisConfiguration.java也就是MyBatis配置核心入口,构建连接创建SqlSessionFactory

2、下面直接贴代码,有问题的话可以留言或者加我的微信公众号:cha-baba,或者个人微信号:benyzhous

application.yml 相关配置

# Server settings
server:
 port:8080
 address:localhost
# DATASOURCE
jdbc:
 driverClass: com.mysql.jdbc.Driver
 url: jdbc:mysql://127.0.0.1:3306/local-kaishustory?useUnicode=true&characterEncoding=utf-8
 username: root
 password: root
# SPRING PROFILES
spring:
 # HTTP ENCODING
 http:
  encoding.charset: UTF-8
  encoding.enable: true
  encoding.force: true
# WeiXin Configuration
weixin:
 mp:
  appid: xx
  secret: ee
  token: weixin
  aeskey:
# MyBatis
mybatis:
 typeAliasesPackage: com.modou.**.domain
 mapperLocations: classpath:/com/modou/**/mapper/*.xml
 configLocation: classpath:/mybatis-config.xml
# LOGGING
logging:
 level:
  com.ibatis:DEBUG 

DataBaseConfiguration.java

package com.modou.conf.mybatis;
import java.util.ArrayList;
import java.util.List;
import javax.sql.DataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.bind.RelaxedPropertyResolver;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.env.Environment;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import com.alibaba.druid.pool.DruidDataSource;
@Configuration
@EnableTransactionManagement
public class DataBaseConfiguration implements EnvironmentAware {
 private RelaxedPropertyResolver propertyResolver;
 private static Logger log = LoggerFactory.getLogger(DataBaseConfiguration.class);
 @Override
 public void setEnvironment(Environment env) {
  this.propertyResolver = new RelaxedPropertyResolver(env, "jdbc.");
 }
 @Bean(name="writeDataSource", destroyMethod = "close", initMethod="init")
 @Primary
 public DataSource writeDataSource() {
  log.debug("Configruing Write DataSource");
  DruidDataSource datasource = new DruidDataSource();
  datasource.setUrl(propertyResolver.getProperty("url"));
  datasource.setDriverClassName(propertyResolver.getProperty("driverClassName"));
  datasource.setUsername(propertyResolver.getProperty("username"));
  datasource.setPassword(propertyResolver.getProperty("password"));
  return datasource;
 }
 @Bean(name="readOneDataSource", destroyMethod = "close", initMethod="init")
 public DataSource readOneDataSource() {
  log.debug("Configruing Read One DataSource");
  DruidDataSource datasource = new DruidDataSource();
  datasource.setUrl(propertyResolver.getProperty("url"));
  datasource.setDriverClassName(propertyResolver.getProperty("driverClassName"));
  datasource.setUsername(propertyResolver.getProperty("username"));
  datasource.setPassword(propertyResolver.getProperty("password"));
  return datasource;
 }
 @Bean(name="readTowDataSource", destroyMethod = "close", initMethod="init")
 public DataSource readTowDataSource() {
  log.debug("Configruing Read Two DataSource");
  DruidDataSource datasource = new DruidDataSource();
  datasource.setUrl(propertyResolver.getProperty("url"));
  datasource.setDriverClassName(propertyResolver.getProperty("driverClassName"));
  datasource.setUsername(propertyResolver.getProperty("username"));
  datasource.setPassword(propertyResolver.getProperty("password"));
  return datasource;
 }
 @Bean(name="readDataSources")
 public List<DataSource> readDataSources(){
  List<DataSource> dataSources = new ArrayList<DataSource>();
  dataSources.add(readOneDataSource());
  dataSources.add(readTowDataSource());
  return dataSources;
 }
} 

MyBatisConfiguration.java

package com.modou.conf.mybatis;
import java.util.List;
import javax.annotation.Resource;
import javax.persistence.EntityManager;
import javax.sql.DataSource;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.mybatis.spring.plugin.rw.RoundRobinRWRoutingDataSourceProxy;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.bind.RelaxedPropertyResolver;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.core.io.DefaultResourceLoader;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
/**
 *
 * 获取第二个数据库的连接信息,在application.yml中配置,并指定特定的前缀
 *
 */
@Configuration
@ConditionalOnClass({ EnableTransactionManagement.class, EntityManager.class })
@AutoConfigureAfter({ DataBaseConfiguration.class })
@MapperScan(basePackages={"com.modou.**.mapper","com.github.abel533.entity.mapper"})
public class MybatisConfiguration implements EnvironmentAware{
 private static Log logger = LogFactory.getLog(MybatisConfiguration.class);
 private RelaxedPropertyResolver propertyResolver;
 @Resource(name="writeDataSource")
 private DataSource writeDataSource;
 @Resource(name="readDataSources")
 private List<Object> readDataSources;
 @Override
 public void setEnvironment(Environment environment) {
  this.propertyResolver = new RelaxedPropertyResolver(environment,"mybatis.");
 }
 @Bean
 @ConditionalOnMissingBean
 public SqlSessionFactory sqlSessionFactory() {
  try {
   SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
   sessionFactory.setDataSource(roundRobinDataSouceProxy());
   sessionFactory.setTypeAliasesPackage(propertyResolver
     .getProperty("typeAliasesPackage"));
   sessionFactory
     .setMapperLocations(new PathMatchingResourcePatternResolver()
       .getResources(propertyResolver
         .getProperty("mapperLocations")));
   sessionFactory
     .setConfigLocation(new DefaultResourceLoader()
       .getResource(propertyResolver
         .getProperty("configLocation")));
   return sessionFactory.getObject();
  } catch (Exception e) {
   logger.warn("Could not confiure mybatis session factory");
   return null;
  }
 }
 @Bean
 public RoundRobinRWRoutingDataSourceProxy roundRobinDataSouceProxy(){
  RoundRobinRWRoutingDataSourceProxy proxy = new RoundRobinRWRoutingDataSourceProxy();
  proxy.setWriteDataSource(writeDataSource);
  proxy.setReadDataSoures(readDataSources);
  proxy.setReadKey("READ");
  proxy.setWriteKey("WRITE");
  return proxy;
 }
 @Bean
 @ConditionalOnMissingBean
 public DataSourceTransactionManager transactionManager() {
  return new DataSourceTransactionManager(writeDataSource);
 }
} 

Application.java

package com.modou.weixin;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import com.modou.weixin.service.HelloWorldService;
/**
 * Created by chababa on 15/8/22.
 */
@Configuration
@ComponentScan(basePackages={"com.modou.conf","com.modou.weixin"})
@EnableAutoConfiguration
public class Application implements CommandLineRunner{
 @Autowired
 HelloWorldService helloWorldService;
 public static void main(String[] args) {
  SpringApplication.run(Application.class, args);
 }
 @Override
 public void run(String... args) throws Exception {
  System.out.println(this.helloWorldService.print());
 }
} 

3、maven pom.xml 相关依赖[我是基于我的多模块依赖,这里只是一个示意],其中配置了jrebel热部署插件,需要搭配jrebel6.2.1,具体配置和下载请转向 http://blog.csdn.net/xiaoyu411502/article/details/48047369

<?xml version="1.0"?>
<project
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
 xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
 <modelVersion>4.0.0</modelVersion>
 <parent>
  <groupId>com.modou.weixin</groupId>
  <artifactId>weixin-boot-parent</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <relativePath>../weixin-boot-parent</relativePath>
 </parent>
 <artifactId>weixin-boot-services</artifactId>
 <name>weixin-boot-services</name>
 <url>http://maven.apache.org</url>
 <properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <springloaded.version>1.2.4.RELEASE</springloaded.version>
 </properties>
 <dependencies>
  <dependency>
   <groupId>com.modou.weixin</groupId>
   <artifactId>weixin-boot-sdk</artifactId>
   <version>${project.version}</version>
  </dependency>
  <dependency>
   <groupId>com.modou.weixin</groupId>
   <artifactId>mybatis-plugin-rw</artifactId>
   <version>${project.version}</version>
  </dependency>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-actuator</artifactId>
  </dependency>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-thymeleaf</artifactId>
  </dependency>
  <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-jdbc</artifactId>
  </dependency>
  <dependency>
   <groupId>javax.persistence</groupId>
   <artifactId>persistence-api</artifactId>
  </dependency>
  <dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis</artifactId>
  </dependency>
  <dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis-spring</artifactId>
  </dependency>
  <dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>druid</artifactId>
  </dependency>
  <dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
  </dependency>
  <dependency>
   <groupId>com.github.pagehelper</groupId>
   <artifactId>pagehelper</artifactId>
  </dependency>
  <dependency>
   <groupId>tk.mybatis</groupId>
   <artifactId>mapper</artifactId>
  </dependency>
  <dependency>
   <groupId>org.mybatis.generator</groupId>
   <artifactId>mybatis-generator-core</artifactId>
  </dependency>
 </dependencies>
</project> 

以上所述是小编给大家介绍的Spring boot整合Mybatis的方法,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对我们网站的支持!

(0)

相关推荐

  • spring Boot与Mybatis整合优化详解

    SpringBoot官方文档http://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/ 关于spring-boot与mybatis整合优化方面的介绍,就是Mybatis-Spring-boot-starter的介绍: 1.取消spring-mybatis.xml配置 ①自动检测已存在的Datasource 之前,需要在spring-mybatis.xml中配置datasource的Bean,现在只需要在applicat

  • 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 Boot整合mybatis(一)实例代码

    sprig-boot是一个微服务架构,加快了spring工程快速开发,以及简便了配置.接下来开始spring-boot与mybatis的整合. 1.创建一个maven工程命名为spring-boot-entity,pom.xml文件配置如下: <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:s

  • Spring Boot+Mybatis的整合过程

    依赖配置 结合前面的内容,这里我们要嵌入数据库的操作,这里以操作MySQL为例整合Mybatis,首先需要在原来的基础上添加以下依赖 <!-- mybatis依赖 --> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.1.1<

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

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

  • springboot与mybatis整合实例详解(完美融合)

    简介 从 Spring Boot 项目名称中的 Boot 可以看出来,Spring Boot 的作用在于创建和启动新的基于 Spring 框架的项目.它的目的是帮助开发人员很容易的创建出独立运行和产品级别的基于 Spring 框架的应用.Spring Boot 会选择最适合的 Spring 子项目和第三方开源库进行整合.大部分 Spring Boot 应用只需要非常少的配置就可以快速运行起来. Spring Boot 包含的特性如下: 创建可以独立运行的 Spring 应用. 直接嵌入 Tomc

  • Spring Boot 整合 Mybatis Annotation 注解的完整 Web 案例

    前言 距离第一篇 Spring Boot 系列的博文 3 个月了.虽然 XML 形式是我比较推荐的,但是注解形式也是方便的.尤其一些小系统,快速的 CRUD 轻量级的系统. 这里感谢晓春 http://xchunzhao.tk/ 的 Pull Request,提供了 springboot-mybatis-annotation 的实现. 一.运行 springboot-mybatis-annotation 工程 然后Application 应用启动类的 main 函数,然后在浏览器访问: http

  • Spring boot怎么整合Mybatis

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

  • 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

  • Spring Boot 如何整合连接池

    Spring Boot 整合连接池 在实际开发中应用程序与数据库交互时,"获得连接"或在"释放资源"是非常消耗资源的两个过程,为了解决如此类性能问题,通常这种情况我们采用连接池技术重用连接Connection对象,如图1所示. 图-1 其实Java为数据库连接池提供了公共的接口:javax.sql.DataSource,各个厂商需要让自己的连接池实现这个接口.然后我们的应用程序中耦合这个接口,便可以方便的切换不同厂商的连接池,常见的连接池有DBCP.C3P0.DRU

  • Spring Boot 功能整合的实现

    前言 如果根据之前做的 Nest.js 后端项目功能为标准的话,那么 Spring Boot 项目需要几种功能进行整合,好在生态丰富,集成也不算困难.所以打算根据之前的项目使用 Spring Boot 重写个新的项目: Restful API CRUD 功能实现 数据库对象关系映射功能持久化支持 OpenAPI 文档支持 参数校验判断业务 redis 缓存 ... 数据库持久化支持 目前数据库持久化主要是 Spring Boot Jpa 和 Spring Boot Mybatis .如果看过 J

  • Spring Boot 优雅整合多数据源

    目录 何时用到多数据源 整合单一的数据源 整合Mybatis 多数据源如何整合? 什么是动态数据源? 数据源切换如何保证线程隔离? 如何构造一个动态数据源? 定义一个注解 如何与Mybatis整合? 演示 总结 前言: 什么是多数据源?最常见的单一应用中最多涉及到一个数据库,即是一个数据源(Datasource).那么顾名思义,多数据源就是在一个单一应用中涉及到了两个及以上的数据库了. 其实在配置数据源的时候就已经很明确这个定义了,如以下代码: @Bean(name = "dataSource&

  • 关于Spring Boot WebSocket整合以及nginx配置详解

    前言 本文主要给大家介绍了关于Spring Boot WebSocket整合及nginx配置的相关内容,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍吧. 一:Spring Boot WebSocket整合 创建一个maven项目,加入如下依赖 <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.boot</groupId>

  • Spring Boot/Angular整合Keycloak实现单点登录功能

    Keycloak Keycloak为现代应用和服务提供开源的认证和访问管理,即通常所说的认证和授权.Keycloak支持OpenID.OAuth 2.0和SAML 2.0协议:支持用户注册.用户管理.权限管理:支持代理OpenID.SAML 2.0 IDP,支持GitHub.LinkedIn等第三方登录,支持整合LDAP和Active Directory:支持自定义认证流程.自定义用户界面,支持国际化. Keycloak支持Java.C#.Python.Android.iOS.JavaScrip

  • Spring Boot 2 整合 QuartJob 实现定时器实时管理功能

    一.QuartJob简介 1.一句话描述 Quartz是一个完全由java编写的开源作业调度框架,形式简易,功能强大. 2.核心API (1).Scheduler 代表一个 Quartz 的独立运行容器,Scheduler 将 Trigger 绑定到特定 JobDetail, 这样当 Trigger 触发时, 对应的 Job 就会被调度. (2).Trigger 描述 Job 执行的时间触发规则.主要有 SimpleTrigger 和 CronTrigger 两个子类,通过一个 TriggerK

  • spring boot 2整合swagger-ui过程解析

    这篇文章主要介绍了spring boot 2整合swagger-ui过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 1.添加mvn依赖 修改pom.xml加入 <dependency> <groupId>io.springfox</groupId> <artifactId>springfox-swagger2</artifactId> <version>2.5.0</v

  • 从零搭建Spring Boot脚手架整合OSS作为文件服务器的详细教程

    1. 前言 文件服务器是一个应用必要的组件之一.最早我搞过FTP,然后又用过FastDFS,接私活的时候我用MongoDB也凑合凑合.现如今时代不同了,开始流行起了OSS. Gitee: https://gitee.com/felord/kono day06 分支 欢迎Star GitHub: https://github.com/NotFound403/kono day06 分支 欢迎Star 2. 什么是OSS 全称为Object Storage Service,也叫对象存储服务,是一种解决

随机推荐