从0到1构建一个spring boot + mybatis的项目
前言：
为什么选择spring boot？或许对于经历过编写大量的配置文件的小伙伴，有一点就可以打动他-----零配置运行一个程序。而且spring boot内嵌Tomcat，当然，spring boot还有好多的优点，大大提高了我们的开发进度。
所以为了有更多的时间陪女朋友，快点加入spring boot的学习吧！！！
学习此篇文章，如果你对以下知识有一定的了解将会更有利于你对这篇文章的理解。
1.spring基础知识，如IOC，AOP等
2.mybatis基础
3.mysql基础
4.maven基础
好了，开始我们spring boot的学习吧
首先你的电脑上需要以下环境（环境统一，不然会出现奇怪的问题）：
1.安装 IntelliJ Idea（旗舰版）
2.java环境(版本1.8或以上)
3.数据库Mysql（版本5.7或以上）
一、新建spring boot项目
1.打开idea，并创建一个新的项目：
2.选择Spring Initializr选项，并选择一个SDK，点击Next
3.填写Group(一般为公司域名反写)和Artifact(项目名)，此项目的管理工具为Maven(当然你也可以使用Gradle)，打包方式 为jar包，java版本为1.8，点击Next
4.这里选择先添加Web依赖，点击Next
5.点击Finish
6.好了，我们的spring boot项目就已经创建好了，我们来看一下项目的结构。对于.mvn mvnw mvnw.cmd这几个文无关紧要，看着烦，可以删除。
7.我们来运行一下项目，图中点击任意哪个都可以，快捷键为Ctrl+Shift+F10
8.在控制台中会输出一大串日志信息，你如果看到了下图中的信息，恭喜你项目已经启动成功了
9.在浏览器访问localhost:8080，你将看到以下信息
我们在com.example.demo下创建一个controller包，在controller包下创建一个Hello.java类。
src/main/java/com/example/demo/controller/Hello.java
package com.example.demo.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class Hello {
@RequestMapping("/hi")
public String hello(){
return "hello world";
}
}
重新启动我们的项目，并访问localhost:8080/hi我们的spring boot项目的hello world程序就已经成功了，我们没有写一行配置，就已经将一个spring boot程序运行起来了。
二、集成Mybatis
1.我们整理一下我们的项目目录结构：
2.在pom.xml文件中添加如下代码
demo/pom.xml
<dependencies>
..........
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.3.0</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
.........
</dependencies>
3.创建数据库和表
建表语句如下：（你也可以使用mysql workbench这个免费工具，官方可下载）
CREATE TABLE `test`.`user` (
`user_id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '用户id',
`user_name` VARCHAR(45) NOT NULL COMMENT '用户名',
`password` VARCHAR(45) NOT NULL COMMENT '密码',
`age` INT NOT NULL COMMENT '年龄',
PRIMARY KEY (`user_id`))
COMMENT = '用户表';
这样我们就已经将mybatis和mysql集成到我们的spring boot项目中去了。下面教大家如何配置使用mybatis.（包括如何使用mybatis generator插件生成代码。）
4编写mybatis代码生成的配置
在src/main/resources/mybatis下新建一个mybatis-generator.xml
src/main/resources/mybatis/mybatis-generator.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="datasource.properties"/>
<!--指定特定数据库的jdbc驱动jar包的位置-->
<classPathEntry location="${db.driverLocation}"/>
<context id="default" targetRuntime="MyBatis3">
<!-- optional，旨在创建class时，对注释进行控制 -->
<commentGenerator>
<property name="suppressDate" value="true"/>
<property name="suppressAllComments" value="true"/>
</commentGenerator>
<!--jdbc的数据库连接 -->
<jdbcConnection
driverClass="${db.driverClassName}"
connectionURL="${db.url}"
userId="${db.username}"
password="${db.password}">
</jdbcConnection>
<!-- 非必需，类型处理器，在数据库类型和java类型之间的转换控制-->
<javaTypeResolver>
<property name="forceBigDecimals" value="false"/>
</javaTypeResolver>
<!-- Model模型生成器,用来生成含有主键key的类，记录类 以及查询Example类
targetPackage 指定生成的model生成所在的包名
targetProject 指定在该项目下所在的路径
-->
<javaModelGenerator targetPackage="com.example.demo.pojo" targetProject="./src/main/java">
<!-- 是否允许子包，即targetPackage.schemaName.tableName -->
<property name="enableSubPackages" value="false"/>
<!-- 是否对model添加 构造函数 -->
<property name="constructorBased" value="true"/>
<!-- 是否对类CHAR类型的列的数据进行trim操作 -->
<property name="trimStrings" value="true"/>
<!-- 建立的Model对象是否 不可改变 即生成的Model对象不会有 setter方法，只有构造方法 -->
<property name="immutable" value="false"/>
</javaModelGenerator>
<!--mapper映射文件生成所在的目录 为每一个数据库的表生成对应的SqlMap文件 -->
<sqlMapGenerator targetPackage="mybatis/mapper" targetProject="./src/main/resources">
<property name="enableSubPackages" value="false"/>
</sqlMapGenerator>
<!-- 客户端代码，生成易于使用的针对Model对象和XML配置文件 的代码
type="ANNOTATEDMAPPER",生成Java Model 和基于注解的Mapper对象
type="MIXEDMAPPER",生成基于注解的Java Model 和相应的Mapper对象
type="XMLMAPPER",生成SQLMap XML文件和独立的Mapper接口
-->
<!-- targetPackage：mapper接口dao生成的位置 -->
<javaClientGenerator type="XMLMAPPER" targetPackage="com.example.demo.dao" targetProject="./src/main/java">
<!-- enableSubPackages:是否让schema作为包的后缀 -->
<property name="enableSubPackages" value="false" />
</javaClientGenerator>
<!-- 每个table标签对应数据库中的一张表，用于生成pojo -->
<table tableName="user" domainObjectName="User" enableCountByExample="true" enableUpdateByExample="true"
enableDeleteByExample="true" enableSelectByExample="true" selectByExampleQueryId="true"/>
<!-- geelynote mybatis插件的搭建 -->
</context>
</generatorConfiguration>
新建resources/datasource.properties并添加如下代码：(#号后面的为注释，这个文件将会被resources/mybatis/mybatis-generator.xml引用)
#数据库本地的驱动jar包路径(你的路径和此处不一定相同)
db.driverLocation=C:/Users/sifu/.m2/repository/mysql/mysql-connector-java/5.1.6/mysql-connector-java-5.1.6.jar
#数据库驱动
db.driverClassName=com.mysql.jdbc.Driver
#数据库url
db.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=true&verifyServerCertificate=false
#数据库用户名
db.username=root
#数据库密码
db.password=sifu
修改application.properties名称为application.yml并且添加如下代码(此文件中有严格的代码格式)：
resources/application.yml
spring:
datasource:
url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=true&verifyServerCertificate=false
driver-class-name: com.mysql.jdbc.Driver
username: root
password: sifu
mybatis:
mapper-locations: classpath:mybatis/mapper/*.xml
type-aliases-package: com.example.demo.pojo
解释：
url：数据库链接地址
driver-class-name：数据库驱动
username：数据库用户名
password：数据库密码
mapper-locations：指定生成的*.xml文件路径
type-aliases-package：指定实体类路径
为什么修改使用yml格式的配置文件，原因是为了使代码更加简洁。以上application.yml代码等同于application.properties的如下代码：
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=true&verifyServerCertificate=false
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=sifu
mybatis.mapper-locations=classpath:mybatis/mapper/*.xml
mybatis.type-aliases-package=com.example.demo.pojo
看一下，是不是yml格式的配置更加简洁？至于用哪个，自己决定咯，个人推荐用yml格式的！！
5.添加mybatis generator插件
修改pom.xml文件，添加mybatis的代码生成插件
.......
<build>
<plugins>
..........
<plugin>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-maven-plugin</artifactId>
<version>1.3.2</version>
<configuration>
<verbose>true</verbose>
<overwrite>true</overwrite>
<configurationFile>${project.basedir}/src/main/resources/mybatis/mybatis-generator.xml
</configurationFile>
</configuration>
</plugin>
</plugins>
</build>
双击mybatisi-generator:generate（注意：不要运行多次，否则会生成重复的代码，编译时会出现神奇的bug）
此时Build成功：
让我们再看一下我们的项目结构：
多了四个文件，这些就是mybatis generator插件生成的代码。
UserMapper：用于操作数据库的接口（没有实现类，对应UserMapper.xml文件）
User：实体类，对应数据库中的一张表
UserExample：用于做条件增删改查用的
UserMapper.xml：里面是一些sql语句
用这些生成的代码来操作数据库面对大部分业务已经足够了，如果不能满足，那就自己在UserMapper.java和UserMapper.xml中去编写添加接口和sql语句吧！这个由你自己去探索！！
现在我们的spring boot + mybatis项目已经基本构建完成了,我们完全可以成功的运行我们的项目。但是到此处还不够，我们还需要一点其他的工具，让我们开发项目更加便捷快速。接着看吧！
三、集成测试工具Swagger2
为了我们能够更好的测试我们编写的代码，我们在pom.xml中添加如下代码，集成swagger2.
pom.xml
<dependencies>
.......
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.7.0</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.7.0</version>
</dependency>
</dependencies>
注意：swagger的版本最好设置高一点，版本过低时，参数如果是对象，调试会出现问题，这里设置为2.7.0版本。
并且新建com/example/demo/config/SwaggerConfig.java---swagger的配置文件，添加如下代码：
package com.example.demo.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;
@Configuration
@EnableSwagger2
public class SwaggerConfig {
@Bean
public Docket createRestApi() {
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo())
.select()
.apis(RequestHandlerSelectors.basePackage("com.example.demo.controller"))
.paths(PathSelectors.any())
.build();
}
private ApiInfo apiInfo() {
return new ApiInfoBuilder()
.title("Spring Boot中使用Swagger2构建RESTful APIs")
.description("")
.termsOfServiceUrl("")
.contact(new Contact("sifu","www.xxx.com","123456@qq.com"))
.version("1.0")
.build();
}
}
注意：.apis(RequestHandlerSelectors.basePackage(""))中请填写正确的controller路径。
下面让我们来编写一个业务逻辑的代码，往我们的数据库中插入一条数据
新建com/example/demo/service/UserService.java
package com.example.demo.service;
import com.example.demo.pojo.User;
public interface UserService {
int add(User user);
}
新建com/example/demo service/impl/UserserviceImpl.java
package com.example.demo.service.impl;
import com.example.demo.dao.UserMapper;
import com.example.demo.pojo.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserMapper userMapper;
public int add(User user) {
return userMapper.insert(user);
}
}
新建com/example/demo/controller/UserController.java
package com.example.demo.controller;
import com.example.demo.pojo.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class UserController {
@Autowired
private UserService userService;
@PostMapping("/add")
public int add(User user) {
return userService.add(user);
}
}
现在我们运行一下我们的程序
ps:卧槽，报错了？？逗我玩呢？浪费我这么多时间
不要急嘛，报错原因是无法找到UserMapper.java.我们在启动类DemoAppliction.java上添加一个注解@MapperScan("com.example.demo.dao")，用于扫描com/example/demo/dao包下的NameMapper.java文件（如果我们不集成Swagger2，则不会报这个错误，也不需要添加此的注解）
com/example/demo/DemoAppliction.java
package com.example.demo;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@MapperScan("com.example.demo.dao")
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
好了，启动我们的项目，并访问http://localhost:8080/swagger-ui.html我们就可以看到一个调试的界面。
是不是感觉这界面看起来很爽，很清晰，但是如果只是好看，那就太low了，重点是在于它的功能强大。
填写参数，因为传的参数是User对象，所以需要填的参数都是实体类中的字段。（UserId是自增的，所以不填）点击Try it out!
Response Body为返回值为1，说明数据库中已经有一条数据插入了，状态码为200，说明请求成功了。
现在我们来看一下我们的数据库中的数据，我们使用idea自带的数据库连接工具
弹出此界面，填写一些必要的信息，点击Test Connection,如果测试成功，那就点击ok：
双击user，我们看到了我们之前添加的数据：
到此，我们的spring boot + mybatis 已经完全构建成功了，接下来就是编写业务逻辑层的代码了，这个就由你自己去探索了。
四、集成Spring AOP（日志打印使用Slf4j）
下面我们继续让我们的项目添加Spring AOP
1.pom.xml添加如下代码：
<dependencies>
........
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
2.下载安装一个插件（记得一定要安装好哦！）：lombok(很好用，下面再讲)
3.新建com/example/demo/aspect/HttpAspect.java，并添加如下代码（此处为了演示，只添加一些日志打印的代码）：
package com.example.demo.aspect;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
@Slf4j
@Aspect
@Component
public class HttpAspect {
@Pointcut(value = "execution(public * com.example.demo.controller.*.*(..))")
public void log() {
}
@Before("log()")
public void doBefore(JoinPoint joinPoint) {
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();
// url
log.info("url={}", request.getRequestURL());
// port
log.info("port={}", request.getRemotePort());
// method
log.info("method={}", request.getMethod());
// ip
log.info("ip={}", request.getRemoteAddr());
// class_method
log.info("class_method={}", joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
// 参数
log.info("args={}", Arrays.toString(joinPoint.getArgs()));
}
@AfterReturning(returning = "object", pointcut = "log()")
public void doAfterReturning(Object object) {
log.info("response={}", object);
}
}
光看此处的代码，我们发现我们根本就没有声明log这个变量，但是我们却使用了它。这就是lombok插件的功能，在这个类上有一个@Slf4j的注解（要使用此注解，lombok插件请安装好），添加这个注解就相当于在此类中添加了如下代码：
import org.slf4j.Logger;
.....
private final Logger log = org.slf4j.LoggerFactory.getLogger(HttpAspect.class);
注意：此处的log对象必须看清楚是org.slf4j.Logger的实例
添加了这段代码的作用是：在执行controller中的方法之前会先执行此类中的方法。
当然，lombok插件的功能远远不止这一点，剩下的就是你自己去探索了。
这里推荐一个关于lombok的使用的学习教程：https://my.oschina.net/u/1024107/blog/889184
Spring AOP学习教程：http://412887952-qq-com.iteye.com/blog/2305333
扩展
最后，为了我们能更好的进行开发，下面我们继续添加一点功能。
1.热部署
pom.xml添加如下代码：
<dependencies>
........
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<fork>true</fork>
</configuration>
</plugin>
.......
</plugins>
</build>
设置：
按：ctrl+shift+a
勾选：
这样，你修改了你项目的代码就不需要点重启，它会自动帮你部署，但是重启有一定的延时，但是比重新点击重启速度快，至于用不用，完全取决于你自己了。(修改static文件中的静态html，css，js等不会重新编译，但是访问时页面依然会改变)
2.添加MybatisCodeHelper插件
这个插件直接下载安装即可（龟速下载，我也很无奈）。作用就是能够快速的在UserMapper.java与UerMapper.xml之间快速跳转.
点击图中标记的图标就可以随意跳转了。
和lombok插件一样，此插件也不仅仅这个功能，剩下的你就慢慢探索去吧！
3.打包
编写完代码之后，我们就需要将项目进行打包了
双击package，项目根目录将会出现一个target目录在此目录下将会有一个.jar文件，这个就是我们需要的已经打包好了的可执行文件。
注意：我们这个项目使用的spring boot版本为1.5.6.RELEASE(此时最新稳定版本)，在运行package时，由于插件也是使用的1.5.6.RELEASE版本，会造成打包失败（具体原因我也不太清楚，可能是这个版本的插件有问题），所以解决办法就是修改插件的版本号，此处改为1.5.4.RELEADSE版本。
ps：一遍一遍调试总结出来的结果，我也很无奈呀=-=
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>1.5.4.RELEASE</version>
<configuration>
<fork>true</fork>
</configuration>
</plugin>
.....
</plugins>
下图标记的地方就是我们需要的jar文件
4.运行
现在只要有这个jar文件，同时Java的环境，就可以运行这个jar包了。打开cmd，运行命令：
java -jar demo.jar
服务就启动了！！！！
当然此命令后面也可以加参数：
java -jar demo.jar --server.port=8888
运行在8888端口号上，实际上就相当于在
application.yml文件中添加如下代码
server:
port: 8888
至于想设置其他的什么参数，我想你应该知道怎么做了吧
最后，我已经将此项目分享到GitHub上了，大家可以去download或者clone：https://github.com/Gitsifu/demo
下面我们在聊聊常见的配置：
server:
port: 8080
context-path: /user
port：设置项目启动的端口号（上面提到了哦！），默认端口号为8080
context-path：设置项目访问的url路径根路径（例如添加了/user则访问链接http://localhost:8080/swagger-ui.html就应该变成这样的http://localhost:8080/user/swagger-ui.html）
。。。。。。此处省略一万字节。。。。。
有关Spring Boot的基础学习下面推荐几篇文章：
微服务开发的入门级框架Spring Boot详解（一）
微服务开发的入门级框架Spring Boot详解（二）
微服务开发的入门级框架Spring Boot详解（三）
微服务开发的入门级框架Spring Boot详解（四）
微服务开发的入门级框架Spring Boot详解（五）
好了，现在整个项目的基本架构已经基本完成了，我也该去陪我女朋友了，各位小伙伴再见咯。
。
。
。
。
哦，对了，我不是没女朋友么，哪来的女朋友陪，哎。。。还是敲我的代码去了。。。
声明：原创文章，欢迎转载，转载请注明出处，谢谢！
