Spring boot
资料
基础
- 新增
@RestController注解，其实是@Controller+@ResponseBody的合集 - Spring4.3以后为简化@RequestMapping(method = RequestMethod.XXX)的写法，故而将其做了一层包装，也就是现在的GetMapping、PostMapping、PutMapping、DeleteMapping、PatchMapping
修改默认静态文件目录
@Configuration
public class ChangeResourceConfiguration extends WebMvcConfigurerAdapter
{
//自定义静态资源文件路径
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/xxx/resources/**").addResourceLocations("classpath:/static/");
}
}自动装配
声明一个Servlet
public class TestServlet extends HttpServlet
{
//重写get方法
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//设置返回类型为json
response.setContentType("application/json");
//设置返回字符集
response.setCharacterEncoding("utf-8");
//输出对象
PrintWriter writer = response.getWriter();
//输出error消息
writer.write("执行TestServlet内doGet方法成功!");
writer.close();
}
}使用Bean注册Servlet
@Configuration
public class ServletConfiguration {
@Bean
public ServletRegistrationBean servletRegistrationBean()
{
return new ServletRegistrationBean(new TestServlet(),"/test");
}
}自动装配
@ServletComponentScan，这个注解的作用就是自动扫描我们SpringBoot项目内的有关Servlet配置，自动装配到我们的项目中。
在TestServlet上使用 @WebServlet(urlPatterns = "/test2")
另外ServletConfiguration 如下声明：
@Configuration
@ServletComponentScan
public class ServletConfiguration {
}拦截器
定义
public class SessionInterceptor implements HandlerInterceptor
{
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object o) throws Exception {
System.out.println(request.getRequestURI());
//登录不做拦截
if(request.getRequestURI().equals("/user/login") || request.getRequestURI().equals("/user/login_view"))
{
return true;
}
//验证session是否存在
Object obj = request.getSession().getAttribute("_session_user");
if(obj == null)
{
response.sendRedirect("/user/login_view");
return false;
}
return true;
}
@Override
public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
}
@Override
public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
}
}注册
@Configuration
public class SessionConfiguration extends WebMvcConfigurerAdapter
{
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new SessionInterceptor()).addPathPatterns("/**");
}
}扩展
请求日志拦截
数据结构
DROP TABLE IF EXISTS `t_logger_infos`;
CREATE TABLE `t_logger_infos` (
`ali_id` int(11) NOT NULL AUTO_INCREMENT,
`ali_client_ip` varchar(30) DEFAULT NULL COMMENT '客户端请求IP地址',
`ali_uri` varchar(100) DEFAULT NULL COMMENT '日志请求地址',
`ali_type` varchar(50) DEFAULT NULL COMMENT '终端请求方式,普通请求,ajax请求',
`ali_method` varchar(10) DEFAULT NULL COMMENT '请求方式method,post,get等',
`ali_param_data` longtext COMMENT '请求参数内容,json',
`ali_session_id` varchar(100) DEFAULT NULL COMMENT '请求接口唯一session标识',
`ali_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '请求时间',
`ali_returm_time` varchar(50) DEFAULT NULL COMMENT '接口返回时间',
`ali_return_data` longtext COMMENT '接口返回数据json',
`ali_http_status_code` varchar(10) DEFAULT NULL COMMENT '请求时httpStatusCode代码，如：200,400,404等',
`ali_time_consuming` int(8) DEFAULT '0' COMMENT '请求耗时（毫秒单位）',
PRIMARY KEY (`ali_id`)
) ENGINE=InnoDB AUTO_INCREMENT=106119 DEFAULT CHARSET=utf8 COMMENT='请求日志信息表';数据Model
@Entity
@Table(name = "t_logger_infos")
public class LoggerEntity implements Serializable
{
//编号
@Id
@GeneratedValue
@Column(name = "ali_id")
private Long id;
//客户端请求ip
@Column(name = "ali_client_ip")
private String clientIp;
//客户端请求路径
@Column(name = "ali_uri")
private String uri;
//终端请求方式,普通请求,ajax请求
@Column(name = "ali_type")
private String type;
//请求方式method,post,get等
@Column(name = "ali_method")
private String method;
//请求参数内容,json
@Column(name = "ali_param_data")
private String paramData;
//请求接口唯一session标识
@Column(name = "ali_session_id")
private String sessionId;
//请求时间
@Column(name = "ali_time",insertable = false)
private Timestamp time;
//接口返回时间
@Column(name = "ali_returm_time")
private String returnTime;
//接口返回数据json
@Column(name = "ali_return_data")
private String returnData;
//请求时httpStatusCode代码，如：200,400,404等
@Column(name = "ali_http_status_code")
private String httpStatusCode;
//请求耗时秒单位
@Column(name = "ali_time_consuming")
private int timeConsuming;
// Get Set ......
}对于Model增删改查省略。。。。。
日志拦截器
public class LoggerInterceptor implements HandlerInterceptor
{
//请求开始时间标识
private static final String LOGGER_SEND_TIME = "_send_time";
//请求日志实体标识
private static final String LOGGER_ENTITY = "_logger_entity";
/**
* 进入SpringMVC的Controller之前开始记录日志实体
* @param request 请求对象
* @param response 响应对象
* @param o
* @return
* @throws Exception
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object o) throws Exception {
//创建日志实体
LoggerEntity logger = new LoggerEntity();
//获取请求sessionId
String sessionId = request.getRequestedSessionId();
//请求路径
String url = request.getRequestURI();
//获取请求参数信息
String paramData = JSON.toJSONString(request.getParameterMap(),
SerializerFeature.DisableCircularReferenceDetect,
SerializerFeature.WriteMapNullValue);
//设置客户端ip
logger.setClientIp(LoggerUtils.getCliectIp(request));
//设置请求方法
logger.setMethod(request.getMethod());
//设置请求类型（json|普通请求）
logger.setType(LoggerUtils.getRequestType(request));
//设置请求参数内容json字符串
logger.setParamData(paramData);
//设置请求地址
logger.setUri(url);
//设置sessionId
logger.setSessionId(sessionId);
//设置请求开始时间
request.setAttribute(LOGGER_SEND_TIME,System.currentTimeMillis());
//设置请求实体到request内，方面afterCompletion方法调用
request.setAttribute(LOGGER_ENTITY,logger);
return true;
}
@Override
public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object o, Exception e) throws Exception {
//获取请求错误码
int status = response.getStatus();
//当前时间
long currentTime = System.currentTimeMillis();
//请求开始时间
long time = Long.valueOf(request.getAttribute(LOGGER_SEND_TIME).toString());
//获取本次请求日志实体
LoggerEntity loggerEntity = (LoggerEntity) request.getAttribute(LOGGER_ENTITY);
//设置请求时间差
loggerEntity.setTimeConsuming(Integer.valueOf((currentTime - time)+""));
//设置返回时间
loggerEntity.setReturnTime(currentTime + "");
//设置返回错误码
loggerEntity.setHttpStatusCode(status+"");
//设置返回值
loggerEntity.setReturnData(JSON.toJSONString(request.getAttribute(LoggerUtils.LOGGER_RETURN),
SerializerFeature.DisableCircularReferenceDetect,
SerializerFeature.WriteMapNullValue));
//执行将日志写入数据库
LoggerJPA loggerDAO = getDAO(LoggerJPA.class,request);
loggerDAO.save(loggerEntity);
}
/**
* 根据传入的类型获取spring管理的对应dao
* @param clazz 类型
* @param request 请求对象
* @param <T>
* @return
*/
private <T> T getDAO(Class<T> clazz,HttpServletRequest request)
{
BeanFactory factory = WebApplicationContextUtils.getRequiredWebApplicationContext(request.getServletContext());
return factory.getBean(clazz);
}
}注册日志拦截器省略。。。。
文件上传
视图
form表单注意要添加' enctype="multipart/form-data" '
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
单个文件上传：<br/>
<form action="/upload" method="post" enctype="multipart/form-data">
<input type="file" name="file"/>
<input type="submit" value="提交上传"/>
</form>
<br/>
多个文件上传：
<form action="/uploads" method="post" enctype="multipart/form-data">
文件1：<input type="file" name="file"/><br/>
文件2：<input type="file" name="file"/><br/>
文件3：<input type="file" name="file"/><br/>
<input type="submit" value="上传多个文件"/>
</form>
</body>
</html>接收文件处理
@Controller
public class UploadController {
/**
* 初始化上传文件界面，跳转到index.jsp
* @return
*/
@RequestMapping(value = "/index",method = RequestMethod.GET)
public String index(){
return "index";
}
/**
* 提取上传方法为公共方法
* @param uploadDir 上传文件目录
* @param file 上传对象
* @throws Exception
*/
private void executeUpload(String uploadDir,MultipartFile file) throws Exception
{
//文件后缀名
String suffix = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf("."));
//上传文件名
String filename = UUID.randomUUID() + suffix;
//服务器端保存的文件对象
File serverFile = new File(uploadDir + filename);
//将上传的文件写入到服务器端文件内
file.transferTo(serverFile);
}
/**
* 上传文件方法
* @param file 前台上传的文件对象
* @return
*/
@RequestMapping(value = "/upload",method = RequestMethod.POST)
public @ResponseBody String upload(HttpServletRequest request,MultipartFile file)
{
try {
//上传目录地址
String uploadDir = request.getSession().getServletContext().getRealPath("/") +"upload/";
//如果目录不存在，自动创建文件夹
File dir = new File(uploadDir);
if(!dir.exists())
{
dir.mkdir();
}
//调用上传方法
executeUpload(uploadDir,file);
}catch (Exception e)
{
//打印错误堆栈信息
e.printStackTrace();
return "上传失败";
}
return "上传成功";
}
/**
* 上传多个文件
* @param request 请求对象
* @param file 上传文件集合
* @return
*/
@RequestMapping(value = "/uploads",method = RequestMethod.POST)
public @ResponseBody String uploads(HttpServletRequest request,MultipartFile[] file)
{
try {
//上传目录地址
String uploadDir = request.getSession().getServletContext().getRealPath("/") +"upload/";
//如果目录不存在，自动创建文件夹
File dir = new File(uploadDir);
if(!dir.exists())
{
dir.mkdir();
}
//遍历文件数组执行上传
for (int i =0;i<file.length;i++) {
if(file[i] != null) {
//调用上传方法
executeUpload(uploadDir, file[i]);
}
}
}catch (Exception e)
{
//打印错误堆栈信息
e.printStackTrace();
return "上传失败";
}
return "上传成功";
}
}注意点
限制文件上传大小
spring.http.multipart.max-file-size=1024Mb
spring.http.multipart.max-request-size=2048Mb自定义参数装载
supportsParameter方法顾名思义，是允许装载的参数，也就是说方法返回true时才会指定装载方法完成参数装载resolveArgument方法是参数状态的实现逻辑方法，该方法返回的值会直接装载到指定的参数上
public class CustomerArgumentResolver
implements HandlerMethodArgumentResolver
{
/**
* 日志对象
*/
private Logger logger = LoggerFactory.getLogger(CustomerArgumentResolver.class);
/**
* 该方法返回true时调用resolveArgument方法执行逻辑
* spring家族的架构设计万变不离其宗啊，在之前event & listener也是用到了同样的方式
* @param methodParameter
* @return
*/
@Override
public boolean supportsParameter(MethodParameter methodParameter) {
return methodParameter.hasParameterAnnotation(ParameterModel.class);
}
/**
* 装载参数
* @param methodParameter 方法参数
* @param modelAndViewContainer 返回视图容器
* @param nativeWebRequest 本次请求对象
* @param webDataBinderFactory 数据绑定工厂
* @return
* @throws Exception
*/
@Override
public Object resolveArgument (
MethodParameter methodParameter,
ModelAndViewContainer modelAndViewContainer,
NativeWebRequest nativeWebRequest,
WebDataBinderFactory webDataBinderFactory
)
throws Exception
{
String parameterName = methodParameter.getParameterName();
logger.info("参数名称：{}",parameterName);
/**
* 目标返回对象
* 如果Model存在该Attribute时从module内获取并设置为返回值
* 如果Model不存在该Attribute则从request parameterMap内获取并设置为返回值
*/
Object target = modelAndViewContainer.containsAttribute(parameterName) ?
modelAndViewContainer.getModel().get(parameterName) : createAttribute(parameterName, methodParameter, webDataBinderFactory, nativeWebRequest);;
/**
* 返回内容，这里返回的内容才是最终装载到参数的值
*/
return target;
}
/**
* 根据参数attributeName获取请求的值
* @param attributeName 请求参数
* @param parameter method 参数对象
* @param binderFactory 数据绑定工厂
* @param request 请求对象
* @return
* @throws Exception
*/
protected Object createAttribute(String attributeName, MethodParameter parameter,
WebDataBinderFactory binderFactory, NativeWebRequest request) throws Exception {
/**
* 获取attributeName的值
*/
String value = getRequestValueForAttribute(attributeName, request);
/**
* 如果存在值
*/
if (value != null) {
/**
* 进行类型转换
* 检查请求的类型与目标参数类型是否可以进行转换
*/
Object attribute = convertAttributeToParameterValue(value, attributeName, parameter, binderFactory, request);
/**
* 如果存在转换后的值，则返回
*/
if (attribute != null) {
return attribute;
}
}
/**
* 检查request parameterMap 内是否存在以attributeName作为前缀的数据
* 如果存在则根据字段的类型来进行设置值、集合、数组等
*/
else
{
Object attribute = putParameters(parameter,request);
if(attribute!=null)
{
return attribute;
}
}
/**
* 如果以上两种条件不符合，直接返回初始化参数类型的空对象
*/
return BeanUtils.instantiateClass(parameter.getParameterType());
}
/**
* 将attribute的值转换为parameter参数值类型
* @param sourceValue 源请求值
* @param attributeName 参数名
* @param parameter 目标参数对象
* @param binderFactory 数据绑定工厂
* @param request 请求对象
* @return
* @throws Exception
*/
protected Object convertAttributeToParameterValue(String sourceValue,
String attributeName,
MethodParameter parameter,
WebDataBinderFactory binderFactory,
NativeWebRequest request) throws Exception {
/**
* 获取类型转换业务逻辑实现类
*/
DataBinder binder = binderFactory.createBinder(request, null, attributeName);
ConversionService conversionService = binder.getConversionService();
if (conversionService != null) {
/**
* 源类型描述
*/
TypeDescriptor source = TypeDescriptor.valueOf(String.class);
/**
* 根据目标参数对象获取目标参数类型描述
*/
TypeDescriptor target = new TypeDescriptor(parameter);
/**
* 验证是否可以进行转换
*/
if (conversionService.canConvert(source, target)) {
/**
* 返回转换后的值
*/
return binder.convertIfNecessary(sourceValue, parameter.getParameterType(), parameter);
}
}
return null;
}
/**
* 从request parameterMap集合内获取attributeName的值
* @param attributeName 参数名称
* @param request 请求对象
* @return
*/
protected String getRequestValueForAttribute(String attributeName, NativeWebRequest request) {
/**
* 获取PathVariables参数集合
*/
Map<String, String> variables = getUriTemplateVariables(request);
/**
* 如果PathVariables参数集合内存在该attributeName
* 直接返回相对应的值
*/
if (StringUtils.hasText(variables.get(attributeName))) {
return variables.get(attributeName);
}
/**
* 如果request parameterMap内存在该attributeName
* 直接返回相对应的值
*/
else if (StringUtils.hasText(request.getParameter(attributeName))) {
return request.getParameter(attributeName);
}
//不存在时返回null
else {
return null;
}
}
/**
* 获取指定前缀的参数：包括uri varaibles 和 parameters
*
* @param namePrefix
* @param request
* @return
* @subPrefix 是否截取掉namePrefix的前缀
*/
protected Map<String, String[]> getPrefixParameterMap(String namePrefix, NativeWebRequest request, boolean subPrefix) {
Map<String, String[]> result = new HashMap();
/**
* 从PathVariables内获取该前缀的参数列表
*/
Map<String, String> variables = getUriTemplateVariables(request);
int namePrefixLength = namePrefix.length();
for (String name : variables.keySet()) {
if (name.startsWith(namePrefix)) {
//page.pn 则截取 pn
if (subPrefix) {
char ch = name.charAt(namePrefix.length());
//如果下一个字符不是 数字 . _ 则不可能是查询 只是前缀类似
if (illegalChar(ch)) {
continue;
}
result.put(name.substring(namePrefixLength + 1), new String[]{variables.get(name)});
} else {
result.put(name, new String[]{variables.get(name)});
}
}
}
/**
* 从request parameterMap集合内获取该前缀的参数列表
*/
Iterator<String> parameterNames = request.getParameterNames();
while (parameterNames.hasNext()) {
String name = parameterNames.next();
if (name.startsWith(namePrefix)) {
//page.pn 则截取 pn
if (subPrefix) {
char ch = name.charAt(namePrefix.length());
//如果下一个字符不是 数字 . _ 则不可能是查询 只是前缀类似
if (illegalChar(ch)) {
continue;
}
result.put(name.substring(namePrefixLength + 1), request.getParameterValues(name));
} else {
result.put(name, request.getParameterValues(name));
}
}
}
return result;
}
/**
* 验证参数前缀是否合法
* @param ch
* @return
*/
private boolean illegalChar(char ch) {
return ch != '.' && ch != '_' && !(ch >= '0' && ch <= '9');
}
/**
* 获取PathVariables集合
* @param request 请求对象
* @return
*/
protected final Map<String, String> getUriTemplateVariables(NativeWebRequest request) {
Map<String, String> variables =
(Map<String, String>) request.getAttribute(
HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);
return (variables != null) ? variables : Collections.emptyMap();
}
/**
* 从request内获取parameter前缀的所有参数
* 并根据parameter的类型将对应字段的值设置到parmaeter对象内并返回
* @param parameter
* @param request
* @return
*/
protected Object putParameters(MethodParameter parameter,NativeWebRequest request)
{
/**
* 根据请求参数类型初始化空对象
*/
Object object = BeanUtils.instantiateClass(parameter.getParameterType());
/**
* 获取指定前缀的请求参数集合
*/
Map<String, String[]> parameters = getPrefixParameterMap(parameter.getParameterName(),request,true);
Iterator<String> iterator = parameters.keySet().iterator();
while(iterator.hasNext())
{
//字段名称
String fieldName = iterator.next();
//请求参数值
String[] parameterValue = parameters.get(fieldName);
try {
Field field = object.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
//字段的类型
Class<?> fieldTargetType = field.getType();
/**
* List（ArrayList、LinkedList）类型
* 将数组类型的值转换为List集合对象
*/
if(List.class.isAssignableFrom(fieldTargetType))
{
field.set(object, Arrays.asList(parameterValue));
}
/**
*Object数组类型，直接将数组值设置为目标字段的值
*/
else if(Object[].class.isAssignableFrom(fieldTargetType))
{
field.set(object, parameterValue);
}
/**
* 单值时获取数组索引为0的值
*/
else {
field.set(object, parameterValue[0]);
}
}
catch (Exception e)
{
logger.error("Set Field：{} Value Error，In {}",fieldName,object.getClass().getName());
continue;
}
}
return object;
}
}配置Spring托管CustomerArgumentResolver
@Configuration
public class WebMvcConfiguration
extends WebMvcConfigurerAdapter
{
/**
* 添加参数装载
* @param argumentResolvers
*/
@Override
public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
/**
* 将自定义的参数装载添加到spring内托管
*/
argumentResolvers.add(new CustomerArgumentResolver());
}
/**
* 配置静态请求视图映射
* @param registry
*/
@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/index").setViewName("index");
}
}WebMvcConfigurer
JavaBean配置WebMvcConfigurer
@Configuration public class WebJavaBeanConfiguration { /** * 日志拦截器 */ @Autowired private LogInterceptor logInterceptor; /** * 实例化WebMvcConfigurer接口 * * @return */ @Bean public WebMvcConfigurer webMvcConfigurer() { return new WebMvcConfigurer() { /** * 添加拦截器 * @param registry */ @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(logInterceptor).addPathPatterns("/**"); } }; } }实现类配置WebMvcConfigurer
@Configuration public class WebConfiguration implements WebMvcConfigurer { /** * 日志拦截器 */ @Autowired private LogInterceptor logInterceptor; /** * 重写添加拦截器方法并添加配置拦截器 * @param registry */ @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(logInterceptor).addPathPatterns("/**"); } }
Start
Pom依赖
<!--版本采用的是最新的 2.0.1.RELEASE TODO 开发中请记得版本一定要选择 RELEASE 哦 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.1.RELEASE</version>
<relativePath /> <!-- lookup parent from repository -->
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!-- 默认就内嵌了Tomcat 容器，如需要更换容器也极其简单 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- 测试包,当我们使用 mvn package 的时候该包并不会被打入,因为它的生命周期只在 test 之内 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<!-- 编译插件 -->
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>配置文件
springboot中配置文件application.properties的理解
application.properties
# ----------------------------------------
# CORE PROPERTIES
# ----------------------------------------
# SPRING 相关配置 (ConfigFileApplicationListener)
spring.config.name= # config file name (default to 'application')
spring.config.location= # location of config file
# profile相关配置
spring.profiles= # comma list of active profiles
# 系统配置相关参数 (SpringApplication)
spring.main.sources=
spring.main.web-environment= # detect by default
spring.main.show-banner=true
spring.main....= # see class for all properties
# 日志配置相关参数
logging.path=/var/logs
logging.file=myapp.log
logging.config=
# IDENTITY (ContextIdApplicationContextInitializer)
spring.application.name=
spring.application.index=
# tomcat相关配置参数 (ServerProperties)
server.port=8080
server.address= # bind to a specific NIC
server.session-timeout= # session timeout in seconds
server.context-path= # the context path, defaults to '/'
server.servlet-path= # the servlet path, defaults to '/'
server.tomcat.access-log-pattern= # log pattern of the access log
server.tomcat.access-log-enabled=false # is access logging enabled
server.tomcat.protocol-header=x-forwarded-proto # ssl forward headers
server.tomcat.remote-ip-header=x-forwarded-for
server.tomcat.basedir=/tmp # base dir (usually not needed, defaults to tmp)
server.tomcat.background-processor-delay=30; # in seconds
server.tomcat.max-threads = 0 # number of threads in protocol handler
server.tomcat.uri-encoding = UTF-8 # character encoding to use for URL decoding
# springmvc相关配置参数 (HttpMapperProperties)
http.mappers.json-pretty-print=false # pretty print JSON
http.mappers.json-sort-keys=false # sort keys
spring.mvc.locale= # set fixed locale, e.g. en_UK
spring.mvc.date-format= # set fixed date format, e.g. dd/MM/yyyy
spring.mvc.message-codes-resolver-format= # PREFIX_ERROR_CODE / POSTFIX_ERROR_CODE
spring.view.prefix= # MVC view prefix
spring.view.suffix= # ... and suffix
spring.resources.cache-period= # cache timeouts in headers sent to browser
spring.resources.add-mappings=true # if default mappings should be added
# thymeleaf相关配置参数 (ThymeleafAutoConfiguration)
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html
spring.thymeleaf.mode=HTML5
spring.thymeleaf.encoding=UTF-8
spring.thymeleaf.content-type=text/html # ;charset=<encoding> is added
spring.thymeleaf.cache=true # set to false for hot refresh
# freemark相关配置参数 (FreeMarkerAutoConfiguration)
spring.freemarker.allowRequestOverride=false
spring.freemarker.allowSessionOverride=false
spring.freemarker.cache=true
spring.freemarker.checkTemplateLocation=true
spring.freemarker.contentType=text/html
spring.freemarker.exposeRequestAttributes=false
spring.freemarker.exposeSessionAttributes=false
spring.freemarker.exposeSpringMacroHelpers=false
spring.freemarker.prefix=
spring.freemarker.requestContextAttribute=
spring.freemarker.settings.*=
spring.freemarker.suffix=.ftl
spring.freemarker.templateEncoding=UTF-8
spring.freemarker.templateLoaderPath=classpath:/templates/
spring.freemarker.viewNames= # whitelist of view names that can be resolved
# groovy模板相关配置参数 (GroovyTemplateAutoConfiguration)
spring.groovy.template.allowRequestOverride=false
spring.groovy.template.allowSessionOverride=false
spring.groovy.template.cache=true
spring.groovy.template.configuration.*= # See Groovy's TemplateConfiguration
spring.groovy.template.contentType=text/html
spring.groovy.template.prefix=classpath:/templates/
spring.groovy.template.suffix=.tpl
spring.groovy.template.templateEncoding=UTF-8
spring.groovy.template.viewNames= # whitelist of view names that can be resolved
# velocity模板相关配置参数 (VelocityAutoConfiguration)
spring.velocity.allowRequestOverride=false
spring.velocity.allowSessionOverride=false
spring.velocity.cache=true
spring.velocity.checkTemplateLocation=true
spring.velocity.contentType=text/html
spring.velocity.dateToolAttribute=
spring.velocity.exposeRequestAttributes=false
spring.velocity.exposeSessionAttributes=false
spring.velocity.exposeSpringMacroHelpers=false
spring.velocity.numberToolAttribute=
spring.velocity.prefix=
spring.velocity.properties.*=
spring.velocity.requestContextAttribute=
spring.velocity.resourceLoaderPath=classpath:/templates/
spring.velocity.suffix=.vm
spring.velocity.templateEncoding=UTF-8
spring.velocity.viewNames= # whitelist of view names that can be resolved
# INTERNATIONALIZATION (MessageSourceAutoConfiguration)
spring.messages.basename=messages
spring.messages.cacheSeconds=-1
spring.messages.encoding=UTF-8
# 安全相关配置参数 (SecurityProperties)
security.user.name=user # login username
security.user.password= # login password
security.user.role=USER # role assigned to the user
security.require-ssl=false # advanced settings ...
security.enable-csrf=false
security.basic.enabled=true
security.basic.realm=Spring
security.basic.path= # /**
security.headers.xss=false
security.headers.cache=false
security.headers.frame=false
security.headers.contentType=false
security.headers.hsts=all # none / domain / all
security.sessions=stateless # always / never / if_required / stateless
security.ignored=false
# 数据源相关配置参数(DataSourceAutoConfiguration & DataSourceProperties)
spring.datasource.name= # name of the data source
spring.datasource.initialize=true # populate using data.sql
spring.datasource.schema= # a schema (DDL) script resource reference
spring.datasource.data= # a data (DML) script resource reference
spring.datasource.platform= # the platform to use in the schema resource (schema-${platform}.sql)
spring.datasource.continueOnError=false # continue even if can't be initialized
spring.datasource.separator=; # statement separator in SQL initialization scripts
spring.datasource.driverClassName= # JDBC Settings...
spring.datasource.url=
spring.datasource.username=
spring.datasource.password=
spring.datasource.max-active=100 # Advanced configuration...
spring.datasource.max-idle=8
spring.datasource.min-idle=8
spring.datasource.initial-size=10
spring.datasource.validation-query=
spring.datasource.test-on-borrow=false
spring.datasource.test-on-return=false
spring.datasource.test-while-idle=
spring.datasource.time-between-eviction-runs-millis=
spring.datasource.min-evictable-idle-time-millis=
spring.datasource.max-wait-millis=
# mongdb相关配置参数 (MongoProperties)
spring.data.mongodb.host= # the db host
spring.data.mongodb.port=27017 # the connection port (defaults to 27107)
spring.data.mongodb.uri=mongodb://localhost/test # connection URL
spring.data.mongo.repositories.enabled=true # if spring data repository support is enabled
# springDataJPA相关配置参数(JpaBaseConfiguration, HibernateJpaAutoConfiguration)
spring.jpa.properties.*= # properties to set on the JPA connection
spring.jpa.openInView=true
spring.jpa.show-sql=true
spring.jpa.database-platform=
spring.jpa.database=
spring.jpa.generate-ddl=false # ignored by Hibernate, might be useful for other vendors
spring.jpa.hibernate.naming-strategy= # naming classname
spring.jpa.hibernate.ddl-auto= # defaults to create-drop for embedded dbs
spring.data.jpa.repositories.enabled=true # if spring data repository support is enabled
# solr相关配置参数(SolrProperties})
spring.data.solr.host=http://127.0.0.1:8983/solr
spring.data.solr.zkHost=
spring.data.solr.repositories.enabled=true # if spring data repository support is enabled
# elasticsearch相关配置参数(ElasticsearchProperties})
spring.data.elasticsearch.cluster-name= # The cluster name (defaults to elasticsearch)
spring.data.elasticsearch.cluster-nodes= # The address(es) of the server node (comma-separated; if not specified starts a client node)
spring.data.elasticsearch.local=true # if local mode should be used with client nodes
spring.data.elasticsearch.repositories.enabled=true # if spring data repository support is enabled
# flyway相关配置参数(FlywayProperties)
flyway.locations=classpath:db/migrations # locations of migrations scripts
flyway.schemas= # schemas to update
flyway.initVersion= 1 # version to start migration
flyway.prefix=V
flyway.suffix=.sql
flyway.enabled=true
flyway.url= # JDBC url if you want Flyway to create its own DataSource
flyway.user= # JDBC username if you want Flyway to create its own DataSource
flyway.password= # JDBC password if you want Flyway to create its own DataSource
# liquibase相关配置参数(LiquibaseProperties)
liquibase.change-log=classpath:/db/changelog/db.changelog-master.yaml
liquibase.contexts= # runtime contexts to use
liquibase.default-schema= # default database schema to use
liquibase.drop-first=false
liquibase.enabled=true
# JMX
spring.jmx.enabled=true # Expose MBeans from Spring
# rabbitmq相关配置参数(RabbitProperties)
spring.rabbitmq.host= # connection host
spring.rabbitmq.port= # connection port
spring.rabbitmq.addresses= # connection addresses (e.g. myhost:9999,otherhost:1111)
spring.rabbitmq.username= # login user
spring.rabbitmq.password= # login password
spring.rabbitmq.virtualhost=
spring.rabbitmq.dynamic=
# redis相关配置参数(RedisProperties)
spring.redis.host=localhost # server host
spring.redis.password= # server password
spring.redis.port=6379 # connection port
spring.redis.pool.max-idle=8 # pool settings ...
spring.redis.pool.min-idle=0
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1
# activemq相关配置参数(ActiveMQProperties)
spring.activemq.broker-url=tcp://localhost:61616 # connection URL
spring.activemq.user=
spring.activemq.password=
spring.activemq.in-memory=true # broker kind to create if no broker-url is specified
spring.activemq.pooled=false
# hornetq相关配置参数(HornetQProperties)
spring.hornetq.mode= # connection mode (native, embedded)
spring.hornetq.host=localhost # hornetQ host (native mode)
spring.hornetq.port=5445 # hornetQ port (native mode)
spring.hornetq.embedded.enabled=true # if the embedded server is enabled (needs hornetq-jms-server.jar)
spring.hornetq.embedded.serverId= # auto-generated id of the embedded server (integer)
spring.hornetq.embedded.persistent=false # message persistence
spring.hornetq.embedded.data-directory= # location of data content (when persistence is enabled)
spring.hornetq.embedded.queues= # comma separate queues to create on startup
spring.hornetq.embedded.topics= # comma separate topics to create on startup
spring.hornetq.embedded.cluster-password= # customer password (randomly generated by default)
# JMS (JmsProperties)
spring.jms.pub-sub-domain= # false for queue (default), true for topic
# springbatch相关配置参数(BatchDatabaseInitializer)
spring.batch.job.names=job1,job2
spring.batch.job.enabled=true
spring.batch.initializer.enabled=true
spring.batch.schema= # batch schema to load
# aop相关配置参数
spring.aop.auto=
spring.aop.proxy-target-class=
# FILE ENCODING (FileEncodingApplicationListener)
spring.mandatory-file-encoding=false
# SPRING SOCIAL (SocialWebAutoConfiguration)
spring.social.auto-connection-views=true # Set to true for default connection views or false if you provide your own
# SPRING SOCIAL FACEBOOK (FacebookAutoConfiguration)
spring.social.facebook.app-id= # your application's Facebook App ID
spring.social.facebook.app-secret= # your application's Facebook App Secret
# SPRING SOCIAL LINKEDIN (LinkedInAutoConfiguration)
spring.social.linkedin.app-id= # your application's LinkedIn App ID
spring.social.linkedin.app-secret= # your application's LinkedIn App Secret
# SPRING SOCIAL TWITTER (TwitterAutoConfiguration)
spring.social.twitter.app-id= # your application's Twitter App ID
spring.social.twitter.app-secret= # your application's Twitter App Secret
# SPRING MOBILE SITE PREFERENCE (SitePreferenceAutoConfiguration)
spring.mobile.sitepreference.enabled=true # enabled by default
# SPRING MOBILE DEVICE VIEWS (DeviceDelegatingViewResolverAutoConfiguration)
spring.mobile.devicedelegatingviewresolver.enabled=true # disabled by default
spring.mobile.devicedelegatingviewresolver.normalPrefix=
spring.mobile.devicedelegatingviewresolver.normalSuffix=
spring.mobile.devicedelegatingviewresolver.mobilePrefix=mobile/
spring.mobile.devicedelegatingviewresolver.mobileSuffix=
spring.mobile.devicedelegatingviewresolver.tabletPrefix=tablet/
spring.mobile.devicedelegatingviewresolver.tabletSuffix=
# ----------------------------------------
# ACTUATOR PROPERTIES
# ----------------------------------------
# MANAGEMENT HTTP SERVER (ManagementServerProperties)
management.port= # defaults to 'server.port'
management.address= # bind to a specific NIC
management.contextPath= # default to '/'
# ENDPOINTS (AbstractEndpoint subclasses)
endpoints.autoconfig.id=autoconfig
endpoints.autoconfig.sensitive=true
endpoints.autoconfig.enabled=true
endpoints.beans.id=beans
endpoints.beans.sensitive=true
endpoints.beans.enabled=true
endpoints.configprops.id=configprops
endpoints.configprops.sensitive=true
endpoints.configprops.enabled=true
endpoints.configprops.keys-to-sanitize=password,secret
endpoints.dump.id=dump
endpoints.dump.sensitive=true
endpoints.dump.enabled=true
endpoints.env.id=env
endpoints.env.sensitive=true
endpoints.env.enabled=true
endpoints.health.id=health
endpoints.health.sensitive=false
endpoints.health.enabled=true
endpoints.info.id=info
endpoints.info.sensitive=false
endpoints.info.enabled=true
endpoints.metrics.id=metrics
endpoints.metrics.sensitive=true
endpoints.metrics.enabled=true
endpoints.shutdown.id=shutdown
endpoints.shutdown.sensitive=true
endpoints.shutdown.enabled=false
endpoints.trace.id=trace
endpoints.trace.sensitive=true
endpoints.trace.enabled=true
# MVC ONLY ENDPOINTS
endpoints.jolokia.path=jolokia
endpoints.jolokia.sensitive=true
endpoints.jolokia.enabled=true # when using Jolokia
endpoints.error.path=/error
# JMX ENDPOINT (EndpointMBeanExportProperties)
endpoints.jmx.enabled=true
endpoints.jmx.domain= # the JMX domain, defaults to 'org.springboot'
endpoints.jmx.unique-names=false
endpoints.jmx.enabled=true
endpoints.jmx.staticNames=
# JOLOKIA (JolokiaProperties)
jolokia.config.*= # See Jolokia manual
# REMOTE SHELL
shell.auth=simple # jaas, key, simple, spring
shell.command-refresh-interval=-1
shell.command-path-pattern= # classpath*:/commands/**, classpath*:/crash/commands/**
shell.config-path-patterns= # classpath*:/crash/*
shell.disabled-plugins=false # don't expose plugins
shell.ssh.enabled= # ssh settings ...
shell.ssh.keyPath=
shell.ssh.port=
shell.telnet.enabled= # telnet settings ...
shell.telnet.port=
shell.auth.jaas.domain= # authentication settings ...
shell.auth.key.path=
shell.auth.simple.user.name=
shell.auth.simple.user.password=
shell.auth.spring.roles=
# GIT INFO
spring.git.properties= # resource ref to generated git info properties filebanner
在目录中添加 banner.txt 文件，添加内容既可以修改启动的banner信息。
Java Code
@RestController
@SpringBootApplication
public class Chapter1Application {
public static void main(String[] args) {
SpringApplication.run(Chapter1Application.class, args);
}
@GetMapping("/demo1")
public String demo1() {
return "run time";
}
@Bean
public CommandLineRunner commandLineRunner(ApplicationContext ctx) {
// 目的是
return args -> {
System.out.println("来看看 SpringBoot 默认为我们提供的 Bean：");
String[] beanNames = ctx.getBeanDefinitionNames();
Arrays.sort(beanNames);
Arrays.stream(beanNames).forEach(System.out::println);
};
}
}
properties config
自定义配置依赖，可引入可不引入。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>自定义属性配置
- 通过注解注入
application.properties中定义属性：
my1.age=123
my1.name=zhangsan通过属性注入
@value("${my1.age}")
private int age;
@value("${my1.name}")
private String name;
- 通过定义class注入
application.properties中定义属性：
my2.age=123
my2.name=zhangsan定义class类[MyProperties1]：
@Component
@ConfigurationProperties(prefix = "my1")
public class MyProperties1{
private int age;
private String name;
public int getAge(){
return this.age;
}
public void setAge(int age){
this.age = age;
}
public String getName(){
return this.name;
}
public void setName(String name){
this.name = name;
}
}自定义文件配置
添加自定义的属性配置文件[my3.properties]
my3.age=13
my3.name=liwu定义class类[MyProperties2]：
@Component
@PropertySource("classpath:my3.properties")
@ConfigurationProperties(prefix = "my1")
public class MyProperties2{
private int age;
private String name;
public int getAge(){
return this.age;
}
public void setAge(int age){
this.age = age;
}
public String getName(){
return this.name;
}
public void setName(String name){
this.name = name;
}
}多环境化配置
常用的应用开发过程，一般都分为多套环境进行迭代开发。
SANDBOX环境、Dev环境、 ST2环境、PROD环境。
而每套环境的数据库、日志级别、缓存、消息中间件等参数的不同，可能每套环境都需要一套自定义的应用配置文件。
SpringBoot中支持多个配置文件，通过“spring.profiles.active=dev”和“application-{profile}.properties”来让那个环境属性文件生效。
例如： Dev环境[application-dev.properties]
server.servlet.context-path=/devST2环境[application-st2.properties]
server.servlet.context-path=/st2PROD环境[application-prod.properties]
server.servlet.context-path=/prod外部命令引导
应用开发完成打包，通过jar命令启动服务时，可以通过参数追加来引导。
如：
java -jar chapter2-0.0.1-SNAPSHOT.jar --spring.profiles.active=test --my1.age=32
日志配置
Spring Boot 内部采用的是 Commons Logging进行日志记录，但在底层为 Java Util Logging、Log4J2、Logback 等日志框架提供了默认配置 。
Java 虽然有很多可用的日志框架，但请不要担心，一般来说，使用 SpringBoot 默认的 Logback 就可以了。
日志格式
Logback 是没有 FATAL 级别的日志，它将被映射到 ERROR
- 时间日期：精确到毫秒,可以用于排序
- 日志级别：ERROR、WARN、INFO、DEBUG、TRACE
- 进程ID
- 分隔符：采用 --- 来标识日志开始部分
- 线程名：方括号括起来（可能会截断控制台输出）
- Logger名：通常使用源代码的类名
- 日志内容：我们输出的消息
日志输出级别
SpringBoot 默认为我们输出的日志级别为 INFO、WARN、ERROR，如需要输出更多日志的时候，可以通过以下方式开启
- 命令模式配置：
java -jar app.jar --debug=true， 这种命令会被 SpringBoot 解析，且优先级最高 - 资源文件配置：
application.properties配置debug=true即可。该配置只对 嵌入式容器、Spring、Hibernate生效，我们自己的项目想要输出 DEBUG 需要额外配置（配置规则：logging.level.<logger-name>=<level>）
日志输出级别配置
logging.level.root = WARN
logging.level.org.springframework.web = DEBUG
logging.level.org.hibernate = ERROR
#比如 mybatis sql日志
logging.level.org.mybatis = INFO
logging.level.mapper所在的包 = DEBUG日志输出格式配置
logging.pattern.console： 定义输出到控制台的格式（不支持JDK Logger）
logging.pattern.file： 定义输出到文件的格式（不支持JDK Logger）LogBack读取配置文件的步骤
（1）尝试classpath下查找文件logback-test.xml
（2）如果文件不存在，尝试查找logback.xml
（3）如果两个文件都不存在，LogBack用BasicConfiguration自动对自己进行最小化配置，这样既实现了上面我们不需要添加任何配置就可以输出到控制台日志信息。配置模板
<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
<!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径-->
<property name="LOG_HOME" value="./logs" />
<!-- 控制台输出 -->
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg %n</pattern>
</encoder>
</appender>
<!-- 按照每天生成日志文件 -->
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!--日志文件输出的文件名-->
<FileNamePattern>${LOG_HOME}/runtime.log.%d{yyyy-MM-dd}.log</FileNamePattern>
<!--日志文件保留天数-->
<MaxHistory>30</MaxHistory>
</rollingPolicy>
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符-->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
</encoder>
<!--日志文件最大的大小-->
<triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
<MaxFileSize>10MB</MaxFileSize>
</triggeringPolicy>
</appender>
<!-- 日志输出级别 -->
<root level="INFO">
<appender-ref ref="STDOUT" />
<appender-ref ref="FILE" />
</root>
</configuration>屏蔽记录日志
logging:
level:
xxx.txx.xxxx.xxxx: 'off'在application.yml配置文件内，off必须添加双引号，否则不会生效。
颜色编码
如果终端支持 ANSI，默认情况下会给日志上个色，提高可读性，可以在配置文件中设置 spring.output.ansi.enabled 来改变默认值
ALWAYS： 启用 ANSI 颜色的输出。
DETECT： 尝试检测 ANSI 着色功能是否可用。
NEVER： 禁用 ANSI 颜色的输出。
编码对照表
Level Color
WARN Yellow
FATAL、ERROR Red
INFO、DEBUG、TRACE Green
如果想修改日志默认色值，可以通过使用 %clr 关键字转换。比如想使文本变为黄色 %clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){yellow}。目前支持的颜色有（blue、cyan、faint、green、magenta、red、yellow）
文件保存
默认情况下，SpringBoot 仅将日志输出到控制台，不会写入到日志文件中去。如果除了控制台输出之外还想写日志文件，则需要在application.properties 设置logging.file 或 logging.path 属性。
logging.file： 将日志写入到指定的 文件 中，默认为相对路径，可以设置成绝对路径
logging.path： 将名为 spring.log 写入到指定的 文件夹 中，如（/var/log）
日志文件在达到 10MB 时进行切割，产生一个新的日志文件（如：spring.1.log、spring.2.log），新的日志依旧输出到 spring.log 中去，默认情况下会记录 ERROR、WARN、INFO 级别消息。
logging.file.max-size： 限制日志文件大小
logging.file.max-history： 限制日志保留天数
自定义日志配置
由于日志在 ApplicationContext 之前就初始化好了，所以 SpringBoot 为我们提供了 logging.config 属性，方便我们配置自定义日志文件。默认情况它会根据日志的依赖自动加载。
Logging System Customization
JDK (Java Util Logging) logging.properties
Log4j2、ERROR log4j2-spring.xml 或 log4j2.xml
Logback logback-spring.xml、logback-spring.groovy、logback.xml、logback.groovy
Logback扩展配置
该扩展配置仅适用 logback-spring.xml 或者设置 logging.config 属性的文件，因为 logback.xml 加载过早，因此无法获取 SpringBoot 的一些扩展属性
使用扩展属性 springProfile 与 springProperty 让你的 logback-spring.xml 配置显得更有逼格，当别人还在苦苦挣扎弄logback-{profile}.xml的时候 你一个文件就搞定了…
springProfile<springProfile> 标签使我们让配置文件更加灵活，它可以选择性的包含或排除部分配置。
<springProfile name="dev">
<!-- 开发环境时激活 -->
</springProfile>
<springProfile name="dev,test">
<!-- 开发，测试的时候激活-->
</springProfile>
<springProfile name="!prod">
<!-- 当 "生产" 环境时，该配置不激活-->
</springProfile>springProperty<springProperty> 标签可以让我们在 Logback 中使用 Spring Environment 中的属性。如果想在logback-spring.xml中回读 application.properties 配置的值时，这是一个非常好的解决方案
<!-- 读取 spring.application.name 属性来生成日志文件名
scope：作用域
name：在 logback-spring.xml 使用的键
source：application.properties 文件中的键
defaultValue：默认值
-->
<springProperty scope="context" name="logName" source="spring.application.name" defaultValue="myapp.log"/>
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
<file>logs/${logName}.log</file>
</appender>模板引擎
Thymeleaf
资料
引入依赖
<!-- 引入 thymeleaf 依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>配置
# thymeleaf相关配置参数 (ThymeleafAutoConfiguration)
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html
spring.thymeleaf.mode=HTML5
spring.thymeleaf.encoding=UTF-8
spring.thymeleaf.content-type=text/html # ;charset=<encoding> is added
spring.thymeleaf.cache=true # set to false for hot refreshJava Code
- 通过`ModelAndView`的方式
@GetMapping("/index")
public ModelAndView index() {
ModelAndView view = new ModelAndView();
// 设置跳转的视图 默认映射到 src/main/resources/templates/{viewName}.html
view.setViewName("index");
// 设置属性
view.addObject("title", "我的第一个WEB页面");
view.addObject("desc", "欢迎进入battcn-web 系统");
Author author = new Author();
author.setAge(22);
author.setEmail("[email protected]");
author.setName("AAA");
view.addObject("author", author);
return view;
}
- 通过`HttpServletRequest`的方式
@GetMapping("/index1")
public String index1(HttpServletRequest request) {
// TODO 与上面的写法不同，但是结果一致。
// 设置属性
request.setAttribute("title", "我的第一个WEB页面");
request.setAttribute("desc", "欢迎进入battcn-web 系统");
Author author = new Author();
author.setAge(22);
author.setEmail("[email protected]");
author.setName("AAAAA");
request.setAttribute("author", author);
// 返回的 index 默认映射到 src/main/resources/templates/xxxx.html
return "index";
}
thymeleaf模板
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<!-- 可以看到 thymeleaf 是通过在标签里添加额外属性来绑定动态数据的 -->
<title th:text="${title}">Title</title>
<!-- 在/resources/static/js目录下创建一个hello.js 用如下语法依赖即可-->
<script type="text/javascript" th:src="@{/js/hello.js}"></script>
</head>
<body>
<h1 th:text="${desc}">Hello World</h1>
<h2>=====作者信息=====</h2>
<p th:text="${author?.name}"></p>
<p th:text="${author?.age}"></p>
<p th:text="${author?.email}"></p>
</body>
</html>文件上传
文件上传和下载是JAVA WEB中常见的一种操作，文件上传主要是将文件通过IO流传输到服务器的某一个特定的文件夹下；刚开始工作那会一个上传文件常常花费小半天的时间，繁琐的代码量以及XML配置让我是痛不欲生；值得庆幸的是有了Spring Boot短短的几句代码就能实现文件上传与本地写入操作….
属性配置
# 禁用 thymeleaf 缓存
spring.thymeleaf.cache=false
# 是否支持批量上传 (默认值 true)
spring.servlet.multipart.enabled=true
# 上传文件的临时目录 （一般情况下不用特意修改）
spring.servlet.multipart.location=
# 上传文件最大为 1M （默认值 1M 根据自身业务自行控制即可）
spring.servlet.multipart.max-file-size=1048576
# 上传请求最大为 10M（默认值10M 根据自身业务自行控制即可）
spring.servlet.multipart.max-request-size=10485760
# 文件大小阈值，当大于这个阈值时将写入到磁盘，否则存在内存中，（默认值0 一般情况下不用特意修改）
spring.servlet.multipart.file-size-threshold=0
# 判断是否要延迟解析文件（相当于懒加载，一般情况下不用特意修改）
spring.servlet.multipart.resolve-lazily=false上传页面
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>文件上传</title>
</head>
<body>
<h2>单一文件上传示例</h2>
<div>
<form method="POST" enctype="multipart/form-data" action="/uploads/upload1">
<p>
文件1：<input type="file" name="file"/>
<input type="submit" value="上传"/>
</p>
</form>
</div>
<hr/>
<h2>批量文件上传示例</h2>
<div>
<form method="POST" enctype="multipart/form-data"
action="/uploads/upload2">
<p>
文件1：<input type="file" name="file"/>
</p>
<p>
文件2：<input type="file" name="file"/>
</p>
<p>
<input type="submit" value="上传"/>
</p>
</form>
</div>
<hr/>
<h2>Base64文件上传</h2>
<div>
<form method="POST" action="/uploads/upload3">
<p>
BASE64编码：<textarea name="base64" rows="10" cols="80"></textarea>
<input type="submit" value="上传"/>
</p>
</form>
</div>
</body>
</html>FileUploadController
其中@GetMapping的方法用来跳转index.html页面，而@PostMapping相关方法则是对应的 单文件上传、多文件上传、BASE64编码 三种处理方式。
@RequestParam("file") 此处的"file"对应的就是html 中 name="file" 的 input 标签，而将文件真正写入的还是借助的commons-io中的FileUtils.copyInputStreamToFile(inputStream,file)
@Controller
@RequestMapping("/uploads")
public class FileUploadController {
public static void main(String[] args) {
SpringApplication.run(Chapter16Application.class, args);
}
private static final Logger log = LoggerFactory.getLogger(Chapter16Application.class);
@GetMapping
public String index() {
return "index";
}
@PostMapping("/upload1")
@ResponseBody
public Map<String, String> upload1(@RequestParam("file") MultipartFile file) throws IOException {
log.info("[文件类型] - [{}]", file.getContentType());
log.info("[文件名称] - [{}]", file.getOriginalFilename());
log.info("[文件大小] - [{}]", file.getSize());
// TODO 将文件写入到指定目录（具体开发中有可能是将文件写入到云存储/或者指定目录通过 Nginx 进行 gzip 压缩和反向代理，此处只是为了演示故将地址写成本地电脑指定目录）
file.transferTo(new File("F:\\app\\chapter16\\" + file.getOriginalFilename()));
Map<String, String> result = new HashMap<>(16);
result.put("contentType", file.getContentType());
result.put("fileName", file.getOriginalFilename());
result.put("fileSize", file.getSize() + "");
return result;
}
@PostMapping("/upload2")
@ResponseBody
public List<Map<String, String>> upload2(@RequestParam("file") MultipartFile[] files) throws IOException {
if (files == null || files.length == 0) {
return null;
}
List<Map<String, String>> results = new ArrayList<>();
for (MultipartFile file : files) {
// TODO Spring Mvc 提供的写入方式
file.transferTo(new File("F:\\app\\chapter16\\" + file.getOriginalFilename()));
Map<String, String> map = new HashMap<>(16);
map.put("contentType", file.getContentType());
map.put("fileName", file.getOriginalFilename());
map.put("fileSize", file.getSize() + "");
results.add(map);
}
return results;
}
@PostMapping("/upload3")
@ResponseBody
public void upload2(String base64) throws IOException {
// TODO BASE64 方式的 格式和名字需要自己控制（如 png 图片编码后前缀就会是 data:image/png;base64,）
final File tempFile = new File("F:\\app\\chapter16\\test.jpg");
// TODO 防止有的传了 data:image/png;base64, 有的没传的情况
String[] d = base64.split("base64,");
final byte[] bytes = Base64Utils.decodeFromString(d.length > 1 ? d[1] : d[0]);
FileCopyUtils.copy(bytes, tempFile);
}
}JSP
引入依赖
# 添加jsp依赖
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
</dependency>
# Servlet依赖
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
</dependency>
# JSTL依赖
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
</dependency>属性配置
spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp创建JSP
在src/main目录下添加 "webapp/WEB-INF/jsp/"
新增index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
this is index jsp page.
</body>
</html>Controller
@Controller
public class IndexController {
/**
* 访问webapp/jsp/index.jsp文件
* @return
*/
@RequestMapping(value = "/index",method = RequestMethod.GET)
public String index(){
return "index";
}
}JSON
fastJson是阿里巴巴旗下的一个开源项目之一，顾名思义它专门用来做快速操作Json的序列化与反序列化的组件。
引入依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.31</version>
</dependency>配置JSON视图
FastJson SerializerFeatures
- WriteNullListAsEmpty ：List字段如果为null,输出为[],而非null
- WriteNullStringAsEmpty ： 字符类型字段如果为null,输出为"",而非null
- DisableCircularReferenceDetect ：消除对同一对象循环引用的问题，默认为false（如果不配置有可能会进入死循环）
- WriteNullBooleanAsFalse：Boolean字段如果为null,输出为false,而非null
- WriteMapNullValue：是否输出值为null的字段,默认为false。
@Configuration
public class FastJsonConfiguration extends WebMvcConfigurerAdapter
{
/**
* 修改自定义消息转换器
* @param converters 消息转换器列表
*/
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
//调用父类的配置
super.configureMessageConverters(converters);
//创建fastJson消息转换器
FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
//创建配置类
FastJsonConfig fastJsonConfig = new FastJsonConfig();
//修改配置返回内容的过滤
fastJsonConfig.setSerializerFeatures(
SerializerFeature.DisableCircularReferenceDetect,
SerializerFeature.WriteMapNullValue,
SerializerFeature.WriteNullStringAsEmpty
);
fastConverter.setFastJsonConfig(fastJsonConfig);
//将fastjson添加到视图消息转换器列表内
converters.add(fastConverter);
}
}持久化
在application.properties中添加如下配置。值得注意的是，SpringBoot默认会自动配置DataSource，它将优先采用HikariCP连接池，如果没有该依赖的情况则选取tomcat-jdbc，如果前两者都不可用最后选取Commons DBCP2。通过spring.datasource.type属性可以指定其它种类的连接池
Spring JdbcTemplate
资料
引入依赖
<!-- JdbcTemplate依赖包 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!-- MYSQL包 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>数据源配置
application.properties 添加如下连接配置：
# spring database config
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&useSSL=false
spring.datasource.password=root
spring.datasource.username=root实体Model
import java.io.Serializable;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class User implements Serializable {
/**
*
*/
private static final long serialVersionUID = 8150275276859257942L;
private Long id;
private String username;
private String password;
}
JdbcTemplate服务
@Service
public class Chapter4Service {
private final JdbcTemplate jdbcTemplate;
@Autowired
public Chapter4Service(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
public List<User> queryUsers() {
// 查询所有用户
String sql = "select * from t_user";
return jdbcTemplate.query(sql, new Object[]{}, new BeanPropertyRowMapper<>(User.class));
}
public User getUser(Long id) {
// 根据主键ID查询
String sql = "select * from t_user where id = ?";
return jdbcTemplate.queryForObject(sql, new Object[]{id}, new BeanPropertyRowMapper<>(User.class));
}
public int delUser(Long id) {
// 根据主键ID删除用户信息
String sql = "DELETE FROM t_user WHERE id = ?";
return jdbcTemplate.update(sql, id);
}
public int addUser(User user) {
// 添加用户
String sql = "insert into t_user(username, password) values(?, ?)";
return jdbcTemplate.update(sql, user.getUsername(), user.getPassword());
}
public int editUser(Long id, User user) {
// 根据主键ID修改用户信息
String sql = "UPDATE t_user SET username = ? ,password = ? WHERE id = ?";
return jdbcTemplate.update(sql, user.getUsername(), user.getPassword(), id);
}
}验证示例
- 注意自已的项目是否配置path
- model要填加属性构造函数
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Chapter4Application.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class Chapter4ApplicationTests {
private static final Logger log = LoggerFactory.getLogger(Chapter4ApplicationTests.class);
@Autowired
private TestRestTemplate template;
@LocalServerPort
private int port;
@Test
public void test1() throws Exception {
template.postForEntity("http://localhost:" + port + "/users", new User("user1", "pass1"), Integer.class);
log.info("[添加用户成功]\n");
// TODO 如果是返回的集合,要用 exchange 而不是 getForEntity ，后者需要自己强转类型
ResponseEntity<List<User>> response2 = template.exchange("http://localhost:" + port + "/users", HttpMethod.GET, null, new ParameterizedTypeReference<List<User>>() {
});
final List<User> body = response2.getBody();
log.info("[查询所有] - [{}]\n", body);
Long userId = body.get(0).getId();
ResponseEntity<User> response3 = template.getForEntity("http://localhost:" + port + "/users/{id}", User.class, userId);
log.info("[主键查询] - [{}]\n", response3.getBody());
template.put("http://localhost:" + port + "/users/{id}", new User("user11", "pass11"), userId);
log.info("[修改用户成功]\n");
template.delete("http://localhost:" + port + "/users/{id}", userId);
log.info("[删除用户成功]");
}
}JPA(hibernate)
资料
引入依赖
<!-- Spring JDBC 的依赖包，使用 spring-boot-starter-jdbc 或 spring-boot-starter-data-jpa 将会自动获得HikariCP依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!-- MYSQL包 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>数据源配置
关于ddl-auto的几个选项：
- create： 每次运行程序时，都会重新创建表，故而数据会丢失
- create-drop： 每次运行程序时会先创建表结构，然后待程序结束时清空表
- upadte： 每次运行程序，没有表时会创建表，如果对象发生改变会更新表结构，原有数据不会清空，只会更新（推荐使用）
- validate： 运行程序会校验数据与数据库的字段类型是否相同，字段不同会报错
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&useSSL=false
spring.datasource.password=root
spring.datasource.username=root
#spring.datasource.type
# JPA\u914D\u7F6E
spring.jpa.hibernate.ddl-auto=update
# \u8F93\u51FA\u65E5\u5FD7
spring.jpa.show-sql=true
# \u6570\u636E\u5E93\u7C7B\u578B
spring.jpa.database=mysql实体Model
@Entity(name = "t_user")
@Getter
@Setter
public class User2 implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
/**
* 自增策略
* TABLE： 使用一个特定的数据库表格来保存主键
* SEQUENCE： 根据底层数据库的序列来生成主键，条件是数据库支持序列。这个值要与generator一起使用，generator 指定生成主键使用的生成器（可能是orcale中自己编写的序列）。
* IDENTITY： 主键由数据库自动生成（主要是支持自动增长的数据库，如mysql）
* AUTO： 主键由程序控制，也是GenerationType的默认值。
*/
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String username;
private String password;
/**
* 不需要映射
*/
@Transient
private String email;
public User2() { }
public User2(String username, String password) {
this.username = username;
this.password = password;
}
public User2(Long id, String username, String password) {
this.id = id;
this.username = username;
this.password = password;
}
}
Repository
/**
* chapter5 JPA Repository
*
* 针对User2操作
*
* 创建UserRepository数据访问层接口，需要继承JpaRepository<T,K>，
* 第一个泛型参数是实体对象的名称，第二个是主键类型。
* 只需要这样简单的配置，该UserRepository就拥常用的CRUD功能，paRepository本身就包含了常用功能。
* 剩下的查询我们按照规范写接口即可，
* JPA支持@Query注解写HQL，也支持findAllByUsername这种根据字段名命名的方式
*/
@Repository
public interface UserRepository extends JpaRepository<User2, Long> {
/**
* 根据用户名查询用户信息
*
* @param username 用户名
* @return 查询结果
*/
List<User2> findAllByUsername(String username);
}分页示例
//import org.springframework.data.domain.PageRequest;
//import org.springframework.data.domain.Sort;
@RequestMapping(value = "/cutpage")
public List<UserEntity> cutPage(int page)
{
UserEntity user = new UserEntity();
user.setSize(2);
user.setSord("desc");
user.setPage(page);
//获取排序对象
Sort.Direction sort_direction = Sort.Direction.ASC.toString().equalsIgnoreCase(user.getSord()) ? Sort.Direction.ASC : Sort.Direction.DESC;
//设置排序对象参数
Sort sort = new Sort(sort_direction, user.getSidx());
//创建分页对象
PageRequest pageRequest = new PageRequest(user.getPage() - 1,user.getSize(),sort);
//执行分页查询
return userJPA.findAll(pageRequest).getContent();
}验证示例
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.test.context.junit4.SpringRunner;
@EnableAutoConfiguration
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Chapter5ApplicationTests.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class Chapter5ApplicationTests {
private static final Logger log = LoggerFactory.getLogger(Chapter5ApplicationTests.class);
@Autowired
private UserRepository userRepository;
@Test
public void test1() throws Exception {
final User2 user = userRepository.save(new User2("u1", "p1"));
log.info("[添加成功] - [{}]", user);
final List<User2> u1 = userRepository.findAllByUsername("u1");
log.info("[条件查询] - [{}]", u1);
Pageable pageable = PageRequest.of(0, 10, Sort.by(Sort.Order.desc("username")));
final Page<User2> users = userRepository.findAll(pageable);
log.info("[分页+排序+查询所有] - [{}]", users.getContent());
userRepository.findById(users.getContent().get(0).getId()).ifPresent(user1 -> log.info("[主键查询] - [{}]", user1));
final User2 edit = userRepository.save(new User2(user.getId(), "修改后的ui", "修改后的p1"));
log.info("[修改成功] - [{}]", edit);
userRepository.deleteById(user.getId());
log.info("[删除主键为 {} 成功] - [{}]", user.getId());
}
}
QueryDSL
QueryDSL是一个Java语言编写的通用查询框架，专注于通过JavaAPI方式构建安全的SQL查询。QueryDSL可以应用到NoSQL数据库上，QueryDSL查询框架可以在任何支持的ORM框架或者SQL平台上以一种通用的API方式来构建SQL。目前QueryDSL支持的平台包扣JPA、JDO、SQL、Java Collections、RDF、Lucene、Hibernate Serch、MongoDB等。
引入依赖
<querydsl.version>4.1.4</querydsl.version>
<!--queryDSL-->
<dependency>
<groupId>com.querydsl</groupId>
<artifactId>querydsl-jpa</artifactId>
<version>${querydsl.version}</version>
</dependency>
<dependency>
<groupId>com.querydsl</groupId>
<artifactId>querydsl-apt</artifactId>
<version>${querydsl.version}</version>
<scope>provided</scope>
</dependency>Maven插件
可以通过插件生成Model
<!--该插件可以生成querysdl需要的查询对象，执行mvn compile即可-->
<plugin>
<groupId>com.mysema.maven</groupId>
<artifactId>apt-maven-plugin</artifactId>
<version>1.1.3</version>
<executions>
<execution>
<goals>
<goal>process</goal>
</goals>
<configuration>
<outputDirectory>target/generated-sources/java</outputDirectory>
<processor>com.querydsl.apt.jpa.JPAAnnotationProcessor</processor>
</configuration>
</execution>
</executions>
</plugin>使用QueryDSL
声明JPA服务：
public interface XXXXJPA
extends
JpaRepository<XXXX,Long>,
QueryDslPredicateExecutor<XXXX>
{}查询示例：
//querydsl查询实体
QXXXXEntity _xxxx = QXXXXXEntity.xxxxEntity;
//构建JPA查询对象
JPAQuery<GoodEntity> jpaQuery = new JPAQuery<>(entityManager);
//返回查询接口
return jpaQuery
//查询字段
.select(_xxxx)
//查询表
.from(_xxxx)
//查询条件
.where(_xxxx.type.id.eq(Long.valueOf("1")))
//返回结果
.fetch();多条件查询发，封装条件请求：
对象Model
public class Inquirer {
//查询条件集合
private List<BooleanExpression> expressions;
public Inquirer() {
this.expressions = new ArrayList<>();
}
/**
* 添加查询条件到Query内的查询集合内
* @param expression 查询条件继承BooleanExpression抽象对象的具体实体对象,querydsl已经封装
* @return
*/
public Inquirer putExpression(BooleanExpression expression)
{
//添加到条件集合
expressions.add(expression);
return this;
}
/**
* 构建出查询findAll函数使用的Predicate接口查询对象<br>
* 调用buidleQuery()可直接作为findAll参数查询条件使用
* @return
*/
public Predicate buidleQuery()
{
//第一个查询条件对象
BooleanExpression be = null;
//遍历所有查询条件，以第一个开始and
for (int i = 0 ; i < expressions.size() ; i++)
{
if(i == 0)
be = expressions.get(i);
else
be = be.and(expressions.get(i));
}
return be;
}
/**
* 将Iterable集合转换成ArrayList集合
* @param iterable 源集合
* @param <T> 类型
* @return arrayList结果
*/
public <T> List<T> iteratorToList(Iterable<T> iterable)
{
List<T> returnList = new ArrayList<T>();
Iterator<T> iterator = iterable.iterator();
while(iterator.hasNext())
{
returnList.add(iterator.next());
}
return returnList;
}
}查询示例：
//querydsl查询实体
QXXXXEntity _xxxx = QXXXXEntity.xxxxEntity;
//自定义查询对象
Inquirer inquirer = new Inquirer();
//添加查询条件
inquirer.putExpression(_xxxx.type.id.eq(Long.valueOf("1")));
//返回查询结果
return inquirer.iteratorToList(xxxxJPA.findAll(inquirer.buidleQuery()));Mybatis
资料
引入依赖
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.3.2</version>
</dependency>
<!-- MYSQL包 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>由于 mybatis.mapper-locations=classpath:com/battcn/mapper/*.xml配置的在java package中，而Spring Boot默认只打入java package -> *.java，所以我们需要给pom.xml文件添加如下内容
<build>
<resources>
<resource>
<directory>src/main/resources</directory>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>数据源配置
spring.datasource.url=jdbc:mysql://localhost:3306/chapter6?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&useSSL=false
spring.datasource.password=root
spring.datasource.username=root
# 注意注意
mybatis.mapper-locations=classpath:com/battcn/mapper/*.xml
#mybatis.mapper-locations=classpath:mapper/*.xml #这种方式需要自己在resources目录下创建mapper目录然后存放xml
mybatis.type-aliases-package=com.battcn.entity
# 驼峰命名规范 如：数据库字段是 order_id 那么 实体字段就要写成 orderId
mybatis.configuration.map-underscore-to-camel-case=true实体Model
@Getter
@Setter
public class User3 implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L;
private Long id;
private String username;
private String password;
public User3() {}
public User3(String username, String password) {
this.username = username;
this.password = password;
}
}
Mapper
这里提供了两种方式操作接口，第一种带@Select注解的是Mybatis3.x提供的新特性，同理它还有@Update、@Delete、@Insert等等一系列注解，第二种就是传统方式了，写个接口映射，然后在XML中写上我们的SQL语句
UserMapper.java
@Mapper
public interface UserMapper {
/**
* 根据用户名查询用户结果集
*
* @param username 用户名
* @return 查询结果
*/
@Select("SELECT * FROM t_user WHERE username = #{username}")
List<User3> findByUsername(@Param("username") String username);
/**
* 保存用户信息
*
* @param user 用户信息
* @return 成功 1 失败 0
*/
int insert(User3 user);
}
UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="xin.rtime.mapper.UserMapper">
<insert id="insert" parameterType="xin.rtime.model.User3">
INSERT INTO `t_user`(`username`,`password`) VALUES (#{username},#{password})
</insert>
</mapper>验证示例
@EnableAutoConfiguration
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Chapter6ApplicationTests.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class Chapter6ApplicationTests {
private static final Logger log = LoggerFactory.getLogger(Chapter6ApplicationTests.class);
@Autowired
private UserMapper userMapper;
@Test
public void test1() throws Exception {
final int row1 = userMapper.insert(new User3("u1", "p1"));
log.info("[添加结果] - [{}]", row1);
final int row2 = userMapper.insert(new User3("u2", "p2"));
log.info("[添加结果] - [{}]", row2);
final int row3 = userMapper.insert(new User3("u1", "p3"));
log.info("[添加结果] - [{}]", row3);
final List<User3> u1 = userMapper.findByUsername("u1");
log.info("[根据用户名查询] - [{}]", u1);
}
}分页
资料
引入依赖
<!-- 通用Mapper插件
文档地址：https://gitee.com/free/Mapper/wikis/Home -->
<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper-spring-boot-starter</artifactId>
<version>2.0.2</version>
</dependency>
<!-- 分页插件
文档地址：https://github.com/pagehelper/Mybatis-PageHelper/blob/master/wikis/zh/HowToUse.md -->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper-spring-boot-starter</artifactId>
<version>1.2.5</version>
</dependency>数据源配置
spring.datasource.url=jdbc:mysql://localhost:3306/chapter7?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&useSSL=false
spring.datasource.password=root
spring.datasource.username=root
# 如果想看到mybatis日志需要做如下配置
logging.level.com.battcn=DEBUG
########## Mybatis 自身配置 ##########
mybatis.mapper-locations=classpath:com/battcn/mapper/*.xml
mybatis.type-aliases-package=com.battcn.entity
# 驼峰命名规范 如：数据库字段是 order_id 那么 实体字段就要写成 orderId
mybatis.configuration.map-underscore-to-camel-case=true
########## 通用Mapper ##########
# 主键自增回写方法,默认值MYSQL,详细说明请看文档
mapper.identity=MYSQL
mapper.mappers=tk.mybatis.mapper.common.BaseMapper
# 设置 insert 和 update 中，是否判断字符串类型!=''
mapper.not-empty=true
# 枚举按简单类型处理
mapper.enum-as-simple-type=true
########## 分页插件 ##########
pagehelper.helper-dialect=mysql
pagehelper.params=count=countSql
pagehelper.reasonable=false
pagehelper.support-methods-arguments=true通用Mapper配置：
mapper.enum-as-simple-type： 枚举按简单类型处理，如果有枚举字段则需要加上该配置才会做映射
mapper.not-empty： 设置以后，会去判断 insert 和 update 中符串类型!=’’分页插件配置：
pagehelper.reasonable： 分页合理化参数，默认值为false。当该参数设置为 true 时，pageNum<=0 时会查询第一页， pageNum>pages（超过总数时），会查询最后一页。默认false 时，直接根据参数进行查询。
support-methods-arguments： 支持通过 Mapper 接口参数来传递分页参数，默认值false，分页插件会从查询方法的参数值中，自动根据上面 params 配置的字段中取值，查找到合适的值时就会自动分页。实体Model
@Getter
@Setter
@Table(name = "t_user") ---此处与JPA使用的注解不一样
public class User3 implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String username;
private String password;
public User3() {}
public User3(String username, String password) {
this.username = username;
this.password = password;
}
}UserMapper
UserMapper.java
@Mapper
public interface UserMapper2 extends BaseMapper<User>{
/**
* 根据用户名统计（TODO 假设它是一个很复杂的SQL）
*
* @param username 用户名
* @return 统计结果
*/
int countByUsername(String username);
}UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="xin.rtime.mapper.UserMapper2">
<select id="countByUsername" resultType="java.lang.Integer">
SELECT count(1) FROM t_user WHERE username = #{username}
</select>
</mapper>示例验证
@EnableAutoConfiguration
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Chapter7Application.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class Chapter7ApplicationTests {
private static final Logger log = LoggerFactory.getLogger(Chapter7Application.class);
@Autowired
private UserMapper2 userMapper;
@Test
public void test1() throws Exception {
final User3 user1 = new User3("u1", "p1");
final User3 user2 = new User3("u1", "p2");
final User3 user3 = new User3("u3", "p3");
userMapper.insertSelective(user1);
log.info("[user1回写主键] - [{}]", user1.getId());
userMapper.insertSelective(user2);
log.info("[user2回写主键] - [{}]", user2.getId());
userMapper.insertSelective(user3);
log.info("[user3回写主键] - [{}]", user3.getId());
final int count = userMapper.countByUsername("u1");
log.info("[调用自己写的SQL] - [{}]", count);
// TODO 模拟分页
userMapper.insertSelective(new User3("u1", "p1"));
userMapper.insertSelective(new User3("u1", "p1"));
userMapper.insertSelective(new User3("u1", "p1"));
userMapper.insertSelective(new User3("u1", "p1"));
userMapper.insertSelective(new User3("u1", "p1"));
userMapper.insertSelective(new User3("u1", "p1"));
userMapper.insertSelective(new User3("u1", "p1"));
userMapper.insertSelective(new User3("u1", "p1"));
userMapper.insertSelective(new User3("u1", "p1"));
userMapper.insertSelective(new User3("u1", "p1"));
// TODO 分页 + 排序 this.userMapper.selectAll() 这一句就是我们需要写的查询，有了这两款插件无缝切换各种数据库
final PageInfo<Object> pageInfo = PageHelper.startPage(1, 10).setOrderBy("id desc").doSelectPageInfo(() -> this.userMapper.selectAll());
log.info("[lambda写法] - [分页信息] - [{}]", pageInfo.toString());
PageHelper.startPage(1, 10).setOrderBy("id desc");
final PageInfo<User3> userPageInfo = new PageInfo<>(this.userMapper.selectAll());
log.info("[普通写法] - [{}]", userPageInfo);
}
}缓存
Redis
Lettuce Redis
Lettuce 和 Jedis 的都是连接Redis Server的客户端程序。Jedis在实现上是直连redis server，多线程环境下非线程安全，除非使用连接池，为每个Jedis实例增加物理连接。Lettuce基于Netty的连接实例（StatefulRedisConnection），可以在多个线程间并发访问，且线程安全，满足多线程环境下的并发访问，同时它是可伸缩的设计，一个连接实例不够的情况也可以按需增加连接实例。
资料
导入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>属性配置
在 application.properties 文件中配置如下内容，由于Spring Boot2.x 的改动，连接池相关配置需要通过spring.redis.lettuce.pool 或者 spring.redis.jedis.pool 进行配置了
spring.redis.host=localhost
spring.redis.password=battcn
# 连接超时时间（毫秒）
spring.redis.timeout=10000
# Redis默认情况下有16个分片，这里配置具体使用的分片，默认是0
spring.redis.database=0
# 连接池最大连接数（使用负值表示没有限制） 默认 8
spring.redis.lettuce.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
spring.redis.lettuce.pool.max-wait=-1
# 连接池中的最大空闲连接 默认 8
spring.redis.lettuce.pool.max-idle=8
# 连接池中的最小空闲连接 默认 0
spring.redis.lettuce.pool.min-idle=0数据Model
@Getter
@Setter
public class UserCache implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
private Long id;
private String username;
private String password;
public UserCache() {}
public UserCache(Long id, String username, String password) {
this.id = id;
this.username = username;
this.password = password;
}
}自定义Template
默认情况下的模板只能支持RedisTemplate<String, String> ，也就是只能存入字符串，这在开发中是不友好的，所以自定义模板是很有必要的，当自定义了模板又想使用String存储这时候就可以使用StringRedisTemplate的方式,并不冲突。
package xin.rtime.config;
import java.io.Serializable;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisCacheAutoConfiguration {
@Bean
public RedisTemplate<String, Serializable> redisCacheTemplate(LettuceConnectionFactory redisConnectionFactory) {
RedisTemplate<String, Serializable> template = new RedisTemplate<>();
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
template.setConnectionFactory(redisConnectionFactory);
return template;
}
}
示例验证
@EnableAutoConfiguration
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Chapter7Application.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class Chapter8ApplicationTests {
private static final Logger log = LoggerFactory.getLogger(Chapter8ApplicationTests.class);
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Autowired
private RedisTemplate<String, Serializable> redisCacheTemplate;
@Test
public void get() {
// TODO 测试线程安全
ExecutorService executorService = Executors.newFixedThreadPool(1000);
IntStream.range(0, 1000).forEach(i ->
executorService.execute(() -> stringRedisTemplate.opsForValue().increment("kk", 1))
);
stringRedisTemplate.opsForValue().set("k1", "v1");
final String k1 = stringRedisTemplate.opsForValue().get("k1");
log.info("[字符缓存结果] - [{}]", k1);
// TODO 以下只演示整合，具体Redis命令可以参考官方文档，Spring Data Redis 只是改了个名字而已，Redis支持的命令它都支持
String key = "battcn:user:1";
redisCacheTemplate.opsForValue().set(key, new UserCache(1L, "u1", "pa"));
// TODO 对应 String（字符串）
final UserCache user = (UserCache) redisCacheTemplate.opsForValue().get(key);
log.info("[对象缓存结果] - [{}]", user);
}
}下列的就是Redis其它类型所对应的操作方式
- opsForValue： 对应 String（字符串）
- opsForZSet： 对应 ZSet（有序集合）
- opsForHash： 对应 Hash（哈希）
- opsForList： 对应 List（列表）
- opsForSet： 对应 Set（集合）
- opsForGeo： 对应 GEO（地理位置）
Spring Cache
具备相当的好的灵活性，不仅能够使用 SpEL（Spring Expression Language）来定义缓存的 key 和各种 condition，还提供开箱即用的缓存临时存储方案，也支持和主流的专业缓存例如 EHCache、Redis、Guava 的集成。
- 基于
annotation即可使得现有代码支持缓存 - 开箱即用
Out-Of-The-Box，不用安装和部署额外第三方组件即可使用缓存 - 支持
Spring Express Language，能使用对象的任何属性或者方法来定义缓存的key和condition - 支持
AspectJ，并通过其实现任何方法的缓存支持 - 支持自定义
key和自定义缓存管理者，具有相当的灵活性和扩展性
引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>使用前后对比
使用前 我们需要硬编码，如果切换
Cache Client还需要修改代码，耦合度高，不易于维护public String get(String key) { String value = userMapper.selectById(key); if (value != null) { cache.put(key,value); } return value; }使用后 基于
Spring Cache注解，缓存由开发者自己配置，但不用参与到具体编码@Cacheable(value = "user", key = "#key") public String get(String key) { return userMapper.selectById(key); }
属性配置
使用了Spring Cache后，能指定spring.cache.type就手动指定一下，虽然它会自动去适配已有Cache的依赖，但先后顺序会对Redis使用有影响（JCache -> EhCache -> Redis -> Guava）
spring.redis.host=localhost
spring.redis.password=battcn
# 一般来说是不用配置的，Spring Cache 会根据依赖的包自行装配
spring.cache.type=redis
# 连接超时时间（毫秒）
spring.redis.timeout=10000
# Redis默认情况下有16个分片，这里配置具体使用的分片
spring.redis.database=0
# 连接池最大连接数（使用负值表示没有限制） 默认 8
spring.redis.lettuce.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
spring.redis.lettuce.pool.max-wait=-1
# 连接池中的最大空闲连接 默认 8
spring.redis.lettuce.pool.max-idle=8
# 连接池中的最小空闲连接 默认 0
spring.redis.lettuce.pool.min-idle=0缓存Service
UserSerivce.java
public interface UserService {
/**
* 删除
*
* @param user 用户对象
* @return 操作结果
*/
User saveOrUpdate(User user);
/**
* 添加
*
* @param id key值
* @return 返回结果
*/
User get(Long id);
/**
* 删除
*
* @param id key值
*/
void delete(Long id);
}
UserServiceImpl.java
@Service
public class UserServiceImpl implements UserService {
private static final Logger log = LoggerFactory.getLogger(UserServiceImpl.class);
private static final Map<Long, User> DATABASES = new HashMap<>();
static {
DATABASES.put(1L, new User(1L, "u1", "p1"));
DATABASES.put(2L, new User(2L, "u2", "p2"));
DATABASES.put(3L, new User(3L, "u3", "p3"));
}
@CachePut(value = "user", key = "#user.id")
@Override
public User saveOrUpdate(User user) {
DATABASES.put(user.getId(), user);
log.info("进入 saveOrUpdate 方法");
return user;
}
@Cacheable(value = "user", key = "#id")
@Override
public User get(Long id) {
// TODO 我们就假设它是从数据库读取出来的
log.info("进入 get 方法");
return DATABASES.get(id);
}
@CacheEvict(value = "user", key = "#id")
@Override
public void delete(Long id) {
DATABASES.remove(id);
log.info("进入 delete 方法");
}
}示例验证
@EnableAutoConfiguration
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Chapter7Application.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class Chapter9ApplicationTests {
private static final Logger log = LoggerFactory.getLogger(Chapter9ApplicationTests.class);
@Autowired
private UserService userService;
@Test
public void test() {
final User user = userService.saveOrUpdate(new User(5L, "u5", "p5"));
log.info("[saveOrUpdate] - [{}]", user);
final User user1 = userService.get(5L);
log.info("[get] - [{}]", user1);
userService.delete(5L);
}
}启动测试类，结果和我们期望的一致，可以看到增删改查中，查询是没有日志输出的，因为它直接从缓存中获取的数据，而添加、修改、删除都是会进入方法内执行具体的业务代码，然后通过切面去删除掉Redis中的缓存数据。其中 # 号代表这是一个 SpEL 表达式，此表达式可以遍历方法的参数对象，具体语法可以参考 Spring 的相关文档手册。
2018-08-22 12:08:39.810 INFO 13308 --- [ main] xin.rtime.service.impl.UserServiceImpl : 进入 saveOrUpdate 方法
2018-08-22 12:08:40.126 INFO 13308 --- [ main] io.lettuce.core.EpollProvider : Starting without optional epoll library
2018-08-22 12:08:40.129 INFO 13308 --- [ main] io.lettuce.core.KqueueProvider : Starting without optional kqueue library
2018-08-22 12:08:40.976 INFO 13308 --- [ main] xin.rtime.Chapter9ApplicationTests : [saveOrUpdate] - [xin.rtime.model.User@283bb8b7]
2018-08-22 12:08:40.982 INFO 13308 --- [ main] xin.rtime.Chapter9ApplicationTests : [get] - [xin.rtime.model.User@32d1d6c5]
2018-08-22 12:08:40.983 INFO 13308 --- [ main] xin.rtime.service.impl.UserServiceImpl : 进入 delete 方法注解介绍
根据条件操作缓存
根据条件操作缓存内容并不影响数据库操作，条件表达式返回一个布尔值，true/false，当条件为true，则进行缓存操作，否则直接调用方法执行的返回结果。
- 长度： @CachePut(value = "user", key = "#user.id",condition = "#user.username.length() < 10") 只缓存用户名长度少于10的数据
- 大小： @Cacheable(value = "user", key = "#id",condition = "#id < 10") 只缓存ID小于10的数据
- 组合： @Cacheable(value="user",key="#user.username.concat(##user.password)")
- 提前操作： @CacheEvict(value="user",allEntries=true,beforeInvocation=true) 加上beforeInvocation=true后，不管内部是否报错，缓存都将被清除，默认情况为false
注解介绍
@Cacheable(根据方法的请求参数对其结果进行缓存)- key： 缓存的 key，可以为空，如果指定要按照 SpEL 表达式编写，如果不指定，则缺省按照方法的所有参数进行组合（如：@Cacheable(value="user",key="#userName")）
- value： 缓存的名称，必须指定至少一个（如：@Cacheable(value="user") 或者 @Cacheable(value={"user1","use2"})）
- condition： 缓存的条件，可以为空，使用 SpEL 编写，返回 true 或者 false，只有为 true 才进行缓存（如：@Cacheable(value = "user", key = "#id",condition = "#id < 10")）
@CachePut(根据方法的请求参数对其结果进行缓存，和 @Cacheable 不同的是，它每次都会触发真实方法的调用)- key： 同上
- value： 同上
- condition： 同上
@CachEvict(根据条件对缓存进行清空)- key： 同上
- value： 同上
- condition： 同上
- allEntries： 是否清空所有缓存内容，缺省为 false，如果指定为 true，则方法调用后将立即清空所有缓存（如：@CacheEvict(value = "user", key = "#id", allEntries = true)）
- beforeInvocation： 是否在方法执行前就清空，缺省为 false，如果指定为 true，则在方法还没有执行的时候就清空缓存，缺省情况下，如果方法执行抛出异常，则不会清空缓存（如：@CacheEvict(value = "user", key = "#id", beforeInvocation = true)）
Spring Cache[CacheManager]
引入依赖
<!-- 添加缓存支持 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<!-- 添加Redis缓存支持 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-redis</artifactId>
<version>1.4.3.RELEASE</version>
</dependency>RedisConfig
@Configuration
@EnableCaching
public class RedisConfiguration extends CachingConfigurerSupport
{
/**
* 自定义生成key的规则
* @return
*/
@Override
public KeyGenerator keyGenerator() {
return new KeyGenerator() {
@Override
public Object generate(Object o, Method method, Object... objects) {
//格式化缓存key字符串
StringBuilder sb = new StringBuilder();
//追加类名
sb.append(o.getClass().getName());
//追加方法名
sb.append(method.getName());
//遍历参数并且追加
for (Object obj : objects) {
sb.append(obj.toString());
}
System.out.println("调用Redis缓存Key : " + sb.toString());
return sb.toString();
}
};
}
/**
* 采用RedisCacheManager作为缓存管理器
* @param redisTemplate
* @return
*/
@Bean
public CacheManager cacheManager(RedisTemplate redisTemplate) {
return new RedisCacheManager(redisTemplate);
}
}使用
@CacheConfig：该注解是用来开启声明的类参与缓存,如果方法内的@Cacheable注解没有添加key值，那么会自动使用cahceNames配置参数并且追加方法名。
@Cacheable：配置方法的缓存参数，可自定义缓存的key以及value。
@Service
@CacheConfig(cacheNames = "user")
public class UserService {
@Autowired
private UserJPA userJPA;
@Cacheable
public List<UserEntity> list()
{
return userJPA.findAll();
}
}MongoDB
spring-boot-starter-data-mongodb确实采用了跟spring-boot-starter-data-jpa同样的方式来完成接口代理类的生成，并且提供了一些常用的单个对象操作的公共方法，MongoRepository接口作用与JPARepository一致，继承了该接口的业务数据接口就可以提供一个被Spring IOC托管的代理实现类，这样我们在注入业务数据接口时就会完成代理实现类的注入。
引入依赖
<!--mongodb依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<!--lombok依赖-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<!--fastjson依赖-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.44</version>
</dependency>
<!--测试依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>Repository
public interface CustomerRepository extends MongoRepository<Customer, String> {
}MongoRepository <T,PK>同样也是采用了两个泛型参数， T：实体类类型。 PK：T实体类内的主键类型，如：String。
Model
@Data
public class Customer implements Serializable {
/**
* 客户编号
*/
@Id
public String id;
/**
* 客户名称
*/
public String firstName;
/**
* 客户姓氏
*/
public String lastName;
public Customer(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
}Configuration
spring:
application:
name: spring-boot-mongodb
data:
mongodb:
uri: mongodb://localhost/test
username: test
password: 123456Test
可以通过@EnableMongoRepositories注解配置basePackages属性完成自定义的MongoDB的MongoRepository实现类的扫描
/**
* 客户数据接口注入
*/
@Autowired
private CustomerRepository repository;
@Override
public void run(String... args) {
// 删除全部
repository.deleteAll();
// 添加一条数据
repository.save(new Customer("于", "起宇"));
// 查询全部
logger.info(JSON.toJSONString(repository.findAll()));
}使用Rest访问MongoDB数据
使用Spring Data Rest自动映射读取MongoDB内的数据，省去一系列繁琐的操作步骤。
引入依赖
<!--data rest依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>改造Repository
@RepositoryRestResource(collectionResourceRel = "customer", path = "customer")
public interface CustomerRepository extends MongoRepository<Customer, String> {
//....省略
}collectionResourceRel：该参数配置映射MongoDB内的Collection名称。 path：该参数配置映射完成rest后访问的路径前缀。
Swagger调试
资料
引入依赖
<dependency>
<groupId>com.battcn</groupId>
<artifactId>swagger-spring-boot-starter</artifactId>
<version>2.0.7-RELEASE</version>
</dependency>属性配置
# 扫描的包路径,默认扫描所有
spring.swagger.base-package=xin.rtime
# 默认为 true
spring.swagger.enabled=true数据Model
@Getter
@Setter
@ApiModel
@ToString
public class User implements Serializable {
private static final long serialVersionUID = 8655851615465363473L;
private Long id;
@ApiModelProperty("用户名")
private String username;
@ApiModelProperty("密码")
private String password;
public User() {}
public User(String username, String password) {
this.username = username;
this.password = password;
}
public User(Long id, String username, String password) {
this.id = id;
this.username = username;
this.password = password;
}
}服务接口
@RestController
@RequestMapping("/swaggerUsers")
@Api(tags = "1.1", description = "用户管理", value = "用户管理")
public class UserController {
private static final Logger log = LoggerFactory.getLogger(UserController.class);
@GetMapping
@ApiOperation(value = "条件查询（DONE）")
@ApiImplicitParams({
@ApiImplicitParam(name = "username", value = "用户名"),
@ApiImplicitParam(name = "password", value = "密码", dataType = DataType.STRING, paramType = ParamType.QUERY), })
public User query(String username, String password) {
log.info("多个参数用 @ApiImplicitParams");
return new User(1L, username, password);
}
@GetMapping("/{id}")
@ApiOperation(value = "主键查询（DONE）")
@ApiImplicitParams({
@ApiImplicitParam(name = "id", value = "用户编号", dataType = DataType.LONG, paramType = ParamType.PATH), })
public User get(@PathVariable Long id) {
log.info("单个参数用 @ApiImplicitParam");
return new User(id, "u1", "p1");
}
@DeleteMapping("/{id}")
@ApiOperation(value = "删除用户（DONE）")
@ApiImplicitParam(name = "id", value = "用户编号", dataType = DataType.LONG, paramType = ParamType.PATH)
public void delete(@PathVariable Long id) {
log.info("单个参数用 ApiImplicitParam");
}
@PostMapping
@ApiOperation(value = "添加用户（DONE）")
public User post(@RequestBody User user) {
log.info("如果是 POST PUT 这种带 @RequestBody 的可以不用写 @ApiImplicitParam");
return user;
}
@PutMapping("/{id}")
@ApiOperation(value = "修改用户（DONE）")
public void put(@PathVariable Long id, @RequestBody User user) {
log.info("如果你不想写 @ApiImplicitParam 那么 swagger 也会使用默认的参数名作为描述信息 ");
}
}
Swagger 注解
- @Api： 描述Controller
- @ApiIgnore： 忽略该Controller，指不对当前类做扫描
- @ApiOperation： 描述Controller类中的method接口
- @ApiParam： 单个参数描述，与@ApiImplicitParam不同的是，他是写在参数左侧的。如（@ApiParam(name = "username",value = "用户名") String username）
- @ApiModel： 描述POJO对象
- @ApiProperty： 描述POJO对象中的属性值
- @ApiImplicitParam： 描述单个入参信息
- @ApiImplicitParams： 描述多个入参信息
- @ApiResponse： 描述单个出参信息
- @ApiResponses： 描述多个出参信息
- @ApiError： 接口错误所返回的信息
QA
- swagger-ui.html 404
解决办法：
@Configuration
public class ServletContextConfig extends WebMvcConfigurationSupport {
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/**").addResourceLocations("classpath:/static/");
registry.addResourceHandler("swagger-ui.html")
.addResourceLocations("classpath:/META-INF/resources/");
registry.addResourceHandler("/webjars/**")
.addResourceLocations("classpath:/META-INF/resources/webjars/");
registry.addResourceHandler("/static/**").addResourceLocations(
"classpath:/META-INF/resources/static/");
super.addResourceHandlers(registry);
}
@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
configurer.enable();
}
}- swagger-ui.html 405
解决办法：检查Controller是否都加入了@RequestMapping注解
消息队列
MQ全称（Message Queue）又名消息队列，是一种异步通讯的中间件。可以将它理解成邮局，发送者将消息传递到邮局，然后由邮局帮我们发送给具体的消息接收者（消费者），具体发送过程与时间我们无需关心，它也不会干扰我进行其它事情。常见的MQ有kafka、activemq、zeromq、rabbitmq 等等，各大MQ的对比和优劣势可以自行Google
RabbitMQ
- 基于SpringBoot & RabbitMQ完成DirectExchange分布式消息消费
- 基于SpringBoot & RabbitMQ完成DirectExchange分布式消息多消费者消费
- 基于SpringBoot & RabbitMQ完成TopicExchange分布式消息消费
- RabbitMQ信任package设置
RabbitMQ是一个遵循AMQP协议，由面向高并发的erlanng语言开发而成，用在实时的对可靠性要求比较高的消息传递上，支持多种语言客户端。支持延迟队列（这是一个非常有用的功能）
Broker：简单来说就是消息队列服务器实体Exchange：消息交换机，它指定消息按什么规则，路由到哪个队列Queue：消息队列载体，每个消息都会被投入到一个或多个队列- `Bindingv：绑定，它的作用就是把exchange和queue按照路由规则绑定起来
Routing Key：路由关键字，exchange根据这个关键字进行消息投递vhost：虚拟主机，一个broker里可以开设多个vhost，用作不同用户的权限分离producer：消息生产者，就是投递消息的程序consumer：消息消费者，就是接受消息的程序channel：消息通道，在客户端的每个连接里，可建立多个channel，每个channel代表一个会话任务
常用场景
- 邮箱发送：用户注册后投递消息到rabbitmq中，由消息的消费方异步的发送邮件，提升系统响应速度
- 流量削峰：一般在秒杀活动中应用广泛，秒杀会因为流量过大，导致应用挂掉，为了解决这个问题，一般在应用前端加入消息队列。用于控制活动人数，将超过此一定阀值的订单直接丢弃。缓解短时间的高流量压垮应用。
- 订单超时：利用rabbitmq的延迟队列，可以很简单的实现订单超时的功能，比如用户在下单后30分钟未支付取消订单
- ......
资料
引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.46</version>
</dependency>属性配置
spring.rabbitmq.username=battcn
spring.rabbitmq.password=battcn
spring.rabbitmq.host=192.168.0.133
spring.rabbitmq.port=5672
spring.rabbitmq.virtual-host=/
# 手动ACK 不开启自动ACK模式,目的是防止报错后未正确处理消息丢失 默认 为 none
spring.rabbitmq.listener.simple.acknowledge-mode=manual定义队列
如果手动创建过或者RabbitMQ中已经存在该队列那么也可以省略下述代码
@Configuration
public class RabbitConfig {
public static final String DEFAULT_BOOK_QUEUE = "dev.book.register.default.queue";
public static final String MANUAL_BOOK_QUEUE = "dev.book.register.manual.queue";
@Bean
public Queue defaultBookQueue() {
// 第一个是 QUEUE 的名字,第二个是消息是否需要持久化处理
return new Queue(DEFAULT_BOOK_QUEUE, true);
}
@Bean
public Queue manualBookQueue() {
// 第一个是 QUEUE 的名字,第二个是消息是否需要持久化处理
return new Queue(MANUAL_BOOK_QUEUE, true);
}
}数据Model
@Getter
@Setter
@ToString
public class Book implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L;
private String id;
private String name;
}消息监听
默认情况下 spring-boot-data-amqp 是自动ACK机制，就意味着 MQ 会在消息消费完毕后自动帮我们去ACK，这样依赖就存在这样一个问题：如果报错了，消息不会丢失，会无限循环消费，很容易就吧磁盘空间耗完，虽然可以配置消费的次数但这种做法也有失优雅。目前比较推荐的就是我们手动ACK然后将消费错误的消息转移到其它的消息队列中，做补偿处理
@Component
public class BookHandler {
private static final Logger log = LoggerFactory.getLogger(BookHandler.class);
/**
* <p>TODO 该方案是 spring-boot-data-amqp 默认的方式,不太推荐。具体推荐使用 listenerManualAck()</p>
* 默认情况下,如果没有配置手动ACK, 那么Spring Data AMQP 会在消息消费完毕后自动帮我们去ACK
* 存在问题：如果报错了,消息不会丢失,但是会无限循环消费,一直报错,如果开启了错误日志很容易就吧磁盘空间耗完
* 解决方案：手动ACK,或者try-catch 然后在 catch 里面讲错误的消息转移到其它的系列中去
* spring.rabbitmq.listener.simple.acknowledge-mode=manual
* <p>
*
* @param book 监听的内容
*/
@RabbitListener(queues = {RabbitConfig.DEFAULT_BOOK_QUEUE})
public void listenerAutoAck(Book book, Message message, Channel channel) {
// TODO 如果手动ACK,消息会被监听消费,但是消息在队列中依旧存在,如果 未配置 acknowledge-mode 默认是会在消费完毕后自动ACK掉
final long deliveryTag = message.getMessageProperties().getDeliveryTag();
try {
log.info("[listenerAutoAck 监听的消息] - [{}]", book.toString());
// TODO 通知 MQ 消息已被成功消费,可以ACK了
channel.basicAck(deliveryTag, false);
} catch (IOException e) {
try {
// TODO 处理失败,重新压入MQ
channel.basicRecover();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
@RabbitListener(queues = {RabbitConfig.MANUAL_BOOK_QUEUE})
public void listenerManualAck(Book book, Message message, Channel channel) {
log.info("[listenerManualAck 监听的消息] - [{}]", book.toString());
try {
// TODO 通知 MQ 消息已被成功消费,可以ACK了
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
} catch (IOException e) {
// TODO 如果报错了,那么我们可以进行容错处理,比如转移当前消息进入其它队列
}
}
}服务接口
@RestController
@RequestMapping(value = "/books")
public class BookController {
private final RabbitTemplate rabbitTemplate;
@Autowired
public BookController(RabbitTemplate rabbitTemplate) {
this.rabbitTemplate = rabbitTemplate;
}
/**
* this.rabbitTemplate.convertAndSend(RabbitConfig.DEFAULT_BOOK_QUEUE, book); 对应 {@link BookHandler#listenerAutoAck}
* this.rabbitTemplate.convertAndSend(RabbitConfig.MANUAL_BOOK_QUEUE, book); 对应 {@link BookHandler#listenerManualAck}
*/
@GetMapping
public void defaultMessage() {
Book book = new Book();
book.setId("1");
book.setName("一起来学Spring Boot");
this.rabbitTemplate.convertAndSend(RabbitConfig.DEFAULT_BOOK_QUEUE, book);
this.rabbitTemplate.convertAndSend(RabbitConfig.MANUAL_BOOK_QUEUE, book);
}
}示例验证
- 调用books暴露的服务
- 查看rabbitMQ console是否有消费记录
延迟消息
延时消息就是指当消息被发送以后，并不想让消费者立即拿到消息，而是等待指定时间后，消费者才拿到这个消息进行消费。
延迟队列能做什么？
- 订单业务： 在电商/点餐中，都有下单后 30 分钟内没有付款，就自动取消订单。
- 短信通知： 下单成功后 60s 之后给用户发送短信通知。
- 失败重试： 业务操作失败后，间隔一定的时间进行失败重试。
这类业务的特点就是：非实时的，需要延迟处理，需要进行失败重试。一种比较笨的方式是采用定时任务，轮训数据库，方法简单好用，但性能底下，在高并发情况下容易弄死数据库，间隔时间不好设置，时间过大，影响精度，过小影响性能，而且做不到按超时的时间顺序处理。另一种就是用Java中的DelayQueue 位于java.util.concurrent包下，本质是由PriorityQueue和BlockingQueue实现的阻塞优先级队列。，这玩意最大的问题就是不支持分布式与持久化
RabbitMQ队列本身是没有直接实现支持延迟队列的功能，但可以通过它的Time-To-Live Extensions 与 Dead Letter Exchange 的特性模拟出延迟队列的功能。
- Time-To-Live Extensions
RabbitMQ支持为队列或者消息设置TTL（time to live 存活时间）。TTL表明了一条消息可在队列中存活的最大时间。当某条消息被设置了TTL或者当某条消息进入了设置了TTL的队列时，这条消息会在TTL时间后死亡成为Dead Letter。如果既配置了消息的TTL，又配置了队列的TTL，那么较小的那个值会被取用。
- Dead Letter Exchange
死信交换机，上文中提到设置了 TTL 的消息或队列最终会成为Dead Letter。如果为队列设置了Dead Letter Exchange（DLX），那么这些Dead Letter就会被重新发送到Dead Letter Exchange中，然后通过Dead Letter Exchange路由到其他队列，即可实现延迟队列的功能。
定义队列
@Configuration
public class RabbitConfig2 {
private static final Logger log = LoggerFactory.getLogger(RabbitConfig.class);
@Bean
public RabbitTemplate rabbitTemplate(CachingConnectionFactory connectionFactory) {
connectionFactory.setPublisherConfirms(true);
connectionFactory.setPublisherReturns(true);
RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
rabbitTemplate.setMandatory(true);
rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> log.info("消息发送成功:correlationData({}),ack({}),cause({})", correlationData, ack, cause));
rabbitTemplate.setReturnCallback((message, replyCode, replyText, exchange, routingKey) -> log.info("消息丢失:exchange({}),route({}),replyCode({}),replyText({}),message:{}", exchange, routingKey, replyCode, replyText, message));
return rabbitTemplate;
}
/**
* 延迟队列 TTL 名称
*/
private static final String REGISTER_DELAY_QUEUE = "dev.book.register.delay.queue";
/**
* DLX，dead letter发送到的 exchange
* TODO 此处的 exchange 很重要,具体消息就是发送到该交换机的
*/
public static final String REGISTER_DELAY_EXCHANGE = "dev.book.register.delay.exchange";
/**
* routing key 名称
* TODO 此处的 routingKey 很重要要,具体消息发送在该 routingKey 的
*/
public static final String DELAY_ROUTING_KEY = "";
public static final String REGISTER_QUEUE_NAME = "dev.book.register.queue";
public static final String REGISTER_EXCHANGE_NAME = "dev.book.register.exchange";
public static final String ROUTING_KEY = "all";
/**
* 延迟队列配置
* <p>
* 1、params.put("x-message-ttl", 5 * 1000);
* TODO 第一种方式是直接设置 Queue 延迟时间 但如果直接给队列设置过期时间,这种做法不是很灵活,（当然二者是兼容的,默认是时间小的优先）
* 2、rabbitTemplate.convertAndSend(book, message -> {
* message.getMessageProperties().setExpiration(2 * 1000 + "");
* return message;
* });
* TODO 第二种就是每次发送消息动态设置延迟时间,这样我们可以灵活控制
**/
@Bean
public Queue delayProcessQueue() {
Map<String, Object> params = new HashMap<>();
// x-dead-letter-exchange 声明了队列里的死信转发到的DLX名称，
params.put("x-dead-letter-exchange", REGISTER_EXCHANGE_NAME);
// x-dead-letter-routing-key 声明了这些死信在转发时携带的 routing-key 名称。
params.put("x-dead-letter-routing-key", ROUTING_KEY);
return new Queue(REGISTER_DELAY_QUEUE, true, false, false, params);
}
/**
* 需要将一个队列绑定到交换机上，要求该消息与一个特定的路由键完全匹配。
* 这是一个完整的匹配。如果一个队列绑定到该交换机上要求路由键 “dog”，则只有被标记为“dog”的消息才被转发，不会转发dog.puppy，也不会转发dog.guard，只会转发dog。
* TODO 它不像 TopicExchange 那样可以使用通配符适配多个
*
* @return DirectExchange
*/
@Bean
public DirectExchange delayExchange() {
return new DirectExchange(REGISTER_DELAY_EXCHANGE);
}
@Bean
public Binding dlxBinding() {
return BindingBuilder.bind(delayProcessQueue()).to(delayExchange()).with(DELAY_ROUTING_KEY);
}
@Bean
public Queue registerBookQueue() {
return new Queue(REGISTER_QUEUE_NAME, true);
}
/**
* 将路由键和某模式进行匹配。此时队列需要绑定要一个模式上。
* 符号“#”匹配一个或多个词，符号“*”匹配不多不少一个词。因此“audit.#”能够匹配到“audit.irs.corporate”，但是“audit.*” 只会匹配到“audit.irs”。
**/
@Bean
public TopicExchange registerBookTopicExchange() {
return new TopicExchange(REGISTER_EXCHANGE_NAME);
}
@Bean
public Binding registerBookBinding() {
// TODO 如果要让延迟队列之间有关联,这里的 routingKey 和 绑定的交换机很关键
return BindingBuilder.bind(registerBookQueue()).to(registerBookTopicExchange()).with(ROUTING_KEY);
}
} 消费监听
默认情况下 spring-boot-data-amqp 是自动ACK机制，就意味着 MQ 会在消息消费完毕后自动帮我们去ACK，这样依赖就存在这样一个问题：如果报错了，消息不会丢失，会无限循环消费，很容易就吧磁盘空间耗完，虽然可以配置消费的次数但这种做法也有失优雅。目前比较推荐的就是我们手动ACK然后将消费错误的消息转移到其它的消息队列中，做补偿处理。 由于我们需要手动控制ACK，因此下面监听完消息后需要调用basicAck通知rabbitmq消息已被正确消费，可以将远程队列中的消息删除
public class BookHandler2 {
private static final Logger log = LoggerFactory.getLogger(BookHandler.class);
@RabbitListener(queues = {RabbitConfig2.REGISTER_QUEUE_NAME})
public void listenerDelayQueue(Book book, Message message, Channel channel) {
log.info("[listenerDelayQueue 监听的消息] - [消费时间] - [{}] - [{}]", LocalDateTime.now(), book.toString());
try {
// TODO 通知 MQ 消息已被成功消费,可以ACK了
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
} catch (IOException e) {
// TODO 如果报错了,那么我们可以进行容错处理,比如转移当前消息进入其它队列
}
}
}
服务接口
@RestController
@RequestMapping("/books2")
public class BookController2 {
private static final Logger log = LoggerFactory.getLogger(BookController.class);
private final RabbitTemplate rabbitTemplate;
@Autowired
public BookController2(RabbitTemplate rabbitTemplate) {
this.rabbitTemplate = rabbitTemplate;
}
/**
* this.rabbitTemplate.convertAndSend(RabbitConfig.REGISTER_DELAY_EXCHANGE, RabbitConfig.DELAY_ROUTING_KEY, book); 对应 {@link BookHandler#listenerDelayQueue}
*/
@GetMapping
public void defaultMessage() {
Book book = new Book();
book.setId("1");
book.setName("一起来学Spring Boot");
// 添加延时队列
this.rabbitTemplate.convertAndSend(RabbitConfig2.REGISTER_DELAY_EXCHANGE, RabbitConfig2.DELAY_ROUTING_KEY, book, message -> {
// TODO 第一句是可要可不要,根据自己需要自行处理
message.getMessageProperties().setHeader(AbstractJavaTypeMapper.DEFAULT_CONTENT_CLASSID_FIELD_NAME, Book.class.getName());
// TODO 如果配置了 params.put("x-message-ttl", 5 * 1000); 那么这一句也可以省略,具体根据业务需要是声明 Queue 的时候就指定好延迟时间还是在发送自己控制时间
message.getMessageProperties().setExpiration(5 * 1000 + "");
return message;
});
log.info("[发送时间] - [{}]", LocalDateTime.now());
}
}示例验证
- 调用books2暴露的服务
- 查看rabbitMQ console是否有消费记录
ActiveMQ
Kafka
监控
原生actuator
actuator是spring boot项目中非常强大一个功能，有助于对应用程序进行监视和管理，通过 restful api 请求来监管、审计、收集应用的运行情况，针对微服务而言它是必不可少的一个环节
Endpoints
actuator 的核心部分，它用来监视应用程序及交互，spring-boot-actuator中已经内置了非常多的 Endpoints（health、info、beans、httptrace、shutdown等等），同时也允许我们自己扩展自己的端点
Spring Boot 2.0中的端点和之前的版本有较大不同,使用时需注意。另外端点的监控机制也有很大不同，启用了不代表可以直接访问，还需要将其暴露出来，传统的management.security管理已被标记为不推荐。
内置Endpoints
| id | desc | Sensitive |
|---|---|---|
auditevents | 显示当前应用程序的审计事件信息 | Yes |
bean | 显示应用Spring Beans的完整列表 | Yes |
caches | 显示可用缓存信息 | Yes |
conditions | 显示自动装配类的状态及及应用信息 | Yes |
configprops | 显示所有 @ConfigurationProperties 列表 | Yes |
env | 显示 ConfigurableEnvironment 中的属性 | Yes |
flyway | 显示 Flyway 数据库迁移信息 | Yes |
health | 显示应用的健康信息（未认证只显示status，认证显示全部信息详情） | No |
info | 显示任意的应用信息（在资源文件写info.xxx即可） | No |
liquibase | 展示Liquibase 数据库迁移 | Yes |
metrics | 展示当前应用的 metrics 信息 | Yes |
mappings | 显示所有 @RequestMapping 路径集列表 | Yes |
scheduledtasks | 显示应用程序中的计划任务 | Yes |
sessions | 允许从Spring会话支持的会话存储中检索和删除用户会话。 | Yes |
shutdown | 允许应用以优雅的方式关闭（默认情况下不启用） | Yes |
threaddump | 执行一个线程dump | Yes |
httptrace | 显示HTTP跟踪信息（默认显示最后100个HTTP请求 - 响应交换） | Yes |
引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
spring-boot-maven-plugin 添加如下配置：
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<executions>
<execution>
<goals>
<goal>build-info</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>属性配置
在 application.properties 文件中配置actuator的相关配置，其中info开头的属性，就是访问info端点中显示的相关内容，值得注意的是Spring Boot2.x中，默认只开放了info、health两个端点，剩余的需要自己通过配置management.endpoints.web.exposure.include属性来加载（有include自然就有exclude，不做详细概述了）。如果想单独操作某个端点可以使用management.endpoint.端点.enabled属性进行启用或禁用
# 描述信息
info.blog-url=http://blog.battcn.com
info.author=Levin
[email protected]@
# 加载所有的端点/默认只加载了 info / health
management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always
# 可以关闭制定的端点
management.endpoint.shutdown.enabled=false
# 路径映射，将 health 路径映射成 rest_health 那么在访问 health 路径将为404，因为原路径已经变成 rest_health 了，一般情况下不建议使用
# management.endpoints.web.path-mapping.health=rest_health默认装配 HealthIndicators
下列是依赖spring-boot-xxx-starter后相关HealthIndicator的实现（通过management.health.defaults.enabled属性可以禁用它们），但想要获取一些额外的信息时，自定义的作用就体现出来了…
| 名称 | 描述 |
|---|---|
CassandraHealthIndicator | 检查 Cassandra 数据库是否启动。 |
DiskSpaceHealthIndicator | 检查磁盘空间不足。 |
DataSourceHealthIndicator | 检查是否可以获得连接 DataSource。 |
ElasticsearchHealthIndicator | 检查 Elasticsearch 集群是否启动。 |
InfluxDbHealthIndicator | 检查 InfluxDB 服务器是否启动。 |
JmsHealthIndicator | 检查 JMS 代理是否启动。 |
MailHealthIndicator | 检查邮件服务器是否启动。 |
MongoHealthIndicator | 检查 Mongo 数据库是否启动。 |
Neo4jHealthIndicator | 检查 Neo4j 服务器是否启动。 |
RabbitHealthIndicator | 检查 Rabbit 服务器是否启动。 |
RedisHealthIndicator | 检查 Redi 服务器是否启动。 |
SolrHealthIndicator | 检查 Solr 服务器是否已启动。 |
健康端点（第一种方式）
实现HealthIndicator接口，根据自己的需要判断返回的状态是UP还是DOWN，功能简单。
@Component("MyHealthIndicator1")
public class MyHealthIndicator implements HealthIndicator {
private static final String VERSION = "v1.0.0";
@Override
public Health health() {
int code = check();
if (code != 0) {
Health.down().withDetail("code", code).withDetail("version", VERSION).build();
}
return Health.up().withDetail("code", code).withDetail("version", VERSION).up().build();
}
private int check() {
return 0;
}
}健康端点（第二种方式）
继承AbstractHealthIndicator抽象类，重写doHealthCheck方法，功能比第一种要强大一点点，默认的DataSourceHealthIndicator 、 RedisHealthIndicator 都是这种写法，内容回调中还做了异常的处理。
@Component("MyAbstractHealthIndicator1")
public class MyAbstractHealthIndicator extends AbstractHealthIndicator {
private static final String VERSION = "v1.0.0";
@Override
protected void doHealthCheck(Health.Builder builder) throws Exception {
int code = check();
if (code != 0) {
builder.down().withDetail("code", code).withDetail("version", VERSION).build();
}
builder.withDetail("code", code)
.withDetail("version", VERSION).up().build();
}
private int check() {
return 0;
}
}自定义端点
上面介绍的 info、health 都是spring-boot-actuator内置的，真正要实现自己的端点还得通过@Endpoint、 @ReadOperation、@WriteOperation、@DeleteOperation。
注解介绍
不同请求的操作，调用时缺少必需参数，或者使用无法转换为所需类型的参数，则不会调用操作方法，响应状态将为400（错误请求）
@Endpoint构建 rest api 的唯一路径@ReadOperation GET请求，响应状态为 200 如果没有返回值响应 404（资源未找到）@WriteOperation POST请求，响应状态为 200 如果没有返回值响应 204（无响应内容）@DeleteOperation DELETE请求，响应状态为 200 如果没有返回值响应 204（无响应内容）
@Endpoint(id = "rtime")
public class MyEndPoint {
@ReadOperation
public Map<String, String> hello() {
Map<String, String> result = new HashMap<>();
result.put("author", "rtime");
result.put("email", "[email protected]");
return result;
}
}SpringBootAdmin
SBA 全称 Spring Boot Admin 是一个管理和监控 Spring Boot 应用程序的开源项目。分为admin-server 与 admin-client 两个组件，admin-server通过采集 actuator 端点数据，显示在 spring-boot-admin-ui 上，已知的端点几乎都有进行采集，通过 spring-boot-admin 可以动态切换日志级别、导出日志、导出heapdump、监控各项指标 等等….
什么是SBA? SBA 全称 Spring Boot Admin 是一个管理和监控 Spring Boot 应用程序的开源项目。分为admin-server 与 admin-client 两个组件，admin-server通过采集 actuator 端点数据，显示在 spring-boot-admin-ui 上，已知的端点几乎都有进行采集，通过 spring-boot-admin 可以动态切换日志级别、导出日志、导出heapdump、监控各项指标 等等….
Spring Boot Admin 在对单一应用服务监控的同时也提供了集群监控方案，支持通过eureka、consul、zookeeper等注册中心的方式实现多服务监控与管理…
导入依赖
<!-- 服务端：带UI界面 -->
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-starter-server</artifactId>
<version>2.0.0</version>
</dependency>
<!-- 客户端包 -->
<dependency>
<groupId>de.codecentric</groupId>
<artifactId>spring-boot-admin-starter-client</artifactId>
<version>2.0.0</version>
</dependency>
<!-- 安全认证 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!-- 在管理界面中与 JMX-beans 进行交互所需要被依赖的 JAR -->
<dependency>
<groupId>org.jolokia</groupId>
<artifactId>jolokia-core</artifactId>
</dependency>属性配置
# \u63CF\u8FF0\u4FE1\u606F
info.blog-url=http://www.rtime.xin
info.author=luis
# \u5982\u679C Maven \u63D2\u4EF6\u6CA1\u914D\u7F6E\u6B64\u5904\u8BF7\u6CE8\u91CA\u6389
[email protected]@
[email protected]@
# \u65E5\u5FD7\u6587\u4EF6
logging.file=./target/admin-server.log
# \u52A0\u8F7D\u6240\u6709\u7684\u7AEF\u70B9/\u9ED8\u8BA4\u53EA\u52A0\u8F7D\u4E86 info / health
management.endpoints.web.exposure.include=*
# \u6BD4\u8F83\u91CD\u8981,\u9ED8\u8BA4 /actuator spring-boot-admin \u626B\u63CF\u4E0D\u5230
management.endpoints.web.base-path=/springboot
management.endpoint.health.show-details=always
spring.boot.admin.client.url=http://localhost:8080/springboot
# \u4E0D\u914D\u7F6E\u8001\u559C\u6B22\u7528\u4E3B\u673A\u540D\uFF0C\u770B\u7740\u4E0D\u8212\u670D....
spring.boot.admin.client.instance.prefer-ip=true
# \u767B\u9646\u6240\u9700\u7684\u8D26\u53F7\u5BC6\u7801
spring.security.user.name=admin
spring.security.user.password=admin
# \u4FBF\u4E8E\u5BA2\u6237\u7AEF\u53EF\u4EE5\u5728\u53D7\u4FDD\u62A4\u7684\u670D\u52A1\u5668\u4E0A\u6CE8\u518Capi
spring.boot.admin.client.username=admin
spring.boot.admin.client.password=admin
# \u4FBF\u670D\u52A1\u5668\u53EF\u4EE5\u8BBF\u95EE\u53D7\u4FDD\u62A4\u7684\u5BA2\u6237\u7AEF\u7AEF\u70B9
spring.boot.admin.client.instance.metadata.user.name=admin
spring.boot.admin.client.instance.metadata.user.password=admin入口
@SpringBootApplication
@EnableAdminServer
public class Chapter14Application {
public static void main(String[] args) {
SpringApplication.run(Chapter14Application.class, args);
}
/**
* dev 环境加载
*/
@Profile("dev")
@Configuration
public static class SecurityPermitAllConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests().anyRequest().permitAll()
.and().csrf().disable();
}
}
/**
* chapter14 环境加载
*/
@Profile("chapter14")
@Configuration
public static class SecuritySecureConfig extends WebSecurityConfigurerAdapter {
private String adminContextPath;
public SecuritySecureConfig() {
}
@Autowired
public SecuritySecureConfig(AdminServerProperties adminServerProperties) {
this.adminContextPath = adminServerProperties.getContextPath();
}
@Override
protected void configure(HttpSecurity http) throws Exception {
SavedRequestAwareAuthenticationSuccessHandler successHandler = new SavedRequestAwareAuthenticationSuccessHandler();
successHandler.setTargetUrlParameter("redirectTo");
if(adminContextPath != null && adminContextPath.length() != 0) {
http.authorizeRequests()
.antMatchers(adminContextPath + "/assets/**").permitAll()
.antMatchers(adminContextPath + "/login").permitAll()
.anyRequest().authenticated()
.and()
.formLogin().loginPage(adminContextPath + "/login").successHandler(successHandler).and()
.logout().logoutUrl(adminContextPath + "/logout").and()
.httpBasic().and()
.csrf().disable();
}
}
}
}定时任务
Timer： JDK自带的java.util.Timer；通过调度java.util.TimerTask的方式 让程序按照某一个频度执行，但不能在指定时间运行。 一般用的较少。
ScheduledExecutorService： JDK1.5新增的，位于java.util.concurrent包中；是基于线程池设计的定时任务类，每个调度任务都会被分配到线程池中，并发执行，互不影响。
Spring Task： Spring3.0 以后新增了task，一个轻量级的Quartz，功能够用，用法简单。
Quartz： 功能最为强大的调度器，可以让程序在指定时间执行，也可以按照某一个频度执行，它还可以动态开关，但是配置起来比较复杂。现如今开源社区中已经很多基于Quartz 实现的分布式定时任务项目（xxl-job、elastic-job）。
Timer
public class TimerDemo {
public static void main(String[] args) {
TimerTask timerTask = new TimerTask() {
@Override
public void run() {
System.out.println("执行任务:" + LocalDateTime.now());
}
};
Timer timer = new Timer();
// timerTask：需要执行的任务
// delay：延迟时间（以毫秒为单位）
// period：间隔时间（以毫秒为单位）
timer.schedule(timerTask, 5000, 3000);
}
}ScheduledExecutorServiceDemo
与Timer很类似，但它的效果更好，多线程并行处理定时任务时，Timer运行多个TimeTask时，只要其中有一个因任务报错没有捕获抛出的异常，其它任务便会自动终止运行，使用 ScheduledExecutorService 则可以规避这个问题
public class ScheduledExecutorServiceDemo {
public static void main(String[] args) {
ScheduledExecutorService service = Executors.newScheduledThreadPool(10);
// 参数：1、具体执行的任务 2、首次执行的延时时间
// 3、任务执行间隔 4、间隔时间单位
service.scheduleAtFixedRate(() -> System.out.println("执行任务A:" + LocalDateTime.now()), 0, 3, TimeUnit.SECONDS);
}
}Spring Task
导入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>常用注解
@Scheduled
定时任务的核心
cron： cron表达式，根据表达式循环执行，与fixedRate属性不同的是它是将时间进行了切割。（@Scheduled(cron = "0/5 * * * * *")任务将在5、10、15、20...这种情况下进行工作）fixedRate： 每隔多久执行一次；（@Scheduled(fixedRate = 1000)假设第一次工作时间为2018-05-29 16:58:28，工作时长为3秒，那么下次任务的时候就是2018-05-29 16:58:31，配置成异步后，只要到了执行时间就会开辟新的线程工作），如果（@Scheduled(fixedRate = 3000) 假设第一次工作时间为2018-05-29 16:58:28，工作时长为1秒，那么下次任务的时间依然是2018-05-29 16:58:31）fixedDelay： 当前任务执行完毕后等待多久继续下次任务（@Scheduled(fixedDelay = 3000) 假设第一次任务工作时间为2018-05-29 16:54:33，工作时长为5秒，那么下次任务的时间就是2018-05-29 16:54:41）initialDelay： 第一次执行延迟时间，只是做延迟的设定，与fixedDelay关系密切，配合使用，相辅相成。
Cron说明:
这是一个时间表达式，可以通过简单的配置就能完成各种时间的配置，我们通过CRON表达式几乎可以完成任意的时间搭配，它包含了六或七个域：
Seconds : 可出现", - * /"四个字符，有效范围为0-59的整数
Minutes : 可出现", - * /"四个字符，有效范围为0-59的整数
Hours : 可出现", - * /"四个字符，有效范围为0-23的整数
DayofMonth : 可出现", - * / ? L W C"八个字符，有效范围为0-31的整数
Month : 可出现", - * /"四个字符，有效范围为1-12的整数或JAN-DEc
DayofWeek : 可出现", - * / ? L C #"四个字符，有效范围为1-7的整数或SUN-SAT两个范围。1表示星期天，2表示星期一， 依次类推
Year : 可出现", - * /"四个字符，有效范围为1970-2099年
下面简单举几个例子：
"0 0 12 * * ?" 每天中午十二点触发
"0 15 10 ? * *" 每天早上10：15触发
"0 15 10 * * ?" 每天早上10：15触发
"0 15 10 * * ? *" 每天早上10：15触发
"0 15 10 * * ? 2005" 2005年的每天早上10：15触发
"0 * 14 * * ?" 每天从下午2点开始到2点59分每分钟一次触发
"0 0/5 14 * * ?" 每天从下午2点开始到2：55分结束每5分钟一次触发
"0 0/5 14,18 * * ?" 每天的下午2点至2：55和6点至6点55分两个时间段内每5分钟一次触发
"0 0-5 14 * * ?" 每天14:00至14:05每分钟一次触发
"0 10,44 14 ? 3 WED" 三月的每周三的14：10和14：44触发
"0 15 10 ? * MON-FRI" 每个周一、周二、周三、周四、周五的10：15触发@Async
代表该任务可以进行异步工作，由原本的串行改为并行
@EnableScheduling
表示开启对@Scheduled注解的解析；同时new ThreadPoolTaskScheduler()也是相当的关键，通过阅读过源码可以发现默认情况下的private volatile int poolSize = 1;这就导致了多个任务的情况下容易出现竞争情况（多个任务的情况下，如果第一个任务没执行完毕，后续的任务将会进入等待状态）。
@EnableAsync
表示开启@Async注解的解析；作用就是将串行化的任务给并行化了。（@Scheduled(cron = "0/1 * * * * *")假设第一次工作时间为2018-05-29 17:30:55，工作周期为3秒；如果不加@Async那么下一次工作时间就是2018-05-29 17:30:59；如果加了@Async 下一次工作时间就是2018-05-29 17:30:56）
示例
@Component
public class SpringTaskDemo {
private static final Logger log = LoggerFactory.getLogger(SpringTaskDemo.class);
@Async
@Scheduled(cron = "0/1 * * * * *")
public void scheduled1() throws InterruptedException {
Thread.sleep(3000);
log.info("scheduled1 每1秒执行一次：{}", LocalDateTime.now());
}
@Scheduled(fixedRate = 1000)
public void scheduled2() throws InterruptedException {
Thread.sleep(3000);
log.info("scheduled2 每1秒执行一次：{}", LocalDateTime.now());
}
@Scheduled(fixedDelay = 3000)
public void scheduled3() throws InterruptedException {
Thread.sleep(5000);
log.info("scheduled3 上次执行完毕后隔3秒继续执行：{}", LocalDateTime.now());
}
} /**
*
* No task executor bean found for async processing: no bean of type TaskExecutor and no bean named 'taskExecutor' either
* 很关键：默认情况下 TaskScheduler 的 poolSize = 1
*
* @return 线程池
*/
@Bean
public TaskScheduler taskScheduler() {
ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
taskScheduler.setPoolSize(10);
return taskScheduler;
}Quartz
引入依赖
<quartz.version>2.3.0</quartz.version>
<!--quartz相关依赖-->
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>${quartz.version}</version>
</dependency>
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz-jobs</artifactId>
<version>${quartz.version}</version>
</dependency>
<!--定时任务需要依赖context模块-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
</dependency>初始化信息
-- ----------------------------
-- Table structure for qrtz_blob_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_blob_triggers`;
CREATE TABLE `qrtz_blob_triggers` (
`SCHED_NAME` varchar(120) NOT NULL,
`TRIGGER_NAME` varchar(200) NOT NULL,
`TRIGGER_GROUP` varchar(200) NOT NULL,
`BLOB_DATA` blob DEFAULT NULL,
PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
KEY `SCHED_NAME` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
CONSTRAINT `qrtz_blob_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_calendars
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_calendars`;
CREATE TABLE `qrtz_calendars` (
`SCHED_NAME` varchar(120) NOT NULL,
`CALENDAR_NAME` varchar(200) NOT NULL,
`CALENDAR` blob NOT NULL,
PRIMARY KEY (`SCHED_NAME`,`CALENDAR_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_cron_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_cron_triggers`;
CREATE TABLE `qrtz_cron_triggers` (
`SCHED_NAME` varchar(120) NOT NULL,
`TRIGGER_NAME` varchar(200) NOT NULL,
`TRIGGER_GROUP` varchar(200) NOT NULL,
`CRON_EXPRESSION` varchar(120) NOT NULL,
`TIME_ZONE_ID` varchar(80) DEFAULT NULL,
PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
CONSTRAINT `qrtz_cron_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_fired_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_fired_triggers`;
CREATE TABLE `qrtz_fired_triggers` (
`SCHED_NAME` varchar(120) NOT NULL,
`ENTRY_ID` varchar(95) NOT NULL,
`TRIGGER_NAME` varchar(200) NOT NULL,
`TRIGGER_GROUP` varchar(200) NOT NULL,
`INSTANCE_NAME` varchar(200) NOT NULL,
`FIRED_TIME` bigint(13) NOT NULL,
`SCHED_TIME` bigint(13) NOT NULL,
`PRIORITY` int(11) NOT NULL,
`STATE` varchar(16) NOT NULL,
`JOB_NAME` varchar(200) DEFAULT NULL,
`JOB_GROUP` varchar(200) DEFAULT NULL,
`IS_NONCONCURRENT` varchar(1) DEFAULT NULL,
`REQUESTS_RECOVERY` varchar(1) DEFAULT NULL,
PRIMARY KEY (`SCHED_NAME`,`ENTRY_ID`),
KEY `IDX_QRTZ_FT_TRIG_INST_NAME` (`SCHED_NAME`,`INSTANCE_NAME`),
KEY `IDX_QRTZ_FT_INST_JOB_REQ_RCVRY` (`SCHED_NAME`,`INSTANCE_NAME`,`REQUESTS_RECOVERY`),
KEY `IDX_QRTZ_FT_J_G` (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
KEY `IDX_QRTZ_FT_JG` (`SCHED_NAME`,`JOB_GROUP`),
KEY `IDX_QRTZ_FT_T_G` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
KEY `IDX_QRTZ_FT_TG` (`SCHED_NAME`,`TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_job_details
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_job_details`;
CREATE TABLE `qrtz_job_details` (
`SCHED_NAME` varchar(120) NOT NULL,
`JOB_NAME` varchar(200) NOT NULL,
`JOB_GROUP` varchar(200) NOT NULL,
`DESCRIPTION` varchar(250) DEFAULT NULL,
`JOB_CLASS_NAME` varchar(250) NOT NULL,
`IS_DURABLE` varchar(1) NOT NULL,
`IS_NONCONCURRENT` varchar(1) NOT NULL,
`IS_UPDATE_DATA` varchar(1) NOT NULL,
`REQUESTS_RECOVERY` varchar(1) NOT NULL,
`JOB_DATA` blob DEFAULT NULL,
PRIMARY KEY (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
KEY `IDX_QRTZ_J_REQ_RECOVERY` (`SCHED_NAME`,`REQUESTS_RECOVERY`),
KEY `IDX_QRTZ_J_GRP` (`SCHED_NAME`,`JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_locks
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_locks`;
CREATE TABLE `qrtz_locks` (
`SCHED_NAME` varchar(120) NOT NULL,
`LOCK_NAME` varchar(40) NOT NULL,
PRIMARY KEY (`SCHED_NAME`,`LOCK_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_paused_trigger_grps
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_paused_trigger_grps`;
CREATE TABLE `qrtz_paused_trigger_grps` (
`SCHED_NAME` varchar(120) NOT NULL,
`TRIGGER_GROUP` varchar(200) NOT NULL,
PRIMARY KEY (`SCHED_NAME`,`TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_scheduler_state
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_scheduler_state`;
CREATE TABLE `qrtz_scheduler_state` (
`SCHED_NAME` varchar(120) NOT NULL,
`INSTANCE_NAME` varchar(200) NOT NULL,
`LAST_CHECKIN_TIME` bigint(13) NOT NULL,
`CHECKIN_INTERVAL` bigint(13) NOT NULL,
PRIMARY KEY (`SCHED_NAME`,`INSTANCE_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_simple_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_simple_triggers`;
CREATE TABLE `qrtz_simple_triggers` (
`SCHED_NAME` varchar(120) NOT NULL,
`TRIGGER_NAME` varchar(200) NOT NULL,
`TRIGGER_GROUP` varchar(200) NOT NULL,
`REPEAT_COUNT` bigint(7) NOT NULL,
`REPEAT_INTERVAL` bigint(12) NOT NULL,
`TIMES_TRIGGERED` bigint(10) NOT NULL,
PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
CONSTRAINT `qrtz_simple_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_simprop_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_simprop_triggers`;
CREATE TABLE `qrtz_simprop_triggers` (
`SCHED_NAME` varchar(120) NOT NULL,
`TRIGGER_NAME` varchar(200) NOT NULL,
`TRIGGER_GROUP` varchar(200) NOT NULL,
`STR_PROP_1` varchar(512) DEFAULT NULL,
`STR_PROP_2` varchar(512) DEFAULT NULL,
`STR_PROP_3` varchar(512) DEFAULT NULL,
`INT_PROP_1` int(11) DEFAULT NULL,
`INT_PROP_2` int(11) DEFAULT NULL,
`LONG_PROP_1` bigint(20) DEFAULT NULL,
`LONG_PROP_2` bigint(20) DEFAULT NULL,
`DEC_PROP_1` decimal(13,4) DEFAULT NULL,
`DEC_PROP_2` decimal(13,4) DEFAULT NULL,
`BOOL_PROP_1` varchar(1) DEFAULT NULL,
`BOOL_PROP_2` varchar(1) DEFAULT NULL,
PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
CONSTRAINT `qrtz_simprop_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_triggers`;
CREATE TABLE `qrtz_triggers` (
`SCHED_NAME` varchar(120) NOT NULL,
`TRIGGER_NAME` varchar(200) NOT NULL,
`TRIGGER_GROUP` varchar(200) NOT NULL,
`JOB_NAME` varchar(200) NOT NULL,
`JOB_GROUP` varchar(200) NOT NULL,
`DESCRIPTION` varchar(250) DEFAULT NULL,
`NEXT_FIRE_TIME` bigint(13) DEFAULT NULL,
`PREV_FIRE_TIME` bigint(13) DEFAULT NULL,
`PRIORITY` int(11) DEFAULT NULL,
`TRIGGER_STATE` varchar(16) NOT NULL,
`TRIGGER_TYPE` varchar(8) NOT NULL,
`START_TIME` bigint(13) NOT NULL,
`END_TIME` bigint(13) DEFAULT NULL,
`CALENDAR_NAME` varchar(200) DEFAULT NULL,
`MISFIRE_INSTR` smallint(2) DEFAULT NULL,
`JOB_DATA` blob DEFAULT NULL,
PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
KEY `IDX_QRTZ_T_J` (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
KEY `IDX_QRTZ_T_JG` (`SCHED_NAME`,`JOB_GROUP`),
KEY `IDX_QRTZ_T_C` (`SCHED_NAME`,`CALENDAR_NAME`),
KEY `IDX_QRTZ_T_G` (`SCHED_NAME`,`TRIGGER_GROUP`),
KEY `IDX_QRTZ_T_STATE` (`SCHED_NAME`,`TRIGGER_STATE`),
KEY `IDX_QRTZ_T_N_STATE` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
KEY `IDX_QRTZ_T_N_G_STATE` (`SCHED_NAME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
KEY `IDX_QRTZ_T_NEXT_FIRE_TIME` (`SCHED_NAME`,`NEXT_FIRE_TIME`),
KEY `IDX_QRTZ_T_NFT_ST` (`SCHED_NAME`,`TRIGGER_STATE`,`NEXT_FIRE_TIME`),
KEY `IDX_QRTZ_T_NFT_MISFIRE` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`),
KEY `IDX_QRTZ_T_NFT_ST_MISFIRE` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`,`TRIGGER_STATE`),
KEY `IDX_QRTZ_T_NFT_ST_MISFIRE_GRP` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
CONSTRAINT `qrtz_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`) REFERENCES `qrtz_job_details` (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;Configuration
quartz与Spring相关框架的整合方式有很多种，我们今天采用jobDetail使用Spring Ioc托管方式来完成整合，我们可以在定时任务实例中使用Spring注入注解完成业务逻辑处理
项目内部数据源的方式来设置调度器的jobSotre，官方quartz有两种持久化的配置方案。
第一种：采用quartz.properties配置文件配置独立的定时任务数据源，可以与使用项目的数据库完全独立。
第二种：采用与创建项目统一个数据源，定时任务持久化相关的表与业务逻辑在同一个数据库内。
@Configuration
@EnableScheduling
public class QuartzConfiguration
{
/**
* 继承org.springframework.scheduling.quartz.SpringBeanJobFactory
* 实现任务实例化方式
*/
public static class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory implements
ApplicationContextAware {
private transient AutowireCapableBeanFactory beanFactory;
@Override
public void setApplicationContext(final ApplicationContext context) {
beanFactory = context.getAutowireCapableBeanFactory();
}
/**
* 将job实例交给spring ioc托管
* 我们在job实例实现类内可以直接使用spring注入的调用被spring ioc管理的实例
* @param bundle
* @return
* @throws Exception
*/
@Override
protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
final Object job = super.createJobInstance(bundle);
/**
* 将job实例交付给spring ioc
*/
beanFactory.autowireBean(job);
return job;
}
}
/**
* 配置任务工厂实例
* @param applicationContext spring上下文实例
* @return
*/
@Bean
public JobFactory jobFactory(ApplicationContext applicationContext)
{
/**
* 采用自定义任务工厂 整合spring实例来完成构建任务
* see {@link AutowiringSpringBeanJobFactory}
*/
AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
jobFactory.setApplicationContext(applicationContext);
return jobFactory;
}
/**
* 配置任务调度器
* 使用项目数据源作为quartz数据源
* @param jobFactory 自定义配置任务工厂
* @param dataSource 数据源实例
* @return
* @throws Exception
*/
@Bean(destroyMethod = "destroy",autowire = Autowire.NO)
public SchedulerFactoryBean schedulerFactoryBean(JobFactory jobFactory, DataSource dataSource) throws Exception
{
SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
//将spring管理job自定义工厂交由调度器维护
schedulerFactoryBean.setJobFactory(jobFactory);
//设置覆盖已存在的任务
schedulerFactoryBean.setOverwriteExistingJobs(true);
//项目启动完成后，等待2秒后开始执行调度器初始化
schedulerFactoryBean.setStartupDelay(2);
//设置调度器自动运行
schedulerFactoryBean.setAutoStartup(true);
//设置数据源，使用与项目统一数据源
schedulerFactoryBean.setDataSource(dataSource);
//设置上下文spring bean name
schedulerFactoryBean.setApplicationContextSchedulerContextKey("applicationContext");
//设置配置文件位置
schedulerFactoryBean.setConfigLocation(new ClassPathResource("/quartz.properties"));
return schedulerFactoryBean;
}
}properties
quartz.properties配置文件一定要放在classpath下，放在别的位置有部分功能不会生效。
#调度器实例名称
org.quartz.scheduler.instanceName = quartzScheduler
#调度器实例编号自动生成
org.quartz.scheduler.instanceId = AUTO
#持久化方式配置
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
#持久化方式配置数据驱动，MySQL数据库
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#quartz相关数据表前缀名
org.quartz.jobStore.tablePrefix = QRTZ_
#开启分布式部署
org.quartz.jobStore.isClustered = true
#配置是否使用
org.quartz.jobStore.useProperties = false
#分布式节点有效性检查时间间隔，单位：毫秒
org.quartz.jobStore.clusterCheckinInterval = 20000
#线程池实现类
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
#执行最大并发线程数量
org.quartz.threadPool.threadCount = 10
#线程优先级
org.quartz.threadPool.threadPriority = 5
#配置为守护线程，设置后任务将不会执行
#org.quartz.threadPool.makeThreadsDaemons=true
#配置是否启动自动加载数据库内的定时任务，默认true
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true在上面配置中org.quartz.jobStore.class与org.quartz.jobStore.driverDelegateClass是定时任务持久化的关键配置，配置了数据库持久化定时任务以及采用MySQL数据库进行连接，当然这里我们也可以配置其他的数据库，如下所示： PostgreSQL ： org.quartz.impl.jdbcjobstore.PostgreSQLDelegate Sybase : org.quartz.impl.jdbcjobstore.SybaseDelegate MSSQL : org.quartz.impl.jdbcjobstore.MSSQLDelegate HSQLDB : org.quartz.impl.jdbcjobstore.HSQLDBDelegate Oracle : org.quartz.impl.jdbcjobstore.oracle.OracleDelegate
org.quartz.jobStore.tablePrefix属性配置了定时任务数据表的前缀，在quartz官方提供的创建表SQL脚本默认就是qrtz_，在对应的XxxDelegate驱动类内也是使用的默认值，所以这里我们如果修改表名前缀，配置可以去掉。
org.quartz.jobStore.isClustered属性配置了开启定时任务分布式功能，再开启分布式时对应属性org.quartz.scheduler.instanceId 改成Auto配置即可，实例唯一标识会自动生成，这个标识具体生成的内容，我们一会在运行的控制台就可以看到了，定时任务分布式准备好后会输出相关的分布式节点配置信息。
定义Job和执行
同样需要继承org.springframework.scheduling.quartz.QuartzJobBean抽象类实现抽象类内的executeInternal方法
public class XXXXXTimer
extends QuartzJobBean
{
/**
* logback
*/
static Logger logger = LoggerFactory.getLogger(GoodStockCheckTimer.class);
@Override
protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
logger.info("执行库存检查定时任务，执行时间：{}",new Date());
}
}定义任务调度器
//任务名称
String name = UUID.randomUUID().toString();
//任务所属分组
String group = GoodStockCheckTimer.class.getName();
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0/30 * * * * ?");
//创建任务
JobDetail jobDetail = JobBuilder.newJob(GoodStockCheckTimer.class).withIdentity(name,group).build();
//创建任务触发器
Trigger trigger = TriggerBuilder.newTrigger().withIdentity(name,group).withSchedule(scheduleBuilder).build();
//将触发器与任务绑定到调度器内
scheduler.scheduleJob(jobDetail, trigger);全局异常
异常Model
@Getter
@Setter
@ToString
public class ErrorResponseEntity {
private int code;
private String message;
public ErrorResponseEntity() {}
public ErrorResponseEntity(int code, String message) {
this.code = code;
this.message = message;
}
}自定义异常
public class CustomException extends RuntimeException {
/**
*
*/
private static final long serialVersionUID = 1L;
private int code;
public CustomException() {
super();
}
public CustomException(int code, String message) {
super(message);
this.setCode(code);
}
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
}异常handler
@ControllerAdvice捕获 Controller 层抛出的异常，如果添加 @ResponseBody 返回信息则为JSON 格式。@RestControllerAdvice相当于 @ControllerAdvice 与 @ResponseBody 的结合体。@ExceptionHandler统一处理一种类的异常，减少代码重复率，降低复杂度。
创建一个 GlobalExceptionHandler 类，并添加上@RestControllerAdvice 注解就可以定义出异常通知类了，然后在定义的方法中添加上 @ExceptionHandler 即可实现异常的捕捉…
@RestControllerAdvice
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
/**
* 定义要捕获的异常 可以多个 @ExceptionHandler({})
*
* @param request request
* @param e exception
* @param response response
* @return 响应结果
*/
@ExceptionHandler(CustomException.class)
public ErrorResponseEntity customExceptionHandler(HttpServletRequest request, final Exception e, HttpServletResponse response) {
response.setStatus(HttpStatus.BAD_REQUEST.value());
CustomException exception = (CustomException) e;
return new ErrorResponseEntity(exception.getCode(), exception.getMessage());
}
/**
* 捕获 RuntimeException 异常
* TODO 如果你觉得在一个 exceptionHandler 通过 if (e instanceof xxxException) 太麻烦
* TODO 那么你还可以自己写多个不同的 exceptionHandler 处理不同异常
*
* @param request request
* @param e exception
* @param response response
* @return 响应结果
*/
@ExceptionHandler(RuntimeException.class)
public ErrorResponseEntity runtimeExceptionHandler(HttpServletRequest request, final Exception e, HttpServletResponse response) {
response.setStatus(HttpStatus.BAD_REQUEST.value());
RuntimeException exception = (RuntimeException) e;
return new ErrorResponseEntity(400, exception.getMessage());
}
/**
* 通用的接口映射异常处理方
*/
@Override
protected ResponseEntity<Object> handleExceptionInternal(Exception ex, Object body, HttpHeaders headers,
HttpStatus status, WebRequest request) {
if (ex instanceof MethodArgumentNotValidException) {
MethodArgumentNotValidException exception = (MethodArgumentNotValidException) ex;
return new ResponseEntity<>(new ErrorResponseEntity(status.value(), exception.getBindingResult().getAllErrors().get(0).getDefaultMessage()), status);
}
if (ex instanceof MethodArgumentTypeMismatchException) {
MethodArgumentTypeMismatchException exception = (MethodArgumentTypeMismatchException) ex;
logger.error("参数转换失败，方法：" + exception.getParameter().getMethod().getName() + "，参数：" + exception.getName()
+ ",信息：" + exception.getLocalizedMessage());
return new ResponseEntity<>(new ErrorResponseEntity(status.value(), "参数转换失败"), status);
}
return new ResponseEntity<>(new ErrorResponseEntity(status.value(), "参数转换失败"), status);
}
}数据验证
导入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>JSR-303
这里只列举了 javax.validation 包下的注解，同理在 spring-boot-starter-web 包中也存在 hibernate-validator 验证包，里面包含了一些 javax.validation 没有的注解.
| 注解 | 说明 |
|---|---|
@NotNull | 限制必须不为null |
@NotEmpty | 验证注解的元素值不为 null 且不为空（字符串长度不为0、集合大小不为0） |
@NotBlank | 验证注解的元素值不为空（不为null、去除首位空格后长度为0），不同于@NotEmpty，@NotBlank只应用于字符串且在比较时会去除字符串的空格 |
@Pattern(value) | 限制必须符合指定的正则表达式 |
@Size(max,min) | 限制字符长度必须在 min 到 max 之间（也可以用在集合上） |
@Email | 验证注解的元素值是Email，也可以通过正则表达式和flag指定自定义的email格式 |
@Max(value) | 限制必须为一个不大于指定值的数字 |
@Min(value) | 限制必须为一个不小于指定值的数字 |
@DecimalMax(value) | 限制必须为一个不大于指定值的数字 |
@DecimalMin(value) | 限制必须为一个不小于指定值的数字 |
@Null | 限制只能为null（很少用） |
@AssertFalse | 限制必须为false （很少用） |
@AssertTrue | 限制必须为true （很少用） |
@Past | 限制必须是一个过去的日期 |
@Future | 限制必须是一个将来的日期 |
@Digits(integer,fraction) | 限制必须为一个小数，且整数部分的位数不能超过 integer，小数部分的位数不能超过 fraction （很少用） |
@CreditCardNumber | 信用卡号进行一个大致的验证 |
@Length(min,max) | 检查字段的长度是否在min和max之间,只限于字符串 |
@URL(protocol,host,port | 检查是否为一个有效的URL，如果提供了protocol,host等，则该URL满足条件 |
other
注解介绍
@Validated： 开启数据有效性校验，添加在类上即为验证方法，添加在方法参数中即为验证参数对象。（添加在方法上无效）@NotBlank： 被注释的字符串不允许为空（value.trim() > 0 ? true : false）@Length： 被注释的字符串的大小必须在指定的范围内@NotNull： 被注释的字段不允许为空(value != null ? true : false)@DecimalMin： 被注释的字段必须大于或等于指定的数值
自定义校验
注解
@Target({FIELD, PARAMETER})
@Retention(RUNTIME)
@Constraint(validatedBy = DateTimeValidator.class)
public @interface DateTime {
String message() default "格式错误";
String format() default "yyyy-MM-dd";
Class<?>[] groups() default {};
Class<? extends Payload>[] payload() default {};
}校验器
定义校验器类 DateTimeValidator 实现 ConstraintValidator 接口，实现接口后需要实现它里面的 initialize： 与 isValid： 方法。
initialize： 主要用于初始化，它可以获得当前注解的所有属性isValid： 进行约束验证的主体方法，其中 value 就是验证参数的具体实例，context 代表约束执行的上下文环境。
这里的验证方式虽然简单，但职责明确；为空验证可以使用 @NotBlank、@NotNull、@NotEmpty 等注解来进行控制，而不是在一个注解中做各种各样的规则判断，应该职责分离
public class DateTimeValidator implements ConstraintValidator<DateTime, String> {
private DateTime dateTime;
@Override
public void initialize(DateTime dateTime) {
this.dateTime = dateTime;
}
/**
* 如果 value 为空则不进行格式验证，为空验证可以使用 @NotBlank
* @NotNull @NotEmpty 等注解来进行控制，职责分离
*/
@Override
public boolean isValid(String value, ConstraintValidatorContext context) {
if (value == null) {
return true;
}
String format = dateTime.format();
if (value.length() != format.length()) {
return false;
}
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
try {
simpleDateFormat.parse(value);
} catch (ParseException e) {
return false;
}
return true;
}
}防重提交
本地防重
引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>21.0</version>
</dependency>本地Lock注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface LocalLock {
/**
* @author fly
*/
String key() default "";
/**
* 过期时间 TODO 由于用的 guava 暂时就忽略这属性吧 集成 redis 需要用到
*
* @author fly
*/
int expire() default 5;
}本地Lock注解拦截
首先通过 CacheBuilder.newBuilder() 构建出缓存对象，设置好过期时间；其目的就是为了防止因程序崩溃锁得不到释放（当然如果单机这种方式程序都炸了，锁早没了；但这不妨碍我们写好点）
在具体的 interceptor() 方法上采用的是 Around（环绕增强） ，所有带 LocalLock 注解的都将被切面处理；
如果想更为灵活，key 的生成规则可以定义成接口形式（可以参考：org.springframework.cache.interceptor.KeyGenerator），这里就偷个懒了；
@Aspect
@Configuration
public class LockMethodInterceptor {
private static final Cache<String, Object> CACHES = CacheBuilder.newBuilder()
// 最大缓存 100 个
.maximumSize(1000)
// 设置写缓存后 5 秒钟过期
.expireAfterWrite(5, TimeUnit.SECONDS)
.build();
@Around("execution(public * *(..)) && @annotation(xin.rtime.repea.annotation.LocalLock)")
public Object interceptor(ProceedingJoinPoint pjp) {
MethodSignature signature = (MethodSignature) pjp.getSignature();
Method method = signature.getMethod();
LocalLock localLock = method.getAnnotation(LocalLock.class);
String key = getKey(localLock.key(), pjp.getArgs());
if (!StringUtils.isEmpty(key)) {
if (CACHES.getIfPresent(key) != null) {
throw new RuntimeException("请勿重复请求");
}
// 如果是第一次请求,就将 key 当前对象压入缓存中
CACHES.put(key, key);
}
try {
return pjp.proceed();
} catch (Throwable throwable) {
throw new RuntimeException("服务器异常");
} finally {
// TODO 为了演示效果,这里就不调用 CACHES.invalidate(key); 代码了
}
}
/**
* key 的生成策略,如果想灵活可以写成接口与实现类的方式（TODO 后续讲解）
*
* @param keyExpress 表达式
* @param args 参数
* @return 生成的key
*/
private String getKey(String keyExpress, Object[] args) {
for (int i = 0; i < args.length; i++) {
keyExpress = keyExpress.replace("arg[" + i + "]", args[i].toString());
}
return keyExpress;
}
}示例验证
@LocalLock(key = "book:arg[0]")
@GetMapping
public String query(@RequestParam String token) {
return "success - " + token;
}分布式防重
引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>属性配置
在 application.properites 资源文件中添加 redis 相关的配置项
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=CacheLock 注解
prefix： 缓存中 key 的前缀expire： 过期时间，此处默认为 5 秒timeUnit： 超时单位，此处默认为秒delimiter： key 的分隔符，将不同参数值分割开来@Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited public @interface CacheLock { /** * redis 锁key的前缀 * * @return redis 锁key的前缀 */ String prefix() default ""; /** * 过期秒数,默认为5秒 * * @return 轮询锁的时间 */ int expire() default 5; /** * 超时时间单位 * * @return 秒 */ TimeUnit timeUnit() default TimeUnit.SECONDS; /** * <p>Key的分隔符（默认 :）</p> * <p>生成的Key：N:SO1008:500</p> * * @return String */ String delimiter() default ":"; }CacheParam 注解
@Target({ElementType.PARAMETER, ElementType.METHOD, ElementType.FIELD}) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited public @interface CacheParam { /** * 字段名称 * * @return String */ String name() default ""; }
Key 生成策略（接口）
public interface CacheKeyGenerator {
/**
* 获取AOP参数,生成指定缓存Key
*
* @param pjp PJP
* @return 缓存KEY
*/
String getLockKey(ProceedingJoinPoint pjp);
}Key 生成策略（实现）
public class LockKeyGenerator implements CacheKeyGenerator {
@Override
public String getLockKey(ProceedingJoinPoint pjp) {
MethodSignature signature = (MethodSignature) pjp.getSignature();
Method method = signature.getMethod();
CacheLock lockAnnotation = method.getAnnotation(CacheLock.class);
final Object[] args = pjp.getArgs();
final Parameter[] parameters = method.getParameters();
StringBuilder builder = new StringBuilder();
// TODO 默认解析方法里面带 CacheParam 注解的属性,如果没有尝试着解析实体对象中的
for (int i = 0; i < parameters.length; i++) {
final CacheParam annotation = parameters[i].getAnnotation(CacheParam.class);
if (annotation == null) {
continue;
}
builder.append(lockAnnotation.delimiter()).append(args[i]);
}
if (StringUtils.isEmpty(builder.toString())) {
final Annotation[][] parameterAnnotations = method.getParameterAnnotations();
for (int i = 0; i < parameterAnnotations.length; i++) {
final Object object = args[i];
final Field[] fields = object.getClass().getDeclaredFields();
for (Field field : fields) {
final CacheParam annotation = field.getAnnotation(CacheParam.class);
if (annotation == null) {
continue;
}
field.setAccessible(true);
builder.append(lockAnnotation.delimiter()).append(ReflectionUtils.getField(field, object));
}
}
}
return lockAnnotation.prefix() + builder.toString();
}
}Lock 拦截器（AOP）
熟悉 Redis 的朋友都知道它是线程安全的，我们利用它的特性可以很轻松的实现一个分布式锁，如 opsForValue().setIfAbsent(key,value) 它的作用就是如果缓存中没有当前 Key 则进行缓存同时返回 true 反之亦然；当缓存后给 key 在设置个过期时间，防止因为系统崩溃而导致锁迟迟不释放形成死锁； 那么我们是不是可以这样认为当返回 true 我们认为它获取到锁了，在锁未释放的时候我们进行异常的抛出….
@Aspect
@Configuration
public class LockMethodInterceptor {
@Autowired
public LockMethodInterceptor(RedisLockHelper redisLockHelper, CacheKeyGenerator cacheKeyGenerator) {
this.redisLockHelper = redisLockHelper;
this.cacheKeyGenerator = cacheKeyGenerator;
}
private final RedisLockHelper redisLockHelper;
private final CacheKeyGenerator cacheKeyGenerator;
@Around("execution(public * *(..)) && @annotation(com.battcn.annotation.CacheLock)")
public Object interceptor(ProceedingJoinPoint pjp) {
MethodSignature signature = (MethodSignature) pjp.getSignature();
Method method = signature.getMethod();
CacheLock lock = method.getAnnotation(CacheLock.class);
if (StringUtils.isEmpty(lock.prefix())) {
throw new RuntimeException("lock key don't null...");
}
final String lockKey = cacheKeyGenerator.getLockKey(pjp);
String value = UUID.randomUUID().toString();
try {
// 假设上锁成功，但是设置过期时间失效，以后拿到的都是 false
final boolean success = redisLockHelper.lock(lockKey, value, lock.expire(), lock.timeUnit());
if (!success) {
throw new RuntimeException("重复提交");
}
try {
return pjp.proceed();
} catch (Throwable throwable) {
throw new RuntimeException("系统异常");
}
} finally {
// TODO 如果演示的话需要注释该代码;实际应该放开
redisLockHelper.unlock(lockKey, value);
}
}
}RedisLockHelper
@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisLockHelper {
private static final String DELIMITER = "|";
/**
* 如果要求比较高可以通过注入的方式分配
*/
private static final ScheduledExecutorService EXECUTOR_SERVICE = Executors.newScheduledThreadPool(10);
private final StringRedisTemplate stringRedisTemplate;
public RedisLockHelper(StringRedisTemplate stringRedisTemplate) {
this.stringRedisTemplate = stringRedisTemplate;
}
/**
* 获取锁（存在死锁风险）
*
* @param lockKey lockKey
* @param value value
* @param time 超时时间
* @param unit 过期单位
* @return true or false
*/
public boolean tryLock(final String lockKey, final String value, final long time, final TimeUnit unit) {
return stringRedisTemplate.execute((RedisCallback<Boolean>) connection -> connection.set(lockKey.getBytes(), value.getBytes(), Expiration.from(time, unit), RedisStringCommands.SetOption.SET_IF_ABSENT));
}
/**
* 获取锁
*
* @param lockKey lockKey
* @param uuid UUID
* @param timeout 超时时间
* @param unit 过期单位
* @return true or false
*/
public boolean lock(String lockKey, final String uuid, long timeout, final TimeUnit unit) {
final long milliseconds = Expiration.from(timeout, unit).getExpirationTimeInMilliseconds();
boolean success = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, (System.currentTimeMillis() + milliseconds) + DELIMITER + uuid);
if (success) {
stringRedisTemplate.expire(lockKey, timeout, TimeUnit.SECONDS);
} else {
String oldVal = stringRedisTemplate.opsForValue().getAndSet(lockKey, (System.currentTimeMillis() + milliseconds) + DELIMITER + uuid);
final String[] oldValues = oldVal.split(Pattern.quote(DELIMITER));
if (Long.parseLong(oldValues[0]) + 1 <= System.currentTimeMillis()) {
return true;
}
}
return success;
}
/**
* @see <a href="http://redis.io/commands/set">Redis Documentation: SET</a>
*/
public void unlock(String lockKey, String value) {
unlock(lockKey, value, 0, TimeUnit.MILLISECONDS);
}
/**
* 延迟unlock
*
* @param lockKey key
* @param uuid client(最好是唯一键的)
* @param delayTime 延迟时间
* @param unit 时间单位
*/
public void unlock(final String lockKey, final String uuid, long delayTime, TimeUnit unit) {
if (StringUtils.isEmpty(lockKey)) {
return;
}
if (delayTime <= 0) {
doUnlock(lockKey, uuid);
} else {
EXECUTOR_SERVICE.schedule(() -> doUnlock(lockKey, uuid), delayTime, unit);
}
}
/**
* @param lockKey key
* @param uuid client(最好是唯一键的)
*/
private void doUnlock(final String lockKey, final String uuid) {
String val = stringRedisTemplate.opsForValue().get(lockKey);
final String[] values = val.split(Pattern.quote(DELIMITER));
if (values.length <= 0) {
return;
}
if (uuid.equals(values[1])) {
stringRedisTemplate.delete(lockKey);
}
}
}示例验证
@RestController
@RequestMapping("/books")
public class BookController {
@CacheLock(prefix = "books")
@GetMapping
public String query(@CacheParam(name = "token") @RequestParam String token) {
return "success - " + token;
}
}数据库管理
Liquibase
LiquiBase 是一个用于数据库重构和迁移的开源工具，通过 changelog文件 的形式记录数据库的变更，然后执行 changelog文件 中的修改，将数据库更新或回滚到一致的状态。
- 支持几乎所有主流的数据库，如MySQL、PostgreSQL、Oracle、Sql Server、DB2等
- 支持多开发者的协作维护；
- 日志文件支持多种格式；如XML、YAML、SON、SQL等
- 支持多种运行方式；如命令行、Spring 集成、Maven 插件、Gradle 插件等
导入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>org.liquibase</groupId>
<artifactId>liquibase-core</artifactId>
</dependency>属性配置
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/chapter23?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&useSSL=false
spring.datasource.username=root
spring.datasource.password=root
# 只要依赖了 liquibase-core 默认可以不用做任何配置,但还是需要知道默认配置值是什么
# spring.liquibase.enabled=true
# spring.liquibase.change-log=classpath:/db/changelog/db.changelog-master.yaml- spring.liquibase.change-log 配置文件的路径，默认值为
classpath:/db/changelog/db.changelog-master.yaml - spring.liquibase.check-change-log-location 检查
change log的位置是否存在，默认为true. - spring.liquibase.contexts 用逗号分隔的运行环境列表。
- spring.liquibase.default-schema 默认数据库
schema - spring.liquibase.drop-first 是否先
drop schema（默认 false） - spring.liquibase.enabled 是否开启
liquibase（默认为 true） - spring.liquibase.password 数据库密码
- spring.liquibase.url 要迁移的JDBC URL，如果没有指定的话，将使用配置的主数据源.
- spring.liquibase.user 数据用户名
- spring.liquibase.rollback-file 执行更新时写入回滚的 SQL文件
数据模板
db.changelog-master.yaml
databaseChangeLog:
# 支持 yaml 格式的 SQL 语法
- changeSet:
id: 1
author: Levin
changes:
- createTable:
tableName: person
columns:
- column:
name: id
type: int
autoIncrement: true
constraints:
primaryKey: true
nullable: false
- column:
name: first_name
type: varchar(255)
constraints:
nullable: false
- column:
name: last_name
type: varchar(255)
constraints:
nullable: false
- changeSet:
id: 2
author: Levin
changes:
- insert:
tableName: person
columns:
- column:
name: first_name
value: Marcel
- column:
name: last_name
value: Overdijk
# 同时也支持依赖外部SQL文件（TODO 个人比较喜欢这种）
- changeSet:
id: 3
author: Levin
changes:
- sqlFile:
encoding: utf8
path: classpath:db/changelog/sqlfile/test1.sql
test1.sql
INSERT INTO `person` (`id`, `first_name`, `last_name`) VALUES ('2', '哈哈', '呵呵');websocket
WebSocket 是 HTML5 新增的一种在单个 TCP 连接上进行全双工通讯的协议，与 HTTP 协议没有太大关系….
在 WebSocket API 中，浏览器和服务器只需要做一个握手的动作，然后，浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。
浏览器通过 JavaScript 向服务器发出建立 WebSocket 连接的请求，连接建立以后，客户端和服务器端就可以通过 TCP 连接直接交换数据。
当你获取 WebSocket 连接后，你可以通过 send() 方法来向服务器发送数据，并通过 onmessage() 事件来接收服务器返回的数据..
导入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-websocket</artifactId>
</dependency>WebSocketUtils
public final class WebSocketUtils {
/**
* 模拟存储 websocket session 使用
*/
public static final Map<String, Session> LIVING_SESSIONS_CACHE = new ConcurrentHashMap<>();
public static void sendMessageAll(String message) {
LIVING_SESSIONS_CACHE.forEach((sessionId, session) -> sendMessage(session, message));
}
/**
* 发送给指定用户消息
*
* @param session 用户 session
* @param message 发送内容
*/
public static void sendMessage(Session session, String message) {
if (session == null) {
return;
}
final RemoteEndpoint.Basic basic = session.getBasicRemote();
if (basic == null) {
return;
}
try {
basic.sendText(message);
} catch (IOException e) {
e.printStackTrace();
}
}
}HTML
onopen建立 WebSocket 连接时触发。message客户端监听服务端事件，当服务端向客户端推送消息时会被监听到。errorWebSocket 发生错误时触发。close关闭 WebSocket 连接时触发。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>battcn websocket</title>
<script src="jquery-3.2.1.min.js" ></script>
</head>
<body>
<label for="message_content">聊 天 室 </label><textarea id="message_content" readonly="readonly" cols="57" rows="10">
</textarea>
<br/>
<label for="in_user_name">用户姓名 </label><input id="in_user_name" value=""/>
<button id="btn_join">加入聊天室</button>
<button id="btn_exit">离开聊天室</button>
<br/><br/>
<label for="in_room_msg">群发消息 </label><input id="in_room_msg" value=""/>
<button id="btn_send_all">发送消息</button>
<br/><br/><br/>
好友聊天
<br/>
<label for="in_sender">发送者 </label><input id="in_sender" value=""/><br/>
<label for="in_receive">接受者 </label><input id="in_receive" value=""/><br/>
<label for="in_point_message">消息体 </label><input id="in_point_message" value=""/><button id="btn_send_point">发送消息</button>
</body>
<script type="text/javascript">
$(document).ready(function(){
var urlPrefix ='ws://localhost:8080/chat-room/';
var ws = null;
$('#btn_join').click(function(){
var username = $('#in_user_name').val();
var url = urlPrefix + username;
ws = new WebSocket(url);
ws.onopen = function () {
console.log("建立 websocket 连接...");
};
ws.onmessage = function(event){
//服务端发送的消息
$('#message_content').append(event.data+'\n');
};
ws.onclose = function(){
$('#message_content').append('用户['+username+'] 已经离开聊天室!');
console.log("关闭 websocket 连接...");
}
});
//客户端发送消息到服务器
$('#btn_send_all').click(function(){
var msg = $('#in_room_msg').val();
if(ws){
ws.send(msg);
}
});
// 退出聊天室
$('#btn_exit').click(function(){
if(ws){
ws.close();
}
});
$("#btn_send_point").click(function() {
var sender = $("#in_sender").val();
var receive = $("#in_receive").val();
var message = $("#in_point_message").val();
$.get("/chat-room/"+sender+"/to/"+receive+"?message="+message,function() {
alert("发送成功...")
})
})
})
</script>
</html>Main
@ServerEndpoint 中的内容就是 WebSocket 协议的地址，其实仔细看会发现与 @RequestMapping 也是异曲同工的…
HTTP 协议：http://localhost:8080/path WebSocket 协议：ws://localhost:8080/path @OnOpen、@OnMessage、@OnClose、@OnError 注解与 WebSocket 中监听事件是相对应的…
@RestController
@ServerEndpoint("/chat-room/{username}")
@SpringBootApplication
public class Chapter21Application {
public static void main(String[] args) {
SpringApplication.run(Chapter21Application.class, args);
}
private static final Logger log = LoggerFactory.getLogger(Chapter21Application.class);
@OnOpen
public void openSession(@PathParam("username") String username, Session session) {
LIVING_SESSIONS_CACHE.put(username, session);
String message = "欢迎用户[" + username + "] 来到聊天室！";
log.info(message);
sendMessageAll(message);
}
@OnMessage
public void onMessage(@PathParam("username") String username, String message) {
log.info(message);
sendMessageAll("用户[" + username + "] : " + message);
}
@OnClose
public void onClose(@PathParam("username") String username, Session session) {
//当前的Session 移除
LIVING_SESSIONS_CACHE.remove(username);
//并且通知其他人当前用户已经离开聊天室了
sendMessageAll("用户[" + username + "] 已经离开聊天室了！");
try {
session.close();
} catch (IOException e) {
e.printStackTrace();
}
}
@OnError
public void onError(Session session, Throwable throwable) {
try {
session.close();
} catch (IOException e) {
e.printStackTrace();
}
throwable.printStackTrace();
}
@GetMapping("/chat-room/{sender}/to/{receive}")
public void onMessage(@PathVariable("sender") String sender, @PathVariable("receive") String receive, String message) {
sendMessage(LIVING_SESSIONS_CACHE.get(receive), "[" + sender + "]" + "-> [" + receive + "] : " + message);
}
}安全框架
Spring Security
SpringSecurity是专门针对基于Spring项目的安全框架，充分利用了依赖注入和AOP来实现安全管控。在很多大型企业级系统中权限是最核心的部分，一个系统的好与坏全都在于权限管控是否灵活，是否颗粒化。在早期的SpringSecurity版本中我们需要大量的xml来进行配置，而基于SpringBoot整合SpringSecurity框架相对而言简直是重生了，简单到不可思议的地步。
SpringSecurity框架有两个概念认证和授权，认证可以访问系统的用户，而授权则是用户可以访问的资源，下面我们来简单讲解下SpringBoot对SpringSecurity安全框架的支持。
引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--引入druid最新maven依赖-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.0.29</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<!-- spring boot tomcat jsp 支持开启 -->
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
</dependency>
<!--servlet支持开启-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-taglibs</artifactId>
<version>4.2.1.RELEASE</version>
</dependency>初始化信息
DROP TABLE IF EXISTS `users`;
CREATE TABLE `users` (
u_id bigint(11) UNSIGNED not null AUTO_INCREMENT,
u_username varchar(50) ,
u_password varchar(255),
PRIMARY KEY (`u_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
DROP TABLE IF EXISTS `roles`;
CREATE TABLE `roles` (
r_id bigint(11) UNSIGNED not null AUTO_INCREMENT,
r_name varchar(30),
PRIMARY KEY (`r_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
DROP TABLE IF EXISTS `user_roles`;
CREATE TABLE `user_roles` (
ur_id bigint(11) UNSIGNED not null AUTO_INCREMENT,
ur_user_id bigint(11),
ur_role_id bigint(11),
PRIMARY KEY (`ur_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
INSERT into users VALUES(1,'admin','123456');
INSERT into roles values(1,'超级管理员'),(2,'普通用户');
INSERT into user_roles VALUES(1,1,1),(2,1,2);
select * from users;
select * from roles;
select * from user_roles;Model
RoleEntity：
@Entity
@Table(name = "roles")
public class RoleEntity implements Serializable
{
@Id
@Column(name = "r_id")
private Long id;
@Column(name = "r_name")
private String name;
@Column(name = "r_flag")
private String flag;
// get set 省略....
}@Entity
@Table(name = "users")
public class UserEntity implements Serializable,UserDetails
{
@Id
@Column(name = "u_id")
private Long id;
@Column(name = "u_username")
private String username;
@Column(name = "u_password")
private String password;
@ManyToMany(fetch = FetchType.EAGER)
@JoinTable(
name = "user_roles",
joinColumns = {
@JoinColumn(name = "ur_user_id")
},
inverseJoinColumns = {
@JoinColumn(name = "ur_role_id")
}
)
private List<RoleEntity> roles;
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
List<GrantedAuthority> auths = new ArrayList<>();
List<RoleEntity> roles = getRoles();
for(RoleEntity role : roles)
{
auths.add(new SimpleGrantedAuthority(role.getFlag()));
}
return auths;
}
@Override
public boolean isAccountNonExpired() {
return true;
}
@Override
public boolean isAccountNonLocked() {
return true;
}
@Override
public boolean isCredentialsNonExpired() {
return true;
}
@Override
public boolean isEnabled() {
return true;
}
// get set 省略......
}Service
public class UserService implements UserDetailsService
{
@Autowired
UserJPA userJPA;
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
UserEntity user = userJPA.findByUsername(username);
if(user == null)
{
throw new UsernameNotFoundException("未查询到用户："+username+"信息！");
}
return user;
}
}UserJPA：
public interface UserJPA extends JpaRepository<UserEntity,Long>
{
//使用SpringDataJPA方法定义查询
public UserEntity findByUsername(String username);
}View
@Configuration
public class MVCConfig extends WebMvcConfigurerAdapter
{
@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/login").setViewName("login");
registry.addViewController("/main").setViewName("main");
}
}login.jsp：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>登录界面</title>
</head>
<body>
<form action="/login" method="post">
<%--<input type="hidden" name="${_csrf.parameterName}" value="${_csrf.token}"/>--%>
用户名：<input type="text" name="username"/><br/>
密码：<input type="password" name="password"/><br/>
<input type="submit" value="登录"/>
</form>
</body>
</html>main.jsp：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="sec" uri="http://www.springframework.org/security/tags" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<sec:authorize access="hasRole('ROLE_ADMIN')">
您是超级管理员可以管理信息。
</sec:authorize>
<br/>
<sec:authorize access="hasRole('ROLE_USER')">
您是普通用户只能查看信息。
</sec:authorize>
</body>
</html>WebSecurityConfig
@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter
{
//完成自定义认证实体注入
@Bean
UserDetailsService userService()
{
return new UserService();
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.csrf().disable()
.authorizeRequests()
.anyRequest().authenticated()//所有请求必须登陆后访问
.and()
.formLogin()
.loginPage("/login")
.failureUrl("/login?error")
.permitAll()//登录界面，错误界面可以直接访问
.and()
.logout()
.permitAll();//注销请求可直接访问
}
}spring config
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8
username: root
password: root
#最大活跃数
maxActive: 20
#初始化数量
initialSize: 1
#最大连接等待超时时间
maxWait: 60000
#打开PSCache，并且指定每个连接PSCache的大小
poolPreparedStatements: true
maxPoolPreparedStatementPerConnectionSize: 20
#通过connectionProperties属性来打开mergeSql功能；慢SQL记录
#connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
minIdle: 1
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 300000
validationQuery: select 1 from dual
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
#配置监控统计拦截的filters，去掉后监控界面sql将无法统计,'wall'用于防火墙
filters: stat, wall, log4j
jpa:
properties:
hibernate:
show_sql: true
format_sql: true
mvc:
view:
prefix: /WEB-INF/jsp/
suffix: .jspOAuth2
OAuth是一个关于授权的开放网络标准，在全世界得到的广泛的应用，目前是2.0的版本。OAuth2在“客户端”与“服务提供商”之间，设置了一个授权层(authorization layer)。“客户端”不能直接登录“服务提供商”，只能登录授权层，以此将用户与客户端分离。“客户端”登录需要OAuth提供的令牌，否则将提示认证失败而导致客户端无法访问服务。
OAuth2授权方式：
1、授权码模式（authorization code）
2、简化模式（implicit）
3、密码模式（resource owner password credentials）
4、客户端模式（client credentials）
授权码模式 授权码相对其他三种来说是功能比较完整、流程最安全严谨的授权方式，通过客户端的后台服务器与服务提供商的认证服务器交互来完成。
简化模式：
这种模式不通过服务器端程序来完成，直接由浏览器发送请求获取令牌，令牌是完全暴露在浏览器中的，这种模式极力不推崇
密码模式：
密码模式也是比较常用到的一种，客户端向授权服务器提供用户名、密码然后得到授权令牌。这种模式不过有种弊端，我们的客户端需要存储用户输入的密码，但是对于用户来说信任度不高的平台是不可能让他们输入密码的。
客户端模式：
客户端模式是客户端以自己的名义去授权服务器申请授权令牌，并不是完全意义上的授权。
初始化信息
DROP TABLE IF EXISTS `authority`;
CREATE TABLE `authority` (
`name` varchar(50) NOT NULL,
PRIMARY KEY (`name`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of authority
-- ----------------------------
INSERT INTO `authority` VALUES ('ROLE_ADMIN');
INSERT INTO `authority` VALUES ('ROLE_USER');
-- ----------------------------
-- Table structure for oauth_access_token
-- ----------------------------
DROP TABLE IF EXISTS `oauth_access_token`;
CREATE TABLE `oauth_access_token` (
`token_id` varchar(256) DEFAULT NULL,
`token` blob,
`authentication_id` varchar(256) DEFAULT NULL,
`user_name` varchar(256) DEFAULT NULL,
`client_id` varchar(256) DEFAULT NULL,
`authentication` blob,
`refresh_token` varchar(256) DEFAULT NULL
) ENGINE=MyISAM DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of oauth_access_token
-- ----------------------------
-- ----------------------------
-- Table structure for oauth_refresh_token
-- ----------------------------
DROP TABLE IF EXISTS `oauth_refresh_token`;
CREATE TABLE `oauth_refresh_token` (
`token_id` varchar(256) DEFAULT NULL,
`token` blob,
`authentication` blob
) ENGINE=MyISAM DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of oauth_refresh_token
-- ----------------------------
-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`username` varchar(50) NOT NULL,
`email` varchar(50) DEFAULT NULL,
`password` varchar(500) DEFAULT NULL,
`activated` tinyint(1) DEFAULT '0',
`activationkey` varchar(50) DEFAULT NULL,
`resetpasswordkey` varchar(50) DEFAULT NULL,
PRIMARY KEY (`username`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('admin', '[email protected]', 'b8f57d6d6ec0a60dfe2e20182d4615b12e321cad9e2979e0b9f81e0d6eda78ad9b6dcfe53e4e22d1', '1', null, null);
INSERT INTO `user` VALUES ('user', '[email protected]', 'd6dfa9ff45e03b161e7f680f35d90d5ef51d243c2a8285aa7e11247bc2c92acde0c2bb626b1fac74', '1', null, null);
INSERT INTO `user` VALUES ('rajith', '[email protected]', 'd6dfa9ff45e03b161e7f680f35d90d5ef51d243c2a8285aa7e11247bc2c92acde0c2bb626b1fac74', '1', null, null);
-- ----------------------------
-- Table structure for user_authority
-- ----------------------------
DROP TABLE IF EXISTS `user_authority`;
CREATE TABLE `user_authority` (
`username` varchar(50) NOT NULL,
`authority` varchar(50) NOT NULL,
UNIQUE KEY `user_authority_idx_1` (`username`,`authority`),
KEY `authority` (`authority`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of user_authority
-- ----------------------------
INSERT INTO `user_authority` VALUES ('admin', 'ROLE_ADMIN');
INSERT INTO `user_authority` VALUES ('admin', 'ROLE_USER');
INSERT INTO `user_authority` VALUES ('rajith', 'ROLE_USER');
INSERT INTO `user_authority` VALUES ('user', 'ROLE_USER');引入依赖
<!--SpringSecurity-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework.security.oauth/spring-security-oauth2 -->
<dependency>
<groupId>org.springframework.security.oauth</groupId>
<artifactId>spring-security-oauth2</artifactId>
<version>2.3.3.RELEASE</version>
</dependency>config
authentication.oauth.clientid=yuqiyu_home_pc
authentication.oauth.secret=yuqiyu_secret
authentication.oauth.tokenValidityInSeconds=1800
security.oauth2.resource.filter-order = 3Model
Model和JpaRepository省略。。。。。。
public enum Authorities {
ROLE_ANONYMOUS,
ROLE_USER,
ROLE_ADMIN
}@Component("userDetailsService")
public class UserDetailsService implements UserDetailsService {
@Autowired
private UserJPA userRepository;
@Override
@Transactional
public UserDetails loadUserByUsername(final String login) {
String lowercaseLogin = login.toLowerCase();
User userFromDatabase = userRepository.findByUsernameCaseInsensitive(lowercaseLogin);
if (userFromDatabase == null) {
throw new NewUserNotFoundException("User " + lowercaseLogin + " was not found in the database");
}
//获取用户的所有权限并且SpringSecurity需要的集合
Collection<GrantedAuthority> grantedAuthorities = new ArrayList<>();
for (Authority authority : userFromDatabase.getAuthorities()) {
GrantedAuthority grantedAuthority = new SimpleGrantedAuthority(authority.getName());
grantedAuthorities.add(grantedAuthority);
}
//返回一个SpringSecurity需要的用户对象
return new org.springframework.security.core.userdetails.User(
userFromDatabase.getUsername(),
userFromDatabase.getPassword(),
grantedAuthorities);
}
}SecurityConfiguration
@Configuration
@EnableWebSecurity
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
//自定义UserDetailsService注入
@Autowired
private HengYuUserDetailsService userDetailsService;
//配置匹配用户时密码规则
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
//配置全局设置
@Autowired
public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
//设置UserDetailsService以及密码规则
auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
}
//排除/hello路径拦截
@Override
public void configure(WebSecurity web) throws Exception {
web.ignoring().antMatchers("/hello");
}
@Override
@Bean
public AuthenticationManager authenticationManagerBean() throws Exception {
return super.authenticationManagerBean();
}
//开启全局方法拦截
@EnableGlobalMethodSecurity(prePostEnabled = true, jsr250Enabled = true)
public static class GlobalSecurityConfiguration extends GlobalMethodSecurityConfiguration {
@Override
protected MethodSecurityExpressionHandler createExpressionHandler() {
return new OAuth2MethodSecurityExpressionHandler();
}
}
}OAuth2Configuration
@Configuration
public class OAuth2Configuration {
@Configuration
@EnableResourceServer
protected static class ResourceServerConfiguration extends ResourceServerConfigurerAdapter {
@Autowired
private CustomAuthenticationEntryPoint customAuthenticationEntryPoint;
@Autowired
private CustomLogoutSuccessHandler customLogoutSuccessHandler;
@Override
public void configure(HttpSecurity http) throws Exception {
http
.exceptionHandling()
.authenticationEntryPoint(customAuthenticationEntryPoint)
.and()
.logout()
.logoutUrl("/oauth/logout")
.logoutSuccessHandler(customLogoutSuccessHandler)
.and()
.authorizeRequests()
.antMatchers("/hello/").permitAll()
.antMatchers("/secure/**").authenticated();
}
}
@Configuration
@EnableAuthorizationServer
protected static class AuthorizationServerConfiguration extends AuthorizationServerConfigurerAdapter implements EnvironmentAware {
private static final String ENV_OAUTH = "authentication.oauth.";
private static final String PROP_CLIENTID = "clientid";
private static final String PROP_SECRET = "secret";
private static final String PROP_TOKEN_VALIDITY_SECONDS = "tokenValidityInSeconds";
private RelaxedPropertyResolver propertyResolver;
@Autowired
private DataSource dataSource;
@Bean
public TokenStore tokenStore() {
return new JdbcTokenStore(dataSource);
}
@Autowired
@Qualifier("authenticationManagerBean")
private AuthenticationManager authenticationManager;
@Override
public void configure(AuthorizationServerEndpointsConfigurer endpoints)
throws Exception {
endpoints
.tokenStore(tokenStore())
.authenticationManager(authenticationManager);
}
@Override
public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
clients
.inMemory()
.withClient(propertyResolver.getProperty(PROP_CLIENTID))
.scopes("read", "write")
.authorities(Authorities.ROLE_ADMIN.name(), Authorities.ROLE_USER.name())
.authorizedGrantTypes("password", "refresh_token")
.secret(propertyResolver.getProperty(PROP_SECRET))
.accessTokenValiditySeconds(propertyResolver.getProperty(PROP_TOKEN_VALIDITY_SECONDS, Integer.class, 1800));
}
@Override
public void setEnvironment(Environment environment) {
this.propertyResolver = new RelaxedPropertyResolver(environment, ENV_OAUTH);
}
}
}CustomLogoutSuccessHandler
登出控制清空accessToken
@Component
public class CustomLogoutSuccessHandler
extends AbstractAuthenticationTargetUrlRequestHandler
implements LogoutSuccessHandler {
private static final String BEARER_AUTHENTICATION = "Bearer ";
private static final String HEADER_AUTHORIZATION = "authorization";
@Autowired
private TokenStore tokenStore;
@Override
public void onLogoutSuccess(HttpServletRequest request,
HttpServletResponse response,
Authentication authentication)
throws IOException, ServletException {
String token = request.getHeader(HEADER_AUTHORIZATION);
if (token != null && token.startsWith(BEARER_AUTHENTICATION)) {
OAuth2AccessToken oAuth2AccessToken = tokenStore.readAccessToken(token.split(" ")[0]);
if (oAuth2AccessToken != null) {
tokenStore.removeAccessToken(oAuth2AccessToken);
}
}
response.setStatus(HttpServletResponse.SC_OK);
}
}CustomAuthenticationEntryPoint
自定义401错误码内容
@Component
public class CustomAuthenticationEntryPoint implements AuthenticationEntryPoint {
private final Logger log = LoggerFactory.getLogger(CustomAuthenticationEntryPoint.class);
public void commence(HttpServletRequest request,
HttpServletResponse response,
AuthenticationException ae) throws IOException, ServletException {
log.info("Pre-authenticated entry point called. Rejecting access");
response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Access Denied");
}
}AccessToken操作
- 获取token
访问/oauth/token地址获取access_token
可以看到我们访问的地址，grant_type使用到了password模式，我们在上面的配置中就是配置我们的客户端（yuqiyu_home_pc）可以执行的模式有两种：password、refresh_token。获取access_token需要添加客户端的授权信息clientid、secret，通过Postman工具的头授权信息即可输出对应的值就可以完成Basic Auth的加密串生成。
成功访问后oauth2给我们返回了几个参数：
access_token：本地访问获取到的access_token，会自动写入到数据库中。
token_type：获取到的access_token的授权方式
refersh_token：刷新token时所用到的授权token
expires_in：有效期（从获取开始计时，值秒后过期）
scope：客户端的接口操作权限（read：读，write：写）
JWT
JWT是一种用户双方之间传递安全信息的简洁的、URL安全的表述性声明规范。JWT（Json Web Token）作为一个开放的标准（RFC 7519），定义了一种简洁的、自包含的方法用于通信双方之间以Json对象的形式进行安全性信息传递，传递时有数字签名所以信息时安全的，JWT使用RSA公钥密钥的形式进行签名。
JWT组成
JWT格式的输出是以.分隔的三段Base64编码，与SAML等基于XML的标准相比，JWT在HTTP和HTML环境中更容易传递。（形式：xxxxx.yyy.zzz）：
1、Header：头部
2、Payload：负载
3、Signature：签名
Header
在header中通常包含了两部分，Token类型以及采用加密的算法
Payload
Token的第二部分是负载，它包含了Claim，Claim是一些实体（一般都是用户）的状态和额外的数据组成。
Signature
创建签名需要使用编码后的header和payload以及一个秘钥，使用header中指定签名算法进行签名。
JWT工作流程图
JWT客户端发送请求到服务器端整体流程：
引入依赖
<!--jwt依赖-->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.7.0</version>
</dependency>初始化信息
DROP TABLE IF EXISTS `api_token_infos`;
CREATE TABLE `api_token_infos` (
`ati_id` int(255) NOT NULL AUTO_INCREMENT,
`ati_app_id` varchar(100) DEFAULT NULL,
`ati_token` blob,
`ati_build_time` varchar(20) DEFAULT NULL COMMENT '生成token时间（秒单位）',
PRIMARY KEY (`ati_id`),
KEY `ati_app_id` (`ati_app_id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=30 DEFAULT CHARSET=utf8 COMMENT='api请求token信息表，根据appId保存';
-- ----------------------------
-- Records of api_token_infos
-- ----------------------------
INSERT INTO `api_token_infos` VALUES ('29', 'c2R4bWtqX21vYmlsZTQ4QTkxMzAwMTkyQzJFMTgzODc0N0NFMzk4MTREM0ZG', 0x65794A68624763694F694A49557A49314E694A392E65794A7A645749694F694A6A4D6C4930596C6430635667794D585A5A6257787A576C52524E4646556133684E656B46335456527265564636536B5A4E564764365430526A4D453477546B5A4E656D73305456525352553077576B63694C434A70595851694F6A45304F5449344E7A51784F545573496D6C7A63794936496B397562476C755A53425A515856306143424364576C735A475679496977695A586877496A6F784E446B794F4467784D7A6B3166512E30464251735536635A53796F46695371316F6F775737634D345358756A3944644439795544324956736B34, '1492874196023');
-- ----------------------------
-- Table structure for api_user_infos
-- ----------------------------
DROP TABLE IF EXISTS `api_user_infos`;
CREATE TABLE `api_user_infos` (
`aui_app_id` varchar(100) NOT NULL COMMENT '授权唯一标识',
`aui_app_secret` blob NOT NULL COMMENT '授权密钥',
`aui_status` char(1) NOT NULL DEFAULT '1' COMMENT '用户状态,1：正常，0：无效',
`aui_day_request_count` int(11) NOT NULL COMMENT '日请求量',
`aui_ajax_bind_ip` varchar(100) DEFAULT NULL COMMENT '绑定IP地址多个使用“,”隔开',
`aui_mark` varchar(255) DEFAULT NULL COMMENT '备注',
PRIMARY KEY (`aui_app_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='api平台用户信息表';
-- ----------------------------
-- Records of api_user_infos
-- ----------------------------
INSERT INTO `api_user_infos` VALUES ('c2R4bWtqX21vYmlsZTQ4QTkxMzAwMTkyQzJFMTgzODc0N0NFMzk4MTREM0ZG', 0x6D4B6B377237494A6B632B52566A765068334D34504736564947556C6744376A4F6F3356776B484A4B534F4C395179643742573159496E764A582F4E324D4B52584A412F626B33524A3532444E376E4B41376464393251642B2B75712B33775342355359303871492F4F787038524979445635513679614B7541786E304767374566792F4374587562537A4A496D394748675878676D3079523135615573386358434B414C62544D34734E5632694F73544E616C3138395843395363457A5A323042576C4D4E4742637A676D4C7A3368464B71624F6E2F46384465535A3043395A43664137322B4A6B6A5A72723168775765537868465A473071706D6666355A4631324C736843383639682B374F707A6238466359655469716B5A7245596E71666663367A557659303533505368584C37644D38466E4546414F4749393457644A5041547936786C456C62664D492F6954412B4371513D3D, '1', '0', '*', '测试用户');Model
model、JpaRepository、Controller省略。。。。
public class TokenResult implements Serializable{
//状态
private boolean flag = true;
//返回消息内容
private String msg = "";
//返回token值
private String token ="";
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public String getToken() {
return token;
}
public void setToken(String token) {
this.token = token;
}
}生成Token：
生成Token方法的内容大致是，检查appId以及appSecret-->检查是否存在该appId的对应Token-->根据存在与否、过期与否执行更新或者写入操作-->返回用户请求。
在createNewToken方法中是JWT生成Token的方法，我们默认了过期时间为7200秒，上面是毫秒单位，我们生成token需要指定subject也就是我们的用户对象，设置过期时间、生成时间、还有签名生成规则等。token生成方法已经编写完成，下面我们需要在除了获取token的路径排除在外拦截所有的路径，验证路径是否存在header包含token，并且验证token是否正确，jwt会自动给我们验证过期，如果过期会抛出对应的异常。
@RestController
@RequestMapping(value = "/jwt")
public class TokenController
{
@Autowired
private TokenJPA tokenJPA;
@Autowired
private UserInfoJPA userInfoJPA;
/**
* 获取token，更新token
* @param appId 用户编号
* @param appSecret 用户密码
* @return
*/
@RequestMapping(value = "/token", method = {RequestMethod.POST,RequestMethod.GET})
public TokenResult token
(
@RequestParam String appId,
@RequestParam String appSecret
)
{
TokenResult token = new TokenResult();
//appId is null
if(appId == null || appId.trim() == "")
{
token.setFlag(false);
token.setMsg("appId is not found!");
}
//appSecret is null
else if(appSecret == null || appSecret.trim() == "")
{
token.setFlag(false);
token.setMsg("appSecret is not found!");
}
else
{
//根据appId查询用户实体
UserInfoEntity userDbInfo = userInfoJPA.findOne(new Specification<UserInfoEntity>() {
@Override
public Predicate toPredicate(Root<UserInfoEntity> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
criteriaQuery.where(criteriaBuilder.equal(root.get("appId"), appId));
return null;
}
});
//如果不存在
if (userDbInfo == null)
{
token.setFlag(false);
token.setMsg("appId : " + appId + ", is not found!");
}
//验证appSecret是否存在
else if (!new String(userDbInfo.getAppSecret()).equals(appSecret.replace(" ","+")))
{
token.setFlag(false);
token.setMsg("appSecret is not effective!");
}
else
{
//检测数据库是否存在该appId的token值
TokenInfoEntity tokenDBEntity = tokenJPA.findOne(new Specification<TokenInfoEntity>() {
@Override
public Predicate toPredicate(Root<TokenInfoEntity> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
criteriaQuery.where(criteriaBuilder.equal(root.get("appId"), appId));
return null;
}
});
//返回token值
String tokenStr = null;
//tokenDBEntity == null -> 生成newToken -> 保存数据库 -> 写入内存 -> 返回newToken
if(tokenDBEntity == null)
{
//生成jwt,Token
tokenStr = createNewToken(appId);
//将token保持到数据库
tokenDBEntity = new TokenInfoEntity();
tokenDBEntity.setAppId(userDbInfo.getAppId());
tokenDBEntity.setBuildTime(String.valueOf(System.currentTimeMillis()));
tokenDBEntity.setToken(tokenStr.getBytes());
tokenJPA.save(tokenDBEntity);
}
//tokenDBEntity != null -> 验证是否超时 ->
//不超时 -> 直接返回dbToken
//超时 -> 生成newToken -> 更新dbToken -> 更新内存Token -> 返回newToken
else
{
//判断数据库中token是否过期，如果没有过期不需要更新直接返回数据库中的token即可
//数据库中生成时间
long dbBuildTime = Long.valueOf(tokenDBEntity.getBuildTime());
//当前时间
long currentTime = System.currentTimeMillis();
//如果当前时间 - 数据库中生成时间 < 7200 证明可以正常使用
long second = TimeUnit.MILLISECONDS.toSeconds(currentTime - dbBuildTime);
if (second > 0 && second < 7200) {
tokenStr = new String(tokenDBEntity.getToken());
}
//超时
else{
//生成newToken
tokenStr = createNewToken(appId);
//更新token
tokenDBEntity.setToken(tokenStr.getBytes());
//更新生成时间
tokenDBEntity.setBuildTime(String.valueOf(System.currentTimeMillis()));
//执行更新
tokenJPA.save(tokenDBEntity);
}
}
//设置返回token
token.setToken(tokenStr);
}
}
return token;
}
/**
* 创建新token
* @param appId
* @return
*/
private String createNewToken(String appId){
//获取当前时间
Date now = new Date(System.currentTimeMillis());
//过期时间
Date expiration = new Date(now.getTime() + 7200000);
return Jwts
.builder()
.setSubject(appId)
//.claim(YAuthConstants.Y_AUTH_ROLES, userDbInfo.getRoles())
.setIssuedAt(now)
.setIssuer("Online YAuth Builder")
.setExpiration(expiration)
.signWith(SignatureAlgorithm.HS256, "HengYuAuthv1.0.0")
.compact();
}
}configuration
@Configuration
public class JWTConfiguration extends WebMvcConfigurerAdapter
{
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new JwtTokenInterceptor()).addPathPatterns("/api/**");
}
}interceptor
Claims就是我们生成Token是的对象，我们把传递的头信息token通过JWT可以逆转成Claims对象，并且通过getSubject可以获取到我们用户的appId。
public class JwtTokenInterceptor implements HandlerInterceptor
{
/**
* 请求之前
* @param request 请求对象
* @param response 返回对象
* @param o
* @return
* @throws Exception
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object o) throws Exception {
//自动排除生成token的路径,并且如果是options请求是cors跨域预请求，设置allow对应头信息
if(request.getRequestURI().equals("/token") || RequestMethod.OPTIONS.toString().equals(request.getMethod()))
{
return true;
}
//其他请求获取头信息
final String authHeader = request.getHeader("X-YAuth-Token");
try {
//如果没有header信息
if (authHeader == null || authHeader.trim() == "") {
throw new SignatureException("not found X-YAuth-Token.");
}
//获取jwt实体对象接口实例
final Claims claims = Jwts.parser().setSigningKey("HengYuAuthv1.0.0")
.parseClaimsJws(authHeader).getBody();
//从数据库中获取token
TokenInfoEntity token = getDAO(TokenJPA.class,request).findOne(new Specification<TokenInfoEntity>() {
@Override
public Predicate toPredicate(Root<TokenInfoEntity> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
criteriaQuery.where(criteriaBuilder.equal(root.get("appId"), claims.getSubject()));
return null;
}
});
//数据库中的token值
String tokenval = new String(token.getToken());
//如果内存中不存在,提示客户端获取token
if(tokenval == null || tokenval.trim() == "") {
throw new SignatureException("not found token info, please get token agin.");
}
//判断内存中的token是否与客户端传来的一致
if(!tokenval.equals(authHeader))
{
throw new SignatureException("not found token info, please get token agin.");
}
}
//验证异常处理
catch (SignatureException | ExpiredJwtException e)
{
//输出对象
PrintWriter writer = response.getWriter();
//输出error消息
writer.write("need refresh token");
writer.close();
return false;
}
//出现异常时
catch (final Exception e)
{
//输出对象
PrintWriter writer = response.getWriter();
//输出error消息
writer.write(e.getMessage());
writer.close();
return false;
}
return true;
}
/**
* 根据传入的类型获取spring管理的对应dao
* @param clazz 类型
* @param request 请求对象
* @param <T>
* @return
*/
private <T> T getDAO(Class<T> clazz,HttpServletRequest request)
{
BeanFactory factory = WebApplicationContextUtils.getRequiredWebApplicationContext(request.getServletContext());
return factory.getBean(clazz);
}
@Override
public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
}
@Override
public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
}
}验证
我们在拦截器中配置的无论是不存在token还是token需要刷新都是返回"need refresh token"错误信息
可以看到我们将之前获取的token作为请求header（X-YAuth-Token）的值进行传递，再次访问127.0.0.1:8080/api/index，就可以成功的获取接口返回的数据。
注意：如果Token过期，再次访问/jwt/token地址传入对应的appId以及appSecret就可以获取一条新的token，也会对应的更新数据库token信息表的内容。Shiro
Shiro 是 Apache 旗下开源的一款强大且易用的Java安全框架，身份验证、授权、加密、会话管理。 相比 Spring Security 而言 Shiro 更加轻量级，且 API 更易于理解…
Shiro 主要分为 安全认证 和 接口授权 两个部分，其中的核心组件为 Subject、SecurityManager、Realms，公共部分 Shiro 都已经为我们封装好了，我们只需要按照一定的规则去编写响应的代码即可…
Subject即表示主体，将用户的概念理解为当前操作的主体，因为它即可以是一个通过浏览器请求的用户，也可能是一个运行的程序，外部应用与 Subject 进行交互，记录当前操作用户。Subject 代表了当前用户的安全操作，SecurityManager 则管理所有用户的安全操作。SecurityManager即安全管理器，对所有的 Subject 进行安全管理，并通过它来提供安全管理的各种服务（认证、授权等）Realm充当了应用与数据安全间的 桥梁 或 连接器。当对用户执行认证（登录）和授权（访问控制）验证时，Shiro 会从应用配置的 Realm 中查找用户及其权限信息。
引入依赖
<shiro.version>1.4.0</shiro.version>
<!-- shiro 相关包 -->
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
<version>${shiro.version}</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-web</artifactId>
<version>${shiro.version}</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>${shiro.version}</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-ehcache</artifactId>
<version>${shiro.version}</version>
</dependency>
<!-- End -->缓存配置
Shiro 为我们提供了 CacheManager 即缓存管理，将用户权限数据存储在缓存，可以提高它的性能。支持 EhCache、Redis 等常规缓存，这里为了简单起见就用 EhCache 了 ， 在resources 目录下创建一个 ehcache-shiro.xml 文件
<?xml version="1.0" encoding="UTF-8"?>
<ehcache updateCheck="false" name="shiroCache">
<defaultCache
maxElementsInMemory="10000"
eternal="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
overflowToDisk="false"
diskPersistent="false"
diskExpiryThreadIntervalSeconds="120"
/>
</ehcache>实体Model
@Getter
@Setter
@ToString
public class User {
/** 自增ID */
private Long id;
/** 账号 */
private String username;
/** 密码 */
private String password;
/** 角色名：Shiro 支持多个角色，而且接收参数也是 Set<String> 集合，但这里为了简单起见定义成 String 类型了 */
private String roleName;
/** 是否禁用 */
private boolean locked;
public User() {}
public User(Long id, String username, String password, String roleName, boolean locked) {
this.id = id;
this.username = username;
this.password = password;
this.roleName = roleName;
this.locked = locked;
}
}伪造数据
public class DBCache {
/**
* K 用户名
* V 用户信息
*/
public static final Map<String, User> USERS_CACHE = new HashMap<>();
/**
* K 角色ID
* V 权限编码
*/
public static final Map<String, Collection<String>> PERMISSIONS_CACHE = new HashMap<>();
static {
// TODO 假设这是数据库记录
USERS_CACHE.put("u1", new User(1L, "u1", "p1", "admin", true));
USERS_CACHE.put("u2", new User(2L, "u2", "p2", "admin", false));
USERS_CACHE.put("u3", new User(3L, "u3", "p3", "test", true));
PERMISSIONS_CACHE.put("admin", Arrays.asList("user:list", "user:add", "user:edit"));
PERMISSIONS_CACHE.put("test", Collections.singletonList("user:list"));
}
}ShiroConfiguration
@Configuration
public class ShiroConfiguration {
private static final Logger log = LoggerFactory.getLogger(ShiroConfiguration.class);
@Bean
public EhCacheManager getEhCacheManager() {
EhCacheManager em = new EhCacheManager();
em.setCacheManagerConfigFile("classpath:ehcache-shiro.xml");
return em;
}
@Bean(name = "lifecycleBeanPostProcessor")
public LifecycleBeanPostProcessor getLifecycleBeanPostProcessor() {
return new LifecycleBeanPostProcessor();
}
/**
* 加密器：这样一来数据库就可以是密文存储，为了演示我就不开启了
*
* @return HashedCredentialsMatcher
*/
// @Bean
// public HashedCredentialsMatcher hashedCredentialsMatcher() {
// HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
// //散列算法:这里使用MD5算法;
// hashedCredentialsMatcher.setHashAlgorithmName("md5");
// //散列的次数，比如散列两次，相当于 md5(md5(""));
// hashedCredentialsMatcher.setHashIterations(2);
// return hashedCredentialsMatcher;
// }
@Bean
public DefaultAdvisorAutoProxyCreator getDefaultAdvisorAutoProxyCreator() {
DefaultAdvisorAutoProxyCreator autoProxyCreator = new DefaultAdvisorAutoProxyCreator();
autoProxyCreator.setProxyTargetClass(true);
return autoProxyCreator;
}
@Bean(name = "authRealm")
public AuthRealm authRealm(EhCacheManager cacheManager) {
AuthRealm authRealm = new AuthRealm();
authRealm.setCacheManager(cacheManager);
return authRealm;
}
@Bean(name = "securityManager")
public DefaultWebSecurityManager getDefaultWebSecurityManager(AuthRealm authRealm) {
DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
defaultWebSecurityManager.setRealm(authRealm);
// <!-- 用户授权/认证信息Cache, 采用EhCache 缓存 -->
defaultWebSecurityManager.setCacheManager(getEhCacheManager());
return defaultWebSecurityManager;
}
@Bean
public AuthorizationAttributeSourceAdvisor getAuthorizationAttributeSourceAdvisor(
DefaultWebSecurityManager securityManager) {
AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
advisor.setSecurityManager(securityManager);
return advisor;
}
/**
* ShiroFilter<br/>
* 注意这里参数中的 StudentService 和 IScoreDao 只是一个例子，因为我们在这里可以用这样的方式获取到相关访问数据库的对象，
* 然后读取数据库相关配置，配置到 shiroFilterFactoryBean 的访问规则中。实际项目中，请使用自己的Service来处理业务逻辑。
*
* @param securityManager 安全管理器
* @return ShiroFilterFactoryBean
*/
@Bean(name = "shiroFilter")
public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager securityManager) {
ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
// 必须设置 SecurityManager
shiroFilterFactoryBean.setSecurityManager(securityManager);
// 如果不设置默认会自动寻找Web工程根目录下的"/login"页面
shiroFilterFactoryBean.setLoginUrl("/login");
// 登录成功后要跳转的连接
shiroFilterFactoryBean.setSuccessUrl("/index");
shiroFilterFactoryBean.setUnauthorizedUrl("/denied");
loadShiroFilterChain(shiroFilterFactoryBean);
return shiroFilterFactoryBean;
}
/**
* 加载shiroFilter权限控制规则（从数据库读取然后配置）
*/
private void loadShiroFilterChain(ShiroFilterFactoryBean shiroFilterFactoryBean) {
/////////////////////// 下面这些规则配置最好配置到配置文件中 ///////////////////////
// TODO 重中之重啊，过滤顺序一定要根据自己需要排序
Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
// 需要验证的写 authc 不需要的写 anon
filterChainDefinitionMap.put("/resource/**", "anon");
filterChainDefinitionMap.put("/install", "anon");
filterChainDefinitionMap.put("/hello", "anon");
// anon：它对应的过滤器里面是空的,什么都没做
log.info("##################从数据库读取权限规则，加载到shiroFilter中##################");
// 不用注解也可以通过 API 方式加载权限规则
Map<String, String> permissions = new LinkedHashMap<>();
permissions.put("/users/find", "perms[user:find]");
filterChainDefinitionMap.putAll(permissions);
filterChainDefinitionMap.put("/**", "authc");
shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
}
}AuthRealm
上面介绍过 Realm ，安全认证和权限验证的核心处理就是重写 AuthorizingRealm 中的 doGetAuthenticationInfo（登录认证） 与 doGetAuthorizationInfo（权限验证）
@Configuration
public class AuthRealm extends AuthorizingRealm {
/**
* 认证回调函数,登录时调用
* 首先根据传入的用户名获取User信息；然后如果user为空，那么抛出没找到帐号异常UnknownAccountException；
* 如果user找到但锁定了抛出锁定异常LockedAccountException；最后生成AuthenticationInfo信息，
* 交给间接父类AuthenticatingRealm使用CredentialsMatcher进行判断密码是否匹配，
* 如果不匹配将抛出密码错误异常IncorrectCredentialsException；
* 另外如果密码重试此处太多将抛出超出重试次数异常ExcessiveAttemptsException；
* 在组装SimpleAuthenticationInfo信息时， 需要传入：身份信息（用户名）、凭据（密文密码）、盐（username+salt），
* CredentialsMatcher使用盐加密传入的明文密码和此处的密文密码进行匹配。
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token)
throws AuthenticationException {
String principal = (String) token.getPrincipal();
User user = Optional.ofNullable(DBCache.USERS_CACHE.get(principal)).orElseThrow(UnknownAccountException::new);
if (!user.isLocked()) {
throw new LockedAccountException();
}
// 从数据库查询出来的账号名和密码,与用户输入的账号和密码对比
// 当用户执行登录时,在方法处理上要实现 user.login(token)
// 然后会自动进入这个类进行认证
// 交给 AuthenticatingRealm 使用 CredentialsMatcher 进行密码匹配，如果觉得人家的不好可以自定义实现
// TODO 如果使用 HashedCredentialsMatcher 这里认证方式就要改一下 SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(principal, "密码", ByteSource.Util.bytes("密码盐"), getName());
SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(principal, user.getPassword(), getName());
Session session = SecurityUtils.getSubject().getSession();
session.setAttribute("USER_SESSION", user);
return authenticationInfo;
}
/**
* 只有需要验证权限时才会调用, 授权查询回调函数, 进行鉴权但缓存中无用户的授权信息时调用.在配有缓存的情况下，只加载一次.
* 如果需要动态权限,但是又不想每次去数据库校验,可以存在ehcache中.自行完善
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principal) {
Session session = SecurityUtils.getSubject().getSession();
User user = (User) session.getAttribute("USER_SESSION");
// 权限信息对象info,用来存放查出的用户的所有的角色（role）及权限（permission）
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
// 用户的角色集合
Set<String> roles = new HashSet<>();
roles.add(user.getRoleName());
info.setRoles(roles);
// 用户的角色对应的所有权限，如果只使用角色定义访问权限，下面可以不要
// 只有角色并没有颗粒度到每一个按钮 或 是操作选项 PERMISSIONS 是可选项
final Map<String, Collection<String>> permissionsCache = DBCache.PERMISSIONS_CACHE;
final Collection<String> permissions = permissionsCache.get(user.getRoleName());
info.addStringPermissions(permissions);
return info;
}
}控制器
在 ShiroConfiguration 中的 shiroFilter 处配置了 /hello = anon，意味着可以不需要认证也可以访问，那么除了这种方式外 Shiro 还为我们提供了一些注解相关的方式…
常用注解
@RequiresGuest代表无需认证即可访问，同理的就是 /path = anon@RequiresAuthentication需要认证，只要登录成功后就允许你操作@RequiresPermissions需要特定的权限，没有则抛出AuthorizationException@RequiresRoles需要特定的角色，没有则抛出AuthorizationException@RequiresUser不太清楚，不常用…
限流
单机版中我们了解到 AtomicInteger、RateLimiter、Semaphore 这几种解决方案，但它们也仅仅是单机的解决手段，在集群环境下就透心凉了，后面又讲述了 Nginx 的限流手段，可它又属于网关层面的策略之一，并不能解决所有问题。例如供短信接口，你无法保证消费方是否会做好限流控制，所以自己在应用层实现限流还是很有必要的。
导入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>21.0</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>属性配置
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=Limit 注解
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Limit {
/**
* 资源的名字
*
* @return String
*/
String name() default "";
/**
* 资源的key
*
* @return String
*/
String key() default "";
/**
* Key的prefix
*
* @return String
*/
String prefix() default "";
/**
* 给定的时间段
* 单位秒
*
* @return int
*/
int period();
/**
* 最多的访问限制次数
*
* @return int
*/
int count();
/**
* 类型
*
* @return LimitType
*/
LimitType limitType() default LimitType.CUSTOMER;
public enum LimitType {
/**
* 自定义key
*/
CUSTOMER,
/**
* 根据请求者IP
*/
IP;
}
}RedisTemplate
@Configuration
public class RedisLimiterHelper {
@Bean
public RedisTemplate<String, Serializable> limitRedisTemplate(LettuceConnectionFactory redisConnectionFactory) {
RedisTemplate<String, Serializable> template = new RedisTemplate<>();
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
template.setConnectionFactory(redisConnectionFactory);
return template;
}
}Limit 拦截器（AOP）
@Aspect
@Configuration
public class LimitInterceptor {
private static final Logger logger = LoggerFactory.getLogger(LimitInterceptor.class);
private final RedisTemplate<String, Serializable> limitRedisTemplate;
@Autowired
public LimitInterceptor(RedisTemplate<String, Serializable> limitRedisTemplate) {
this.limitRedisTemplate = limitRedisTemplate;
}
@Around("execution(public * *(..)) && @annotation(xin.rtime.limiter.annotation.Limit)")
public Object interceptor(ProceedingJoinPoint pjp) {
MethodSignature signature = (MethodSignature) pjp.getSignature();
Method method = signature.getMethod();
Limit limitAnnotation = method.getAnnotation(Limit.class);
LimitType limitType = limitAnnotation.limitType();
String name = limitAnnotation.name();
String key;
int limitPeriod = limitAnnotation.period();
int limitCount = limitAnnotation.count();
switch (limitType) {
case IP:
key = getIpAddress();
break;
case CUSTOMER:
// TODO 如果此处想根据表达式或者一些规则生成 请看 一起来学Spring Boot | 第二十三篇：轻松搞定重复提交（分布式锁）
key = limitAnnotation.key();
break;
default:
key = StringUtils.upperCase(method.getName());
}
ImmutableList<String> keys = ImmutableList.of(StringUtils.join(limitAnnotation.prefix(), key));
try {
String luaScript = buildLuaScript();
RedisScript<Number> redisScript = new DefaultRedisScript<>(luaScript, Number.class);
Number count = limitRedisTemplate.execute(redisScript, keys, limitCount, limitPeriod);
logger.info("Access try count is {} for name={} and key = {}", count, name, key);
if (count != null && count.intValue() <= limitCount) {
return pjp.proceed();
} else {
throw new RuntimeException("You have been dragged into the blacklist");
}
} catch (Throwable e) {
if (e instanceof RuntimeException) {
throw new RuntimeException(e.getLocalizedMessage());
}
throw new RuntimeException("server exception");
}
}
/**
* 限流 脚本
*
* @return lua脚本
*/
public String buildLuaScript() {
StringBuilder lua = new StringBuilder();
lua.append("local c");
lua.append("\nc = redis.call('get',KEYS[1])");
// 调用不超过最大值，则直接返回
lua.append("\nif c and tonumber(c) > tonumber(ARGV[1]) then");
lua.append("\nreturn c;");
lua.append("\nend");
// 执行计算器自加
lua.append("\nc = redis.call('incr',KEYS[1])");
lua.append("\nif tonumber(c) == 1 then");
// 从第一次调用开始限流，设置对应键值的过期
lua.append("\nredis.call('expire',KEYS[1],ARGV[2])");
lua.append("\nend");
lua.append("\nreturn c;");
return lua.toString();
}
private static final String UNKNOWN = "unknown";
public String getIpAddress() {
HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
String ip = request.getHeader("x-forwarded-for");
if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
ip = request.getHeader("Proxy-Client-IP");
}
if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
ip = request.getHeader("WL-Proxy-Client-IP");
}
if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
ip = request.getRemoteAddr();
}
return ip;
}
}示例
@RestController
public class LimiterController {
private static final AtomicInteger ATOMIC_INTEGER = new AtomicInteger();
@Limit(key = "test", period = 100, count = 10)
@GetMapping("/test")
public int testLimiter() {
// 意味著 100S 内最多允許訪問10次
return ATOMIC_INTEGER.incrementAndGet();
}
}前端
Ajax跨域
方案一
addMapping：配置可以被跨域的路径，可以任意配置，可以具体到直接请求路径。
allowedMethods：允许所有的请求方法访问该跨域资源服务器，如：POST、GET、PUT、DELETE等。
allowedOrigins：允许所有的请求域名访问我们的跨域资源，可以固定单条或者多条内容，如："http://www.baidu.com"，只有百度可以访问我们的跨域资源。
allowedHeaders：允许所有的请求header访问，可以自定义设置任意请求头信息，如："X-YAUTH-TOKEN"
@Configuration
public class CorsConfig extends WebMvcConfigurerAdapter {
static final String ORIGINS[] = new String[] { "GET", "POST", "PUT", "DELETE" };
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**").allowedOrigins("*").allowCredentials(true).allowedMethods(ORIGINS)
.maxAge(3600);
}
}
2、HTTP请求接口
@RestController
public class HelloController {
@Autowired
HelloService helloService;
@GetMapping(value = "/test", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
public String query() {
return "hello";
}
}方案二
public class ManagementApplication {
private CorsConfiguration buildConfig() {
CorsConfiguration corsConfiguration = new CorsConfiguration();
corsConfiguration.addAllowedOrigin("*");
corsConfiguration.addAllowedHeader("*");
corsConfiguration.addAllowedMethod("*");
//corsConfiguration.addExposedHeader(HttpHeaderConStant.X_TOTAL_COUNT);
return corsConfiguration;
}
/**
* 跨域过滤器
*
* @return
*/
@Bean
public CorsFilter corsFilter() {
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
source.registerCorsConfiguration("/**", buildConfig());
return new CorsFilter(source);
}
}
跨域的html
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>跨域请求</title>
<script src="https://cdn.bootcss.com/jquery/1.10.2/jquery.min.js">
</script>
<script>
$(document).ready(function(){
$("button").click(function(){
$.ajax({url:"http://localhost:8080/test",success:function(result){
$("#p1").html(result);
}});
});
});
</script>
</head>
<body>
<p width="500px" height="100px" id="p1"></p>
<button>获取其他内容</button>
</body>
</html>跨域的Filter
@Component
public class OriginFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest req, ServletResponse res,
FilterChain chain) throws IOException, ServletException {
HttpServletResponse response = (HttpServletResponse) res;
response.setHeader("Access-Control-Allow-Origin", "*");
response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE,PUT");
response.setHeader("Access-Control-Max-Age", "3600");
response.setHeader("Access-Control-Allow-Headers", "x-requested-with");
chain.doFilter(req, res);
}
@Override
public void destroy() {
// TODO Auto-generated method stub
}
}Nginx跨域
其中：add_header 'Access-Control-Expose-Headers' 务必加上你请求时所带的header。例如本例中的“Token”，其实是前端传给后端过来的。如果记不得也没有关系，浏览器的调试器会有详细说明。
location / {
proxy_pass http://localhost:8080;
if ($request_method = 'OPTIONS') {
add_header 'Access-Control-Allow-Origin' '*';
add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS';
add_header 'Access-Control-Allow-Headers' 'DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Content-Range,Range,Token';
add_header 'Access-Control-Max-Age' 1728000;
add_header 'Content-Type' 'text/plain; charset=utf-8';
add_header 'Content-Length' 0;
return 204;
}
if ($request_method = 'POST') {
add_header 'Access-Control-Allow-Origin' '*';
add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS';
add_header 'Access-Control-Allow-Headers' 'DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Content-Range,Range,Token';
add_header 'Access-Control-Expose-Headers' 'DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Content-Range,Range,Token';
}
if ($request_method = 'GET') {
add_header 'Access-Control-Allow-Origin' '*';
add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS';
add_header 'Access-Control-Allow-Headers' 'DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Content-Range,Range,Token';
add_header 'Access-Control-Expose-Headers' 'DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Content-Range,Range,Token';
}
}其他
JavaMail
JavaMail是SUN提供给广大Java开发人员的一款邮件发送和接受的一款开源类库，支持常用的邮件协议，如：SMTP、POP3、IMAP，开发人员使用JavaMail编写邮件程序时，不再需要考虑底层的通讯细节如：Socket而是关注在逻辑层面。JavaMail可以发送各种复杂MIME格式的邮件内容，注意JavaMail仅支持JDK4及以上版本。虽然JavaMail是JDK的API但它并没有直接加入JDK中，所以我们需要另外添加依赖。
引入依赖
<dependency>
<groupId>javax.mail</groupId>
<artifactId>mail</artifactId>
<version>1.4.7</version>
</dependency>属性配置
mail_zh_CN.properties
配置的邮箱需要开通POP3/SMTP服务。
mail.smtp.service=smtp.qq.com
mail.smtp.prot=587
[email protected]
mail.from.smtp.pwd=myihkkyvtxegbahg
mail.from.nickname=admin数据Model
public class MailEntity implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
// 此处填写SMTP服务器
private String smtpService;
// 设置端口号
private String smtpPort;
// 设置发送邮箱
private String fromMailAddress;
// 设置发送邮箱的STMP口令
private String fromMailStmpPwd;
// 设置邮件标题
private String title;
// 设置邮件内容
private String content;
// 内容格式（默认采用html）
private String contentType;
// 接受邮件地址集合
private List<String> list = new ArrayList<>();
// get set .....
}public enum MailContentTypeEnum {
HTML("text/html;charset=UTF-8"), //html格式
TEXT("text");
private String value;
MailContentTypeEnum(String value) {
this.value = value;
}
public String getValue() {
return value;
}
}propertiesUtil
public class PropertiesUtil {
private final ResourceBundle resource;
private final String fileName;
/**
* 构造函数实例化部分对象，获取文件资源对象
*
* @param fileName
*/
public PropertiesUtil(String fileName) {
this.fileName = fileName;
Locale locale = new Locale("zh", "CN");
this.resource = ResourceBundle.getBundle(this.fileName, locale);
}
/**
* 根据传入的key获取对象的值
*
* @param key
* properties文件对应的key
* @return String 解析后的对应key的值
*/
public String getValue(String key) {
String message = this.resource.getString(key);
return message;
}
/**
* 获取properties文件内的所有key值<br>
*
* @return
*/
public Enumeration<String> getKeys() {
return resource.getKeys();
}
}
发送邮件
public class MailSender {
// 邮件实体
private static MailEntity mail = new MailEntity();
/**
* 设置邮件标题
*
* @param title
* 标题信息
* @return
*/
public MailSender title(String title) {
mail.setTitle(title);
return this;
}
/**
* 设置邮件内容
*
* @param content
* @return
*/
public MailSender content(String content) {
mail.setContent(content);
return this;
}
/**
* 设置邮件格式
*
* @param typeEnum
* @return
*/
public MailSender contentType(MailContentTypeEnum typeEnum) {
mail.setContentType(typeEnum.getValue());
return this;
}
/**
* 设置请求目标邮件地址
*
* @param targets
* @return
*/
public MailSender targets(List<String> targets) {
mail.setList(targets);
return this;
}
/**
* 执行发送邮件
*
* @throws Exception
* 如果发送失败会抛出异常信息
*/
public void send() throws Exception {
// 默认使用html内容发送
if (mail.getContentType() == null)
mail.setContentType(MailContentTypeEnum.HTML.getValue());
if (mail.getTitle() == null || mail.getTitle().trim().length() == 0) {
throw new Exception("邮件标题没有设置.调用title方法设置");
}
if (mail.getContent() == null || mail.getContent().trim().length() == 0) {
throw new Exception("邮件内容没有设置.调用content方法设置");
}
if (mail.getList().size() == 0) {
throw new Exception("没有接受者邮箱地址.调用targets方法设置");
}
// 读取/resource/mail_zh_CN.properties文件内容
final PropertiesUtil properties = new PropertiesUtil("mail");
// 创建Properties 类用于记录邮箱的一些属性
final Properties props = new Properties();
// 表示SMTP发送邮件，必须进行身份验证
props.put("mail.smtp.auth", "true");
// 此处填写SMTP服务器
props.put("mail.smtp.host", properties.getValue("mail.smtp.service"));
// 设置端口号，QQ邮箱给出了两个端口465/587
props.put("mail.smtp.port", properties.getValue("mail.smtp.prot"));
// 设置发送邮箱
props.put("mail.user", properties.getValue("mail.from.address"));
// 设置发送邮箱的16位STMP口令
props.put("mail.password", properties.getValue("mail.from.smtp.pwd"));
// 构建授权信息，用于进行SMTP进行身份验证
Authenticator authenticator = new Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
// 用户名、密码
String userName = props.getProperty("mail.user");
String password = props.getProperty("mail.password");
return new PasswordAuthentication(userName, password);
}
};
// 使用环境属性和授权信息，创建邮件会话
Session mailSession = Session.getInstance(props, authenticator);
// 创建邮件消息
MimeMessage message = new MimeMessage(mailSession);
// 设置发件人
String nickName = MimeUtility.encodeText(properties.getValue("mail.from.nickname"));
InternetAddress form = new InternetAddress(nickName + " <" + props.getProperty("mail.user") + ">");
message.setFrom(form);
// 设置邮件标题
message.setSubject(mail.getTitle());
// html发送邮件
if (mail.getContentType().equals(MailContentTypeEnum.HTML.getValue())) {
// 设置邮件的内容体
message.setContent(mail.getContent(), mail.getContentType());
}
// 文本发送邮件
else if (mail.getContentType().equals(MailContentTypeEnum.TEXT.getValue())) {
message.setText(mail.getContent());
}
// 发送邮箱地址
List<String> targets = mail.getList();
for (int i = 0; i < targets.size(); i++) {
try {
// 设置收件人的邮箱
InternetAddress to = new InternetAddress(targets.get(i));
message.setRecipient(Message.RecipientType.TO, to);
// 最后当然就是发送邮件啦
Transport.send(message);
} catch (Exception e) {
continue;
}
}
}
}测试
public static void sendMail() throws Exception {
new MailSender().title("测试SpringBoot发送邮件")
.content("简单文本内容发送")
.contentType(MailContentTypeEnum.TEXT)
.targets(new ArrayList<String>() {
{
add("[email protected]");
}
}).send();
}Druid
Druid是一个关系型数据库连接池，它是阿里巴巴的一个开源项目。Druid支持所有JDBC兼容数据库，包括了Oracle、MySQL、PostgreSQL、SQL Server、H2等。
Druid在监控、可扩展性、稳定性和性能方面具有明显的优势。通过Druid提供的监控功能，可以实时观察数据库连接池和SQL查询的工作情况。使用Druid连接池在一定程度上可以提高数据访问效率。
引入依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.0.29</version>
</dependency>添加配置
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8
username: root
password: root
#最大活跃数
maxActive: 20
#初始化数量
initialSize: 1
#最大连接等待超时时间
maxWait: 60000
#打开PSCache，并且指定每个连接PSCache的大小
poolPreparedStatements: true
maxPoolPreparedStatementPerConnectionSize: 20
#通过connectionProperties属性来打开mergeSql功能；慢SQL记录
#connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
minIdle: 1
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 300000
validationQuery: select 1 from dual
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
#配置监控统计拦截的filters，去掉后监控界面sql将无法统计,'wall'用于防火墙
filters: stat, wall, log4j
jpa:
properties:
hibernate:
show_sql: true
format_sql: true开启监控
添加Druid的filter
@Configuration
public class DruidConfiguration {
@Bean
public ServletRegistrationBean startViewServlet() {
// 创建servlet注册实体
ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new StatViewServlet(),
"/druid/*");
// 设置ip白名单
servletRegistrationBean.addInitParameter("allow", "127.0.0.1");
// 设置ip黑名单，如果allow与deny共同存在时,deny优先于allow
servletRegistrationBean.addInitParameter("deny", "192.168.0.19");
// 设置控制台管理用户
servletRegistrationBean.addInitParameter("loginUsername", "druid");
servletRegistrationBean.addInitParameter("loginPassword", "123456");
// 是否可以重置数据
servletRegistrationBean.addInitParameter("resetEnable", "false");
return servletRegistrationBean;
}
@Bean
public FilterRegistrationBean statFilter() {
// 创建过滤器
FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new WebStatFilter());
// 设置过滤器过滤路径
filterRegistrationBean.addUrlPatterns("/*");
// 忽略过滤的形式
filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
return filterRegistrationBean;
}
}多数据源
数据源配置
spring:
datasource:
user:
type: com.alibaba.druid.pool.DruidDataSource
url: jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8
username: root
password: root
driver-class-name: com.mysql.jdbc.Driver
filters: stat
maxActive: 20
initialSize: 1
maxWait: 60000
minIdle: 1
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 300000
validationQuery: select 'x'
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
poolPreparedStatements: true
maxOpenPreparedStatements: 20
book:
type: com.alibaba.druid.pool.DruidDataSource
url: jdbc:mysql://127.0.0.1:3306/books?characterEncoding=utf8
username: root
password: root
driver-class-name: com.mysql.jdbc.Driver
filters: stat
maxActive: 20
initialSize: 1
maxWait: 60000
minIdle: 1
timeBetweenEvictionRunsMillis: 60000
minEvictableIdleTimeMillis: 300000
validationQuery: select 'x'
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
poolPreparedStatements: true
maxOpenPreparedStatements: 20
jpa:
properties:
hibernate:
show_sql: true
format_sql: trueConfiguration
声明数据源
@Configuration
public class DataSourceConfigurer
{
//用户数据源
@Bean(name = "userDataSource")//装配该方法返回值为userDataSource管理bean
@Qualifier("userDataSource")//spring装配bean唯一标识
@ConfigurationProperties(prefix="spring.datasource.user")//application.yml文件内配置数据源的前缀
public DataSource userDataSource(){return DataSourceBuilder.create().build();}
//书籍数据源
@Bean(name = "bookDataSource")
@Primary//配置该数据源为主数据源
@Qualifier("bookDataSource")
@ConfigurationProperties(prefix = "spring.datasource.book")
public DataSource bookDataSource(){return DataSourceBuilder.create().build();}
}@Primary
@Primary配置了数据源为主数据源，当没有配置自动切换的package时默认使用该数据源进行数据处理操作。
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
entityManagerFactoryRef="entityManagerFactoryBook",//实体管理引用
transactionManagerRef="transactionManagerBook",//事务管理引用
basePackages = { "com.yuqiyu.chapter24.book"}) //设置书籍数据源所应用到的包
public class BookDataSourceConfigurer
{
//注入书籍数据源
@Autowired
@Qualifier("bookDataSource")
private DataSource bookDataSource;
//配置EntityManager实体
@Primary
@Bean(name = "entityManagerBook")
public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
return entityManagerFactoryBook(builder).getObject().createEntityManager();
}
//配置EntityManager工厂实体
@Primary
@Bean(name = "entityManagerFactoryBook")
public LocalContainerEntityManagerFactoryBean entityManagerFactoryBook (EntityManagerFactoryBuilder builder) {
return builder
.dataSource(bookDataSource)
.properties(getVendorProperties(bookDataSource))
.packages(new String[]{ "com.yuqiyu.chapter24.book" }) //设置应用creditDataSource的基础包名
.persistenceUnit("bookPersistenceUnit")
.build();
}
//注入jpa配置实体
@Autowired
private JpaProperties jpaProperties;
//获取jpa配置信息
private Map<String, String> getVendorProperties(DataSource dataSource) {
return jpaProperties.getHibernateProperties(dataSource);
}
//配置事务
@Primary
@Bean(name = "transactionManagerBook")
public PlatformTransactionManager transactionManagerBook(EntityManagerFactoryBuilder builder) {
return new JpaTransactionManager(entityManagerFactoryBook(builder).getObject());
}
}@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
entityManagerFactoryRef="entityManagerFactoryUser",//实体管理引用
transactionManagerRef="transactionManagerUser",//失误管理引用
basePackages = { "com.yuqiyu.chapter24.user"}) //设置用户数据源所应用到的包
public class UserDataSourceConfigurer
{
//注入用户数据源
@Autowired
@Qualifier("userDataSource")
private DataSource userDataSource;
//配置EntityManager实体
@Bean(name = "entityManagerUser")
public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
return entityManagerFactoryUser(builder).getObject().createEntityManager();
}
//配置EntityManager工厂实体
@Bean(name = "entityManagerFactoryUser")
public LocalContainerEntityManagerFactoryBean entityManagerFactoryUser (EntityManagerFactoryBuilder builder) {
return builder
.dataSource(userDataSource)
.properties(getVendorProperties(userDataSource))
.packages(new String[]{ "com.yuqiyu.chapter24.user" }) //设置应用creditDataSource的基础包名
.persistenceUnit("userPersistenceUnit")
.build();
}
//注入jpa配置实体
@Autowired
private JpaProperties jpaProperties;
//获取jpa配置信息
private Map<String, String> getVendorProperties(DataSource dataSource) {
return jpaProperties.getHibernateProperties(dataSource);
}
//配置事务
@Bean(name = "transactionManagerUser")
public PlatformTransactionManager transactionManagerUser(EntityManagerFactoryBuilder builder) {
return new JpaTransactionManager(entityManagerFactoryUser(builder).getObject());
}
}事件监听、订阅
ApplicationEvent以及Listener是Spring为我们提供的一个事件监听、订阅的实现，内部实现原理是观察者设计模式，设计初衷也是为了系统业务逻辑之间的解耦，提高可扩展性以及可维护性。事件发布者并不需要考虑谁去监听，监听具体的实现内容是什么，发布者的工作只是为了发布事件而已。
创建事件监听
我们自定义事件UserRegisterEvent继承了ApplicationEvent，继承后必须重载构造函数，构造函数的参数可以任意指定，其中source参数指的是发生事件的对象，一般我们在发布事件时使用的是this关键字代替本类对象，而user参数是我们自定义的注册用户对象，该对象可以在监听内被获取。
public class UserRegisterEvent extends ApplicationEvent
{
//注册用户对象
private UserBean user;
/**
* 重写构造函数
* @param source 发生事件的对象
* @param user 注册用户对象
*/
public UserRegisterEvent(Object source,UserBean user) {
super(source);
this.user = user;
}
// 省略Get方法
}发布时间
在实际的Service中，完成事件的发布
声明上下文
@Autowired
ApplicationContext applicationContext;
发布事件
//发布UserRegisterEvent事件
applicationContext.publishEvent(new UserRegisterEvent(this,user));
监听事件方法一
在我们用户注册监听实现方法上添加@EventListener注解，该注解会根据方法内配置的事件完成监听。
@Component
public class AnnotationRegisterListener {
/**
* 注册监听实现方法
* @param userRegisterEvent 用户注册事件
*/
@EventListener
public void register(UserRegisterEvent userRegisterEvent)
{
//获取注册用户对象
UserBean user = userRegisterEvent.getUser();
//../省略逻辑
//输出注册用户信息
System.out.println("@EventListener注册信息，用户名："+user.getName()+"，密码："+user.getPassword());
}
}监听事件方法二
原生，实现ApplicationListener监听类，泛型是事件逻辑
@Component
public class RegisterListener implements ApplicationListener<UserRegisterEvent>
{
/**
* 实现监听
* @param userRegisterEvent
*/
@Override
public void onApplicationEvent(UserRegisterEvent userRegisterEvent) {
//获取注册用户对象
UserBean user = userRegisterEvent.getUser();
//../省略逻辑
//输出注册用户信息
System.out.println("注册信息，用户名："+user.getName()+"，密码："+user.getPassword());
}
}有序事件监听
事件监听是无序的，监听到的事件先后顺序完全随机出现的。我们接下来使用SmartApplicationListener实现监听方式来实现该逻辑。
SmartApplicationListener接口继承了全局监听ApplicationListener，并且泛型对象使用的ApplicationEvent来作为全局监听，可以理解为使用SmartApplicationListener作为监听父接口的实现，监听所有事件发布。
@Component
public class UserRegisterListener implements SmartApplicationListener
{
/**
* 该方法返回true&supportsSourceType同样返回true时，才会调用该监听内的onApplicationEvent方法
* @param aClass 接收到的监听事件类型
* @return
*/
@Override
public boolean supportsEventType(Class<? extends ApplicationEvent> aClass) {
//只有UserRegisterEvent监听类型才会执行下面逻辑
return aClass == UserRegisterEvent.class;
}
/**
* 该方法返回true&supportsEventType同样返回true时，才会调用该监听内的onApplicationEvent方法
* @param aClass
* @return
*/
@Override
public boolean supportsSourceType(Class<?> aClass) {
//只有在UserService内发布的UserRegisterEvent事件时才会执行下面逻辑
return aClass == UserService.class;
}
/**
* supportsEventType & supportsSourceType 两个方法返回true时调用该方法执行业务逻辑
* @param applicationEvent 具体监听实例，这里是UserRegisterEvent
*/
@Override
public void onApplicationEvent(ApplicationEvent applicationEvent) {
//转换事件类型
UserRegisterEvent userRegisterEvent = (UserRegisterEvent) applicationEvent;
//获取注册用户对象信息
UserBean user = userRegisterEvent.getUser();
//.../完成注册业务逻辑
System.out.println("注册信息，用户名："+user.getName()+"，密码："+user.getPassword());
}
/**
* 同步情况下监听执行的顺序
* @return
*/
@Override
public int getOrder() {
return 0;
}
}通过getOrder来实现有序执行事件。
使用@Async实现异步监听
@Aysnc其实是Spring内的一个组件，可以完成对类内单个或者多个方法实现异步调用，这样可以大大的节省等待耗时。内部实现机制是线程池任务ThreadPoolTaskExecutor，通过线程池来对配置@Async的方法或者类做出执行动作。
线程任务池配置
@Configuration
@EnableAsync
public class ListenerAsyncConfiguration implements AsyncConfigurer
{
/**
* 获取异步线程池执行对象
* @return
*/
@Override
public Executor getAsyncExecutor() {
//使用Spring内置线程池任务对象
ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
//设置线程池参数
taskExecutor.setCorePoolSize(5);
taskExecutor.setMaxPoolSize(10);
taskExecutor.setQueueCapacity(25);
taskExecutor.initialize();
return taskExecutor;
}
@Override
public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
return null;
}
}异步处理
/**
* supportsEventType & supportsSourceType 两个方法返回true时调用该方法执行业务逻辑
* @param applicationEvent 具体监听实例，这里是UserRegisterEvent
*/
@Override
@Async
public void onApplicationEvent(ApplicationEvent applicationEvent) {
try {
Thread.sleep(3000);//静静的沉睡3秒钟
}catch (Exception e)
{
e.printStackTrace();
}
//转换事件类型
UserRegisterEvent userRegisterEvent = (UserRegisterEvent) applicationEvent;
//获取注册用户对象信息
UserBean user = userRegisterEvent.getUser();
System.out.println("用户："+user.getName()+"，注册成功，发送邮件通知。");
}Lombok
引入依赖
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.16.18</version>
</dependency>常用注解
Getter/Setter 作用于属性上，新增getter和setter方法
ToString 自动生成toString方法 会将所有的属性都包含并且调用后可以输出
AllArgsConstructor 全部参数的构造函数的自动生成，该注解的作用域也是只有在实体类上，因为只有实体类才会存在构造函数
NoArgsConstructor 没有参数的构造函数
Data 解就可以涵盖@ToString、@Getter、@Setter方法
Slf4j 在实体类上直接添加@Slf4j就可以自动创建一个日志对象作为类内全局字段 Test
单元测试对于开发人员来说是非常熟悉的，我们每天的工作也都是围绕着开发与测试进行的，在最早的时候测试都是采用工具Debug模式进行调试程序，后来Junit的诞生也让程序测试发生了很大的变化。
引入依赖
<!--springboot程序测试依赖，创建项目默认添加-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>编写Test
@RunWith(SpringRunner.class)
@SpringBootTest
public class Tests {
/**
* 模拟mvc测试对象
*/
private MockMvc mockMvc;
/**
* web项目上下文
*/
@Autowired
private WebApplicationContext webApplicationContext;
/**
* 数据接口
*/
@Autowired
private XxxxxJPA xxxxxJPA;
/**
* 所有测试方法执行之前执行该方法
*/
@Before
public void before() {
//获取mockmvc对象实例
mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
}
/**
* 测试访问/index地址
* @throws Exception
*/
@Test
public void testIndex() throws Exception {
MvcResult mvcResult = mockMvc
.perform(// 1
MockMvcRequestBuilders.get("/index") // 2
.param("name","admin") // 3
)
.andReturn();// 4
int status = mvcResult.getResponse().getStatus(); // 5
String responseString = mvcResult.getResponse().getContentAsString(); // 6
Assert.assertEquals("请求错误", 200, status); // 7
Assert.assertEquals("返回结果不一致", "this is index pageadmin", responseString); // 8
}
}MockMvc解析：
我在上面代码中进行了标记，我们按照标记进行讲解，这样会更明白一些：
1 perform方法其实只是为了构建一个请求，并且返回ResultActions实例，该实例则是可以获取到请求的返回内容。
2 MockMvcRequestBuilders该抽象类则是可以构建多种请求方式，如：Post、Get、Put、Delete等常用的请求方式，其中参数则是我们需要请求的本项目的相对路径，/则是项目请求的根路径。
3 param方法用于在发送请求时携带参数，当然除了该方法还有很多其他的方法，大家可以根据实际请求情况选择调用。
4 andReturn方法则是在发送请求后需要获取放回时调用，该方法返回MvcResult对象，该对象可以获取到返回的视图名称、返回的Response状态、获取拦截请求的拦截器集合等。
5 我们在这里就是使用到了第4步内的MvcResult对象实例获取的MockHttpServletResponse对象从而才得到的Status状态码。
6 同样也是使用MvcResult实例获取的MockHttpServletResponse对象从而得到的请求返回的字符串内容。【可以查看rest返回的json数据】
7 使用Junit内部验证类Assert判断返回的状态码是否正常为200
8 判断返回的字符串是否与我们预计的一样。
ContiPerf
ContiPerf是一个轻量级的测试工具，基于JUnit 4 开发，可用于效率测试等
引入依赖
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.7</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.databene</groupId>
<artifactId>contiperf</artifactId>
<version>2.1.0</version>
<scope>test</scope>
</dependency>示例
@PerfTest(invocations = 1000, threads = 40)
@Required(max = 1200, average = 250, totalTime = 60000)
public class ContiPerfTest {
@Rule
public ContiPerfRule i = new ContiPerfRule();
@Test
public void test1() throws Exception {
Thread.sleep(200);
}
}@Rule注释激活ContiPerf，
@Test指定测试方法，
@PerfTest指定调用次数和线程数量，
@Required指定性能要求（每次执行的最长时间，平均时间，总时间等）。
也可以通过对类指定@PerfTest和@Required，表示类中方法的默认设置
主要参数介绍
1）PerfTest参数
@PerfTest(invocations = 300)：执行300次，和线程数量无关，默认值为1，表示执行1次；
@PerfTest(threads=30)：并发执行30个线程，默认值为1个线程；
@PerfTest(duration = 20000)：重复地执行测试至少执行20s。
2）Required参数
@Required(throughput = 20)：要求每秒至少执行20个测试；
@Required(average = 50)：要求平均执行时间不超过50ms；
@Required(median = 45)：要求所有执行的50%不超过45ms；
@Required(max = 2000)：要求没有测试超过2s；
@Required(totalTime = 5000)：要求总的执行时间不超过5s；
@Required(percentile90 = 3000)：要求90%的测试不超过3s；
@Required(percentile95 = 5000)：要求95%的测试不超过5s；
@Required(percentile99 = 10000)：要求99%的测试不超过10s;
@Required(percentiles = "66:200,96:500")：要求66%的测试不超过200ms，96%的测试不超过500ms。