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

时间:2022-08-28 14:53:03

前言:

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 快速搭建微服务框架详细教程

总体流程:

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

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

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

1.2 导入spring-boot 相关依赖

  项目初始化时,相关依赖如下:

  • spring-boot-starters:核心模块,包括自动配置支持、日志和yaml
  • spring-boot-starter-test:测试模块,包括junit、hamcrest、mockito
  • spring-boot-devtools:用于设置热部署
?
1
2
3
4
5
6
7
8
9
10
11
12
<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模块,需要添加:    

?
1
2
3
4
<dependency>
 <groupid>org.springframework.boot</groupid>
 <artifactid>spring-boot-starter-web</artifactid>
</dependency>

1.3 启动项目

  添加首页控制层:

?
1
2
3
4
5
6
7
8
@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 依赖,实现分页功能     
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<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文件:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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方法的重复创建:     

?
1
2
3
4
5
6
<dependency>
 <groupid>org.projectlombok</groupid>
 <artifactid>lombok</artifactid>
 <version>1.16.18</version>
 <scope>provided</scope>
</dependency>

  实体类最终的代码如下:

?
1
2
3
4
5
6
7
8
9
10
11
@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操作,因此我们这里并不需要再重写操作,我可以先一个根据用户名查找的方法:

?
1
2
3
4
5
6
7
8
@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 不能放在同一个目录。

  测试类:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@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 来配置依赖关系。

?
1
2
3
4
<dependency>
 <groupid>org.springframework.boot</groupid>
 <artifactid>spring-boot-starter-redis</artifactid>
</dependency>

3.2 redis 配置

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 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 哨兵集群配置:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 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 就可以注入对象。

?
1
2
3
4
5
6
7
8
9
10
11
12
@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工具类,后续可以继续优化。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
@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 依赖:

?
1
2
3
4
5
6
7
8
9
10
<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 的配置类:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
@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 的接口添加注解:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
@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、修改项目打包类型:

?
1
2
3
4
<groupid>com.jaycekon</groupid>
 <artifactid>demo</artifactid>
 <version>0.0.1-snapshot</version>
 <packaging>war</packaging>

2、修改application.java 文件:

?
1
2
3
4
5
6
7
8
9
10
@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);
 }
}

在我的上一篇博客,哆啦a梦的传送门,已经讲解了一些基本配置方法,这里为大家讲解一下,接入sonarqube 进行代码质量检测的配置(需要本地安装sonarqube服务)。

首先需要在metadata 中,加入sonarqube 的项目名(新建的命名):

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

 然后在post steps 中选择添加 execute sonarqube scanner:

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

在配置好这两项后,jenkins 在编译文件时,就会执行sonarqube 代码质量检测。

最后,我们可以设置项目在编译完后,执行shell 脚本,进行项目的自动发版:

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

  项目编译完后,会找到项目下的playbook,执行里面的脚本,将我们的项目部署到设定的服务器中。

 源码地址:https://github.com/jaycekon/springbootdemo

总结 :

  本篇文章为大家带来了spring-boot 的架构搭建,主要使用到了目前较为流行的技术。希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对服务器之家网站的支持!

原文链接:http://www.cnblogs.com/jaycekon/p/SpringBoot.html