实用的工具类
话不多说,直接上代码吧
mybatisplus分页查询工具类
依赖ThreadLocalUtils用于传递总条数
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import lombok.extern.slf4j.Slf4j;
import java.util.List;
/**
* @author if
* Description: page分页查询帮助类
* date: 2021/11/29 下午 02:42
*/
@Slf4j
public class PageUtils<T> {
private static final Integer COUNT_NUM = 10;
private static final Integer MIN_COUNT = 1;
public static final Integer MAX_COUNT = 100;
private static final String ID = "id";
public static Long getTotal() {
return ThreadLocalUtils.getThenDel(ThreadLocalUtils.TOTAL);
}
public List<T> getList(Integer current, Integer count, IService<T> service, Boolean asc) {
return getList(current, count, service, new QueryWrapper<>(), asc);
}
public List<T> getList(Integer current, Integer count, IService<T> service, QueryWrapper<T> queryWrapper, Boolean asc) {
Page<T> page = buildPage(current, count);
QueryWrapper<T> wrapper = buildWrapper(queryWrapper, asc);
IPage<T> iPage = service.page(page, wrapper);
return getList(iPage);
}
public List<T> getList(Integer current, Integer count, LambdaQueryChainWrapper<T> wrapper) {
Page<T> page = buildPage(current, count);
IPage<T> iPage = wrapper.page(page);
return getList(iPage);
}
public List<T> getList(Integer current, Integer count, BaseMapper<T> mapper, Boolean asc) {
return getList(current, count, mapper, new QueryWrapper<>(), asc);
}
public List<T> getList(Integer current, Integer count, BaseMapper<T> mapper, QueryWrapper<T> queryWrapper, Boolean asc) {
Page<T> page = buildPage(current, count);
QueryWrapper<T> wrapper = buildWrapper(queryWrapper, asc);
IPage<T> iPage = mapper.selectPage(page, wrapper);
return getList(iPage);
}
public List<T> getList(IPage<T> iPage) {
List<T> records = iPage.getRecords();
// 分页未生效,手动分页一下
if (iPage.getTotal() <= 0) {
ThreadLocalUtils.set(ThreadLocalUtils.TOTAL, (long) iPage.getRecords().size());
int page = (int) iPage.getCurrent();
int pageSize = (int) iPage.getSize();
page = (page - 1) * pageSize;
return records.subList(page, page + Math.min(pageSize, records.size()));
}
ThreadLocalUtils.set(ThreadLocalUtils.TOTAL, iPage.getTotal());
return records;
}
public static <T> Page<T> buildPage(Integer current, Integer count) {
// 1 <= count <= 100
count = (count == null || count < MIN_COUNT || count > MAX_COUNT) ? COUNT_NUM : count;
current = current == null ? 1 : current;
//Page构造器中,current<=1时会默认给1
return new Page<>(current, count, true);
}
/**
* 判断是否正序排列
* 如果排列依据为空,自动按照id排序,反之按照排列依据排序
*/
public QueryWrapper<T> buildWrapper(QueryWrapper<T> queryWrapper, Boolean asc) {
return asc ? queryWrapper.orderByAsc(ID) : queryWrapper.orderByDesc(ID);
}
}
ThreadLocal工具类
import org.apache.commons.lang3.StringUtils;
import org.springframework.util.CollectionUtils;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
/**
* @author if
* Description: ThreadLocal工具类
* date: 2021/11/29 下午 02:42
*/
@SuppressWarnings("unused")
public final class ThreadLocalUtils {
private static final ThreadLocal<Map<String, Object>> THREAD_LOCAL =
ThreadLocal.withInitial(() -> new ConcurrentHashMap<>(16));
public static final String TOTAL = "total";
/**
* 获取到ThreadLocal中值
*
* @return ThreadLocal存储的是Map
*/
public static Map<String, Object> getThreadLocal() {
return THREAD_LOCAL.get();
}
/**
* 获取完后删除对应值
*
* @param key
* @param <T>
* @return
*/
public static <T> T getThenDel(String key) {
T t = get(key, null);
delete(key);
return t;
}
/**
* 从ThreadLocal中的Map获取值
*
* @param key Map中的key
* @param <T> Map中的value的类型
* @return Map中的value值 可能为空
*/
public static <T> T get(String key) {
return get(key, null);
}
/**
* 从ThreadLocal中的Map获取值
*
* @param key Map中的key
* @param defaultValue Map中的value的为null 是 的默认值
* @param <T> Map中的value的类型
* @return Map中的value值 可能为空
*/
@SuppressWarnings("unchecked")
public static <T> T get(String key, T defaultValue) {
Map<String, Object> map = THREAD_LOCAL.get();
if (CollectionUtils.isEmpty(map)) {
return null;
}
return (T) Optional.ofNullable(map.get(key)).orElse(defaultValue);
}
/**
* ThreadLocal中的Map设置值
*
* @param key Map中的key
* @param value Map中的value
*/
public static void set(String key, Object value) {
Map<String, Object> map = THREAD_LOCAL.get();
map.put(key, value);
}
/**
* ThreadLocal中的Map 添加Map
*
* @param keyValueMap 参数map
*/
public static void set(Map<String, Object> keyValueMap) {
Map<String, Object> map = THREAD_LOCAL.get();
map.putAll(keyValueMap);
}
/**
* 删除ThreadLocal中的Map 中的value
*
* @param key Map中的key
*/
public static void delete(String key) {
Map<String, Object> map = THREAD_LOCAL.get();
if (CollectionUtils.isEmpty(map)) {
return;
}
map.remove(key);
}
/**
* 删除ThreadLocal中的Map
*/
public static void remove() {
THREAD_LOCAL.remove();
}
/**
* 从ThreadLocal中的Map获取值 根据可key的前缀
*
* @param prefix key 的前缀
* @param <T> Map中的value的类型
* @return 符合条件的Map
*/
@SuppressWarnings("unchecked")
public static <T> Map<String, T> fetchVarsByPrefix(String prefix) {
Map<String, T> vars = new HashMap<>(16);
if (StringUtils.isBlank(prefix)) {
return vars;
}
Map<String, Object> map = THREAD_LOCAL.get();
if (CollectionUtils.isEmpty(map)) {
return vars;
}
return map.entrySet().stream().filter(test -> test.getKey().startsWith(prefix))
.collect(Collectors.toMap(Map.Entry::getKey, time -> (T) time.getValue()));
}
/**
* 删除ThreadLocal中的Map 中的Value 按 Map中的Key的前缀
*
* @param prefix Map中的Key的前缀
*/
public static void deleteVarsByPrefix(String prefix) {
if (StringUtils.isBlank(prefix)) {
return;
}
Map<String, Object> map = THREAD_LOCAL.get();
if (CollectionUtils.isEmpty(map)) {
return;
}
map.keySet().stream().filter(o -> o.startsWith(prefix)).collect(Collectors.toSet()).forEach(map::remove);
}
}
时间日期处理工具类
值得一提的是,本工具类采用ThreadLocal隔离了不同线程之间的SimpleDateFormat对象,保证线程安全
其实也可以使用本身就是线程安全的DateTimeFormatter类
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DateFormat;
import java.time.Duration;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* @Author if
* @Description: 时间日期工具类并通过ThreadLocal解决DateFormat的线程安全问题
* ThreadLocal通过保存各个线程的SimpleDateFormat类对象的副本
* 使每个线程在运行时,各自使用自身绑定的SimpleDateFormat对象
* 互不干扰,执行性能比较高,推荐在高并发的生产环境使用。
* @Date 2022-01-08 下午 03:20
*/
public class TimeUtil {
/**
* 时间格式(yyyy-MM-dd)
*/
public final static String DATE_PATTERN = "yyyy-MM-dd";
private static final ThreadLocal<DateFormat> DATE_LOCAL = ThreadLocal.withInitial(() -> new SimpleDateFormat(DATE_PATTERN));
/**
* 时间格式(yyyy-MM-dd HH:mm:ss)
*/
public final static String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
private static final ThreadLocal<DateFormat> DATE_TIME_LOCAL = ThreadLocal.withInitial(() -> new SimpleDateFormat(DATE_TIME_PATTERN));
/**
* 日期格式化
*
* @param date 日期
* @return 默认返回yyyy-MM-dd HH:mm:ss格式日期
*/
public static String format(Date date) {
return format(date, DATE_TIME_PATTERN);
}
/**
* 计算相差分钟数,并保留两位小数
*
* @param start 起始时间
* @param end 截止时间
* @return 保留两位小数
*/
public static Double getSubMinutes(Date start, Date end) {
long seconds = getSubSeconds(start, end);
BigDecimal b = new BigDecimal(seconds / 60.0D);
return b.setScale(2, RoundingMode.HALF_UP).doubleValue();
}
/**
* 计算相差秒数
*
* @param start 起始时间
* @param end 截止时间
* @return 相差秒数
*/
public static Long getSubSeconds(Date start, Date end) {
LocalDateTime startTime = LocalDateTime.parse(format(start), DateTimeFormatter.ofPattern(DATE_TIME_PATTERN));
LocalDateTime endTime = LocalDateTime.parse(format(end), DateTimeFormatter.ofPattern(DATE_TIME_PATTERN));
return Duration.between(startTime, endTime).toMillis() / 1000;
}
/**
* 日期格式化
*
* @param date 日期
* @param pattern 格式,如:DateUtils.DATE_TIME_PATTERN
* @return 返回yyyy-MM-dd格式日期
*/
public static String format(Date date, String pattern) {
if (date == null) {
return null;
}
switch (pattern) {
case (DATE_PATTERN):
return DATE_LOCAL.get().format(date);
case (DATE_TIME_PATTERN):
return DATE_TIME_LOCAL.get().format(date);
default:
return null;
}
}
/**
* 判断今天是否在两个日期范围之内
*
* @param startTime 开始时间
* @param endTime 结束时间
*/
public static Boolean isTodayBetweenTwoDays(Date startTime, Date endTime) {
return isSomeDayBetweenTwoDays(new Date(),startTime,endTime);
}
/**
* 判断某个日期是否在两个日期范围之内
*
* @param someTime 某个日期
* @param startTime 开始时间
* @param endTime 结束时间
*/
public static Boolean isSomeDayBetweenTwoDays(Date someTime, Date startTime, Date endTime) {
return someTime.getTime() >= startTime.getTime() && someTime.getTime() <= endTime.getTime();
}
}
servlet请求工具类
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @author if
* Description: servlet请求工具类
* date: 2021/11/29 下午 02:42
*/
public class ServletUtils {
private static final String TOKEN="token";
/**
* 获取request
*/
public static HttpServletRequest getRequest() {
return getRequestAttributes().getRequest();
}
/**
* 获取response
*/
public static HttpServletResponse getResponse() {
return getRequestAttributes().getResponse();
}
/**
* 获取请求头中的token
*/
public static String getToken(){
return getRequestAttributes().getRequest().getHeader(TOKEN);
}
/**
* 获取请求属性
*/
public static ServletRequestAttributes getRequestAttributes() {
RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
return (ServletRequestAttributes) attributes;
}
}
Base64加密解密工具类
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
/**
* Base64工具
* @author dolyw.com
* @date 2018/8/21 15:14
*/
public class Base64ConvertUtil {
private Base64ConvertUtil() {}
/**
* 加密JDK1.8
* @param str
* @return java.lang.String
* @author dolyw.com
* @date 2018/8/21 15:28
*/
public static String encode(String str) throws UnsupportedEncodingException {
byte[] encodeBytes = Base64.getEncoder().encode(str.getBytes(StandardCharsets.UTF_8));
return new String(encodeBytes);
}
/**
* 解密JDK1.8
* @param str
* @return java.lang.String
* @author dolyw.com
* @date 2018/8/21 15:28
*/
public static String decode(String str) throws UnsupportedEncodingException {
byte[] decodeBytes = Base64.getDecoder().decode(str.getBytes(StandardCharsets.UTF_8));
return new String(decodeBytes);
}
}
获取IP工具类
import javax.servlet.http.HttpServletRequest;
import java.net.InetAddress;
/**
* @Author if
* @Description: 获取ip工具类
* @Date 2022-01-08 下午 03:20
*/
public class IpUtils {
private static final String UNKNOWN = "unknown";
private static final String LOCAL = "127.0.0.1";
public static String getIpAddr(HttpServletRequest request) {
String ipAddress;
try {
ipAddress = request.getHeader("x-forwarded-for");
if (ipAddress == null || ipAddress.length() == 0 || UNKNOWN.equalsIgnoreCase(ipAddress)) {
ipAddress = request.getHeader("Proxy-Client-IP");
}
if (ipAddress == null || ipAddress.length() == 0 || UNKNOWN.equalsIgnoreCase(ipAddress)) {
ipAddress = request.getHeader("WL-Proxy-Client-IP");
}
if (ipAddress == null || ipAddress.length() == 0 || UNKNOWN.equalsIgnoreCase(ipAddress)) {
ipAddress = request.getRemoteAddr();
if (LOCAL.equals(ipAddress)) {
// 根据网卡取本机配置的IP
ipAddress = InetAddress.getLocalHost().getHostAddress();
}
}
// 对于通过多个代理的情况,第一个IP为客户端真实IP,多个IP按照','分割
// "***.***.***.***".length()
if (ipAddress != null && ipAddress.length() > 15) {
// = 15
if (ipAddress.indexOf(",") > 0) {
ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
}
}
} catch (Exception e) {
ipAddress="";
}
return ipAddress;
}
}