java工具类

已于 2024-07-24 11:34:03 修改
阅读量436 收藏 3
点赞数 10
文章标签： java 工具类
于 2024-07-23 15:07:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45766875/article/details/140636369
版权

1.日期格式化

日期格式化记得想到joda-time依赖(DateTime)

package com.atguigu.utils;  

import java.text.SimpleDateFormat;  

import java.util.*;  

/**  
  - 日期操作工具类 */public class DateUtils {  

  /**  

  - 日期转换-  String -> Date * * @param dateString 字符串时间  
  - @return Date类型信息  
  - @throws Exception 抛出异常  

  */ public static Date parseString2Date(String dateString) throws Exception {  

  if (dateString == null) {  

  return null;  

  }  

  return parseString2Date(dateString, "yyyy-MM-dd");  

  }  

  /**  

  - 日期转换-  String -> Date * * @param dateString 字符串时间  
  - @param pattern 格式模板  
  - @return Date类型信息  
  - @throws Exception 抛出异常  

  */ public static Date parseString2Date(String dateString, String pattern) throws Exception {  

  if (dateString == null) {  

  return null;  

  }  

  SimpleDateFormat sdf = new SimpleDateFormat(pattern);  

  Date date = sdf.parse(dateString);  

  return date;  

  }  

  /**  

  - 日期转换 Date -> String * * @param date Date类型信息  
  - @return 字符串时间  
  - @throws Exception 抛出异常  

  */ public static String parseDate2String(Date date) throws Exception {  

  if (date == null) {  

  return null;  

  }  

  return parseDate2String(date, "yyyy-MM-dd");  

  }  

  /**  

  - 日期转换 Date -> String * * @param date Date类型信息  
  - @param pattern 格式模板  
  - @return 字符串时间  
  - @throws Exception 抛出异常  

  */ public static String parseDate2String(Date date, String pattern) throws Exception {  

  if (date == null) {  

  return null;  

  }  

  SimpleDateFormat sdf = new SimpleDateFormat(pattern);  

  String strDate = sdf.format(date);  

  return strDate;  

  }  

  /**  

  - 获取当前日期的本周一是几号 * * @return 本周一的日期  

  */ public static Date getThisWeekMonday() {  

  Calendar cal = Calendar.getInstance();  

  cal.setTime(new Date());  

  // 获得当前日期是一个星期的第几天  

  int dayWeek = cal.get(Calendar.DAY_OF_WEEK);  

  if (1 == dayWeek) {  

  cal.add(Calendar.DAY_OF_MONTH, -1);  

  }  

  // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一  

  cal.setFirstDayOfWeek(Calendar.MONDAY);  

  // 获得当前日期是一个星期的第几天  

  int day = cal.get(Calendar.DAY_OF_WEEK);  

  // 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值  

  cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);  

  return cal.getTime();  

  }  

  /**  

  - 获取当前日期周的最后一天 * * @return 当前日期周的最后一天  

  */ public static Date getSundayOfThisWeek() {  

  Calendar c = Calendar.getInstance();  

  int dayOfWeek = c.get(Calendar.DAY_OF_WEEK) - 1;  

  if (dayOfWeek == 0) {  

  dayOfWeek = 7;  

  }  

  c.add(Calendar.DATE, -dayOfWeek + 7);  

  return c.getTime();  

  }  

  /**  

  - 根据日期区间获取月份列表 * * @param minDate 开始时间  
  - @param maxDate 结束时间  
  - @return 月份列表  
  - @throws Exception  

  */  

  public static List<String> getMonthBetween(String minDate, String maxDate, String format) throws Exception {  

  ArrayList<String> result = new ArrayList<>();  

  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");  

  Calendar min = Calendar.getInstance();  

  Calendar max = Calendar.getInstance();  

  min.setTime(sdf.parse(minDate));  

  min.set(min.get(Calendar.YEAR), min.get(Calendar.MONTH), 1);  

  max.setTime(sdf.parse(maxDate));  

  max.set(max.get(Calendar.YEAR), max.get(Calendar.MONTH), 2);  

  SimpleDateFormat sdf2 = new SimpleDateFormat(format);  

  Calendar curr = min;  

  while (curr.before(max)) {  

  result.add(sdf2.format(curr.getTime()));  

  curr.add(Calendar.MONTH, 1);  

  }  

  return result;  

  }  

  /**  

  - 根据日期获取年度中的周索引 * * @param date 日期  
  - @return 周索引  
  - @throws Exception  

  */  

  public static Integer getWeekOfYear(String date) throws Exception {  

  Date useDate = parseString2Date(date);  

  Calendar cal = Calendar.getInstance();  

  cal.setTime(useDate);  

  return cal.get(Calendar.WEEK_OF_YEAR);  

  }  

  /**  

  - 根据年份获取年中周列表 * * @param year 年分  
  - @return 周列表  
  - @throws Exception  

  */  

  public static Map<Integer, String> getWeeksOfYear(String year) throws Exception {  

  Date useDate = parseString2Date(year, "yyyy");  

  Calendar cal = Calendar.getInstance();  

  cal.setTime(useDate);  

  //获取年中周数量  

  int weeksCount = cal.getWeeksInWeekYear();  

  Map<Integer, String> mapWeeks = new HashMap<>(55);  

  for (int i = 0; i < weeksCount; i++) {  

  cal.get(Calendar.DAY_OF_YEAR);  

  mapWeeks.put(i + 1, parseDate2String(getFirstDayOfWeek(cal.get(Calendar.YEAR), i)));  

  }  

  return mapWeeks;  

  }  

  /**  

  - 获取某年的第几周的开始日期 * * @param year 年分  
  - @param week 周索引  
  - @return 开始日期  
  - @throws Exception  

  */  

  public static Date getFirstDayOfWeek(int year, int week) throws Exception {  

  Calendar c = new GregorianCalendar();  

  c.set(Calendar.YEAR, year);  

  c.set(Calendar.MONTH, Calendar.JANUARY);  

  c.set(Calendar.DATE, 1);  

  Calendar cal = (GregorianCalendar) c.clone();  

  cal.add(Calendar.DATE, week * 7);  

  return getFirstDayOfWeek(cal.getTime());  

  }  

  /**  

  - 获取某年的第几周的结束日期 * * @param year 年份  
  - @param week 周索引  
  - @return 结束日期  
  - @throws Exception  

  */  

  public static Date getLastDayOfWeek(int year, int week) throws Exception {  

  Calendar c = new GregorianCalendar();  

  c.set(Calendar.YEAR, year);  

  c.set(Calendar.MONTH, Calendar.JANUARY);  

  c.set(Calendar.DATE, 1);  

  Calendar cal = (GregorianCalendar) c.clone();  

  cal.add(Calendar.DATE, week * 7);  

  return getLastDayOfWeek(cal.getTime());  

  }  

  /**  

  - 获取当前时间所在周的开始日期 * * @param date 当前时间  
  - @return 开始时间  

  */ public static Date getFirstDayOfWeek(Date date) {  

  Calendar c = new GregorianCalendar();  

  c.setFirstDayOfWeek(Calendar.SUNDAY);  

  c.setTime(date);  

  c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek());  

  return c.getTime();  

  }  

  /**  

  - 获取当前时间所在周的结束日期 * * @param date 当前时间  
  - @return 结束日期  

  */ public static Date getLastDayOfWeek(Date date) {  

  Calendar c = new GregorianCalendar();  

  c.setFirstDayOfWeek(Calendar.SUNDAY);  

  c.setTime(date);  

  c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6);  

  return c.getTime();  

  }  

  //获得上周一的日期  

  public static Date geLastWeekMonday(Date date) {  

  Calendar cal = Calendar.getInstance();  

  cal.setTime(getThisWeekMonday(date));  

  cal.add(Calendar.DATE, -7);  

  return cal.getTime();  

  }  

  //获得本周一的日期  

  public static Date getThisWeekMonday(Date date) {  

  Calendar cal = Calendar.getInstance();  

  cal.setTime(date);  

  // 获得当前日期是一个星期的第几天  

  int dayWeek = cal.get(Calendar.DAY_OF_WEEK);  

  if (1 == dayWeek) {  

  cal.add(Calendar.DAY_OF_MONTH, -1);  

  }  

  // 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一  

  cal.setFirstDayOfWeek(Calendar.MONDAY);  

  // 获得当前日期是一个星期的第几天  

  int day = cal.get(Calendar.DAY_OF_WEEK);  

  // 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值  

  cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);  

  return cal.getTime();  

  }  

  //获得下周一的日期  

  public static Date getNextWeekMonday(Date date) {  

  Calendar cal = Calendar.getInstance();  

  cal.setTime(getThisWeekMonday(date));  

  cal.add(Calendar.DATE, 7);  

  return cal.getTime();  

  }  

  //获得今天日期  

  public static Date getToday(){  

  return new Date();  

  }  

  //获得本月一日的日期  

  public static Date getFirstDay4ThisMonth(){  

  Calendar calendar = Calendar.getInstance();  

  calendar.set(Calendar.DAY_OF_MONTH,1);  

  return calendar.getTime();  

  }  

  //获得本月最后一日的日期  

  public static Date getLastDay4ThisMonth(){  

  Calendar calendar = Calendar.getInstance();  

  calendar.add(Calendar.MONTH, 1);  

  calendar.set(Calendar.DAY_OF_MONTH, 0);  

  return calendar.getTime();  

  }  

  /**  

  - 获取指定月份的最后一天  String lastDayOfMonth = getLastDayOfMonth("2019-08"); * @param yearMonth  
  - @return  

  */  

  public static String getLastDayOfMonth(String yearMonth) {  

  int year = Integer.parseInt(yearMonth.split("-")[0]); //年  

  int month = Integer.parseInt(yearMonth.split("-")[1]); //月  

  Calendar cal = Calendar.getInstance();  

  // 设置年份  

  cal.set(Calendar.YEAR, year);  

  // 设置月份  

  // cal.set(Calendar.MONTH, month - 1); cal.set(Calendar.MONTH, month); //设置当前月的上一个月  

  // 获取某月最大天数 //int lastDay = cal.getActualMaximum(Calendar.DATE); int lastDay = cal.getMinimum(Calendar.DATE); //获取月份中的最小值，即第一天  

  // 设置日历中月份的最大天数 [//cal.set](//cal.set)(Calendar.DAY_OF_MONTH, lastDay); cal.set(Calendar.DAY_OF_MONTH, lastDay - 1); //上月的第一天减去1就是当月的最后一天  

  // 格式化日期 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");  

  return sdf.format(cal.getTime());  

  }  

  public static void main(String[] args) {  

  try {  

  System.out.println("本周一" + parseDate2String(getThisWeekMonday()));  

  System.out.println("本月一日" + parseDate2String(getFirstDay4ThisMonth()));  

  } catch (Exception e) {  

  e.printStackTrace();  

  }  

  }}

2.MD5加密

import java.math.BigInteger;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

public class MD5Utils {

  /**
    - 使用md5的算法进行加密

    */

  public static String md5(String plainText) {

    byte[] secretBytes = null;

    try {

      secretBytes = MessageDigest.getInstance("md5").digest(

        plainText.getBytes());

    } catch (NoSuchAlgorithmException e) {

      throw new RuntimeException("没有md5这个算法！");

    }

    String md5code = new BigInteger(1, secretBytes).toString(16);// 16进制数字

    // 如果生成数字未满32位，需要前面补0

    for (int i = 0; i < 32 - md5code.length(); i++) {

      md5code = "0" + md5code;

    }

    return md5code;

  }

}

3.批量上传文件Poi

import java.io.FileNotFoundException;  

import java.io.IOException;  

import java.io.InputStream;  

import java.text.SimpleDateFormat;  

import java.util.ArrayList;  

import java.util.List;  

import org.apache.poi.hssf.usermodel.HSSFWorkbook;  

import org.apache.poi.ss.usermodel.Cell;  

import org.apache.poi.ss.usermodel.Row;  

import org.apache.poi.ss.usermodel.Sheet;  

import org.apache.poi.ss.usermodel.Workbook;  

import org.apache.poi.xssf.usermodel.XSSFWorkbook;  

import org.springframework.web.multipart.MultipartFile;  

public class POIUtils {  

  private final static String xls = "xls";  

  private final static String xlsx = "xlsx";  

  private final static String DATE_FORMAT = "yyyy/MM/dd";  

  /**  

  - 读入excel文件，解析后返回 * @param file  
  - @throws IOException  

  */  

  public static List<String[]> readExcel(MultipartFile file) throws IOException {  

  //检查文件  

  checkFile(file);  

  //获得Workbook工作薄对象  

  Workbook workbook = getWorkBook(file);  

  //创建返回对象，把每行中的值作为一个数组，所有行作为一个集合返回  

  List<String[]> list = new ArrayList<String[]>();  

  if(workbook != null){  

  for(int sheetNum = 0;sheetNum < workbook.getNumberOfSheets();sheetNum++){  

  //获得当前sheet工作表  

  Sheet sheet = workbook.getSheetAt(sheetNum);  

  if(sheet == null){  

  continue;  

  }  

  //获得当前sheet的开始行  

  int firstRowNum = sheet.getFirstRowNum();  

  //获得当前sheet的结束行  

  int lastRowNum = sheet.getLastRowNum();  

  //循环除了第一行的所有行  

  for(int rowNum = firstRowNum+1;rowNum <= lastRowNum;rowNum++){  

  //获得当前行  

  Row row = sheet.getRow(rowNum);  

  if(row == null){  

  continue;  

  }  

  //获得当前行的开始列  

  int firstCellNum = row.getFirstCellNum();  

  //获得当前行的列数  

  int lastCellNum = row.getPhysicalNumberOfCells();  

  String[] cells = new String[row.getPhysicalNumberOfCells()];  

  //循环当前行  

  for(int cellNum = firstCellNum; cellNum < lastCellNum;cellNum++){  

  Cell cell = row.getCell(cellNum);  

  cells[cellNum] = getCellValue(cell);  

  }  

  list.add(cells);  

  }  

  } workbook.close();  

  }  

  return list;  

  }  

  //校验文件是否合法  

  public static void checkFile(MultipartFile file) throws IOException{  

  //判断文件是否存在  

  if(null == file){  

  throw new FileNotFoundException("文件不存在！");  

  }  

  //获得文件名  

  String fileName = file.getOriginalFilename();  

  //判断文件是否是excel文件  

  if(!fileName.endsWith(xls) && !fileName.endsWith(xlsx)){  

  throw new IOException(fileName + "不是excel文件");  

  }  

  } public static Workbook getWorkBook(MultipartFile file) {  

  //获得文件名  

  String fileName = file.getOriginalFilename();  

  //创建Workbook工作薄对象，表示整个excel  

  Workbook workbook = null;  

  try {  

  //获取excel文件的io流  

  InputStream is = file.getInputStream();  

  //根据文件后缀名不同(xls和xlsx)获得不同的Workbook实现类对象  

  if(fileName.endsWith(xls)){  

  //2003  

  workbook = new HSSFWorkbook(is);  

  }else if(fileName.endsWith(xlsx)){  

  //2007  

  workbook = new XSSFWorkbook(is);  

  }  

  } catch (IOException e) {  

  e.printStackTrace();  

  }  

  return workbook;  

  }  

  public static String getCellValue(Cell cell){  

  String cellValue = "";  

  if(cell == null){  

  return cellValue;  

  }  

  //如果当前单元格内容为日期类型，需要特殊处理  

  String dataFormatString = cell.getCellStyle().getDataFormatString();  

  if(dataFormatString.equals("m/d/yy")){  

  cellValue = new SimpleDateFormat(DATE_FORMAT).format(cell.getDateCellValue());  

  return cellValue;  

  }  

  //把数字当成String来读，避免出现1读成1.0的情况  

  if(cell.getCellType() == Cell.CELL_TYPE_NUMERIC){  

  cell.setCellType(Cell.CELL_TYPE_STRING);  

  }  

  //判断数据的类型  

  switch (cell.getCellType()){  

  case Cell.CELL_TYPE_NUMERIC: //数字  

  cellValue = String.valueOf(cell.getNumericCellValue());  

  break;  

  case Cell.CELL_TYPE_STRING: //字符串  

  cellValue = String.valueOf(cell.getStringCellValue());  

  break;  

  case Cell.CELL_TYPE_BOOLEAN: //Boolean  

  cellValue = String.valueOf(cell.getBooleanCellValue());  

  break;  

  case Cell.CELL_TYPE_FORMULA: //公式  

  cellValue = String.valueOf(cell.getCellFormula());  

  break;  

  case Cell.CELL_TYPE_BLANK: //空值  

  cellValue = "";  

  break;  

  case Cell.CELL_TYPE_ERROR: //故障  

  cellValue = "非法字符";  

  break;  

  default:  

    cellValue = "未知类型";  

  break;  

  }  

  return cellValue;  

  }  

}

4.·返回结果类封装


import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

/**
 * 全局统一返回结果类
 *
 */
@Data
@ApiModel(value = "全局统一返回结果")
public class Result<T> {

    @ApiModelProperty(value = "返回码")
    private Integer code;

    @ApiModelProperty(value = "返回消息")
    private String message;

    @ApiModelProperty(value = "返回数据")
    private T data;

    public Result(){}

    // 返回数据
    protected static <T> Result<T> build(T data) {
        Result<T> result = new Result<T>();
        if (data != null)
            result.setData(data);
        return result;
    }

    public static <T> Result<T> build(T body, ResultCodeEnum resultCodeEnum) {
        Result<T> result = build(body);
        result.setCode(resultCodeEnum.getCode());
        result.setMessage(resultCodeEnum.getMessage());
        return result;
    }

    public static<T> Result<T> ok(){
        return Result.ok(null);
    }

    /**
     * 操作成功
     * @param data
     * @param <T>
     * @return
     */
    public static<T> Result<T> ok(T data){
        Result<T> result = build(data);
        return build(data, ResultCodeEnum.SUCCESS);
    }

    public static<T> Result<T> fail(){
        return Result.fail(null);
    }

    /**
     * 操作失败
     * @param data
     * @param <T>
     * @return
     */
    public static<T> Result<T> fail(T data){
        Result<T> result = build(data);
        return build(data, ResultCodeEnum.FAIL);
    }

    public Result<T> message(String msg){
        this.setMessage(msg);
        return this;
    }

    public Result<T> code(Integer code){
        this.setCode(code);
        return this;
    }

    public boolean isOk() {
        if(this.getCode().intValue() == ResultCodeEnum.SUCCESS.getCode().intValue()) {
            return true;
        }
        return false;
    }
}

5.随机生成验证码

import java.util.Random;

/**
 * 随机生成验证码工具类
 */
public class ValidateCodeUtils {
    /**
     * 随机生成验证码
     * @param length 长度为4位或者6位
     * @return
     */
    public static Integer generateValidateCode(int length){
        Integer code =null;
        if(length == 4){
            code = new Random().nextInt(9999);//生成随机数，最大为9999
            if(code < 1000){
                code = code + 1000;//保证随机数为4位数字
            }
        }else if(length == 6){
            code = new Random().nextInt(999999);//生成随机数，最大为999999
            if(code < 100000){
                code = code + 100000;//保证随机数为6位数字
            }
        }else{
            throw new RuntimeException("只能生成4位或6位数字验证码");
        }
        return code;
    }

    /**
     * 随机生成指定长度字符串验证码
     * @param length 长度
     * @return
     */
    public static String generateValidateCode4String(int length){
        Random rdm = new Random();
        String hash1 = Integer.toHexString(rdm.nextInt());
        String capstr = hash1.substring(0, length);
        return capstr;
    }
}

6.获取ip地址工具类



import org.springframework.http.HttpHeaders;
import org.springframework.http.server.reactive.ServerHttpRequest;

import javax.servlet.http.HttpServletRequest;
import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * 获取ip地址
 */
public class IpUtil {

    public static String getIpAddress(HttpServletRequest request) {
        String ipAddress = null;
        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 (ipAddress.equals("127.0.0.1")) {
                    // 根据网卡取本机配置的IP
                    InetAddress inet = null;
                    try {
                        inet = InetAddress.getLocalHost();
                    } catch (UnknownHostException e) {
                        e.printStackTrace();
                    }
                    ipAddress = inet.getHostAddress();
                }
            }
            // 对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
            if (ipAddress != null && ipAddress.length() > 15) { // "***.***.***.***".length()
                // = 15
                if (ipAddress.indexOf(",") > 0) {
                    ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
                }
            }
        } catch (Exception e) {
            ipAddress="";
        }
        // ipAddress = this.getRequest().getRemoteAddr();

        return ipAddress;
    }
    // 网关中获取Ip地址
    public static String getGatwayIpAddress(ServerHttpRequest request) {
        HttpHeaders headers = request.getHeaders();
        String ip = headers.getFirst("x-forwarded-for");
        if (ip != null && ip.length() != 0 && !"unknown".equalsIgnoreCase(ip)) {
            // 多次反向代理后会有多个ip值，第一个ip才是真实ip
            if (ip.indexOf(",") != -1) {
                ip = ip.split(",")[0];
            }
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = headers.getFirst("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = headers.getFirst("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = headers.getFirst("HTTP_CLIENT_IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = headers.getFirst("HTTP_X_FORWARDED_FOR");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = headers.getFirst("X-Real-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddress().getAddress().getHostAddress();
        }
        return ip;
    }
}

7.从请求的token里面获取用户信息(依赖jwt)



import com.atguigu.yygh.util.JwtHelper;

import javax.servlet.http.HttpServletRequest;


public class AuthContextHolder {
    //获取当前用户id
    public static Long getUserId(HttpServletRequest request) {
        //从header获取token
        String token = request.getHeader("token");
        //jwt从token获取userid
        Long userId = JwtHelper.getUserId(token);
        return userId;
    }
    //获取当前用户名称
    public static String getUserName(HttpServletRequest request) {
        //从header获取token
        String token = request.getHeader("token");
        //jwt从token获取userid
        String userName = JwtHelper.getUserName(token);
        return userName;
    }
}

8.Jwt创建token

<dependencies>

<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.7.0</version>
</dependency>

</dependencies>




import io.jsonwebtoken.*;
import org.springframework.util.StringUtils;

import java.util.Date;

public class JwtHelper {

    private static long tokenExpiration = 24*60*60*1000;

    private static String tokenSignKey = "123456";



    public static String createToken(Long userId, String userName) {

        String token = Jwts.builder()

                .setSubject("YYGH-USER")

                .setExpiration(new Date(System.currentTimeMillis() + tokenExpiration))

                .claim("userId", userId)

                .claim("userName", userName)

                .signWith(SignatureAlgorithm.HS512, tokenSignKey)

                .compressWith(CompressionCodecs.GZIP)

                .compact();

        return token;

    }
/**
* @Description: 根据token解析用户id
* @Author: Mr.Zhan
* @param:
* @return:
*/
    public static Long getUserId(String token) {

        if(StringUtils.isEmpty(token)) return null;

        Jws<Claims> claimsJws = Jwts.parser().setSigningKey(tokenSignKey).parseClaimsJws(token);

        Claims claims = claimsJws.getBody();

        Integer userId = (Integer)claims.get("userId");

        return userId.longValue();

    }

    /**
    * @Description: 根据token解析用户名
    * @Author: Mr.Zhan
    * @param:
    * @return:
    */
    public static String getUserName(String token) {

        if(StringUtils.isEmpty(token)) return "";

        Jws<Claims> claimsJws

                = Jwts.parser().setSigningKey(tokenSignKey).parseClaimsJws(token);

        Claims claims = claimsJws.getBody();

        return (String)claims.get("userName");

    }

    public static void main(String[] args) {

        String token = JwtHelper.createToken(1L, "55");

        System.out.println(token);

        System.out.println(JwtHelper.getUserId(token));

        System.out.println(JwtHelper.getUserName(token));

    }
}

9.redisutils

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.stereotype.Component;

import org.springframework.util.CollectionUtils;



import java.util.Collection;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.concurrent.TimeUnit;



/**

 * @apiNote Redis工具类，便捷开发

 * @date 2022/3/2 17:13

 */

@Component

public class RedisUtil {



    @Autowired

    private RedisTemplate<String, Object> redisTemplate;



    // =============================================================== common



    /**

     * 指定缓存失效时间

     *

     * @param key  键

     * @param time 时间（秒）

     * @return boolean 设值是否成功

     */

    public boolean expire(String key, long time) {

        try {

            if (time > 0) {

                redisTemplate.expire(key, time, TimeUnit.SECONDS);

            }

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        } finally {

        }

    }



    /**

     * 获取键过期时间

     *

     * @param key 键

     * @return long 时间（秒） 返回为0时，代表永久有效

     */

    public long getExpire(String key) {

        return redisTemplate.getExpire(key, TimeUnit.SECONDS);

    }



    /**

     * 根据key获取过期时间

     *

     * @param key 键

     * @return boolean

     * @date 2022/3/2 17:21

     */

    public boolean hasKey(String key) {

        try {

            return redisTemplate.hasKey(key);

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }



    /**

     * 删除缓存

     *

     * @param key 一个或者多个键

     * @date 2022/3/2 17:24

     */

    public void del(String... key) {

        if (key != null && key.length > 0) {

            if (key.length == 1) {

                redisTemplate.delete(key[0]);

            } else {

                redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));

            }

        }

    }



    // =============================================================== String



    /**

     * 获取缓存中的key

     *

     * @param key 键

     * @return java.lang.Object

     * @date 2022/3/2 17:26

     */

    public Object get(String key) {

        return key == null ? null : redisTemplate.opsForValue().get(key);

    }



    /**

     * 放入缓存信息

     *

     * @param key   键

     * @param value 值

     * @return boolean 是否成功

     * @date 2022/3/2 17:29

     */

    public boolean set(String key, Object value) {

        try {

            redisTemplate.opsForValue().set(key, value);

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }



    /**

     * 放入缓存信息，并设置过期时间

     *

     * @param key   键

     * @param value 值

     * @param time  时间（秒）；若过期时间<=0,则设置为无限期

     * @return boolean

     * @date 2022/3/2 17:32

     */

    public boolean set(String key, Object value, long time) {

        try {

            if (time > 0) {

                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);

            } else {

                redisTemplate.opsForValue().set(key, value);

            }

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }



    /**

     * 通过递增因子，递增key的值

     *

     * @param key   键

     * @param delta 递增因子（大于0）

     * @return long

     * @date 2022/3/2 17:38

     */

    public long incr(String key, long delta) {

        if (delta < 0) {

            throw new RuntimeException("The increment factor must be greater than 0");

        }

        return redisTemplate.opsForValue().increment(key, delta);

    }



    /**

     * 通过递减因子，递减key的值

     *

     * @param key   键

     * @param delta 递减因子

     * @return long

     * @date 2022/3/2 17:41

     */

    public long decr(String key, long delta) {

        if (delta < 0) {

            throw new RuntimeException("The decrement factor must be greater than 0");

        }

        return redisTemplate.opsForValue().decrement(key, delta);

    }



    // ======================================================================== Map



    /**

     * 通过key的item，获取hash的值

     *

     * @param key  键 （不能为空）

     * @param item 项 （不能为空）

     * @return java.lang.Object

     * @date 2022/3/2 17:47

     */

    public Object hget(String key, String item) {

        if (key.isEmpty() || item.isEmpty()) {

            throw new RuntimeException("key or item Can't be empty ");

        }

        return redisTemplate.opsForHash().get(key, item);

    }



    /**

     * 获取hashkey对应的所有键值对

     *

     * @param key

     * @return java.util.Map<java.lang.Object, java.lang.Object>

     * @date 2022/3/2 17:57

     */

    public Map<Object, Object> hmget(String key) {

        return redisTemplate.opsForHash().entries(key);

    }



    /**

     * hashset

     *

     * @param key 键

     * @param map 对应多个键值

     * @return boolean 是否设值成功

     */

    public boolean hmset(String key, Map<String, Object> map) {

        try {

            redisTemplate.opsForHash().putAll(key, map);

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }



    /**

     * 向一张hash表中放入树，如果不存在则创建

     *

     * @param key   键

     * @param item  项

     * @param value 值

     * @return boolean 是否成功

     */

    public boolean hset(String key, String item, Object value) {

        try {

            redisTemplate.opsForHash().put(key, item, value);

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }



    /**

     * 判断hash表时候有该项的值

     *

     * @param key  键 （不能为空）

     * @param item 项，可以有多个，不能为null

     */

    public void hdel(String key, Object... item) {

        redisTemplate.opsForHash().delete(key, item);

    }



    /**

     * 判断hash表是否该项的值

     *

     * @param key  键 （不能为空）

     * @param item 项 （不能为空）

     * @return boolean 是否存在

     */

    public boolean hHashKey(String key, String item) {

        return redisTemplate.opsForHash().hasKey(key, item);

    }



    /**

     * hash递增

     *

     * @param key  键

     * @param item 项

     * @param by   递增因子（大于0）

     * @return double

     * @date 2022/3/3 9:27

     */

    public double hincr(String key, String item, double by) {

        return redisTemplate.opsForHash().increment(key, item, by);

    }



    /**

     * hash递减

     *

     * @param key  键

     * @param item 项

     * @param by   递减因子（小于0）

     * @return double

     * @date 2022/3/3 9:35

     */

    public double hdecr(String key, String item, double by) {

        return redisTemplate.opsForHash().increment(key, item, -by);

    }



    // =============================================================== set



    /**

     * 根据key获取Set中的所有值

     *

     * @param key 键

     * @return java.util.Set<java.lang.Object>

     */

    public Set<Object> sGet(String key) {

        try {

            return redisTemplate.opsForSet().members(key);

        } catch (Exception e) {

            e.printStackTrace();

            return null;

        }

    }



    /**

     * 根据value从一个set中查询，是否存在

     *

     * @param key   键

     * @param value 值

     * @return boolean

     */

    public boolean sHasKey(String key, Object value) {

        try {

            return redisTemplate.opsForSet().isMember(key, value);

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }



    /**

     * 将数据放入set缓存

     *

     * @param key

     * @param values

     * @return long

     * @date 2022/3/3 9:52

     */

    public long sSet(String key, Object... values) {

        try {

            return redisTemplate.opsForSet().add(key, values);

        } catch (Exception e) {

            e.printStackTrace();

            return 0;

        }

    }



    /**

     * 将set数据放入缓存

     *

     * @param key    键

     * @param time   时间（秒）

     * @param values 值

     * @return long 成功的个数

     */

    public long sSetAndTime(String key, long time, Object... values) {

        try {

            Long count = redisTemplate.opsForSet().add(key, values);

            if (time > 0) {

                expire(key, time);

            }

            return count;

        } catch (Exception e) {

            e.printStackTrace();

            return 0;

        }

    }



    /**

     * 获取set缓存的长度

     *

     * @param key 键

     * @return long 长度

     * @date 2022/3/3 9:59

     */

    public long sGetSetSize(String key) {

        try {

            return redisTemplate.opsForSet().size(key);

        } catch (Exception e) {

            e.printStackTrace();

            return 0;

        }

    }



    /**

     * 移除值为value的key

     *

     * @param key    键

     * @param values 值

     * @return long

     * @date 2022/3/3 10:01

     */

    public long setRemove(String key, Object... values) {

        try {

            Long count = redisTemplate.opsForSet().remove(key, values);

            return count;

        } catch (Exception e) {

            e.printStackTrace();

            return 0;

        }

    }



    // ================================================================== List



    /**

     * 获取list缓存的内容

     *

     * @param key

     * @param start

     * @param end

     * @return java.util.List<java.lang.Object>

     * @date 2022/3/3 10:05

     */

    public List<Object> lGet(String key, long start, long end) {

        try {

            return redisTemplate.opsForList().range(key, start, end);

        } catch (Exception e) {

            e.printStackTrace();

            return null;

        }

    }



    /**

     * 获取list缓存的长度

     *

     * @param key 键

     * @return long 长度

     * @date 2022/3/3 10:06

     */

    public long lGetListSize(String key) {

        try {

            return redisTemplate.opsForList().size(key);

        } catch (Exception e) {

            e.printStackTrace();

            return 0;

        }

    }



    /**

     * 通过索引，获取list中的值 <br>

     * index >=0 时，0为表头；1第二个元素；

     * index < 0 时，-1为表尾；-2倒数第二个元素

     *

     * @param key   键

     * @param index 索引

     * @return java.lang.Object 下标的值

     * @date 2022/3/3 10:09

     */

    public Object lGetIndex(String key, long index) {

        try {

            return redisTemplate.opsForList().index(key, index);

        } catch (Exception e) {

            e.printStackTrace();

            return null;

        }

    }



    /**

     * 将list放入缓存

     *

     * @param key   键

     * @param value 值

     * @return boolean 是否成功

     * @date 2022/3/3 10:17

     */

    public boolean lSet(String key, Object value) {

        try {

            redisTemplate.opsForList().rightPush(key, value);

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }



    /**

     * 将list放入缓存

     *

     * @param key   键

     * @param value 值

     * @param time  时间（秒）

     * @return boolean 是否成功

     * @date 2022/3/3 10:22

     */

    public boolean lSet(String key, Object value, long time) {

        try {

            redisTemplate.opsForList().rightPush(key, value);

            if (time > 0) {

                expire(key, time);

            }

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }



    /**

     * 将list放入缓存

     *

     * @param key   键

     * @param value 值

     * @return boolean 是否成功

     * @date 2022/3/3 10:24

     */

    public boolean lSet(String key, List<Object> value) {

        try {

            redisTemplate.opsForList().rightPushAll(key, value);

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }



    /**

     * 将list放入缓存

     *

     * @param key   键

     * @param value 值

     * @param time  时间（秒）

     * @return boolean 是否成功

     * @date 2022/3/3 10:26

     */

    public boolean lSet(String key, List<Object> value, long time) {

        try {

            redisTemplate.opsForList().rightPushAll(key, value);

            if (time > 0) {

                expire(key, time);

            }

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }



    /**

     * 根据索引索引list中的某种数据

     *

     * @param key   键

     * @param index 索引

     * @param value 值

     * @return boolean

     * @date 2022/3/3 10:28

     */

    public boolean lUpdateIndex(String key, long index, Object value) {

        try {

            redisTemplate.opsForList().set(key, index, value);

            return true;

        } catch (Exception e) {

            e.printStackTrace();

            return false;

        }

    }



    /**

     * 移除N个值为value

     *

     * @param key   键

     * @param count 移除个数

     * @param value 值

     * @return long 移除的个数

     * @date 2022/3/3 10:29

     */

    public long lRemove(String key, long count, Object value) {

        try {

            Long remove = redisTemplate.opsForList().remove(key, count, value);

            return remove;

        } catch (Exception e) {

            e.printStackTrace();

            return 0;

        }

    }

}

10.枚举类模板



import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public enum OrderStatusEnum {
    UNPAID(0,"预约成功，待支付"),
    PAID(1,"已支付" ),
    GET_NUMBER(2,"已取号" ),
    CANCLE(-1,"取消预约"),
    ;

    private Integer status;
    private String comment ;

    public static String getStatusNameByStatus(Integer status) {
        OrderStatusEnum arrObj[] = OrderStatusEnum.values();
        for (OrderStatusEnum obj : arrObj) {
            if (status.intValue() == obj.getStatus().intValue()) {
                return obj.getComment();
            }
        }
        return "";
    }

    public static List<Map<String,Object>> getStatusList() {
        List<Map<String,Object>> list = new ArrayList<>();
        OrderStatusEnum arrObj[] = OrderStatusEnum.values();
        for (OrderStatusEnum obj : arrObj) {
            Map<String,Object> map = new HashMap<>();
            map.put("status", obj.getStatus());
            map.put("comment", obj.getComment());
            list.add(map);
        }
        return list;
    }

    OrderStatusEnum(Integer status, String comment ){
        this.comment=comment;
        this.status = status;
    }

    public String getComment() {
        return comment;
    }

    public void setComment(String comment) {
        this.comment = comment;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }
}

11.HttpclientUtil



import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * HttpClient类 微信：
 *
 */
public class HttpClientUtil {

    public static String doGet(String url)   {

        // 创建Httpclient对象
        CloseableHttpClient httpclient = HttpClients.createDefault();
        // 创建http GET请求
        HttpGet httpGet = new HttpGet(url);
        CloseableHttpResponse response = null;
        try {
            // 执行请求
            response = httpclient.execute(httpGet);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                HttpEntity entity = response.getEntity();
                String result = EntityUtils.toString(entity, "UTF-8");
                EntityUtils.consume(entity);
                httpclient.close();
                return result;
            }
            httpclient.close();
        }catch (IOException e){
            e.printStackTrace();
            return null;
        }

        return  null;
    }


    public static void download(String url,String fileName)   {

        // 创建Httpclient对象
        CloseableHttpClient httpclient = HttpClients.createDefault();
        // 创建http GET请求
        HttpGet httpGet = new HttpGet(url);
        CloseableHttpResponse response = null;
        try {
            // 执行请求
            response = httpclient.execute(httpGet);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                HttpEntity entity = response.getEntity();

               // String result = EntityUtils.toString(entity, "UTF-8");
                byte[] bytes = EntityUtils.toByteArray(entity);
                File file =new File(fileName);
               //  InputStream in = entity.getContent();
                FileOutputStream fout = new FileOutputStream(file);
                fout.write(bytes);

                EntityUtils.consume(entity);

                httpclient.close();
                fout.flush();
                fout.close();
                return  ;
            }
            httpclient.close();
        }catch (IOException e){
            e.printStackTrace();
            return  ;
        }

        return   ;
    }
}

豆豆的java之旅
关注
java 工具类 单例_工具类用单例模式还是静态方法
weixin_39882317的博客
02-13 1377
上一篇blog中将工具类写成了静态类(所有的方法都是静态方法)，今天发现了这种方式的弊端。且听我慢慢道来：今天需要重构一个实习生的代码，逻辑很简单，消费kafka，提取需要的内容写入ssdb，他将配置信息直接写到了项目中，而我们需要区分本地、测试、生产环境，不现实，这就是重构的原因。这就要求我必须封装kafka消费、jedis(ssdb兼容jedis)读写工具类。本来打算照着前几天的做，但是想着参...
java时间日期格式化工具类
11-29
java时间日期格式化工具类，最近新整理的目前各种会用到的关于日期的格式化
java日期格式化工具类
cjings的专栏
07-08 581
* 日期工具类-xw素材网整理  * 默认使用 "yyyy-MM-dd HH:mm:ss" 格式化日期  * @author xw素材网 public final class DateUtils { * 英文简写（默认）如：2010-12-01 public static String FORMAT_SHORT = "yyyy-MM-dd"; * 英文全称  如：2010-12-01
java日期和时间工具类（DateUtils/TimeUtils）
最新发布
Flying_Fish_roe的博客
10-03 733
空值判断isEmpty：判断字符串是否为null或空字符串。isBlank：判断字符串是否为null、空字符串或仅包含空白字符。去空格trim：去除字符串前后的空格。：去除字符串中的所有空格。字符串拼接join：使用指定的分隔符连接字符串数组或集合中的元素。字符串替换replace：替换字符串中的目标子串或字符。字符串拆分split：使用指定的分隔符拆分字符串。：拆分字符串并去除每个元素的前后空格。大小写转换：将字符串转换为大写。：将字符串转换为小写。查找操作contains。
Java日期工具类，Java时间工具类，Java时间格式化
04-26
NULL 博文链接：https://fanshuyao.iteye.com/blog/2355386
java 时间格式化工具类_java时间日期格式化工具类程序
weixin_31080131的博客
02-24 122
package com.util;import java.sql.Timestamp;import java.text.DateFormat;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Calendar;import java.util.Date;public class Co...
java 工具类 lang3 jar包
12-12
java 工具类 lang3 jar包 StringUtils ArrayUtils SystemUtils
java工具类地址
09-28
java常用的工具类收集；包括字符串、数字、日期、文件、图像、编码解码、校验工具、文档操作等。
Java工具类介绍
11-20
这是本人在公司培训时做的一个PPT文档，介绍了Java常用的工具类
Java常用工具类大全，工作5年精心整理（最新版）
12-28
提供了很丰富的java工具类，包括字符串、数字、日期、文件、图像、编码解码、校验工具、文档操作等。 主要分为以下几种： - 1.通用操作类，例如String、数字、日期、各种校验等 - 2.文档操作，excel、pdf等 - 3.加密...
日期格式转化工具类(java版本)
10-24
史上最全日期类型转化，包括各种形式的日期转化，时间转化。并可以获取当前年份，月份，以及当前星期等。可以获取过去的时间时间，小时，分钟数等。
java时间格式化工具类_Java 日期格式化，Java 日期工具类，Java Date工具类
weixin_34749183的博客
02-13 107
importjava.text.ParseException;importjava.text.SimpleDateFormat;importjava.util.Calendar;importjava.util.Date;importorg.apache.commons.lang.StringUtils;public classDateUtils {public final static Strin...
java的格式化时间工具类
qq_41358574的博客
09-10 827
代码： public class DateTimeUtil { private static final Logger logger = LoggerFactory.getLogger(DateTimeUtil.class); public static final String STANDER_FORMAT = "yyyy-MM-dd HH:mm:ss"; public static final String STANDER_SHORT_FORMAT = "yyyy-MM-dd"
java 时间格式化工具类_Java 日期格式工具类
weixin_32916125的博客
02-13 164
Java 日期格式工具类方法如下DateUtil 类import java.text.DateFormat;import java.text.ParseException;import java.text.ParsePosition;import java.text.SimpleDateFormat;import java.util.ArrayList;import java.util.Calen...
Java格式化时间工具类
凉兮的博客
06-17 218
通用格式化时间工具类 import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; public class MyDateFormat { /*** * 获取当前时间并格式化 * @return * @throws ParseException */ public static Date getNewDate() throws Pa
java操作时间工具类
胡献根的博客
10-25 391
/** * 日期处理 * * @author huxiangen * @email *******@qq.com * @date 2019年10月25日 下午12:53:33 */ public class DateUtils { /** 时间格式(yyyy-MM-dd) */ public final static String DATE_PATTERN = "yyyy-MM...
java格式化类
zm020328的博客
07-14 557
日期格式化类 数字格式化
Java工具类大全：XML解析与日期时间处理
资源摘要信息:"一个全面的Java工具类集合，涵盖了XML解析、日期时间处理等关键编程领域。" Java作为一门广泛使用的编程语言，拥有一个庞大的生态系统和丰富的第三方库支持。在日常的开发过程中，常常需要一些通用的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值