1. liugh-parent源码研究参考

1.1. 前言

  • 这也是个开源的springboot脚手架项目，这里研究记录一些该框架写的比较好的代码段和功能
  • 脚手架地址

1.2. 功能

1.2.1. 当前用户

  • 这里它用了注解切面进行登录用户的统一注入入口参数，这个做法可以进行参考，不需要在需要使用到登录用户的地方用对象去取了
  1. import com.liugh.annotation.CurrentUser;
  2. import com.liugh.exception.UnauthorizedException;
  3. import com.liugh.entity.User;
  4. import org.springframework.core.MethodParameter;
  5. import org.springframework.web.bind.support.WebDataBinderFactory;
  6. import org.springframework.web.context.request.NativeWebRequest;
  7. import org.springframework.web.context.request.RequestAttributes;
  8. import org.springframework.web.method.support.HandlerMethodArgumentResolver;
  9. import org.springframework.web.method.support.ModelAndViewContainer;
  11. /**
  12.  *  增加方法注入，将含有 @CurrentUser 注解的方法参数注入当前登录用户
  13.  * @author liugh
  14.  * @since 2018-05-03
  15.  */
  16. public class CurrentUserMethodArgumentResolver implements HandlerMethodArgumentResolver {
  17.     @Override
  18.     public boolean supportsParameter(MethodParameter parameter) {
  19.         return parameter.getParameterType().isAssignableFrom(User.class)
  20.                 && parameter.hasParameterAnnotation(CurrentUser.class);
  21.     }
  23.     @Override
  24.     public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
  25.         User user = (User) webRequest.getAttribute("currentUser", RequestAttributes.SCOPE_REQUEST);
  26.         if (user == null) {
  27.             throw new UnauthorizedException("获取用户信息失败");
  28.         }
  29.         return user;
  30.     }
  31. }
  1. /**
  2.  * 身份认证异常
  3.  * @author liugh
  4.  * @since 2018-05-06
  5.  */
  6. public class UnauthorizedException extends RuntimeException {
  7.     public UnauthorizedException(String msg) {
  8.         super(msg);
  9.     }
  11.     public UnauthorizedException() {
  12.         super();
  13.     }
  14. }
  1. /**
  2.  * 在Controller的方法参数中使用此注解，该方法在映射时会注入当前登录的User对象
  3.  * @author : liugh
  4.  * @date : 2018/05/08
  5.  */
  6. @Target(ElementType.PARAMETER)          // 可用在方法的参数上
  7. @Retention(RetentionPolicy.RUNTIME)     // 运行时有效
  8. public @interface CurrentUser {
  9. }
  • 注入解析对象
  1. import org.springframework.context.annotation.Bean;
  2. import org.springframework.context.annotation.Configuration;
  3. import org.springframework.web.method.support.HandlerMethodArgumentResolver;
  4. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  5. import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
  7. import java.util.List;
  9. /**
  10.  * @author liugh
  11.  * @since 2018-05-03
  12.  */
  13. @Configuration
  14. public class WebMvcConfigurer extends WebMvcConfigurerAdapter {
  15.     @Override
  16.     public void addInterceptors(InterceptorRegistry registry) {
  17.         super.addInterceptors(registry);
  18.     }
  20.     @Override
  21.     public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
  22.         argumentResolvers.add(currentUserMethodArgumentResolver());
  23.         super.addArgumentResolvers(argumentResolvers);
  24.     }
  26.     @Bean
  27.     public CurrentUserMethodArgumentResolver currentUserMethodArgumentResolver() {
  28.         return new CurrentUserMethodArgumentResolver();
  29.     }
  30. }

1.2.2. 令牌桶

  • 这是一种限流思路，令牌桶算法请自行百度，这里也不是从零实现，用到了guava中的RateLimiter限流器
  1. import com.google.common.collect.Maps;
  2. import com.google.common.util.concurrent.RateLimiter;
  3. import com.liugh.annotation.AccessLimit;
  4. import com.liugh.base.BusinessException;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.aspectj.lang.ProceedingJoinPoint;
  7. import org.springframework.web.context.request.RequestContextHolder;
  8. import org.springframework.web.context.request.ServletRequestAttributes;
  10. import javax.servlet.http.HttpServletRequest;
  11. import java.lang.reflect.Method;
  12. import java.text.SimpleDateFormat;
  13. import java.util.Date;
  14. import java.util.Map;
  15. import java.util.concurrent.TimeUnit;
  17. /**
  18.  * 限流切面
  19.  * Created by liugh on 2018/10/12.
  20.  */
  21. @Slf4j
  22. public class AccessLimitAspect extends AbstractAspectManager{
  24.     public AccessLimitAspect(AspectApi aspectApi){
  25.         super(aspectApi);
  26.     }
  28.     @Override
  29.     public Object doHandlerAspect(ProceedingJoinPoint pjp, Method method)throws Throwable {
  30.         super.doHandlerAspect(pjp,method);
  31.         execute(pjp,method);
  32.         return null;
  33.     }
  35.     //添加速率.保证是单例的
  36.     private static RateLimiter rateLimiter = RateLimiter.create(1000);
  37.      //使用url做为key,存放令牌桶 防止每次重新创建令牌桶
  38.     private static  Map<String, RateLimiter> limitMap = Maps.newConcurrentMap();
  40.     @Override
  41.     public Object execute(ProceedingJoinPoint pjp,Method method) throws Throwable{
  42.         AccessLimit lxRateLimit = method.getAnnotation(AccessLimit.class);
  43.         HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
  44.         // 或者url(存在map集合的key)
  45.         String url = request.getRequestURI();
  46.         if (!limitMap.containsKey(url)) {
  47.             // 创建令牌桶
  48.             rateLimiter = RateLimiter.create(lxRateLimit.perSecond());
  49.             limitMap.put(url, rateLimiter);
  50.             log.info("<<=================  请求{},创建令牌桶,容量{} 成功!!!",url,lxRateLimit.perSecond());
  51.         }
  52.         rateLimiter = limitMap.get(url);
  53.         if (!rateLimiter.tryAcquire(lxRateLimit.timeOut(), lxRateLimit.timeOutUnit())) {//获取令牌
  54.             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  55.             log.info("Error ---时间:{},获取令牌失败.", sdf.format(new Date()));
  56.             throw new BusinessException("服务器繁忙，请稍后再试!");
  57.         }
  58.         return null;
  59.     }
  60. }
  • 切面
  1. import com.liugh.annotation.AccessLimit;
  2. import com.liugh.annotation.Log;
  3. import com.liugh.annotation.ParamXssPass;
  4. import com.liugh.annotation.ValidationParam;
  5. import com.liugh.aspect.*;
  6. import com.liugh.util.ComUtil;
  7. import com.liugh.util.StringUtil;
  8. import org.aspectj.lang.ProceedingJoinPoint;
  9. import org.aspectj.lang.annotation.Around;
  10. import org.aspectj.lang.annotation.Aspect;
  11. import org.aspectj.lang.annotation.Pointcut;
  12. import org.springframework.context.annotation.Configuration;
  14. import java.lang.reflect.Method;
  16. /**
  17.  * 切面:防止xss攻击 记录log  参数验证
  18.  * @author liugh
  19.  * @since 2018-05-03
  20.  */
  21. @Aspect
  22. @Configuration
  23. public class ControllerAspect {
  25.     @Pointcut("execution(* com.liugh.controller..*(..))  ")
  26.     public void aspect() {
  27.     }
  29.     @Around(value = "aspect()")
  30.     public Object validationPoint(ProceedingJoinPoint pjp)throws Throwable{
  31.         Method method = currentMethod(pjp,pjp.getSignature().getName());
  32.         //创建被装饰者
  33.         AspectApiImpl aspectApi = new AspectApiImpl();
  34.         //是否需要验证参数
  35.         if (!ComUtil.isEmpty(StringUtil.getMethodAnnotationOne(method, ValidationParam.class.getSimpleName()))) {
  36.             new ValidationParamAspect(aspectApi).doHandlerAspect(pjp,method);
  37.         }
  38.         //是否需要限流
  39.         if (method.isAnnotationPresent(AccessLimit.class)) {
  40.             new AccessLimitAspect(aspectApi).doHandlerAspect(pjp,method);
  41.         }
  42.         //是否需要拦截xss攻击
  43.         if(method.isAnnotationPresent( ParamXssPass.class )){
  44.            new ParamXssPassAspect(aspectApi).doHandlerAspect(pjp,method);
  45.         }
  46.         //是否需要记录日志
  47.         if(method.isAnnotationPresent(Log.class)){
  48.             return new RecordLogAspect(aspectApi).doHandlerAspect(pjp,method);
  49.         }
  50.         return  pjp.proceed(pjp.getArgs());
  51.     }
  53.     /**
  54.      * 获取目标类的所有方法，找到当前要执行的方法
  55.      */
  56.     private Method currentMethod ( ProceedingJoinPoint joinPoint , String methodName ) {
  57.         Method[] methods      = joinPoint.getTarget().getClass().getMethods();
  58.         Method   resultMethod = null;
  59.         for ( Method method : methods ) {
  60.             if ( method.getName().equals( methodName ) ) {
  61.                 resultMethod = method;
  62.                 break;
  63.             }
  64.         }
  65.         return resultMethod;
  66.     }
  68. }
  • 上面的代码还包含了参数验证，xss攻击拦截，日志记录，这些比较常用功能，感兴趣的自行下载代码浏览细节

1.2.3. 异步日志记录

  • 日志的异步记录，这是个好思路，日志记录不影响主任务，可以改成异步加快速度
  1. /**
  2.  * 线程池配置、启用异步
  3.  *
  4.  * @author liugh
  5.  *
  6.  */
  7. //开启异步
  8. @EnableAsync(proxyTargetClass = true)
  9. @Configuration
  10. public class AsycTaskExecutorConfig {
  12. 	@Bean
  13. 	public TaskExecutor taskExecutor() {
  14. 		ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
  15. 		//核心线程数
  16. 		taskExecutor.setCorePoolSize(50);
  17. 		//最大线程数
  18. 		taskExecutor.setMaxPoolSize(100);
  19. 		return taskExecutor;
  20. 	}
  21. }
  • 日志切面
  1. import java.lang.reflect.Method;
  2. import java.util.Map;
  4. import com.alibaba.fastjson.JSONObject;
  5. import com.liugh.annotation.Log;
  6. import com.liugh.service.SpringContextBeanService;
  7. import com.liugh.entity.OperationLog;
  8. import com.liugh.service.IOperationLogService;
  9. import com.liugh.util.ComUtil;
  10. import com.liugh.util.JWTUtil;
  11. import org.aspectj.lang.ProceedingJoinPoint;
  12. import org.slf4j.Logger;
  13. import org.slf4j.LoggerFactory;
  14. import org.springframework.scheduling.annotation.Async;
  15. import org.springframework.web.context.request.RequestAttributes;
  16. import org.springframework.web.context.request.RequestContextHolder;
  17. import org.springframework.web.context.request.ServletRequestAttributes;
  19. import javax.servlet.http.HttpServletRequest;
  21. /**
  22.  * 记录日志切面
  23.  * @author liugh
  24.  * @since on 2018/5/10.
  25.  */
  26. public class RecordLogAspect extends AbstractAspectManager {
  28.     public RecordLogAspect(AspectApi aspectApi){
  29.         super(aspectApi);
  30.     }
  32.     @Override
  33.     public Object doHandlerAspect(ProceedingJoinPoint pjp, Method method) throws Throwable{
  34.         super.doHandlerAspect(pjp,method);
  35.         return execute(pjp,method);
  36.     }
  38.     private Logger logger = LoggerFactory.getLogger(RecordLogAspect.class);
  40.     @Override
  41.     @Async
  42.     protected Object execute(ProceedingJoinPoint pjp, Method method) throws Throwable{
  43.         Log log  = method.getAnnotation( Log.class );
  44.         // 异常日志信息
  45.         String actionLog = null;
  46.         StackTraceElement[] stackTrace =null;
  47.         // 是否执行异常
  48.         boolean isException = false;
  49.         // 接收时间戳
  50.         long endTime;
  51.         // 开始时间戳
  52.         long operationTime = System.currentTimeMillis();
  53.         try {
  54.             return pjp.proceed(pjp.getArgs());
  55.         } catch ( Throwable throwable ) {
  56.             isException = true;
  57.             actionLog = throwable.getMessage();
  58.             stackTrace = throwable.getStackTrace();
  59.             throw throwable;
  60.         } finally {
  61.             // 日志处理
  62.             logHandle( pjp , method , log , actionLog , operationTime , isException,stackTrace );
  63.         }
  64.     }
  66.     private void logHandle (ProceedingJoinPoint joinPoint ,
  67.                             Method method ,
  68.                             Log log ,
  69.                             String actionLog ,
  70.                             long startTime  ,
  71.                             boolean isException,
  72.                             StackTraceElement[] stackTrace) {
  73.         RequestAttributes ra = RequestContextHolder.getRequestAttributes();
  74.         IOperationLogService operationLogService = SpringContextBeanService.getBean(IOperationLogService.class);
  75.         ServletRequestAttributes sra = (ServletRequestAttributes) ra;
  76.         HttpServletRequest request = sra.getRequest();
  77.         String authorization = request.getHeader("Authorization");
  78.         OperationLog operationLog = new OperationLog();
  79.         if(!ComUtil.isEmpty(authorization)){
  80.             String userNo = JWTUtil.getUserNo(authorization);
  81.             operationLog.setUserNo(userNo);
  82.         }
  83.         operationLog.setIp(getIpAddress(request));
  84.         operationLog.setClassName(joinPoint.getTarget().getClass().getName() );
  85.         operationLog.setCreateTime(startTime);
  86.         operationLog.setLogDescription(log.description());
  87.         operationLog.setModelName(log.modelName());
  88.         operationLog.setAction(log.action());
  89.         if(isException){
  90.             StringBuilder sb = new StringBuilder();
  91.             sb.append(actionLog+" 
  92.  ");
  93.             for (int i = 0; i < stackTrace.length; i++) {
  94.                 sb.append(stackTrace[i]+" 
  95.  ");
  96.             }
  97.             operationLog.setMessage(sb.toString());
  98.         }
  99.         operationLog.setMethodName(method.getName());
  100.         operationLog.setSucceed(isException == true ? 2:1);
  101.         Object[] args = joinPoint.getArgs();
  102.         StringBuilder sb = new StringBuilder();
  103.         boolean isJoint = false;
  104.         for (int i = 0; i < args.length; i++) {
  105.             if(args[i] instanceof JSONObject){
  106.                 JSONObject parse = (JSONObject)JSONObject.parse(args[i].toString());
  107.                 if(!ComUtil.isEmpty(parse.getString("password"))){
  108.                     parse.put("password","*******");
  109.                 }
  110.                 if(!ComUtil.isEmpty(parse.getString("rePassword"))){
  111.                     parse.put("rePassword","*******");
  112.                 }
  113.                 if(!ComUtil.isEmpty(parse.getString("oldPassword"))){
  114.                     parse.put("oldPassword","*******");
  115.                 }
  116.                 operationLog.setActionArgs(parse.toString());
  117.             }else if(args[i] instanceof String
  118.                     || args[i] instanceof Long
  119.                     || args[i] instanceof Integer
  120.                     || args[i] instanceof Double
  121.                     || args[i] instanceof Float
  122.                     || args[i] instanceof Byte
  123.                     || args[i] instanceof Short
  124.                     || args[i] instanceof Character){
  125.                 isJoint=true;
  126.             }
  127.             else if(args[i] instanceof String []
  128.                     || args[i] instanceof Long []
  129.                     || args[i] instanceof Integer []
  130.                     || args[i] instanceof Double []
  131.                     || args[i] instanceof Float []
  132.                     || args[i] instanceof Byte []
  133.                     || args[i] instanceof Short []
  134.                     || args[i] instanceof Character []){
  135.                 Object[] strs = (Object[])args[i];
  136.                 StringBuilder sbArray  =new StringBuilder();
  137.                 sbArray.append("[");
  138.                 for (Object str:strs) {
  139.                     sbArray.append(str.toString()+",");
  140.                 }
  141.                 sbArray.deleteCharAt(sbArray.length()-1);
  142.                 sbArray.append("]");
  143.                 operationLog.setActionArgs(sbArray.toString());
  144.             }else {
  145.                 continue;
  146.             }
  147.         }
  148.         if(isJoint){
  149.             Map<String, String[]> parameterMap = request.getParameterMap();
  150.             for (String key:parameterMap.keySet()) {
  151.                 String[] strings = parameterMap.get(key);
  152.                 for (String str:strings) {
  153.                     sb.append(key+"="+str+"&");
  154.                 }
  155.             }
  156.             operationLog.setActionArgs(sb.deleteCharAt(sb.length()-1).toString());
  157.         }
  158.         logger.info("执行方法信息:"+JSONObject.toJSON(operationLog));
  159.         operationLogService.insert(operationLog);
  160.     }
  162.     private  String getIpAddress(HttpServletRequest request) {
  163.         String ip = request.getHeader("x-forwarded-for");
  164.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
  165.             ip = request.getHeader("Proxy-Client-IP");
  166.         }
  167.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
  168.             ip = request.getHeader("WL-Proxy-Client-IP");
  169.         }
  170.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
  171.             ip = request.getHeader("HTTP_CLIENT_IP");
  172.         }
  173.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
  174.             ip = request.getHeader("HTTP_X_FORWARDED_FOR");
  175.         }
  176.         if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
  177.             ip = request.getRemoteAddr();
  178.         }
  179.         return ip+":"+request.getRemotePort();
  180.     }
  181. }

1.2.4. 启动初始化扫描

  • 启动时扫描对应包，然后做相应处理，这里是把对应接口记录后用于后续pass，也就是通过@Pass不认证处理
  1. import com.liugh.annotation.Pass;
  2. import com.liugh.base.Constant;
  3. import com.liugh.util.ComUtil;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.apache.commons.lang3.StringUtils;
  6. import org.springframework.beans.factory.annotation.Value;
  7. import org.springframework.boot.CommandLineRunner;
  8. import org.springframework.stereotype.Component;
  9. import org.springframework.web.bind.annotation.*;
  11. import java.io.File;
  12. import java.io.IOException;
  13. import java.lang.reflect.Method;
  14. import java.net.JarURLConnection;
  15. import java.net.URL;
  16. import java.util.Enumeration;
  17. import java.util.HashSet;
  18. import java.util.Set;
  19. import java.util.jar.JarEntry;
  20. import java.util.jar.JarFile;
  22. /**
  23.  * @author liugh
  24.  * @Since 2018-05-10
  25.  */
  26. @Component
  27. //日志打印 log.info
  28. @Slf4j
  29. public class MyCommandLineRunner implements CommandLineRunner {
  31. 	@Value("${controller.scanPackage}")
  32. 	private String scanPackage;
  34. 	@Override
  35. 	public void run(String... args) throws Exception {
  36. 		doScanner(scanPackage);
  37. 		Set<String> urlAndMethodSet  =new HashSet<>();
  38. 		for (String aClassName:Constant.METHOD_URL_SET) {
  39. 			Class<?> clazz = Class.forName(aClassName);
  40. 			String baseUrl = "";
  41. 			String[] classUrl ={};
  42. 			if(!ComUtil.isEmpty(clazz.getAnnotation(RequestMapping.class))){
  43. 				classUrl=clazz.getAnnotation(RequestMapping.class).value();
  44. 			}
  45. 			Method[] methods = clazz.getMethods();
  46. 			for (Method method:methods) {
  47. 				if(method.isAnnotationPresent(Pass.class)){
  48. 					String [] methodUrl = null;
  49. 					StringBuilder sb  =new StringBuilder();
  50. 					if(!ComUtil.isEmpty(method.getAnnotation(PostMapping.class))){
  51. 						methodUrl=method.getAnnotation(PostMapping.class).value();
  52. 						if(ComUtil.isEmpty(methodUrl)){
  53. 							methodUrl=method.getAnnotation(PostMapping.class).path();
  54. 						}
  55. 						baseUrl=getRequestUrl(classUrl, methodUrl, sb,"POST");
  56. 					}else if(!ComUtil.isEmpty(method.getAnnotation(GetMapping.class))){
  57. 						methodUrl=method.getAnnotation(GetMapping.class).value();
  58. 						if(ComUtil.isEmpty(methodUrl)){
  59. 							methodUrl=method.getAnnotation(GetMapping.class).path();
  60. 						}
  61. 						baseUrl=getRequestUrl(classUrl, methodUrl, sb,"GET");
  62. 					}else if(!ComUtil.isEmpty(method.getAnnotation(DeleteMapping.class))){
  63. 						methodUrl=method.getAnnotation(DeleteMapping.class).value();
  64. 						if(ComUtil.isEmpty(methodUrl)){
  65. 							methodUrl=method.getAnnotation(DeleteMapping.class).path();
  66. 						}
  67. 						baseUrl=getRequestUrl(classUrl, methodUrl, sb,"DELETE");
  68. 					}else if(!ComUtil.isEmpty(method.getAnnotation(PutMapping.class))){
  69. 						methodUrl=method.getAnnotation(PutMapping.class).value();
  70. 						if(ComUtil.isEmpty(methodUrl)){
  71. 							methodUrl=method.getAnnotation(PutMapping.class).path();
  72. 						}
  73. 						baseUrl=getRequestUrl(classUrl, methodUrl, sb,"PUT");
  74. 					}else {
  75. 						methodUrl=method.getAnnotation(RequestMapping.class).value();
  76. 						baseUrl=getRequestUrl(classUrl, methodUrl, sb,RequestMapping.class.getSimpleName());
  77. 					}
  78. 					if(!ComUtil.isEmpty(baseUrl)){
  79. 						urlAndMethodSet.add(baseUrl);
  80. 					}
  81. 				}
  82. 			}
  83. 		}
  84. 		Constant.METHOD_URL_SET=urlAndMethodSet;
  85. 		log.info("@Pass:"+urlAndMethodSet);
  86. 	}
  88. 	private String  getRequestUrl(String[] classUrl, String[] methodUrl, StringBuilder sb,String requestName) {
  89. 		sb.append("/api/v1");
  90. 		if(!ComUtil.isEmpty(classUrl)){
  91.             for (String url:classUrl) {
  92.                 sb.append(url+"/");
  93.             }
  94.         }
  95. 		for (String url:methodUrl) {
  96.             sb.append(url);
  97.         }
  98.         if(sb.toString().endsWith("/")){
  99. 			sb.deleteCharAt(sb.length()-1);
  100. 		}
  101. 		return sb.toString().replaceAll("/+", "/")+":--:"+requestName;
  102. 	}
  104. 	private void doScanner(String packageName) {
  105. 		//把所有的.替换成/
  106. 		URL url  =this.getClass().getClassLoader().getResource(packageName.replaceAll("\\.", "/"));
  107. 		// 是否循环迭代
  108. 		if(StringUtils.countMatches(url.getFile(), ".jar")>0){
  109. 			boolean recursive=true;
  110. 			JarFile jar;
  111. 			// 获取jar
  112. 			try {
  113. 				jar = ((JarURLConnection) url.openConnection())
  114. 						.getJarFile();
  115. 				// 从此jar包 得到一个枚举类
  116. 				Enumeration<JarEntry> entries = jar.entries();
  117. 				while (entries.hasMoreElements()) {
  118. 					// 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
  119. 					JarEntry entry = entries.nextElement();
  120. 					String name = entry.getName();
  121. 					// 如果是以/开头的
  122. 					if (name.charAt(0) == '/') {
  123. 						// 获取后面的字符串
  124. 						name = name.substring(1);
  125. 					}
  126. 					// 如果前半部分和定义的包名相同
  127. 					if (name.startsWith(packageName.replaceAll("\\.","/"))) {
  128. 						int idx = name.lastIndexOf('/');
  129. 						// 如果以"/"结尾 是一个包
  130. 						if (idx != -1) {
  131. 							// 获取包名 把"/"替换成"."
  132. 							packageName = name.substring(0, idx)
  133. 									.replace('/', '.');
  134. 						}
  135. 						// 如果可以迭代下去 并且是一个包
  136. 						if ((idx != -1) || recursive) {
  137. 							// 如果是一个.class文件 而且不是目录
  138. 							if (name.endsWith(".class")
  139. 									&& !entry.isDirectory()) {
  140. 								// 去掉后面的".class" 获取真正的类名
  141. 								String className = name.substring(
  142. 										packageName.length() + 1, name
  143. 												.length() - 6);
  144. 								try {
  145. 									// 添加到classes
  146. 									Constant.METHOD_URL_SET.add(Class
  147. 											.forName(packageName + '.'
  148. 													+ className).getName());
  149. 								} catch (ClassNotFoundException e) {
  150. 									e.printStackTrace();
  151. 								}
  152. 							}
  153. 						}
  154. 					}
  155. 				}
  156. 				return;
  157. 			} catch (IOException e) {
  158. 				e.printStackTrace();
  159. 			}
  160. 		}
  161. 		File dir = new File(url.getFile());
  162. 		for (File file : dir.listFiles()) {
  163. 			if(file.isDirectory()){
  164. 				//递归读取包
  165. 				doScanner(packageName+"."+file.getName());
  166. 			}else{
  167. 				String className =packageName +"." +file.getName().replace(".class", "");
  168. 				Constant.METHOD_URL_SET.add(className);
  169. 			}
  170. 		}
  171. 	}
  173. }

1.2.5. redis缓存用法

  • 缓存wiselyKeyGenerator具体用法，之前没了解到这个的具体用法，这次知道了
  1. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  2. import com.fasterxml.jackson.annotation.PropertyAccessor;
  3. import com.fasterxml.jackson.databind.ObjectMapper;
  4. import org.springframework.cache.CacheManager;
  5. import org.springframework.cache.annotation.CachingConfigurerSupport;
  6. import org.springframework.cache.annotation.EnableCaching;
  7. import org.springframework.cache.interceptor.KeyGenerator;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.Configuration;
  10. import org.springframework.data.redis.cache.RedisCacheManager;
  11. import org.springframework.data.redis.connection.RedisConnectionFactory;
  12. import org.springframework.data.redis.core.RedisTemplate;
  13. import org.springframework.data.redis.core.StringRedisTemplate;
  14. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  16. import java.lang.reflect.Method;
  18. /**
  19.  * @author liugh
  20.  * @since on 2018/5/11.
  21.  */
  22. @Configuration
  23. @EnableCaching
  24. public class RedisConfig extends CachingConfigurerSupport {
  26.     /*定义缓存数据 key 生成策略的bean
  27.    包名+类名+方法名+所有参数
  28.    */
  29.     @Bean("wiselyKeyGenerator")
  30.     public KeyGenerator wiselyKeyGenerator(){
  31.         return new KeyGenerator() {
  32.             @Override
  33.             public Object generate(Object target, Method method, Object... params) {
  34.                 StringBuilder sb = new StringBuilder();
  35.                 sb.append(target.getClass().getSimpleName()+":");
  36.                 sb.append(method.getName()+":");
  37.                 for (Object obj : params) {
  38.                     sb.append(obj.toString()+":");
  39.                 }
  40.                 return sb.deleteCharAt(sb.length()-1).toString();
  41.             }
  42.         };
  44.     }
  46.     /*要启用spring缓存支持,需创建一个 CacheManager的 bean，CacheManager 接口有很多实现，这里Redis 的集成，用 RedisCacheManager这个实现类
  47.     Redis 不是应用的共享内存，它只是一个内存服务器，就像 MySql 似的，
  48.     我们需要将应用连接到它并使用某种“语言”进行交互，因此我们还需要一个连接工厂以及一个 Spring 和 Redis 对话要用的 RedisTemplate，
  49.     这些都是 Redis 缓存所必需的配置，把它们都放在自定义的 CachingConfigurerSupport 中
  50.      */
  51.     @Bean
  52.     public CacheManager cacheManager(
  53.             @SuppressWarnings("rawtypes") RedisTemplate redisTemplate) {
  54.         RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
  55. //        cacheManager.setDefaultExpiration(60);//设置缓存保留时间（seconds）
  56.         return cacheManager;
  57.     }
  58. //    @Bean  springboot 2.0
  59. //    public CacheManager cacheManager(
  60. //            @SuppressWarnings("rawtypes") RedisTemplate redisTemplate) {
  61. //        // 初始化缓存管理器，在这里我们可以缓存的整体过期时间什么的，我这里默认没有配置
  62. //        RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager
  63. //                .RedisCacheManagerBuilder
  64. //                .fromConnectionFactory(jedisConnectionFactory);
  65. //        return builder.build();
  66. //    }
  68.     //1.项目启动时此方法先被注册成bean被spring管理
  69.     @Bean
  70.     public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
  71.         StringRedisTemplate template = new StringRedisTemplate(factory);
  72.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  73.         ObjectMapper om = new ObjectMapper();
  74.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  75.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  76.         jackson2JsonRedisSerializer.setObjectMapper(om);
  77.         template.setValueSerializer(jackson2JsonRedisSerializer);
  78.         template.afterPropertiesSet();
  79.         return template;
  80.     }
  81. }
  • 使用
  1.     @Override
  2.     //redis方法级别的缓存，需要做缓存打开改注解即可
  3.     @Cacheable(value = "UserToRole",keyGenerator="wiselyKeyGenerator")
  4.     public List<Menu> selectByIds(List<Integer> permissionIds) {
  5.         EntityWrapper<Menu> ew = new EntityWrapper<>();
  6.         ew.in("menu_id", permissionIds);
  7.         return this.selectList(ew);
  8.     }

springboot脚手架liugh-parent源码研究参考的更多相关文章

  1. 从源码研究如何不重启Springboot项目实现redis配置动态切换

    上一篇Websocket的续篇暂时还没有动手写,这篇算是插播吧.今天讲讲不重启项目动态切换redis服务. 背景 多个项目或微服务场景下,各个项目都需要配置redis数据源.但是,每当运维搞事时(修改 ...

  2. zepto源码研究 - zepto.js - 1

    简要:网上已经有很多人已经将zepto的源码研究得很细致了,但我还是想写下zepto源码系列,将别人的东西和自己的想法写下来以加深印象也是自娱自乐,文章中可能有许多错误,望有人不吝指出,烦请赐教. 首 ...

  3. underscore.js源码研究(6)

    概述 很早就想研究underscore源码了,虽然underscore.js这个库有些过时了,但是我还是想学习一下库的架构,函数式编程以及常用方法的编写这些方面的内容,又恰好没什么其它要研究的了,所以 ...

  4. 阿里sentinel源码研究深入

    1. 阿里sentinel源码研究深入 1.1. 前言 昨天已经把sentinel成功部署到线上环境,可参考我上篇博文,该走的坑也都走了一遍,已经可以初步使用它的限流和降级功能,根据我目前的实践,限流 ...

  5. OAuth2学习及DotNetOpenAuth部分源码研究

    OAuth2学习及DotNetOpenAuth部分源码研究 在上篇文章中我研究了OpenId及DotNetOpenAuth的相关应用,这一篇继续研究OAuth2. 一.什么是OAuth2 OAuth是 ...

  6. Android开源项目 Universal imageloader 源码研究之Lru算法

    https://github.com/nostra13/Android-Universal-Image-Loader universal imageloader 源码研究之Lru算法 LRU - Le ...

  7. dubbo源码研究（一）

    1. dubbo源码研究(一) 1.1. dubbo启动加载过程 我们知道,现在流行注解方式,用spring管理服务,dubbo最常用的就是@Reference和@Service了,那么我首先找到这两 ...

  8. 【JavaScript】$.extend使用心得及源码研究

    最近写多了js的面向对象编程,用$.extend写继承写得很顺手.但是在使用过程中发现有几个问题. 1.深拷贝 $.extend默认是浅拷贝,这意味着在继承复杂对象时,对象中内嵌的对象无法被拷贝到. ...

  9. list源码4(参考STL源码--侯捷)：transfer、splice、merge、reverse、sort

    list源码1(参考STL源码--侯捷):list节点.迭代器.数据结构 list源码2(参考STL源码--侯捷):constructor.push_back.insert list源码3(参考STL ...

随机推荐

  1. java中的this关键字三种作用

    1.表示类中的属性和调用方法2.调用本类中的构造方法3.表示当前对象

  2. nginx 跨域请求访问

    1.nginx跨域请求访问 location ~ .*\.(htm|html)$ { add_header Access-Control-Allow-Origin(请求域名) *(所有域名) http ...

  3. MySQL 官方测试库

    MySQL 官方测试库 github 地址 https://github.com/datacharmer/test_db MySQL 文档地址 https://dev.mysql.com/doc/em ...

  4. hdu2281&&POJ1320——Pell方程

    hdu2281 输入一个 $N$,求最大的 $n$($n \leq N$)和 $x$,使得 $x^2 = \frac{1^2+2^2+...+n^2}{n}$. 分析: 将右边式子的分子求和化简,有: ...

  5. Office Tool Plus 安装Office

    Office Tool Plus 是一款集office 卸载安装管理,激活等多功能于一体的神器. 官网:https://otp.landian.vip/en-us/ 下载 安装 值得注意的是Retai ...

  6. Kali系统改国内源配置和SSH配置

    一.Kali系统更新源 使用官网的虚拟化镜像安装,默认为英文界面,更新源也是官方源.因为官方服务器在国外,速度不是很理想,现在就来改国内源并且更新系统. 1.使用编辑器打开系统源文本(在终端内操作,先 ...

  7. 2.shell编程-函数的高级用法

    2.1.函数的定义和使用 函数基本使用 [root@VM_0_9_centos ~]# test() > {} -bash: syntax error near unexpected token ...

  8. selenium--浏览器窗口截图

    前戏 在进行web自动化的时候,只有一个报错信息是不行的,往往需要截图来帮助我们来快速的定位问题,试想一下,我们在一个弹框里添加一些数据,点击保存后,然后在操作元素,这时selenium报错,说找不到 ...

  9. 直接插入排序与缩小增量插入排序（希尔排序ShellSort）

    直接插入排序 要理解shell排序,首先要把直接插入排序的基础打扎实. 学习资料:白话经典算法系列之二 直接插入排序的三种实现.直接插入排序 根据我的思路,直接插入排序设置3重循环. 循环1:对 i= ...

  10. 奇技淫巧and板子

    目录 求第\(k\)大的数 求长度不小于L的子段使之和最大 ST表 \(O(1)\)实现能查询栈中最小元素 二分 树和图的深度优先遍历和广度优先遍历 树的dfs序 求树的重心 图的联通块划分 拓扑排序 ...