import java .time .DayOfWeek ;
import java .time .LocalDate ;
import java .time .LocalDateTime ;
import java .time .LocalTime ;
import java .time .format .DateTimeFormatter ;
import java .time .temporal .ChronoUnit ;
import java .time .temporal .TemporalAccessor ;
import java .time .temporal .TemporalAdjusters ;
import java .util .ArrayList ;
import java .util .List ;
/**
* 日期时间工具类
*/
public class LocalDateUtils {
/**
* 显示年月日时分秒，例如 2022-08-11 09:51:53.
*/
public static final String DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss" ;
/**
* 仅显示年月日，例如 2022-08-11.
*/
public static final String DATE_PATTERN = "yyyy-MM-dd" ;
/**
* 仅显示时分秒，例如 09:51:53.
*/
public static final String TIME_PATTERN = "HH:mm:ss" ;
/**
* 显示年月日时分秒(无符号)，例如 20220811095153.
*/
public static final String UNSIGNED_DATETIME_PATTERN = "yyyyMMddHHmmss" ;
/**
* 仅显示年月日(无符号)，例如 20220811.
*/
public static final String UNSIGNED_DATE_PATTERN = "yyyyMMdd" ;
/**
* 春天;
*/
public static final Integer SPRING = 1 ;
/**
* 夏天;
*/
public static final Integer SUMMER = 2 ;
/**
* 秋天;
*/
public static final Integer AUTUMN = 3 ;
/**
* 冬天;
*/
public static final Integer WINTER = 4 ;
/**
* 星期日;
*/
public static final String SUNDAY = "星期日" ;
/**
* 星期一;
*/
public static final String MONDAY = "星期一" ;
/**
* 星期二;
*/
public static final String TUESDAY = "星期二" ;
/**
* 星期三;
*/
public static final String WEDNESDAY = "星期三" ;
/**
* 星期四;
*/
public static final String THURSDAY = "星期四" ;
/**
* 星期五;
*/
public static final String FRIDAY = "星期五" ;
/**
* 星期六;
*/
public static final String SATURDAY = "星期六" ;
/**
* 年
*/
private static final String YEAR = "year" ;
/**
* 月
*/
private static final String MONTH = "month" ;
/**
* 周
*/
private static final String WEEK = "week" ;
/**
* 日
*/
private static final String DAY = "day" ;
/**
* 时
*/
private static final String HOUR = "hour" ;
/**
* 分
*/
private static final String MINUTE = "minute" ;
/**
* 秒
*/
private static final String SECOND = "second" ;
/**
* 获取当前日期和时间字符串.
*
* @return String 日期时间字符串，例如 2022-08-11 09:51:53
*/
public static String getLocalDateTimeStr () {
return format (LocalDateTime .now (), DATETIME_PATTERN );
}
/**
* 获取当前日期字符串.
*
* @return String 日期字符串，例如2022-08-11
*/
public static String getLocalDateStr () {
return format (LocalDate .now (), DATE_PATTERN );
}
/**
* 获取当前时间字符串.
*
* @return String 时间字符串，例如 09:51:53
*/
public static String getLocalTimeStr () {
return format (LocalTime .now (), TIME_PATTERN );
}
/**
* 获取当前星期字符串.
*
* @return String 当前星期字符串，例如 星期二
*/
public static String getDayOfWeekStr () {
return format (LocalDate .now (), "E" );
}
/**
* 获取指定日期是星期几
*
* @param localDate 日期
* @return String 星期几
*/
public static String getDayOfWeekStr (LocalDate localDate ) {
String [] weekOfDays = {MONDAY , TUESDAY , WEDNESDAY , THURSDAY , FRIDAY , SATURDAY , SUNDAY };
int dayOfWeek = localDate .getDayOfWeek ().getValue () - 1 ;
return weekOfDays [dayOfWeek ];
}
/**
* 获取日期时间字符串
*
* @param temporal 需要转化的日期时间
* @param pattern 时间格式
* @return String 日期时间字符串，例如 2022-08-11 09:51:53
*/
public static String format (TemporalAccessor temporal , String pattern ) {
DateTimeFormatter dateTimeFormatter = DateTimeFormatter .ofPattern (pattern );
return dateTimeFormatter .format (temporal );
}
/**
* 日期时间字符串转换为日期时间(java.time.LocalDateTime)
*
* @param localDateTimeStr 日期时间字符串
* @param pattern 日期时间格式 例如DATETIME_PATTERN
* @return LocalDateTime 日期时间
*/
public static LocalDateTime parseLocalDateTime (String localDateTimeStr , String pattern ) {
DateTimeFormatter dateTimeFormatter = DateTimeFormatter .ofPattern (pattern );
return LocalDateTime .parse (localDateTimeStr , dateTimeFormatter );
}
/**
* 日期字符串转换为日期(java.time.LocalDate)
*
* @param localDateStr 日期字符串
* @param pattern 日期格式 例如DATE_PATTERN
* @return LocalDate 日期
*/
public static LocalDate parseLocalDate (String localDateStr , String pattern ) {
DateTimeFormatter dateTimeFormatter = DateTimeFormatter .ofPattern (pattern );
return LocalDate .parse (localDateStr , dateTimeFormatter );
}
/**
* 获取指定日期时间加上指定数量日期时间单位之后的日期时间.
*
* @param localDateTime 日期时间
* @param num 数量
* @param chronoUnit 日期时间单位
* @return LocalDateTime 新的日期时间
*/
public static LocalDateTime plus (LocalDateTime localDateTime , int num , ChronoUnit chronoUnit ) {
return localDateTime .plus (num , chronoUnit );
}
/**
* 获取指定日期时间减去指定数量日期时间单位之后的日期时间.
*
* @param localDateTime 日期时间
* @param num 数量
* @param chronoUnit 日期时间单位
* @return LocalDateTime 新的日期时间
*/
public static LocalDateTime minus (LocalDateTime localDateTime , int num , ChronoUnit chronoUnit ) {
return localDateTime .minus (num , chronoUnit );
}
/**
* 根据ChronoUnit计算两个日期时间之间相隔日期时间
*
* @param start 开始日期时间
* @param end 结束日期时间
* @param chronoUnit 日期时间单位
* @return long 相隔日期时间
*/
public static long getChronoUnitBetween (LocalDateTime start , LocalDateTime end , ChronoUnit chronoUnit ) {
return Math .abs (start .until (end , chronoUnit ));
}
/**
* 根据ChronoUnit计算两个日期之间相隔年数或月数或天数
*
* @param start 开始日期
* @param end 结束日期
* @param chronoUnit 日期时间单位,(ChronoUnit.YEARS,ChronoUnit.MONTHS,ChronoUnit.WEEKS,ChronoUnit.DAYS)
* @return long 相隔年数或月数或天数
*/
public static long getChronoUnitBetween (LocalDate start , LocalDate end , ChronoUnit chronoUnit ) {
return Math .abs (start .until (end , chronoUnit ));
}
/**
* 获取本年第一天的日期字符串
*
* @return String 格式：yyyy-MM-dd 00:00:00
*/
public static String getFirstDayOfYearStr () {
return getFirstDayOfYearStr (LocalDateTime .now ());
}
/**
* 获取本年最后一天的日期字符串
*
* @return String 格式：yyyy-MM-dd 23:59:59
*/
public static String getLastDayOfYearStr () {
return getLastDayOfYearStr (LocalDateTime .now ());
}
/**
* 获取指定日期当年第一天的日期字符串
*
* @param localDateTime 指定日期时间
* @return String 格式：yyyy-MM-dd 00:00:00
*/
public static String getFirstDayOfYearStr (LocalDateTime localDateTime ) {
return getFirstDayOfYearStr (localDateTime , DATETIME_PATTERN );
}
/**
* 获取指定日期当年最后一天的日期字符串
*
* @param localDateTime 指定日期时间
* @return String 格式：yyyy-MM-dd 23:59:59
*/
public static String getLastDayOfYearStr (LocalDateTime localDateTime ) {
return getLastDayOfYearStr (localDateTime , DATETIME_PATTERN );
}
/**
* 获取指定日期当年第一天的日期字符串,带日期格式化参数
*
* @param localDateTime 指定日期时间
* @param pattern 日期时间格式
* @return String 格式：yyyy-MM-dd 00:00:00
*/
public static String getFirstDayOfYearStr (LocalDateTime localDateTime , String pattern ) {
return format (localDateTime .withDayOfYear (1 ).withHour (0 ).withMinute (0 ).withSecond (0 ), pattern );
}
/**
* 获取指定日期当年最后一天的日期字符串,带日期格式化参数
*
* @param localDateTime 指定日期时间
* @param pattern 日期时间格式
* @return String 格式：yyyy-MM-dd 23:59:59
*/
public static String getLastDayOfYearStr (LocalDateTime localDateTime , String pattern ) {
return format (localDateTime .with (TemporalAdjusters .lastDayOfYear ()).withHour (23 ).withMinute (59 ).withSecond (59 ), pattern );
}
/**
* 获取本月第一天的日期字符串
*
* @return String 格式：yyyy-MM-dd 00:00:00
*/
public static String getFirstDayOfMonthStr () {
return getFirstDayOfMonthStr (LocalDateTime .now ());
}
/**
* 获取本月最后一天的日期字符串
*
* @return String 格式：yyyy-MM-dd 23:59:59
*/
public static String getLastDayOfMonthStr () {
return getLastDayOfMonthStr (LocalDateTime .now ());
}
/**
* 获取指定日期当月第一天的日期字符串
*
* @param localDateTime 指定日期时间
* @return String 格式：yyyy-MM-dd 23:59:59
*/
public static String getFirstDayOfMonthStr (LocalDateTime localDateTime ) {
return getFirstDayOfMonthStr (localDateTime , DATETIME_PATTERN );
}
/**
* 获取指定日期当月最后一天的日期字符串
*
* @param localDateTime 指定日期时间
* @return String 格式：yyyy-MM-dd 23:59:59
*/
public static String getLastDayOfMonthStr (LocalDateTime localDateTime ) {
return getLastDayOfMonthStr (localDateTime , DATETIME_PATTERN );
}
/**
* 获取指定日期当月第一天的日期字符串,带日期格式化参数
*
* @param localDateTime 指定日期时间
* @return String 格式：yyyy-MM-dd 00:00:00
*/
public static String getFirstDayOfMonthStr (LocalDateTime localDateTime , String pattern ) {
return format (localDateTime .withDayOfMonth (1 ).withHour (0 ).withMinute (0 ).withSecond (0 ), pattern );
}
/**
* 获取指定日期当月最后一天的日期字符串,带日期格式化参数
*
* @param localDateTime 指定日期时间
* @param pattern 日期时间格式
* @return String 格式：yyyy-MM-dd 23:59:59
*/
public static String getLastDayOfMonthStr (LocalDateTime localDateTime , String pattern ) {
return format (localDateTime .with (TemporalAdjusters .lastDayOfMonth ()).withHour (23 ).withMinute (59 ).withSecond (59 ), pattern );
}
/**
* 获取本周第一天的日期字符串
*
* @return String 格式：yyyy-MM-dd 00:00:00
*/
public static String getFirstDayOfWeekStr () {
return getFirstDayOfWeekStr (LocalDateTime .now ());
}
/**
* 获取本周最后一天的日期字符串
*
* @return String 格式：yyyy-MM-dd 23:59:59
*/
public static String getLastDayOfWeekStr () {
return getLastDayOfWeekStr (LocalDateTime .now ());
}
/**
* 获取指定日期当周第一天的日期字符串,这里第一天为周一
*
* @param localDateTime 指定日期时间
* @return String 格式：yyyy-MM-dd 00:00:00
*/
public static String getFirstDayOfWeekStr (LocalDateTime localDateTime ) {
return getFirstDayOfWeekStr (localDateTime , DATETIME_PATTERN );
}
/**
* 获取指定日期当周最后一天的日期字符串,这里最后一天为周日
*
* @param localDateTime 指定日期时间
* @return String 格式：yyyy-MM-dd 23:59:59
*/
public static String getLastDayOfWeekStr (LocalDateTime localDateTime ) {
return getLastDayOfWeekStr (localDateTime , DATETIME_PATTERN );
}
/**
* 获取指定日期当周第一天的日期字符串,这里第一天为周一,带日期格式化参数
*
* @param localDateTime 指定日期时间
* @param pattern 日期时间格式
* @return String 格式：yyyy-MM-dd 00:00:00
*/
public static String getFirstDayOfWeekStr (LocalDateTime localDateTime , String pattern ) {
return format (localDateTime .with (DayOfWeek .MONDAY ).withHour (0 ).withMinute (0 ).withSecond (0 ), pattern );
}
/**
* 获取指定日期当周最后一天的日期字符串,这里最后一天为周日,带日期格式化参数
*
* @param localDateTime 指定日期时间
* @param pattern 日期时间格式
* @return String 格式：yyyy-MM-dd 23:59:59
*/
public static String getLastDayOfWeekStr (LocalDateTime localDateTime , String pattern ) {
return format (localDateTime .with (DayOfWeek .SUNDAY ).withHour (23 ).withMinute (59 ).withSecond (59 ), pattern );
}
/**
* 获取今天开始时间的日期字符串
*
* @return String 格式：yyyy-MM-dd 00:00:00
*/
public static String getStartTimeOfDayStr () {
return getStartTimeOfDayStr (LocalDateTime .now ());
}
/**
* 获取今天结束时间的日期字符串
*
* @return String 格式：yyyy-MM-dd 23:59:59
*/
public static String getEndTimeOfDayStr () {
return getEndTimeOfDayStr (LocalDateTime .now ());
}
/**
* 获取指定日期开始时间的日期字符串
*
* @param localDateTime 指定日期时间
* @return String 格式：yyyy-MM-dd 00:00:00
*/
public static String getStartTimeOfDayStr (LocalDateTime localDateTime ) {
return getStartTimeOfDayStr (localDateTime , DATETIME_PATTERN );
}
/**
* 获取指定日期结束时间的日期字符串
*
* @param localDateTime 指定日期时间
* @return String 格式：yyyy-MM-dd 23:59:59
*/
public static String getEndTimeOfDayStr (LocalDateTime localDateTime ) {
return getEndTimeOfDayStr (localDateTime , DATETIME_PATTERN );
}
/**
* 获取指定日期开始时间的日期字符串,带日期格式化参数
*
* @param localDateTime 指定日期时间
* @param pattern 日期时间格式
* @return String 格式：yyyy-MM-dd HH:mm:ss
*/
public static String getStartTimeOfDayStr (LocalDateTime localDateTime , String pattern ) {
return format (localDateTime .withHour (0 ).withMinute (0 ).withSecond (0 ), pattern );
}
/**
* 获取指定日期结束时间的日期字符串,带日期格式化参数
*
* @param localDateTime 指定日期时间
* @param pattern 日期时间格式
* @return String 格式：yyyy-MM-dd 23:59:59
*/
public static String getEndTimeOfDayStr (LocalDateTime localDateTime , String pattern ) {
return format (localDateTime .withHour (23 ).withMinute (59 ).withSecond (59 ), pattern );
}
/**
* 切割日期。按照周期切割成小段日期段。例如： <br>
*
* @param startDate 开始日期（yyyy-MM-dd）
* @param endDate 结束日期（yyyy-MM-dd）
* @param period 周期（天，周，月，年）
* @return 切割之后的日期集合
* <li>startDate="2019-02-28",endDate="2019-03-05",period="day"</li>
* <li>结果为：[2019-02-28, 2019-03-01, 2019-03-02, 2019-03-03, 2019-03-04, 2019-03-05]</li><br>
* <li>startDate="2019-02-28",endDate="2019-03-25",period="week"</li>
* <li>结果为：[2019-02-28,2019-03-06, 2019-03-07,2019-03-13, 2019-03-14,2019-03-20,
* 2019-03-21,2019-03-25]</li><br>
* <li>startDate="2019-02-28",endDate="2019-05-25",period="month"</li>
* <li>结果为：[2019-02-28,2019-02-28, 2019-03-01,2019-03-31, 2019-04-01,2019-04-30,
* 2019-05-01,2019-05-25]</li><br>
* <li>startDate="2019-02-28",endDate="2020-05-25",period="year"</li>
* <li>结果为：[2019-02-28,2019-12-31, 2020-01-01,2020-05-25]</li><br>
*/
public static List <String > listDateStrs (String startDate , String endDate , String period ) {
List <String > result = new ArrayList <>();
DateTimeFormatter dateTimeFormatter = DateTimeFormatter .ofPattern (DATE_PATTERN );
LocalDate end = LocalDate .parse (endDate , dateTimeFormatter );
LocalDate start = LocalDate .parse (startDate , dateTimeFormatter );
LocalDate tmp = start ;
switch (period ) {
case DAY :
while (start .isBefore (end ) || start .isEqual (end )) {
result .add (start .toString ());
start = start .plusDays (1 );
}
break ;
case WEEK :
while (tmp .isBefore (end ) || tmp .isEqual (end )) {
if (tmp .plusDays (6 ).isAfter (end )) {
result .add (tmp .toString () + "," + end );
} else {
result .add (tmp .toString () + "," + tmp .plusDays (6 ));
}
tmp = tmp .plusDays (7 );
}
break ;
case MONTH :
while (tmp .isBefore (end ) || tmp .isEqual (end )) {
LocalDate lastDayOfMonth = tmp .with (TemporalAdjusters .lastDayOfMonth ());
if (lastDayOfMonth .isAfter (end )) {
result .add (tmp .toString () + "," + end );
} else {
result .add (tmp .toString () + "," + lastDayOfMonth );
}
tmp = lastDayOfMonth .plusDays (1 );
}
break ;
case YEAR :
while (tmp .isBefore (end ) || tmp .isEqual (end )) {
LocalDate lastDayOfYear = tmp .with (TemporalAdjusters .lastDayOfYear ());
if (lastDayOfYear .isAfter (end )) {
result .add (tmp .toString () + "," + end );
} else {
result .add (tmp .toString () + "," + lastDayOfYear );
}
tmp = lastDayOfYear .plusDays (1 );
}
break ;
default :
break ;
}
return result ;
}
public static void main (String [] args ) {
System .out .println (getLocalDateTimeStr ());
System .out .println (getLocalDateStr ());
System .out .println (getLocalTimeStr ());
System .out .println (getDayOfWeekStr ());
System .out .println (getDayOfWeekStr (LocalDate .now ()));
System .out .println ("========" );
System .out .println (format (LocalDate .now (), UNSIGNED_DATE_PATTERN ));
System .out .println ("========" );
System .out .println (parseLocalDateTime ("2020-12-13 11:14:12" , DATETIME_PATTERN ));
System .out .println (parseLocalDate ("2020-12-13" , DATE_PATTERN ));
System .out .println ("========" );
System .out .println (plus (LocalDateTime .now (), 3 , ChronoUnit .HOURS ));
System .out .println (minus (LocalDateTime .now (), 4 , ChronoUnit .DAYS ));
System .out .println ("========" );
System .out .println (getChronoUnitBetween (LocalDateTime .now (), parseLocalDateTime ("2020-12-12 12:03:12" , DATETIME_PATTERN ), ChronoUnit .MINUTES ));
System .out .println (getChronoUnitBetween (LocalDate .now (), parseLocalDate ("2021-12-12" , DATE_PATTERN ), ChronoUnit .WEEKS ));
System .out .println ("========" );
System .out .println (getFirstDayOfYearStr ());
System .out .println (getFirstDayOfYearStr (parseLocalDateTime ("2021-12-12 12:03:12" , DATETIME_PATTERN )));
System .out .println (getFirstDayOfYearStr (parseLocalDateTime ("2021-12-12 12:03:12" , DATETIME_PATTERN ), UNSIGNED_DATETIME_PATTERN ));
System .out .println (getLastDayOfYearStr ());
System .out .println (getLastDayOfYearStr (parseLocalDateTime ("2021-12-12 12:03:12" , DATETIME_PATTERN )));
System .out .println (getLastDayOfYearStr (parseLocalDateTime ("2021-12-12 12:03:12" , DATETIME_PATTERN ), UNSIGNED_DATETIME_PATTERN ));
System .out .println ("========" );
System .out .println (getFirstDayOfMonthStr ());
System .out .println (getFirstDayOfMonthStr (parseLocalDateTime ("2021-12-12 12:03:12" , DATETIME_PATTERN )));
System .out .println (getFirstDayOfMonthStr (parseLocalDateTime ("2021-12-12 12:03:12" , DATETIME_PATTERN ), UNSIGNED_DATETIME_PATTERN ));
System .out .println (getLastDayOfMonthStr ());
System .out .println (getLastDayOfMonthStr (parseLocalDateTime ("2021-12-12 12:03:12" , DATETIME_PATTERN )));
System .out .println (getLastDayOfMonthStr (parseLocalDateTime ("2021-12-12 12:03:12" , DATETIME_PATTERN ), UNSIGNED_DATETIME_PATTERN ));
System .out .println ("========" );
System .out .println (getFirstDayOfWeekStr ());
System .out .println (getFirstDayOfWeekStr (parseLocalDateTime ("2021-12-12 12:03:12" , DATETIME_PATTERN )));
System .out .println (getFirstDayOfWeekStr (parseLocalDateTime ("2021-12-12 12:03:12" , DATETIME_PATTERN ), UNSIGNED_DATETIME_PATTERN ));
System .out .println (getLastDayOfWeekStr ());
System .out .println (getLastDayOfWeekStr (parseLocalDateTime ("2021-12-12 12:03:12" , DATETIME_PATTERN )));
System .out .println (getLastDayOfWeekStr (parseLocalDateTime ("2021-12-12 12:03:12" , DATETIME_PATTERN ), UNSIGNED_DATETIME_PATTERN ));
System .out .println ("========" );
System .out .println (getStartTimeOfDayStr ());
System .out .println (getStartTimeOfDayStr (parseLocalDateTime ("2021-12-12 12:03:12" , DATETIME_PATTERN )));
System .out .println (getStartTimeOfDayStr (parseLocalDateTime ("2021-12-12 12:03:12" , DATETIME_PATTERN ), UNSIGNED_DATETIME_PATTERN ));
System .out .println (getEndTimeOfDayStr ());
System .out .println (getEndTimeOfDayStr (parseLocalDateTime ("2021-12-12 12:03:12" , DATETIME_PATTERN )));
System .out .println (getEndTimeOfDayStr (parseLocalDateTime ("2021-12-12 12:03:12" , DATETIME_PATTERN ), UNSIGNED_DATETIME_PATTERN ));
System .out .println ("========" );
List <String > dateStrs = listDateStrs ("2019-01-30" , "2020-12-13" , YEAR );
for (String dateStr : dateStrs ) {
System .out .println (dateStr );
}
System .out .println ("========" );
List <String > dateStrs1 = listDateStrs ("2019-01-30" , "2020-12-13" , MONTH );
for (String dateStr : dateStrs1 ) {
System .out .println (dateStr );
}
System .out .println ("========" );
List <String > dateStrs2 = listDateStrs ("2020-12-01" , "2020-12-13" , DAY );
for (String dateStr : dateStrs2 ) {
System .out .println (dateStr );
}
}
}@ Component
@ Slf4j
public class RedisUtils {
@ Autowired
private RedisTemplate <String ,Object > redisTemplate ;
/**
* redis有五种数据类型 opsForValue表示是操作字符串类型
*/
public Object get (String key ){
return key == null ? null : redisTemplate .opsForValue ().get (key );
}
//本来只可以放入string类型，但是我们配置了自动序列化所以这儿可以传入object
public boolean set (String key ,Object value ){
try {
redisTemplate .opsForValue ().set (key ,value );
return true ;
}catch (Exception e ){
log .error ("redis set value exception:{}" ,e );
return false ;
}
}
/**
* 原子操作 expire 过期时间 秒
*/
public boolean setex (String key ,Object value ,long expire ){
try {//TimeUnit.SECONDS指定类型为秒
redisTemplate .opsForValue ().set (key ,value ,expire , TimeUnit .SECONDS );
return true ;
}catch (Exception e ){
log .error ("redis set value and expire exception:{}" ,e );
return false ;
}
}
/**
* 非原子操作
*/
public boolean expire (String key ,long expire ){
try {//这儿没有ops什么的是因为每种数据类型都能设置过期时间
redisTemplate .expire (key ,expire ,TimeUnit .SECONDS );
return true ;
}catch (Exception e ){
log .error ("redis set key expire exception:{}" ,e );
return false ;
}
}
/**
* 获取key的过期时间
*/
public long ttl (String key ){
return redisTemplate .getExpire (key );
}
/**
* 删除key 可变参数
*/
public void del (String ...keys ){
if (keys !=null &&keys .length >0 ) {
redisTemplate .delete ((Collection <String >) CollectionUtils .arrayToList (keys ));
}
}
/**
* @param step 传入正数 就是加多少 传入负数就是减多少
*/
public long incrBy (String key ,long step ){
return redisTemplate .opsForValue ().increment (key ,step );
}
/**
* @return 如果该key存在就返回false 设置不成功 key不存在就返回ture设置成功
*/
public boolean setnx (String key ,Object value ){
return redisTemplate .opsForValue ().setIfAbsent (key ,value );
}
/**
* 原子操作 在上面方法加上过期时间设置
*/
public boolean setnxAndExpire (String key ,Object value ,long expire ){
return redisTemplate .opsForValue ().setIfAbsent (key ,value ,expire ,TimeUnit .SECONDS );
}
/**
* 如果该key存在就返回之前的value 不存在就返回null
*/
public Object getAndSet (String key ,Object value ){
return redisTemplate .opsForValue ().getAndSet (key ,value );
}
/**
* 判断key是否存在
*/
public boolean hasKey (String key ){
return redisTemplate .hasKey (key );
}
/***list的长度**/
public long llen (String key ){
return redisTemplate .opsForList ().size (key );
}
/**
* 获取key中index位置的值，负数就反过来数，-1为最后一个
*/
public Object lgetByIndex (String key ,long index ){
try {
return redisTemplate .opsForList ().index (key , index );
} catch (Exception e ) {
log .error ("redis lgetByIndex error,key:{},index:{}exception:{}" ,key ,index ,e );
return null ;
}
}
/**
* 将list放入缓存
*/
public boolean lrpush (String key , Object value ) {
try {
redisTemplate .opsForList ().rightPush (key , value );
return true ;
} catch (Exception e ) {
log .error ("redis lrpush error,key:{},value:{}exception:{}" ,key ,value ,e );
return false ;
}
}
/**
* 将list放入缓存 time 时间(秒)
*/
public boolean lrpush (String key , Object value , long time ) {
try {
redisTemplate .opsForList ().rightPush (key , value );
if (time > 0 )
expire (key , time );
return true ;
} catch (Exception e ) {
log .error ("redis lrpush error,key:{},value:{},timeL{},exception:{}" ,key ,value ,time ,e );
return false ;
}
}
/**
* 将list放入缓存
*/
public boolean lrpush (String key , List <Object > value ) {
try {
redisTemplate .opsForList ().rightPushAll (key , value );
return true ;
} catch (Exception e ) {
log .error ("redis lrpush error,key:{},value:{},exception:{}" ,key ,value ,e );
return false ;
}
}
/**
* 将list放入缓存 time 时间(秒)
*/
public boolean lrpush (String key , List <Object > value , long time ) {
try {
redisTemplate .opsForList ().rightPushAll (key , value );
if (time > 0 )
expire (key , time );
return true ;
} catch (Exception e ) {
log .error ("redis lrpush error,key:{},value:{},time:{},exception:{}" ,key ,value ,time ,e );
return false ;
}
}
/**
* 根据索引修改list中的某条数据
*/
public boolean lUpdateByIndex (String key , long index , Object value ) {
try {
redisTemplate .opsForList ().set (key , index , value );
return true ;
} catch (Exception e ) {
log .error ("redis lUpdateByIndex error,key:{},index:{},value:{},exception:{}" ,key ,index ,value ,e );
return false ;
}
}
/**
* 移除N个值为value
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public long lrem (String key , long count , Object value ) {
try {
Long remove = redisTemplate .opsForList ().remove (key , count , value );
return remove ;
} catch (Exception e ) {
log .error ("redis lrem error,key:{},count:{},value:{},exception:{}" ,key ,count ,value ,e );
return 0 ;
}
}
/*****hash数据类型方法 opsForHash表示是操作字符串类型*****/
/**
* @param key 健
* @param field 属性
* @param value 值
* @return
*/
public boolean hset (String key , String field , Object value ) {
try {
redisTemplate .opsForHash ().put (key , field , value );
return true ;
}catch (Exception e ){
log .error ("redis hset eror,key:{},field:{},value:{}" ,key ,field ,value );
return false ;
}
}
/**
*
* @param key
* @param field
* @param value
* @param seconds(秒) 过期时间
* @return
*/
public boolean hset (String key , String field , Object value ,long seconds ) {
try {
redisTemplate .opsForHash ().put (key , field , value );
expire (key ,seconds );//调用通用方法设置过期时间
return true ;
}catch (Exception e ){
log .error ("redis hset and expire eror,key:{},field:{},value:{},exception:{}" ,key ,field ,value ,e );
return false ;
}
}
/**
* 获取key中field属性的值
* @param key
* @param field
* @return
*/
public Object hget (String key ,String field ){
return redisTemplate .opsForHash ().get (key ,field );
}
/**
* 获取key中多个属性的键值对，这儿使用map来接收
* @param key
* @param fields
* @return
*/
public Map <String ,Object > hmget (String key , String ...fields ){
Map <String ,Object > map = new HashMap <>();
for (String field :fields ){
map .put (field ,hget (key ,field ));
}
return map ;
}
/**
* @param key 获得该key下的所有键值对
* @return
*/
public Map <Object , Object > hmget (String key ){
return redisTemplate .opsForHash ().entries (key );
}
/**
* @param key 键
* @param map 对应多个键值
* @param seconds 过期时间(秒)
* @return
*/
public boolean hmset (String key ,Map <String ,Object > map ,long seconds ){
try {
redisTemplate .opsForHash ().putAll (key , map );
expire (key ,seconds );
return true ;
}catch (Exception e ){
log .error ("redis hmset eror,key:{},value:{},expireTime,exception:{}" ,key ,map ,seconds ,e );
return false ;
}
}
/**
*删除key中的属性
* @param key
* @param fields
*/
public void hdel (String key ,Object ...fields ){
redisTemplate .opsForHash ().delete (key ,fields );
}
/**
* 判断key中是否存在某属性
*/
public boolean hHashKey (String key ,String field ){
return redisTemplate .opsForHash ().hasKey (key ,field );
}
/**
* 对key中filed的value增加多少 如果是减少就传入负数
*/
public double hincr (String key ,String field ,double step ){
return redisTemplate .opsForHash ().increment (key ,field ,step );
}
/**
* key中多少个
*/
public long hlen (String key ){
return redisTemplate .opsForHash ().size (key );
}
/******其他方法用到在增加********/
/***set集合***/
/**
* 获取key中所有元素
* @param key
* @return
*/
public Set <Object > sgetAll (String key ){
try {
return redisTemplate .opsForSet ().members (key );
}catch (Exception e ){
log .error ("redis sgetAll error,key:{},exception:{}" ,key ,e );
return null ;
}
}
/**
* 判断value是否在key中
* @param key
* @param value
* @return
*/
public boolean sexists (String key ,Object value ){
try {
return redisTemplate .opsForSet ().isMember (key ,value );
}catch (Exception e ){
log .error ("redis sexists error,key:{},value:{},exception:{}" ,key ,value ,e );
return false ;
}
}
/**
* 插入多个元素
* @param key
* @param values
* @return 成功的个数
*/
public long sset (String key ,Object ...values ){
try {
return redisTemplate .opsForSet ().add (key ,values );
}catch (Exception e ){
log .error ("redis sset error,key:{},value:{},values:{},exception:{}" ,key ,values ,e );
return 0 ;
}
}
/**
* 添加元素并设置过期时间 （非原子操作）
*/
public long sset (String key ,long time ,Object ...values ){
try {
long count = redisTemplate .opsForSet ().add (key ,values );
expire (key ,time );
return count ;
}catch (Exception e ){
log .error ("redis sset error,key:{},value:{},values:{},exception:{}" ,key ,values ,e );
return 0 ;
}
}
/**
* 获取set的长度
*/
public long sgetSize (String key ){
try {
return redisTemplate .opsForSet ().size (key );
}catch (Exception e ){
log .error ("redis sgetSize error,key:{},exception:{}" ,key ,e );
return 0 ;
}
}
/**
* 移除值为value的
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public long sRemove (String key , Object ... values ) {
try {
Long count = redisTemplate .opsForSet ().remove (key , values );
return count ;
} catch (Exception e ) {
log .error ("redis sRemove error,key:{},values:{},exception:{}" ,key ,values ,e );
return 0 ;
}
}
/**
* 随机取count个元素 count为正数就取不重复的 负数就有可能重复
* @param key
* @param count
* @return
*/
public List <Object > sRandom (String key ,long count ) {
try {
return redisTemplate .opsForSet ().randomMembers (key ,count );
} catch (Exception e ) {
log .error ("redis sRandom error,key:{},count:{},exception:{}" ,key ,count ,e );
return null ;
}
}
/****zset工具类***/
/**
* 添加元素
* @param key
* @param member
* @param score
* @return
*/
public boolean zadd (String key ,Object member ,double score ){
try {
return redisTemplate .opsForZSet ().add (key ,member ,score );
} catch (Exception e ) {
log .error ("redis zadd error,key:{},value:{},score:{},exception:{}" ,key ,member ,score ,e );
return false ;
}
}
public Set <String > zrange (String key ,int start ,int end ){
try {
Set <Object > range = redisTemplate .opsForZSet ().
range (key , start , end );
if (range ==null ||range .size ()==0 ) return null ;
return range .stream ().
map (o ->(String )o ).collect (Collectors .toSet ());
} catch (Exception e ) {
log .error ("redis zrange error,key:{},start:{},end:{},exception:{}" ,
key ,start ,end ,e );
return null ;
}
}
}/**
* 精确的浮点数运算
*/
public class ArithUtil {
/** 默认除法运算精度 */
private static final int DEF_DIV_SCALE = 10 ;
/** 这个类不能实例化 */
private ArithUtil () {}
/**
* 提供精确的加法运算。
* @param v1 被加数
* @param v2 加数
* @return 两个参数的和
*/
public static double add (double v1 , double v2 )
{
BigDecimal b1 = new BigDecimal (Double .toString (v1 ));
BigDecimal b2 = new BigDecimal (Double .toString (v2 ));
return b1 .add (b2 ).doubleValue ();
}
/**
* 提供精确的减法运算。
* @param v1 被减数
* @param v2 减数
* @return 两个参数的差
*/
public static double sub (double v1 , double v2 )
{
BigDecimal b1 = new BigDecimal (Double .toString (v1 ));
BigDecimal b2 = new BigDecimal (Double .toString (v2 ));
return b1 .subtract (b2 ).doubleValue ();
}
/**
* 提供精确的乘法运算。
* @param v1 被乘数
* @param v2 乘数
* @return 两个参数的积
*/
public static double mul (double v1 , double v2 )
{
BigDecimal b1 = new BigDecimal (Double .toString (v1 ));
BigDecimal b2 = new BigDecimal (Double .toString (v2 ));
return b1 .multiply (b2 ).doubleValue ();
}
/**
* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
* 小数点以后10位，以后的数字四舍五入。
* @param v1 被除数
* @param v2 除数
* @return 两个参数的商
*/
public static double div (double v1 , double v2 )
{
return div (v1 , v2 , DEF_DIV_SCALE );
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
* 定精度，以后的数字四舍五入。
* @param v1 被除数
* @param v2 除数
* @param scale 表示表示需要精确到小数点以后几位。
* @return 两个参数的商
*/
public static double div (double v1 , double v2 , int scale )
{
if (scale < 0 )
{
throw new IllegalArgumentException (
"The scale must be a positive integer or zero" );
}
BigDecimal b1 = new BigDecimal (Double .toString (v1 ));
BigDecimal b2 = new BigDecimal (Double .toString (v2 ));
if (b1 .compareTo (BigDecimal .ZERO ) == 0 )
{
return BigDecimal .ZERO .doubleValue ();
}
return b1 .divide (b2 , scale , RoundingMode .HALF_UP ).doubleValue ();
}
/**
* 提供精确的小数位四舍五入处理。
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @return 四舍五入后的结果
*/
public static double round (double v , int scale )
{
if (scale < 0 )
{
throw new IllegalArgumentException (
"The scale must be a positive integer or zero" );
}
BigDecimal b = new BigDecimal (Double .toString (v ));
BigDecimal one = BigDecimal .ONE ;
return b .divide (one , scale , RoundingMode .HALF_UP ).doubleValue ();
}
}spring工具类 方便在非spring管理环境中获取bean @ Component
public final class SpringUtils implements BeanFactoryPostProcessor , ApplicationContextAware
{
/** Spring应用上下文环境 */
private static ConfigurableListableBeanFactory beanFactory ;
private static ApplicationContext applicationContext ;
@ Override
public void postProcessBeanFactory (ConfigurableListableBeanFactory beanFactory ) throws BeansException
{
SpringUtils .beanFactory = beanFactory ;
}
@ Override
public void setApplicationContext (ApplicationContext applicationContext ) throws BeansException
{
SpringUtils .applicationContext = applicationContext ;
}
/**
* 获取对象
*/
@ SuppressWarnings ("unchecked" )
public static <T > T getBean (String name ) throws BeansException
{
return (T ) applicationContext .getBean (name );
}
/**
* 获取类型为requiredType的对象
*/
public static <T > T getBean (Class <T > clz ) throws BeansException
{
T result = (T ) applicationContext .getBean (clz );
return result ;
}
/**
* 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true
*/
public static boolean containsBean (String name )
{
return beanFactory .containsBean (name );
}
/**
* 判断以给定名字注册的bean定义是一个singleton还是一个prototype。 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）
*/
public static boolean isSingleton (String name ) throws NoSuchBeanDefinitionException
{
return beanFactory .isSingleton (name );
}
/**
* @param name
*/
public static Class <?> getType (String name ) throws NoSuchBeanDefinitionException
{
return beanFactory .getType (name );
}
/**
* 如果给定的bean名字在bean定义中有别名，则返回这些别名
*/
public static String [] getAliases (String name ) throws NoSuchBeanDefinitionException
{
return beanFactory .getAliases (name );
}
/**
* 获取aop代理对象
*/
@ SuppressWarnings ("unchecked" )
public static <T > T getAopProxy (T invoker )
{
return (T ) AopContext .currentProxy ();
}
/**
* 获取当前的环境配置，无配置返回null
*/
public static String [] getActiveProfiles ()
{
return applicationContext .getEnvironment ().getActiveProfiles ();
}
/**
* 获取配置文件中的值
*/
public static String getRequiredProperty (String key )
{
return applicationContext .getEnvironment ().getRequiredProperty (key );
}
}public class JacksonUtil {
/** 默认日期时间格式 */
public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss" ;
/** 默认日期格式 */
public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd" ;
/** 默认时间格式 */
public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss" ;
public static final ObjectMapper OBJECT_MAMMER = new ObjectMapper ()
.disable (DeserializationFeature .FAIL_ON_UNKNOWN_PROPERTIES )
.configure (SerializationFeature .WRITE_DATES_AS_TIMESTAMPS , true );
static {
JavaTimeModule javaTimeModule = new JavaTimeModule ();
javaTimeModule .addSerializer (LocalDateTime .class ,new LocalDateTimeSerializer (DateTimeFormatter .ofPattern (DEFAULT_DATE_TIME_FORMAT )));
javaTimeModule .addSerializer (LocalDate .class ,new LocalDateSerializer (DateTimeFormatter .ofPattern (DEFAULT_DATE_FORMAT )));
javaTimeModule .addSerializer (LocalTime .class ,new LocalTimeSerializer (DateTimeFormatter .ofPattern (DEFAULT_TIME_FORMAT )));
javaTimeModule .addDeserializer (LocalDateTime .class ,new LocalDateTimeDeserializer (DateTimeFormatter .ofPattern (DEFAULT_DATE_TIME_FORMAT )));
javaTimeModule .addDeserializer (LocalDate .class ,new LocalDateDeserializer (DateTimeFormatter .ofPattern (DEFAULT_DATE_FORMAT )));
javaTimeModule .addDeserializer (LocalTime .class ,new LocalTimeDeserializer (DateTimeFormatter .ofPattern (DEFAULT_TIME_FORMAT )));
OBJECT_MAMMER .registerModule (javaTimeModule ).registerModule (new ParameterNamesModule ());
}
public static String getStringValue (JsonNode root , String ... fields ) {
JsonNode node = getNode (root , fields );
return node == null ? null : StringUtils .trimToNull (node .asText (null ));
}
public static Double getDoubleValue (JsonNode root , String ... fields ) {
JsonNode node = getNode (root , fields );
return node == null || node .isNull () ? null : node .asDouble ();
}
public static Boolean getBooleanValue (JsonNode root , String ... fields ) {
JsonNode node = getNode (root , fields );
return node == null || node .isNull () ? null : node .asBoolean ();
}
public static JsonNode getNode (JsonNode root , String ... fields ) {
if (fields .length == 0 ) {
return root ;
}
if (root == null || !root .isObject ()) {
return null ;
}
if (fields .length == 1 ) {
return root .get (fields [0 ]);
}
for (String field : fields ) {
root = getNode (root , field );
if (root == null ) {
return null ;
}
}
return root ;
}
public static String writeValueAsString (Object o ) {
return writeValueAsString (o , OBJECT_MAMMER );
}
public static String writeValueAsString (Object o , ObjectMapper objectMapper ) {
if (o == null ) {
return null ;
}
try {
return objectMapper .writeValueAsString (o );
} catch (JsonProcessingException e ) {
throw new RuntimeException (e );
}
}
public static JsonNode readTree (String content ) {
return readTree (content , OBJECT_MAMMER );
}
public static JsonNode readTree (String content , ObjectMapper objectMapper ) {
if (StringUtils .isBlank (content )) {
return null ;
}
try {
return objectMapper .readTree (content );
} catch (IOException e ) {
throw new RuntimeException (e );
}
}
public static <T > T readValue (JsonNode content , Class <T > clazz ) {
if (content == null ) {
return null ;
}
try {
return OBJECT_MAMMER .readValue (content .traverse (), clazz );
} catch (IOException e ) {
throw new RuntimeException (e );
}
}
public static JavaType getCollectionType (Class <?> collectionClass , Class <?>... elementClasses ) {
return OBJECT_MAMMER .getTypeFactory ().constructParametricType (collectionClass , elementClasses );
}
}