Skip to content

M
midjourney-proxy
Commit 7c9fba98 by gaopeng
Options

solr相关

parent 738fdc3e
Showing with 1805 additions and 34 deletions
pcloud-common/pom.xml
......@@ -291,13 +291,6 @@
<artifactId>aliyun-java-sdk-mts</artifactId>
</dependency>
<!-- solr add by gaop at 2018-4-23 11:33:47 -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-solr</artifactId>
</dependency>
<!-- end -->
<!-- Jackson Begin -->
<dependency>
<groupId>org.codehaus.jackson</groupId>
......
pcloud-common/src/main/java/com/pcloud/common/utils/DateNewUtils.java 0 → 100644
package com.pcloud.common.utils;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.pcloud.common.utils.validate.ValidateUtils;
/**
* 线程安全的时间工具类
* @author PENG
* @date 2018年12月11日16:40:06
*/
public class DateNewUtils extends org.apache.commons.lang.time.DateUtils {
public static final long DAY_MILLI = 24 * 60 * 60 * 1000;
public final static int LEFT_OPEN_RIGHT_OPEN = 1;
public final static int LEFT_CLOSE_RIGHT_OPEN = 2;
public final static int LEFT_OPEN_RIGHT_CLOSE = 3;
public final static int LEFT_CLOSE_RIGHT_CLOSE = 4;
/**
* 比较日期的模式 --只比较日期，不比较时间
*/
public final static int COMP_MODEL_DATE = 1;
/**
* 比较日期的模式 --只比较时间，不比较日期
*/
public final static int COMP_MODEL_TIME = 2;
/**
* 比较日期的模式 --比较日期，也比较时间
*/
public final static int COMP_MODEL_DATETIME = 3;
private static Logger logger = LoggerFactory.getLogger(DateNewUtils.class);
/**
* 要用到的DATE Format的定义
*/
public static final String SHORT_DATE_FORMAT_PATTERN = "yyyy-MM-dd";
public static final String YMD_DATE_FORMAT_PATTERN = "yyyyMMdd";
public static final String YMD_DATE_FORMAT_PATTERN1 = "yyyy/MM/dd";
public static final String YMD_DATE_FORMAT_PATTERN2 = "yyyy年MM月dd日";
public static final String LONG_DATE_FORMAT_PATTERN = "yyyy-MM-dd HH:mm:ss";
public static final String TIME_WITH_MINUTE_PATTERN = "HH:mm";
public static final String TIME_DATE_FORMAT_PATTERN = "HH:mm:ss";
public static final String HMS_DATE_FORMAT_PATTERN = "HHmmss";
public static final String YMDHMS_DATE_FORMAT_PATTERN = "yyyyMMddHHmmss";
public static final String YMDHM_DATE_FORMAT_PATTERN = "yyyy-MM-dd HH:mm";
public static final String YMDHMSS_DATE_FORMAT_PATTERN = "yyyy-MM-dd hh:mm:ss:SSS";
/**
* 锁对象
*/
private static final Object LOCK_OBJ = new Object();
/**
* 存放不同的日期模板格式的sdf的Map
*/
private static Map<String, ThreadLocal<SimpleDateFormat>> sdfMap = new HashMap<>();
/**
* 返回一个ThreadLocal的sdf,每个线程只会new一次sdf
* @param pattern
* @return
*/
private static SimpleDateFormat getSdf(final String pattern) {
ThreadLocal<SimpleDateFormat> tl = sdfMap.get(pattern);
// 此处的双重判断和同步是为了防止sdfMap这个单例被多次put重复的sdf
if (tl == null) {
synchronized (LOCK_OBJ) {
// 这里是关键,使用ThreadLocal<SimpleDateFormat>替代原来直接new SimpleDateFormat
tl = sdfMap.computeIfAbsent(pattern, k -> ThreadLocal.withInitial(() -> new SimpleDateFormat(pattern)));
}
}
return tl.get();
}
/**
* 根据日期格式字符串解析日期字符串
* @param str 日期字符串
* @param parsePatterns 日期格式字符串
* @return 解析后日期
* @throws ParseException
*/
public static synchronized Date parseDate(String str, String parsePatterns) throws ParseException {
return org.apache.commons.lang.time.DateUtils.parseDate(str, new String[]{parsePatterns});
}
/**
* 根据单位字段比较两个日期
* @param date 日期1
* @param otherDate 日期2
* @param withUnit 单位字段，从Calendar field取值
* @return 等于返回0值, 大于返回大于0的值 小于返回小于0的值
*/
public static int compareDate(Date date, Date otherDate, int withUnit) {
Calendar dateCal = Calendar.getInstance();
dateCal.setTime(date);
Calendar otherDateCal = Calendar.getInstance();
otherDateCal.setTime(otherDate);
switch (withUnit) {
case Calendar.YEAR:
dateCal.clear(Calendar.MONTH);
otherDateCal.clear(Calendar.MONTH);
case Calendar.MONTH:
dateCal.set(Calendar.DATE, 1);
otherDateCal.set(Calendar.DATE, 1);
case Calendar.DATE:
dateCal.set(Calendar.HOUR_OF_DAY, 0);
otherDateCal.set(Calendar.HOUR_OF_DAY, 0);
case Calendar.HOUR:
dateCal.clear(Calendar.MINUTE);
otherDateCal.clear(Calendar.MINUTE);
case Calendar.MINUTE:
dateCal.clear(Calendar.SECOND);
otherDateCal.clear(Calendar.SECOND);
case Calendar.SECOND:
dateCal.clear(Calendar.MILLISECOND);
otherDateCal.clear(Calendar.MILLISECOND);
case Calendar.MILLISECOND:
break;
default:
throw new IllegalArgumentException("withUnit 单位字段 " + withUnit + " 不合法！！");
}
return dateCal.compareTo(otherDateCal);
}
/**
* 根据单位字段比较两个时间
* @param date 时间1
* @param otherDate 时间2
* @param withUnit 单位字段，从Calendar field取值
* @return 等于返回0值, 大于返回大于0的值 小于返回小于0的值
*/
public static int compareTime(Date date, Date otherDate, int withUnit) {
Calendar dateCal = Calendar.getInstance();
dateCal.setTime(date);
Calendar otherDateCal = Calendar.getInstance();
otherDateCal.setTime(otherDate);
dateCal.clear(Calendar.YEAR);
dateCal.clear(Calendar.MONTH);
dateCal.set(Calendar.DATE, 1);
otherDateCal.clear(Calendar.YEAR);
otherDateCal.clear(Calendar.MONTH);
otherDateCal.set(Calendar.DATE, 1);
switch (withUnit) {
case Calendar.HOUR:
dateCal.clear(Calendar.MINUTE);
otherDateCal.clear(Calendar.MINUTE);
case Calendar.MINUTE:
dateCal.clear(Calendar.SECOND);
otherDateCal.clear(Calendar.SECOND);
case Calendar.SECOND:
dateCal.clear(Calendar.MILLISECOND);
otherDateCal.clear(Calendar.MILLISECOND);
case Calendar.MILLISECOND:
break;
default:
throw new IllegalArgumentException("withUnit 单位字段 " + withUnit + " 不合法！！");
}
return dateCal.compareTo(otherDateCal);
}
/**
* 获得当前的日期毫秒
* @return
*/
public static long nowTimeMillis() {
return System.currentTimeMillis();
}
/**
* 获得当前的unix时间戳，不含毫秒
* @return
*/
public static long nowTimeSecond() {
return System.currentTimeMillis() / 1000;
}
/**
* 获得当前的unix时间戳，不含毫秒
* @return
*/
public static long addNowTimeSecond(long second) {
return System.currentTimeMillis() / 1000 + second;
}
/**
* 获得当前的时间戳
* @return
*/
public static Timestamp nowTimeStamp() {
return new Timestamp(nowTimeMillis());
}
/**
* yyyy-MM-dd 当前日期
*/
public static String getReqDate() {
return getSdf(YMD_DATE_FORMAT_PATTERN).format(new Date());
}
/**
* yyyy-MM-dd 传入日期
* @param date
* @return
*/
public static String getReqDate(Date date) {
return getSdf(SHORT_DATE_FORMAT_PATTERN).format(date);
}
/**
* yyyyMMdd 传入日期
* @param date
* @return
*/
public static String getReqDateyyyyMMdd(Date date) {
return getSdf(YMD_DATE_FORMAT_PATTERN).format(date);
}
/**
* yyyy-MM-dd 传入的时间戳
* @param tmp
* @return
*/
public static String timestampToDateStr(Timestamp tmp) {
return getSdf(SHORT_DATE_FORMAT_PATTERN).format(tmp);
}
/**
* HH:mm:ss 当前时间
* @return
*/
public static String getReqTime() {
return getSdf(TIME_DATE_FORMAT_PATTERN).format(new Date());
}
/**
* HHmmss 当前时间
* @return
*/
public static String getHmsTime() {
return getSdf(HMS_DATE_FORMAT_PATTERN).format(new Date());
}
/**
* yyyyMMddHHmmss 当前时间
* @return
*/
public static String getYmdHmsTime() {
return getSdf(YMDHMS_DATE_FORMAT_PATTERN).format(new Date());
}
/**
* 得到时间戳格式字串
* @param date
* @return
*/
public static String getTimeStampStr(Date date) {
return getSdf(LONG_DATE_FORMAT_PATTERN).format(date);
}
/**
* 得到长日期格式字串
* @return
*/
public static String getLongDateStr() {
return getSdf(LONG_DATE_FORMAT_PATTERN).format(new Date());
}
public static String getLongDateStr(Timestamp time) {
return getSdf(LONG_DATE_FORMAT_PATTERN).format(time);
}
/**
* 得到短日期格式字串
* @param date
* @return
*/
public static String getShortDateStr(Date date) {
return getSdf(SHORT_DATE_FORMAT_PATTERN).format(date);
}
public static String getShortDateStr() {
return getSdf(SHORT_DATE_FORMAT_PATTERN).format(new Date());
}
/**
* 计算 second 秒后的时间
* @param date
* @param second
* @return
*/
public static Date addSecond(Date date, int second) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.SECOND, second);
return calendar.getTime();
}
/**
* 计算 minute 分钟后的时间
* @param date
* @param minute
* @return
*/
public static Date addMinute(Date date, int minute) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.MINUTE, minute);
return calendar.getTime();
}
/**
* 计算 hour 小时后的时间
* @param date
* @param hour
* @return
*/
public static Date addHour(Date date, int hour) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.HOUR, hour);
return calendar.getTime();
}
/**
* 得到day的起始时间点。
* @param date
* @return
*/
public static Date getDayStart(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
return calendar.getTime();
}
/**
* 得到day的终止时间点.
* @param date
* @return
*/
public static Date getDayEnd(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
calendar.add(Calendar.DAY_OF_MONTH, 1);
calendar.add(Calendar.MILLISECOND, -1);
return calendar.getTime();
}
/**
* 计算 day 天后的时间
* @param date
* @param day
* @return
*/
public static Date addDay(Date date, int day) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.DAY_OF_MONTH, day);
return calendar.getTime();
}
/**
* 得到month的终止时间点.
* @param date
* @return
*/
public static Date getMonthEnd(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
calendar.add(Calendar.MONTH, 1);
calendar.add(Calendar.MILLISECOND, -1);
return calendar.getTime();
}
public static Date addYear(Date date, int year) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.DAY_OF_YEAR, 365 * year);
return calendar.getTime();
}
public static Timestamp strToTimestamp(String dateStr) {
return Timestamp.valueOf(dateStr);
}
public static Timestamp strToTimestamp(Date date) {
return Timestamp.valueOf(getSdf(LONG_DATE_FORMAT_PATTERN).format(date));
}
public static Timestamp getCurTimestamp() {
return Timestamp.valueOf(getSdf(LONG_DATE_FORMAT_PATTERN).format(new Date()));
}
/**
* 取得两个日期之间的日数
* @return t1到t2间的日数，如果t2 在 t1之后，返回正数，否则返回负数
*/
public static long daysBetween(java.sql.Timestamp t1, java.sql.Timestamp t2) {
return (t2.getTime() - t1.getTime()) / DAY_MILLI;
}
/**
* 返回java.sql.Timestamp型的SYSDATE
* @return java.sql.Timestamp型的SYSDATE
* @history
* @since 1.0
*/
public static java.sql.Timestamp getSysDateTimestamp() {
return new java.sql.Timestamp(System.currentTimeMillis());
}
/**
* 利用缺省的Date格式(YYYY/MM/DD)转换String到java.sql.Timestamp
* @param sDate Date string
* @return
* @history
* @since 1.0
*/
public static java.sql.Timestamp toSqlTimestamp(String sDate) {
if (sDate == null) {
return null;
}
if (sDate.length() != SHORT_DATE_FORMAT_PATTERN.length()
&& sDate.length() != LONG_DATE_FORMAT_PATTERN.length()) {
return null;
}
return toSqlTimestamp(sDate,
sDate.length() == SHORT_DATE_FORMAT_PATTERN.length() ? SHORT_DATE_FORMAT_PATTERN
: LONG_DATE_FORMAT_PATTERN);
}
/**
* 利用缺省的Date格式(YYYY/MM/DD hh:mm:ss)转化String到java.sql.Timestamp
* @param sDate Date string
* @param sFmt Date format YMD_DATE_FORMAT_PATTERN/TIME_DATE_FORMAT_PATTERN
* @return
* @history
* @since 1.0
*/
public static java.sql.Timestamp toSqlTimestamp(String sDate, String sFmt) {
String temp = null;
if (sDate == null || sFmt == null) {
return null;
}
if (sDate.length() != sFmt.length()) {
return null;
}
if (sFmt.equals(LONG_DATE_FORMAT_PATTERN)) {
temp = sDate.replace('/', '-');
temp = temp + ".000000000";
} else if (sFmt.equals(SHORT_DATE_FORMAT_PATTERN)) {
temp = sDate.replace('/', '-');
temp = temp + " 00:00:00.000000000";
} else {
return null;
}
return java.sql.Timestamp.valueOf(temp);
}
/**
* 以YYYY/MM/DD HH24:MI:SS格式返回系统日期时间
* @return 系统日期时间
* @history
* @since 1.0
*/
public static String getSysDateTimeString() {
return toString(new java.util.Date(System.currentTimeMillis()), getSdf(LONG_DATE_FORMAT_PATTERN));
}
/**
* 根据指定的Format转化java.util.Date到String
* @param dt java.util.Date instance
* @param sFmt Date format , YMD_DATE_FORMAT_PATTERN or TIME_DATE_FORMAT_PATTERN
* @return
* @history
* @since 1.0
*/
public static String toString(java.util.Date dt, String sFmt) {
if (dt == null || sFmt == null || "".equals(sFmt)) {
return "";
}
return toString(dt, getSdf(sFmt));
}
/**
* 利用指定SimpleDateFormat instance转换java.util.Date到String
* @param dt java.util.Date instance
* @param formatter SimpleDateFormat Instance
* @return
* @history
* @since 1.0
*/
private static String toString(java.util.Date dt, SimpleDateFormat formatter) {
String sRet = null;
try {
sRet = formatter.format(dt);
} catch (Exception e) {
logger.error("error:", e);
sRet = null;
}
return sRet;
}
/**
* 转换java.sql.Timestamp到String，格式为YYYY/MM/DD HH24:MI
* @param dt java.sql.Timestamp instance
* @return
* @history
* @since 1.0
*/
public static String toSqlTimestampString2(java.sql.Timestamp dt) {
if (dt == null) {
return null;
}
String temp = toSqlTimestampString(dt, LONG_DATE_FORMAT_PATTERN);
return temp.substring(0, 16);
}
public static String toString(java.sql.Timestamp dt) {
return dt == null ? "" : toSqlTimestampString2(dt);
}
/**
* 根据指定的格式转换java.sql.Timestamp到String
* @param dt java.sql.Timestamp instance
* @param sFmt Date 格式，YMD_DATE_FORMAT_PATTERN/TIME_DATE_FORMAT_PATTERN/
* DATE_FORMAT_SESSION
* @return
* @history
* @since 1.0
*/
public static String toSqlTimestampString(java.sql.Timestamp dt, String sFmt) {
String temp = null;
String out = null;
if (dt == null || sFmt == null) {
return null;
}
temp = dt.toString();
if (sFmt.equals(LONG_DATE_FORMAT_PATTERN) || sFmt.equals(SHORT_DATE_FORMAT_PATTERN)) {
temp = temp.substring(0, sFmt.length());
out = temp.replace('/', '-');
}
return out;
}
/**
* 得到当前日期的星期
* @return
*/
public static int getWeek() {
Calendar cal = Calendar.getInstance();
cal.setTime(new Date());
return cal.get(Calendar.DAY_OF_WEEK);
}
/**
* Timestamp 格式转换成yyyy-MM-dd timestampToSql(Timestamp 格式转换成yyyy-MM-dd)
* @param timestamp 时间
* @return createTimeStr yyyy-MM-dd 时间
* @Exception 异常对象
* @since V1.0
*/
public static String timestampToStringYMD(java.sql.Timestamp timestamp) {
return getSdf(SHORT_DATE_FORMAT_PATTERN).format(timestamp);
}
/**
* 判断一个时间是否在某个时间区间内
* @param now 目标时间
* @param start 时间区间开始
* @param end 时间区间结束
* @param model 区间模式
* @return 是否在区间内
*/
public static boolean isBetween(Date now, Date start, Date end, int model) {
return isBetween(now, start, end, model, COMP_MODEL_DATE);
}
/**
* 判断时间是否在制定的时间段之类
* @param date 需要判断的时间
* @param start 时间段的起始时间
* @param end 时间段的截止时间
* @param interModel 区间的模式
* 取值：
* LEFT_OPEN_RIGHT_OPEN
* LEFT_CLOSE_RIGHT_OPEN
* LEFT_OPEN_RIGHT_CLOSE
* LEFT_CLOSE_RIGHT_CLOSE
* @param compModel 比较的模式
* 取值：
* COMP_MODEL_DATE 只比较日期，不比较时间
* COMP_MODEL_TIME 只比较时间，不比较日期
* COMP_MODEL_DATETIME 比较日期，也比较时间
* @return
*/
public static boolean isBetween(Date date, Date start, Date end, int interModel, int compModel) {
if (date == null || start == null || end == null) {
throw new IllegalArgumentException("日期不能为空");
}
SimpleDateFormat format = null;
switch (compModel) {
case COMP_MODEL_DATE: {
format = getSdf(YMD_DATE_FORMAT_PATTERN);
break;
}
case COMP_MODEL_TIME: {
format = getSdf(HMS_DATE_FORMAT_PATTERN);
break;
}
case COMP_MODEL_DATETIME: {
format = getSdf(YMDHMS_DATE_FORMAT_PATTERN);
break;
}
default: {
throw new IllegalArgumentException(String.format("日期的比较模式[%d]有误", compModel));
}
}
long dateNumber = Long.parseLong(format.format(date));
long startNumber = Long.parseLong(format.format(start));
long endNumber = Long.parseLong(format.format(end));
switch (interModel) {
case LEFT_OPEN_RIGHT_OPEN: {
if (dateNumber <= startNumber || dateNumber >= endNumber) {
return false;
} else {
return true;
}
}
case LEFT_CLOSE_RIGHT_OPEN: {
if (dateNumber < startNumber || dateNumber >= endNumber) {
return false;
} else {
return true;
}
}
case LEFT_OPEN_RIGHT_CLOSE: {
if (dateNumber <= startNumber || dateNumber > endNumber) {
return false;
} else {
return true;
}
}
case LEFT_CLOSE_RIGHT_CLOSE: {
if (dateNumber < startNumber || dateNumber > endNumber) {
return false;
} else {
return true;
}
}
default: {
throw new IllegalArgumentException(String.format("日期的区间模式[%d]有误", interModel));
}
}
}
/**
* 得到当前周起始时间
* @param date
* @return
*/
public static Date getWeekStart(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.get(Calendar.WEEK_OF_YEAR);
int firstDay = calendar.getFirstDayOfWeek();
calendar.set(Calendar.DAY_OF_WEEK, firstDay);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
return calendar.getTime();
}
/**
* 得到当前周截止时间
* @param date
* @return
*/
public static Date getWeekEnd(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.get(Calendar.WEEK_OF_YEAR);
int firstDay = calendar.getFirstDayOfWeek();
calendar.set(Calendar.DAY_OF_WEEK, 8 - firstDay);
calendar.set(Calendar.HOUR_OF_DAY, 23);
calendar.set(Calendar.MINUTE, 59);
calendar.set(Calendar.SECOND, 59);
calendar.set(Calendar.MILLISECOND, 0);
return calendar.getTime();
}
/**
* 得到当月起始时间
* @param date
* @return
*/
public static Date getMonthStart(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
return calendar.getTime();
}
/**
* 得到当前年起始时间
* @param date
* @return
*/
public static Date getYearStart(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.YEAR, calendar.get(Calendar.YEAR));
calendar.set(Calendar.MONTH, 0);
calendar.set(Calendar.DAY_OF_MONTH, 1);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
return calendar.getTime();
}
/**
* 得到当前年最后一天
* @param date
* @return
*/
public static Date getYearEnd(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.YEAR, calendar.get(Calendar.YEAR));
calendar.set(Calendar.MONTH, 11);
calendar.set(Calendar.DAY_OF_MONTH, 31);
calendar.set(Calendar.HOUR_OF_DAY, 23);
calendar.set(Calendar.MINUTE, 59);
calendar.set(Calendar.SECOND, 59);
calendar.set(Calendar.MILLISECOND, 0);
return calendar.getTime();
}
/**
* 取得月天数
* @param date
* @return
*/
public static int getDayOfMonth(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
return c.getActualMaximum(Calendar.DAY_OF_MONTH);
}
/**
* 取得月第一天
* @param date
* @return
*/
public static Date getFirstDateOfMonth(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
c.set(Calendar.DAY_OF_MONTH, c.getActualMinimum(Calendar.DAY_OF_MONTH));
return c.getTime();
}
/**
* 取得月最后一天
* @param date
* @return
*/
public static Date getLastDateOfMonth(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
c.set(Calendar.DAY_OF_MONTH, c.getActualMaximum(Calendar.DAY_OF_MONTH));
return c.getTime();
}
/**
* 取得季度第一天
* @param date
* @return
*/
public static Date getSeasonStart(Date date) {
return getDayStart(getFirstDateOfMonth(getSeasonDate(date)[0]));
}
/**
* 取得季度最后一天
* @param date
* @return
*/
public static Date getSeasonEnd(Date date) {
return getDayEnd(getLastDateOfMonth(getSeasonDate(date)[2]));
}
/**
* 取得季度月
* @param date
* @return
*/
public static Date[] getSeasonDate(Date date) {
Date[] season = new Date[3];
Calendar c = Calendar.getInstance();
c.setTime(date);
int nSeason = getSeason(date);
if (nSeason == 1) {// 第一季度
c.set(Calendar.MONTH, Calendar.JANUARY);
season[0] = c.getTime();
c.set(Calendar.MONTH, Calendar.FEBRUARY);
season[1] = c.getTime();
c.set(Calendar.MONTH, Calendar.MARCH);
season[2] = c.getTime();
} else if (nSeason == 2) {// 第二季度
c.set(Calendar.MONTH, Calendar.APRIL);
season[0] = c.getTime();
c.set(Calendar.MONTH, Calendar.MAY);
season[1] = c.getTime();
c.set(Calendar.MONTH, Calendar.JUNE);
season[2] = c.getTime();
} else if (nSeason == 3) {// 第三季度
c.set(Calendar.MONTH, Calendar.JULY);
season[0] = c.getTime();
c.set(Calendar.MONTH, Calendar.AUGUST);
season[1] = c.getTime();
c.set(Calendar.MONTH, Calendar.SEPTEMBER);
season[2] = c.getTime();
} else if (nSeason == 4) {// 第四季度
c.set(Calendar.MONTH, Calendar.OCTOBER);
season[0] = c.getTime();
c.set(Calendar.MONTH, Calendar.NOVEMBER);
season[1] = c.getTime();
c.set(Calendar.MONTH, Calendar.DECEMBER);
season[2] = c.getTime();
}
return season;
}
/**
* 1 第一季度 2 第二季度 3 第三季度 4 第四季度
* @param date
* @return
*/
public static int getSeason(Date date) {
int season = 0;
Calendar c = Calendar.getInstance();
c.setTime(date);
int month = c.get(Calendar.MONTH);
switch (month) {
case Calendar.JANUARY:
case Calendar.FEBRUARY:
case Calendar.MARCH:
season = 1;
break;
case Calendar.APRIL:
case Calendar.MAY:
case Calendar.JUNE:
season = 2;
break;
case Calendar.JULY:
case Calendar.AUGUST:
case Calendar.SEPTEMBER:
season = 3;
break;
case Calendar.OCTOBER:
case Calendar.NOVEMBER:
case Calendar.DECEMBER:
season = 4;
break;
default:
break;
}
return season;
}
/**
* 字符串转date
* @param dateString
* @return
*/
public static Date stringToDate(String dateString) {
Date date = null;
try {
date = getSdf(YMD_DATE_FORMAT_PATTERN1).parse(dateString);
} catch (ParseException e) {
logger.error("error:", e);
}
return date;
}
/**
* 字符串转date
* @param dateString
* @return
*/
public static Date stringToShortDate(String dateString) {
Date date = null;
try {
date = getSdf(SHORT_DATE_FORMAT_PATTERN).parse(dateString);
} catch (ParseException e) {
logger.error("error:", e);
}
return date;
}
/**
* 字符串转换datetime
* @param dateString
* @return
*/
public static Date stringToDateTime(String dateString) {
Date date = null;
try {
date = getSdf(LONG_DATE_FORMAT_PATTERN).parse(dateString);
} catch (ParseException e) {
logger.error("error:", e);
}
return date;
}
/**
* 判断输入日期是一个星期中的第几天(星期天为一个星期第一天)
* @param date
* @return
*/
public static int getWeekIndex(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
return calendar.get(Calendar.DAY_OF_WEEK);
}
/**
* 当前时间的前几天，并且以例如2013/12/09 00:00:00 形式输出
*/
public static Date subDays(int days) {
Date date = addDay(new Date(), -days);
String dateStr = getReqDate(date);
Date date1 = null;
try {
date1 = getSdf(SHORT_DATE_FORMAT_PATTERN).parse(dateStr);
} catch (ParseException e) {
logger.error("error:", e);
}
return date1;
}
/**
* 判断开始时间和结束时间，是否超出了当前时间的一定的间隔数限制 如：开始时间和结束时间，不能超出距离当前时间90天
* @param startDate 开始时间
* @param endDate 结束时间按
* @param interval 间隔数
* @param dateUnit 单位(如：月，日),参照Calendar的时间单位
* @return
*/
public static boolean isOverIntervalLimit(Date startDate, Date endDate, int interval, int dateUnit) {
Calendar cal = Calendar.getInstance();
cal.setTime(new Date());
cal.add(dateUnit, interval * (-1));
Date curDate = getDayStart(cal.getTime());
if (getDayStart(startDate).compareTo(curDate) < 0 || getDayStart(endDate).compareTo(curDate) < 0) {
return true;
}
return false;
}
/**
* 判断开始时间和结束时间，是否超出了当前时间的一定的间隔数限制, 时间单位默认为天数 如：开始时间和结束时间，不能超出距离当前时间90天
* @param startDate 开始时间
* @param endDate 结束时间按
* @param interval 间隔数
* @return
*/
public static boolean isOverIntervalLimit(Date startDate, Date endDate, int interval) {
Calendar cal = Calendar.getInstance();
cal.setTime(new Date());
cal.add(Calendar.DAY_OF_MONTH, interval * (-1));
Date curDate = getDayStart(cal.getTime());
if (getDayStart(startDate).compareTo(curDate) < 0 || getDayStart(endDate).compareTo(curDate) < 0) {
return true;
}
return false;
}
/**
* 判断开始时间和结束时间，是否超出了当前时间的一定的间隔数限制, 时间单位默认为天数 如：开始时间和结束时间，不能超出距离当前时间90天
* @param startDateStr 开始时间
* @param endDateStr 结束时间按
* @param interval 间隔数
* @return
*/
public static boolean isOverIntervalLimit(String startDateStr, String endDateStr, int interval) {
Date startDate = null;
Date endDate = null;
try {
startDate = parseDate(startDateStr, SHORT_DATE_FORMAT_PATTERN);
endDate = parseDate(endDateStr, SHORT_DATE_FORMAT_PATTERN);
} catch (ParseException e) {
logger.error("error:", e);
return false;
}
return isOverIntervalLimit(startDate, endDate, interval);
}
/**
* 传入时间字符串及时间格式，返回对应的Date对象
* @param src 时间字符串
* @param pattern 时间格式
* @return Date
*/
public static Date getDateFromString(String src, String pattern) {
try {
return getSdf(pattern).parse(src);
} catch (ParseException e) {
logger.error("error:", e);
return null;
}
}
/**
* 取季度
* @param date
* @return
*/
@SuppressWarnings("deprecation")
public static int getQuarter(Date date) {
if (date.getMonth() == 0 || date.getMonth() == 1 || date.getMonth() == 2) {
return 1;
} else if (date.getMonth() == 3 || date.getMonth() == 4 || date.getMonth() == 5) {
return 2;
} else if (date.getMonth() == 6 || date.getMonth() == 7 || date.getMonth() == 8) {
return 3;
} else if (date.getMonth() == 9 || date.getMonth() == 10 || date.getMonth() == 11) {
return 4;
} else {
return 0;
}
}
/**
* 取得通用日期时间格式字符串
* @param date
* @return String
*/
public static String formatDate(Date date) {
if (date == null) {
return "";
}
return getSdf(LONG_DATE_FORMAT_PATTERN).format(date);
}
/**
* 获取当日的日期格式串
* @return String
*/
public static String today() {
return formatDate(new Date(), SHORT_DATE_FORMAT_PATTERN);
}
/**
* 获取当前时间格式串
* @return String
*/
public static String currentTime() {
return formatDate(new Date(), YMDHMSS_DATE_FORMAT_PATTERN);
}
/**
* 取得指定日期格式的字符串
* @param date
* @return pattern
*/
public static String formatDate(Date date, String pattern) {
return getSdf(pattern).format(date);
}
/**
* 获取昨日的日期格式串
* @return Date
*/
public static String getYesterday() {
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DATE, -1);
return formatDate(calendar.getTime(), SHORT_DATE_FORMAT_PATTERN);
}
/**
* 判断当前时间是否在一定的时间范围内
* @param startTime
* @return boolean
*/
public static boolean isInBetweenTimes(String startTime, String endTime) {
Date nowTime = new Date();
String time = getSdf(TIME_DATE_FORMAT_PATTERN).format(nowTime);
if (time.compareTo(startTime) >= 0 && time.compareTo(endTime) <= 0) {
return true;
} else {
return false;
}
}
/**
* 判断当前日期是否在一定的时间范围内
* @param startDate
* @param endDate
* @return
*/
public static boolean isInBetweenDate(String startDate, String endDate) {
Date now = new Date();
String date = getSdf(SHORT_DATE_FORMAT_PATTERN).format(now);
if (date.compareTo(startDate) >= 0 && date.compareTo(endDate) <= 0) {
return true;
} else {
return false;
}
}
/**
* 判断当前日期是否在一定的时间范围内
* @param startDate
* @param endDate
* @return
*/
public static boolean isInBetweenDate(Date startDate, Date endDate) {
Date now = new Date();
String date = getSdf(SHORT_DATE_FORMAT_PATTERN).format(now);
if (date.compareTo(getSdf(SHORT_DATE_FORMAT_PATTERN).format(startDate)) >= 0
&& date.compareTo(getSdf(SHORT_DATE_FORMAT_PATTERN).format(endDate)) <= 0) {
return true;
} else {
return false;
}
}
/**
* 字符转日期
* @param dateStr
* @return
*/
public static Date getDateByStr(String dateStr) {
SimpleDateFormat formatter = null;
if (dateStr == null) {
return null;
} else if (dateStr.length() == 10) {
formatter = getSdf(SHORT_DATE_FORMAT_PATTERN);
} else if (dateStr.length() == 16) {
formatter = getSdf(YMDHM_DATE_FORMAT_PATTERN);
} else if (dateStr.length() == 19) {
formatter = getSdf(LONG_DATE_FORMAT_PATTERN);
} else if (dateStr.length() > 19) {
dateStr = dateStr.substring(0, 19);
formatter = getSdf(LONG_DATE_FORMAT_PATTERN);
} else {
return null;
}
try {
return formatter.parse(dateStr);
} catch (ParseException e) {
logger.error("error:", e);
return null;
}
}
/**
* 根据传入的数字，输出相比现在days天的数据
* @param days
* @return Date
*/
public static Date getDate(int days) {
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DATE, days);
return calendar.getTime();
}
/**
* 根据传入的数字，输出相比现在days天的数据
* @param days
* @return Date
*/
public static Date getDate(String currentDate, int days) {
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DATE, days);
return calendar.getTime();
}
/**
* 日期最大时间
* @param dt
* @return
*/
public static Date getMaxTime(Date dt) {
Date dt1 = null;
Calendar ca = Calendar.getInstance();
ca.setTime(dt);
ca.add(Calendar.DAY_OF_MONTH, 1);
dt1 = ca.getTime();
dt1 = getMinTime(dt1);
ca.setTime(dt1);
ca.add(Calendar.SECOND, -1);
dt1 = ca.getTime();
return dt1;
}
/**
* 日期最小时间
* @param dt
* @return
*/
public static Date getMinTime(Date dt) {
return getDateByStr(formatDate(dt, SHORT_DATE_FORMAT_PATTERN));
}
/**
* 月的最后一天
* @param date
* @return
*/
@SuppressWarnings("deprecation")
public static Date getLastDayOfMonth(Date date) {
Calendar cDay1 = Calendar.getInstance();
cDay1.setTime(date);
int lastDay = cDay1.getActualMaximum(Calendar.DAY_OF_MONTH);
Date lastDate = cDay1.getTime();
lastDate.setDate(lastDay);
return lastDate;
}
/**
* 月的第一天
* @param date
* @return
*/
public static Date getFirstDayOfMonth(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.DATE, calendar.getActualMinimum(Calendar.DATE));
return calendar.getTime();
}
/**
* 上月第一天
* @return
*/
public static Date getPreviousMonthFirstDay() {
Calendar lastDate = Calendar.getInstance();
// 设为当前月的1号
lastDate.set(Calendar.DATE, 1);
// 减一个月，变为下月的1号
lastDate.add(Calendar.MONTH, -1);
return getMinTime(lastDate.getTime());
}
/**
* 上月最后一天
* @return
*/
public static Date getPreviousMonthLastDay() {
Calendar lastDate = Calendar.getInstance();
// 设为当前月的1号
lastDate.set(Calendar.DATE, 1);
lastDate.add(Calendar.DATE, -1);
return getMinTime(lastDate.getTime());
}
/**
* 两个日期相关天数
* @param startDate
* @param endDate
* @return
*/
public static long getDateDiff(String startDate, String endDate) {
long diff = 0;
try {
Date date1 = getSdf(SHORT_DATE_FORMAT_PATTERN).parse(startDate);
Date date2 = getSdf(SHORT_DATE_FORMAT_PATTERN).parse(endDate);
diff = (date1.getTime() - date2.getTime()) / (24 * 60 * 60 * 1000) > 0
? (date1.getTime() - date2.getTime()) / (24 * 60 * 60 * 1000)
: (date2.getTime() - date1.getTime()) / (24 * 60 * 60 * 1000);
} catch (ParseException e) {
logger.error("error:", e);
}
return diff;
}
public static long getDateDiff(Date date1, Date date2) {
if (ValidateUtils.isEmpty(date1) || ValidateUtils.isEmpty(date1)) {
return 0L;
}
long diff = (date1.getTime() - date2.getTime()) / (24 * 60 * 60 * 1000) > 0
? (date1.getTime() - date2.getTime()) / (24 * 60 * 60 * 1000)
: (date2.getTime() - date1.getTime()) / (24 * 60 * 60 * 1000);
return diff;
}
/**
* 判断两个时间是不是在一个周中
*/
public static boolean isSameWeekWithToday(Date date) {
if (date == null) {
return false;
}
// 0.先把Date类型的对象转换Calendar类型的对象
Calendar todayCal = Calendar.getInstance();
Calendar dateCal = Calendar.getInstance();
todayCal.setTime(new Date());
dateCal.setTime(date);
int subYear = todayCal.get(Calendar.YEAR) - dateCal.get(Calendar.YEAR);
// subYear==0,说明是同一年
if (subYear == 0) {
if (todayCal.get(Calendar.WEEK_OF_YEAR) == dateCal.get(Calendar.WEEK_OF_YEAR)) {
return true;
}
} else if (subYear == 1 && dateCal.get(Calendar.MONTH) == 11 && todayCal.get(Calendar.MONTH) == 0) {
if (todayCal.get(Calendar.WEEK_OF_YEAR) == dateCal.get(Calendar.WEEK_OF_YEAR)) {
return true;
}
} else if (subYear == -1 && todayCal.get(Calendar.MONTH) == 11 && dateCal.get(Calendar.MONTH) == 0) {
if (todayCal.get(Calendar.WEEK_OF_YEAR) == dateCal.get(Calendar.WEEK_OF_YEAR)) {
return true;
}
}
return false;
}
/**
* getStrFormTime: <br/>
* @param form 格式时间
* @param date 时间
* @return
*/
public static String getStrFormTime(String form, Date date) {
return getSdf(form).format(date);
}
/**
* 获取几天内日期 return 2014-5-4、2014-5-3
*/
public static List<String> getLastDays(int countDay) {
List<String> listDate = new ArrayList<>();
for (int i = 0; i < countDay; i++) {
listDate.add(getReqDateyyyyMMdd(getDate(-i)));
}
return listDate;
}
/**
* 获取几天内日期 return 2014-5-4、2014-5-3
*/
public static List<String> getLastDays(String currentDate, int countDay) {
Date date = stringToShortDate(currentDate);
List<String> listDate = new ArrayList<>();
for (int i = 0; i < countDay; i++) {
listDate.add(getReqDate(addDay(date, -i)));
}
return listDate;
}
/**
* 对时间进行格式化
* @param date
* @return
*/
public static Date dateFormat(Date date) {
SimpleDateFormat sdf = getSdf(SHORT_DATE_FORMAT_PATTERN);
Date value = new Date();
try {
value = sdf.parse(sdf.format(date));
} catch (ParseException e) {
logger.error("error:", e);
}
return value;
}
/**
* 比较两个时间差
* @param endDate
* @param nowDate
* @return
*/
public static String datePoor(Date endDate, Date nowDate) {
if (endDate == null || nowDate == null) {
return null;
}
long nd = 1000 * 24 * 60 * 60;
long nh = 1000 * 60 * 60;
long nm = 1000 * 60;
// long ns = 1000;
// 获得两个时间的毫秒时间差异
long diff = endDate.getTime() - nowDate.getTime();
// 计算差多少天
long day = diff / nd;
// 计算差多少小时
long hour = diff % nd / nh;
// 计算差多少分钟
long min = diff % nd % nh / nm;
// 计算差多少秒//输出结果
return String.valueOf(day) + "天" + hour + "小时" + min + "分钟";
}
/**
* 获取两个时间差，时，分，秒
* @param endDate
* @param nowDate
* @return
*/
public static long[] getDatePoor(Date endDate, Date nowDate) {
if (endDate == null || nowDate == null) {
return null;
}
long nd = 1000 * 24 * 60 * 60;
long nh = 1000 * 60 * 60;
long nm = 1000 * 60;
// long ns = 1000;
// 获得两个时间的毫秒时间差异
long diff = endDate.getTime() - nowDate.getTime();
// 计算差多少天
long day = diff / nd;
// 计算差多少小时
long hour = diff % nd / nh;
// 计算差多少分钟
long min = diff % nd % nh / nm;
// 计算差多少秒//输出结果
return new long[]{day, hour, min};
}
/**
* 获取下一周最后一天
* @return
*/
public static Date getLastDayOfNextWeek() {
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.WEEK_OF_YEAR, 1);
while (calendar.get(Calendar.DAY_OF_WEEK) != Calendar.SUNDAY) {
calendar.add(Calendar.DATE, 1);
}
return calendar.getTime();
}
/**
* 获取今天开始时间
* @return
*/
public static Date getDayBegin() {
Calendar cal = new GregorianCalendar();
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
return cal.getTime();
}
/**
* 获取今天结束时间
* @return
*/
public static Date getDayEnd() {
Calendar cal = new GregorianCalendar();
cal.set(Calendar.HOUR_OF_DAY, 23);
cal.set(Calendar.MINUTE, 59);
cal.set(Calendar.SECOND, 59);
return cal.getTime();
}
/**
* 获取某个日期的开始时间
* @param day
* @return
*/
public static Timestamp getDayStartTime(Date day) {
Calendar calendar = Calendar.getInstance();
if (null != day) {
calendar.setTime(day);
}
calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), calendar.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
calendar.set(Calendar.MILLISECOND, 0);
return new Timestamp(calendar.getTimeInMillis());
}
/**
* 获取某个日期的结束时间
* @param day 日期
* @return
*/
public static Timestamp getDayEndTime(Date day) {
Calendar calendar = Calendar.getInstance();
if (null != day) {
calendar.setTime(day);
}
calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), calendar.get(Calendar.DAY_OF_MONTH), 23, 59, 59);
calendar.set(Calendar.MILLISECOND, 999);
return new Timestamp(calendar.getTimeInMillis());
}
/**
* 获取昨天开始时间
* @return
*/
public static Date getBeginDayOfYesterday() {
Calendar cal = new GregorianCalendar();
cal.setTime(getDayBegin());
cal.add(Calendar.DAY_OF_MONTH, -1);
return cal.getTime();
}
/**
* 获取昨天的结束时间
* @return
*/
public static Date getEndDayOfYesterDay() {
Calendar cal = new GregorianCalendar();
cal.setTime(getDayEnd());
cal.add(Calendar.DAY_OF_MONTH, -1);
return cal.getTime();
}
}
pcloud-solr/pom.xml 0 → 100644
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://maven.apache.org/POM/4.0.0"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.pcloud.common</groupId>
<artifactId>pcloud-common-parent</artifactId>
<version>2.1.0-SNAPSHOT</version>
</parent>
<artifactId>pcloud-solr</artifactId>
<packaging>jar</packaging>
<version>${pcloud-solr.version}</version>
<name>pcloud-solr</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>com.pcloud.common</groupId>
<artifactId>pcloud-common-config</artifactId>
<version>${pcloud-common-config.version}</version>
</dependency>
<!-- solr add by gaop at 2018-4-23 11:33:47 -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-solr</artifactId>
<version>${spring.data.solr.version}</version>
</dependency>
<!-- Spring Cloud Begin -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<!-- Spring Cloud End -->
<!-- Common Dependency Begin -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.18</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.4</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.38</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.1</version>
</dependency>
<!-- Common Dependency End -->
</dependencies>
</project>
pcloud-common/src/main/java/com/pcloud/common/utils/solr/SolrDto.java → pcloud-solr/src/main/java/com/pcloud/solr/SolrDto.java
package com.pcloud.common.utils.solr;
package com.pcloud.solr;
import java.io.Serializable;
import java.util.Calendar;
......
pcloud-common/src/main/java/com/pcloud/common/utils/solr/SolrQueryParam.java → pcloud-solr/src/main/java/com/pcloud/solr/SolrQueryParam.java
package com.pcloud.common.utils.solr;
package com.pcloud.solr;
import java.util.List;
import java.util.Map;
......
pcloud-common/src/main/java/com/pcloud/common/utils/solr/SolrResult.java → pcloud-solr/src/main/java/com/pcloud/solr/SolrResult.java
package com.pcloud.common.utils.solr;
package com.pcloud.solr;
import java.io.Serializable;
import java.util.List;
......@@ -8,7 +8,7 @@ import java.util.List;
* @author PENG
* @date 2018/4/24
*/
public class SolrResult implements Serializable {
public class SolrResult<T> implements Serializable {
private static final long serialVersionUID = 1195918725820896691L;
......@@ -25,7 +25,7 @@ public class SolrResult implements Serializable {
/**
* 查询结果列表
*/
private List<SolrDto> list;
private List<T> list;
public Integer getTotalCount() {
return totalCount;
......@@ -43,11 +43,11 @@ public class SolrResult implements Serializable {
this.maxScore = maxScore;
}
public List<SolrDto> getList() {
public List<T> getList() {
return list;
}
public void setList(List<SolrDto> list) {
public void setList(List<T> list) {
this.list = list;
}
......
pcloud-common/src/main/java/com/pcloud/common/utils/solr/SolrUtils.java → pcloud-solr/src/main/java/com/pcloud/solr/SolrUtils.java
package com.pcloud.common.utils.solr;
package com.pcloud.solr;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.solr.client.solrj.SolrClient;
import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.impl.CloudSolrClient;
......@@ -21,8 +23,6 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
import com.pcloud.common.utils.DateUtils;
import com.pcloud.common.utils.ListUtils;
/**
* Description solr全文检索工具类
......@@ -39,7 +39,7 @@ public class SolrUtils {
private static String defaultCollection;
private static CloudSolrClient solrClient;
protected static CloudSolrClient solrClient;
/**
* 新增或修改索引（id主键存在时为更新）
......@@ -52,6 +52,15 @@ public class SolrUtils {
/**
* 新增或修改索引（id主键存在时为更新）
* @param object solr索引DTO
* @return 是否成功
*/
public static Boolean addObject(Object object) {
return addObject(getDefaultCollection(), object);
}
/**
* 新增或修改索引（id主键存在时为更新）
* @param collection 索引集
* @param solrDto solr索引DTO
* @return 是否成功
......@@ -68,6 +77,23 @@ public class SolrUtils {
}
/**
* 新增或修改索引（id主键存在时为更新）
* @param collection 索引集
* @param object solr索引DTO
* @return 是否成功
*/
public static Boolean addObject(String collection, Object object) {
try {
solrClient.addBean(collection, object);
solrClient.commit(collection);
} catch (Exception e) {
LOGGER.error("solr新增索引失败:" + e.getMessage(), e);
return false;
}
return true;
}
/**
* 批量新增或修改索引（id主键存在时为更新）
* @param list solr索引DTO列表
* @return 是否成功
......@@ -78,6 +104,15 @@ public class SolrUtils {
/**
* 批量新增或修改索引（id主键存在时为更新）
* @param list solr索引DTO列表
* @return 是否成功
*/
public static Boolean addObject(List<Object> list) {
return addObject(getDefaultCollection(), list);
}
/**
* 批量新增或修改索引（id主键存在时为更新）
* @param collection 索引集
* @param list solr索引DTO列表
* @return 是否成功
......@@ -94,6 +129,23 @@ public class SolrUtils {
}
/**
* 批量新增或修改索引（id主键存在时为更新）
* @param collection 索引集
* @param list solr索引DTO列表
* @return 是否成功
*/
public static Boolean addObject(String collection, List<SolrDto> list) {
try {
solrClient.addBeans(collection, list);
solrClient.commit(collection);
} catch (Exception e) {
LOGGER.error("solr批量新增索引失败:" + e.getMessage(), e);
return false;
}
return true;
}
/**
* 根据id主键删除索引
* @param id id主键
* @return 是否成功
......@@ -156,6 +208,15 @@ public class SolrUtils {
/**
* 根据id主键获取索引
* @param id id主键
* @return SolrDto
*/
public static SolrDocument getObjectById(String id) {
return getObjectById(getDefaultCollection(), id);
}
/**
* 根据id主键获取索引
* @param collection 索引集
* @param id id主键
* @return SolrDto
......@@ -175,6 +236,21 @@ public class SolrUtils {
}
/**
* 根据id主键获取索引
* @param collection 索引集
* @param id id主键
* @return SolrDto
*/
public static SolrDocument getObjectById(String collection, String id) {
try {
return solrClient.getById(collection, id);
} catch (Exception e) {
LOGGER.error("solr根据id查询索引失败:" + e.getMessage(), e);
return null;
}
}
/**
* 根据id主键列表批量获取索引
* @param ids id主键列表
* @return SolrDto Map
......@@ -185,13 +261,22 @@ public class SolrUtils {
/**
* 根据id主键列表批量获取索引
* @param ids id主键列表
* @return SolrDto Map
*/
public static Map<String, SolrDocument> mapObjectByIds(List<String> ids) {
return mapObjectByIds(getDefaultCollection(), ids);
}
/**
* 根据id主键列表批量获取索引
* @param collection 索引集
* @param ids id主键列表
* @return SolrDto Map
*/
public static Map<String, SolrDto> getById(String collection, List<String> ids) {
try {
if (ListUtils.isEmpty(ids)) {
if (null == ids || ids.isEmpty()) {
return null;
}
SolrDocumentList documents = solrClient.getById(collection, ids);
......@@ -211,6 +296,33 @@ public class SolrUtils {
}
/**
* 根据id主键列表批量获取索引
* @param collection 索引集
* @param ids id主键列表
* @return SolrDto Map
*/
public static Map<String, SolrDocument> mapObjectByIds(String collection, List<String> ids) {
try {
if (null == ids || ids.isEmpty()) {
return null;
}
SolrDocumentList documents = solrClient.getById(collection, ids);
if (null != documents) {
Map<String, SolrDocument> map = new HashMap<>();
for (SolrDocument document : documents) {
map.put((String) document.get("id"), document);
}
return map;
} else {
return null;
}
} catch (Exception e) {
LOGGER.error("solr根据id批量查询索引失败:" + e.getMessage(), e);
return null;
}
}
/**
* 查询
* @param param 查询参数
* @return SolrResult
......@@ -221,18 +333,27 @@ public class SolrUtils {
/**
* 查询
* @param param 查询参数
* @return SolrResult
*/
public static SolrResult<SolrDocument> searchObject(SolrQueryParam param) {
return searchObject(getDefaultCollection(), param);
}
/**
* 查询
* @param collection 索引集
* @param param 查询参数
* @return SolrResult
*/
public static SolrResult search(String collection, SolrQueryParam param) {
public static SolrResult<SolrDto> search(String collection, SolrQueryParam param) {
try {
SolrQuery solrQuery = formatQueryParam(param);
solrQuery.set("wt", "json");
QueryResponse response = solrClient.query(collection, solrQuery);
SolrDocumentList documents = response.getResults();
LOGGER.info("solr查询结果：" + documents.toString());
SolrResult solrResult = new SolrResult();
SolrResult<SolrDto> solrResult = new SolrResult<SolrDto>();
solrResult.setTotalCount(Integer.parseInt(documents.getNumFound() + ""));
solrResult.setMaxScore(documents.getMaxScore());
List<SolrDto> list = new ArrayList<>();
......@@ -249,6 +370,34 @@ public class SolrUtils {
}
/**
* 查询
* @param collection 索引集
* @param param 查询参数
* @return SolrResult
*/
public static SolrResult<SolrDocument> searchObject(String collection, SolrQueryParam param) {
try {
SolrQuery solrQuery = formatQueryParam(param);
solrQuery.set("wt", "json");
QueryResponse response = solrClient.query(collection, solrQuery);
SolrDocumentList documents = response.getResults();
LOGGER.info("solr查询结果：" + documents.toString());
SolrResult<SolrDocument> solrResult = new SolrResult<>();
solrResult.setTotalCount(Integer.parseInt(documents.getNumFound() + ""));
solrResult.setMaxScore(documents.getMaxScore());
List<SolrDocument> list = new ArrayList<>();
for (SolrDocument document : documents) {
list.add(document);
}
solrResult.setList(list);
return solrResult;
} catch (Exception e) {
LOGGER.error("solr查询索引失败:" + e.getMessage(), e);
return null;
}
}
/**
* 将solr返回的document转换成solrDto
* @param document solr文档
* @return SolrDto
......@@ -287,7 +436,7 @@ public class SolrUtils {
* @param param solr查询参数
* @return SolrQuery
*/
private static SolrQuery formatQueryParam(SolrQueryParam param) {
protected static SolrQuery formatQueryParam(SolrQueryParam param) {
SolrQuery solrQuery = new SolrQuery();
if (null == param) {
param = new SolrQueryParam();
......@@ -297,7 +446,7 @@ public class SolrUtils {
} else {
solrQuery.set("q", "*:*");
}
if (!ListUtils.isEmpty(param.getFq())) {
if (null != param.getFq() && !param.getFq().isEmpty()) {
for (String fq : param.getFq()) {
solrQuery.addFilterQuery(fq);
}
......@@ -353,7 +502,7 @@ public class SolrUtils {
*/
public static String getUTCShortDateStr() {
Calendar calendar = Calendar.getInstance();
calendar.setTime(DateUtils.dateFormat(new Date()));
calendar.setTime(dateFormat(new Date()));
calendar.add(Calendar.HOUR_OF_DAY, -8);
return UTC_FULL_DATE_FORMAT.format(calendar.getTime());
}
......@@ -365,15 +514,31 @@ public class SolrUtils {
*/
public static String formatUTCShortDate(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(DateUtils.dateFormat(date));
calendar.setTime(dateFormat(date));
calendar.add(Calendar.HOUR_OF_DAY, -8);
return UTC_FULL_DATE_FORMAT.format(calendar.getTime());
}
/**
* 对时间进行格式化
* @param date 时间
* @return 格式化时间
*/
protected static Date dateFormat(Date date) {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
Date value = new Date();
try {
value = format.parse(format.format(date));
} catch (ParseException e) {
LOGGER.error("日期转换错误:" + e.getMessage(), e);
}
return value;
}
/**
* 获取默认集合
*/
private static String getDefaultCollection() {
protected static String getDefaultCollection() {
return null == solrClient.getDefaultCollection() ? defaultCollection : solrClient.getDefaultCollection();
}
......
pom.xml
......@@ -18,6 +18,7 @@
<module>pcloud-common-config</module>
<module>pcloud-common</module>
<module>pcloud-common-core</module>
<module>pcloud-solr</module>
</modules>
<packaging>pom</packaging>
......@@ -47,6 +48,7 @@
<pcloud-common.version>2.1.0-RELEASE</pcloud-common.version>
<pcloud-common-config.version>2.1.0-RELEASE</pcloud-common-config.version>
<pcloud-common-core.version>2.1.0-RELEASE</pcloud-common-core.version>
<pcloud-solr.version>2.1.0-RELEASE</pcloud-solr.version>
</properties>
</profile>
<!-- 压测环境 -->
......@@ -68,6 +70,7 @@
<pcloud-common.version>2.1.0-RELEASE</pcloud-common.version>
<pcloud-common-config.version>2.1.0-RELEASE</pcloud-common-config.version>
<pcloud-common-core.version>2.1.0-RELEASE</pcloud-common-core.version>
<pcloud-solr.version>2.1.0-RELEASE</pcloud-solr.version>
</properties>
</profile>
<!-- 生产环境 RAYS -->
......@@ -89,6 +92,7 @@
<pcloud-common.version>2.1.1-RELEASE</pcloud-common.version>
<pcloud-common-config.version>2.1.1-RELEASE</pcloud-common-config.version>
<pcloud-common-core.version>2.1.1-RELEASE</pcloud-common-core.version>
<pcloud-solr.version>2.1.1-RELEASE</pcloud-solr.version>
</properties>
</profile>
</profiles>
......@@ -303,13 +307,6 @@
</dependency>
<!-- end -->
<!-- solr add by gaop at 2018-4-23 11:33:47 -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-solr</artifactId>
<version>${spring.data.solr.version}</version>
</dependency>
<!-- Jackson Begin -->
<dependency>
<groupId>org.codehaus.jackson</groupId>
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment