马克社区,马克吐温社区,马克java社区系统异常了，发个邮件

系统异常了，发个邮件

描述
在我们的项目中，总是有一些我们不可控制的异常，比如数据库连接不上，redis挂掉，以及一些代码上未可知的异常爆发，不能在项目上线时就可以统计出来，并且修复，所以当我们这些bug抛出异常时，或者在某些可控的严重异常需要推送邮件或者短信或者其他的通讯工具比如钉钉或者飞书等，我们就需要这样的功能，这里提供一个邮件通知方法，当有未知异常或者被定义为严重异常的，就会给运维人员发送一个邮件进行通知，方便计时应对和问题定位。

解决方案
在springboot中的全局异常捕获处，对不可控异常拿到异常栈信息，进行异常msg的组装和通过freemarker模板进行渲染html文本，然后再把这个异常msg的html进行qq模式的email的发送

，freemarker模板可以支撑字符串模板渲染，即渲染的模板字符串可以保存到数据库，也可以直接定义好xxx.ftl模板，都行，这里需要强调的是渲染的模板字符串可以保存到数据库

就更加灵活，可以设计一套freemarker模板的管理系统，比如，对自定义的freemarker模板配置后，保存到数据库，然后根据不同的用户或者企业或者业务，就可以从库中获取对应的freemarker模板，进行数据渲染html，再通过短信或者邮件或者钉钉，这样就实现了类似阿里或者腾讯等第三方的模板配置后进行消息推送的功能。

代码
代码组成包含有自定义的模板的工具jar包和邮件的springboot-starter，以及在微服务中对异常的处理，和调用邮件的消息封装以及模板的创建

模板自定springboot-starter

详细代码

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <parent>
 <artifactId>wlc-spring-boot-tools</artifactId>
 <groupId>com.wlc</groupId>
 <version>1.0-SNAPSHOT</version>
 </parent>
 <modelVersion>4.0.0</modelVersion>

 <artifactId>wlc-template</artifactId>
 <version>1.0-SNAPSHOT</version>
 <dependencies>
　　　　<--freemarker依赖 -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-freemarker</artifactId>
 </dependency>
　　　　<--spring-webmvc依赖，这里可以换成spring的ioc包 -->
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-webmvc</artifactId>
 <version>5.3.9</version>
 <scope>compile</scope>
 </dependency>

 </dependencies>

</project>
BeanUtils，处理bean转map
import org.springframework.cglib.beans.BeanMap;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.Map;

/**
* 描述实体工具类 
* 作者：IT学习道场 
* 时间：2018/10/26 13:37
*/
public class BeanUtils extends org.springframework.beans.BeanUtils {
 public BeanUtils() {
 }

 /**
 * 实例化对象：传入类对类进行实例化对象
 *
 * @param clazz 类
 * @return 对象
 * @author Lius
 * @date 2018/10/26 13:49
 */
 public static <T> T newInstance(Class<?> clazz) {
 return (T) instantiateClass(clazz);
 }

 /**
 * 实例化对象，传入类名对该类进行实例化对象
 *
 * @param clazzStr 类名,传入是必须传入全路径，com...
 * @return 对象
 * @author Lius
 * @date 2018/10/26 13:54
 */
 public static <T> T newInstance(String clazzStr) {
 try {
 Class<?> clazz = Class.forName(clazzStr);
 return newInstance(clazz);
 } catch (ClassNotFoundException e) {
 throw new RuntimeException();
 }
 }

 /**
 * 把对象封装成Map形式
 *
 * @param src 需要封装的实体对象
 * @author Lius
 * @date 2018/10/26 14:08
 */
 public static Map toMap(Object src) {
 return BeanMap.create(src);
 }

 /**
 * 把Map转换成bean对象
 *
 * @author Lius
 * @date 2018/10/26 14:09
 */
 public static <T> T toBean(Map<String, Object> beanMap, Class<T> valueType) {
 // 对象实例化
 T bean = BeanUtils.newInstance(valueType);
 PropertyDescriptor[] propertyDescriptors = getPropertyDescriptors(valueType);
 for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
 String properName = propertyDescriptor.getName();
 // 过滤class属性
 if ("class".equals(properName)) {
 continue;
 }
 if (beanMap.containsKey(properName)) {
 Method writeMethod = propertyDescriptor.getWriteMethod();
 if (null == writeMethod) {
 continue;
 }
 Object value = beanMap.get(properName);
 if (!writeMethod.isAccessible()) {
 writeMethod.setAccessible(true);
 }
 try {
 writeMethod.invoke(bean, value);
 } catch (Throwable throwable) {
 throw new RuntimeException("Could not set property '" + properName + " ' to bean" + throwable);
 }
 }
 }
 return bean;
 }
}
FreemarkerUtil，来处理模板的封装
import com.wlc.template.util.BeanUtils;
import freemarker.cache.StringTemplateLoader;
import freemarker.template.Configuration;
import freemarker.template.Template;
import freemarker.template.TemplateException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.ui.freemarker.FreeMarkerTemplateUtils;
import org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer;

import java.io.IOException;
import java.util.Map;

/**
* 描述: FreemarkerUtil辅助类 
* 时间: 2022-07-01 9:44 
* 作者：IT学习道场
*/
@Component
public class FreemarkerUtil {
 @Autowired
 private FreeMarkerConfigurer freeMarkerConfigurer;

 /**
 * bean转map
 * @param bean 转换bean
 * @return Map<String, Object> - map对象
 */
 public Map<String, Object> beanToMap(Object bean){
 Map<String, Object> map = BeanUtils.toMap(bean);
 return map;
 }

 /**
 * 根据模板路径获取模板渲染数据
 * @param templatePath 模板路径，ex：templatePath = "notice.ftl"，意思是 resources/templates/下的notice.ftl文件
 * @param data 渲染数据对象
 * @return String- 渲染后的html文本
 */
 public String freeMarkerRenderHtml(String templatePath, Map<String, Object> data ){
 //获取模板信息
 Template template = null;
 String html= "";
 try {
 template = freeMarkerConfigurer.getConfiguration().getTemplate(templatePath);
 html = FreeMarkerTemplateUtils.processTemplateIntoString(template, data);
 } catch (IOException e) {
 e.printStackTrace();
 } catch (TemplateException e) {
 e.printStackTrace();
 }
 return html;

 }

 /**
 * 字符文本渲染成html文本
 * @param templateName 模板名
 * @param templateText 模板文本
 * @param data 渲染数据map
 * @return String - 渲染后的html文本
 */
 public String textRenderFreemarkerHtml(String templateName, String templateText, Map<String, Object> data){
 String html = textRenderFreemarkerHtml(templateName, templateText, "utf-8", data);
 return html;
 }

 /**
 * 字符文本渲染成html文本
 * @param templateName 模板名
 * @param templateText 模板文本
 * @param charEncode 模板编码
 * @param data 渲染数据map
 * @return String - 渲染后的html文本
 */
 public String textRenderFreemarkerHtml(String templateName, String templateText, String charEncode, Map<String, Object> data){
 Template template = textToFreemarkerTemplate(templateName, templateText, charEncode);
 String html = freemarkerTemplateRenderHtml(template, data);
 return html;
 }

 /**
 * 根据模板对象和数据map渲染html文本
 * @param template 模板对象
 * @param data 渲染数据map
 * @return String - html文本
 */
 public String freemarkerTemplateRenderHtml(Template template, Map<String, Object> data){
 String html = "";
 try {
 //渲染data数据到模板中
 html = FreeMarkerTemplateUtils.processTemplateIntoString(template, data);
 } catch (IOException e) {
 e.printStackTrace();
 } catch (TemplateException e) {
 e.printStackTrace();
 }
 return html;
 }

 /**
 * 文本转freemarker模板
 * @param templateName 模板名字
 * @param templateText 模板文本
 * @param charEncode 模板编码
 * @return Template- 返回freemarkerTemplate对象
 */
 public Template textToFreemarkerTemplate(String templateName, String templateText, String charEncode){
 //获取配置文件
 Configuration cfg = freeMarkerConfigurer.getConfiguration();
 //创建freeMarker字符串模板加载器
 StringTemplateLoader stringLoader = new StringTemplateLoader();
 //加载模板名字和模板文本
 stringLoader.putTemplate(templateName, templateText);
 //配置文件设置模板加载器
 cfg.setTemplateLoader(stringLoader);
 freemarker.template.Template template = null;
 try {
 //从配置文件中获取模板对象
 template = cfg.getTemplate(templateName, charEncode);

 } catch (IOException e) {
 e.printStackTrace();
 }
 return template;
 }

}
这样，模板的渲染jar就封装好了

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <parent>
 <artifactId>wlc-spring-boot-tools</artifactId>
 <groupId>com.wlc</groupId>
 <version>1.0-SNAPSHOT</version>
 </parent>
 <modelVersion>4.0.0</modelVersion>

 <artifactId>wlc-email-spring-boot-starter</artifactId>
 <version>1.0-SNAPSHOT</version>
 <dependencies>
 
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-mail</artifactId>
 </dependency>
 
 <dependency>
 <groupId>com.wlc</groupId>
 <artifactId>wlc-template</artifactId>
 <version>1.0-SNAPSHOT</version>
 </dependency>
 </dependencies>

</project>
EmailUtil-> 邮件发送工具类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.mail.MailProperties;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;

import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;
import java.util.Date;

/**
* 描述: email辅助类 
* 时间: 2022-07-01 10:20 
* 作者：IT学习道场
*/
public class EmailUtil {

 @Autowired
 private JavaMailSender javaMailSender;

 @Autowired
 private MailProperties mailProperties;

 /**
 * 发送普通邮件
 * @param subject 主题
 * @param simpleText 内容
 * @param toEamils 邮件接受邮箱数组
 */
 public void simpleEmailSend(String subject, String simpleText, String... toEamils) {
 SimpleMailMessage message = new SimpleMailMessage();
 message.setSentDate(new Date());
 message.setFrom(mailProperties.getUsername());
 message.setTo(toEamils);
 message.setSubject(subject);
 message.setText(simpleText);
 //发送邮件
 javaMailSender.send(message);
 }

 /**
 * 发送html邮件
 * @param subject 发送主题
 * @param html 发送的html
 * @param toEamils 邮件接收人数组
 */
 public void emailSendHtml(String subject, String html, String... toEamils) {
 MimeMessage mimeMessage = javaMailSender.createMimeMessage();
 MimeMessageHelper message = null;
 try {
 message = new MimeMessageHelper(mimeMessage, true);
 message.setSentDate(new Date());
 message.setFrom(mailProperties.getUsername());
 message.setTo(toEamils);
 message.setSubject(subject);
 message.setText(html, true);
 //发送邮件
 javaMailSender.send(mimeMessage);
 } catch (MessagingException e) {
 e.printStackTrace();
 }
 }
}

EmailService -> email服务类的辅助类
import com.wlc.email.util.EmailUtil;
import com.wlc.template.freemarker.FreemarkerUtil;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.Map;

/**
* 描述: email服务类 
* 时间: 2022-07-01 10:33 
* 作者：IT学习道场
*/
public class EmailService {

 @Autowired
 private EmailUtil emailUtil;
 @Autowired
 private FreemarkerUtil freemarkerUtil;

 /**
 * 根据模板路径给邮件发送html模板
 * @param subject 邮件主题
 * @param templatePath html模板路径
 * @param data 渲染html模板里的数据map
 * @param toEamils 邮件接受者数组
 */
 public void emailSendHtmlByTemplatePath(String subject, String templatePath, Map<String, Object> data, String... toEamils) {
 String html = freemarkerUtil.freeMarkerRenderHtml(templatePath, data);
 emailUtil.emailSendHtml(subject, html, toEamils);
 }

 /**
 * 根据字符模板文本给邮件发送html模板
 * @param subject 邮件主题
 * @param templateName html模板名字
 * @param templateText html模板text文本（就是html的模板字符串，使用html模板易字符串的形式保存到数据库，
 * 然后从数据库中读取模板字符串，在转换成模板对象，把data进行渲染成html，来发送邮件）
 * @param data 渲染html模板里的数据map
 * @param toEamils 邮件接受者数组
 */
 public void emailSendHtmlByTemplateText(String subject, String templateName, String templateText, Map<String, Object> data, String... toEamils) {
 String html = freemarkerUtil.textRenderFreemarkerHtml(templateName, templateText, data);
 emailUtil.emailSendHtml(subject, html, toEamils);
 }

 /**
 * 根据字符模板文本给邮件发送html模板
 * @param subject 邮件主题
 * @param templateName html模板名字
 * @param templateText html模板text文本（就是html的模板字符串，使用html模板易字符串的形式保存到数据库，
 * 然后从数据库中读取模板字符串，在转换成模板对象，把data进行渲染成html，来发送邮件）
 * @param data 渲染html模板里的数据map
 * @param charEncode 编码格式 ex: "utf-8"
 * @param toEamils 邮件接受者数组
 */
 public void emailSendHtmlByTemplateText(String subject, String templateName, String templateText, String charEncode, Map<String, Object> data, String... toEamils) {
 String html = freemarkerUtil.textRenderFreemarkerHtml(templateName, templateText, charEncode, data);
 emailUtil.emailSendHtml(subject, html, toEamils);
 }

}
EmailAutoConfiguration --> 自定义邮件自动化配置类
import com.wlc.email.service.EmailService;
import com.wlc.email.util.EmailUtil;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
* 描述: 自定义邮件自动化配置类 
* 时间: 2022-07-01 11:00 
* 作者：IT学习道场
*/
@Configuration
public class EmailAutoConfiguration {

 @Bean
 public EmailService emailService(){
 EmailService emailService = new EmailService();
 return emailService;
 }

 @Bean
 EmailUtil emailUtil(){
 EmailUtil emailUtil = new EmailUtil();
 return emailUtil;
 }
}
resources/META-INF下的spring.factories文件

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.wlc.email.config.EmailAutoConfiguration
这样一个邮件的自定义springboot-starter就封装好了

下面就是在各个微服务中的全局异常捕获中进行msg的freemarker的组装和邮件的发送

演示的服务代码，全局异常处理

ftl代码，有类似需求可以copy

<!DOCTYPE html>
<html lang="en">
<head>
 <meta charset="UTF-8"></meta>
 <title>邮件内容</title>
</head>
<body>
 <img width="400px" height="200px" src="https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fimgsa.baidu.com%2Fexp%2Fw%3D500%2Fsign%3Da5c70c27a1efce1bea2bc8ca9f50f3e8%2Fa9d3fd1f4134970a05665ffe93cad1c8a6865dcd.jpg&refer=http%3A%2F%2Fimgsa.baidu.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=auto?sec=1659171243&t=17d3f0b344e9cb402e8ec4311207fa5a">
 <h4>系统管理员</h4>
 <h4> 您好！</h4>
 系统异常了！日志如下：
 服务名：${appName}
 服务ip：${ipAddr}
 类路径：${className}
 方法名字：${methodName}
 异常发生行号：${lineNumber}
 ${content}
 IT学习道场系统
</body>
</html>

EmailExtendContent -> email的异常邮件信息组装类,这里是给邮件哪个模板里需要的数据组装

import com.utils.IPUtil;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.servlet.http.HttpServletRequest;

/**
* 描述: email的异常邮件信息组装类 
* 时间: 2022-06-30 17:03 
* 作者：IT学习道场
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class EmailExtendContent {
 //异常
 public Exception e;
 //请求request
 public HttpServletRequest request;
 //ip地址
 public String ipAddr;
 //类命
 public String className;
 //方法名
 public String methodName;
 //发生异常的行号
 public int lineNumber;

 public EmailExtendContent(Exception e, HttpServletRequest request) {
 this.e = e;
 this.request = request;
 handler();

 }

 void handler(){
 StackTraceElement stackTraceElement = e.getStackTrace()[0];
 // 获取类名
 ipAddr = IPUtil.getIpAddr(request);
 className = stackTraceElement.getClassName();
 methodName = stackTraceElement.getMethodName();
 lineNumber = stackTraceElement.getLineNumber();
 }
}
EmailHandler --> 微服务中email处理类定制化处理类
import com.wlc.email.service.EmailService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;

/**
* 描述: email处理类 
* 时间: 2022-07-01 11:11 
* 作者：IT学习道场
*/
@Component
public class EmailHandler {

 @Autowired
 private EmailService emailService; // 自定义邮件starter里的 EmailService
 @Value("${spring.application.name:no-service}") //服务应用没名字
 private String appName;
 @Value("#{'${spring.mail.toEamils:}'.split(',')}") //邮件接收者的邮箱数组
 private String[] toEamils;

 /**
 * 异步发送邮件
 * @param stackExceptionMsg 栈异常信息 str
 * @param e 异常对象
 * @param request request
 */
 @Async
 public void sendExceptionEmail(String stackExceptionMsg,Exception e, HttpServletRequest request){
 //根据异常对象和request组装EmailExtendContent
 EmailExtendContent emailExtendContent = new EmailExtendContent(e, request);
 //组装渲染数据data
 Map<String, Object> data = builderData(appName, emailExtendContent, stackExceptionMsg);
 //发送邮件
 emailService.emailSendHtmlByTemplatePath("美术传媒系统异常报告", "notice.ftl", data, toEamils);
 }

 private Map builderData(String appName, EmailExtendContent extendContent, String content){
 Map<String, Object> data = new HashMap<>();
 data.put("appName", appName);
 data.put("ipAddr", extendContent.ipAddr);
 data.put("className", extendContent.className);
 data.put("methodName", extendContent.methodName);
 data.put("lineNumber", extendContent.lineNumber);
 data.put("content", content);
 return data;
 }
}

然后就可以在全局异常里调用一下 EmailHandler.sendExceptionEmail即可

import cn.hutool.core.exceptions.ExceptionUtil;
import com.email.EmailHandler;
import com.http.constant.HttpCode;
import com.http.exception.BusinessException;
import com.utils.JsonUtil;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.validation.BindException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
import javax.servlet.http.HttpServletRequest;

/**
* 全局结果响应处理，全局异常处理 
* 作者：IT学习道场 
* 时间：2019-01-24 10:33
*/
@Slf4j
@RestControllerAdvice
public class ResultAdvice implements ResponseBodyAdvice<Object> {

 @Autowired
 private EmailHandler emailHandler;

 @Override
 public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) {
 return true;
 }
 /**
 * 先捕获异常然后再把数据返回到ResponseBody中，
 * 然后在Body中要返回数据的时候调用上面的拦截方法beforeBodyWrite()
 */
 @ExceptionHandler(value = Exception.class)
 public Object handleException(Object o, Exception e, HttpServletRequest request) {
 //此处返回json数据
 //捕捉到的异常如果是自定义异常类，那么就返回自定义异常类中的错误码和错误信息
 String stackExceptionMsg = ExceptionUtil.stacktraceToString(e);
 //异常输出到日志
 log.error(stackExceptionMsg);
 //自定义基础异常
 if (e instanceof BusinessException) {
 return new ResultException(((BusinessException) e).getCode(), false, ((BusinessException) e).getMessage(), request.getRequestURL().toString());
 //非法参数异常
 } else if (e instanceof IllegalArgumentException) {
 return new ResultException(HttpCode.BAD_REQUEST.code, false, "参数异常,请稍候再试", request.getRequestURL().toString());
 //绑定异常
 } else if (e instanceof BindException) {
 return new ResultException(HttpCode.BAD_REQUEST.code, false, ((BindException) e).getBindingResult().getFieldError().getDefaultMessage(), request.getRequestURL().toString());
 //方法参数异常验证异常
 } else if (e instanceof MethodArgumentNotValidException) {
 return new ResultException(HttpCode.BAD_REQUEST.code, false, ((MethodArgumentNotValidException) e).getBindingResult().getFieldError().getDefaultMessage(), request.getRequestURL().toString());
 }

 //这里是除了自定义异常的其他异常信息
 else {
　　　　　　 // 这里是未知不可控异常，发送异常邮件即可
 emailHandler.sendExceptionEmail(stackExceptionMsg, e, request);
 return new ResultException(HttpCode.SERVER_ERROR.code, false, "系统异常请联系管理员", request.getRequestURL().toString());
 }
 }
}

下面是

application.yml的邮件配置

erver:
port: 8080
#启用undertow
undertow:
 # CPU有几核，就填写几。
 io-threads: 4
 #阻塞任务线程池, 当执行类似servlet请求阻塞IO操作, undertow会从这个线程池中取得线程
 # 它的值设置取决于系统线程执行任务的阻塞系数，默认值是IO线程数*8
 worker-threads: 32
 # 以下的配置会影响buffer,这些buffer会用于服务器连接的IO操作,有点类似netty的池化内存管理
 # 每块buffer的空间大小,越小的空间被利用越充分，不要设置太大，以免影响其他应用，合适即可
 buffer-size: 1024
 # 是否分配的直接内存(NIO直接分配的堆外内存)
 direct-buffers: true
servlet:
 context-path: /

spring:
application:
 name: wlc
redis:
 host: localhost
 port: 6379
 password:
 lettuce:
 pool:
 # 连接池中的最大空闲连接默认8
 max-idle: 8
 # 连接池中的最小空闲连接默认0
 min-idle: 0
 # 连接池最大连接数默认8 ，负数表示没有限制
 max-active: 8
 # 连接池最大阻塞等待时间（使用负值表示没有限制）默认-1
 max-wait: -1

#, 1603610130@qq.com
mail:
 host: smtp.qq.com
　　#你开通smtp的邮箱地址
 username: xxxxx@qq.com
　　#你的邮箱开通smtp时的授权码
 password: xxxxxxxxxx
 port: 465
 toEamils: xxxx@qq.com,yyyy@qq.com
 properties:
 mail:
 smtp:
 auth: true
 ssl:
 enable: true
 starttls:
 enable: true
 required: true
验证，已通知找个接口，搞个异常测试，我的是 int i= 1/0，简单测试

到此结束，觉得有用就关注下，全是原创干货，你可以看下我的合集，希望能对你有所帮助

作者：IT学习道场

欢迎关注微信公众号： IT学习道场