关于 Spring For All

关于 Spring For All

Spring For All 的一切
最新动态

最新动态

Spring 5 会是咋样呢
Spring Boot

Spring Boot

快速构建并运行 Spring 应用程序
Spring Cloud

Spring Cloud

分布式系统的一套工具,可用于构建微服务
Spring Framework

Spring Framework

提供依赖注入、事务、Web应用、数据访问等模块
Spring Data

Spring Data

提供一致性数据访问模块
Spring Security

Spring Security

提供应用身份验证和授权支持
Spring Batch

Spring Batch

提供高容批处理操作模块
Spring AMQP

Spring AMQP

基于AMQP消息解决方案
Micro Service Arch.

Micro Service Arch.

微服务架构相关
开源项目及视频教程

开源项目及视频教程

做中国最好的 Spring 开源项目及视频教程
小马哥专栏

小马哥专栏

阿里技术布道者,专注 Spring Boot 及微服务

Springboot 实现 Restful 服务,基于 HTTP / JSON 传输

泥瓦匠BYSocket 发表了文章 • 1 个评论 • 952 次浏览 • 2017-05-31 18:43 • 来自相关话题

“怎样的人生才是没有遗憾的人生?我的体会是:
(1)拥有健康;
(2)创造“难忘时刻”;
(3)尽力做好自己,不必改变世界;
(4)活在当下。”
– 《向死而生》李开复
 
基于上一篇《Springboot 整合 Mybatis 的完整 Web 案例》,这边我们着重在 控制层 讲讲。讲讲如何在 Springboot 实现 Restful 服务,基于 HTTP / JSON 传输。
 
一、运行 springboot-restful 工程
git clone 下载工程 springboot-learning-example ,项目地址见 GitHub – https://github.com/JeffLi1993/springboot-learning-example。 
 
下面开始运行工程步骤(Quick Start): 
1.数据库准备
a.创建数据库 springbootdb:$(document).ready(function() {$('pre code').each(function(i, block) { hljs.highlightBlock( block); }); });CREATE DATABASE springbootdb;
 
b.创建表 city :(因为我喜欢徒步)DROP TABLE IF EXISTS `city`;
CREATE TABLE `city` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '城市编号',
`province_id` int(10) unsigned NOT NULL COMMENT '省份编号',
`city_name` varchar(25) DEFAULT NULL COMMENT '城市名称',
`description` varchar(25) DEFAULT NULL COMMENT '描述',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;


 
c.插入数据INSERT city VALUES (1 ,1,'温岭市','BYSocket 的家在温岭。');
2. springboot-restful 工程项目结构介绍
springboot-restful 工程项目结构
 
如下:org.spring.springboot.controller – Controller 层
org.spring.springboot.dao – 数据操作层 DAO
org.spring.springboot.domain – 实体类
org.spring.springboot.service – 业务逻辑层
Application – 应用启动类
application.properties – 应用配置文件,应用启动会自动读取配置

3.改数据库配置
打开 application.properties 文件, 修改相应的数据源配置,比如数据源地址、账号、密码等。(如果不是用 MySQL,自行添加连接驱动 pom,然后修改驱动名配置。) 
 
4.编译工程
在项目根目录 springboot-learning-example,运行 maven 指令:mvn clean install


5.运行工程
右键运行 springboot-restful 工程 Application 应用启动类的 main 函数。
用 postman 工具可以如下操作,
根据 ID,获取城市信息
GET http://127.0.0.1:8080/api/city/1 





获取城市列表
GET http://127.0.0.1:8080/api/city





 
新增城市信息
POST http://127.0.0.1:8080/api/city




 
更新城市信息
PUT http://127.0.0.1:8080/api/city




 
删除城市信息
DELETE http://127.0.0.1:8080/api/city/2 






二、springboot-restful 工程控制层实现详解
 
1.什么是 REST?
REST 是属于 WEB 自身的一种架构风格,是在 HTTP 1.1 规范下实现的。Representational State Transfer 全称翻译为表现层状态转化。Resource:资源。比如 newsfeed;
Representational:表现形式,比如用JSON,富文本等;
State Transfer:状态变化。通过HTTP 动作实现。

理解 REST ,要明白五个关键要素:资源(Resource)
资源的表述(Representation)
状态转移(State Transfer)
统一接口(Uniform Interface)
超文本驱动(Hypertext Driven)

 6 个主要特性:面向资源(Resource Oriented)
可寻址(Addressability)
连通性(Connectedness)
无状态(Statelessness)
统一接口(Uniform Interface)
超文本驱动(Hypertext Driven)
 
具体这里就不一一展开,详见 http://www.infoq.com/cn/articles/understanding-restful-style 
 
 2.Spring 对 REST 支持实现
CityRestController.java 城市 Controller 实现 Restful HTTP 服务public class CityRestController {

@Autowired
private CityService cityService;

@RequestMapping(value = "/api/city/{id}", method = RequestMethod.GET)
public City findOneCity(@PathVariable("id") Long id) {
return cityService.findCityById(id);
}

@RequestMapping(value = "/api/city", method = RequestMethod.GET)
public List<City> findAllCity() {
return cityService.findAllCity();
}

@RequestMapping(value = "/api/city", method = RequestMethod.POST)
public void createCity(@RequestBody City city) {
cityService.saveCity(city);
}

@RequestMapping(value = "/api/city", method = RequestMethod.PUT)
public void modifyCity(@RequestBody City city) {
cityService.updateCity(city);
}

@RequestMapping(value = "/api/city/{id}", method = RequestMethod.DELETE)
public void modifyCity(@PathVariable("id") Long id) {
cityService.deleteCity(id);
}
}
具体 Service 、dao 层实现看代码
GitHub https://github.com/JeffLi1993/ ... stful 
 
代码详解:
@RequestMapping 处理请求地址映射。method – 指定请求的方法类型:POST/GET/DELETE/PUT 等
value – 指定实际的请求地址
consumes – 指定处理请求的提交内容类型,例如 Content-Type 头部设置application/json, text/html
produces – 指定返回的内容类型@PathVariable URL 映射时,用于绑定请求参数到方法参数
@RequestBody 这里注解用于读取请求体 boy 的数据,通过 HttpMessageConverter 解析绑定到对象中 
 
3.HTTP 知识补充
 GET 请求获取Request-URI所标识的资源
POST 在Request-URI所标识的资源后附加新的数据
HEAD 请求获取由Request-URI所标识的资源的响应消息报头
PUT 请求服务器存储一个资源,并用Request-URI作为其标识
DELETE 请求服务器删除Request-URI所标识的资源
TRACE 请求服务器回送收到的请求信息,主要用于测试或诊断
CONNECT 保留将来使用
OPTIONS
 
请求查询服务器的性能,或者查询与资源相关的选项和需求详情请看《JavaEE 要懂的小事:一、图解Http协议》 

三、小结
Springboot 实现 Restful 服务,基于 HTTP / JSON 传输,适用于前后端分离。
这只是个小demo,没有加入bean validation这种校验。还有各种业务场景。
 
本文作者: 泥瓦匠
原文链接: http://www.bysocket.com
版权归作者所有,转载请注明出处






  查看全部
“怎样的人生才是没有遗憾的人生?我的体会是:
(1)拥有健康;
(2)创造“难忘时刻”;
(3)尽力做好自己,不必改变世界;
(4)活在当下。”
– 《向死而生》李开复
 
基于上一篇《Springboot 整合 Mybatis 的完整 Web 案例》,这边我们着重在 控制层 讲讲。讲讲如何在 Springboot 实现 Restful 服务,基于 HTTP / JSON 传输。
 
一、运行 springboot-restful 工程
git clone 下载工程 springboot-learning-example ,项目地址见 GitHub – https://github.com/JeffLi1993/springboot-learning-example。 
 
下面开始运行工程步骤(Quick Start): 
1.数据库准备
a.创建数据库 springbootdb:
CREATE DATABASE springbootdb;

 
b.创建表 city :(因为我喜欢徒步)
DROP TABLE IF EXISTS  `city`;
CREATE TABLE `city` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '城市编号',
`province_id` int(10) unsigned NOT NULL COMMENT '省份编号',
`city_name` varchar(25) DEFAULT NULL COMMENT '城市名称',
`description` varchar(25) DEFAULT NULL COMMENT '描述',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;


 
c.插入数据
INSERT city VALUES (1 ,1,'温岭市','BYSocket 的家在温岭。');

2. springboot-restful 工程项目结构介绍
springboot-restful 工程项目结构
 
如下:
org.spring.springboot.controller – Controller 层
org.spring.springboot.dao – 数据操作层 DAO
org.spring.springboot.domain – 实体类
org.spring.springboot.service – 业务逻辑层
Application – 应用启动类
application.properties – 应用配置文件,应用启动会自动读取配置


3.改数据库配置
打开 application.properties 文件, 修改相应的数据源配置,比如数据源地址、账号、密码等。(如果不是用 MySQL,自行添加连接驱动 pom,然后修改驱动名配置。) 
 
4.编译工程
在项目根目录 springboot-learning-example,运行 maven 指令:
mvn clean install 


5.运行工程
右键运行 springboot-restful 工程 Application 应用启动类的 main 函数。
用 postman 工具可以如下操作,
根据 ID,获取城市信息
GET http://127.0.0.1:8080/api/city/1 
r1.png


获取城市列表
GET http://127.0.0.1:8080/api/city

r2.png

 
新增城市信息
POST http://127.0.0.1:8080/api/city
r3.png

 
更新城市信息
PUT http://127.0.0.1:8080/api/city
r4.png

 
删除城市信息
DELETE http://127.0.0.1:8080/api/city/2 
r5.png



二、springboot-restful 工程控制层实现详解
 
1.什么是 REST?
REST 是属于 WEB 自身的一种架构风格,是在 HTTP 1.1 规范下实现的。Representational State Transfer 全称翻译为表现层状态转化。
Resource:资源。比如 newsfeed;
Representational:表现形式,比如用JSON,富文本等;
State Transfer:状态变化。通过HTTP 动作实现。


理解 REST ,要明白五个关键要素:
资源(Resource)
资源的表述(Representation)
状态转移(State Transfer)
统一接口(Uniform Interface)
超文本驱动(Hypertext Driven)


 6 个主要特性:
面向资源(Resource Oriented)
可寻址(Addressability)
连通性(Connectedness)
无状态(Statelessness)
统一接口(Uniform Interface)
超文本驱动(Hypertext Driven)

 
具体这里就不一一展开,详见 http://www.infoq.com/cn/articles/understanding-restful-style 
 
 2.Spring 对 REST 支持实现
CityRestController.java 城市 Controller 实现 Restful HTTP 服务
public class CityRestController {

@Autowired
private CityService cityService;

@RequestMapping(value = "/api/city/{id}", method = RequestMethod.GET)
public City findOneCity(@PathVariable("id") Long id) {
return cityService.findCityById(id);
}

@RequestMapping(value = "/api/city", method = RequestMethod.GET)
public List<City> findAllCity() {
return cityService.findAllCity();
}

@RequestMapping(value = "/api/city", method = RequestMethod.POST)
public void createCity(@RequestBody City city) {
cityService.saveCity(city);
}

@RequestMapping(value = "/api/city", method = RequestMethod.PUT)
public void modifyCity(@RequestBody City city) {
cityService.updateCity(city);
}

@RequestMapping(value = "/api/city/{id}", method = RequestMethod.DELETE)
public void modifyCity(@PathVariable("id") Long id) {
cityService.deleteCity(id);
}
}

具体 Service 、dao 层实现看代码
GitHub https://github.com/JeffLi1993/ ... stful 
 
代码详解:
@RequestMapping 处理请求地址映射。method – 指定请求的方法类型:POST/GET/DELETE/PUT 等
value – 指定实际的请求地址
consumes – 指定处理请求的提交内容类型,例如 Content-Type 头部设置application/json, text/html
produces – 指定返回的内容类型@PathVariable URL 映射时,用于绑定请求参数到方法参数
@RequestBody 这里注解用于读取请求体 boy 的数据,通过 HttpMessageConverter 解析绑定到对象中 
 
3.HTTP 知识补充
 
GET            请求获取Request-URI所标识的资源
POST 在Request-URI所标识的资源后附加新的数据
HEAD 请求获取由Request-URI所标识的资源的响应消息报头
PUT 请求服务器存储一个资源,并用Request-URI作为其标识
DELETE 请求服务器删除Request-URI所标识的资源
TRACE 请求服务器回送收到的请求信息,主要用于测试或诊断
CONNECT 保留将来使用
OPTIONS

 
请求查询服务器的性能,或者查询与资源相关的选项和需求详情请看《JavaEE 要懂的小事:一、图解Http协议》 

三、小结
Springboot 实现 Restful 服务,基于 HTTP / JSON 传输,适用于前后端分离。
这只是个小demo,没有加入bean validation这种校验。还有各种业务场景。
 
本文作者: 泥瓦匠
原文链接: http://www.bysocket.com
版权归作者所有,转载请注明出处

Spring4all.jpg


 

SpringBoot 整合 Mybatis 的完整 Web 案例

泥瓦匠BYSocket 发表了文章 • 17 个评论 • 1536 次浏览 • 2017-05-28 17:28 • 来自相关话题

推荐一本书《腾讯传》。
 
新年第一篇 Springboot 技术文诞生。泥瓦匠准备写写 Springboot 相关最佳实践。一方面总结下一些 Springboot 相关,一方面和大家交流交流 Springboot 框架。
现在业界互联网流行的数据操作层框架 Mybatis,下面详解下 Springboot 如何整合 Mybatis 。
这边没有使用 Mybatis Annotation 这种,是使用 xml 配置 SQL。因为我觉得 SQL 和业务代码应该隔离,方便和 DBA 校对 SQL。二者 XML 对较长的 SQL 比较清晰。
 
一、运行 springboot-mybatis 工程
git clone 下载工程 springboot-learning-example ,项目地址见 springboot-learning-example。
 
下面开始运行工程步骤(Quick Start):

1.数据库准备
a.创建数据库 springbootdb:CREATE DATABASE springbootdb;


b.创建表 city :(因为我喜欢徒步)
DROP TABLE IF EXISTS `city`;
CREATE TABLE `city` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '城市编号',
`province_id` int(10) unsigned NOT NULL COMMENT '省份编号',
`city_name` varchar(25) DEFAULT NULL COMMENT '城市名称',
`description` varchar(25) DEFAULT NULL COMMENT '描述',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
 
c.插入数据
INSERT city VALUES (1 ,1,'温岭市','BYSocket 的家在温岭。');

2. 项目结构介绍
项目结构如下:
org.spring.springboot.controller – Controller 层
org.spring.springboot.dao – 数据操作层 DAO
org.spring.springboot.domain – 实体类
org.spring.springboot.service – 业务逻辑层
Application – 应用启动类
application.properties – 应用配置文件,应用启动会自动读取配置
 
3.改数据库配置
打开 application.properties 文件, 修改相应的数据源配置,比如数据源地址、账号、密码等。(如果不是用 MySQL,自行添加连接驱动 pom,然后修改驱动名配置。)

4.编译工程
在项目根目录 springboot-learning-example,运行 maven 指令:mvn clean install
 
5.运行工程
 
右键运行 Application 应用启动类的 main 函数,然后在浏览器访问:
http://localhost:8080/api/city?cityName=温岭市 
 
可以看到返回的 JSON 结果:{
"id": 1,
"provinceId": 1,
"cityName": "温岭市",
"description": "我的家在温岭。"
}
 
 
二、springboot-mybatis 工程配置详解
 
1.pom 添加 Mybatis 依赖
<!-- Spring Boot Mybatis 依赖 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>${mybatis-spring-boot}</version>
</dependency>

整个工程的 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/ma ... gt%3B
<modelVersion>4.0.0</modelVersion>

<groupId>springboot</groupId>
<artifactId>springboot-mybatis</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>springboot-mybatis :: 整合 Mybatis Demo</name>

<!-- Spring Boot 启动父依赖 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.1.RELEASE</version>
</parent>

<properties>
<mybatis-spring-boot>1.2.0</mybatis-spring-boot>
<mysql-connector>5.1.39</mysql-connector>
</properties>

<dependencies>

<!-- Spring Boot Web 依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- Spring Boot Test 依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>

<!-- Spring Boot Mybatis 依赖 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>${mybatis-spring-boot}</version>
</dependency>

<!-- MySQL 连接驱动依赖 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql-connector}</version>
</dependency>

<!-- Junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
</project>
 
 
2.在 application.properties 应用配置文件,增加 Mybatis 相关配置## Mybatis 配置
mybatis.typeAliasesPackage=org.spring.springboot.domain
mybatis.mapperLocations=classpath:mapper/*.xml
 
mybatis.typeAliasesPackage 配置为 org.spring.springboot.domain,指向实体类包路径。
mybatis.mapperLocations 配置为 classpath 路径下 mapper 包下,* 代表会扫描所有 xml 文件。
 
mybatis 其他配置相关详解如下:
mybatis.config = mybatis 配置文件名称
mybatis.mapperLocations = mapper xml 文件地址
mybatis.typeAliasesPackage = 实体类包路径
mybatis.typeHandlersPackage = type handlers 处理器包路径
mybatis.check-config-location = 检查 mybatis 配置是否存在,一般命名为 mybatis-config.xml
mybatis.executorType = 执行模式。默认是 SIMPLE3.在 Application 应用启动类添加注解 MapperScan

Application.java 代码如下:/**
* Spring Boot 应用启动类
*
* Created by bysocket on 16/4/26.
*/
// Spring Boot 应用的标识
@SpringBootApplication
// mapper 接口类扫描包配置
@MapperScan("org.spring.springboot.dao")
public class Application {

public static void main(String[] args) {
// 程序启动入口
// 启动嵌入式的 Tomcat 并初始化 Spring 环境及其各 Spring 组件
SpringApplication.run(Application.class,args);
}
}
 
mapper 接口类扫描包配置注解 MapperScan :用这个注解可以注册 Mybatis mapper 接口类。

4.添加相应的 City domain类、CityDao mapper接口类
 
City.java:/**
* 城市实体类
*
* Created by bysocket on 07/02/2017.
*/
public class City {

/**
* 城市编号
*/
private Long id;

/**
* 省份编号
*/
private Long provinceId;

/**
* 城市名称
*/
private String cityName;

/**
* 描述
*/
private String description;

public Long getId() {
return id;
}

public void setId(Long id) {
this.id = id;
}

public Long getProvinceId() {
return provinceId;
}

public void setProvinceId(Long provinceId) {
this.provinceId = provinceId;
}

public String getCityName() {
return cityName;
}

public void setCityName(String cityName) {
this.cityName = cityName;
}

public String getDescription() {
return description;
}

public void setDescription(String description) {
this.description = description;
}
}
 
CityDao.java:/**
* 城市 DAO 接口类
*
* Created by bysocket on 07/02/2017.
*/
public interface CityDao {

/**
* 根据城市名称,查询城市信息
*
* @param cityName 城市名
*/
City findByName(@Param("cityName") String cityName);
}
 
其他不明白的,可以 git clone 下载工程 springboot-learning-example ,工程代码注解很详细。 https://github.com/JeffLi1993/springboot-learning-example。 
 
三、其他
 
利用 Mybatis-generator自动生成代码 http://www.cnblogs.com/yjmyzz/p/4210554.html
Mybatis 通用 Mapper3 https://github.com/abel533/Mapper
Mybatis 分页插件 PageHelper https://github.com/pagehelper/Mybatis-PageHelper 

本文作者: 泥瓦匠
原文链接: http://www.bysocket.com/?p=1610 
版权归作者所有,转载请注明出处 查看全部
推荐一本书《腾讯传》。
 
新年第一篇 Springboot 技术文诞生。泥瓦匠准备写写 Springboot 相关最佳实践。一方面总结下一些 Springboot 相关,一方面和大家交流交流 Springboot 框架。
现在业界互联网流行的数据操作层框架 Mybatis,下面详解下 Springboot 如何整合 Mybatis 。
这边没有使用 Mybatis Annotation 这种,是使用 xml 配置 SQL。因为我觉得 SQL 和业务代码应该隔离,方便和 DBA 校对 SQL。二者 XML 对较长的 SQL 比较清晰。
 
一、运行 springboot-mybatis 工程
git clone 下载工程 springboot-learning-example ,项目地址见 springboot-learning-example
 
下面开始运行工程步骤(Quick Start):

1.数据库准备
a.创建数据库 springbootdb:
CREATE DATABASE springbootdb;


b.创建表 city :(因为我喜欢徒步)
DROP TABLE IF EXISTS  `city`;
CREATE TABLE `city` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '城市编号',
`province_id` int(10) unsigned NOT NULL COMMENT '省份编号',
`city_name` varchar(25) DEFAULT NULL COMMENT '城市名称',
`description` varchar(25) DEFAULT NULL COMMENT '描述',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

 
c.插入数据
INSERT city VALUES (1 ,1,'温岭市','BYSocket 的家在温岭。');

2. 项目结构介绍
项目结构如下:
org.spring.springboot.controller – Controller 层
org.spring.springboot.dao – 数据操作层 DAO
org.spring.springboot.domain – 实体类
org.spring.springboot.service – 业务逻辑层
Application – 应用启动类
application.properties – 应用配置文件,应用启动会自动读取配置

 
3.改数据库配置
打开 application.properties 文件, 修改相应的数据源配置,比如数据源地址、账号、密码等。(如果不是用 MySQL,自行添加连接驱动 pom,然后修改驱动名配置。)

4.编译工程
在项目根目录 springboot-learning-example,运行 maven 指令:
mvn clean install

 
5.运行工程
 
右键运行 Application 应用启动类的 main 函数,然后在浏览器访问:
http://localhost:8080/api/city?cityName=温岭市 
 
可以看到返回的 JSON 结果:
{
"id": 1,
"provinceId": 1,
"cityName": "温岭市",
"description": "我的家在温岭。"
}

 
 
二、springboot-mybatis 工程配置详解
 
1.pom 添加 Mybatis 依赖

<!-- Spring Boot Mybatis 依赖 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>${mybatis-spring-boot}</version>
</dependency>


整个工程的 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/ma ... gt%3B
<modelVersion>4.0.0</modelVersion>

<groupId>springboot</groupId>
<artifactId>springboot-mybatis</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>springboot-mybatis :: 整合 Mybatis Demo</name>

<!-- Spring Boot 启动父依赖 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.1.RELEASE</version>
</parent>

<properties>
<mybatis-spring-boot>1.2.0</mybatis-spring-boot>
<mysql-connector>5.1.39</mysql-connector>
</properties>

<dependencies>

<!-- Spring Boot Web 依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- Spring Boot Test 依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>

<!-- Spring Boot Mybatis 依赖 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>${mybatis-spring-boot}</version>
</dependency>

<!-- MySQL 连接驱动依赖 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql-connector}</version>
</dependency>

<!-- Junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
</project>

 
 
2.在 application.properties 应用配置文件,增加 Mybatis 相关配置
## Mybatis 配置
mybatis.typeAliasesPackage=org.spring.springboot.domain
mybatis.mapperLocations=classpath:mapper/*.xml

 
mybatis.typeAliasesPackage 配置为 org.spring.springboot.domain,指向实体类包路径。
mybatis.mapperLocations 配置为 classpath 路径下 mapper 包下,* 代表会扫描所有 xml 文件。
 
mybatis 其他配置相关详解如下:
mybatis.config = mybatis 配置文件名称
mybatis.mapperLocations = mapper xml 文件地址
mybatis.typeAliasesPackage = 实体类包路径
mybatis.typeHandlersPackage = type handlers 处理器包路径
mybatis.check-config-location = 检查 mybatis 配置是否存在,一般命名为 mybatis-config.xml
mybatis.executorType = 执行模式。默认是 SIMPLE3.在 Application 应用启动类添加注解 MapperScan


Application.java 代码如下:
/**
* Spring Boot 应用启动类
*
* Created by bysocket on 16/4/26.
*/
// Spring Boot 应用的标识
@SpringBootApplication
// mapper 接口类扫描包配置
@MapperScan("org.spring.springboot.dao")
public class Application {

public static void main(String[] args) {
// 程序启动入口
// 启动嵌入式的 Tomcat 并初始化 Spring 环境及其各 Spring 组件
SpringApplication.run(Application.class,args);
}
}

 
mapper 接口类扫描包配置注解 MapperScan :用这个注解可以注册 Mybatis mapper 接口类。

4.添加相应的 City domain类、CityDao mapper接口类
 
City.java:
/**
* 城市实体类
*
* Created by bysocket on 07/02/2017.
*/
public class City {

/**
* 城市编号
*/
private Long id;

/**
* 省份编号
*/
private Long provinceId;

/**
* 城市名称
*/
private String cityName;

/**
* 描述
*/
private String description;

public Long getId() {
return id;
}

public void setId(Long id) {
this.id = id;
}

public Long getProvinceId() {
return provinceId;
}

public void setProvinceId(Long provinceId) {
this.provinceId = provinceId;
}

public String getCityName() {
return cityName;
}

public void setCityName(String cityName) {
this.cityName = cityName;
}

public String getDescription() {
return description;
}

public void setDescription(String description) {
this.description = description;
}
}

 
CityDao.java:
/**
* 城市 DAO 接口类
*
* Created by bysocket on 07/02/2017.
*/
public interface CityDao {

/**
* 根据城市名称,查询城市信息
*
* @param cityName 城市名
*/
City findByName(@Param("cityName") String cityName);
}

 
其他不明白的,可以 git clone 下载工程 springboot-learning-example ,工程代码注解很详细。 https://github.com/JeffLi1993/springboot-learning-example。 
 
三、其他
 
利用 Mybatis-generator自动生成代码 http://www.cnblogs.com/yjmyzz/p/4210554.html
Mybatis 通用 Mapper3 https://github.com/abel533/Mapper
Mybatis 分页插件 PageHelper https://github.com/pagehelper/Mybatis-PageHelper 

本文作者: 泥瓦匠
原文链接: http://www.bysocket.com/?p=1610 
版权归作者所有,转载请注明出处

Spring Boot Actuator监控端点小结

程序猿DD 发表了文章 • 0 个评论 • 377 次浏览 • 2017-05-28 15:45 • 来自相关话题

在Spring Boot的众多Starter POMs中有一个特殊的模块,它不同于其他模块那样大多用于开发业务功能或是连接一些其他外部资源。它完全是一个用于暴露自身信息的模块,所以很明显,它的主要作用是用于监控与管理,它就是:`spring-boot-starter-actuator`。

`spring-boot-starter-actuator`模块的实现对于实施微服务的中小团队来说,可以有效地减少监控系统在采集应用指标时的开发量。当然,它也并不是万能的,有时候我们也需要对其做一些简单的扩展来帮助我们实现自身系统个性化的监控需求。下面,在本文中,我们将详解的介绍一些关于`spring-boot-starter-actuator`模块的内容,包括它的原生提供的端点以及一些常用的扩展和配置方式。

初识Actuator

下面,我们可以通过对快速入门中实现的Spring Boot应用增加`spring-boot-starter-actuator`模块功能,来对它有一个直观的认识。

在现有的Spring Boot应用中引入该模块非常简单,只需要在`pom.xml`的`dependencies`节点中,新增`spring-boot-starter-actuator`的依赖即可,具体如下:<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
通过增加该依赖之后,重新启动应用。此时,我们可以在控制台中看到如下图所示的输出:



上图显示了一批端点定义,这些端点并非我们自己在程序中创建,而是由`spring-boot-starter-actuator`模块根据应用依赖和配置自动创建出来的监控和管理端点。通过这些端点,我们可以实时的获取应用的各项监控指标,比如:访问`/health`端点,我们可以获得如下返回的应用健康信息:{
"status": "UP",
"diskSpace": {
"status": "UP",
"total": 491270434816,
"free": 383870214144,
"threshold": 10485760
}
}
原生端点

通过在快速入门示例中添加`spring-boot-starter-actuator`模块,我们已经对它有了一个初步的认识。接下来,我们详细介绍一下`spring-boot-starter-actuator`模块中已经实现的一些原生端点。如果根据端点的作用来说,我们可以原生端点分为三大类:

- 应用配置类:获取应用程序中加载的应用配置、环境变量、自动化配置报告等与Spring Boot应用密切相关的配置类信息。
- 度量指标类:获取应用程序运行过程中用于监控的度量指标,比如:内存信息、线程池信息、HTTP请求统计等。
- 操作控制类:提供了对应用的关闭等操作类功能。

下面我们来详细了解一下这三类端点都分别可以为我们提供怎么样的有用信息和强大功能,以及我们如何去扩展和配置它们。

应用配置类

由于Spring Boot为了改善传统Spring应用繁杂的配置内容,采用了包扫描和自动化配置的机制来加载原本集中于xml文件中的各项内容。虽然这样的做法,让我们的代码变得非常简洁,但是整个应用的实例创建和依赖关系等信息都被离散到了各个配置类的注解上,这使得我们分析整个应用中资源和实例的各种关系变得非常的困难。而这类端点就可以帮助我们轻松的获取一系列关于Spring 应用配置内容的详细报告,比如:自动化配置的报告、Bean创建的报告、环境属性的报告等。

- /autoconfig:该端点用来获取应用的自动化配置报告,其中包括所有自动化配置的候选项。同时还列出了每个候选项自动化配置的各个先决条件是否满足。所以,该端点可以帮助我们方便的找到一些自动化配置为什么没有生效的具体原因。该报告内容将自动化配置内容分为两部分:

  - `positiveMatches`中返回的是条件匹配成功的自动化配置
  - `negativeMatches`中返回的是条件匹配不成功的自动化配置 {
"positiveMatches": { // 条件匹配成功的
"EndpointWebMvcAutoConfiguration": [
{
"condition": "OnClassCondition",
"message": "@ConditionalOnClass classes found: javax.servlet.Servlet,org.springframework.web.servlet.DispatcherServlet"
},
{
"condition": "OnWebApplicationCondition",
"message": "found web application StandardServletEnvironment"
}
],
...
},
"negativeMatches": { // 条件不匹配成功的
"HealthIndicatorAutoConfiguration.DataSourcesHealthIndicatorConfiguration": [
{
"condition": "OnClassCondition",
"message": "required @ConditionalOnClass classes not found: org.springframework.jdbc.core.JdbcTemplate"
}
],
...
}
}
从如上示例中我们可以看到,每个自动化配置候选项中都有一系列的条件,比如上面没有成功匹配的`HealthIndicatorAutoConfiguration.DataSourcesHealthIndicatorConfiguration`配置,它的先决条件就是需要在工程中包含`org.springframework.jdbc.core.JdbcTemplate`类,由于我们没有引入相关的依赖,它就不会执行自动化配置内容。所以,当我们发现有一些期望的配置没有生效时,就可以通过该端点来查看没有生效的具体原因。

- /beans:该端点用来获取应用上下文中创建的所有Bean。[
{
"context": "hello:dev:8881",
"parent": null,
"beans": [
{
"bean": "org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration$DispatcherServletConfiguration",
"scope": "singleton",
"type": "org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration$DispatcherServletConfiguration$$EnhancerBySpringCGLIB$$3440282b",
"resource": "null",
"dependencies": [
"serverProperties",
"spring.mvc.CONFIGURATION_PROPERTIES",
"multipartConfigElement"
]
},
{
"bean": "dispatcherServlet",
"scope": "singleton",
"type": "org.springframework.web.servlet.DispatcherServlet",
"resource": "class path resource [org/springframework/boot/autoconfigure/web/DispatcherServletAutoConfiguration$DispatcherServletConfiguration.class]",
"dependencies":
}
]
}
]
  如上示例中,我们可以看到在每个bean中都包含了下面这几个信息:

  - bean:Bean的名称
  - scope:Bean的作用域
  - type:Bean的Java类型
  - reource:class文件的具体路径
  - dependencies:依赖的Bean名称

- /configprops:该端点用来获取应用中配置的属性信息报告。从下面该端点返回示例的片段中,我们看到返回了关于该短信的配置信息,`prefix`属性代表了属性的配置前缀,`properties`代表了各个属性的名称和值。所以,我们可以通过该报告来看到各个属性的配置路径,比如我们要关闭该端点,就可以通过使用`endpoints.configprops.enabled=false`来完成设置。 {
"configurationPropertiesReportEndpoint": {
"prefix": "endpoints.configprops",
"properties": {
"id": "configprops",
"sensitive": true,
"enabled": true
}
},
...
}
- /env:该端点与`/configprops`不同,它用来获取应用所有可用的环境属性报告。包括:环境变量、JVM属性、应用的配置配置、命令行中的参数。从下面该端点返回的示例片段中,我们可以看到它不仅返回了应用的配置属性,还返回了系统属性、环境变量等丰富的配置信息,其中也包括了应用还没有没有使用的配置。所以它可以帮助我们方便地看到当前应用可以加载的配置信息,并配合`@ConfigurationProperties`注解将它们引入到我们的应用程序中来进行使用。另外,为了配置属性的安全,对于一些类似密码等敏感信息,该端点都会进行隐私保护,但是我们需要让属性名中包含:password、secret、key这些关键词,这样该端点在返回它们的时候会使用`*`来替代实际的属性值。 {
"profiles": [
"dev"
],
"server.ports": {
"local.server.port": 8881
},
"servletContextInitParams": {

},
"systemProperties": {
"idea.version": "2016.1.3",
"java.runtime.name": "Java(TM) SE Runtime Environment",
"sun.boot.library.path": "C:\\Program Files\\Java\\jdk1.8.0_91\\jre\\bin",
"java.vm.version": "25.91-b15",
"java.vm.vendor": "Oracle Corporation",
...
},
"systemEnvironment": {
"configsetroot": "C:\\WINDOWS\\ConfigSetRoot",
"RABBITMQ_BASE": "E:\\tools\\rabbitmq",
...
},
"applicationConfig: [classpath:/application-dev.properties]": {
"server.port": "8881"
},
"applicationConfig: [classpath:/application.properties]": {
"server.port": "8885",
"spring.profiles.active": "dev",
"info.app.name": "spring-boot-hello",
"info.app.version": "v1.0.0",
"spring.application.name": "hello"
}
}
- /mappings:该端点用来返回所有Spring MVC的控制器映射关系报告。从下面的示例片段中,我们可以看该报告的信息与我们在启用Spring MVC的Web应用时输出的日志信息类似,其中`bean`属性标识了该映射关系的请求处理器,`method`属性标识了该映射关系的具体处理类和处理函数。{
"/webjars/**": {
"bean": "resourceHandlerMapping"
},
"/**": {
"bean": "resourceHandlerMapping"
},
"/**/favicon.ico": {
"bean": "faviconHandlerMapping"
},
"{[/hello]}": {
"bean": "requestMappingHandlerMapping",
"method": "public java.lang.String com.didispace.web.HelloController.index()"
},
"{[/mappings || /mappings.json],methods=[GET],produces=[application/json]}": {
"bean": "endpointHandlerMapping",
"method": "public java.lang.Object org.springframework.boot.actuate.endpoint.mvc.EndpointMvcAdapter.invoke()"
},
...
}
- /info:该端点用来返回一些应用自定义的信息。默认情况下,该端点只会返回一个空的json内容。我们可以在`application.properties`配置文件中通过`info`前缀来设置一些属性,比如下面这样: info.app.name=spring-boot-hello
info.app.version=v1.0.0
  再访问`/info`端点,我们可以得到下面的返回报告,其中就包含了上面我们在应用自定义的两个参数。 {
"app": {
"name": "spring-boot-hello",
"version": "v1.0.0"
}
}
度量指标类

上面我们所介绍的应用配置类端点所提供的信息报告在应用启动的时候都已经基本确定了其返回内容,可以说是一个静态报告。而度量指标类端点提供的报告内容则是动态变化的,这些端点提供了应用程序在运行过程中的一些快照信息,比如:内存使用情况、HTTP请求统计、外部资源指标等。这些端点对于我们构建微服务架构中的监控系统非常有帮助,由于Spring Boot应用自身实现了这些端点,所以我们可以很方便地利用它们来收集我们想要的信息,以制定出各种自动化策略。下面,我们就来分别看看这些强大的端点功能。

- /metrics:该端点用来返回当前应用的各类重要度量指标,比如:内存信息、线程信息、垃圾回收信息等。 {
"mem": 541305,
"mem.free": 317864,
"processors": 8,
"instance.uptime": 33376471,
"uptime": 33385352,
"systemload.average": -1,
"heap.committed": 476672,
"heap.init": 262144,
"heap.used": 158807,
"heap": 3701248,
"nonheap.committed": 65856,
"nonheap.init": 2496,
"nonheap.used": 64633,
"nonheap": 0,
"threads.peak": 22,
"threads.daemon": 20,
"threads.totalStarted": 26,
"threads": 22,
"classes": 7669,
"classes.loaded": 7669,
"classes.unloaded": 0,
"gc.ps_scavenge.count": 7,
"gc.ps_scavenge.time": 118,
"gc.ps_marksweep.count": 2,
"gc.ps_marksweep.time": 234,
"httpsessions.max": -1,
"httpsessions.active": 0,
"gauge.response.beans": 55,
"gauge.response.env": 10,
"gauge.response.hello": 5,
"gauge.response.metrics": 4,
"gauge.response.configprops": 153,
"gauge.response.star-star": 5,
"counter.status.200.beans": 1,
"counter.status.200.metrics": 3,
"counter.status.200.configprops": 1,
"counter.status.404.star-star": 2,
"counter.status.200.hello": 11,
"counter.status.200.env": 1
}
  从上面的示例中,我们看到有这些重要的度量值:

  - 系统信息:包括处理器数量`processors`、运行时间`uptime`和`instance.uptime`、系统平均负载`systemload.average`。
  - `mem.*`:内存概要信息,包括分配给应用的总内存数量以及当前空闲的内存数量。这些信息来自`java.lang.Runtime`。
  - `heap.*`:堆内存使用情况。这些信息来自`java.lang.management.MemoryMXBean`接口中`getHeapMemoryUsage`方法获取的`java.lang.management.MemoryUsage`。
  - `nonheap.*`:非堆内存使用情况。这些信息来自`java.lang.management.MemoryMXBean`接口中`getNonHeapMemoryUsage`方法获取的`java.lang.management.MemoryUsage`。
  - `threads.*`:线程使用情况,包括线程数、守护线程数(daemon)、线程峰值(peak)等,这些数据均来自`java.lang.management.ThreadMXBean`。
  - `classes.*`:应用加载和卸载的类统计。这些数据均来自`java.lang.management.ClassLoadingMXBean`。
  - `gc.*`:垃圾收集器的详细信息,包括垃圾回收次数`gc.ps_scavenge.count`、垃圾回收消耗时间`gc.ps_scavenge.time`、标记-清除算法的次数`gc.ps_marksweep.count`、标记-清除算法的消耗时间`gc.ps_marksweep.time`。这些数据均来自`java.lang.management.GarbageCollectorMXBean`。
  - `httpsessions.*`:Tomcat容器的会话使用情况。包括最大会话数`httpsessions.max`和活跃会话数`httpsessions.active`。该度量指标信息仅在引入了嵌入式Tomcat作为应用容器的时候才会提供。
  - `gauge.*`:HTTP请求的性能指标之一,它主要用来反映一个绝对数值。比如上面示例中的`gauge.response.hello: 5`,它表示上一次`hello`请求的延迟时间为5毫秒。
  - `counter.*`:HTTP请求的性能指标之一,它主要作为计数器来使用,记录了增加量和减少量。如上示例中`counter.status.200.hello: 11`,它代表了`hello`请求返回`200`状态的次数为11。

  对于`gauge.*`和`counter.*`的统计,这里有一个特殊的内容请求`star-star`,它代表了对静态资源的访问。这两类度量指标非常有用,我们不仅可以使用它默认的统计指标,还可以在程序中轻松的增加自定义统计值。只需要通过注入`org.springframework.boot.actuate.metrics.CounterService`和`org.springframework.boot.actuate.metrics.GaugeService`来实现自定义的统计指标信息。比如:我们可以像下面这样自定义实现对`hello`接口的访问次数统计。 @RestController
public class HelloController {

@Autowired
private CounterService counterService;

@RequestMapping("/hello")
public String greet() {
counterService.increment("didispace.hello.count");
return "";
}

}
  `/metrics`端点可以提供应用运行状态的完整度量指标报告,这项功能非常的实用,但是对于监控系统中的各项监控功能,它们的监控内容、数据收集频率都有所不同,如果我们每次都通过全量获取报告的方式来收集,略显粗暴。所以,我们还可以通过`/metrics/{name}`接口来更细粒度的获取度量信息,比如我们可以通过访问`/metrics/mem.free`来获取当前可用内存数量。

- /health:该端点在一开始的示例中我们已经使用过了,它用来获取应用的各类健康指标信息。在`spring-boot-starter-actuator`模块中自带实现了一些常用资源的健康指标检测器。这些检测器都通过`HealthIndicator`接口实现,并且会根据依赖关系的引入实现自动化装配,比如用于检测磁盘的`DiskSpaceHealthIndicator`、检测DataSource连接是否可用的`DataSourceHealthIndicator`等。有时候,我们可能还会用到一些Spring Boot的Starter POMs中还没有封装的产品来进行开发,比如:当使用RocketMQ作为消息代理时,由于没有自动化配置的检测器,所以我们需要自己来实现一个用来采集健康信息的检测器。比如,我们可以在Spring Boot的应用中,为`org.springframework.boot.actuate.health.HealthIndicator`接口实现一个对RocketMQ的检测器类: @Component
public class RocketMQHealthIndicator implements HealthIndicator {

@Override
public Health health() {
int errorCode = check();
if (errorCode != 0) {
return Health.down().withDetail("Error Code", errorCode).build();
}
return Health.up().build();
}

private int check() {
// 对监控对象的检测操作
}
}
  通过重写`health()`函数来实现健康检查,返回的`Heath`对象中,共有两项内容,一个是状态信息,除了该示例中的`UP`与`DOWN`之外,还有`UNKNOWN`和`OUT_OF_SERVICE`,可以根据需要来实现返回;还有一个详细信息,采用Map的方式存储,在这里通过`withDetail`函数,注入了一个Error Code信息,我们也可以填入一下其他信息,比如,检测对象的IP地址、端口等。重新启动应用,并访问`/health`接口,我们在返回的JSON字符串中,将会包含了如下信息: "rocketMQ": {
"status": "UP"
}
- /dump:该端点用来暴露程序运行中的线程信息。它使用`java.lang.management.ThreadMXBean`的`dumpAllThreads`方法来返回所有含有同步信息的活动线程详情。

- /trace:该端点用来返回基本的HTTP跟踪信息。默认情况下,跟踪信息的存储采用`org.springframework.boot.actuate.trace.InMemoryTraceRepository`实现的内存方式,始终保留最近的100条请求记录。它记录的内容格式如下: [
{
"timestamp": 1482570022463,
"info": {
"method": "GET",
"path": "/metrics/mem",
"headers": {
"request": {
"host": "localhost:8881",
"connection": "keep-alive",
"cache-control": "no-cache",
"user-agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36",
"postman-token": "9817ea4d-ad9d-b2fc-7685-9dff1a1bc193",
"accept": "*/*",
"accept-encoding": "gzip, deflate, sdch",
"accept-language": "zh-CN,zh;q=0.8"
},
"response": {
"X-Application-Context": "hello:dev:8881",
"Content-Type": "application/json;charset=UTF-8",
"Transfer-Encoding": "chunked",
"Date": "Sat, 24 Dec 2016 09:00:22 GMT",
"status": "200"
}
}
}
},
...
]
操作控制类

仔细的读者可能会发现,我们在“初识Actuator”时运行示例的控制台中输出的所有监控端点,已经在介绍应用配置类端点和度量指标类端点时都讲解完了。那么还有哪些是操作控制类端点呢?实际上,由于之前介绍的所有端点都是用来反映应用自身的属性或是运行中的状态,相对于操作控制类端点没有那么敏感,所以他们默认都是启用的。而操作控制类端点拥有更强大的控制能力,如果要使用它们的话,需要通过属性来配置开启。

在原生端点中,只提供了一个用来关闭应用的端点:`/shutdown`。我们可以通过如下配置开启它:endpoints.shutdown.enabled=true
在配置了上述属性之后,只需要访问该应用的`/shutdown`端点就能实现关闭该应用的远程操作。由于开放关闭应用的操作本身是一件非常危险的事,所以真正在线上使用的时候,我们需要对其加入一定的保护机制,比如:定制Actuator的端点路径、整合Spring Security进行安全校验等。
 

本文作者:程序猿DD-翟永超
原文链接:Spring Boot Actuator监控端点小结
版权归作者所有,转载请注明出处
  查看全部
在Spring Boot的众多Starter POMs中有一个特殊的模块,它不同于其他模块那样大多用于开发业务功能或是连接一些其他外部资源。它完全是一个用于暴露自身信息的模块,所以很明显,它的主要作用是用于监控与管理,它就是:`spring-boot-starter-actuator`。

`spring-boot-starter-actuator`模块的实现对于实施微服务的中小团队来说,可以有效地减少监控系统在采集应用指标时的开发量。当然,它也并不是万能的,有时候我们也需要对其做一些简单的扩展来帮助我们实现自身系统个性化的监控需求。下面,在本文中,我们将详解的介绍一些关于`spring-boot-starter-actuator`模块的内容,包括它的原生提供的端点以及一些常用的扩展和配置方式。

初识Actuator

下面,我们可以通过对快速入门中实现的Spring Boot应用增加`spring-boot-starter-actuator`模块功能,来对它有一个直观的认识。

在现有的Spring Boot应用中引入该模块非常简单,只需要在`pom.xml`的`dependencies`节点中,新增`spring-boot-starter-actuator`的依赖即可,具体如下:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

通过增加该依赖之后,重新启动应用。此时,我们可以在控制台中看到如下图所示的输出:



上图显示了一批端点定义,这些端点并非我们自己在程序中创建,而是由`spring-boot-starter-actuator`模块根据应用依赖和配置自动创建出来的监控和管理端点。通过这些端点,我们可以实时的获取应用的各项监控指标,比如:访问`/health`端点,我们可以获得如下返回的应用健康信息:
{
"status": "UP",
"diskSpace": {
"status": "UP",
"total": 491270434816,
"free": 383870214144,
"threshold": 10485760
}
}

原生端点

通过在快速入门示例中添加`spring-boot-starter-actuator`模块,我们已经对它有了一个初步的认识。接下来,我们详细介绍一下`spring-boot-starter-actuator`模块中已经实现的一些原生端点。如果根据端点的作用来说,我们可以原生端点分为三大类:

- 应用配置类:获取应用程序中加载的应用配置、环境变量、自动化配置报告等与Spring Boot应用密切相关的配置类信息。
- 度量指标类:获取应用程序运行过程中用于监控的度量指标,比如:内存信息、线程池信息、HTTP请求统计等。
- 操作控制类:提供了对应用的关闭等操作类功能。

下面我们来详细了解一下这三类端点都分别可以为我们提供怎么样的有用信息和强大功能,以及我们如何去扩展和配置它们。

应用配置类

由于Spring Boot为了改善传统Spring应用繁杂的配置内容,采用了包扫描和自动化配置的机制来加载原本集中于xml文件中的各项内容。虽然这样的做法,让我们的代码变得非常简洁,但是整个应用的实例创建和依赖关系等信息都被离散到了各个配置类的注解上,这使得我们分析整个应用中资源和实例的各种关系变得非常的困难。而这类端点就可以帮助我们轻松的获取一系列关于Spring 应用配置内容的详细报告,比如:自动化配置的报告、Bean创建的报告、环境属性的报告等。

- /autoconfig:该端点用来获取应用的自动化配置报告,其中包括所有自动化配置的候选项。同时还列出了每个候选项自动化配置的各个先决条件是否满足。所以,该端点可以帮助我们方便的找到一些自动化配置为什么没有生效的具体原因。该报告内容将自动化配置内容分为两部分:

  - `positiveMatches`中返回的是条件匹配成功的自动化配置
  - `negativeMatches`中返回的是条件匹配不成功的自动化配置
 {
"positiveMatches": { // 条件匹配成功的
"EndpointWebMvcAutoConfiguration": [
{
"condition": "OnClassCondition",
"message": "@ConditionalOnClass classes found: javax.servlet.Servlet,org.springframework.web.servlet.DispatcherServlet"
},
{
"condition": "OnWebApplicationCondition",
"message": "found web application StandardServletEnvironment"
}
],
...
},
"negativeMatches": { // 条件不匹配成功的
"HealthIndicatorAutoConfiguration.DataSourcesHealthIndicatorConfiguration": [
{
"condition": "OnClassCondition",
"message": "required @ConditionalOnClass classes not found: org.springframework.jdbc.core.JdbcTemplate"
}
],
...
}
}

从如上示例中我们可以看到,每个自动化配置候选项中都有一系列的条件,比如上面没有成功匹配的`HealthIndicatorAutoConfiguration.DataSourcesHealthIndicatorConfiguration`配置,它的先决条件就是需要在工程中包含`org.springframework.jdbc.core.JdbcTemplate`类,由于我们没有引入相关的依赖,它就不会执行自动化配置内容。所以,当我们发现有一些期望的配置没有生效时,就可以通过该端点来查看没有生效的具体原因。

- /beans:该端点用来获取应用上下文中创建的所有Bean。
[
{
"context": "hello:dev:8881",
"parent": null,
"beans": [
{
"bean": "org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration$DispatcherServletConfiguration",
"scope": "singleton",
"type": "org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration$DispatcherServletConfiguration$$EnhancerBySpringCGLIB$$3440282b",
"resource": "null",
"dependencies": [
"serverProperties",
"spring.mvc.CONFIGURATION_PROPERTIES",
"multipartConfigElement"
]
},
{
"bean": "dispatcherServlet",
"scope": "singleton",
"type": "org.springframework.web.servlet.DispatcherServlet",
"resource": "class path resource [org/springframework/boot/autoconfigure/web/DispatcherServletAutoConfiguration$DispatcherServletConfiguration.class]",
"dependencies":
}
]
}
]

  如上示例中,我们可以看到在每个bean中都包含了下面这几个信息:

  - bean:Bean的名称
  - scope:Bean的作用域
  - type:Bean的Java类型
  - reource:class文件的具体路径
  - dependencies:依赖的Bean名称

- /configprops:该端点用来获取应用中配置的属性信息报告。从下面该端点返回示例的片段中,我们看到返回了关于该短信的配置信息,`prefix`属性代表了属性的配置前缀,`properties`代表了各个属性的名称和值。所以,我们可以通过该报告来看到各个属性的配置路径,比如我们要关闭该端点,就可以通过使用`endpoints.configprops.enabled=false`来完成设置。
 {
"configurationPropertiesReportEndpoint": {
"prefix": "endpoints.configprops",
"properties": {
"id": "configprops",
"sensitive": true,
"enabled": true
}
},
...
}

- /env:该端点与`/configprops`不同,它用来获取应用所有可用的环境属性报告。包括:环境变量、JVM属性、应用的配置配置、命令行中的参数。从下面该端点返回的示例片段中,我们可以看到它不仅返回了应用的配置属性,还返回了系统属性、环境变量等丰富的配置信息,其中也包括了应用还没有没有使用的配置。所以它可以帮助我们方便地看到当前应用可以加载的配置信息,并配合`@ConfigurationProperties`注解将它们引入到我们的应用程序中来进行使用。另外,为了配置属性的安全,对于一些类似密码等敏感信息,该端点都会进行隐私保护,但是我们需要让属性名中包含:password、secret、key这些关键词,这样该端点在返回它们的时候会使用`*`来替代实际的属性值。
 {
"profiles": [
"dev"
],
"server.ports": {
"local.server.port": 8881
},
"servletContextInitParams": {

},
"systemProperties": {
"idea.version": "2016.1.3",
"java.runtime.name": "Java(TM) SE Runtime Environment",
"sun.boot.library.path": "C:\\Program Files\\Java\\jdk1.8.0_91\\jre\\bin",
"java.vm.version": "25.91-b15",
"java.vm.vendor": "Oracle Corporation",
...
},
"systemEnvironment": {
"configsetroot": "C:\\WINDOWS\\ConfigSetRoot",
"RABBITMQ_BASE": "E:\\tools\\rabbitmq",
...
},
"applicationConfig: [classpath:/application-dev.properties]": {
"server.port": "8881"
},
"applicationConfig: [classpath:/application.properties]": {
"server.port": "8885",
"spring.profiles.active": "dev",
"info.app.name": "spring-boot-hello",
"info.app.version": "v1.0.0",
"spring.application.name": "hello"
}
}

- /mappings:该端点用来返回所有Spring MVC的控制器映射关系报告。从下面的示例片段中,我们可以看该报告的信息与我们在启用Spring MVC的Web应用时输出的日志信息类似,其中`bean`属性标识了该映射关系的请求处理器,`method`属性标识了该映射关系的具体处理类和处理函数。
{
"/webjars/**": {
"bean": "resourceHandlerMapping"
},
"/**": {
"bean": "resourceHandlerMapping"
},
"/**/favicon.ico": {
"bean": "faviconHandlerMapping"
},
"{[/hello]}": {
"bean": "requestMappingHandlerMapping",
"method": "public java.lang.String com.didispace.web.HelloController.index()"
},
"{[/mappings || /mappings.json],methods=[GET],produces=[application/json]}": {
"bean": "endpointHandlerMapping",
"method": "public java.lang.Object org.springframework.boot.actuate.endpoint.mvc.EndpointMvcAdapter.invoke()"
},
...
}

- /info:该端点用来返回一些应用自定义的信息。默认情况下,该端点只会返回一个空的json内容。我们可以在`application.properties`配置文件中通过`info`前缀来设置一些属性,比如下面这样:
  info.app.name=spring-boot-hello
info.app.version=v1.0.0

  再访问`/info`端点,我们可以得到下面的返回报告,其中就包含了上面我们在应用自定义的两个参数。
  {
"app": {
"name": "spring-boot-hello",
"version": "v1.0.0"
}
}

度量指标类

上面我们所介绍的应用配置类端点所提供的信息报告在应用启动的时候都已经基本确定了其返回内容,可以说是一个静态报告。而度量指标类端点提供的报告内容则是动态变化的,这些端点提供了应用程序在运行过程中的一些快照信息,比如:内存使用情况、HTTP请求统计、外部资源指标等。这些端点对于我们构建微服务架构中的监控系统非常有帮助,由于Spring Boot应用自身实现了这些端点,所以我们可以很方便地利用它们来收集我们想要的信息,以制定出各种自动化策略。下面,我们就来分别看看这些强大的端点功能。

- /metrics:该端点用来返回当前应用的各类重要度量指标,比如:内存信息、线程信息、垃圾回收信息等。
 {
"mem": 541305,
"mem.free": 317864,
"processors": 8,
"instance.uptime": 33376471,
"uptime": 33385352,
"systemload.average": -1,
"heap.committed": 476672,
"heap.init": 262144,
"heap.used": 158807,
"heap": 3701248,
"nonheap.committed": 65856,
"nonheap.init": 2496,
"nonheap.used": 64633,
"nonheap": 0,
"threads.peak": 22,
"threads.daemon": 20,
"threads.totalStarted": 26,
"threads": 22,
"classes": 7669,
"classes.loaded": 7669,
"classes.unloaded": 0,
"gc.ps_scavenge.count": 7,
"gc.ps_scavenge.time": 118,
"gc.ps_marksweep.count": 2,
"gc.ps_marksweep.time": 234,
"httpsessions.max": -1,
"httpsessions.active": 0,
"gauge.response.beans": 55,
"gauge.response.env": 10,
"gauge.response.hello": 5,
"gauge.response.metrics": 4,
"gauge.response.configprops": 153,
"gauge.response.star-star": 5,
"counter.status.200.beans": 1,
"counter.status.200.metrics": 3,
"counter.status.200.configprops": 1,
"counter.status.404.star-star": 2,
"counter.status.200.hello": 11,
"counter.status.200.env": 1
}

  从上面的示例中,我们看到有这些重要的度量值:

  - 系统信息:包括处理器数量`processors`、运行时间`uptime`和`instance.uptime`、系统平均负载`systemload.average`。
  - `mem.*`:内存概要信息,包括分配给应用的总内存数量以及当前空闲的内存数量。这些信息来自`java.lang.Runtime`。
  - `heap.*`:堆内存使用情况。这些信息来自`java.lang.management.MemoryMXBean`接口中`getHeapMemoryUsage`方法获取的`java.lang.management.MemoryUsage`。
  - `nonheap.*`:非堆内存使用情况。这些信息来自`java.lang.management.MemoryMXBean`接口中`getNonHeapMemoryUsage`方法获取的`java.lang.management.MemoryUsage`。
  - `threads.*`:线程使用情况,包括线程数、守护线程数(daemon)、线程峰值(peak)等,这些数据均来自`java.lang.management.ThreadMXBean`。
  - `classes.*`:应用加载和卸载的类统计。这些数据均来自`java.lang.management.ClassLoadingMXBean`。
  - `gc.*`:垃圾收集器的详细信息,包括垃圾回收次数`gc.ps_scavenge.count`、垃圾回收消耗时间`gc.ps_scavenge.time`、标记-清除算法的次数`gc.ps_marksweep.count`、标记-清除算法的消耗时间`gc.ps_marksweep.time`。这些数据均来自`java.lang.management.GarbageCollectorMXBean`。
  - `httpsessions.*`:Tomcat容器的会话使用情况。包括最大会话数`httpsessions.max`和活跃会话数`httpsessions.active`。该度量指标信息仅在引入了嵌入式Tomcat作为应用容器的时候才会提供。
  - `gauge.*`:HTTP请求的性能指标之一,它主要用来反映一个绝对数值。比如上面示例中的`gauge.response.hello: 5`,它表示上一次`hello`请求的延迟时间为5毫秒。
  - `counter.*`:HTTP请求的性能指标之一,它主要作为计数器来使用,记录了增加量和减少量。如上示例中`counter.status.200.hello: 11`,它代表了`hello`请求返回`200`状态的次数为11。

  对于`gauge.*`和`counter.*`的统计,这里有一个特殊的内容请求`star-star`,它代表了对静态资源的访问。这两类度量指标非常有用,我们不仅可以使用它默认的统计指标,还可以在程序中轻松的增加自定义统计值。只需要通过注入`org.springframework.boot.actuate.metrics.CounterService`和`org.springframework.boot.actuate.metrics.GaugeService`来实现自定义的统计指标信息。比如:我们可以像下面这样自定义实现对`hello`接口的访问次数统计。
  @RestController
public class HelloController {

@Autowired
private CounterService counterService;

@RequestMapping("/hello")
public String greet() {
counterService.increment("didispace.hello.count");
return "";
}

}

  `/metrics`端点可以提供应用运行状态的完整度量指标报告,这项功能非常的实用,但是对于监控系统中的各项监控功能,它们的监控内容、数据收集频率都有所不同,如果我们每次都通过全量获取报告的方式来收集,略显粗暴。所以,我们还可以通过`/metrics/{name}`接口来更细粒度的获取度量信息,比如我们可以通过访问`/metrics/mem.free`来获取当前可用内存数量。

- /health:该端点在一开始的示例中我们已经使用过了,它用来获取应用的各类健康指标信息。在`spring-boot-starter-actuator`模块中自带实现了一些常用资源的健康指标检测器。这些检测器都通过`HealthIndicator`接口实现,并且会根据依赖关系的引入实现自动化装配,比如用于检测磁盘的`DiskSpaceHealthIndicator`、检测DataSource连接是否可用的`DataSourceHealthIndicator`等。有时候,我们可能还会用到一些Spring Boot的Starter POMs中还没有封装的产品来进行开发,比如:当使用RocketMQ作为消息代理时,由于没有自动化配置的检测器,所以我们需要自己来实现一个用来采集健康信息的检测器。比如,我们可以在Spring Boot的应用中,为`org.springframework.boot.actuate.health.HealthIndicator`接口实现一个对RocketMQ的检测器类:
  @Component
public class RocketMQHealthIndicator implements HealthIndicator {

@Override
public Health health() {
int errorCode = check();
if (errorCode != 0) {
return Health.down().withDetail("Error Code", errorCode).build();
}
return Health.up().build();
}

private int check() {
// 对监控对象的检测操作
}
}

  通过重写`health()`函数来实现健康检查,返回的`Heath`对象中,共有两项内容,一个是状态信息,除了该示例中的`UP`与`DOWN`之外,还有`UNKNOWN`和`OUT_OF_SERVICE`,可以根据需要来实现返回;还有一个详细信息,采用Map的方式存储,在这里通过`withDetail`函数,注入了一个Error Code信息,我们也可以填入一下其他信息,比如,检测对象的IP地址、端口等。重新启动应用,并访问`/health`接口,我们在返回的JSON字符串中,将会包含了如下信息:
  "rocketMQ": {
"status": "UP"
}

- /dump:该端点用来暴露程序运行中的线程信息。它使用`java.lang.management.ThreadMXBean`的`dumpAllThreads`方法来返回所有含有同步信息的活动线程详情。

- /trace:该端点用来返回基本的HTTP跟踪信息。默认情况下,跟踪信息的存储采用`org.springframework.boot.actuate.trace.InMemoryTraceRepository`实现的内存方式,始终保留最近的100条请求记录。它记录的内容格式如下:
   [
{
"timestamp": 1482570022463,
"info": {
"method": "GET",
"path": "/metrics/mem",
"headers": {
"request": {
"host": "localhost:8881",
"connection": "keep-alive",
"cache-control": "no-cache",
"user-agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36",
"postman-token": "9817ea4d-ad9d-b2fc-7685-9dff1a1bc193",
"accept": "*/*",
"accept-encoding": "gzip, deflate, sdch",
"accept-language": "zh-CN,zh;q=0.8"
},
"response": {
"X-Application-Context": "hello:dev:8881",
"Content-Type": "application/json;charset=UTF-8",
"Transfer-Encoding": "chunked",
"Date": "Sat, 24 Dec 2016 09:00:22 GMT",
"status": "200"
}
}
}
},
...
]

操作控制类

仔细的读者可能会发现,我们在“初识Actuator”时运行示例的控制台中输出的所有监控端点,已经在介绍应用配置类端点和度量指标类端点时都讲解完了。那么还有哪些是操作控制类端点呢?实际上,由于之前介绍的所有端点都是用来反映应用自身的属性或是运行中的状态,相对于操作控制类端点没有那么敏感,所以他们默认都是启用的。而操作控制类端点拥有更强大的控制能力,如果要使用它们的话,需要通过属性来配置开启。

在原生端点中,只提供了一个用来关闭应用的端点:`/shutdown`。我们可以通过如下配置开启它:
endpoints.shutdown.enabled=true

在配置了上述属性之后,只需要访问该应用的`/shutdown`端点就能实现关闭该应用的远程操作。由于开放关闭应用的操作本身是一件非常危险的事,所以真正在线上使用的时候,我们需要对其加入一定的保护机制,比如:定制Actuator的端点路径、整合Spring Security进行安全校验等。
 


本文作者:程序猿DD-翟永超
原文链接:Spring Boot Actuator监控端点小结
版权归作者所有,转载请注明出处
 


Spring Boot 整合 Mybatis Annotation 注解的完整 Web 案例

泥瓦匠BYSocket 发表了文章 • 8 个评论 • 667 次浏览 • 2017-05-27 14:35 • 来自相关话题

『 公司需要人、产品、业务和方向,方向又要人、产品、业务和方向,方向… 循环』

本文提纲
一、前言
二、运行 springboot-mybatis-annotation 工程
三、springboot-mybatis-annotation 工程配置详解
四、小结

运行环境:JDK 7 或 8、Maven 3.0+
技术栈:SpringBoot 1.5+、SpringBoot Mybatis Starter 1.2+ 、MyBatis 3.4+

前言

距离第一篇 Spring Boot 系列的博文 3 个月了。《Springboot 整合 Mybatis 的完整 Web 案例》第一篇出来是 XML 配置 SQL 的形式。虽然 XML 形式是我比较推荐的,但是注解形式也是方便的。尤其一些小系统,快速的 CRUD 轻量级的系统。

这里感谢晓春 http://xchunzhao.tk/ 的 Pull Request,提供了 springboot-mybatis-annotation 的实现。

一、运行 springboot-mybatis-annotation 工程

由于这篇文章和 《Springboot 整合 Mybatis 的完整 Web 案例》 类似,所以运行这块环境配置大家参考另外一篇兄弟文章。

然后Application 应用启动类的 main 函数,然后在浏览器访问:

http://localhost:8080/api/city?cityName=温岭市

可以看到返回的 JSON 结果:{
"id": 1,
"provinceId": 1,
"cityName": "温岭市",
"description": "我的家在温岭。"
}

 

三、springboot-mybatis-annotation 工程配置详解

1.pom 添加 Mybatis 依赖<?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/ma ... gt%3B
<modelVersion>4.0.0</modelVersion>

<groupId>springboot</groupId>
<artifactId>springboot-mybatis-annotation</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>springboot-mybatis-annotation</name>
<description>Springboot-mybatis :: 整合Mybatis Annotation Demo</description>

<!-- Spring Boot 启动父依赖 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.1.RELEASE</version>
</parent>

<properties>
<mybatis-spring-boot>1.2.0</mybatis-spring-boot>
<mysql-connector>5.1.39</mysql-connector>
</properties>

<dependencies>

<!-- Spring Boot Web 依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- Spring Boot Test 依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>

<!-- Spring Boot Mybatis 依赖 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>${mybatis-spring-boot}</version>
</dependency>

<!-- MySQL 连接驱动依赖 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql-connector}</version>
</dependency>

<!-- Junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>


</project>

2.在 CityDao 城市数据操作层接口类添加注解 @Mapper、@Select 和 @Results/**
* 城市 DAO 接口类
*
* Created by xchunzhao on 02/05/2017.
*/
@Mapper // 标志为 Mybatis 的 Mapper
public interface CityDao {

/**
* 根据城市名称,查询城市信息
*
* @param cityName 城市名
*/
@Select("SELECT * FROM city")
// 返回 Map 结果集
@Results({
@Result(property = "id", column = "id"),
@Result(property = "provinceId", column = "province_id"),
@Result(property = "cityName", column = "city_name"),
@Result(property = "description", column = "description"),
})
City findByName(@Param("cityName") String cityName);
}@Mapper 标志接口为 MyBatis Mapper 接口
@Select 是 Select 操作语句
@Results 标志结果集,以及与库表字段的映射关系

其他的注解可以看 org.apache.ibatis.annotations 包提供的,如图:

 
可以 git clone 下载工程 springboot-learning-example ,springboot-mybatis-annotation 工程代码注解很详细。 https://github.com/JeffLi1993/springboot-learning-example 。

四、小结

注解不涉及到配置,更近贴近 0 配置。再次感谢晓春 http://xchunzhao.tk/ 的 Pull Request
 
本文作者: 泥瓦匠
原文链接: http://www.bysocket.com/?p=1811 
版权归作者所有,转载请注明出处 查看全部
『 公司需要人、产品、业务和方向,方向又要人、产品、业务和方向,方向… 循环』

本文提纲
一、前言
二、运行 springboot-mybatis-annotation 工程
三、springboot-mybatis-annotation 工程配置详解
四、小结

运行环境:JDK 7 或 8、Maven 3.0+
技术栈:SpringBoot 1.5+、SpringBoot Mybatis Starter 1.2+ 、MyBatis 3.4+

前言

距离第一篇 Spring Boot 系列的博文 3 个月了。《Springboot 整合 Mybatis 的完整 Web 案例》第一篇出来是 XML 配置 SQL 的形式。虽然 XML 形式是我比较推荐的,但是注解形式也是方便的。尤其一些小系统,快速的 CRUD 轻量级的系统。

这里感谢晓春 http://xchunzhao.tk/ 的 Pull Request,提供了 springboot-mybatis-annotation 的实现。

一、运行 springboot-mybatis-annotation 工程

由于这篇文章和 《Springboot 整合 Mybatis 的完整 Web 案例》 类似,所以运行这块环境配置大家参考另外一篇兄弟文章。

然后Application 应用启动类的 main 函数,然后在浏览器访问:

http://localhost:8080/api/city?cityName=温岭市

可以看到返回的 JSON 结果:
{
"id": 1,
"provinceId": 1,
"cityName": "温岭市",
"description": "我的家在温岭。"
}


 

三、springboot-mybatis-annotation 工程配置详解

1.pom 添加 Mybatis 依赖
<?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/ma ... gt%3B
<modelVersion>4.0.0</modelVersion>

<groupId>springboot</groupId>
<artifactId>springboot-mybatis-annotation</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>springboot-mybatis-annotation</name>
<description>Springboot-mybatis :: 整合Mybatis Annotation Demo</description>

<!-- Spring Boot 启动父依赖 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.1.RELEASE</version>
</parent>

<properties>
<mybatis-spring-boot>1.2.0</mybatis-spring-boot>
<mysql-connector>5.1.39</mysql-connector>
</properties>

<dependencies>

<!-- Spring Boot Web 依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- Spring Boot Test 依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>

<!-- Spring Boot Mybatis 依赖 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>${mybatis-spring-boot}</version>
</dependency>

<!-- MySQL 连接驱动依赖 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql-connector}</version>
</dependency>

<!-- Junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>


</project>


2.在 CityDao 城市数据操作层接口类添加注解 @Mapper、@Select 和 @Results
/**
* 城市 DAO 接口类
*
* Created by xchunzhao on 02/05/2017.
*/
@Mapper // 标志为 Mybatis 的 Mapper
public interface CityDao {

/**
* 根据城市名称,查询城市信息
*
* @param cityName 城市名
*/
@Select("SELECT * FROM city")
// 返回 Map 结果集
@Results({
@Result(property = "id", column = "id"),
@Result(property = "provinceId", column = "province_id"),
@Result(property = "cityName", column = "city_name"),
@Result(property = "description", column = "description"),
})
City findByName(@Param("cityName") String cityName);
}
@Mapper 标志接口为 MyBatis Mapper 接口
@Select 是 Select 操作语句
@Results 标志结果集,以及与库表字段的映射关系

其他的注解可以看 org.apache.ibatis.annotations 包提供的,如图:

 
可以 git clone 下载工程 springboot-learning-example ,springboot-mybatis-annotation 工程代码注解很详细。 https://github.com/JeffLi1993/springboot-learning-example 。

四、小结

注解不涉及到配置,更近贴近 0 配置。再次感谢晓春 http://xchunzhao.tk/ 的 Pull Request
 
本文作者: 泥瓦匠
原文链接: http://www.bysocket.com/?p=1811 
版权归作者所有,转载请注明出处

Spring Boot 之配置文件详解

泥瓦匠BYSocket 发表了文章 • 3 个评论 • 658 次浏览 • 2017-05-27 10:12 • 来自相关话题

『 仓廪实而知礼节,衣食足而知荣辱 – 管仲 』
 
本文提纲
一、自动配置
二、自定义属性
三、random.* 属性
四、多环境配置运行环境:JDK 7 或 8,Maven 3.0+技术栈:SpringBoot 1.5+

一、自动配置
Spring Boot 提供了对应用进行自动化配置。相比以前 XML 配置方式,很多显式方式申明是不需要的。二者,大多数默认的配置足够实现开发功能,从而更快速开发。

什么是自动配置?
Spring Boot 提供了默认的配置,如默认的 Bean ,去运行 Spring 应用。它是非侵入式的,只提供一个默认实现。

大多数情况下,自动配置的 Bean 满足了现有的业务场景,不需要去覆盖。但如果自动配置做的不够好,需要覆盖配置。比如通过命令行动态指定某个 jar ,按不同环境启动(这个例子在第 4 小节介绍)。那怎么办?这里先要考虑到配置的优先级。Spring Boot 不单单从 application.properties 获取配置,所以我们可以在程序中多种设置配置属性。
 
按照以下列表的优先级排列:

1.命令行参数
2.java:comp/env 里的 JNDI 属性
3.JVM 系统属性
4.操作系统环境变量
5.RandomValuePropertySource 属性类生成的 random.* 属性
6.应用以外的 application.properties(或 yml)文件
7.打包在应用内的 application.properties(或 yml)文件
8.在应用 @Configuration 配置类中,用 @PropertySource 注解声明的属性文件
9.SpringApplication.setDefaultProperties 声明的默认属性可见,命令行参数优先级最高。这个可以根据这个优先级,可以在测试或生产环境中快速地修改配置参数值,而不需要重新打包和部署应用。

还有第 6 点,根据这个在多 moudle 的项目中,比如常见的项目分 api 、service、dao 等 moudles,往往会加一个 deploy moudle 去打包该业务各个子 moudle,应用以外的配置优先。
 
二、自定义属性
泥瓦匠喜欢按着代码工程来讲解知识。git clone 下载工程 springboot-learning-example ,项目地址见 GitHub – https://github.com/JeffLi1993/springboot-learning-example。 
 
a. 编译工程
在项目根目录 springboot-learning-example,运行 maven 指令:cd springboot-learning-example
mvn clean install
b. 运行工程 
test 方法运行 springboot-properties 工程 org.spring.springboot.property.PropertiesTest 测试类的 getHomeProperties 方法。
可以在控制台看到输出,这是通过自定义属性获取的值:HomeProperties{province='ZheJiang', city='WenLing', desc='dev: I'm living in ZheJiang WenLing.'
 
怎么定义自定义属性呢?首先项目结构如下:├── pom.xml
└── src
├── main
│ ├── java
│ │ └── org
│ │ └── spring
│ │ └── springboot
│ │ ├── Application.java
│ │ └── property
│ │ ├── HomeProperties.java
│ │ └── UserProperties.java
│ └── resources
│ ├── application-dev.properties
│ ├── application-prod.properties
│ └── application.properties
└── test
├── java
│ └── org
│ └── spring
│ └── springboot
│ └── property
│ ├── HomeProperties1.java
│ └── PropertiesTest.java
└── resouorces
└── application.yml
在 application.properties 中对应 HomeProperties 对象字段编写属性的 KV 值:## 家乡属性 Dev
home.province=ZheJiang
home.city=WenLing
home.desc=dev: I'm living in ${home.province} ${home.city}.
 
这里也可以通过占位符,进行属性之间的引用。然后,编写对应的 HomeProperties Java 对象:/**
* 家乡属性
*
* Created by bysocket on 17/04/2017.
*/
@Component
@ConfigurationProperties(prefix = "home")
public class HomeProperties {

/**
* 省份
*/
private String province;

/**
* 城市
*/
private String city;

/**
* 描述
*/
private String desc;

public String getProvince() {
return province;
}

public void setProvince(String province) {
this.province = province;
}

public String getCity() {
return city;
}

public void setCity(String city) {
this.city = city;
}

public String getDesc() {
return desc;
}

public void setDesc(String desc) {
this.desc = desc;
}

@Override
public String toString() {
return "HomeProperties{" +
"province='" + province + '\'' +
", city='" + city + '\'' +
", desc='" + desc + '\'' +
'}';
}
}
通过 @ConfigurationProperties(prefix = “home”) 注解,将配置文件中以 home 前缀的属性值自动绑定到对应的字段中。
同时用 @Component 作为 Bean 注入到 Spring 容器中。如果不是用 application.properties 文件,而是用 application.yml 的文件,对应配置如下:## 家乡属性
home:
province: 浙江省
city: 温岭松门
desc: 我家住在${home.province}的${home.city}
 
注意:键值对冒号后面,必须空一格。
注意:就有一个坑了
application.properties 配置中文值的时候,读取出来的属性值会出现乱码问题。但是 application.yml 不会出现乱码问题。
原因是,Spring Boot 是以 iso-8859 的编码方式读取 application.properties 配置文件。
 
注意:还有一个坑
如果定义一个键值对 user.name=xxx ,这里会读取不到对应写的属性值。为什么呢?Spring Boot 的默认 StandardEnvironment 首先将会加载 “systemEnvironment” 作为首个PropertySource. 而 source 即为System.getProperties().当 getProperty时,按照读取顺序,返回 “systemEnvironment” 的值.即 System.getProperty(“user.name“)
(Mac 机子会读自己的登录账号,这里感谢我的死党 http://rapharino.com/) 
 
三、random.* 属性
Spring Boot 通过 RandomValuePropertySource 提供了很多关于随机数的工具类。概括可以生成随机字符串、随机 int 、随机 long、某范围的随机数。
运行 springboot-properties 工程 org.spring.springboot.property.PropertiesTest 测试类的 randomTestUser 方法。多次运行,可以发现每次输出不同 User 属性值:UserProperties{id=-3135706105861091890, age=41, desc='泥瓦匠叫做3cf8fb2507f64e361f62700bcbd17770', uuid='582bcc01-bb7f-41db-94d5-c22aae186cb4'}
 
application.yml 方式的配置如下( application.properties 形式这里不写了):## 随机属性
user:
id: ${random.long}
age: ${random.int[1,200]}
desc: 泥瓦匠叫做${random.value}
uuid: ${random.uuid}

四、多环境配置
很多场景的配置,比如数据库配置、Redis 配置、注册中心和日志配置等。在不同的环境,我们需要不同的包去运行项目。所以看项目结构,有两个环境的配置:application-dev.properties:开发环境
application-prod.properties:生产环境
Spring Boot 是通过 application.properties 文件中,设置 spring.profiles.active 属性,比如 ,配置了 dev ,则加载的是 application-dev.properties :# Spring Profiles Active
spring.profiles.active=dev
 
那运行 springboot-properties 工程中 Application 应用启动类,从控制台中可以看出,是加载了 application-dev.properties 的属性输出:HomeProperties{province='ZheJiang', city='WenLing', desc='dev: I'm living in ZheJiang WenLing.'}
 
将 spring.profiles.active 设置成 prod,重新运行,可得到 application-prod.properties的属性输出:HomeProperties{province='ZheJiang', city='WenLing', desc='prod: I'm living in ZheJiang WenLing.'}
 
根据优先级,顺便介绍下 jar 运行的方式,通过设置 -Dspring.profiles.active=prod 去指定相应的配置:mvn package
java -jar -Dspring.profiles.active=prod springboot-properties-0.0.1-SNAPSHOT.jar

五、小结
常用的样板配置在 Spring Boot 官方文档给出,我们常在 application.properties(或 yml)去配置各种常用配置:
http://docs.spring.io/spring-boot/docs/current/reference/html/common-application-properties.html 
 
感谢资料:
http://blog.didispace.com/springbootproperties/ 
https://docs.spring.io/spring-boot/docs 
 
本文作者: 泥瓦匠
原文链接: http://www.bysocket.com/?p=1124
版权归作者所有,转载请注明出处 查看全部
『 仓廪实而知礼节,衣食足而知荣辱 – 管仲 』
 
本文提纲
一、自动配置
二、自定义属性
三、random.* 属性
四、多环境配置运行环境:JDK 7 或 8,Maven 3.0+技术栈:SpringBoot 1.5+

一、自动配置
Spring Boot 提供了对应用进行自动化配置。相比以前 XML 配置方式,很多显式方式申明是不需要的。二者,大多数默认的配置足够实现开发功能,从而更快速开发。

什么是自动配置?
Spring Boot 提供了默认的配置,如默认的 Bean ,去运行 Spring 应用。它是非侵入式的,只提供一个默认实现。

大多数情况下,自动配置的 Bean 满足了现有的业务场景,不需要去覆盖。但如果自动配置做的不够好,需要覆盖配置。比如通过命令行动态指定某个 jar ,按不同环境启动(这个例子在第 4 小节介绍)。那怎么办?这里先要考虑到配置的优先级。Spring Boot 不单单从 application.properties 获取配置,所以我们可以在程序中多种设置配置属性。
 
按照以下列表的优先级排列


1.命令行参数
2.java:comp/env 里的 JNDI 属性
3.JVM 系统属性
4.操作系统环境变量
5.RandomValuePropertySource 属性类生成的 random.* 属性
6.应用以外的 application.properties(或 yml)文件
7.打包在应用内的 application.properties(或 yml)文件
8.在应用 @Configuration 配置类中,用 @PropertySource 注解声明的属性文件
9.SpringApplication.setDefaultProperties 声明的默认属性可见,命令行参数优先级最高。这个可以根据这个优先级,可以在测试或生产环境中快速地修改配置参数值,而不需要重新打包和部署应用。


还有第 6 点,根据这个在多 moudle 的项目中,比如常见的项目分 api 、service、dao 等 moudles,往往会加一个 deploy moudle 去打包该业务各个子 moudle,应用以外的配置优先。
 
二、自定义属性
泥瓦匠喜欢按着代码工程来讲解知识。git clone 下载工程 springboot-learning-example ,项目地址见 GitHub – https://github.com/JeffLi1993/springboot-learning-example。 
 
a. 编译工程
在项目根目录 springboot-learning-example,运行 maven 指令:
cd springboot-learning-example
mvn clean install

b. 运行工程 
test 方法运行 springboot-properties 工程 org.spring.springboot.property.PropertiesTest 测试类的 getHomeProperties 方法。
可以在控制台看到输出,这是通过自定义属性获取的值:
HomeProperties{province='ZheJiang', city='WenLing', desc='dev: I'm living in ZheJiang WenLing.'

 
怎么定义自定义属性呢?首先项目结构如下:
├── pom.xml
└── src
├── main
│ ├── java
│ │ └── org
│ │ └── spring
│ │ └── springboot
│ │ ├── Application.java
│ │ └── property
│ │ ├── HomeProperties.java
│ │ └── UserProperties.java
│ └── resources
│ ├── application-dev.properties
│ ├── application-prod.properties
│ └── application.properties
└── test
├── java
│ └── org
│ └── spring
│ └── springboot
│ └── property
│ ├── HomeProperties1.java
│ └── PropertiesTest.java
└── resouorces
└── application.yml

在 application.properties 中对应 HomeProperties 对象字段编写属性的 KV 值:
## 家乡属性 Dev
home.province=ZheJiang
home.city=WenLing
home.desc=dev: I'm living in ${home.province} ${home.city}.

 
这里也可以通过占位符,进行属性之间的引用。然后,编写对应的 HomeProperties Java 对象:
/**
* 家乡属性
*
* Created by bysocket on 17/04/2017.
*/
@Component
@ConfigurationProperties(prefix = "home")
public class HomeProperties {

/**
* 省份
*/
private String province;

/**
* 城市
*/
private String city;

/**
* 描述
*/
private String desc;

public String getProvince() {
return province;
}

public void setProvince(String province) {
this.province = province;
}

public String getCity() {
return city;
}

public void setCity(String city) {
this.city = city;
}

public String getDesc() {
return desc;
}

public void setDesc(String desc) {
this.desc = desc;
}

@Override
public String toString() {
return "HomeProperties{" +
"province='" + province + '\'' +
", city='" + city + '\'' +
", desc='" + desc + '\'' +
'}';
}
}

通过 @ConfigurationProperties(prefix = “home”) 注解,将配置文件中以 home 前缀的属性值自动绑定到对应的字段中。
同时用 @Component 作为 Bean 注入到 Spring 容器中。如果不是用 application.properties 文件,而是用 application.yml 的文件,对应配置如下:
## 家乡属性
home:
province: 浙江省
city: 温岭松门
desc: 我家住在${home.province}的${home.city}

 
注意:键值对冒号后面,必须空一格。
注意:就有一个坑了
application.properties 配置中文值的时候,读取出来的属性值会出现乱码问题。但是 application.yml 不会出现乱码问题。
原因是,Spring Boot 是以 iso-8859 的编码方式读取 application.properties 配置文件。
 
注意:还有一个坑
如果定义一个键值对 user.name=xxx ,这里会读取不到对应写的属性值。为什么呢?Spring Boot 的默认 StandardEnvironment 首先将会加载 “systemEnvironment” 作为首个PropertySource. 而 source 即为System.getProperties().当 getProperty时,按照读取顺序,返回 “systemEnvironment” 的值.即 System.getProperty(“user.name“)
(Mac 机子会读自己的登录账号,这里感谢我的死党 http://rapharino.com/) 
 
三、random.* 属性
Spring Boot 通过 RandomValuePropertySource 提供了很多关于随机数的工具类。概括可以生成随机字符串、随机 int 、随机 long、某范围的随机数。
运行 springboot-properties 工程 org.spring.springboot.property.PropertiesTest 测试类的 randomTestUser 方法。多次运行,可以发现每次输出不同 User 属性值:
UserProperties{id=-3135706105861091890, age=41, desc='泥瓦匠叫做3cf8fb2507f64e361f62700bcbd17770', uuid='582bcc01-bb7f-41db-94d5-c22aae186cb4'}

 
application.yml 方式的配置如下( application.properties 形式这里不写了):
## 随机属性
user:
id: ${random.long}
age: ${random.int[1,200]}
desc: 泥瓦匠叫做${random.value}
uuid: ${random.uuid}


四、多环境配置
很多场景的配置,比如数据库配置、Redis 配置、注册中心和日志配置等。在不同的环境,我们需要不同的包去运行项目。所以看项目结构,有两个环境的配置:
application-dev.properties:开发环境
application-prod.properties:生产环境

Spring Boot 是通过 application.properties 文件中,设置 spring.profiles.active 属性,比如 ,配置了 dev ,则加载的是 application-dev.properties :
# Spring Profiles Active
spring.profiles.active=dev

 
那运行 springboot-properties 工程中 Application 应用启动类,从控制台中可以看出,是加载了 application-dev.properties 的属性输出:
HomeProperties{province='ZheJiang', city='WenLing', desc='dev: I'm living in ZheJiang WenLing.'}

 
将 spring.profiles.active 设置成 prod,重新运行,可得到 application-prod.properties的属性输出:
HomeProperties{province='ZheJiang', city='WenLing', desc='prod: I'm living in ZheJiang WenLing.'}

 
根据优先级,顺便介绍下 jar 运行的方式,通过设置 -Dspring.profiles.active=prod 去指定相应的配置:
mvn package
java -jar -Dspring.profiles.active=prod springboot-properties-0.0.1-SNAPSHOT.jar


五、小结
常用的样板配置在 Spring Boot 官方文档给出,我们常在 application.properties(或 yml)去配置各种常用配置:
http://docs.spring.io/spring-boot/docs/current/reference/html/common-application-properties.html 
 
感谢资料:
http://blog.didispace.com/springbootproperties/ 
https://docs.spring.io/spring-boot/docs 
 
本文作者: 泥瓦匠
原文链接: http://www.bysocket.com/?p=1124
版权归作者所有,转载请注明出处

Spring Boot 之 HelloWorld 详解

泥瓦匠BYSocket 发表了文章 • 21 个评论 • 818 次浏览 • 2017-05-26 17:36 • 来自相关话题

“以前是人放狗看家,现在是狗牵着人散步” — 随笔

Spring Boot 系列文章:《Spring Boot 那些事》


一、Spring Boot 自述

世界上最好的文档来源自官方的《Spring Boot Reference Guide》,是这样介绍的:

Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run”…Most Spring Boot applications need very little Spring configuration.


Spring Boot(英文中是“引导”的意思),是用来简化Spring应用的搭建到开发的过程。应用开箱即用,只要通过 “just run”(可能是 java -jar 或 tomcat 或 maven插件run 或 shell脚本),就可以启动项目。二者,Spring Boot 只要很少的Spring配置文件(例如那些xml,property)。

因为“习惯优先于配置”的原则,使得Spring Boot在快速开发应用和微服务架构实践中得到广泛应用。

 
Javaer装好JDK环境和Maven工具就可以开始学习Boot了~


二、HelloWorld实战详解

首先得有个maven基础项目,可以直接使用Maven骨架工程生成Maven骨架Web项目,即man archetype:generate命令:mvn archetype:generate -DgroupId=springboot -DartifactId=springboot-helloworld -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

2.1  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/ma ... gt%3B
<modelVersion>4.0.0</modelVersion>

<groupId>springboot</groupId>
<artifactId>springboot-helloworld</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>springboot-helloworld :: HelloWorld Demo</name>

<!-- Spring Boot 启动父依赖 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.3.3.RELEASE</version>
</parent>

<dependencies>
<!-- Spring Boot web依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- Junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
</project>只要加入一个 Spring Boot 启动父依赖即可。

 

2.2 Controller层

HelloWorldController的代码如下:/**
* Spring Boot HelloWorld案例
*
* Created by bysocket on 16/4/26.
*/
@RestController
public class HelloWorldController {

@RequestMapping("/")
public String sayHello() {
return "Hello,World!";
}
}@RestController和@RequestMapping注解是来自SpringMVC的注解,它们不是SpringBoot的特定部分。

1. @RestController:提供实现了REST API,可以服务JSON,XML或者其他。这里是以String的形式渲染出结果。

2. @RequestMapping:提供路由信息,”/“路径的HTTP Request都会被映射到sayHello方法进行处理。

具体参考,世界上最好的文档来源自官方的《Spring Framework Document》


2.3 启动应用类

和第一段描述一样,开箱即用。如下面Application类:/**
* Spring Boot应用启动类
*
* Created by bysocket on 16/4/26.
*/
@SpringBootApplication
public class Application {

public static void main(String args) {
SpringApplication.run(Application.class,args);
}
}1. @SpringBootApplication:Spring Boot 应用的标识

2. Application很简单,一个main函数作为主入口。SpringApplication引导应用,并将Application本身作为参数传递给run方法。具体run方法会启动嵌入式的Tomcat并初始化Spring环境及其各Spring组件。

 

2.4 Controller层测试类

一个好的程序,不能缺少好的UT。针对HelloWorldController的UT如下:/**
* Spring Boot HelloWorldController 测试 - {@link HelloWorldController}
*
* Created by bysocket on 16/4/26.
*/
public class HelloWorldControllerTest {

@Test
public void testSayHello() {
assertEquals("Hello,World!",new HelloWorldController().sayHello());
}
}
三、运行

Just Run的宗旨,运行很简单,直接右键Run运行Application类。同样你也可以Debug Run。可以在控制台中看到:Tomcat started on port(s): 8080 (http)
Started Application in 5.986 seconds (JVM running for 7.398)
然后访问 http://localhost:8080/ ,即可在页面中看到Spring Boot对你 say hello:

Hello,World!

 

四、小结

1. Spring Boot pom配置

2. Spring Boot 启动及原理

3. 对应代码分享在 Github 主页

如以上文章或链接对你有帮助的话,别忘了在文章结尾处评论哈
你也可以点击页面右边“分享”悬浮按钮哦,让更多的人阅读这篇文章。
 
本文作者: 泥瓦匠
原文链接: http://www.bysocket.com/?p=1124
版权归作者所有,转载请注明出处





  查看全部
“以前是人放狗看家,现在是狗牵着人散步” — 随笔

Spring Boot 系列文章:《Spring Boot 那些事


一、Spring Boot 自述

世界上最好的文档来源自官方的《Spring Boot Reference Guide》,是这样介绍的:


Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run”…Most Spring Boot applications need very little Spring configuration.



Spring Boot(英文中是“引导”的意思),是用来简化Spring应用的搭建到开发的过程。应用开箱即用,只要通过 “just run”(可能是 java -jar 或 tomcat 或 maven插件run 或 shell脚本),就可以启动项目。二者,Spring Boot 只要很少的Spring配置文件(例如那些xml,property)。

因为“习惯优先于配置”的原则,使得Spring Boot在快速开发应用和微服务架构实践中得到广泛应用。

 
Javaer装好JDK环境和Maven工具就可以开始学习Boot了~


二、HelloWorld实战详解

首先得有个maven基础项目,可以直接使用Maven骨架工程生成Maven骨架Web项目,即man archetype:generate命令:
mvn archetype:generate -DgroupId=springboot -DartifactId=springboot-helloworld -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false


2.1  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/ma ... gt%3B
<modelVersion>4.0.0</modelVersion>

<groupId>springboot</groupId>
<artifactId>springboot-helloworld</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>springboot-helloworld :: HelloWorld Demo</name>

<!-- Spring Boot 启动父依赖 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.3.3.RELEASE</version>
</parent>

<dependencies>
<!-- Spring Boot web依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- Junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
</project>
只要加入一个 Spring Boot 启动父依赖即可。

 

2.2 Controller层

HelloWorldController的代码如下:
/**
* Spring Boot HelloWorld案例
*
* Created by bysocket on 16/4/26.
*/
@RestController
public class HelloWorldController {

@RequestMapping("/")
public String sayHello() {
return "Hello,World!";
}
}
@RestController和@RequestMapping注解是来自SpringMVC的注解,它们不是SpringBoot的特定部分。

1. @RestController:提供实现了REST API,可以服务JSON,XML或者其他。这里是以String的形式渲染出结果。

2. @RequestMapping:提供路由信息,”/“路径的HTTP Request都会被映射到sayHello方法进行处理。

具体参考,世界上最好的文档来源自官方的《Spring Framework Document》


2.3 启动应用类

和第一段描述一样,开箱即用。如下面Application类:
/**
* Spring Boot应用启动类
*
* Created by bysocket on 16/4/26.
*/
@SpringBootApplication
public class Application {

public static void main(String args) {
SpringApplication.run(Application.class,args);
}
}
1. @SpringBootApplication:Spring Boot 应用的标识

2. Application很简单,一个main函数作为主入口。SpringApplication引导应用,并将Application本身作为参数传递给run方法。具体run方法会启动嵌入式的Tomcat并初始化Spring环境及其各Spring组件。

 

2.4 Controller层测试类

一个好的程序,不能缺少好的UT。针对HelloWorldController的UT如下:
/**
* Spring Boot HelloWorldController 测试 - {@link HelloWorldController}
*
* Created by bysocket on 16/4/26.
*/
public class HelloWorldControllerTest {

@Test
public void testSayHello() {
assertEquals("Hello,World!",new HelloWorldController().sayHello());
}
}

三、运行

Just Run的宗旨,运行很简单,直接右键Run运行Application类。同样你也可以Debug Run。可以在控制台中看到:
Tomcat started on port(s): 8080 (http)
Started Application in 5.986 seconds (JVM running for 7.398)

然后访问 http://localhost:8080/ ,即可在页面中看到Spring Boot对你 say hello:

Hello,World!

 

四、小结

1. Spring Boot pom配置

2. Spring Boot 启动及原理

3. 对应代码分享在 Github 主页

如以上文章或链接对你有帮助的话,别忘了在文章结尾处评论哈
你也可以点击页面右边“分享”悬浮按钮哦,让更多的人阅读这篇文章。
 
本文作者: 泥瓦匠
原文链接: http://www.bysocket.com/?p=1124
版权归作者所有,转载请注明出处

WechatIMG351.jpeg