从0到1构建一个spring boot + mybatis的项目

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，并创建一个新的项目：

1.png

2.选择Spring Initializr选项，并选择一个SDK，点击Next

2.png

3.填写Group(一般为公司域名反写)和Artifact(项目名)，此项目的管理工具为Maven(当然你也可以使用Gradle)，打包方式 为jar包，java版本为1.8，点击Next

3.png

4.这里选择先添加Web依赖，点击Next

4.png

5.点击Finish

5.png

6.好了，我们的spring boot项目就已经创建好了，我们来看一下项目的结构。对于.mvn mvnw mvnw.cmd这几个文无关紧要，看着烦，可以删除。

6.png

7.我们来运行一下项目，图中点击任意哪个都可以，快捷键为Ctrl+Shift+F10

7.png

8.在控制台中会输出一大串日志信息，你如果看到了下图中的信息，恭喜你项目已经启动成功了

8.png

9.在浏览器访问localhost:8080，你将看到以下信息

9.png

我们在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程序运行起来了。

10.png

二、集成Mybatis

1.我们整理一下我们的项目目录结构：

11.png

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）

12.png

此时Build成功：

13.png

让我们再看一下我们的项目结构：

14.png

多了四个文件，这些就是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.dao.UserMapper;
import com.example.demo.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    private final UserMapper mapper;

    @Autowired
    public UserService(UserMapper mapper) {
        this.mapper = mapper;
    }

    public int add(User user) {
        return mapper.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 {
    private final UserService service;

    @Autowired
    public UserController(UserService service) {
        this.service = service;
    }

    @PostMapping("/add")
    public int add(User user){
        return service.add(user);
    }
}

现在我们运行一下我们的程序

15.png

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我们就可以看到一个调试的界面。

16.png

是不是感觉这界面看起来很爽，很清晰，但是如果只是好看，那就太low了，重点是在于它的功能强大。

填写参数，因为传的参数是User对象，所以需要填的参数都是实体类中的字段。（UserId是自增的，所以不填）点击Try it out!

17.png

Response Body为返回值为1，说明数据库中已经有一条数据插入了，状态码为200，说明请求成功了。

现在我们来看一下我们的数据库中的数据，我们使用idea自带的数据库连接工具

18.png

弹出此界面，填写一些必要的信息，点击Test Connection,如果测试成功，那就点击ok：

19.png

双击user，我们看到了我们之前添加的数据：

20.png

到此，我们的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>

设置：

image.png

按：ctrl+shift+a

image.png
勾选：
image.png

这样，你修改了你项目的代码就不需要点重启，它会自动帮你部署，但是重启有一定的延时，但是比重新点击重启速度快，至于用不用，完全取决于你自己了。(修改static文件中的静态html，css，js等不会重新编译，但是访问时页面依然会改变)

2.添加MybatisCodeHelper插件

这个插件直接下载安装即可（龟速下载，我也很无奈）。作用就是能够快速的在UserMapper.java与UerMapper.xml之间快速跳转.

21.png

点击图中标记的图标就可以随意跳转了。

和lombok插件一样，此插件也不仅仅这个功能，剩下的你就慢慢探索去吧！

3.打包

编写完代码之后，我们就需要将项目进行打包了

22.png

双击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文件

23.png

4.运行

现在只要有这个jar文件，同时Java的环境，就可以运行这个jar包了。打开cmd，运行命令：

java -jar demo.jar

24.png

服务就启动了！！！！

当然此命令后面也可以加参数：

java -jar demo.jar --server.port=8888

25.png
运行在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详解（五）

好了，现在整个项目的基本架构已经基本完成了，我也该去陪我女朋友了，各位小伙伴再见咯。
。
。
。
。
哦，对了，我不是没女朋友么，哪来的女朋友陪，哎。。。还是敲我的代码去了。。。

谁说我没对象，new一个就可以了

声明：原创文章，欢迎转载，转载请注明出处，谢谢！