Spring Boot 快速搭建微服务框架详细教程

前言：

springboot是为了简化spring应用的创建、运行、调试、部署等而出现的，使用它可以做到专注于spring应用的开发，而无需过多关注xml的配置。

简单来说，它提供了一堆依赖打包，并已经按照使用习惯解决了依赖问题---习惯大于约定。

spring boot默认使用tomcat作为服务器，使用logback提供日志记录。

spring boot的主要优点：

为所有spring开发者更快的入门
开箱即用，提供各种默认配置来简化项目配置
内嵌式容器简化web项目
没有冗余代码生成和xml配置的要求

技术栈：

java 8
maven
spring-boot
mybatis
redis
lombok
swagger2
jenkins
sonarquber

1、使用maven构建项目

1.1 通过 spring initializr 工具生产基础项目

　　通过访问：http://start.spring.io/ 快速创建spring-boot 的服务框架。

Spring Boot 快速搭建微服务框架详细教程

　　初始化相应信息后，下载压缩包。解压完成后，用idea打开项目，项目的目录结构：

　　 Spring Boot 快速搭建微服务框架详细教程

总体流程：

访问：http://start.spring.io/
选择构建工具maven project、spring boot版本1.3.2以及一些工程基本信息
点击generate project下载项目压缩包

解压项目包，并用ide以maven项目导入，以intellij idea 14为例：

菜单中选择file–>new–>project from existing sources...
选择解压后的项目文件夹，点击ok
点击import project from external model并选择maven，点击next到底为止。
若你的环境有多个版本的jdk，注意到选择java sdk的时候请选择java 7以上的版本

1.2 导入spring-boot 相关依赖

　　项目初始化时，相关依赖如下：

spring-boot-starters：核心模块，包括自动配置支持、日志和yaml
spring-boot-starter-test：测试模块，包括junit、hamcrest、mockito
spring-boot-devtools：用于设置热部署

									<dependency>  <groupid>org.springframework.boot</groupid>

									 <artifactid>spring-boot-starter</artifactid>

									</dependency>

									<dependency>  <groupid>org.springframework.boot</groupid>

									 <artifactid>spring-boot-starter-test</artifactid>

									 <scope>test</scope>

									</dependency>

									<!--热部署-->

									<dependency>  <groupid>org.springframework.boot</groupid>

									 <artifactid>spring-boot-devtools</artifactid>

									 <optional>true</optional>

									</dependency>

　　这里我们需要引入web模块，需要添加：

									<dependency>

									 <groupid>org.springframework.boot</groupid>

									 <artifactid>spring-boot-starter-web</artifactid>

									</dependency>

1.3 启动项目

　　添加首页控制层：

									@restcontroller

									public class indexcontroller {

									 @requestmapping("index")

									 public string index() {

									 return "hello world!";

									 }

									}

　　运行demoapplication中的main方法，启动服务：

Spring Boot 快速搭建微服务框架详细教程

　　　　服务启动后，访问 http://localhost:8080/index ，可以看到页面输出hello world！。

2、整合mybatis

2.1 项目依赖

引入连接mysql的必要依赖mysql-connector-java
引入整合mybatis的核心依赖mybatis-spring-boot-starter
引入tk.mybatis 依赖，实现对实体类的增删改查的代码
引入pagerhelper 依赖，实现分页功能

									<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>

									  <version>5.1.43</version>

									 </dependency> 

									  <dependency>

									  <groupid>tk.mybatis</groupid>

									  <artifactid>mapper-spring-boot-starter</artifactid>

									  <version>1.1.3</version>

									 </dependency>

									 <!--pagehelper-->

									 <dependency>

									  <groupid>com.github.pagehelper</groupid>

									  <artifactid>pagehelper-spring-boot-starter</artifactid>

									  <version>1.1.2</version>

									 </dependency>

2.2 项目配置

　修改resources 下的application.properties文件：

									spring.datasource.url=jdbc:mysql://localhost:3306/test

									spring.datasource.username=root

									spring.datasource.password=root

									spring.datasource.driver-class-name=com.mysql.jdbc.driver

									#实体类扫描包

									mybatis.type-aliases-package=com.jaycekon.demo.model

									#mapper.xml文件扫描目录

									mybatis.mapper-locations=classpath:mapper/*.xml

									#驼峰命名

									mybatis.configuration.mapunderscoretocamelcase=true

									#tkmapper 工具类

									mapper.mappers=com.jaycekon.demo.util.mymapper

									mapper.not-empty=false

									mapper.identity=mysql

									pagehelper.helperdialect=mysql

									pagehelper.reasonable=true

									pagehelper.supportmethodsarguments=true

									pagehelper.params=count=countsql

2.3 单元测试

　　创建实体类，我们引入lombok相关依赖，用于避免数据get set方法的重复创建：

									<dependency>

									 <groupid>org.projectlombok</groupid>

									 <artifactid>lombok</artifactid>

									 <version>1.16.18</version>

									 <scope>provided</scope>

									</dependency>

　　实体类最终的代码如下：

									@data

									@noargsconstructor

									@allargsconstructor

									@accessors(chain = true)

									public class user {

									 private int id;

									 private string username;

									 private string idcard;

									 private string phone;

									 private string password;

									}

　　可以看出，在添加了lombok 之后，我们的java 实体类代码简洁了很多。

　　接下来，我们需要创建usermapper 数据库处理类。由于mymapper 已经帮我们实现了基本的crud操作，因此我们这里并不需要再重写操作，我可以先一个根据用户名查找的方法：

									@mapper

									public interface usermapper extends mymapper<user> {

									 @select("select * from user where username=#{username}")

									 user selectbyname(string username);

									}

									　　mymapper 类位于util 目录下：

									public interface mymapper<t> extends mapper<t>, mysqlmapper<t> {

									}

　　这里需要注意，mymapper 与我们的实体类mapper 不能放在同一个目录。

　　测试类：

									@runwith(springrunner.class)

									@springboottest

									@mapperscan("com.jaycekon.demo.mapper")

									public class usermappertest {

									 @autowired

									 private usermapper mapper;

									 @test

									 public void testinset() {

									 user user = new user(1, "jaycekon","1234","1234","123");

									 int i = mapper.insert(user);

									 assert.assertnotequals(0, i);

									 }

									 @test

									 public void testselect(){

									 user user = mapper.selectbyname("jaycekon");

									 assert.assertnotequals(null,user);

									 }

									}

3、整合redis

3.1 相关依赖

　　spring boot提供的数据访问框架spring data redis基于jedis。可以通过引入 spring-boot-starter-redis 来配置依赖关系。

									<dependency>

									 <groupid>org.springframework.boot</groupid>

									 <artifactid>spring-boot-starter-redis</artifactid>

									</dependency>

3.2 redis 配置

1、spring-boot 连接单机版redis 的配置如下：

									# redis (redisproperties)

									# redis数据库索引（默认为0）

									spring.redis.database=0

									# redis服务器地址

									spring.redis.host=localhost

									# redis服务器连接端口

									spring.redis.port=6379

									# redis服务器连接密码（默认为空）

									spring.redis.password=

									# 连接池最大连接数（使用负值表示没有限制）

									spring.redis.pool.max-active=8

									# 连接池最大阻塞等待时间（使用负值表示没有限制）

									spring.redis.pool.max-wait=-1

									# 连接池中的最大空闲连接

									spring.redis.pool.max-idle=8

									# 连接池中的最小空闲连接

									spring.redis.pool.min-idle=0

									# 连接超时时间（毫秒）

									spring.redis.timeout=0

2、spriig-boot 连接sentinel 哨兵集群配置：

									# redis (redisproperties)

									# redis数据库索引（默认为0）

									spring.redis.database=0

									# redis服务器地址

									#spring.redis.host=localhost

									# redis服务器连接端口

									#spring.redis.port=6379

									# redis服务器连接密码（默认为空）

									spring.redis.password=

									# 连接池最大连接数（使用负值表示没有限制）

									spring.redis.pool.max-active=8

									# 连接池最大阻塞等待时间（使用负值表示没有限制）

									spring.redis.pool.max-wait=-1

									# 连接池中的最大空闲连接

									spring.redis.pool.max-idle=8

									# 连接池中的最小空闲连接

									spring.redis.pool.min-idle=0

									# 连接超时时间（毫秒）

									spring.redis.timeout=0

									#哨兵监听redis server名称

									spring.redis.sentinel.master=cn-test-master

									#哨兵的配置列表

									spring.redis.sentinel.nodes=localhost:26379,localhost:36379,localhost:46379

3.3 redis 操作工具类

　　1、stringredistemplate 工具类

　　　　stringredistemplate 工具类可以解决字符串级别的redis操作。在写好配置后，可以直接通过autowried 就可以注入对象。

									@runwith(springjunit4classrunner.class)

									@springapplicationconfiguration(application.class)

									public class applicationtests {

									 @autowired

									 private stringredistemplate stringredistemplate;

									 @test

									 public void test() throws exception {

									 // 保存字符串

									 stringredistemplate.opsforvalue().set("aaa", "111");

									 assert.assertequals("111", stringredistemplate.opsforvalue().get("aaa"));

									 }

									}

　　2、redistemplate<object,object> 工具类

　　　　可以处理大部分的序列化操作，在这里我封装了一个简化redis工具类，后续可以继续优化。

									@component

									public class rediscomponent {

									 @autowired

									 //操作字符串的template，stringredistemplate是redistemplate的一个子集

									 private stringredistemplate stringredistemplate;

									 private logger logger = loggerfactory.getlogger(rediscomponent.class);

									 @autowired

									 // redistemplate，可以进行所有的操作

									 private redistemplate<object, object> redistemplate;

									 public void set(string key, string value) {

									 valueoperations<string, string> ops = this.stringredistemplate.opsforvalue();

									 boolean bexistent = this.stringredistemplate.haskey(key);

									 if (bexistent) {

									  logger.info("this key is bexistent!");

									 } else {

									  ops.set(key, value);

									 }

									 }

									 public string get(string key) {

									 return this.stringredistemplate.opsforvalue().get(key);

									 }

									 public void del(string key) {

									 this.stringredistemplate.delete(key);

									 }

									 public void sentinelset(string key, object object) {

									 redistemplate.opsforvalue().set(key, json.tojsonstring(object));

									 }

									 public string sentinelget(string key) {

									 return string.valueof(redistemplate.opsforvalue().get(key));

									 }

									}

4、整合swagger2

4.1 添加swagger2 依赖：

									<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>

4.2 创建swagger2 配置类：

在application.java 同级创建一个swagger2 的配置类：

									@configuration

									@enableswagger2

									public class swagger2 {

									 @bean

									 public docket webapi() {

									 return new docket(documentationtype.swagger_2)

									  .groupname("demoapi接口文档")

									  .apiinfo(apiinfo())

									  .select()

									  .apis(requesthandlerselectors.basepackage("com.jaycekon.demo.controller"))

									  .paths(pathselectors.any()).build();

									 }

									 /**

									 swagger2使用说明：

									 @api：用在类上，说明该类的作用

									 @apioperation：用在方法上，说明方法的作用

									 @apiignore：使用该注解忽略这个api

									 @apiimplicitparams：用在方法上包含一组参数说明

									 @apiimplicitparam：用在@apiimplicitparams注解中，指定一个请求参数的各个方面

									 paramtype：参数放在哪个地方

									 header-->请求参数的获取：@requestheader

									 query-->请求参数的获取：@requestparam

									 path（用于restful接口）-->请求参数的获取：@pathvariable

									 body（不常用）

									 form（不常用）

									 name：参数名

									 datatype：参数类型

									 required：参数是否必须传

									 value：参数的意思

									 defaultvalue：参数的默认值

									 @apiresponses：用于表示一组响应

									 @apiresponse：用在@apiresponses中，一般用于表达一个错误的响应信息

									 code：数字，例如400

									 message：信息，例如"请求参数没填好"

									 response：抛出异常的类

									 @apimodel：描述一个model的信息（这种一般用在post创建的时候，使用@requestbody这样的场景，请求参数无法使用@apiimplicitparam注解进行描述的时候）

									 @apimodelproperty：描述一个model的属性

									 */

									 private apiinfo apiinfo() {

									 return new apiinfobuilder()

									  .title("demo使用swagger2构建restful apis")

									  .description("微信打卡服务")

									  .contact(new contact("jaycekon", "http://petstore.swagger.io/v2/swagger.json", "jaycekon@163.com"))

									  .version("1.0")

									  .build();

									 }

									}

4.3 在需要生成api 的接口添加注解:

									@api(tags = "测试用例")

									@restcontroller

									@requestmapping(value="/users") // 通过这里配置使下面的映射都在/users下，可去除

									public class usercontroller {

									 @apioperation(value="获取用户列表", notes="")

									 @requestmapping(value={""}, method= requestmethod.get)

									 public list<user> getuserlist() {

									 return new arraylist<>();

									 }

									 @apioperation(value="创建用户", notes="根据user对象创建用户")

									 @apiimplicitparam(name = "user", value = "用户详细实体user", required = true, datatype = "user")

									 @requestmapping(value="", method=requestmethod.post)

									 public string postuser(@requestbody user user) {

									 return "success";

									 }

									 @apioperation(value="获取用户详细信息", notes="根据url的id来获取用户详细信息")

									 @apiimplicitparam(name = "id", value = "用户id", required = true, datatype = "long")

									 @requestmapping(value="/{id}", method=requestmethod.get)

									 public user getuser(@pathvariable long id) {

									 return new user();

									 }

									 @apioperation(value="更新用户详细信息", notes="根据url的id来指定更新对象，并根据传过来的user信息来更新用户详细信息")

									 @apiimplicitparams({

									  @apiimplicitparam(name = "id", value = "用户id", required = true, datatype = "long"),

									  @apiimplicitparam(name = "user", value = "用户详细实体user", required = true, datatype = "user")

									 })

									 @requestmapping(value="/{id}", method=requestmethod.put)

									 public string putuser(@pathvariable long id, @requestbody user user) {

									 return "success";

									 }

									 @apioperation(value="删除用户", notes="根据url的id来指定删除对象")

									 @apiimplicitparam(name = "id", value = "用户id", required = true, datatype = "long")

									 @requestmapping(value="/{id}", method=requestmethod.delete)

									 public string deleteuser(@pathvariable long id) {

									 return "success";

									 }

									}

完成上述代码添加上，启动spring boot程序，访问：http://localhost:8080/swagger-ui.html
。

就能看到前文所展示的restful api的页面。我们可以再点开具体的api请求，以post类型的/users请求为例，可找到上述代码中我们配置的notes信息以及参数user的描述信息，如下图所示。

Spring Boot 快速搭建微服务框架详细教程

4、接入jenkins&sonarqube

　　　　项目框架搭建好后，我们可以通jenkins 进行项目的自动发版，以及sonarqube 进行代码质量检测。在接入钱，我们需要将项目打包成war包，需要进行以下修改：

1、修改项目打包类型：

									<groupid>com.jaycekon</groupid>

									 <artifactid>demo</artifactid>

									 <version>0.0.1-snapshot</version>

									 <packaging>war</packaging>

2、修改application.java 文件：

									@springbootapplication

									public class demoapplication extends springbootservletinitializer {

									 @override

									 protected springapplicationbuilder configure(springapplicationbuilder application) {

									 return application.sources(demoapplication.class);

									 }

									 public static void main(string[] args) {

									 springapplication.run(demoapplication.class, args);

									 }

									}