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=root
# 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);
}
}
