springboot aop配合反射统一签名验证实践
目录
- aop配合反射统一签名验证
- 接口统一签名校验
- 第一种aop 方式实现
- 第二种拦截器
aop配合反射统一签名验证
直接上代码，作为记录。
CheckSignAspect.java
@Aspect //定义一个切面
@Configuration
@Log4j2
public class CheckSignAspect {
// 定义切点Pointcut
@Pointcut("execution(* com.lsj.xxl.controller.*.*CheckSign(..))")
public void excudeService() {
}
@Around("excudeService()")
public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
String class_name = pjp.getTarget().getClass().getName();
String method_name = pjp.getSignature().getName();
String[] paramNames = getFieldsName(class_name, method_name);
Object[] method_args = pjp.getArgs();
SortedMap<String, String> map = logParam(paramNames, method_args);
if (map != null) {
String sign = map.get("sign").toUpperCase();
map.remove("sign");
String realSign = SignUtil.createSign("utf8", map);
if (!realSign.equals(sign)) {
return "签名校验错误";
}
}
Object result = pjp.proceed();
return result;
}
/**
* 使用javassist来获取方法参数名称
*
* @param class_name 类名
* @param method_name 方法名
* @return
* @throws Exception
*/
private String[] getFieldsName(String class_name, String method_name) throws Exception {
Class<?> clazz = Class.forName(class_name);
String clazz_name = clazz.getName();
ClassPool pool = ClassPool.getDefault();
ClassClassPath classPath = new ClassClassPath(clazz);
pool.insertClassPath(classPath);
CtClass ctClass = pool.get(clazz_name);
CtMethod ctMethod = ctClass.getDeclaredMethod(method_name);
MethodInfo methodInfo = ctMethod.getMethodInfo();
CodeAttribute codeAttribute = methodInfo.getCodeAttribute();
LocalVariableAttribute attr = (LocalVariableAttribute) codeAttribute.getAttribute(LocalVariableAttribute.tag);
if (attr == null) {
return null;
}
String[] paramsArgsName = new String[ctMethod.getParameterTypes().length];
int pos = Modifier.isStatic(ctMethod.getModifiers()) ? 0 : 1;
for (int i = 0; i < paramsArgsName.length; i++) {
paramsArgsName[i] = attr.variableName(i + pos);
}
return paramsArgsName;
}
/**
* 打印方法参数值 基本类型直接打印，非基本类型需要重写toString方法
*
* @param paramsArgsName 方法参数名数组
* @param paramsArgsValue 方法参数值数组
*/
private SortedMap<String, String> logParam(String[] paramsArgsName, Object[] paramsArgsValue) {
Map<String, String> map = new HashMap();
if (ArrayUtils.isEmpty(paramsArgsName) || ArrayUtils.isEmpty(paramsArgsValue)) {
log.info("该方法没有参数");
return null;
}
// StringBuffer buffer = new StringBuffer();
for (int i = 0; i < paramsArgsName.length; i++) {
//参数名
String name = paramsArgsName[i];
//参数值
Object value = paramsArgsValue[i];
// if ("sign".equals(name)){
// continue;
// }
if (isPrimite(value.getClass())) {
map.put(name, String.valueOf(value));
} else {
map.put(name, value.toString());
}
}
return new TreeMap<>(map);
}
/**
* 判断是否为基本类型：包括String
*
* @param clazz clazz
* @return true：是; false：不是
*/
private boolean isPrimite(Class<?> clazz) {
if (clazz.isPrimitive() || clazz == String.class) {
return true;
} else {
return false;
}
}
}
SignUtil.java
public class SignUtil {
public static String createSign(String characterEncoding, SortedMap<String, String> parameters) {
StringBuffer sb = new StringBuffer();
for (Map.Entry<String, String> entry : parameters.entrySet()) {
if (!Strings.isNullOrEmpty(entry.getValue()) && !"sign".equals(entry.getKey()) && !"key".equals(entry.getKey())) {
sb.append(entry.getKey() + "=" + entry.getValue() + "&");
}
}
String s = sb.toString();
if (s.length() > 0) {
s = s.substring(0, sb.toString().length() - 1);
}
System.out.println("待加密字符串:" + s);
String sign = MD5Util.MD5Encode(s, characterEncoding).toUpperCase();
return sign;
}
}
测试
@PostMapping("test1")
public String bbCheckSign( @RequestParam("value") String value,
@RequestParam("bb")String bb,
@RequestParam("sign")String sign){
return "ok";
}
补充：
上述方式也可换为注解实现，具体修改代码如下：
添加注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME )
public @interface CheckSign {
}
改变切点
@Pointcut("@annotation(com.lsj.xxl.annotation.CheckSign)")
接口统一签名校验
实现接口请求签名校验，时间戳判断，响应数据返回签名等内容。
这个签名校验，和返回签名可以用多种方法实现。
第一种aop 方式实现
自定义注解体
/**
* @author xxx
*/
@Retention(value = RetentionPolicy.RUNTIME)
public @interface SignatureValidation {
}
aop实现
/**
* @author xxx
*/
@Aspect
@Component
public class SignatureValidation {
/**
* 时间戳请求最小限制(600s)
* 设置的越小，安全系数越高，但是要注意一定的容错性
*/
private static final long MAX_REQUEST = 10 * 60 * 1000L;
/**
* 秘钥
*/
private static final String SECRET= "test";
/**
* 验签切点(完整的找到设置的文件地址)
*/
@Pointcut("execution(@com.xx.xxx.xxxxx.aop.SignatureValidation * *(..))")
private void verifyUserKey() {
}
/**
* 获取请求数据，并校验签名数据
*/
@Before("verifyUserKey()")
public void doBasicProfiling(JoinPoint point) {
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = Objects.requireNonNull(attributes).getRequest();
String sign = "" ;
String timestamp = "" ;
String version = "";
SortedMap<String,String> sortedMap = new TreeMap<String,String>();
for ( Object obj :point.getArgs()) {
JSONObject jsonObject =JSONUtil.parseObj(obj);
if( !StrUtil.isEmptyIfStr(jsonObject.get("sign"))){
sign=jsonObject.get("sign").toString();
}
if(!StrUtil.isEmptyIfStr(jsonObject.get("timestamp"))){
timestamp=jsonObject.get("timestamp").toString();
sortedMap.put("timestamp", timestamp);
}
if(!StrUtil.isEmptyIfStr(jsonObject.get("version"))){
version=jsonObject.get("version").toString();
sortedMap.put("version", version);
}
if(!StrUtil.isEmptyIfStr(jsonObject.get("data"))){
String dataStr= jsonObject.get("data").toString();
if(!JSONUtil.isJsonObj(dataStr)) {
if(JSONUtil.isJsonArray(dataStr)){
sortedMap.put("data", JSONUtil.parseArray(dataStr).toString());
}
sortedMap.put("data", dataStr);
}
else
{
JSONObject dataJson= JSONUtil.parseObj(dataStr);
@SuppressWarnings("unchecked")
Set<String> keySet = dataJson.keySet();
String key = "";
Object value = null;
// 遍历json数据，添加到SortedMap对象
for (Iterator<String> iterator = keySet.iterator(); iterator.hasNext();) {
key = iterator.next();
value = dataJson.get(key);
String valueStr="";
if(!StrUtil.isEmptyIfStr(value)){
valueStr=value.toString();
}
sortedMap.put(key, valueStr);
}
}
}
}
if (StrUtil.isEmptyIfStr(sign)) {
throw new CustomException(BaseResultInfoEnum.ERROR_MISSING_SIGN_1009.getMsg(),BaseResultInfoEnum.ERROR_MISSING_SIGN_1009.getCode());
}
//新的签名
String newSign = createSign(sortedMap,SECRET);
if (!newSign.equals(sign.toUpperCase())) {
throw new CustomException(BaseResultInfoEnum.ERROR_SIGN_1010.getMsg(),BaseResultInfoEnum.ERROR_SIGN_1010.getCode());
}
}
/**
*
* @param point
* @param responseObject 返回参数
*/
@AfterReturning(pointcut="verifyUserKey()",returning="responseObject")
public void afterReturning(JoinPoint point,Object responseObject) {
HttpServletResponse response=((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
if(responseObject instanceof ResponseModel){
ResponseModel responseModel= (ResponseModel) responseObject;
responseModel.setTimestamp(System.currentTimeMillis());
responseModel.setVersion(0);
String sign= Md5Utils.createSign(Md5Utils.createParameters(responseModel),SECRET);
responseModel.setSign(sign);
}
}
}
md5签名
/**
* @author xxx
*/
public class Md5Utils {
/**
* 生成签名
* @param parameters
* @param key 商户ID
* @return
*/
public static String createSign(SortedMap<String,String> parameters, String key){
StringBuffer sb = new StringBuffer();
Set es = parameters.entrySet();
Iterator it = es.iterator();
while(it.hasNext()) {
Map.Entry entry = (Map.Entry)it.next();
String k = (String)entry.getKey();
Object v = entry.getValue();
if(null != v && !"".equals(v)
&& !"sign".equals(k) && !"key".equals(k)) {
sb.append(k + "=" + v + "&");
}
}
sb.append("key=" + key);
String sign = SecureUtil.md5(sb.toString()).toUpperCase();
return sign;
}
/**
* 签名参数
* @param responseModel 响应数据签名返回给调用者
* @return
*/
public static SortedMap<String,String> createParameters(ResponseModel responseModel){
SortedMap<String,String> sortedMap = new TreeMap<String,String>();
if(responseModel!=null) {
sortedMap.put("timestamp", Convert.toStr(responseModel.getTimestamp()) );
sortedMap.put("version", Convert.toStr(responseModel.getVersion()));
JSONObject json = JSONUtil.parseObj(responseModel, false);
if(responseModel.getData()!=null) {
sortedMap.put("data", json.get("data").toString());
}
}
return sortedMap;
}
}
使用，在控制中的方法上方注解即可
第二种拦截器
这里只做了时间判断，签名校验可以根据需要修改即可实现。
过滤器
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
/**
* @author xx
*/
@WebFilter(urlPatterns = "/*",filterName = "channelFilter")
public class ChannelFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
ServletRequest requestWrapper = null;
if(servletRequest instanceof HttpServletRequest) {
requestWrapper = new RequestWrapper((HttpServletRequest) servletRequest);
}
if(requestWrapper == null) {
filterChain.doFilter(servletRequest, servletResponse);
} else {
filterChain.doFilter(requestWrapper, servletResponse);
}
}
@Override
public void destroy() {
}
}
拦截器配置
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
/**
* @author xxxx
*/
@Configuration
public class InterceptorConfig implements WebMvcConfigurer{
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(getHandlerInterceptor());
}
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedHeaders("Content-Type", "x-requested-with", "X-Custom-Header")
.allowedMethods("PUT", "POST", "GET", "DELETE", "OPTIONS")
.allowedOrigins("*")
.allowCredentials(true);
}
@Bean
public FilterRegistrationBean repeatedlyReadFilter() {
FilterRegistrationBean registration = new FilterRegistrationBean();
ChannelFilter repeatedlyReadFilter = new ChannelFilter();
registration.setFilter(repeatedlyReadFilter);
registration.addUrlPatterns("/*");
return registration;
}
@Bean
public HandlerInterceptor getHandlerInterceptor() {
return new TimestampInterceptor();
}
}
RequestWrapper 请求流重写处理
import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.*;
/**
* @author xxx
*/
public class RequestWrapper extends HttpServletRequestWrapper {
private final String body;
public RequestWrapper(HttpServletRequest request) {
super(request);
StringBuilder stringBuilder = new StringBuilder();
BufferedReader bufferedReader = null;
InputStream inputStream = null;
try {
inputStream = request.getInputStream();
if (inputStream != null) {
bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
char[] charBuffer = new char[128];
int bytesRead = -1;
while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
stringBuilder.append(charBuffer, 0, bytesRead);
}
} else {
stringBuilder.append("");
}
} catch (IOException ex) {
} finally {
if (inputStream != null) {
try {
inputStream.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
if (bufferedReader != null) {
try {
bufferedReader.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
body = stringBuilder.toString();
}
@Override
public ServletInputStream getInputStream() throws IOException {
final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body.getBytes());
ServletInputStream servletInputStream = new ServletInputStream() {
@Override
public boolean isFinished() {
return false;
}
@Override
public boolean isReady() {
return false;
}
@Override
public void setReadListener(ReadListener readListener) {
}
@Override
public int read() throws IOException {
return byteArrayInputStream.read();
}
};
return servletInputStream;
}
@Override
public BufferedReader getReader() throws IOException {
return new BufferedReader(new InputStreamReader(this.getInputStream()));
}
public String getBody() {
return this.body;
}
}
拦截器 这里可以实现请求来的签名处理，这里只处理时间了
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import xxx.xxx.xxx.common.result.BaseResultInfoEnum;
import xxx.xxx.common.core.exception.CustomException;
import org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @author xxx
*/
public class TimestampInterceptor implements HandlerInterceptor {
/**
* 时间戳请求最小限制(600s)
* 设置的越小，安全系数越高，但是要注意一定的容错性
*/
private static final long MAX_REQUEST = 10 * 60 * 1000L;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
if (handler instanceof HandlerMethod) {
HandlerMethod handlerMethod = (HandlerMethod) handler;
if (handlerMethod.getBean() instanceof BasicErrorController) {
return true;
}
// if ("GET".equals(request.getMethod())) {
// return true;
// }
ValidateResponse validateResponse = new ValidateResponse(true, null);
RequestWrapper myRequestWrapper = new RequestWrapper((HttpServletRequest) request);
validateResponse= checkTimestamp(myRequestWrapper.getBody());
if (!validateResponse.isValidate()) {
throw validateResponse.getException();
}
}
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
}
private ValidateResponse checkTimestamp(String requestBody) {
try {
JSONObject jsonObject = JSONUtil.parseObj(requestBody);
String timestamp = "" ;
if(!StrUtil.isEmptyIfStr(jsonObject.get("timestamp"))) {
timestamp=jsonObject.get("timestamp").toString();
}
if (StrUtil.isEmptyIfStr(timestamp)) {
return new ValidateResponse(false, new CustomException(BaseResultInfoEnum.ERROR_MISSING_TIMESTAMP_1007.getMsg(), BaseResultInfoEnum.ERROR_MISSING_TIMESTAMP_1007.getCode()));
}
long now = System.currentTimeMillis();
long time = Long.parseLong(timestamp);
if (now - time > MAX_REQUEST) {
return new ValidateResponse(false, new CustomException(BaseResultInfoEnum.ERROR_TIMESTAMP_TIMEOUT_1008.getMsg(), BaseResultInfoEnum.ERROR_TIMESTAMP_TIMEOUT_1008.getCode()));
}
} catch (Exception e) {
e.printStackTrace();
}
return new ValidateResponse(true, null);
}
/**
* 校验返回对象
*/
private static class ValidateResponse {
private boolean validate;
private CustomException exception;
public ValidateResponse(boolean validate, CustomException exception) {
this.validate = validate;
this.exception = exception;
}
public boolean isValidate() {
return validate;
}
public Exception getException() {
return exception;
}
}
}
返回给前端(或其他平台的)处理类
import comzzzz.xx.common.pojo.PageResponseModel;
import com.zzz.xxxx.common.pojo.ResponseModel;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
/**
* @author sunrh
*/
@ControllerAdvice
public class ResponseBodyTimestamp implements ResponseBodyAdvice {
@Override
public boolean supports(MethodParameter methodParameter, Class aClass) {
return true;
}
@Override
public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
//就是这里处理返回签名数据
if(o instanceof ResponseModel){
ResponseModel responseModel= (ResponseModel) o;
responseModel.setTimestamp(System.currentTimeMillis());
return responseModel;
}
if(o instanceof PageResponseModel){
PageResponseModel responseModel= (PageResponseModel) o;
responseModel.setTimestamp(System.currentTimeMillis());
return responseModel;
}
return o;
}
}
最终实现的效果图
以上为个人经验，希望能给大家一个参考，也希望大家多多支持我们。
赞 (0)
相关推荐
-
SpringBoot接口加密解密统一处理
我们与客户端的接口交互中,为了更高的安全性,我们可能需要对接口加密(请求参数加密,服务端解密).返回信息加密(服务端加密,客户端解密),但是也不是所有的接口都这样,有些接口可能不需要,我们可以使用注解来轻松达到此要求. 将接口参数的加密解密和返回信息的加密解密分开,分别定义注解,利用Controller的ControllerAdvice来拦截所有的请求,在其中判断是否需要加密解密,即可达到要求. 使用方法:使用 DecryptRequest 和 EncryptResponse 注解即可,可以放在
-
SpringBoot自定义注解API数据加密和签名校验
api数据数据签名(MD5,SHA1) 签名枚举类SginEnum.java package com.jx.app.api.framework.annotation.enums; /** * @ClassName: SginEnum * @Description: TODO(这是一个签名枚举类) * @author gangyu * @date 2018年11月20日 下午4:30:44 */ public enum SginEnum { //0不需要签名,1使用MD5数据加密 2 使用SHA数
-
Spring Boot实现通用的接口参数校验
本文介绍基于 Spring Boot 和 JDK8 编写一个 AOP ,结合自定义注解实现通用的接口参数校验. 缘由 目前参数校验常用的方法是在实体类上添加注解,但对于不同的方法,所应用的校验规则也是不一样的,例如有一个 AccountVO 实体: public class AccountVO { private String name; // 姓名 private Integer age; // 年龄 } 假设存在这样一个业务:用户注册时需要填写姓名和年龄,用户登陆时只需要填写姓名就可以了.那
-
springboot aop配合反射统一签名验证实践
目录 aop配合反射统一签名验证 接口统一签名校验 第一种aop 方式实现 第二种拦截器 aop配合反射统一签名验证 直接上代码,作为记录. CheckSignAspect.java @Aspect //定义一个切面 @Configuration @Log4j2 public class CheckSignAspect { // 定义切点Pointcut @Pointcut("execution(* com.lsj.xxl.controller.*.*CheckSign(..))")
-
详解springboot+aop+Lua分布式限流的最佳实践
一.什么是限流?为什么要限流? 不知道大家有没有做过帝都的地铁,就是进地铁站都要排队的那种,为什么要这样摆长龙转圈圈?答案就是为了限流!因为一趟地铁的运力是有限的,一下挤进去太多人会造成站台的拥挤.列车的超载,存在一定的安全隐患.同理,我们的程序也是一样,它处理请求的能力也是有限的,一旦请求多到超出它的处理极限就会崩溃.为了不出现最坏的崩溃情况,只能耽误一下大家进站的时间. 限流是保证系统高可用的重要手段!!! 由于互联网公司的流量巨大,系统上线会做一个流量峰值的评估,尤其是像各种秒杀促销活动,
-
SpringBoot AOP统一处理Web请求日志的示例代码
SpringBoot AOP统一处理Web请求日志 引入依赖: <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 新建过滤器 WebLogAspect.java 使用 @Aspect 注解修饰:说明当前类 是一个切面类. 使用 @Component
-
SpringBoot如何进行对象复制的实践
目录 为什么需要对象复制 对象复制工具类推荐 Orika基本使用 引入依赖 Orika工具类使用文档 TC1,基础实体映射 TC2,实体映射 - 字段转换 TC3,基础集合映射 TC4,集合映射 - 字段映射 TC5,集合与实体映射 TC6,类类型映射 TC7,多重映射 TC8,MyBaits plus分页映射 小结 首先我们看看为什么需要对象复制? 为什么需要对象复制 如上,是我们平时开发中最常见的三层MVC架构模型,编辑操作时Controller层接收到前端传来的DTO对象,在Service
-
SpringBoot实现多数据源的切换实践
目录 前言 工程结构 编码实现 yml文件 主数据源MainDatasourceProperties 其他数据源DynamicDatasourceProperties 数据源配置类DatasourceConfiguration DatasourceChooser DatasourceContext 数据源注解DatasourceScope 数据源切面DynamicDatasourceAspect 使用 前言 我们在进行软件开发的过程中,刚开始的时候因为无法估量系统后期的访问量和并发量,所以一开始
-
阿里nacos+springboot+dubbo2.7.3统一处理异常的两种方式
目录 1.为什么要抛异常? 2.给出解决方案 3.两种抛异常的实例解说 dubbo工程搭建 在网上很多关于dubbo异常统一处理的博文,90%都是抄来抄去.大多都是先上一段dubbo中对于异常的统一处理的原码,然后说一堆的(甚至有12345,五种)不靠谱方案,最后再说“本篇使用的是方案4”,然后再对所谓的方案4写了一段文字,最后还说不清!!! 本篇解决方案不会那么罗里吧嗦也不会贴dubbo源码来凑字数,我就直接从刚结束不久的双11保卫战性能全链路优化中我们的面对10万级别TPS的方案中提取的代码
-
SpringBoot AOP Redis实现延时双删功能实战
目录 一.业务场景 1.此时存在的问题 2.解决方案 3.为何要延时500毫秒? 4.为何要两次删除缓存? 二.代码实践 1.引入Redis和SpringBoot AOP依赖 2.编写自定义aop注解和切面 3.application.yml 4.user_db.sql脚本 5.UserController 6.UserService 三.测试验证 四.代码工程及地址 一.业务场景 在多线程并发情况下,假设有两个数据库修改请求,为保证数据库与redis的数据一致性,修改请求的实现中需要修改数据库
-
使用SpringBoot AOP 记录操作日志、异常日志的过程
平时我们在做项目时经常需要对一些重要功能操作记录日志,方便以后跟踪是谁在操作此功能:我们在操作某些功能时也有可能会发生异常,但是每次发生异常要定位原因我们都要到服务器去查询日志才能找到,而且也不能对发生的异常进行统计,从而改进我们的项目,要是能做个功能专门来记录操作日志和异常日志那就好了, 当然我们肯定有方法来做这件事情,而且也不会很难,我们可以在需要的方法中增加记录日志的代码,和在每个方法中增加记录异常的代码,最终把记录的日志存到数据库中.听起来好像很容易,但是我们做起来会发现,做这项工作很繁
-
springboot配置Jackson返回统一默认值的实现示例
在项目开发中,我们返回的数据或者对象没有的时候一般直接返回的null 有数据时的返回值 { "flag": true, "code": "10000", "msg": "成功!", "data": { "id": 32, "templateType": 1, "templateName": "我的测试模板1"
-
SpringBoot Aop 详解和多种使用场景解析
前言 aop面向切面编程,是编程中一个很重要的思想本篇文章主要介绍的是SpringBoot切面Aop的使用和案例 什么是aop AOP(Aspect OrientedProgramming):面向切面编程,面向切面编程(也叫面向方面编程),是目前软件开发中的一个热点,也是Spring框架中的一个重要内容.利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率. 使用场景 利用AOP可以对我们边缘业务进行隔离,降低无关业务逻辑耦