原创

Spring Boot （二）集成Mybatis、Druid

项目GitHub地址：

https://github.com/FrameReserve/TrainingBoot

Spring Boot （二）集成Mybatis、Druid，标记地址：

https://github.com/FrameReserve/TrainingBoot/releases/tag/0.0.2

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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.training</groupId>
	<artifactId>TrainingBoot</artifactId>
	<version>1.0.0</version>
	<packaging>war</packaging>

	<name>TrainingBoot</name>
	<description>The first Spring Boot project</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.4.1.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
		<!--  依赖版本  -->
		<mybatis.version>3.4.1</mybatis.version>
		<mybatis.spring.version>1.3.0</mybatis.spring.version>
	</properties>
	
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
		
		<resources>  
    
	    	<resource>
		  		<directory>src/main/java</directory>
		  		<includes>
		  			<include>**/*.properties</include>
		  			<include>**/*.xml</include>
		  		</includes>
		  		<!-- 是否替换资源中的属性-->
		  		<filtering>false</filtering>
	  		</resource>
	  		
	  		<resource>
	  			<directory>src/main/resources</directory>
	  			
	            <!-- 是否替换资源中的属性-->
	            <filtering>true</filtering>          
	        </resource>
	  		
	    </resources>
    
	</build>
	
	

	<dependencies>
	
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		
		<dependency>  
	        <groupId>org.springframework.boot</groupId>  
	        <artifactId>spring-boot-starter-tomcat</artifactId>  
	        <scope>provided</scope>  
	    </dependency>
	    
	    <dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
		</dependency>
	    
	    <dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-aop</artifactId>
		</dependency>
		
	    <!-- mysql -->
	    <dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>

		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.0.25</version>
		</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>

		<!--通用MAPPER-->
		<dependency>
			<groupId>tk.mybatis</groupId>
			<artifactId>mapper</artifactId>
			<version>3.3.7</version>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper -->
		<dependency>
			<groupId>com.github.pagehelper</groupId>
			<artifactId>pagehelper</artifactId>
			<version>4.1.6</version>
		</dependency>
		
		<!-- swagger -->
		<dependency>
			<groupId>io.springfox</groupId>
			<artifactId>springfox-swagger2</artifactId>
			<version>2.2.2</version>
		</dependency>
		
		<dependency>
			<groupId>io.springfox</groupId>
			<artifactId>springfox-swagger-ui</artifactId>
			<version>2.2.2</version>
		</dependency>
		
		<!-- Apache Commons Lang -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.4</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/commons-lang/commons-lang -->
		<dependency>
			<groupId>commons-lang</groupId>
			<artifactId>commons-lang</artifactId>
			<version>2.6</version>
		</dependency>
		
		<!-- Gson -->
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.2.2</version>
        </dependency>
        
        <!-- utils -->
        <dependency>
            <groupId>org.unitils</groupId>
            <artifactId>unitils-core</artifactId>
            <version>3.4.2</version>
        </dependency>
		
	</dependencies>

</project>

src/main/resources/application.yml

spring:
    datasource:
        name: dataSource 
        url: jdbc:mysql://192.168.2.63:3306/training 
        username: root 
        password: 123 
        # 使用druid数据源 
        type: com.alibaba.druid.pool.DruidDataSource 
        driver-class-name: com.mysql.jdbc.Driver 
#        filters: stat
#        maxActive: 20
#        initialSize: 1
#        maxWait: 60000
#        minIdle: 1
#        timeBetweenEvictionRunsMillis: 60000
#        minEvictableIdleTimeMillis: 300000
#        validationQuery: select 'x'
#        testWhileIdle: true
#        testOnBorrow: false
#        testOnReturn: false
#        poolPreparedStatements: true
#        maxOpenPreparedStatements: 20

MyBatis配置类：

src/main/java/com/training/core/mybatis/MyBatisConfig.java

package com.training.core.mybatis;

import com.github.pagehelper.PageHelper;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.annotation.TransactionManagementConfigurer;

import javax.sql.DataSource;
import java.util.Properties;

/**
 * Created by Athos on 2016-10-13.
 */
@Configuration
@EnableTransactionManagement
public class MyBatisConfig implements TransactionManagementConfigurer {

    @Autowired
    private DataSource dataSource;

    @Bean(name = "sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactoryBean() {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        bean.setTypeAliasesPackage("com.training");

        //分页插件
        PageHelper pageHelper = new PageHelper();
        Properties properties = new Properties();
        properties.setProperty("reasonable", "true");
        properties.setProperty("supportMethodsArguments", "true");
        properties.setProperty("returnPageInfo", "check");
        properties.setProperty("params", "count=countSql");
        pageHelper.setProperties(properties);

        //添加插件
        bean.setPlugins(new Interceptor[]{pageHelper});

        //添加XML目录
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        try {
            bean.setMapperLocations(resolver.getResources("classpath:**/mapper/*.xml"));
            return bean.getObject();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    @Bean
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

    @Bean
    @Override
    public PlatformTransactionManager annotationDrivenTransactionManager() {
        return new DataSourceTransactionManager(dataSource);
    }
}

src/main/java/com/training/core/mybatis/MyBatisMapperScannerConfig.java

package com.training.core.mybatis;

import java.util.Properties;

import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import tk.mybatis.mapper.common.Mapper;
import tk.mybatis.spring.mapper.MapperScannerConfigurer;


/**
 * Created by Athos on 2016-10-06.
 */
@Configuration
//TODO 注意，由于MapperScannerConfigurer执行的比较早，所以必须有下面的注解
@AutoConfigureAfter(MyBatisConfig.class)
public class MyBatisMapperScannerConfig {
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer() {
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactory");
        //这里的BasePackage 不能写com.training,估计跟spring 的扫描冲突,会实例化两个service,应该需要重构目录
        mapperScannerConfigurer.setBasePackage("com.training.*.mapper");
        Properties properties = new Properties();
        properties.setProperty("mappers", Mapper.class.getName());
        properties.setProperty("notEmpty", "false");
        properties.setProperty("IDENTITY", "MYSQL");
        mapperScannerConfigurer.setProperties(properties);
        return mapperScannerConfigurer;
    }
}

//--------------------------------------------- 业务代码 -------------------------------------------------------------------------------------

定义BaseEntity，方便后期反射，统一增删改查

package com.training.core.entity;

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

import com.fasterxml.jackson.annotation.JsonProperty;
import tk.mybatis.mapper.annotation.NameStyle;
import tk.mybatis.mapper.code.Style;

import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@NameStyle(value = Style.camelhumpAndLowercase)
public class BaseEntity implements Serializable {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
    @JsonProperty("id")
    private Integer id;

	/**
	 * 创建时间
	 */
	@Column
	private Date createTime;
	
	/**
	 * 最后修改时间
	 */
	@Column
	private Date lastModifyTime;
	public Integer getId() {
		return id;
	}

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

	public Date getCreateTime() {
		return createTime;
	}

	public void setCreateTime(Date createTime) {
		this.createTime = createTime;
	}

	public Date getLastModifyTime() {
		return lastModifyTime;
	}

	public void setLastModifyTime(Date lastModifyTime) {
		this.lastModifyTime = lastModifyTime;
	}
}

BaseDao统一增删改查接口：

src/main/java/com/training/core/dao/BaseDao.java

package com.training.core.dao;

import java.util.List;

import tk.mybatis.mapper.entity.Example;

import com.training.core.dto.FlexiPageDto;
import com.training.core.entity.BaseEntity;

public interface BaseDao<T extends BaseEntity> {

	/**
	 * 根据Id查询实体
	 */
	public T getEntityById(final Class<T> cls, final Integer id);
	
	/**
	 * 新增实体
	 */
	public void addEntity(final T entity);
	
	/**
	 * 更新实体
	 */
	public void updateEntity(final T entity);
	
	/**
	 * 根据Id删除实体
	 */
	public void deleteEntityById(final Class<T> cls, final Integer id);

	/**
	 * 查询全部
     */
	public List<T> selectAll(Class<T> cls);
	
	/**
	 * 单表模糊查询
	 */
	public List<T> findByLike(Example example);
	
	/**
	 * 根据模糊分页查询
	 */
	public List<T> findByPage(Example example, FlexiPageDto flexiPageDto);
	
	/**
	 * 单表模糊查询总记录数
	 */
	public int findRowCount(Example example);
	
	
}

BaseDao统一增删改查实现：

src/main/java/com/training/core/dao/impl/MyBatisBaseDaoImpl.java

package com.training.core.dao.impl;

import java.util.List;

import javax.annotation.Resource;

import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Repository;

import tk.mybatis.mapper.common.Mapper;
import tk.mybatis.mapper.entity.Example;

import com.training.core.annotation.MapperClass;
import com.training.core.dao.BaseDao;
import com.training.core.dto.FlexiPageDto;
import com.training.core.entity.BaseEntity;

@Repository("myBatisBaseDao")
@SuppressWarnings("unchecked")
public class MyBatisBaseDaoImpl<T extends BaseEntity> implements BaseDao<T> {
    
    @Resource
    @Qualifier("sessionFactory")
    private SqlSessionFactory sqlSessionFactory;
    
    private SqlSession sqlSession;
    
    @SuppressWarnings("rawtypes")
    public <M extends Mapper<T>> M getMapper(Class cls){
        MapperClass mapperClass = (MapperClass) cls.getAnnotation(MapperClass.class);
        if(null == mapperClass){
            throw new RuntimeException("没有注解MapperClass");
        }
             return (M) getSqlSession().getMapper(mapperClass.value());
    }

    @Override
    public T getEntityById(Class<T> cls, Integer id) {
        return this.getMapper(cls).selectByPrimaryKey(id);
    }

    @Override
    public void addEntity(T entity) {
        this.getMapper(entity.getClass()).insert(entity);
    }

    @Override
    public void updateEntity(T entity) {
        this.getMapper(entity.getClass()).updateByPrimaryKey(entity);
    }

    @Override
    public void deleteEntityById(Class<T> cls, Integer id) {
        this.getMapper(cls).deleteByPrimaryKey(id);
    }

    @Override
    public List<T> selectAll(Class<T> cls) {
        return this.getMapper(cls).selectAll();
    }

    @Override
    public List<T> findByLike(Example example) {
        return this.getMapper(example.getEntityClass()).selectByExample(example);
    }

    @Override
    public List<T> findByPage(Example example, FlexiPageDto flexiPageDto) {
        
        RowBounds rowBounds = new RowBounds(flexiPageDto.getOffset(), flexiPageDto.getRp());
        return this.getMapper(example.getEntityClass()).selectByExampleAndRowBounds(example, rowBounds);
    }

    @Override
    public int findRowCount(Example example) {
        return this.getMapper(example.getEntityClass()).selectCountByExample(example);
    }
    
    public SqlSession getSqlSession(){
        if (null == sqlSession){
            synchronized (MyBatisBaseDaoImpl.class) {
                this.sqlSession = new SqlSessionTemplate(sqlSessionFactory);
            }
        }
        return this.sqlSession;
    }
    
}

工具类、辅助类：

1. 自定义注解，指定Mapper Class。方便后期实现统一增删改查。

src/main/java/com/training/core/annotation/MapperClass.java

package com.training.core.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Created by Athos on 2016-07-04.
 */
@SuppressWarnings("unchecked")
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MapperClass{
	/**
	 *指定 MapperClass
	 */
    Class value();
}

2. 分页工具类

src/main/java/com/training/core/dto/FlexiPageDto.java

package com.training.core.dto;


public class FlexiPageDto {

	public static final Integer MAX_PAGE_SIZE=3000;
	public static final Integer SHORT_PAGE_SIZE=5;
	
	public FlexiPageDto() {
		super();
	}

	public FlexiPageDto(Integer page, Integer rp) {
		super();
		this.page = page;
		this.rp = rp;
	}

	public FlexiPageDto(Integer page, Integer rp, String sortName) {
		super();
		this.page = page;
		this.rp = rp;
		this.sortName = sortName;
	}

	public FlexiPageDto(Integer page, Integer rp, String sortName, String sortOrder) {
		super();
		this.page = page;
		this.rp = rp;
		this.sortName = sortName;
		this.sortOrder = sortOrder;
	}
	
	public static FlexiPageDto createMaxPageDto(){
		FlexiPageDto flexiPageDto=new FlexiPageDto();
		flexiPageDto.setRp(MAX_PAGE_SIZE).setPage(1);
		return flexiPageDto;
	}
	public static FlexiPageDto generateFlexiPageDto(Integer page, Integer rp, String orderBy) {
		FlexiPageDto flexiPageDto = new FlexiPageDto(page, rp);
		if (null != orderBy && "" != orderBy.trim()) {
			String[] orderBys = orderBy.split("_");
			flexiPageDto.setSortName(orderBys[0]);
			flexiPageDto.setSortOrder(orderBys[1]);
		}
		return flexiPageDto;
	}

	/**
	 * 当前页
	 */
	private Integer page;
	
	/**
	 * 每页显示，默认:10
	 */
	private Integer rp = 10;
	
	/**
	 * 总记录数
	 */
	private Integer rowCount;
	
	/**
	 * 排序字段
	 */
	private String sortName;
	
	/**
	 * 排序(asc/desc)
	 */
	private String sortOrder = "desc";
	
	public static final String SORTORDER_ACS = "asc";
	
	/**
	 * 数据开始坐标，Mysql从0开始
	 */
	public Integer getOffset(){
		return (this.getPage()-1)*this.getRp();
	}
	
	/**
	 * 总页数
	 */
	public Integer getTotalPage() {
		if (null == rowCount) {
			return 0;
		}
		int totalPage = (rowCount / rp);
		int remainder = rowCount % rp;
		if (rowCount > 0 && totalPage == 0) {
			totalPage = 1;
			return totalPage;
		}
		if (remainder > 0) {
			totalPage++;
			return totalPage;
		}
		return totalPage;		
	}

	// -------------------------- getter and setter -----------------------------
	public Integer getRp() {
		return rp;
	}

	public FlexiPageDto setRp(Integer rp) {
		this.rp = rp;
		return this;
	}

	public Integer getPage() {
		return page;
	}

	public FlexiPageDto setPage(Integer page) {
		this.page = page;
		return this;
	}

	public String getSortName() {
		return sortName;
	}

	public FlexiPageDto setSortName(String sortName) {
		this.sortName = sortName;
		return this;
	}

	public String getSortOrder() {
		return sortOrder;
	}

	public FlexiPageDto setSortOrder(String sortOrder) {
		this.sortOrder = sortOrder;
		return this;
	}

	public Integer getRowCount() {
		return rowCount;
	}

	public FlexiPageDto setRowCount(Integer rowCount) {
		
		this.rowCount = rowCount;
		return this;
	}
	
	public String getSortString(){
		
		if (null == sortName) {
			return null;
		}
		String[] fields = this.getSortName().split("_");
		String[] fieldsorts = this.getSortOrder().split("_");
		if(fields.length!=fieldsorts.length){
			throw new RuntimeException("排序规则不一致");
		}
		
		String sql = "";
		for(int index=0;index<fields.length;index++){
			sql = sql+" "+fields[index]+" "+fieldsorts[index];
		}
		
		return sql;
	}

}