【Java】几个实用的工具类

实用的工具类

话不多说，直接上代码吧

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;
    }
}