SpringBoot和Mybatis整合

SpringBoot和Mybatis整合

使用Maven配置 Eclipse环境 MySql数据库

最近刚开始学习Spring框架

然后也是第一次使用MyBatis和SpringBoot的整合

从网上找了很多种方法 一直都搞不出来 最后终于成功了 所以写一下博客记录一下

下面的代码里面我只写了SelectByPrimayKey的方法 其余的方法大同小异也就没有写了

毕竟只是为了试验这两个框架的整合使用 如果需要的话可以自己动动手加上的

然后有很多代码是从别的博客里面照搬的 不过东拼西凑的也没注意原作者到底是谁 所以也没写作者的名字

如果有侵权请指正 我会马上删除或者写上出处

1.首先配置pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion>
<groupId>com.tony</groupId>
<artifactId>SecondMyBatisWithSB</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.2.3.RELEASE</version>
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<!-- commons -->
<commons-io.version></commons-io.version>
<commons-lang3.version>3.4</commons-lang3.version>
<!-- springMvc -->
<spring-jdbc.version>4.1.6.RELEASE</spring-jdbc.version>
<spring-tx.version>4.1.6.RELEASE</spring-tx.version>
<spring-web.version>4.1.6.RELEASE</spring-web.version>
<spring-webmvc>4.1.6.RELEASE</spring-webmvc>
<spring-data-japa.version>1.8.0.RELEASE</spring-data-japa.version>
<spring-test.version>4.1.6.RELEASE</spring-test.version>
<aspectjweaver.version>1.8.5</aspectjweaver.version>
<webmvc.version>2.2.2.RELEASE</webmvc.version>
<!-- myBatis -->
<mybatis.version>3.2.8</mybatis.version>
<mybatis-generator-core.version>1.3.2</mybatis-generator-core.version>
<mybatis-spring.version>1.2.2</mybatis-spring.version>
<mysql-connector-java.version>5.1.34</mysql-connector-java.version>
<!-- mybatis pagehelper -->
<pagehelper.version>3.6.3</pagehelper.version>
</properties>

<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>${commons-lang3.version}</version>
</dependency>
<!-- datasource heroku -->
<dependency>
<groupId>com.zaxxer</groupId>
<artifactId>HikariCP-java6</artifactId>
<exclusions>
<exclusion>
<artifactId>tools</artifactId>
<groupId>com.sun</groupId>
</exclusion>
</exclusions>
</dependency>
<!-- aspectJ -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
</dependency>
<!-- Spring boot -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- myBatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>${mybatis.version}</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>${mybatis-spring.version}</version>
</dependency>
<dependency>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-core</artifactId>
<version>${mybatis-generator-core.version}</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!-- mybatis pagehelper -->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>${pagehelper.version}</version>
</dependency>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-rest-webmvc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-commons</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.hateoas</groupId>
<artifactId>spring-hateoas</artifactId>
</dependency>
<!-- javax -->
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
<version>1</version>
</dependency>
<dependency>
<groupId>javax</groupId>
<artifactId>javaee-api</artifactId>
<version>7.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.glassfish.web</groupId>
<artifactId>javax.servlet.jsp.jstl</artifactId>
<version>1.2.2</version>
</dependency>
</dependencies>
<build>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-maven-plugin</artifactId>
<version>1.3.2</version>
<configuration>
<configurationFile>src/main/resources/mybatis-generator-config.xml</configurationFile>
<verbose>true</verbose>
<overwrite>true</overwrite>
</configuration>
<executions>
<execution>
<id>Generate MyBatis Artifacts</id>
<goals>
<goal>generate</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</pluginManagement>
</build>

</project>

2.配置application.yml 放置在resources文件夹下即可

# Server settings
server:
port:8080
address:localhost

# DATASOURCE
jdbc:
dataSourceClassName: com.mysql.jdbc.jdbc2.optional.MysqlDataSource
url: jdbc:mysql://localhost:3306/test?useUnicode=true&charaterEncoding=utf-8
databaseName: test
serverName: 127.0.0.1
username: root
password: root
cachePrepStmts: true
prepStmtsSize: 250
prepStmtsCacheSqlLimit: 2048
userServerPrepStmts: true

# SPRING PROFILES
spring:
# HTTP ENCODING
http:
encoding.charset: UTF-8
encoding.enable: true
encoding.force: true

# MyBatis
mybatis:
typeAliasesPackage: com.tony.entity
mapperLocations: classpath:/com/tony/mapper/*.xml
configLocation: classpath:/mybatis-config.xml

# LOGGING
logging:
level:
com.ibatis:DEBUG

3.配置mybatis-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
<properties>
<property name="dialect" value="mysql" />
</properties>
<settings>
<!-- 这个配置使全局的映射器启用或禁用缓存。系统默认值是true，设置只是为了展示出来 -->
<setting name="cacheEnabled" value="true" />
<!-- 全局启用或禁用延迟加载。当禁用时，所有关联对象都会即时加载。 系统默认值是true，设置只是为了展示出来 -->
<setting name="lazyLoadingEnabled" value="true" />
<!-- 允许或不允许多种结果集从一个单独的语句中返回（需要适合的驱动）。 系统默认值是true，设置只是为了展示出来 -->
<setting name="multipleResultSetsEnabled" value="true" />
<!--使用列标签代替列名。不同的驱动在这方便表现不同。参考驱动文档或充分测试两种方法来决定所使用的驱动。 系统默认值是true，设置只是为了展示出来 -->
<setting name="useColumnLabel" value="true" />
<!--允许 JDBC 支持生成的键。需要适合的驱动。如果设置为 true 则这个设置强制生成的键被使用，尽管一些驱动拒绝兼容但仍然有效（比如
Derby）。 系统默认值是false，设置只是为了展示出来 -->
<setting name="useGeneratedKeys" value="false" />
<!--配置默认的执行器。SIMPLE 执行器没有什么特别之处。REUSE 执行器重用预处理语句。BATCH 执行器重用语句和批量更新 系统默认值是SIMPLE，设置只是为了展示出来 -->
<setting name="defaultExecutorType" value="SIMPLE" />
<!--设置超时时间，它决定驱动等待一个数据库响应的时间。 系统默认值是null，设置只是为了展示出来 -->
<setting name="defaultStatementTimeout" value="25000" />
</settings>
<plugins>
<plugin interceptor="com.github.pagehelper.PageHelper">
<property name="dialect" value="mysql" />
<property name="offsetAsPageNum" value="true" />
<property name="rowBoundsWithCount" value="true" />
<property name="pageSizeZero" value="true" />
<property name="reasonable" value="true" />
</plugin>
</plugins>
</configuration>

4.配置mybatis-generator.properties

这个是用来配置自动生成mapper.xml\dao\entity用的配置文件

#=============================#
#======database setting=======#
#=============================#

# mysql database setting
jdbc.type=mysql
jdbc.driverClassName:com.mysql.jdbc.Driver
jdbc.url:jdbc:mysql://127.0.0.1:3306/xxx?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true
jdbc.username=root
jdbc.password=fixture

# pool settings
jdbc.pool.minIdle=8
jdbc.pool.maxActive=100

# mybatis generator setting
generator.classPath=C:/Users/TonyJiang/.m2/repository/mysql/mysql-connector-java/5.1.38/mysql-connector-java-5.1.38.jar
generator.mapperConfigFilename=mapper-config.xml
generator.targetProject=SecondMyBatisWithSB
generator.domainPackage=com.tony.entity
generator.mapperPackage=com.tony.mapper
generator.daoPackage=com.tony.dao

5.配置mybatis-generator-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd" >
<generatorConfiguration>
<!-- 引入配置文件 -->
<properties resource="mybatis-generator.properties" />
<!-- 指定数据连接驱动jar地址 -->
<classPathEntry location="${generator.classPath}" />
<!-- 一个数据库一个context -->
<context id="BuildingTables" targetRuntime="Mybatis3">
<!-- defaultModelType="hierarchical" -->
<property name="javaFileEncoding" value="UTF-8" />
<property name="suppressTypeWarnings" value="true" />

<plugin type="org.mybatis.generator.plugins.SerializablePlugin" />
<plugin type="org.mybatis.generator.plugins.CaseInsensitiveLikePlugin" />
<plugin type="org.mybatis.generator.plugins.RowBoundsPlugin" />
<plugin type="org.mybatis.generator.plugins.ToStringPlugin" />
<plugin type="org.mybatis.generator.plugins.CachePlugin" />

<plugin type="org.mybatis.generator.plugins.MapperConfigPlugin">
<property name="fileName" value="${generator.mapperConfigFilename}" />
<property name="targetPackage" value="${generator.mapperPackage}" />
<property name="targetProject"
value="${generator.targetProject}/src/main/java" />
</plugin>
<plugin type="org.mybatis.generator.plugins.RenameExampleClassPlugin">
<property name="searchString" value="Example$" />
<property name="replaceString" value="Criteria" />
</plugin>

<!-- 注释 -->
<commentGenerator>
<property name="suppressAllComments" value="true" /><!-- 是否取消注释 -->
<property name="suppressDate" value="true" /> <!-- 是否生成注释代时间戳 -->
</commentGenerator>

<!-- jdbc连接 -->
<jdbcConnection driverClass="${jdbc.driverClassName}"
connectionURL="${jdbc.url}" userId="${jdbc.username}" password="${jdbc.password}" />
<!-- 类型转换 -->
<javaTypeResolver>
<!-- 是否使用bigDecimal， false可自动转化以下类型（Long, Integer, Short, etc.） -->
<property name="forceBigDecimals" value="false" />
</javaTypeResolver>

<!-- 生成实体类地址 -->
<javaModelGenerator targetPackage="${generator.domainPackage}"
targetProject="${generator.targetProject}/src/main/java">
<!-- 是否在当前路径下新加一层schema,eg：fase路径com.oop.eksp.user.model， true:com.oop.eksp.user.model.[schemaName] -->
<property name="enableSubPackages" value="true" />
<!-- 是否针对string类型的字段在set的时候进行trim调用 -->
<property name="trimStrings" value="true" />
</javaModelGenerator>

<!-- 生成mapxml文件 -->
<sqlMapGenerator targetPackage="${generator.mapperPackage}"
targetProject="${generator.targetProject}/src/main/java">
<!-- 是否在当前路径下新加一层schema,eg：fase路径com.oop.eksp.user.model， true:com.oop.eksp.user.model.[schemaName] -->
<property name="enableSubPackages" value="true" />
</sqlMapGenerator>

<!-- 生成mapxml对应client，也就是接口dao -->
<javaClientGenerator targetPackage="${generator.daoPackage}"
targetProject="${generator.targetProject}/src/main/java" type="XMLMAPPER">
<!-- 是否在当前路径下新加一层schema,eg：fase路径com.oop.eksp.user.model， true:com.oop.eksp.user.model.[schemaName] -->
<property name="enableSubPackages" value="true" />
</javaClientGenerator>

<!-- 配置表信息 -->
<table tableName="t_user" domainObjectName="User" enableCountByExample="false" enableUpdateByExample="false"
enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false"></table>

</context>
</generatorConfiguration>

之后用mybatis-generator的插件自动生成相应的mapper dao接口 entity既可

具体方法可以先百度 相对来说比较简单的

或者也可以手写一下 毕竟刚开始学手写更能熟悉那些结构-

生成之后还是需要在修改一下的 修改的主要内容在后续代码中

6.下面开始代码部分

首先是Application.java

必须放在主包下面 这样才能成功扫描所有的包

比如我是放在com.tony下面

package com.tony;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan
@EnableAutoConfiguration
@SpringBootApplication
public class Application {
public static void main(String[] args){
SpringApplication.run(Application.class, args);
}
}

然后是controller层 先测试一下SpringBoot能不能运行

com.tony.controller

package com.tony.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.tony.service.UserService;

@Controller
@RequestMapping("/test")
public class TestAction {

@Autowired
private UserService userService;
@RequestMapping("/greeting")
@ResponseBody
public Object hello(){
return "Hello Spring";
}
@ResponseBody
@RequestMapping("/user")
public Object get(@RequestParam String id){
return userService.findOne(id);
}
}

下面是自动生成的那几个部分

- com.tony.dao

- com.tony.mapper

- com.tony.entity

不过其实我是修改过的 不是原来自动生成的那些

UserMapper.java

package com.tony.dao;

import com.tony.entity.User;
import com.tony.commons.dao.BaseDao;

public interface UserMapper extends BaseDao<User, String>{

}

User.java

package com.tony.entity;

import java.io.Serializable;

import com.tony.commons.entity.AbstractEntity;

public class User extends AbstractEntity implements Serializable {
private String id;

private String username;

private String password;

private static final long serialVersionUID = 1L;

public String getId() {
return id;
}

public void setId(String id) {
this.id = id == null ? null : id.trim();
}

public String getUsername() {
return username;
}

public void setUsername(String username) {
this.username = username == null ? null : username.trim();
}

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password == null ? null : password.trim();
}

@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(getClass().getSimpleName());
sb.append(" [");
sb.append("Hash = ").append(hashCode());
sb.append(", id=").append(id);
sb.append(", username=").append(username);
sb.append(", password=").append(password);
sb.append(", serialVersionUID=").append(serialVersionUID);
sb.append("]");
return sb.toString();
}
}

UserMapper.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.tony.dao.UserMapper" >
<resultMap id="BaseResultMap" type="com.tony.entity.User" >
<id column="id" property="id" jdbcType="VARCHAR" />
<result column="username" property="username" jdbcType="VARCHAR" />
<result column="password" property="password" jdbcType="VARCHAR" />
<result column="create_by" property="createBy" jdbcType="VARCHAR" />
<result column="create_date" property="createDate" jdbcType="DATE" />
<result column="last_modified_by" property="lastModifiedBy" jdbcType="VARCHAR" />
<result column="last_modified_date" property="lastModifiedDate" jdbcType="DATE" />
</resultMap>

<sql id="Base_Column_List" >
id, username, password, create_by, create_date, last_modified_by, last_modified_date
</sql>

<select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.String" >
select
<include refid="Base_Column_List" />
from t_user
where id = #{id,jdbcType=VARCHAR}
</select>
<delete id="deleteByPrimaryKey" parameterType="java.lang.String" >
delete from t_user
where id = #{id,jdbcType=VARCHAR}
</delete>

<insert id="insert" parameterType="com.tony.entity.User" >
insert into t_user (id, username, password,
create_by, create_date, last_modified_by,
last_modified_date)
values (#{id,jdbcType=VARCHAR}, #{username,jdbcType=VARCHAR}, #{password,jdbcType=VARCHAR},
#{createBy,jdbcType=VARCHAR}, #{createDate,jdbcType=DATE}, #{lastModifiedBy,jdbcType=VARCHAR},
#{lastModifiedDate,jdbcType=DATE})
</insert>
<insert id="insertSelective" parameterType="com.tony.entity.User" >
insert into t_user
<trim prefix="(" suffix=")" suffixOverrides="," >
<if test="id != null" >
id,
</if>
<if test="username != null" >
username,
</if>
<if test="password != null" >
password,
</if>
<if test="createBy != null" >
create_by,
</if>
<if test="createDate != null" >
create_date,
</if>
<if test="lastModifiedBy != null" >
last_modified_by,
</if>
<if test="lastModifiedDate != null" >
last_modified_date,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides="," >
<if test="id != null" >
#{id,jdbcType=VARCHAR},
</if>
<if test="username != null" >
#{username,jdbcType=VARCHAR},
</if>
<if test="password != null" >
#{password,jdbcType=VARCHAR},
</if>
<if test="createBy != null" >
#{createBy,jdbcType=VARCHAR},
</if>
<if test="createDate != null" >
#{createDate,jdbcType=DATE},
</if>
<if test="lastModifiedBy != null" >
#{lastModifiedBy,jdbcType=VARCHAR},
</if>
<if test="lastModifiedDate != null" >
#{lastModifiedDate,jdbcType=DATE},
</if>
</trim>
</insert>

<update id="updateByPrimaryKeySelective" parameterType="com.tony.entity.User" >
update t_user
<set >
<if test="username != null" >
username = #{username,jdbcType=VARCHAR},
</if>
<if test="password != null" >
password = #{password,jdbcType=VARCHAR},
</if>
<if test="createBy != null" >
create_by = #{createBy,jdbcType=VARCHAR},
</if>
<if test="createDate != null" >
create_date = #{createDate,jdbcType=DATE},
</if>
<if test="lastModifiedBy != null" >
last_modified_by = #{lastModifiedBy,jdbcType=VARCHAR},
</if>
<if test="lastModifiedDate != null" >
last_modified_date = #{lastModifiedDate,jdbcType=DATE},
</if>
</set>
where id = #{id,jdbcType=VARCHAR}
</update>
<update id="updateByPrimaryKey" parameterType="com.tony.entity.User" >
update t_user
set username = #{username,jdbcType=VARCHAR},
password = #{password,jdbcType=VARCHAR},
create_by = #{createBy,jdbcType=VARCHAR},
create_date = #{createDate,jdbcType=DATE},
last_modified_by = #{lastModifiedBy,jdbcType=VARCHAR},
last_modified_date = #{lastModifiedDate,jdbcType=DATE}
where id = #{id,jdbcType=VARCHAR}
</update>

<cache />
</mapper>

接下来是一些需要自己写的

com.tony.commons.dao

BaseDao.java

package com.tony.commons.dao;

import java.io.Serializable;

public interface BaseDao<T extends Serializable , ID extends Serializable> {
int deleteByPrimaryKey(ID id);

int insert(T record);

int insertSelective(T record);

T selectByPrimaryKey(ID id);

int updateByPrimaryKeySelective(T record);

int updateByPrimaryKey(T record);
}

com.tony.commons.entity

AbstractEntity.java

package com.tony.commons.entity;

import java.io.Serializable;
import java.util.Date;

import javax.persistence.MappedSuperclass;
import javax.validation.constraints.NotNull;

import org.springframework.data.annotation.CreatedBy;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedBy;
import org.springframework.data.annotation.LastModifiedDate;

@MappedSuperclass
public abstract class AbstractEntity implements  Serializable {

private static final long serialVersionUID = 1L;

private String id;

public String getId() {
return id;
}

public void setId(String id) {
this.id = id;
}

@CreatedBy
@NotNull
private String createBy;

@CreatedDate
@NotNull
private Date createDate = new Date();

@LastModifiedBy
private String lastModifiedBy;

@LastModifiedDate
private Date lastModifiedDate = new Date();

public String getCreateBy() {
return createBy;
}

public void setCreateBy(String createBy) {
this.createBy = createBy;
}

public Date getCreateDate() {
return createDate;
}

public void setCreateDate(Date createDate) {
this.createDate = createDate;
}

public String getLastModifiedBy() {
return lastModifiedBy;
}

public void setLastModifiedBy(String lastModifiedBy) {
this.lastModifiedBy = lastModifiedBy;
}

public Date getLastModifiedDate() {
return lastModifiedDate;
}

public void setLastModifiedDate(Date lastModifiedDate) {
this.lastModifiedDate = lastModifiedDate;
}
}

com.tony.commons.service

BaseService.java

package com.tony.commons.service;

import java.io.Serializable;

public interface BaseService<T extends Serializable> {

T findOne(String id);

}

com.tony.commons.service.impl

BaseServiceImpl.java

package com.tony.commons.service.impl;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;

import com.tony.commons.dao.BaseDao;
import com.tony.commons.entity.AbstractEntity;
import com.tony.commons.service.BaseService;

@Transactional
public abstract class BaseServiceImpl<T extends AbstractEntity>
implements BaseService<T> {

protected abstract BaseDao<T,  String> getDao();

protected Class<T> entityClazz;

@SuppressWarnings("unchecked")
public BaseServiceImpl() {
Type genType = getClass().getGenericSuperclass();
Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
entityClazz = (Class<T>) params[0];
}

@Transactional(readOnly = true)
public T findOne(String id) {
Assert.notNull(id);
return getDao().selectByPrimaryKey(id);
}

}

com.tony.service

UserService.java

package com.tony.service;

import com.tony.entity.User;
import com.tony.commons.service.BaseService;

public interface UserService extends BaseService<User> {
User findOneById(String Id);
}

com.tony.service.impl

UserServiceImpl.java

package com.tony.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.tony.dao.UserMapper;
import com.tony.entity.User;
import com.tony.service.UserService;
import com.tony.commons.dao.BaseDao;
import com.tony.commons.service.impl.BaseServiceImpl;

@Service
@Transactional
public class UserServiceImpl extends BaseServiceImpl<User>
implements UserService {

@Autowired
private UserMapper userDao;

public User findOneById(String Id) {
return getDao().selectByPrimaryKey(Id);
}

@Override
protected BaseDao<User, String> getDao() {
return userDao;
}
}

下面两个是Mybatis的配置类

com.tony.config.mybatis

DataBaseConfiguration.java

package com.tony.config.mybatis;

import java.util.Arrays;
import javax.sql.DataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.bind.RelaxedPropertyResolver;
import org.springframework.context.ApplicationContextException;
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.transaction.annotation.EnableTransactionManagement;

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

@Configuration
@EnableTransactionManagement
public class DataBaseConfiguration implements EnvironmentAware {

private RelaxedPropertyResolver propertyResolver;

private static Logger log = LoggerFactory
.getLogger(DataBaseConfiguration.class);

private Environment env;

public void setEnvironment(Environment env) {
this.env = env;
this.propertyResolver = new RelaxedPropertyResolver(env, "jdbc.");
}

@Bean(destroyMethod = "shutdown")
public DataSource dataSource() {
log.debug("Configruing DataSource");
if (propertyResolver.getProperty("url") == null
&& propertyResolver.getProperty("databaseName") == null) {
log.error("Your database conncetion pool configuration is incorrct ! The application "
+ "cannot start . Please check your jdbc");
Arrays.toString(env.getActiveProfiles());
throw new ApplicationContextException(
"DataBase connection pool is not configured correctly");
}
HikariConfig config = new HikariConfig();
config.setDataSourceClassName(propertyResolver
.getProperty("dataSourceClassName"));
if (propertyResolver.getProperty("url") == null
|| "".equals(propertyResolver.getProperty("url"))) {
config.addDataSourceProperty("databaseName",
propertyResolver.getProperty("databaseName"));
config.addDataSourceProperty("serverName",
propertyResolver.getProperty("serverName"));
} else {
config.addDataSourceProperty("url",
propertyResolver.getProperty("url"));
}
config.setUsername(propertyResolver.getProperty("username"));
config.setPassword(propertyResolver.getProperty("password"));
if ("com.mysql.jdbc.jdbc2.optional.MysqlDataSource"
.equals(propertyResolver.getProperty("dataSourceName"))) {
config.addDataSourceProperty("cachePrepStmts",
propertyResolver.getProperty("cachePrepStmts"));
config.addDataSourceProperty("prepStmtCacheSize",
propertyResolver.getProperty("prepStmtsCacheSize"));
config.addDataSourceProperty("prepStmtCacheSqlLimit",
propertyResolver.getProperty("prepStmtCacheSqlLimit"));
config.addDataSourceProperty("userServerPrepStmts",
propertyResolver.getProperty("userServerPrepStmts"));
}
return new HikariDataSource(config);
}

}

MybatisConfiguration.java

package com.tony.config.mybatis;

import javax.inject.Inject;
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.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;

@Configuration
@ConditionalOnClass({ EnableTransactionManagement.class, EntityManager.class })
@AutoConfigureAfter({ DataBaseConfiguration.class })
@MapperScan(basePackages={"com.tony.dao"})
public class MybatisConfiguration implements EnvironmentAware {

private static Log logger = LogFactory.getLog(MybatisConfiguration.class);

private RelaxedPropertyResolver propertyResolver;

@Inject
private DataSource dataSource;

public void setEnvironment(Environment environment) {
this.propertyResolver = new RelaxedPropertyResolver(environment,
"mybatis.");
}

@Bean
@ConditionalOnMissingBean
public SqlSessionFactory sqlSessionFactory() {
try {
SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
sessionFactory.setDataSource(dataSource);
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
@ConditionalOnMissingBean
public DataSourceTransactionManager transactionManager() {
return new DataSourceTransactionManager(dataSource);
}
}

好了 大功告成 运行一下应该就可以了