wx1569567608
- 浏览: 71223 次
-
文章分类
最新评论
21.1.从零开始学springboot-搭建一个可以上线的项目结构-多模块篇
前言
通过前面的多章学习，相信大家对于springboot整合各个基础依赖已经得心应手了。并且，对于各个依赖的选择和使用都有了一定的理解。本章，将对前段时间的所学做一个总结，会完成一个可以上生产的项目基础架构。 首先，我们来归纳一下一般项目的需求：
- 多数据源
- 分布式事务
- 数据持久层
- 缓存
- 日志记录
- druid数据源监控
- api文档
以上需求基本囊括了所有项目的基础。那么我们，根据需求，对应我们的前几章所学，不难得出springboot+mybatis+多数据源+druid+atomikos+redis+log+swagger2 的搭配，另外，项目多环境的情况，还必须提供切换环境的配置。为了解决mybatis写entity个mapper.xml文件麻烦的问题，我们需要引入自动生成插件mybatis-generator。
再者，这边我们考虑到项目的解耦，还会在将整个项目拆分成多个独立的模块，这在实际开发过程中也是很重要的一部分。
项目结构定义
如图，我们把一个项目拆成了共4个模块
mr-entity 存放实体类（mapper类，mapper.xml文件） mr-service 存放业务逻辑类 mr-utils 存放工具类，如redis等等工具 web-service 真正的web服务应用，依赖于以上三个模块。
关于项目拆分成多个模块的好处如下：
- 模块与模块松耦合，通过依赖来调用
- 重复的代码可以单独抽成一个模块共用
- 打包时可以分模块打包，做个java开发的都知道，项目会越来越大，后续整个项目打包编译时间会很长，所以多模块很有必要
- 不同的模块可以分配给不同的人开发维护，彼此不会冲突
创建父项目
注意，使用IDEA创建父项目时选择的是
创建父项目完成后，我们将项目下的src目录删掉，只保留pom.xml文件即可。
创建子项目
右键父项目
同样的操作依次创建
mr-entity
mr-service
mr-utils
web-service
这几个子模块，同时注意，除了web-service这个模块，将其它子模块的无关文件意义删除，精简项目结构。
删除后结构如下
mr-entity
删除
.mvn
src/test
.gitignore
HELP.md
mvnw
mvnw.cmd
删除java文件夹下的xxxxxxApplication入口文件（因为entity模块只是个公共类模块，无需运行）
mr-service 删除
.mvn
src/test
.gitignore
HELP.md
mvnw
mvnw.cmd
删除java文件夹下的xxxxxxApplication入口文件
mr-utils 删除
.mvn
src/test
.gitignore
HELP.md
mvnw
mvnw.cmd
删除java文件夹下的xxxxxxApplication入口文件
最后，强调下，web-service作为一个服务，不用做任何处理，不需要删除文件！
至此，精简后的多模块项目已经创建完毕，下面我们来通过pom文件来建立父子关系。
多模块父子关系建立
我们在父pom.xml添加：
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.4.RELEASE</version>
</parent>
<!-- 申明有哪些子模块 -->
<packaging>pom</packaging>
<modules>
<module>mr-entity</module>
<module>mr-service</module>
<module>mr-utils</module>
<module>web-service</module>
</modules>
然后我们在各个子模块的pom.xml文件依次添加父依赖
<!-- 申明父模块 -->
<parent>
<groupId>com.mrcoder</groupId>
<artifactId>mrcoder-service</artifactId>
<version>1.0.0</version>
<relativePath>../pom.xml</relativePath>
</parent>
同时，除了web-service这个子模块，删除其它子模块的 <dependencies>和 <build>标签。
添加依赖和子模块之间的依赖关系
好了，通过以上的操作，父子模块关系很清晰了，但是子模块与子模块之间的依赖关系还没有建立（意思就是，mr-entity作为实体类模块，肯定会被mr-service模块使用，那么如何在mr-service模块内使用mr-entity的实体类呢？） 接下来 ，我们来修改pom.xml文件建立这种依赖关系
mr-entity模块不依赖任务子模块，所以无需任务改动，关于注释的build信息，大家先不用管。 mr-entity/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.mrcoder</groupId>
<artifactId>mr-entity</artifactId>
<version>0.0.1</version>
<name>mr-entity</name>
<description>mr-entity</description>
<parent>
<groupId>com.mrcoder</groupId>
<artifactId>mrcoder-service</artifactId>
<version>1.0.0</version>
<relativePath>../pom.xml</relativePath>
</parent>
<!--<build>-->
<!--<plugins>-->
<!--<plugin>-->
<!--<groupId>org.springframework.boot</groupId>-->
<!--<artifactId>spring-boot-maven-plugin</artifactId>-->
<!--</plugin>-->
<!--<!– mybatis generator 自动生成代码插件 –>-->
<!--<plugin>-->
<!--<groupId>org.mybatis.generator</groupId>-->
<!--<artifactId>mybatis-generator-maven-plugin</artifactId>-->
<!--<version>${mybatis-generator.version}</version>-->
<!--<configuration>-->
<!--<!– 对应generator配置文件的路径 –>-->
<!--<configurationFile>src/main/resources/generator/masterGenerator.xml</configurationFile>-->
<!--<!–<configurationFile>src/main/resources/generator/slaveGenerator.xml</configurationFile>–>-->
<!--<overwrite>true</overwrite>-->
<!--<verbose>true</verbose>-->
<!--</configuration>-->
<!--</plugin>-->
<!--</plugins>-->
<!--</build>-->
</project>
mr-service模块依赖mr-utils和mr-entity mr-service/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.mrcoder</groupId>
<artifactId>mr-service</artifactId>
<version>0.0.1</version>
<name>mr-service</name>
<description>mr-service</description>
<parent>
<groupId>com.mrcoder</groupId>
<artifactId>mrcoder-service</artifactId>
<version>1.0.0</version>
<relativePath>../pom.xml</relativePath>
</parent>
<dependencies>
<dependency>
<groupId>com.mrcoder</groupId>
<artifactId>mr-entity</artifactId>
<version>0.0.1</version>
</dependency>
<dependency>
<groupId>com.mrcoder</groupId>
<artifactId>mr-utils</artifactId>
<version>0.0.1</version>
</dependency>
</dependencies>
</project>
mr-utils不依赖任何子模块 mr-utils/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.mrcoder</groupId>
<artifactId>mr-utils</artifactId>
<version>0.0.1</version>
<name>mr-utils</name>
<description>mr-utils</description>
<parent>
<groupId>com.mrcoder</groupId>
<artifactId>mrcoder-service</artifactId>
<version>1.0.0</version>
<relativePath>../pom.xml</relativePath>
</parent>
</project>
最后我们看真正的对外服务模块web-service（大家实际开发时最好在模块的命名上和其它子模块区分开，比如作者就喜欢加个-service后缀来代表它是真正的对外服务模块） web-service依赖其它的所有子模块，其它子模块其实就是web-service拆分出去的~ web-service/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.mrcoder</groupId>
<artifactId>web-service</artifactId>
<version>0.0.1</version>
<name>web-service</name>
<description>web-service</description>
<parent>
<groupId>com.mrcoder</groupId>
<artifactId>mrcoder-service</artifactId>
<version>1.0.0</version>
<relativePath>../pom.xml</relativePath>
</parent>
<dependencies>
<dependency>
<groupId>com.mrcoder</groupId>
<artifactId>mr-entity</artifactId>
<version>0.0.1</version>
</dependency>
<dependency>
<groupId>com.mrcoder</groupId>
<artifactId>mr-utils</artifactId>
<version>0.0.1</version>
</dependency>
<dependency>
<groupId>com.mrcoder</groupId>
<artifactId>mr-service</artifactId>
<version>0.0.1</version>
</dependency>
</dependencies>
<!-- 需要打包的模块才带build信息，不需要的请打包时注释 -->
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<!-- 主程序需要知道main class -->
<mainClass>com.mrcoder.webservice.WebServiceApplication</mainClass>
<layout>ZIP</layout>
</configuration>
<executions>
<execution>
<goals>
<goal>repackage</goal><!--可以把依赖的包都打包到生成的Jar包中-->
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
关于build块，大家先不用管，这是关于打包代码，后续作者会讲。
至此模块间的依赖关系已建立完成
添加依赖
我们将使用到的所有依赖加入到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.mrcoder</groupId>
<artifactId>mrcoder-service</artifactId>
<version>1.0.0</version>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.4.RELEASE</version>
</parent>
<!-- 申明有哪些子模块 -->
<packaging>pom</packaging>
<modules>
<module>mr-entity</module>
<module>mr-service</module>
<module>mr-utils</module>
<module>web-service</module>
</modules>
<properties>
<java.version>1.8</java.version>
<sb.version>2.1.4.RELEASE</sb.version>
<mybatis.version>2.0.0</mybatis.version>
<druid.version>1.1.16</druid.version>
<mysql.version>8.0.11</mysql.version>
<redis.version>1.4.7.RELEASE</redis.version>
<fastjson.version>1.2.57</fastjson.version>
<mybatis-generator.version>1.3.2</mybatis-generator.version>
<swagger.version>2.6.1</swagger.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>${sb.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<version>${sb.version}</version>
<scope>test</scope>
</dependency>
<!-- 引入依赖 start -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>${sb.version}</version>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>${mybatis.version}</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>${druid.version}</version>
</dependency>
<!-- 添加对jta事务支持的依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jta-atomikos</artifactId>
<version>${sb.version}</version>
</dependency>
<!-- mysql 8.0+ 对druid 1.1.10 xa事务支持有问题,so 两个都用release版解决问题 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<!-- 添加对aop支持的依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
<version>${sb.version}</version>
</dependency>
<!-- 添加对redis支持的依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<version>${redis.version}</version>
</dependency>
<!-- json支持 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>${fastjson.version}</version>
</dependency>
<!-- 引入 swagger等相关依赖 -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>${swagger.version}</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>${swagger.version}</version>
</dependency>
<!-- 引入依赖 end -->
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<!--默认关掉单元测试 -->
<testFailureIgnore>true</testFailureIgnore>
</configuration>
</plugin>
</plugins>
</build>
</project>
关于依赖有和作用已在代码中注释，另外，仔细的同学肯定发现了，作者将版本号单独使用了<properties>标签包住了，这也是常用的方式，目的是为了方便的管理依赖版本，统一管理。
接下来，我们来完善各个子模块的代码。
mr-entity
结构如下
手动建立各个package和类文件
entity/master/Student
package com.mrcoder.mrentity.entity.master;
import java.io.Serializable;
public class Student implements Serializable {
private Long id;
private String name;
private int age;
private int grade;
public Student() {
}
public Student(String name, int age, int grade) {
this.name = name;
this.age = age;
this.grade = grade;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", grade=" + grade +
'}';
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getGrade() {
return grade;
}
public void setGrade(int grade) {
this.grade = grade;
}
}
entity/slave/Teacher
package com.mrcoder.mrentity.entity.slave;
import java.io.Serializable;
public class Teacher implements Serializable {
private Long id;
private String name;
private int age;
private int course;
public Teacher() {
}
public Teacher(String name, int age, int course) {
this.name = name;
this.age = age;
this.course = course;
}
@Override
public String toString() {
return "Teacher{" +
"id=" + id +
", name='" + name + '\'' +
", age='" + age + '\'' +
", course='" + course + '\'' +
'}';
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getCourse() {
return course;
}
public void setCourse(int course) {
this.course = course;
}
}
mapper/master/StudentMapper
package com.mrcoder.mrentity.mapper.master;
import com.mrcoder.mrentity.entity.master.Student;
import org.apache.ibatis.annotations.Select;
import java.util.List;
public interface StudentMapper {
// @Select("SELECT * FROM student")
List<Student> getList();
// @Select("SELECT * FROM student WHERE id = #{id}")
Student getById(Long id);
// @Insert("INSERT INTO student(age,grade,name) VALUES(#{age}, #{grade}, #{name})")
Integer insert(Student student);
// @Update("UPDATE student SET name=#{name},age=#{age}, grade=#{grade} WHERE id =#{id}")
Integer update(Student student);
// @Delete("DELETE FROM student WHERE id =#{id}")
Integer delete(Long id);
//注解方式，本项目不建议使用
@Select("SELECT * FROM student")
List<Student> getListByAnno();
}
mapper/slave/TeacherMapper
package com.mrcoder.mrentity.mapper.slave;
import com.mrcoder.mrentity.entity.slave.Teacher;
import java.util.List;
public interface TeacherMapper {
// @Select("SELECT * FROM teacher")
List<Teacher> getList();
// @Select("SELECT * FROM teacher WHERE id = #{id}")
Teacher getById(Long id);
// @Insert("INSERT INTO teacher(age,course,name) VALUES(#{age}, #{course}, #{name})")
void insert(Teacher teacher);
// @Update("UPDATE teacher SET name=#{name},age=#{age}, course=#{course} WHERE id =#{id}")
void update(Teacher teacher);
// @Delete("DELETE FROM teacher WHERE id =#{id}")
void delete(Long id);
}
resources/mapper/master/StudentMapper.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.mrcoder.mrentity.mapper.master.StudentMapper">
<resultMap id="BaseResultMap" type="com.mrcoder.mrentity.entity.master.Student">
<id column="id" property="id" jdbcType="INTEGER"/>
<result column="name" property="name" jdbcType="VARCHAR"/>
<result column="age" property="age" jdbcType="INTEGER"/>
<result column="grade" property="grade" javaType="INTEGER"/>
</resultMap>
<sql id="Base_Column_List">
id, name, age, grade
</sql>
<select id="getList" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List"/>
FROM student
</select>
<select id="getById" parameterType="java.lang.Long" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List"/>
FROM student
WHERE id = #{id}
</select>
<insert id="insert" parameterType="com.mrcoder.mrentity.entity.master.Student">
INSERT INTO
student
(age,grade,name)
VALUES
(#{age}, #{grade}, #{name})
</insert>
<update id="update" parameterType="com.mrcoder.mrentity.entity.master.Student">
UPDATE
student
SET
age = #{age},
grade = #{grade},
name = #{name}
WHERE
id = #{id}
</update>
<delete id="delete" parameterType="java.lang.Long">
DELETE FROM
student
WHERE
id =#{id}
</delete>
</mapper>
resources/mapper/master/TeacherMapper.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.mrcoder.mrentity.mapper.slave.TeacherMapper">
<resultMap id="BaseResultMap" type="com.mrcoder.mrentity.entity.slave.Teacher">
<id column="id" property="id" jdbcType="INTEGER"/>
<result column="name" property="name" jdbcType="VARCHAR"/>
<result column="age" property="age" jdbcType="INTEGER"/>
<result column="course" property="course" javaType="INTEGER"/>
</resultMap>
<sql id="Base_Column_List">
id, name, age, course
</sql>
<select id="getList" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List"/>
FROM teacher
</select>
<select id="getById" parameterType="java.lang.Long" resultMap="BaseResultMap">
SELECT
<include refid="Base_Column_List"/>
FROM teacher
WHERE id = #{id}
</select>
<insert id="insert" parameterType="com.mrcoder.mrentity.entity.slave.Teacher">
INSERT INTO
teacher
(age,course,name)
VALUES
(#{age}, #{course}, #{name})
</insert>
<update id="update" parameterType="com.mrcoder.mrentity.entity.slave.Teacher">
UPDATE
teacher
SET
age = #{age},
course = #{course},
name = #{name}
WHERE
id = #{id}
</update>
<delete id="delete" parameterType="java.lang.Long">
DELETE FROM
teacher
WHERE
id =#{id}
</delete>
</mapper>
关于resources/generator/文件夹下的内容，“熟读”我前几章的同学肯定知道，这俩个xml文件是mybatis用来自动生成entity和mapper文件的，这里不多赘述，不懂的同学可以百度“mybatis自动生成代码”查询。
这边顺带解释下mr-entity/pom.xml中的
注释的代码是用mybatis用来自动生成代码的，细心的同学发现了，
这边有两个配置文件，一个是master，一个是slave，我们可以在mr-entity的结构中发现，所有的类文件都是通过master和slave包来区分两个数据源的，也就是master数据源的实体类就放到master包内~，生成代码的逻辑也是一样，所以这边会有两个配置文件，大家使用时，用到master自动生成时请注释slave的配置，用到slave就注释master。（这一块作者暂时没有找到能同时生成master和slave多个数据源代码而且不需要改配置的方式，后续有时间会去研究下）
最后，强调一下，关于master和slave命名的问题，不是我们理解的主从数据库关系，仅仅是作者习惯命名，和主从没有任何关系，各位看官可以自由命名！
关于resources/generator/masterGenerator.xml和resources/generator/slaveGenerator.xml，有两个地方需要大家根据实际情况修改后才能使用
master数据源生成代码的配置文件 resources/generator/masterGenerator.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>
<!-- 本地数据库驱动程序jar包的全路径 -->
<classPathEntry
location="D:\MaveRepository\mysql\mysql-connector-java\8.0.15\mysql-connector-java-8.0.15.jar"/>
<context id="context" targetRuntime="MyBatis3">
<!-- optional，旨在创建class时，对注释进行控制 -->
<commentGenerator>
<property name="suppressAllComments" value="true"/>
<property name="suppressDate" value="true"/>
</commentGenerator>
<!-- 数据库的相关配置 -->
<jdbcConnection driverClass="com.mysql.cj.jdbc.Driver" connectionURL="jdbc:mysql://192.168.145.131:3306/test"
userId="root" password="123456"/>
<!-- 非必需，类型处理器，在数据库类型和java类型之间的转换控制-->
<javaTypeResolver>
<property name="forceBigDecimals" value="false"/>
</javaTypeResolver>
<!-- Model实体类生成的位置 -->
<javaModelGenerator targetPackage="com.mrcoder.mrentity.entity.master" targetProject="src/main/java">
<!-- 是否对model添加 构造函数 -->
<property name="constructorBased" value="false"/>
<!-- 是否允许子包，即targetPackage.schemaName.tableName -->
<property name="enableSubPackages" value="true"/>
<!-- 建立的Model对象是否 不可改变 即生成的Model对象不会有 setter方法，只有构造方法 -->
<property name="immutable" value="false"/>
<!-- 给Model添加一个父类 -->
<!--<property name="rootClass" value="com.foo.louis.Hello"/>-->
<!-- 是否对类CHAR类型的列的数据进行trim操作 -->
<property name="trimStrings" value="true"/>
</javaModelGenerator>
<!-- *Mapper.xml 文件的位置 -->
<sqlMapGenerator targetPackage="mapper/master" targetProject="src/main/resources">
<property name="enableSubPackages" value="true"/>
</sqlMapGenerator>
<!-- Mapper 接口文件的位置 -->
<javaClientGenerator targetPackage="com.mrcoder.mrentity.mapper.master" targetProject="src/main/java"
type="XMLMAPPER">
<property name="enableSubPackages" value="true"/>
<!--
定义Maper.java 源代码中的ByExample() 方法的可视性，可选的值有：
public;
private;
protected;
default
注意：如果 targetRuntime="MyBatis3",此参数被忽略
-->
<property name="exampleMethodVisibility" value=""/>
<!--方法名计数器Important note: this property is ignored if the target runtime is MyBatis3.-->
<property name="methodNameCalculator" value=""/>
<!--为生成的接口添加父接口-->
<property name="rootInterface" value=""/>
</javaClientGenerator>
<!-- 相关表的配置 -->
<table tableName="person" enableCountByExample="false" enableDeleteByExample="false"
enableSelectByExample="false"
enableUpdateByExample="false"/>
</context>
</generatorConfiguration>
slave数据源生成代码的配置文件 resources/generator/slaveGenerator.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>
<!-- 本地数据库驱动程序jar包的全路径 -->
<classPathEntry location="D:\MaveRepository\mysql\mysql-connector-java\8.0.15\mysql-connector-java-8.0.15.jar"/>
<context id="context" targetRuntime="MyBatis3">
<!-- optional，旨在创建class时，对注释进行控制 -->
<commentGenerator>
<property name="suppressAllComments" value="true"/>
<property name="suppressDate" value="true"/>
</commentGenerator>
<!-- 数据库的相关配置 -->
<jdbcConnection driverClass="com.mysql.cj.jdbc.Driver" connectionURL="jdbc:mysql://192.168.145.131:3306/test2"
userId="root" password="123456"/>
<!-- 非必需，类型处理器，在数据库类型和java类型之间的转换控制-->
<javaTypeResolver>
<property name="forceBigDecimals" value="false"/>
</javaTypeResolver>
<!-- Model实体类生成的位置 -->
<javaModelGenerator targetPackage="com.mrcoder.mrentity.entity.slave" targetProject="src/main/java">
<!-- 是否对model添加 构造函数 -->
<property name="constructorBased" value="false"/>
<!-- 是否允许子包，即targetPackage.schemaName.tableName -->
<property name="enableSubPackages" value="true"/>
<!-- 建立的Model对象是否 不可改变 即生成的Model对象不会有 setter方法，只有构造方法 -->
<property name="immutable" value="false"/>
<!-- 给Model添加一个父类 -->
<!--<property name="rootClass" value="com.foo.louis.Hello"/>-->
<!-- 是否对类CHAR类型的列的数据进行trim操作 -->
<property name="trimStrings" value="true"/>
</javaModelGenerator>
<!-- *Mapper.xml 文件的位置 -->
<sqlMapGenerator targetPackage="mapper/slave" targetProject="src/main/resources">
<property name="enableSubPackages" value="true"/>
</sqlMapGenerator>
<!-- Mapper 接口文件的位置 -->
<javaClientGenerator targetPackage="com.mrcoder.mrentity.mapper.slave" targetProject="src/main/java"
type="XMLMAPPER">
<property name="enableSubPackages" value="true"/>
<!--
定义Maper.java 源代码中的ByExample() 方法的可视性，可选的值有：
public;
private;
protected;
default
注意：如果 targetRuntime="MyBatis3",此参数被忽略
-->
<property name="exampleMethodVisibility" value=""/>
<!--方法名计数器Important note: this property is ignored if the target runtime is MyBatis3.-->
<property name="methodNameCalculator" value=""/>
<!--为生成的接口添加父接口-->
<property name="rootInterface" value=""/>
</javaClientGenerator>
<!-- 相关表的配置 -->
<table tableName="orders" enableCountByExample="false" enableDeleteByExample="false"
enableSelectByExample="false"
enableUpdateByExample="false"/>
</context>
</generatorConfiguration>
mr-service
目录结构
mr-service这个模块简单介绍下，impl内放的是实现类，外面定义的是接口，这也是为了遵循基本的开发规范~
RedisService (redis服务类，作者没有定义接口，同学们自行判断)
package com.mrcoder.mrservice;
import com.mrcoder.mrutils.redis.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
/**
* redis 测试业务层
*/
@Service
public class RedisService {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Autowired
private RedisUtil redisUtil;//内部封装了 RedisTemplate<String, Object>
/**
* 测试存储 String 类型数据
*/
public void setValue(String key, String string) {
redisUtil.set(key, string);
}
/**
* 测试读取 String 类型数据
*/
public Object getValue(String key) {
boolean flag = redisUtil.hasKey(key);
Object rs = null;
if (flag) {
rs = redisUtil.get(key);
}
return rs;
}
}
StudentService
package com.mrcoder.mrservice;
import com.mrcoder.mrentity.entity.master.Student;
import java.util.List;
public interface StudentService {
public List<Student> getListByAnno();
public List<Student> getList();
public Student getById(Long id);
public Integer save(Student s);
public Integer update(Student s);
public Integer delete(Long id);
public void trans(int code);
}
TeacherService （作者偷懒，就不实现Teacher服务类了）
package com.mrcoder.mrservice;
public class TeacherService {
}
impl/StudentServiceImpl
package com.mrcoder.mrservice.impl;
import com.mrcoder.mrentity.entity.master.Student;
import com.mrcoder.mrentity.entity.slave.Teacher;
import com.mrcoder.mrentity.mapper.master.StudentMapper;
import com.mrcoder.mrentity.mapper.slave.TeacherMapper;
import com.mrcoder.mrservice.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Service
public class StudentServiceImpl implements StudentService {
@Autowired
private StudentMapper studentMapper;
@Autowired
private TeacherMapper teacherMapper;
public List<Student> getListByAnno() {
return studentMapper.getListByAnno();
}
public List<Student> getList() {
return studentMapper.getList();
}
public Student getById(Long id) {
return studentMapper.getById(id);
}
public Integer save(Student s) {
return studentMapper.insert(s);
}
public Integer update(Student s) {
return studentMapper.update(s);
}
public Integer delete(Long id) {
return studentMapper.delete(id);
}
@Transactional
public void trans(int code) {
Student s1 = new Student();
s1.setAge(10);
s1.setGrade(10);
s1.setName("s1");
studentMapper.insert(s1);
Teacher t1 = new Teacher();
t1.setAge(10);
t1.setName("t1");
t1.setCourse(10);
teacherMapper.insert(t1);
int result = 1 / code;
}
}
impl/TeacherServiceImpl (偷懒不写，咋地）
package com.mrcoder.mrservice.impl;
public class TeacherServiceImpl {
}
mr-utils
目录结构
redis/RedisUtil
package com.mrcoder.mrutils.redis;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.CollectionUtils;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
* @Description: redis 工具类
*/
public class RedisUtil {
private RedisTemplate<String, Object> redisTemplate;
public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
this.redisTemplate = redisTemplate;
}
/**
* 指定缓存失效时间
*
* @param key 键
* @param time 时间(秒)
* @return
*/
public boolean expire(String key, long time) {
try {
if (time > 0) {
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据key 获取过期时间
*
* @param key 键 不能为null
* @return 时间(秒) 返回0代表为永久有效
*/
public long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 判断key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public boolean hasKey(String key) {
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除缓存
*
* @param key 可以传一个值 或多个
*/
@SuppressWarnings("unchecked")
public void del(String... key) {
if (key != null && key.length > 0) {
if (key.length == 1) {
redisTemplate.delete(key[0]);
} else {
redisTemplate.delete(CollectionUtils.arrayToList(key));
}
}
}
/**
* 普通缓存获取
*
* @param key 键
* @return 值
*/
public Object get(String key) {
return key == null ? null : redisTemplate.opsForValue().get(key);
}
/**
* 普通缓存放入
*
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public boolean set(String key, Object value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 普通缓存放入并设置时间
*
* @param key 键
* @param value 值
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
* @return true成功 false 失败
*/
public boolean set(String key, Object value, long time) {
try {
if (time > 0) {
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
} else {
set(key, value);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 递增
*
* @param key 键
* @param delta 要增加几(大于0)
* @return
*/
public long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 递减
*
* @param key 键
* @param delta 要减少几(小于0)
* @return
*/
public long decr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递减因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, -delta);
}
/**
* HashGet
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return 值
*/
public Object hget(String key, String item) {
return redisTemplate.opsForHash().get(key, item);
}
/**
* 获取hashKey对应的所有键值
*
* @param key 键
* @return 对应的多个键值
*/
public Map<Object, Object> hmget(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* HashSet
*
* @param key 键
* @param map 对应多个键值
* @return true 成功 false 失败
*/
public boolean hmset(String key, Map<String, Object> map) {
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* HashSet 并设置时间
*
* @param key 键
* @param map 对应多个键值
* @param time 时间(秒)
* @return true成功 false失败
*/
public boolean hmset(String key, Map<String, Object> map, long time) {
try {
redisTemplate.opsForHash().putAll(key, map);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @return true 成功 false失败
*/
public boolean hset(String key, String item, Object value) {
try {
redisTemplate.opsForHash().put(key, item, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true 成功 false失败
*/
public boolean hset(String key, String item, Object value, long time) {
try {
redisTemplate.opsForHash().put(key, item, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除hash表中的值
*
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public void hdel(String key, Object... item) {
redisTemplate.opsForHash().delete(key, item);
}
/**
* 判断hash表中是否有该项的值
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public boolean hHasKey(String key, String item) {
return redisTemplate.opsForHash().hasKey(key, item);
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
*
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
* @return
*/
public double hincr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash递减
*
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
* @return
*/
public double hdecr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, -by);
}
/**
* 根据key获取Set中的所有值
*
* @param key 键
* @return
*/
public Set<Object> sGet(String key) {
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 根据value从一个set中查询,是否存在
*
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public boolean sHasKey(String key, Object value) {
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将数据放入set缓存
*
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSet(String key, Object... values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 将set数据放入缓存
*
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSetAndTime(String key, long time, Object... values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if (time > 0) expire(key, time);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 获取set缓存的长度
*
* @param key 键
* @return
*/
public long sGetSetSize(String key) {
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 移除值为value的
*
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public long setRemove(String key, Object... values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
//===============================list=================================
/**
* 获取list缓存的内容
*
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
* @return
*/
public List<Object> lGet(String key, long start, long end) {
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 获取list缓存的长度
*
* @param key 键
* @return
*/
public long lGetListSize(String key) {
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 通过索引 获取list中的值
*
* @param key 键
* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
* @return
*/
public Object lGetIndex(String key, long index) {
try {
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, Object value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, Object value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value);
if (time > 0) expire(key, time);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, List<Object> value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, List<Object> value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0) expire(key, time);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据索引修改list中的某条数据
*
* @param key 键
* @param index 索引
* @param value 值
* @return
*/
public boolean lUpdateIndex(String key, long index, Object value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 移除N个值为value
*
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public long lRemove(String key, long count, Object value) {
try {
Long remove = redisTemplate.opsForList().remove(key, count, value);
return remove;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
}
web-service
以上，我们完善了几个公共的子模块，最后，我们来完善下真正的服务子模块，也就是web-service模块
config/datasource/DataSourceConfig
package com.mrcoder.webservice.config.datasource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.jta.atomikos.AtomikosDataSourceBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.context.annotation.Primary;
import org.springframework.core.env.Environment;
import javax.sql.DataSource;
import java.util.Properties;
/**
* 数据源配置类
*/
@Configuration
public class DataSourceConfig {
@Autowired
private Environment env;
@Value("${spring.datasource.type}")
private String dataSourceType;
/**
* 配置主数据源，多数据源中必须要使用@Primary指定一个主数据源
* 其次DataSource里用的是DruidXADataSource ，而后注册到AtomikosDataSourceBean并且返回
*/
@Primary
@Bean(name = "masterDataSource")
@DependsOn({"txManager"})
public DataSource masterDataSource() {
AtomikosDataSourceBean ds = new AtomikosDataSourceBean();
Properties prop = build(env, "spring.datasource.druid.master.");
ds.setXaDataSourceClassName(dataSourceType);
ds.setPoolSize(5);
ds.setXaProperties(prop);
return ds;
}
/**
* 配置次数据源
* 其次DataSource里用的是DruidXADataSource ，而后注册到AtomikosDataSourceBean并且返回
*/
@Bean(name = "slaveDataSource")
@DependsOn({"txManager"})
public DataSource slaveDataSource() {
AtomikosDataSourceBean ds = new AtomikosDataSourceBean();
Properties prop = build(env, "spring.datasource.druid.slave.");
ds.setXaDataSourceClassName(dataSourceType);
ds.setPoolSize(5);
ds.setXaProperties(prop);
return ds;
}
private Properties build(Environment env, String prefix) {
Properties prop = new Properties();
prop.put("name", env.getProperty(prefix + "name"));
prop.put("url", env.getProperty(prefix + "url"));
prop.put("username", env.getProperty(prefix + "username"));
prop.put("password", env.getProperty(prefix + "password"));
prop.put("driverClassName", env.getProperty(prefix + "driverClassName", ""));
prop.put("filters", env.getProperty(prefix + "filters"));
prop.put("maxActive", env.getProperty(prefix + "maxActive", Integer.class));
prop.put("initialSize", env.getProperty(prefix + "initialSize", Integer.class));
prop.put("maxWait", env.getProperty(prefix + "maxWait", Integer.class));
prop.put("minIdle", env.getProperty(prefix + "minIdle", Integer.class));
prop.put("timeBetweenEvictionRunsMillis",
env.getProperty(prefix + "timeBetweenEvictionRunsMillis", Integer.class));
prop.put("minEvictableIdleTimeMillis", env.getProperty(prefix + "minEvictableIdleTimeMillis", Integer.class));
prop.put("validationQuery", env.getProperty(prefix + "validationQuery"));
prop.put("testWhileIdle", env.getProperty(prefix + "testWhileIdle", Boolean.class));
prop.put("testOnBorrow", env.getProperty(prefix + "testOnBorrow", Boolean.class));
prop.put("testOnReturn", env.getProperty(prefix + "testOnReturn", Boolean.class));
prop.put("poolPreparedStatements", env.getProperty(prefix + "poolPreparedStatements", Boolean.class));
prop.put("maxOpenPreparedStatements", env.getProperty(prefix + "maxOpenPreparedStatements", Integer.class));
return prop;
}
}
config/datasource/MasterSqlSessionTemplateConfig
package com.mrcoder.webservice.config.datasource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.mybatis.spring.boot.autoconfigure.ConfigurationCustomizer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import javax.sql.DataSource;
/**
* MasterSqlSessionTemplateConfig配置类
*/
@Configuration
//下面的sqlSessionTemplateRef 值需要和生成的SqlSessionTemplate bean name相同，如果没有指定name,那么就是方法名
@MapperScan(basePackages = {"com.mrcoder.mrentity.mapper.master"}, sqlSessionTemplateRef = "masterSqlSessionTemplate")
public class MasterSqlSessionTemplateConfig {
@Value("${mybatis.mapper-locations}")
private String mapper_location;
@Value("${mybatis.type-aliases-package}")
private String type_aliases_package;
@Value("${mybatis.configuration.map-underscore-to-camel-case}")
private boolean mapUnderscoreToCamelCase;
//将MybatisConfig类中初始化的对象注入进来
@Autowired
private ConfigurationCustomizer customizer;
private Logger logger = LoggerFactory.getLogger(MasterSqlSessionTemplateConfig.class);
/**
* 自定义sqlSessionFactory配置（因为没有用到MybatisAutoConfiguration自动配置类，需要手动配置）
*/
@Bean
public SqlSessionFactory masterSqlSessionFactory(@Qualifier("masterDataSource") DataSource dataSource) throws Exception {
logger.info("mapper文件地址为：{}", mapper_location);
//在基本的 MyBatis 中,session 工厂可以使用 SqlSessionFactoryBuilder 来创建。
//而在 MyBatis-spring 中,则使用SqlSessionFactoryBean 来替代：
SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
bean.setDataSource(dataSource);
//如果重写了 SqlSessionFactory 需要在初始化的时候手动将 mapper 地址 set到 factory 中，否则会报错：
//org.apache.ibatis.binding.BindingException: Invalid bound statement (not found)
bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(mapper_location));
//下面这个setTypeAliasesPackage无效，是mybatis集成springBoot的一个bug，暂时未能解决
bean.setTypeAliasesPackage(type_aliases_package);
org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
logger.info("mybatis配置驼峰转换为：{}", mapUnderscoreToCamelCase);
configuration.setMapUnderscoreToCamelCase(mapUnderscoreToCamelCase);
//因为没有用mybatis-springBoot自动装配，所以需要手动将configuration装配进去，要不然自定义的map key驼峰转换不起作用
customizer.customize(configuration);
bean.setConfiguration(configuration);
return bean.getObject();
}
/**
* SqlSessionTemplate 是 SqlSession接口的实现类，是spring-mybatis中的，实现了SqlSession线程安全
*/
@Bean
public SqlSessionTemplate masterSqlSessionTemplate(@Qualifier("masterSqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
SqlSessionTemplate template = new SqlSessionTemplate(sqlSessionFactory);
return template;
}
}
config/datasource/SlaveSqlSessionTemplateConfig
package com.mrcoder.webservice.config.datasource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import javax.sql.DataSource;
/**
* SlaveSqlSessionTemplateConfig配置类
*/
@Configuration
@MapperScan(basePackages = {"com.mrcoder.mrentity.mapper.slave"}, sqlSessionTemplateRef = "slaveSqlSessionTemplate")
public class SlaveSqlSessionTemplateConfig {
@Value("${mybatis.mapper-locations}")
private String mapper_location;
@Bean
public SqlSessionFactory slaveSqlSessionFactory(@Qualifier("slaveDataSource") DataSource dataSource) throws Exception {
SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
bean.setDataSource(dataSource);
//如果重写了 SqlSessionFactory 需要在初始化的时候手动将 mapper 地址 set到 factory 中，否则会报错：
//org.apache.ibatis.binding.BindingException: Invalid bound statement (not found)
bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(mapper_location));
return bean.getObject();
}
@Bean
public SqlSessionTemplate slaveSqlSessionTemplate(@Qualifier("slaveSqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
SqlSessionTemplate template = new SqlSessionTemplate(sqlSessionFactory);
return template;
}
}
config/datasource/TransactionManagerConfig
package com.mrcoder.webservice.config.datasource;
import com.atomikos.icatch.jta.UserTransactionImp;
import com.atomikos.icatch.jta.UserTransactionManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.transaction.jta.JtaTransactionManager;
import javax.transaction.TransactionManager;
import javax.transaction.UserTransaction;
/**
* 多数据源事务管理器配置类
*/
@Configuration
public class TransactionManagerConfig {
/**
* 分布式事务使用JTA管理，不管有多少个数据源只要配置一个 JtaTransactionManager
*
* @return
*/
@Bean(name = "atomikosTransactionManager", initMethod = "init", destroyMethod = "close")
public TransactionManager atomikosTransactionManager() throws Throwable {
UserTransactionManager userTransactionManager = new UserTransactionManager();
userTransactionManager.setForceShutdown(false);
return userTransactionManager;
}
@Bean(name = "txManager")
@DependsOn({ "userTransaction", "atomikosTransactionManager" })
public JtaTransactionManager transactionManager() throws Throwable {
UserTransaction userTransaction = userTransaction();
TransactionManager atomikosTransactionManager = atomikosTransactionManager();
return new JtaTransactionManager(userTransaction, atomikosTransactionManager);
}
@Bean(name = "userTransaction")
public UserTransaction userTransaction() throws Throwable {
UserTransactionImp userTransactionImp = new UserTransactionImp();
userTransactionImp.setTransactionTimeout(10000);
return userTransactionImp;
}
}
config/wrapper/CustomWrapper
package com.mrcoder.webservice.config.wrapper;
import com.google.common.base.CaseFormat;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.wrapper.MapWrapper;
import java.util.Map;
/**
* @Description: 自定义wrapper处理spring boot + mybatis返回结果为map时的key值转换为驼峰
*/
public class CustomWrapper extends MapWrapper {
public CustomWrapper(MetaObject metaObject, Map<String, Object> map) {
super(metaObject, map);
}
@Override
public String findProperty(String name, boolean useCamelCaseMapping) {
if (useCamelCaseMapping) {
return CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, name);
}
return name;
}
}
config/wrapper/MapWrapperFactory
package com.mrcoder.webservice.config.wrapper;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.wrapper.ObjectWrapper;
import org.apache.ibatis.reflection.wrapper.ObjectWrapperFactory;
import java.util.Map;
/**
* 实现接口 ObjectWrapperFactory,通过包装工厂来创建自定义的wrapper
*/
public class MapWrapperFactory implements ObjectWrapperFactory {
@Override
public boolean hasWrapperFor(Object object) {
return object != null && object instanceof Map;
}
@Override
public ObjectWrapper getWrapperFor(MetaObject metaObject, Object object) {
return new CustomWrapper(metaObject, (Map) object);
}
}
config/DruidConfig
package com.mrcoder.webservice.config;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* 配置 Druid登陆配置（白名单等）
*/
@Configuration
public class DruidConfig {
@Value("${spring.druid.name}")
private String name;
@Value("${spring.druid.pass}")
private String pass;
private Logger logger = LoggerFactory.getLogger(DruidConfig.class);
/**
* 配置 Druid控制台 白名单、黑名单、用户名、密码等
* 访问地址 ip+port/projectContextPath/druid/index.html
*/
@Bean
public ServletRegistrationBean DruidStatViewServlet() {
logger.info("servletRegistrationBean configure is starting...");
//org.springframework.boot.context.embedded.ServletRegistrationBean提供类的进行注册.
ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
//添加初始化参数
servletRegistrationBean.addInitParameter("allow", "*");
servletRegistrationBean.addInitParameter("loginUsername", name);
servletRegistrationBean.addInitParameter("loginPassword", pass);
//是否可以重置
servletRegistrationBean.addInitParameter("resetEnable", "false");
return servletRegistrationBean;
}
/**
* 注册一个：filterRegistrationBean
*/
@Bean
public FilterRegistrationBean druidStatFilter2() {
logger.info("filterRegistrationBean configure is starting...");
FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new WebStatFilter());
//添加过滤规则.
filterRegistrationBean.addUrlPatterns("/*");
//添加不需要忽略的格式信息.
filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
return filterRegistrationBean;
}
}
config/MybatisConfig
package com.mrcoder.webservice.config;
import com.mrcoder.webservice.config.wrapper.MapWrapperFactory;
import org.mybatis.spring.boot.autoconfigure.ConfigurationCustomizer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* mybatis配置类,将自定义的MapWrapperFactory覆盖默认的ObjectWrapperFactory
*/
@Configuration
public class MybatisConfig {
private Logger logger = LoggerFactory.getLogger(MybatisConfig.class);
@Bean
public ConfigurationCustomizer mybatisConfigurationCustomizer() {
logger.info("initialize the ConfigurationCustomizer....");
return new ConfigurationCustomizer() {
@Override
public void customize(org.apache.ibatis.session.Configuration configuration) {
configuration.setObjectWrapperFactory(new MapWrapperFactory());
}
};
}
}
config/RedisConfig
package com.mrcoder.webservice.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.mrcoder.mrutils.redis.RedisUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* @redis 配置类
*/
@Configuration
public class RedisConfig {
private Logger logger = LoggerFactory.getLogger(RedisConfig.class);
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
// 配置连接工厂
template.setConnectionFactory(factory);
//使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
// 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
// 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jacksonSeial.setObjectMapper(om);
// 值采用json序列化
template.setValueSerializer(jacksonSeial);
//使用StringRedisSerializer来序列化和反序列化redis的key值
template.setKeySerializer(new StringRedisSerializer());
// 设置hash key 和value序列化模式
template.setHashKeySerializer(new StringRedisSerializer());
template.setHashValueSerializer(jacksonSeial);
template.afterPropertiesSet();
return template;
}
/**
* 对hash类型的数据操作
*
* @param redisTemplate
* @return
*/
@Bean
public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForHash();
}
/**
* 对redis字符串类型数据操作
*
* @param redisTemplate
* @return
*/
@Bean
public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForValue();
}
/**
* 对链表类型的数据操作
*
* @param redisTemplate
* @return
*/
@Bean
public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForList();
}
/**
* 对无序集合类型的数据操作
*
* @param redisTemplate
* @return
*/
@Bean
public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForSet();
}
/**
* 对有序集合类型的数据操作
*
* @param redisTemplate
* @return
*/
@Bean
public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForZSet();
}
/**
* 使用上面初始化的RedisTemplate实例来初始化一个RedisUtil对象
* ps:@Qualifier("redisTemplate") 可以不用加，如果存在RedisTemplate实例，spring会默认注入
*/
@Bean
public RedisUtil redisUtil(@Qualifier("redisTemplate") RedisTemplate redisTemplate) {
RedisUtil redisUtil = new RedisUtil();
redisUtil.setRedisTemplate(redisTemplate);
return redisUtil;
}
}
config/Swagger2Config
package com.mrcoder.webservice.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
/**
* @Description: swagger2配置类
*/
@Configuration
@EnableSwagger2
public class Swagger2Config {
@Bean
public Docket createRestApi() {
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo())
.select()
.apis(RequestHandlerSelectors.basePackage("com.mrcoder.webservice.controller"))
.paths(PathSelectors.any())
.build();
}
private ApiInfo apiInfo() {
return new ApiInfoBuilder()
.title("SPRING-BOOT整合MYBATIS--API说明文档")
.description("2019-04-26")
.version("1.0.0")
.license("署名-MrCoder")
.build();
}
}
controller/TestController
package com.mrcoder.webservice.controller;
import com.mrcoder.mrentity.entity.master.Student;
import com.mrcoder.mrservice.RedisService;
import com.mrcoder.mrservice.StudentService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@Api(value = "Test", description = "Test测试Controller")
public class TestController {
@Autowired
private StudentService studentService;
@Autowired
private RedisService redisService;
private Log logger = LogFactory.getLog(getClass());
@ApiOperation(value = "log测试接口", notes = "测试写level日志")
@RequestMapping("log")
public void testAll() {
logger.info("====info");
logger.warn("====warn");
logger.error("====error");
}
//列表查询
@RequestMapping("getStudentList")
public ResponseEntity<List<Student>> getStudentList() {
return ResponseEntity.ok(studentService.getList());
}
//列表查询
@RequestMapping("getStudentListByAnno")
public ResponseEntity<List<Student>> getStudentListByAnno() {
return ResponseEntity.ok(studentService.getListByAnno());
}
//新增
@RequestMapping("addStudent")
public int addStudent() {
Student student = new Student();
student.setAge(1);
student.setGrade(1);
student.setName("student");
return studentService.save(student);
}
//更新
@RequestMapping("updateStudent/{id}")
public int updateStudent(@PathVariable(name = "id") Long id) {
Student student = new Student();
student.setAge(10);
student.setGrade(10);
student.setName("update");
student.setId(id);
return studentService.update(student);
}
//删除
@RequestMapping("deleteStudent/{id}")
public int deleteStudent(@PathVariable(name = "id") Long id) {
return studentService.delete(id);
}
//事务
@RequestMapping("transSuccess")
public void transSuccess() {
//人为制造0除异常测试事务分布式事务回滚
studentService.trans(1);
}
//事务
@RequestMapping("transRoll")
public void transRoll() {
//人为制造0除异常测试事务分布式事务回滚
studentService.trans(0);
}
//redis string读写
@RequestMapping(value = "/redis")
public String redis() {
redisService.setValue("test", "test123");
return redisService.getValue("test").toString();
}
}
WebServiceApplication
package com.mrcoder.webservice;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
@SpringBootApplication
@ComponentScan(basePackages = {"com.mrcoder"})
public class WebServiceApplication {
public static void main(String[] args) {
SpringApplication.run(WebServiceApplication.class, args);
}
}
注意
@ComponentScan(basePackages = {"com.mrcoder"})
这个注解是用来扫描com.mrcoder下的所有类的。
核心配置,主要的数据源配置都在此 resources/application.yml
## 公共配置start
## 配置数据源相关信息
spring:
## 环境配置
profiles:
active: dev
## 数据源设置
datasource:
type: com.alibaba.druid.pool.xa.DruidXADataSource
druid:
## 连接池配置
master:
## JDBC配置
name: master
url: jdbc:mysql://192.168.145.131:3306/test?useUnicode=true&characterEncoding=UTF-8&useSSL=false&autoReconnect=true&failOverReadOnly=false&serverTimezone=GMT%2B8
username: root
password: 123456
driver-class-name: com.mysql.cj.jdbc.Driver
filters: stat
maxActive: 20
initialSize: 1
maxWait: 60000
minIdle: 1
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 300000
validationQuery: select 'x'
testWhileIdle: true
testOnBorrow: true
testOnReturn: true
poolPreparedStatements: true
maxOpenPreparedStatements: 20
slave:
## JDBC配置
name: slave
url: jdbc:mysql://192.168.145.131:3306/test2?useUnicode=true&characterEncoding=UTF-8&useSSL=false&autoReconnect=true&failOverReadOnly=false&serverTimezone=GMT%2B8
username: root
password: 123456
driver-class-name: com.mysql.cj.jdbc.Driver
filters: stat
maxActive: 20
initialSize: 1
maxWait: 60000
minIdle: 1
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 300000
validationQuery: select 'x'
testWhileIdle: true
testOnBorrow: true
testOnReturn: true
poolPreparedStatements: true
maxOpenPreparedStatements: 20
redis:
host: 127.0.0.1 # redis服务所在的地址
port: 6379
password: # redis的密码默认为空
pool:
max-active: 8 #连接池最大连接数（使用负值表示没有限制）
max-idle: 8 #连接池最大空闲数
min-idle: 1 #连接池最小空闲数
max-wait: 60000 #获取连接的超时等待事件
timeout: 30000 #连接redis服务器的最大等待时间
#druid监控页面用户名和密码
druid:
name: admin
pass: admin
## 该配置节点为独立的节点
mybatis:
mapper-locations: classpath:mapper/*/*.xml # 注意：一定要对应mapper映射xml文件的所在路径
type-aliases-package: com.mrcoder.mrentity.entity # 注意：对应实体类的路径
configuration:
map-underscore-to-camel-case: true
## 公共配置 end
---
## 开发环境配置
spring:
profiles: dev
server:
port: 8080
---
## 测试环境配置
spring:
profiles: test
server:
port: 8082
---
## 生产环境配置
spring:
profiles: prod
server:
port: 8084
这边细心的盆友发现了
这边是为了区分多个环境的配置，实际项目开发时，都会区分开发/联调/测试/生产等环境，yml配置文件本身支持多环境的区分，用“---”隔开来不同环境。
公用的配置写在最上方即可，需要采用的配置用"active"关键词声明即可。
atomikos分布式事务管理器配置 resources/jta.properties
com.atomikos.icatch.service=com.atomikos.icatch.standalone.UserTransactionServiceFactory
com.atomikos.icatch.max_timeout=600000
com.atomikos.icatch.default_jta_timeout=600000
com.atomikos.icatch.log_base_dir =transaction-logs
com.atomikos.icatch.log_base_name=springboot-mybatis
com.atomikos.icatch.serial_jta_transactions=false
日志配置 resources/logback-spring.xml
<configuration debug="false" scan="true" scanPeriod="10 seconds">
<contextName>logback</contextName>
<!--输出sql语句-->
<logger name="com.mrcoder.webservice" level="debug"/>
<property name="path" value="/logs"></property>
<property name="maxHistory" value="30"/>
<property name="maxFileSize" value="50MB"/>
<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
<level>debug</level>
</filter>
<encoder>
<pattern>%date %level [%thread] %logger{36} [%file : %line] %msg%n
</pattern>
</encoder>
</appender>
<appender name="debug_file" class="ch.qos.logback.core.rolling.RollingFileAppender">
<file>logs/logback_debug.log</file>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!-- 每天一归档 -->
<fileNamePattern>${path}/logback_debug.log.%d{yyyy-MM-dd}-%i.zip</fileNamePattern>
<maxHistory>${maxHistory}</maxHistory>
<timeBasedFileNamingAndTriggeringPolicy
class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<maxFileSize>${maxFileSize}</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>
</rollingPolicy>
<encoder>
<pattern>%date %level [%thread] %logger{36} [%file : %line] %msg%n
</pattern>
</encoder>
<filter class="ch.qos.logback.classic.filter.LevelFilter">
<level>DEBUG</level>
<onMatch>ACCEPT</onMatch>
<onMismatch>DENY</onMismatch>
</filter>
</appender>
<appender name="info_file" class="ch.qos.logback.core.rolling.RollingFileAppender">
<file>logs/logback_info.log</file>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!-- 每天一归档 -->
<fileNamePattern>${path}/logback_info.log.%d{yyyy-MM-dd}-%i.zip</fileNamePattern>
<maxHistory>${maxHistory}</maxHistory>
<timeBasedFileNamingAndTriggeringPolicy
class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<maxFileSize>${maxFileSize}</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>
</rollingPolicy>
<encoder>
<pattern>%date %level [%thread] %logger{36} [%file : %line] %msg%n
</pattern>
</encoder>
<filter class="ch.qos.logback.classic.filter.LevelFilter">
<level>INFO</level>
<onMatch>ACCEPT</onMatch>
<onMismatch>DENY</onMismatch>
</filter>
</appender>
<appender name="warn_file" class="ch.qos.logback.core.rolling.RollingFileAppender">
<file>logs/logback_warn.log</file>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!-- 每天一归档 -->
<fileNamePattern>${path}/logback_warn.log.%d{yyyy-MM-dd}-%i.zip</fileNamePattern>
<maxHistory>${maxHistory}</maxHistory>
<timeBasedFileNamingAndTriggeringPolicy
class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<maxFileSize>${maxFileSize}</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>
</rollingPolicy>
<encoder>
<pattern>%date %level [%thread] %logger{36} [%file : %line] %msg%n
</pattern>
</encoder>
<filter class="ch.qos.logback.classic.filter.LevelFilter">
<level>WARN</level>
<onMatch>ACCEPT</onMatch>
<onMismatch>DENY</onMismatch>
</filter>
</appender>
<appender name="error_file" class="ch.qos.logback.core.rolling.RollingFileAppender">
<file>logs/logback_error.log</file>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!-- 每天一归档 -->
<fileNamePattern>${path}/logback_error.log.%d{yyyy-MM-dd}-%i.zip</fileNamePattern>
<maxHistory>${maxHistory}</maxHistory>
<timeBasedFileNamingAndTriggeringPolicy
class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<maxFileSize>${maxFileSize}</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>
</rollingPolicy>
<encoder>
<pattern>%date %level [%thread] %logger{36} [%file : %line] %msg%n
</pattern>
</encoder>
<filter class="ch.qos.logback.classic.filter.LevelFilter">
<level>ERROR</level>
<onMatch>ACCEPT</onMatch>
<onMismatch>DENY</onMismatch>
</filter>
</appender>
<root>
<level value="info"/>
<appender-ref ref="console"/>
<appender-ref ref="debug_file"/>
<appender-ref ref="info_file"/>
<appender-ref ref="warn_file"/>
<appender-ref ref="error_file"/>
</root>
</configuration>
至此，所有的代码均已完善，大家已经可以运行
运行
http://localhost:8080/log
http://localhost:8080/getStudentList
http://localhost:8080/getStudentListByAnno
http://localhost:8080/addStudent
http://localhost:8080/updateStudent/1
http://localhost:8080/deleteStudent/1
http://localhost:8080/transSuccess
http://localhost:8080/transRoll
http://localhost:8080/redis
关于druid和swagger2的使用
druid监控 （具体使用请查看官方文档）
http://localhost:8080/druid 账号和密码在application.yml有配置
swagger2 api文档 （具体使用请查看官方文档）
http://localhost:8080/swagger-ui.html
关于swagger2 api文档的自动生成，我们只是简单的测试了一下
关于mybatis 代码自动生成
这个其实在前几章，作者已经介绍过了，但是这边再讲一下。
我们看mr-entity子模块的pom.xml文件，可以看到注释的build信息，只需放开注释，我们假设在你的master数据源（也就是test库）中有张person表，你想自动生成entity和mapper文件，只需修改resources/generator/masterGenerator.xml
然后点击IDEA右侧
关于打包的介绍
关于打包的几个pom.xml build块配置
先看父模块pom.xml中的
这个是跑测试用例JUnit的配置
再看web-service子模块的pom.xml配置
重要的掉已经在截图中标红了，大家可以重点看下~
最后，我们再看mr-entity子模块pom.xml中的build信息
可以看到，这边是注释的，为啥注释呢？因为像mr-entity，mr-service，mr-utils等模块无需打包，我们最终需要打包的只有真正的应用web-service模块。也就是说只有需要打包的模块才能有build配置信息。
最后，打包命令我们只需在IDEA右侧点击
注意，作者打包时操作的是root项目，也就是父项目。操作父项目执行的操作会对所有的子模块执行，若同学们只想打包某个子项目只需对对应的子模块下执行操作即可~ 强调一下重点，先clean，再package！
执行完成后，我们看IDEA的console口出现
此时，我们发现，各个模块下都会出现一个target文件夹，且里面会有对应的jar包，我们找到web-service服务模块的jar包（为什么找这个，因为只有它才是真正提供服务的模块，才有入口启动类，通俗点，只有它能运行，不懂的可以再回头看看文章。） 我们再cmd下执行 jar -jar xxxx.jar包 即可运行该服务！linux下同理！注意，必须按照JDK环境，这里就不讲如何安装配置JDK了。
总结
好了，至此，一个可生产的springboot项目结构已经搭建完毕，该结构可以直接拿去投产，从结构的构思到demo的编写，作者花了几天的时间，还请用的上的同学关注下作者的公众号，同时对github点个赞~
项目地址
https://github.com/MrCoderStack/SpringBootFrame
请关注我的订阅号
转载于:https://my.oschina.net/u/3066875/blog/3055365
分享到：
发表评论
相关推荐
sftp直接上载到home文件夹下方便调用（可以先解压缩之后再传，虽然网速会慢一丢丢） sudo apt-get install alien sudo alien -i /home/ubuntu/oracle-instantclient-basic-21.1.0.0.0-1.x86_64.rpm sudo alien -i /...
总之，"instantclient-basic-linux.x64-21.1.0.0.0.zip" 是Oracle提供的一个高效、轻量级的解决方案，让Linux用户无需完整安装Oracle客户端即可处理与Oracle数据库相关的任务。其丰富的特性、广泛的API支持以及便捷...
稳定可用
BAC0-21.1.28-py3-none-any.whl
RAD Studio 11.1安装包 DevExpressVCL 21.1.6[CS]
jssor.slider-21.1.6.mini.js
资源分类：Python库 所属语言：Python 资源全名：bidsphysio.acq2bids-21.1.28-py3-none-any.whl 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
离线部署rabbitmq-server-generic-unix-3.7.8.tar otp_src_21.1.tar 基于arm x86系统linux都可以 离线部署rabbitmq-server-generic-unix-3.7.8.tar otp_src_21.1.tar 基于arm x86系统linux都可以 离线部署rabbitmq-...
Erlang OTP（Open Telephony Platform）是Erlang编程语言的一个核心组成部分，它提供了一套全面的库和工具，用于构建高度并发、分布式、容错的系统。OTP的全称实际上是“Open Telecom Platform”，但在现代，它更...
otp_src_21.1.tar.gz 是OTP的一个源代码版本，对应于Erlang的21.1版本。这个压缩包包含了开发、编译和测试Erlang OTP 21.1所需的所有源代码文件。 Erlang是一种并发编程语言，特别适用于构建实时系统和容错系统，如...
这个版本，v21.1.3.0，是DevExpress产品线的一个更新，它提供了最新的功能和改进，旨在提升开发人员的工作效率和应用的质量。 DevExpress v21.1.3.0可能包含以下关键组件和知识点： 1. **UI控件库**：DevExpress...
QualcommPackageManager.2.0.31.1.Linux-x86
解决EMC存储配置，flash，java不兼容问题
2021.1.1.22版本作为该年度早期的主要更新，为开发人员提供了一系列新的特性和改进，使得从零基础入门的开发者能够更加顺利地构建应用直至成功上架。 此版本的Android Studio特别注重性能优化，对应用的编译和运行...
DevExpress Universal Complete v21.1.4.0是一款由DevExpress公司推出的全面的.NET开发工具集，主要用于构建高性能、美观且功能丰富的Windows、Web和移动应用。这个版本包含了多个组件库和框架，为开发者提供了大量...
这个工具主要用于Android设备，它提供了一个安全、高效的方式来修改系统核心，实现root权限，安装自定义模块，以及隐藏 root 状态以通过官方的安全检查。"Magisk-v21.1.zip" 是 Magisk 工具的特定版本，版本号为21.1...
DevExpress_VCL_v21.1.7_for_Delphi11_Alexandria
DevExpress VCL v21.1.7 for Delphi 11 Alexandria是一款专为Embarcadero Delphi 11 Alexandria开发的高级组件库，旨在提升Delphi开发人员的生产力和应用质量。该套件提供了丰富的用户界面控件、数据可视化工具以及...