获取请求响应时间、数学计算相关的工具类库、异步返回

阳光穿透心脏的1/2处 2022-12-24 15:56 114阅读 0赞

## 一、后台打印请求响应时间等数据 ##

**1.1、使用shiro实现**

import lombok.extern.slf4j.Slf4j;
 import org.apache.shiro.web.servlet.AdviceFilter;
 import org.springframework.core.NamedThreadLocal;
 
 import javax.servlet.ServletRequest;
 import javax.servlet.ServletResponse;
 import javax.servlet.http.HttpServletRequest;
 
 
 @Slf4j
 public class LogFilter extends AdviceFilter { 
 
 private NamedThreadLocal<Long> startTimeThreadLocal = new NamedThreadLocal<>("ThreadLocal-StartTime");
 
 
 @Override
 protected boolean preHandle(ServletRequest request, ServletResponse response) { 
 //1、开始时间
 long beginTime = System.currentTimeMillis();
 startTimeThreadLocal.set(beginTime);
 HttpServletRequest httpRequest = (HttpServletRequest) request;
 String url = httpRequest.getRequestURL().toString();
 String remoteAddress = request.getRemoteAddr() + ":" + request.getRemotePort();
 String token = httpRequest.getHeader("token");
 log.info(String.format("--------请求接口 %s --------", url));
 log.info(String.format("--------请求来源 %s --------", remoteAddress));
 log.info(String.format("--------请求 token %s --------", token));
 return true;
 }
 
 @Override
 public void afterCompletion(ServletRequest request, ServletResponse response, Exception e) { 
 //2、结束时间
 long endTime = System.currentTimeMillis();
 //得到线程绑定的局部变量（开始时间）
 long beginTime = startTimeThreadLocal.get();
 log.info(String.format("--------耗时 %d millis --------", endTime - beginTime));
 }
 }

import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
 import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
 import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
 import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
 import javax.servlet.Filter;
 import java.util.LinkedHashMap;
 import java.util.Map;
 
 @Configuration
 public class ShiroConfig { 
 
 @Value("${spring.redis.shiro.host}")
 private String host;
 @Value("${spring.redis.shiro.port}")
 private Integer port;
 @Value("${session.timeout}")
 private Integer sessionTimeout;
 @Value("${spring.redis.shiro.password}")
 private String password;
 @Value("${spring.redis.shiro.database}")
 private Integer database;
 
 
 /** * 权限规则配置 **/
 @Bean
 public ShiroFilterFactoryBean shiroFilterFactoryBean(org.apache.shiro.mgt.SecurityManager securityManager) { 
 ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
 shiroFilterFactoryBean.setSecurityManager(securityManager);
 Map<String, Filter> filters = shiroFilterFactoryBean.getFilters();
 filters.put("log", new LogFilter());
 shiroFilterFactoryBean.setFilters(filters);
 Map<String, String> map = new LinkedHashMap<>();
 //swagger资源 不拦截
 map.put("/swagger-ui.html", "anon");
 map.put("/swagger-resources/**/**", "anon");
 map.put("/v2/api-docs", "anon");
 shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
 return shiroFilterFactoryBean;
 }
 
 
 @Bean
 public org.apache.shiro.mgt.SecurityManager securityManager() { 
 DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
 return securityManager;
 }
 
 @Bean
 public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator() { 
 DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
 advisorAutoProxyCreator.setProxyTargetClass(true);
 return advisorAutoProxyCreator;
 }
 
 @Bean
 public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(org.apache.shiro.mgt.SecurityManager securityManager) { 
 AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
 authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
 return authorizationAttributeSourceAdvisor;
 }
 
 
 }

**1.2、使用servlet拦截实现**

import com.alibaba.fastjson.JSON;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.core.NamedThreadLocal;
 import org.springframework.web.servlet.HandlerInterceptor;
 import org.springframework.web.servlet.ModelAndView;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.util.Map;
 
 
 @Slf4j
 public class LogInterceptor implements HandlerInterceptor { 
 
 
 private static final ThreadLocal<Long> START_TIME_THREAD_LOCAL = new NamedThreadLocal<>("ThreadLocal-StartTime");
 
 /** * 拦截的方法执行之前调用 */
 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
 Object handler) { 
 //1、开始时间
 long beginTime = System.currentTimeMillis();
 //线程绑定变量（该数据只有当前请求的线程可见）
 START_TIME_THREAD_LOCAL.set(beginTime);
 return true;
 }
 
 /** * 拦截的方法执行过程中，返回model and view之前调用 */
 @Override
 public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
 ModelAndView modelAndView) { 
 if (modelAndView != null) { 
 log.info("ViewName: " + modelAndView.getViewName());
 }
 }
 
 
 @Override
 public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
 Object handler, Exception e) { 
 
 // 打印JVM信息。
 //1. 得到线程绑定的局部变量（开始时间）
 long beginTime = START_TIME_THREAD_LOCAL.get();
 //2、结束时间
 long endTime = System.currentTimeMillis();
 Map<String, String[]> pm = request.getParameterMap();
 log.info("耗时:{}ms\tURI:{}\t请求参数:{}\t最大内存:{}m\t已分配内存:{}m\t已分配内存中的剩余空间:{}m\t最大可用内存:{}m",
 (endTime - beginTime), request.getRequestURI(), JSON.toJSON(pm), Runtime.getRuntime().maxMemory() / 1024 / 1024, Runtime.getRuntime().totalMemory() / 1024 / 1024, Runtime.getRuntime().freeMemory() / 1024 / 1024,
 (Runtime.getRuntime().maxMemory() - Runtime.getRuntime().totalMemory() + Runtime.getRuntime().freeMemory()) / 1024 / 1024);
 
 }
 }

import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    
    
    @Configuration
    public class WebAppConfig implements WebMvcConfigurer { 
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) { 
            //注册自定义拦截器，添加拦截路径和排除拦截路径
            registry.addInterceptor(new LogInterceptor()).addPathPatterns("/**");
        }
    }

## 二、批量删除文件 ##

mport org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.File;
 import java.util.Objects;
 
 public class DeleteFileUtil { 
 
 private static final Logger LOGGER = LoggerFactory.getLogger(DeleteFileUtil.class);
 
 /** * 删除单个文件 * * @param fileName * 要删除的文件的文件名 * @return 单个文件删除成功返回true，否则返回false */
 public static boolean deleteFile(String fileName) { 
 File file = new File(fileName);
 // 如果文件路径所对应的文件存在，并且是一个文件，则直接删除
 if (file.exists() && file.isFile()) { 
 if (file.delete()) { 
 LOGGER.info("删除单个文件" + fileName + "成功！");
 return true;
 } else { 
 LOGGER.info("删除单个文件" + fileName + "失败！");
 return false;
 }
 } else { 
 LOGGER.info("删除单个文件失败：" + fileName + "不存在！");
 return false;
 }
 }
 
 
 /** * 删除目录及目录下的文件 * * @param dir * 要删除的目录的文件路径 * @return 目录删除成功返回true，否则返回false */
 public static boolean deleteDirectory(String dir) { 
 // 如果dir不以文件分隔符结尾，自动添加文件分隔符
 if (!dir.endsWith(File.separator)) { 
 dir = dir + File.separator;
 }
 File dirFile = new File(dir);
 // 如果dir对应的文件不存在，或者不是一个目录，则退出
 if ((!dirFile.exists()) || (!dirFile.isDirectory())) { 
 LOGGER.info("删除目录失败：" + dir + "不存在！");
 return false;
 }
 boolean flag = true;
 // 删除文件夹中的所有文件包括子目录
 File[] files = dirFile.listFiles();
 for (int i = 0; i < Objects.requireNonNull(files).length; i++) { 
 // 删除子文件
 if (files[i].isFile()) { 
 flag = DeleteFileUtil.deleteFile(files[i].getAbsolutePath());
 if (!flag) { 
 break;
 }
 } else if (files[i].isDirectory()) { 
 // 删除子目录
 flag = DeleteFileUtil.deleteDirectory(files[i].getAbsolutePath());
 if (!flag) { 
 break;
 }
 }
 }
 dirFile.delete();
 if (!flag) { 
 LOGGER.info("删除目录失败！");
 return false;
 }
 return true;
 }
 }

## 三、流压缩 ##

import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.zip.GZIPInputStream;
 import java.util.zip.GZIPOutputStream;
 
 
 public class ByteUtil { 
 
 public static List<Byte> toList(byte[] array) { 
 if (array == null) { 
 return null;
 }
 
 List<Byte> list = new ArrayList<Byte>(array.length);
 
 for (byte value : array) { 
 list.add(value);
 }
 
 return list;
 }
 
 public static byte[] toArray(List<Byte> list) { 
 if (list == null) { 
 return null;
 }
 
 byte[] array = new byte[list.size()];
 
 int index = 0;
 for (byte value : list) { 
 array[index++] = value;
 }
 
 return array;
 }
 
 
 /** * 把long类型的value转为8个byte字节，放到byte数组的off开始的位置，高位在前 * * @param value * @param bytes * @param off */
 public static void long2bytes(long value, byte[] bytes, int off) { 
 bytes[off + 7] = (byte) value;
 bytes[off + 6] = (byte) (value >>> 8);
 bytes[off + 5] = (byte) (value >>> 16);
 bytes[off + 4] = (byte) (value >>> 24);
 bytes[off + 3] = (byte) (value >>> 32);
 bytes[off + 2] = (byte) (value >>> 40);
 bytes[off + 1] = (byte) (value >>> 48);
 bytes[off] = (byte) (value >>> 56);
 }
 
 /** * 把byte数组中off开始的8个字节，转为long类型，高位在前 * * @param bytes * @param off */
 public static long bytes2long(byte[] bytes, int off) { 
 return ((bytes[off + 7] & 0xFFL)) + ((bytes[off + 6] & 0xFFL) << 8) + ((bytes[off + 5] & 0xFFL) << 16)
 + ((bytes[off + 4] & 0xFFL) << 24) + ((bytes[off + 3] & 0xFFL) << 32) + ((bytes[off + 2] & 0xFFL) << 40)
 + ((bytes[off + 1] & 0xFFL) << 48) + (((long) bytes[off]) << 56);
 }
 
 /** * 把int类型的value转为4个byte字节，放到byte数组的off开始的位置，高位在前 * * @param value * @param bytes * @param off */
 public static void int2bytes(int value, byte[] bytes, int off) { 
 bytes[off + 3] = (byte) value;
 bytes[off + 2] = (byte) (value >>> 8);
 bytes[off + 1] = (byte) (value >>> 16);
 bytes[off] = (byte) (value >>> 24);
 }
 
 /** * 把byte数组中off开始的4个字节，转为int类型，高位在前 * * @param bytes * @param off */
 public static int bytes2int(byte[] bytes, int off) { 
 return ((bytes[off + 3] & 0xFF)) + ((bytes[off + 2] & 0xFF) << 8) + ((bytes[off + 1] & 0xFF) << 16) + ((bytes[off]) << 24);
 }
 
 /** * 把short类型的value转为2个byte字节，放到byte数组的off开始的位置，高位在前 * * @param value * @param bytes * @param off */
 public static void short2bytes(short value, byte[] bytes, int off) { 
 bytes[off + 1] = (byte) value;
 bytes[off] = (byte) (value >>> 8);
 }
 
 /** * 把byte数组中off开始的2个字节，转为short类型，高位在前 * * @param b * @param off */
 public static short bytes2short(byte[] b, int off) { 
 return (short) (((b[off + 1] & 0xFF)) + ((b[off] & 0xFF) << 8));
 }
 
 public static byte[] gzip(byte[] data) throws IOException { 
 ByteArrayOutputStream bos = new ByteArrayOutputStream(data.length);
 GZIPOutputStream gzip = null;
 try { 
 gzip = new GZIPOutputStream(bos);
 gzip.write(data);
 gzip.finish();
 return bos.toByteArray();
 } finally { 
 if (gzip != null) { 
 gzip.close();
 }
 }
 
 }
 
 public static byte[] unGzip(byte[] data) throws IOException { 
 GZIPInputStream gzip = null;
 try { 
 gzip = new GZIPInputStream(new ByteArrayInputStream(data));
 byte[] buf = new byte[2048];
 int size = -1;
 ByteArrayOutputStream bos = new ByteArrayOutputStream(data.length + 1024);
 while ((size = gzip.read(buf, 0, buf.length)) != -1) { 
 bos.write(buf, 0, size);
 }
 return bos.toByteArray();
 } finally { 
 if (gzip != null) { 
 gzip.close();
 }
 }
 
 }
 }

## 四、无符号类型计算工具类. ##

public class UnsignedUtils { 
 /** * 将byte类型的数字转化为无符号的数字. * * 区间[0~255] * * @param num 数字 * @return 转化后所对应无符号数字 */
 public static int toUnsigned(byte num) { 
 return num & 0xFF;
 }
 
 /** * 将short类型的数字转化为无符号的数字. * * 区间[0~65535] * * @param num 数字 * @return 转化后所对应无符号数字 */
 public static int toUnsigned(short num) { 
 return num & 0xFFFF;
 }
 
 /** * 将int类型的数字转化为无符号的数字. * * 区间[0~4294967295] * * @param num 数字 * @return 转化后所对应无符号数字 */
 public static long toUnsigned(int num) { 
 return num & 0xFFFFFFFFL;
 }
 }

## 五、数学计算相关的工具类库 ##

/** * 平面坐标系中的一个点. */
 public class Point { 
 private final int x;
 private final int y;
 
 private Point(int x, int y) { 
 this.x = x;
 this.y = y;
 }
 
 /** * 根据X与Y构建一个坐标点. * * 这个类未公开构造函数，是为了日后方便此类做缓存处理，入口先准备好 * * @param x X坐标 * @param y Y坐标 * @return 坐标点 */
 public static Point valueOf(int x, int y) { 
 return new Point(x, y);
 }
 
 /** * 获取X坐标 * * @return X坐标 */
 public int getX() { 
 return x;
 }
 
 /** * 获取Y坐标 * * @return Y坐标 */
 public int getY() { 
 return y;
 }
 
 @Override
 public int hashCode() { 
 final int prime = 31;
 int result = 1;
 result = prime * result + x;
 result = prime * result + y;
 return result;
 }
 
 @Override
 public boolean equals(Object obj) { 
 if (this == obj) { 
 return true;
 }
 if (obj == null) { 
 return false;
 }
 if (getClass() != obj.getClass()) { 
 return false;
 }
 Point other = (Point) obj;
 if (x != other.x) { 
 return false;
 }
 if (y != other.y) { 
 return false;
 }
 return true;
 }
 
 @Override
 public String toString() { 
 return "Point [x=" + x + ", y=" + y + "]";
 }
 }

import java.math.BigDecimal;
 import java.math.RoundingMode;
 import java.util.HashMap;
 import java.util.Map;
 
 /** * 数学计算相关的工具类库. */
 public class MathUtils { 
 /** * 一 */
 public static final double ONE = 1.0;
 /** * 百 */
 public static final double HUNDRED = 100.0;
 /** * 千 */
 public static final double THOUSAND = 1000.0;
 /** * 万 */
 public static final double TEN_THOUSAND = 1_0000.0;
 /** * 百万 */
 public static final double MILLION = 100_0000.0;
 
 /** * 计算两个参数的和，如果相加出现溢出那就返回{@code int}的最大值. * * 区别于JDK的方法，仅仅认同判定方案，游戏世界，溢出时那就修正一个合理的值，一般调用此方法的游戏逻辑决不能因异常而中断 * * @param x 第一个参数 * @param y 第二个参数 * @return 两个参数的和 * @see Math#addExact(int, int) */
 public static int addExact(int x, int y) { 
 try { 
 return Math.addExact(x, y);
 } catch (ArithmeticException e) { 
 return Integer.MAX_VALUE;
 }
 }
 
 /** * 计算两个参数的和，如果相加出现溢出那就返回{@code long}的最大值. * * 区别于JDK的方法，仅仅认同判定方案，游戏世界，溢出时那就修正一个合理的值，一般调用此方法的游戏逻辑决不能因异常而中断 * * @param x 第一个参数 * @param y 第二个参数 * @return 两个参数的和 * @see Math#addExact(long, long) */
 public static long addExact(long x, long y) { 
 try { 
 return Math.addExact(x, y);
 } catch (ArithmeticException e) { 
 return Long.MAX_VALUE;
 }
 }
 
 /** * 计算两个参数的乘积，如果相乘出现溢出那就返回{@code int}的最大值. * * 区别于JDK的方法，仅仅认同判定方案，游戏世界，溢出时那就修正一个合理的值，一般调用此方法的游戏逻辑决不能因异常而中断 * * @param x 第一个参数 * @param y 第二个参数 * @return 两个参数的乘积 * @see Math#multiplyExact(int, int) */
 public static int multiplyExact(int x, int y) { 
 try { 
 return Math.multiplyExact(x, y);
 } catch (ArithmeticException e) { 
 return Integer.MAX_VALUE;
 }
 }
 
 /** * 计算两个参数的乘积，如果相乘出现溢出那就返回{@code long}的最大值. * * 区别于JDK的方法，仅仅认同判定方案，游戏世界，溢出时那就修正一个合理的值，一般调用此方法的游戏逻辑决不能因异常而中断 * * @param x 第一个参数 * @param y 第二个参数 * @return 两个参数的乘积 * @see Math#multiplyExact(long, long) */
 public static long multiplyExact(long x, long y) { 
 try { 
 return Math.multiplyExact(x, y);
 } catch (ArithmeticException e) { 
 return Long.MAX_VALUE;
 }
 }
 
 /** * 计算两点(x1,y1)到(x2,y2)的距离. * * Math.sqrt(|x1-x2|² + |y1-y2|²) * * @param x1 坐标X1 * @param y1 坐标Y1 * @param x2 坐标X2 * @param y2 坐标Y2 * @return 两点的距离 */
 public static double distance(int x1, int y1, int x2, int y2) { 
 final double x = Math.abs(x1 - x2);
 final double y = Math.abs(y1 - y2);
 return Math.sqrt(x * x + y * y);
 }
 
 /** * 计算两点(x1,y1)到(x2,y2)的距离. * * Math.sqrt(|x1-x2|² + |y1-y2|²) * * @param x1 坐标X1 * @param y1 坐标Y1 * @param x2 坐标X2 * @param y2 坐标Y2 * @return 两点的距离 */
 public static double distance(double x1, double y1, double x2, double y2) { 
 final double x = Math.abs(x1 - x2);
 final double y = Math.abs(y1 - y2);
 return Math.sqrt(x * x + y * y);
 }
 
 /** * 计算两点P1(x1,y1)到P2(x2,y2)的距离. * * Math.sqrt(|x1-x2|² + |y1-y2|²) * * @param p1 坐标1 * @param p2 坐标2 * @return 两点的距离 */
 public static double distance(Point p1, Point p2) { 
 return distance(p1.getX(), p1.getY(), p2.getX(), p2.getY());
 }
 
 /** * 判定两点(x1,y1)和(x2,y2)是否相邻. * * 可用于两个AOI是否相邻判定 * * @param x1 坐标X1 * @param y1 坐标Y1 * @param x2 坐标X2 * @param y2 坐标Y2 * @return 如果两坐标相邻返回true, 否则返回false */
 public static boolean adjacent(int x1, int y1, int x2, int y2) { 
 return Math.abs(x1 - x2) <= 1 && Math.abs(y1 - y2) <= 1;
 }
 
 /** * 判定两点P1(x1,y1)和P2(x2,y2)是否相邻. * * 可用于两个AOI是否相邻判定 * * @param p1 坐标1 * @param p2 坐标2 * @return 如果两坐标相邻返回true, 否则返回false */
 public static boolean adjacent(Point p1, Point p2) { 
 return adjacent(p1.getX(), p1.getY(), p2.getX(), p2.getY());
 }
 
 /** * 向下取整，并返回int值. * * @param a 一个带有小数的数值 * @return 返回向下取整后的int值 */
 public static int floorInt(double a) { 
 return (int) Math.floor(a);
 }
 
 /** * 向下取整，并返回long值. * * @param a 一个带有小数的数值 * @return 返回向下取整后的long值 */
 public static long floorLong(double a) { 
 return (long) Math.floor(a);
 }
 
 /** * 向上取整，并返回int值. * * @param a 一个带有小数的数值 * @return 返回向上取整后的int值 */
 public static int ceilInt(double a) { 
 return (int) Math.ceil(a);
 }
 
 /** * 向上取整，并返回long值. * * @param a 一个带有小数的数值 * @return 返回向上取整后的long值 */
 public static long ceilLong(double a) { 
 return (long) Math.ceil(a);
 }
 
 /** * 4舍5入取整，并返回int值. * * @param a 一个带有小数的数值 * @return 返回向上取整后的int值 */
 public static int roundInt(double a) { 
 return (int) Math.round(a);
 }
 
 /** * 4舍5入取整，并返回long值. * * @param a 一个带有小数的数值 * @return 返回向上取整后的long值 */
 public static long roundLong(double a) { 
 return (long) Math.round(a);
 }
 
 /** * 格式化小数位数的方法. * * 采用了{@link BigDecimal#setScale(int, RoundingMode)}方式来保留小数位数 * 默认舍入方式为4舍5入, 参考{@link RoundingMode#HALF_UP} * * @param value 原始值 * @param newScale 保留小数位数 * @return 返回要被保留指定小数位数的值. */
 public static float formatScale(float value, int newScale) { 
 return formatScale(value, newScale, RoundingMode.HALF_UP);
 }
 
 /** * 格式化小数位数的方法. * * 采用了{@link BigDecimal#setScale(int, RoundingMode)}方式来保留小数位数 * * @param value 原始值 * @param newScale 保留小数位数 * @param mode 被保留位数后舍入方式，参考{@link RoundingMode} * @return 返回要被保留指定小数位数的值. */
 public static float formatScale(float value, int newScale, RoundingMode mode) { 
 return BigDecimal.valueOf(value).setScale(newScale, mode).floatValue();
 }
 
 /** * 格式化小数位数的方法. * * 采用了{@link BigDecimal#setScale(int, RoundingMode)}方式来保留小数位数 * 默认舍入方式为4舍5入, 参考{@link RoundingMode#HALF_UP} * * @param value 原始值 * @param newScale 保留小数位数 * @return 返回要被保留指定小数位数的值. */
 public static double formatScale(double value, int newScale) { 
 return formatScale(value, newScale, RoundingMode.HALF_UP);
 }
 
 /** * 格式化小数位数的方法. * * 采用了{@link BigDecimal#setScale(int, RoundingMode)}方式来保留小数位数 * * @param value 原始值 * @param newScale 保留小数位数 * @param mode 被保留位数后舍入方式，参考{@link RoundingMode} * @return 返回要被保留指定小数位数的值. */
 public static double formatScale(double value, int newScale, RoundingMode mode) { 
 return BigDecimal.valueOf(value).setScale(newScale, mode).doubleValue();
 }
 
 /** * N种资源掠夺最优计算方案. * * 有N种资源，尝试抢其他的部分，但各种资源有一定的比例... * 使用场景：SLG的城池掠夺资源计算 * * @param <T> 资源类型 * @param resources N种资源(参数选用LinkedHashMap，就是想按顺序优先扣前面的...) * @param max 掠夺的最大值 * @param ratio 掠夺比例建议：比例总和在100以内 * @return 一种最优的掠夺结果 */
 public static <T> Map<T, Long> plunder(Map<T, Long> resources, long max, Map<T, Integer> ratio) { 
 final Map<T, Long> result = new HashMap<>(resources.size());
 final int sum = ratio.values().stream().reduce(0, (a, b) -> a + b);
 final long step = max >= sum ? max / Math.min(1000, Math.max(10, ratio.values().stream().reduce(0, (a, b) -> a + b))) : max;
 // 总计要抢的资源量
 long total = max;
 
 while (total > 0) { 
 // 标识是否还有资源可以抢...
 boolean flag = false;
 for (Map.Entry<T, Long> e : resources.entrySet()) { 
 if (e.getValue() <= 0) { 
 continue;
 }
 
 // 只要有一种资源大于0都算还有资源
 flag = true;
 
 // 比例+小步长随便，让抢出来的资源效果更好些...
 long selfStep = step * ratio.getOrDefault(e.getKey(), 1) + RandomUtils.nextLong(step);
 long temp = selfStep > total ? total : selfStep;
 
 // 如果资源不足，就以当前有的抢光就好了...
 if (e.getValue() < temp) { 
 temp = e.getValue();
 }
 
 // 最终本次抢的值
 final long value = temp;
 e.setValue(e.getValue() - value);
 total -= temp;
 result.compute(e.getKey(), (k, v) -> v == null ? value : v.longValue() + value);
 
 // 抢满了就退出啦...
 if (total <= 0) { 
 break;
 }
 }
 
 // 没有资源可以抢时，就直接退出了...
 if (!flag) { 
 break;
 }
 }
 return result;
 }
 
 /** * long类型的数值按比率转化为double类型的值. * * 由于配置表在转化中精度丢失问题，建议策划配置的是long类型的数值，所以就有了这个转化方法。 * 比如：约定XX列为百分比，那配置50，就是50%，等于0.5 * * @param value long类型的数值 * @param ratio 比率 * @return double类型的值 */
 public static double longToDouble(long value, double ratio) { 
 return value / ratio;
 }
 
 /** * long类型的数值以千分比转化为double类型的值. * * 参考 {@link MathUtils#longToDouble(long, double)} * * @param value long类型的数值 * @return double类型的值 */
 public static double permillage(long value) { 
 return MathUtils.longToDouble(value, MathUtils.THOUSAND);
 }
 
 /** * long类型的数值以百分比转化为double类型的值. * * 参考 {@link MathUtils#longToDouble(long, double)} * * @param value long类型的数值 * @return double类型的值 */
 public static double percentage(long value) { 
 return MathUtils.longToDouble(value, MathUtils.HUNDRED);
 }
 }

## 六、controller异步返回 场景：例如下载文件或者上传文件可以用异步返回 ##

@GetMapping("/download")
 public Callable<Token> download(@RequestParam(name = "mediaId") @ApiParam(value = "文件Id") String mediaId) { 
 return () -> { 
 Token token = CommonUtil.getToken(appId, appSecret);
 log.info("token.getAccessToken:{}, mediaId:{}",token.getAccessToken(), mediaId);
 return token ;
 };
 
 }