tfdream / backend-snippet Goto Github PK

public interface StatsDetailMapper {
    //批量insert
    int insertBatch(@Param("list") List<StatsDetail> list);
}

  <insert id="insertBatch">
    insert into crm_call_center_zc_stats_detail (`date`, start_time, end_time,
    agent_id, agent_name, call_way,
    call_id, callee, caller,
    call_type, call_direction, call_flag,
    call_result, duration, recording_duration,
    consult_flag, transfer_flag, quality_status,
    handle_status, hidden_flag, call_start_time,
    call_end_time, satisfy_level, satisfy_value,
    voice_aliyun_url, create_time, update_time
    )
    values
    <foreach collection="list" item="item" index="index" separator=",">
      (#{item.date,jdbcType=INTEGER}, #{item.startTime,jdbcType=INTEGER}, #{item.endTime,jdbcType=INTEGER},
      #{item.agentId,jdbcType=VARCHAR}, #{item.agentName,jdbcType=VARCHAR}, #{item.callWay,jdbcType=INTEGER},
      #{item.callId,jdbcType=VARCHAR}, #{item.callee,jdbcType=VARCHAR}, #{item.caller,jdbcType=VARCHAR},
      #{item.callType,jdbcType=INTEGER}, #{item.callDirection,jdbcType=INTEGER}, #{item.callFlag,jdbcType=INTEGER},
      #{item.callResult,jdbcType=INTEGER}, #{item.duration,jdbcType=INTEGER}, #{item.recordingDuration,jdbcType=INTEGER},
      #{item.consultFlag,jdbcType=INTEGER}, #{item.transferFlag,jdbcType=INTEGER}, #{item.qualityStatus,jdbcType=INTEGER},
      #{item.handleStatus,jdbcType=INTEGER}, #{item.hiddenFlag,jdbcType=INTEGER}, #{item.callStartTime,jdbcType=TIMESTAMP},
      #{item.callEndTime,jdbcType=TIMESTAMP}, #{item.satisfyLevel,jdbcType=INTEGER}, #{item.satisfyValue,jdbcType=VARCHAR},
      #{item.voiceAliyunUrl,jdbcType=VARCHAR}, #{item.createTime,jdbcType=TIMESTAMP}, #{item.updateTime,jdbcType=TIMESTAMP}
      )
    </foreach >
  </insert>

public interface UserVisitingMapper {

    List<UserVisiting> selectByIds(List<Long> ids);
}

  <select id="selectByIds" resultMap="BaseResultMap" parameterType="java.util.List" >
    select
    <include refid="Base_Column_List" />
    from sys_v2_user_visiting
    where id IN
    <foreach collection="list" index="index" item="item" open="(" separator="," close=")">
      #{item}
    </foreach>
  </select>

spring.http.multipart.max-file-size=1MB # Max file size. Values can use the suffixed "MB" or "KB" to indicate a Megabyte or Kilobyte size.
spring.http.multipart.max-request-size=10MB # Max request size. Values can use the suffixed "MB" or "KB" to indicate a Megabyte or Kilobyte size.

spring.servlet.multipart.max-file-size=1MB # Max file size. Values can use the suffixes "MB" or "KB" to indicate megabytes or kilobytes, respectively.
spring.servlet.multipart.max-request-size=10MB # Max request size. Values can use the suffixes "MB" or "KB" to indicate megabytes or kilobytes, respectively.

{
    "id": 1141603, 
    "shopId": 5, 
    "memberId": 503928, 
    "changeValue": 239, 
    "changeType": 3, 
    "operatorType": 2, 
    "comment": "积分兑换", 
    "createTime": "2021-04-01 10:49:04", 
    "beforeChange": 8602, 
    "afterChange": 8363, 
    "orderId": 425831, 
    "orderGoodsIds": "638408"
}

/**
 * @author Ricky Fung
 */
@Component
public class RankingRedisManager {
    private final Logger LOG = LoggerFactory.getLogger(this.getClass());

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    private DefaultRedisScript<List> rankScript;

    public RankingRedisManager() {
        this.rankScript = new DefaultRedisScript<>();
        this.rankScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("scripts/lua/rank_user_calc.lua")));
        this.rankScript.setResultType(List.class);
    }

    public void updateRankingList(RankingRound round, MemberInfoDTO memberInfoDTO,
                           RankingCreditOpType opType, int changeCredit, DateTime now) {
        Long activityId = round.getActivityId();
        Integer seq = round.getSeq();
        Integer memberId = memberInfoDTO.getMemberId();

        int delta = changeCredit; //积分变化值
        if (opType == RankingCreditOpType.REFUND) { //退款
            delta = 0 - changeCredit;
        }

        String userKey = RankingConstant.getRoundUserKey(activityId, seq, Long.valueOf(memberId));
        String rankKey = RankingConstant.getRoundRankKey(activityId, seq);

        List<String> keys = Arrays.asList(userKey, rankKey);

        //会员信息序列化
        String member = serialize(memberInfoDTO);

        //计算时间因子
        double timeWeight = calcTimeWeight(now);

        //执行LUA脚本
        List<Long> result = stringRedisTemplate.execute(this.rankScript, keys,
                String.valueOf(delta), String.valueOf(timeWeight),
                member, String.valueOf(maxRankNum));

        LOG.info("擂台赛-更新排行榜, memberId={}, activityId={}, seq={}, opType={}, changeCredit={}, 更新redis结果={}",
                memberId, activityId, seq, opType, changeCredit, JsonUtils.toJson(result));
    }

    @Value("${ranking.serialize.delimiter:#}")
    private String delimiter;

    //======== 序列化
    private RankingListItem deserialize(String data) {
        RankingListItem item = new RankingListItem();
        int index = data.indexOf(delimiter);
        if (index > 0) {
            item.setUserId(Long.valueOf(data.substring(0, index)));
            item.setNickname(data.substring(index + delimiter.length()));
        }
        return item;
    }

    private String serialize(MemberInfoDTO memberInfoDTO) {
        return serialize(memberInfoDTO.getMemberId(), memberInfoDTO.getMobile());
    }

    private String serialize(Integer memberId, String nickname) {
        StringBuilder sb = new StringBuilder(40);
        sb.append(memberId).append(delimiter)
                .append(nickname);
        return sb.toString();
    }

    @Value("${ranking.epoch.left:2021-01-01}")
    private String epochLeft;

    @Value("${ranking.epoch.right:2031-01-01}")
    private String epochRight;

    private double calcTimeWeight(DateTime now) {
        //计算时间因子
        DateTime left = DateUtils.parseDateTime(epochLeft, DateUtils.DATE_STANDARD_FORMAT);
        DateTime right = DateUtils.parseDateTime(epochRight, DateUtils.DATE_STANDARD_FORMAT);

        double timeWeight = (now.getMillis() - left.getMillis()) * 1.0d / (right.getMillis() - left.getMillis());
        return timeWeight;
    }

local user_total_key = KEYS[1]
local ranking_key = KEYS[2]

local delta = tonumber(ARGV[1])
local time_weight = tonumber(ARGV[2])
local member = ARGV[3]
local max_ranking_size = tonumber(ARGV[4])

local total_credit = tonumber(redis.call("INCRBY", user_total_key, delta))

local score = total_credit + time_weight;
if total_credit < 0 then
  score = total_credit - time_weight;
end

redis.call("ZADD", ranking_key, score, member)

local rank_size = tonumber(redis.call("ZCARD", ranking_key))
if rank_size == nil then
  rank_size = 0
end

local stop = rank_size - max_ranking_size - 1
local delete_cnt = 0
if stop > 0 then
    delete_cnt = tonumber(redis.call("ZREMRANGEBYRANK", ranking_key, 0, stop))
end

return { total_credit, rank_size, delete_cnt}

    public List<RankingListItem> getRankingList(Long activityId, Integer seq) {
        return getRankingList(activityId, seq, true);
    }

    /**
     * 获取排行榜
     * @param activityId
     * @param seq
     * @param mask 用户昵称是否打码
     * @return
     */
    public List<RankingListItem> getRankingList(Long activityId, Integer seq, boolean mask) {
        String key = RankingConstant.getRoundRankKey(activityId, seq);
        Set<ZSetOperations.TypedTuple<String>> tupleSet = stringRedisTemplate.opsForZSet().reverseRangeWithScores(key, 0, topRankNum - 1);
        if (CollectionUtils.isEmpty(tupleSet)) {
            return Collections.EMPTY_LIST;
        }
        List<RankingListItem> list = new ArrayList<>(tupleSet.size());
        int rank = 1;
        for (ZSetOperations.TypedTuple<String> tuple : tupleSet) {
            RankingListItem item = deserialize(tuple.getValue());
            item.setRank(rank);
            item.setTotalCredit(scoreToInt(tuple.getScore()));

            if (mask) {
                item.setNickname(maskNickname(item.getNickname(), 3, 7));
            }
            rank++;
            list.add(item);
        }
        return list;
    }

    private RankingListItem deserialize(String data) {
        RankingListItem item = new RankingListItem();
        int index = data.indexOf(delimiter);
        if (index > 0) {
            item.setUserId(Long.valueOf(data.substring(0, index)));
            item.setNickname(data.substring(index + delimiter.length()));
        }
        return item;
    }

    private Integer scoreToInt(Double score) {
        if (score == null) {
            return IntegerConstant.ZERO;
        }
        return score.intValue();
    }

List<String> list = new ArrayList<>();
list.stream().sorted(
    Comparator.comparing(a->address.indexOf(a))
　　).forEach(System.out :: println);

list.stream().sorted(
        (a,b)-> a.getPriority() - b.getPriority()
).forEach(System.out :: println);//由大到小排序

        List<Person> peoples = Arrays.asList(
                new Person("java", 22),
                new Person("js", 35),
                new Person("css", 31)
        );

        Person result1 = peoples.stream()
                .filter(p -> "java".equals(p.getName()))
                .findAny()
                .orElse(null);
        System.out.println(result1);

List<String> agentIds = list.stream().map(StatsDetail::getAgentId).collect(Collectors.toList());

list.stream().mapToDouble(User::getHeight).sum()//和
list.stream().mapToDouble(User::getHeight).max()//最大
list.stream().mapToDouble(User::getHeight).min()//最小
list.stream().mapToDouble(User::getHeight).average()//平均值

List<Integer> idList = orderIdList.stream().distinct().collect(Collectors.toList());

// 根据name去重
List<Person> unique = persons.stream().collect(
            Collectors.collectingAndThen(
                    Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Person::getName))), ArrayList::new)
);

Map<String, String> collect = list.stream().collect(Collectors.toMap(p -> p.getId(), p -> p.getName()));

@Configuration
@ConditionalOnClass({OkHttpClient.class, RestTemplate.class})
@EnableConfigurationProperties(LegoRestTemplateProperties.class)
public class RestTemplateAutoConfiguration {
    private final Logger LOG = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private LegoRestTemplateProperties legoRestTemplateProperties;

    @Bean
    @ConditionalOnMissingBean(OkHttpClient.class)
    public OkHttpClient okHttpClient() {
        Integer readTimeoutMillis = legoRestTemplateProperties.getReadTimeout();
        Integer writeTimeoutMillis = legoRestTemplateProperties.getWriteTimeout();
        Integer connectTimeoutMillis = legoRestTemplateProperties.getConnectTimeout();

        LOG.info("[Lego框架] OkHttp模块初始化开始, readTimeoutMillis:{}, writeTimeoutMillis:{},connectTimeoutMillis:{}",
                readTimeoutMillis, writeTimeoutMillis, connectTimeoutMillis);

        OkHttpClient client = new OkHttpClient.Builder()
                .readTimeout(readTimeoutMillis, TimeUnit.MILLISECONDS)
                .writeTimeout(writeTimeoutMillis, TimeUnit.MILLISECONDS)
                .connectTimeout(connectTimeoutMillis, TimeUnit.MILLISECONDS)
                .build();
        return client;
    }

    @Bean
    public OkHttp3ClientHttpRequestFactory okHttp3ClientHttpRequestFactory(OkHttpClient okHttpClient) {
        OkHttp3ClientHttpRequestFactory factory = new OkHttp3ClientHttpRequestFactory(okHttpClient);
        return factory;
    }

    @DistributedTracing
    @Bean
    @ConditionalOnMissingBean(RestTemplate.class)
    public RestTemplate restTemplate(OkHttp3ClientHttpRequestFactory okHttp3ClientHttpRequestFactory) {
        LOG.info("[Lego框架] RestTemplate模块初始化开始");
        RestTemplate restTemplate = new RestTemplate(okHttp3ClientHttpRequestFactory);
        List<HttpMessageConverter<?>> messageConverters = restTemplate.getMessageConverters();
        //1.解决中文乱码
        messageConverters.set(1, new StringHttpMessageConverter(StandardCharsets.UTF_8));
        return restTemplate;
    }

}

        String reqUrl = sb.toString();
        try {
            LOG.info("客服呼叫中心-获取开放平台token, 请求接口:{}", reqUrl);

            String json = restTemplate.getForObject(reqUrl, String.class);
            LOG.info("客服呼叫中心-获取开放平台token, 请求接口:{} 响应结果:{}", reqUrl, json);

            if (StringUtils.isNotEmpty(json)) {
                ZcOpenResult result = JsonUtils.parseObject(json, new TypeToken<ZcOpenResult<ZcOpenTokenInfo>>(){}.getType());
                if (result.isSuccess()) {
                    return ResponseDTO.ok(result.getItem());
                }
            }
        } catch (Exception e) {
            LOG.error(String.format("客服呼叫中心-获取开放平台token异常, 请求接口:%s", reqUrl), e);
        }
 

        String reqUrl = sb.toString();
        LOG.info("客服呼叫中心-查询坐席列表开始, 请求接口:{}", reqUrl);

        try {
            //1.获取token
            String token = getAccessToken();

            //创建请求头
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            headers.add("token", token);
            HttpEntity<String> httpEntity = new HttpEntity<>("", headers);

            ResponseEntity<String> responseEntity = restTemplate.exchange(reqUrl, HttpMethod.GET, httpEntity, String.class);
            if (responseEntity.getStatusCode() != HttpStatus.OK) {
                LOG.info("客服呼叫中心-查询坐席列表, 请求接口:{} 响应状态码:{}", reqUrl, responseEntity.getStatusCode());
                return ResponseDTO.systemError();
            }

            String json = responseEntity.getBody();
            LOG.info("客服呼叫中心-查询坐席列表, 请求接口:{} 响应结果:{}", reqUrl, json);

            if (StringUtils.isNotEmpty(json)) {
                ZcOpenListResult result = JsonUtils.parseObject(json, new TypeToken<ZcOpenListResult<ZcAgentInfo>>(){}.getType());
                if (result.isSuccess()) {
                    return ResponseDTO.ok(result.getItems());
                } else if (result.getCode().equals("900002")) { //token失效
                    LOG.info("客服呼叫中心-查询坐席列表, 请求接口:{} token:{} 已失效或不存在", reqUrl, token);
                    deleteCacheToken();
                }
            }
        } catch (Exception e) {
            LOG.error(String.format("客服呼叫中心-查询坐席列表异常, 请求接口:{}", reqUrl), e);
        }

    @GetMapping("/check/token")
    public LoginInfoDTO checkToken(String checkToken,HttpServletRequest request){
        System.out.println(checkToken);
        String url = "http://**.com/api/cas/authenticate";
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.MULTIPART_FORM_DATA);
        MultiValueMap map = new LinkedMultiValueMap();
        map.add("checkToken",checkToken);
        HttpEntity requestBody = new HttpEntity(map, headers);
 
        ResponseEntity<LoginInfoDTO> responseEntity = restTemplate.postForEntity(url, requestBody, LoginInfoDTO.class);
        LoginInfoDTO loginInfoDTO = responseEntity.getBody();
        
        return loginInfoDTO;
    }

            String reqUrl = sb.toString();

            ZcAgentCallHoldReq req = new ZcAgentCallHoldReq();
            req.setCompanyId(companyId);
            req.setAppId(appId);
            req.setCallId(unholdReq.getCallId());
            req.setAgentId(agentId);
            req.setDirection(unholdReq.getDirection().toString());
            req.setCaller(unholdReq.getCallerNumber());

            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            HttpEntity<ZcAgentCallHoldReq> httpEntity = new HttpEntity<>(req, headers);

            LOG.info("客服呼叫中心-取消通话保持, userId:{}, agentId:{} 请求接口:{} 请求参数:{}", userId, agentId, reqUrl, JsonUtils.toJson(req));

            String json = restTemplate.postForObject(reqUrl, httpEntity, String.class);
            LOG.info("客服呼叫中心-取消通话保持, userId:{}, agentId:{} 接口响应结果:{}", userId, agentId, json);

            if (StringUtils.isNotEmpty(json)) {
                JsonObject jo = new JsonParser().parse(json).getAsJsonObject();
                if (BpConstants.ZC_SUCCESS_CODE.equals(jo.get("retCode").getAsString())) {
                    return ResponseDTO.ok();
                } else {
                    alertManager.alertAsync(String.format("调用智齿【取消通话保持接口】失败, reqUrl:%s", reqUrl), json);
                }
                return ResponseDTO.invalidParam(jo.get("retMsg").getAsString());
            }

/**
 * @author Ricky Fung
 */
public abstract class NamingUtils {

    /**
     * 下划线命名转为驼峰命名
     * @param field
     * @return
     */
    public static String mapUnderscoreToCamelCase(String field){
        char[] chs = field.toCharArray();
        StringBuilder sb = new StringBuilder(chs.length);

        boolean prevUnderscore = false;
        for(int i=0; i<chs.length; i++) {
            if (chs[i] == '_') {
                prevUnderscore = true;
                continue;
            }
            sb.append(prevUnderscore ? Character.toUpperCase(chs[i]) : chs[i]);
            prevUnderscore = false;
        }
        return sb.toString();
    }

    /**
     * 驼峰命名转为下划线命名
     * @param field
     * @return
     */
    public static String mapCamelCaseToUnderscore(String field){
        char[] chs = field.toCharArray();
        StringBuilder sb = new StringBuilder(chs.length+6);
        for(int i=0; i<chs.length; i++){
            if(Character.isUpperCase(chs[i])){
                sb.append("_");
                sb.append(Character.toLowerCase(chs[i]));
            } else {
                sb.append(chs[i]);
            }
        }
        return sb.toString();
    }
}

/**
 * @author Ricky Fung
 */
@RestController
@RequestMapping("/admin/user")
public class HomeController {
    private final Logger LOG = LoggerFactory.getLogger(this.getClass());
    @Resource
    private HomeService homeService;

    @PostMapping("/login")
    public ServiceResult doLogin(@RequestParam("mobile") String mobile,
                                 @RequestParam("password") String password) {
        try {
            return homeService.doLogin(mobile, password, DateTime.now());
        } catch (Exception e) {
            LOG.error("用户到访登记系统-后台管理-登录-异常。mobile:{},password:{}", mobile, password, e);
            return ServiceResult.systemError("登录失败");
        }
    }

    @RequiredAuth
    @PostMapping("/logout")
    public ServiceResult logout() {
        Long userId = SecurityContextHolder.getContext().getUserId();
        return homeService.logout(userId);
    }

    @RequiredAuth
    @GetMapping("/user-info")
    public ServiceResult userInfo() {
        Long userId = SecurityContextHolder.getContext().getUserId();
        return homeService.userInfo(userId);
    }

}

import io.dreamstudio.vr.admin.manager.TokenManager;
import io.dreamstudio.vr.admin.web.vo.AuthTokenInfo;
import io.dreamstudio.vr.commons.auth.SecurityContext;
import io.dreamstudio.vr.commons.auth.SecurityContextHolder;
import io.dreamstudio.vr.commons.auth.annotation.OptionalAuth;
import io.dreamstudio.vr.commons.auth.annotation.RequiredAuth;
import io.dreamstudio.vr.commons.constant.VisitingConstant;
import io.dreamstudio.vr.commons.exceptions.InvalidAuthException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Date;

/**
 * @author Ricky Fung
 */
public class AuthInterceptor extends HandlerInterceptorAdapter {
    private final Logger LOG = LoggerFactory.getLogger(this.getClass());

    @Resource
    private TokenManager tokenManager;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (!(handler instanceof HandlerMethod)) {
            return true;
        }

        HandlerMethod handlerMethod = (HandlerMethod) handler;
        RequiredAuth requiredAuth = AnnotationUtils.findAnnotation(handlerMethod.getMethod(), RequiredAuth.class);
        if (requiredAuth != null) {
            return checkAuth(request, handlerMethod.getMethod().getName(), true);
        }

        OptionalAuth optionalAuth = AnnotationUtils.findAnnotation(handlerMethod.getMethod(), OptionalAuth.class);
        if (optionalAuth != null) {
            return checkAuth(request, handlerMethod.getMethod().getName(), false);
        }

        return true;
    }

    private boolean checkAuth(HttpServletRequest request,
                              String methodName, boolean required) throws InvalidAuthException {
        //设置默认
        SecurityContextHolder.setContext(DefaultSecurityContext.NONE);
        Date now = new Date();

        String tokenVal = request.getHeader("Authorization");

        //1.校验token
        AuthTokenInfo tokenInfo = tokenManager.validateToken(tokenVal);
        if (tokenInfo==null) {
            if (required) {
                throw new InvalidAuthException("身份校验-token解密为NULL, token:"+tokenVal);
            }
            return true;
        }

        Long userId = tokenInfo.getUserId();

        //2.验证token过期时间
        Date tokenExpireTime = tokenInfo.getExpiryTime();
        if (tokenExpireTime.before(now)) {
            LOG.warn("用户到访登记系统-后台管理-身份校验, token过期, userId:{}, token:{}", userId, tokenVal);
            if (required) {
                throw new InvalidAuthException("身份校验-token已过期, token:"+tokenVal);
            }
            return true;
        }

        //3.与redis中token做对比(防止已失效)
        String redisToken = tokenManager.getRedisToken(userId);
        if (!tokenVal.equals(redisToken)) {
            if (required) {
                LOG.warn("用户到访登记系统-后台管理-身份校验, token不匹配, userId:{}, token:{}, redisToken:{}", userId, tokenVal, redisToken);
                throw new InvalidAuthException("身份校验-token不匹配, userId:"+userId);
            }
            return true;
        }

        tokenManager.refreshSession(userId, now);
        SecurityContextHolder.setContext(new SecurityContext(userId, tokenVal));
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        SecurityContextHolder.clear();
    }

}

import io.dreamstudio.vr.admin.util.TokenUtils;
import io.dreamstudio.vr.admin.web.vo.AuthTokenInfo;
import io.dreamstudio.vr.commons.constant.RedisConstant;
import io.dreamstudio.vr.commons.exceptions.InvalidAuthException;
import io.dreamstudio.vr.commons.util.DateUtils;
import org.joda.time.DateTime;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Date;
import java.util.concurrent.TimeUnit;

/**
 * @author Ricky Fung
 */
@Component
public class TokenManager {
    private final Logger LOG = LoggerFactory.getLogger(this.getClass());

    private static final String SECRET = "VIP_2020_FUCKING_XG";

    /**
     * 过期时间
     */
    private long sessionExpirySeconds = 3600;
    /**
     * 会话刷新过期时间
     */
    private int sessionRefreshSeconds = 1800;

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    public String genAndSaveToken(Long userId, DateTime now) {
        //计算token过期时间
        Date expiryDate = now.plusDays(2).toDate();

        //生成token
        String token = TokenUtils.genToken(userId, expiryDate, SECRET);
        String adminLoginKey = RedisConstant.getAdminLoginKey(userId);

        //过期时间
        stringRedisTemplate.opsForValue().set(adminLoginKey, token, sessionExpirySeconds, TimeUnit.SECONDS);

        LOG.info("用户到访登记系统-后台管理-登录, userId:{}, 失效时间:{}", userId, DateUtils.format(expiryDate));
        return token;
    }

    public void deleteLoginCache(Long accountId) {
        String adminLoginKey = RedisConstant.getAdminLoginKey(accountId);
        stringRedisTemplate.delete(adminLoginKey);
    }

    //----------拦截器

    public AuthTokenInfo validateToken(String token) throws InvalidAuthException {
        return TokenUtils.validate(token, SECRET);
    }

    //延长会话时间
    public void refreshSession(Long accountId, Date now) {
        String adminLoginKey = RedisConstant.getAdminLoginKey(accountId);
        //延长会话时间
        Date expiryTime = new DateTime(now).plusSeconds(sessionRefreshSeconds).toDate();
        stringRedisTemplate.expireAt(adminLoginKey, expiryTime);
    }

    public String getRedisToken(Long userId) {
        String adminLoginKey = RedisConstant.getAdminLoginKey(userId);
        return stringRedisTemplate.opsForValue().get(adminLoginKey);
    }

}

import io.dreamstudio.vr.admin.web.vo.AuthTokenInfo;
import io.dreamstudio.vr.commons.exceptions.InvalidAuthException;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang3.StringUtils;

import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.Date;

/**
 * token工具类
 * @author Ricky Fung
 */
public abstract class TokenUtils {

    /**
     * 生成token
     * @param userId
     * @param expiryTime
     * @param secret
     * @return
     */
    public static String genToken(Long userId, Date expiryTime, String secret) {
        long ttl = expiryTime.getTime();
        String sig = genSig(userId, ttl, secret);

        String token = String.format("%s#%s#%s", userId, ttl, sig);
        return base64Encode(token);
    }

    /**
     * 解密token
     * @param str
     * @param secret
     * @return
     * @throws InvalidAuthException
     */
    public static AuthTokenInfo validate(String str, String secret) throws InvalidAuthException {
        if (StringUtils.isEmpty(str)) {
            return null;
        }
        String token = base64Decode(str);
        String[] arr = token.split("#");
        if (arr.length!=3) {
            throw new InvalidAuthException("token格式不准确");
        }
        Long userId = Long.valueOf(arr[0]);
        long ttl = Long.parseLong(arr[1]);
        String sig = genSig(userId, ttl, secret);
        if (!sig.equals(arr[2])) {
            throw new InvalidAuthException("token签名验证不通过");
        }
        AuthTokenInfo tokenInfo = new AuthTokenInfo();
        tokenInfo.setUserId(userId);
        tokenInfo.setExpiryTime(new Date(ttl));
        return tokenInfo;
    }

    /**
     * md5加密
     * @param data
     * @return
     */
    public static String md5Hex(String data) {
        return DigestUtils.md5Hex(stringToBytes(data));
    }

    private static byte[] stringToBytes(String data) {
        return data.getBytes(StandardCharsets.UTF_8);
    }

    private static String bytesToString(byte[] buf) {
        return new String(buf, StandardCharsets.UTF_8);
    }

    //----------
    private static String genSig(Long userId, long ttl, String secret) {
        String sig = String.format("%s#%s#%s", userId, ttl, secret);
        return DigestUtils.sha1Hex(stringToBytes(sig));
    }

    private static String base64Encode(String data) {
        return bytesToString(Base64.getEncoder().encode(stringToBytes(data)));
    }

    private static String base64Decode(String data) {
        return bytesToString(Base64.getDecoder().decode(stringToBytes(data)));
    }
}

/**
 * @author Ricky Fung
 */
public class SecurityContextHolder {
	private static final ThreadLocal<SecurityContext> contextHolder = new ThreadLocal<SecurityContext>();

	public static void setContext(SecurityContext context) {
		if (context==null) {
			throw new NullPointerException("context is NULL");
		}
		contextHolder.set(context);
	}

	public static SecurityContext getContext() {
		return contextHolder.get();
	}

	public static void clear() {
		contextHolder.remove();
	}
}

public interface SecurityContext {

    Long getUserId();

    String getToken();

    long getExpiryDate();
    
}

/**
 * @author Ricky Fung
 */
public class DefaultSecurityContext implements SecurityContext {
    public static final SecurityContext NONE = new DefaultSecurityContext(null, null);
    private Long userId;
    private String token;
    private long expiryDate;

    public DefaultSecurityContext(Long userId, String token) {
        this.userId = userId;
        this.token = token;
    }

    public DefaultSecurityContext(Long userId, String token, long expiryDate) {
        this.userId = userId;
        this.token = token;
        this.expiryDate = expiryDate;
    }

    @Override
    public Long getUserId() {
        return userId;
    }

    @Override
    public String getToken() {
        return token;
    }
    @Override
    public long getExpiryDate() {
        return expiryDate;
    }
}

import java.util.Date;

/**
 * @author Ricky Fung
 */
public class AuthTokenInfo {
    private Long userId;
    private Date expiryTime;

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public Date getExpiryTime() {
        return expiryTime;
    }

    public void setExpiryTime(Date expiryTime) {
        this.expiryTime = expiryTime;
    }
}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 必需校验登录
 * @author Ricky Fung
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequiredAuth {
}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 可选校验登录
 * @author Ricky Fung
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface OptionalAuth {
}

$ brew install mysql

brew list mysql   #查看已经安装的mysql路径
cd /usr/local/Cellar/mysql/${mysql.version}/bin
mysql.server start

$ brew uninstall mysql 
$ sudo rm -rf /usr/local/Cellar/mysql
$ brew cleanup
$ sudo rm -rf /usr/local/var/mysql

spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=GMT+8

import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat;

public class UserDTO {
    @JsonFormat(timezone = "GMT+8",pattern = "yyyy-MM-dd")
    @DateTimeFormat(pattern="yyyy-MM-dd")
    private Date createdDate;
}

spring.jackson.default-property-inclusion=non-null

import java.io.Serializable;

import com.fasterxml.jackson.annotation.JsonInclude;

@JsonInclude(JsonInclude.Include.NON_NULL)//该注解配合jackson，序列化时忽略 null属性
public class UserDTO implements Serializable {
}

import io.dreamstudio.vr.commons.enums.GenderEnum;
import org.apache.commons.lang3.StringUtils;

import java.time.LocalDate;
import java.time.Period;
import java.time.format.DateTimeFormatter;

/**
 * @author Ricky Fung
 */
public abstract class IdCardUtils {
    //旧一代身份证号
    private static final int OLD_ID_NO_LENGTH = 15;

    //新一代身份证号 18位
    private static final int NEW_ID_NO_LENGTH = 18;

    /**
     * 根据身份证号获取性别
     * @param idNo 身份证号
     * @return 性别(1: 男，0: 女，-1: 未知)
     */
    public static GenderEnum getGender(String idNo) {
        if (!isValidIdNo(idNo)) {
            return GenderEnum.UNKNOWN;
        }
        if (idNo.length() == OLD_ID_NO_LENGTH) {
            //旧身份证号 规则：其中第15位男为单数,女为双数;
            int mod = Integer.valueOf(idNo.charAt(OLD_ID_NO_LENGTH - 1)) % 2;
            return GenderEnum.getByType(mod);
        }
        //新身份证号 规则：第十七位奇数分给男性，偶数分给女性。
        int mod = Integer.valueOf(idNo.charAt(16)) % 2;
        return GenderEnum.getByType(mod);
    }

    /**
     * 根据身份证号获取用户年龄
     * @param idNo
     * @return
     */
    public static int getAge(String idNo) {
        if (!isValidIdNo(idNo)) {
            return -1;
        }
        String yearStr;
        if (idNo.length() == OLD_ID_NO_LENGTH) {
            //旧身份证号 规则：7-12位出生年月日,比如670401代表1967年4月1日
            StringBuilder sb = new StringBuilder();
            sb.append("19").append(idNo.substring(6, 12));
            yearStr = sb.toString();
        } else {
            //新身份证号
            yearStr = idNo.substring(6, 14);
        }
        LocalDate birthDate = LocalDate.parse(yearStr, DateTimeFormatter.ofPattern(DateUtils.DATE_COMPACT_FORMAT));
        LocalDate now = LocalDate.now();

        Period period = Period.between(birthDate, now);
        return period.getYears();
    }

    public static boolean isValidIdNo(String idNo) {
        if (StringUtils.isNotEmpty(idNo) && (idNo.length() == OLD_ID_NO_LENGTH || idNo.length() == NEW_ID_NO_LENGTH)) {
            char first = idNo.charAt(0);
            if (first > '0' && first < '7') {
                return true;
            }
        }
        return false;
    }
}

/**
 * @author Ricky Fung
 */
public enum GenderEnum {
    FEMALE(0, "女"),
    MALE(1, "男"),
    UNKNOWN(-1, "未知"),
    ;
    private int type;
    private String gender;

    GenderEnum(int type, String gender) {
        this.type = type;
        this.gender = gender;
    }

    public static GenderEnum getByType(int type) {
        for (GenderEnum g : GenderEnum.values()) {
            if (g.getType() == type) {
                return g;
            }
        }
        return null;
    }

    public int getType() {
        return type;
    }

    public String getGender() {
        return gender;
    }
}

int insertBatch(List<OrderPackage> list);

  <insert id="insertBatch" parameterType="java.util.List" keyProperty="id" useGeneratedKeys="true">
    insert into es_shop_order_package (city_distribution_type, express_id, express_sn,
    is_city_distribution, member_id,
    no_express, order_goods_ids, order_id,
    remark, send_time, shop_id
    )
    values
    <foreach collection="list" item="item" index="index" separator=",">
      (#{item.cityDistributionType,jdbcType=INTEGER}, #{item.expressId,jdbcType=INTEGER}, #{item.expressSn,jdbcType=VARCHAR},
      #{item.isCityDistribution,jdbcType=INTEGER}, #{item.memberId,jdbcType=INTEGER},
      #{item.noExpress,jdbcType=INTEGER}, #{item.orderGoodsIds,jdbcType=VARCHAR}, #{item.orderId,jdbcType=INTEGER},
      #{item.remark,jdbcType=VARCHAR}, #{item.sendTime,jdbcType=TIMESTAMP}, #{item.shopId,jdbcType=INTEGER})
    </foreach>
  </insert>

List<OrderPackage> selectByIds(@Param("list") List<Integer> ids);

  <select id="selectByIds" resultMap="BaseResultMap">
    select
    <include refid="Base_Column_List" />
    from es_shop_order_package
    where id IN
    <foreach collection="list" index="index" item="item" open="(" separator="," close=")">
      #{item}
    </foreach>
  </select>

<update id="updateByIdBatch" parameterType="list">
    update es_shop_order
    set status = 1
    where id in
    <foreach collection="list" item="item" index="index" separator="," open="(" close=")">
        #{item.id}
    </foreach>
</update>

    int deleteByPrimaryKey(List<Long> idList);

    <!--根据主键删除-->  <!--这里必须要是 item="id" -->
    <delete id="deleteByPrimaryKey" parameterType="java.util.List">
      delete from cms_menu
        where id in
        <foreach item="id" collection="list" open="(" separator="," close=")"> 
            #{id,jdbcType=BIGINT}
        </foreach>
    </delete>

//List 以ID分组 Map<Integer,List<Apple>>
Map<Integer, List<Apple>> groupBy = appleList.stream().collect(Collectors.groupingBy(Apple::getId));
 
System.err.println("groupBy:"+groupBy);
{1=[Apple{id=1, name='苹果1', money=3.25, num=10}, Apple{id=1, name='苹果2', money=1.35, num=20}], 2=[Apple{id=2, name='香蕉', money=2.89, num=30}], 3=[Apple{id=3, name='荔枝', money=9.99, num=40}]}

/**
 * List -> Map
 * 需要注意的是：
 * toMap 如果集合对象有重复的key，会报错Duplicate key ....
 *  apple1,apple12的id都为1。
 *  可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
 */
Map<Integer, Apple> appleMap = appleList.stream().collect(Collectors.toMap(Apple::getId, a -> a,(k1,k2)->k1));

package com.mkyong.java8
 
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
 
public class TestListMap {
 
    public static void main(String[] args) {
 
        List<Hosting> list = new ArrayList<>();
        list.add(new Hosting(1, "liquidweb.com", 80000));
        list.add(new Hosting(2, "linode.com", 90000));
        list.add(new Hosting(3, "digitalocean.com", 120000));
        list.add(new Hosting(4, "aws.amazon.com", 200000));
        list.add(new Hosting(5, "mkyong.com", 1));
 
        // key = id, value - websites
        Map<Integer, String> result1 = list.stream().collect(
                Collectors.toMap(Hosting::getId, Hosting::getName));
 
        System.out.println("Result 1 : " + result1);
 
        // key = name, value - websites
        Map<String, Long> result2 = list.stream().collect(
                Collectors.toMap(Hosting::getName, Hosting::getWebsites));
 
        System.out.println("Result 2 : " + result2);
 
        // Same with result1, just different syntax
        // key = id, value = name
        Map<Integer, String> result3 = list.stream().collect(
                Collectors.toMap(x -> x.getId(), x -> x.getName()));
 
        System.out.println("Result 3 : " + result3);
    }
}

//过滤出符合条件的数据
List<Apple> filterList = appleList.stream().filter(a -> a.getName().equals("香蕉")).collect(Collectors.toList());
 
System.err.println("filterList:"+filterList);
[Apple{id=2, name='香蕉', money=2.89, num=30}]

//计算 总金额
BigDecimal totalMoney = appleList.stream().map(Apple::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add);
System.err.println("totalMoney:"+totalMoney);  //totalMoney:17.48

Optional<Dish> maxDish = Dish.menu.stream().
      collect(Collectors.maxBy(Comparator.comparing(Dish::getCalories)));
maxDish.ifPresent(System.out::println);
 
Optional<Dish> minDish = Dish.menu.stream().
      collect(Collectors.minBy(Comparator.comparing(Dish::getCalories)));
minDish.ifPresent(System.out::println);

    <properties>
        <fastjson.version>1.2.79</fastjson.version>
        <jackson.version>2.12.6</jackson.version>
        <gson.version>2.8.8</gson.version>
    </properties>

    <!-- jackson -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-annotations</artifactId>
        <version>${jackson.version}</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>${jackson.version}</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>${jackson.version}</version>
    </dependency>

    <!-- gson -->
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>${gson.version}</version>
    </dependency>

    <!-- fastjson -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>${fastjson.version}</version>
    </dependency>

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.meituan.quickstart.configcenter.entity.User;
import org.junit.jupiter.api.Test;

import java.lang.reflect.Type;
import java.util.List;

public class JacksonTest {

	@Test
	public void testGeneric() throws JsonProcessingException {
		ObjectMapper objectMapper = new ObjectMapper();
		// 排除json字符串中实体类没有的字段
		objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false);

		String json = "[{\"name\":\"a\",\"password\":\"345\"},{\"name\":\"b\",\"password\":\"123\"}]";

		//第一种方法
		TypeReference<List<User>> reference = new TypeReference<List<User>>(){};
		List<User> list = objectMapper.readValue(json, reference);
		System.out.println(list);

		//第二种方法
		Type type = reference.getType();
		JavaType jType = objectMapper.getTypeFactory().constructType(type);
		List<User> list2 = objectMapper.readValue(json, jType);
		System.out.println(list2);

		//第三种方法
		JavaType javaType = objectMapper.getTypeFactory().constructCollectionType(List.class, User.class);
		List<User> list3 = objectMapper.readValue(json, javaType);
		System.out.println(list3);
	}
}

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;
import com.meituan.quickstart.configcenter.entity.User;
import org.junit.jupiter.api.Test;

import java.lang.reflect.Type;
import java.util.List;

public class GsonTest {
	private static final Gson GSON = new GsonBuilder()
			.disableHtmlEscaping()
			.create();

	@Test
	public void testGeneric() {
		String json = "[{\"name\":\"a\",\"password\":\"345\"},{\"name\":\"b\",\"password\":\"123\"}]";

		//第一种方法
		Type typeOfT = new TypeToken<List<User>>(){}.getType();
		List<User> list = GSON.fromJson(json, typeOfT);
		System.out.println(list);

		//第二种方法
		List<User> list2 = GSON.fromJson(json, TypeToken.getParameterized(List.class, User.class).getType());
		System.out.println(list2);
	}
}

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.meituan.quickstart.configcenter.entity.User;
import org.junit.jupiter.api.Test;
import java.lang.reflect.Type;
import java.util.List;

public class FastjsonTest {

	@Test
	public void testGeneric() {
		String json = "[{\"name\":\"a\",\"password\":\"345\"},{\"name\":\"b\",\"password\":\"123\"}]";

		//第一种方法
		List<User> list = JSON.parseArray(json, User.class);
		System.out.println(list);

		//第二种方法
		List<User> list2 = JSON.parseObject(json, new TypeReference<List<User>>(){});
		System.out.println(list2);

		//第三种方法
		TypeReference<List<User>> typeReference = new TypeReference<List<User>>(){};
		Type type = typeReference.getType();
		List<User> list3 = JSON.parseObject(json, type);
		System.out.println(list3);
	}

	@Test
	public void testSimple() {
		String json = "{\"name\":\"b\",\"password\":\"123\"}";
		User user = JSON.parseObject(json ,User.class);
		System.out.println(user);
	}
}

MDC And Managed Threads
A copy of the mapped diagnostic context can not always be inherited by worker threads from the initiating thread. This is the case when java.util.concurrent.Executors is used for thread management. For instance, newCachedThreadPool method creates a ThreadPoolExecutor and like other thread pooling code, it has intricate thread creation logic.

In such cases, it is recommended that MDC.getCopyOfContextMap() is invoked on the original (master) thread before submitting a task to the executor. When the task runs, as its first action, it should invoke MDC.setContextMapValues() to associate the stored copy of the original MDC values with the new Executor managed thread.

/**
 * JBoss, Home of Professional Open Source.
 * Copyright 2014-2020 Red Hat, Inc., and individual contributors
 * as indicated by the @author tags.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.jboss.pnc.common.concurrent;

import org.slf4j.MDC;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.function.Consumer;

/**
 * @author <a href="mailto:[email protected]">Matej Lazar</a>
 */
public class MDCWrappers {

    public static Runnable wrap(final Runnable runnable) {
        final Map<String, String> context = MDC.getCopyOfContextMap();
        return () -> {
            Map previous = MDC.getCopyOfContextMap();
            if (context == null) {
                MDC.clear();
            } else {
                MDC.setContextMap(context);
            }
            try {
                runnable.run();
            } finally {
                if (previous == null) {
                    MDC.clear();
                } else {
                    MDC.setContextMap(previous);
                }
            }
        };
    }

    public static <T> Callable<T> wrap(final Callable<T> callable) {
        final Map<String, String> context = MDC.getCopyOfContextMap();
        return () -> {
            Map previous = MDC.getCopyOfContextMap();
            if (context == null) {
                MDC.clear();
            } else {
                MDC.setContextMap(context);
            }
            try {
                return callable.call();
            } finally {
                if (previous == null) {
                    MDC.clear();
                } else {
                    MDC.setContextMap(previous);
                }
            }
        };
    }

    public static <T> Consumer<T> wrap(final Consumer<T> consumer) {
        final Map<String, String> context = MDC.getCopyOfContextMap();
        return (t) -> {
            Map previous = MDC.getCopyOfContextMap();
            if (context == null) {
                MDC.clear();
            } else {
                MDC.setContextMap(context);
            }
            try {
                consumer.accept(t);
            } finally {
                if (previous == null) {
                    MDC.clear();
                } else {
                    MDC.setContextMap(previous);
                }
            }
        };
    }

    public static <T> Collection<Callable<T>> wrapCollection(Collection<? extends Callable<T>> tasks) {
        Collection<Callable<T>> wrapped = new ArrayList<>();
        for (Callable<T> task : tasks) {
            wrapped.add(wrap(task));
        }
        return wrapped;
    }
}

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
 <groupId>org.mybatis.spring.boot</groupId>
 <artifactId>mybatis-spring-boot-starter</artifactId>
 <version>2.1.3</version>
</dependency>

<dependency>
 <groupId>com.github.pagehelper</groupId>
 <artifactId>pagehelper-spring-boot-starter</artifactId>
 <version>1.3.0</version>
</dependency>

public PageInfo<ResponseEntityDto> page(RequestParamDto param) {
 PageHelper.startPage(param.getPageNum(), param.getPageSize());
 List<ResoinseEntityDto> list = mapper.selectManySelective(param);
 PageInfo<ResponseEntityDto> pageInfo = (PageInfo<ResponseEntityDto>)list;
 return pageInfo;
} 

public PageInfo<ResponseEntityDto> page(RequestParamDto param) {
 return PageHelper.startPage(param.getPageNum(), param.getPageSize())
     .doSelectPageInfo(() -> list(param))
} 
public List<ResponseEntityDto> list(RequestParamDto param) {
 return mapper.selectManySelective(param);
}

CREATE TABLE `user_info` (
    `id` int(11) NOT NULL AUTO_INCREMENT,
    `user_id` int(11) NOT NULL,
    `name` varchar(255) DEFAULT '' COMMENT '昵称',
    `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET= utf8mb4;

CREATE TABLE `operation_activity` (
`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
`title` varchar(128) NOT NULL COMMENT '活动名称',
`type` smallint(4) NOT NULL COMMENT '活动类型 1:大转盘抽奖 2:老虎机抽奖',
`start_time` datetime NOT NULL COMMENT '开始时间',
`end_time` datetime NOT NULL COMMENT '结束时间',
`config` varchar(1600) DEFAULT NULL COMMENT '活动配置信息',
`state` tinyint(2) NOT NULL COMMENT '状态 1:未发布 2:已发布 3:已下线',
`create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
`offline_time` datetime NOT NULL COMMENT '下线时间',
`parent_id` bigint(20) NOT NULL DEFAULT '0' COMMENT '主活动id',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='运营活动配置表'

    private void sendRedirect(HttpServletResponse response, String targetUrl) {
        response.setHeader("Location", targetUrl); //目标地址
        response.setStatus(HttpServletResponse.SC_FOUND);  //设置状态码为302
    }

    private void sendRedirect(HttpServletResponse response, String targetUrl) {
        response.sendRedirect(targetUrl);
    }

    /**
     * Send a temporary redirect to the specified redirect location URL.
     *
     * @param location Location URL to redirect to
     *
     * @exception IllegalStateException if this response has
     *  already been committed
     * @exception IOException if an input/output error occurs
     */
    @Override
    public void sendRedirect(String location) throws IOException {
        sendRedirect(location, SC_FOUND);
    }


    /**
     * Internal method that allows a redirect to be sent with a status other
     * than {@link HttpServletResponse#SC_FOUND} (302). No attempt is made to
     * validate the status code.
     *
     * @param location Location URL to redirect to
     * @param status HTTP status code that will be sent
     * @throws IOException an IO exception occurred
     */
    public void sendRedirect(String location, int status) throws IOException {
        if (isCommitted()) {
            throw new IllegalStateException(sm.getString("coyoteResponse.sendRedirect.ise"));
        }

        // Ignore any call from an included servlet
        if (included) {
            return;
        }

        // Clear any data content that has been buffered
        resetBuffer(true);

        // Generate a temporary redirect to the specified location
        try {
            String locationUri;
            // Relative redirects require HTTP/1.1
            if (getRequest().getCoyoteRequest().getSupportsRelativeRedirects() &&
                    getContext().getUseRelativeRedirects()) {
                locationUri = location;
            } else {
                locationUri = toAbsolute(location);
            }
            setStatus(status);
            setHeader("Location", locationUri);
            if (getContext().getSendRedirectBody()) {
                PrintWriter writer = getWriter();
                writer.print(sm.getString("coyoteResponse.sendRedirect.note",
                        Escape.htmlElementContent(locationUri)));
                flushBuffer();
            }
        } catch (IllegalArgumentException e) {
            log.warn(sm.getString("response.sendRedirectFail", location), e);
            setStatus(SC_NOT_FOUND);
        }

        // Cause the response to be finished (from the application perspective)
        setSuspended(true);
    }

/directory/file1.jsp
/directory/file2.jsp
/directory/file3.jsp

directory/*

*.jsp

<![CDATA[ >= ]]>

<![CDATA[ <= ]]>

  <select id="findUserCreditLog" resultMap="BaseResultMap">
    select
    <include refid="Base_Column_List" />
    from esx_member_credit_log
    where user_id = #{userId}
    <![CDATA[
    AND  create_time >= #{startTime}
    AND  create_time <= #{endTime}
    ]]>
  </select>

select
    <include refid="Base_Column_List" />
    from student
    where 1=1
    <if test="name != null and name !=''">
      and name like concat('%', #{name}, '%')
    </if>
    <if test="sex != null">
      and sex=#{sex}
    </if>

select
    <include refid="Base_Column_List" />
    from student
 <where>
    <if test="name != null and name !=''">
      and name like concat('%', #{name}, '%')
    </if>
    <if test="sex != null">
      and sex=#{sex}
    </if>
</where>

<Host name="localhost"  appBase="webapps" unpackWARs="true" autoDeploy="false" deployOnStartup="false"></Host>

project1: localhost:8080/project1/...

project1: localhost:8080/project2/...

ROOT: localhost:8080/xxx

<Host name="localhost"  appBase="webapps" unpackWARs="true" autoDeploy="false" deployOnStartup="false">
      <Context path="" docBase="/data/app" reloadable="false"/>
</Host>

<Host name="localhost"  appBase="webapps" unpackWARs="true" autoDeploy="false" deployOnStartup="false">
<Context path="mvp" docBase="book" debug="0" reloadable="true"/>
</Host>

<Host name="localhost"  appBase="webapps" unpackWARs="true" autoDeploy="false" deployOnStartup="false">
     <Context path="aaa" docBase="/data/app/sa" debug="0" reloadable="true"/>
     <Context path="bbb" docBase="/data/app/sb" debug="0" reloadable="true"/>
</Host>

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>2.8.6</version>
</dependency>

Cache<String, Object> manualCache = Caffeine.newBuilder()
        .expireAfterWrite(10, TimeUnit.MINUTES)
        .maximumSize(10_000)
        .build();

String key = "name1";
// 根据key查询一个缓存，如果没有返回NULL
graph = manualCache.getIfPresent(key);
// 根据Key查询一个缓存，如果没有调用createExpensiveGraph方法，并将返回值保存到缓存。
// 如果该方法返回Null则manualCache.get返回null，如果该方法抛出异常则manualCache.get抛出异常
graph = manualCache.get(key, k -> createExpensiveGraph(k));
// 将一个值放入缓存，如果以前有值就覆盖以前的值
manualCache.put(key, graph);
// 删除一个缓存
manualCache.invalidate(key);

LoadingCache<String, Object> loadingCache = Caffeine.newBuilder()
        .maximumSize(10_000)
        .expireAfterWrite(10, TimeUnit.MINUTES)
        .build(key -> createExpensiveGraph(key));
    
String key = "name1";
Object graph = loadingCache.get(key);

// 获取组key的值返回一个Map
List<String> keys = new ArrayList<>();
keys.add(key);
Map<String, Object> graphs = loadingCache.getAll(keys);

AsyncLoadingCache<String, Object> asyncLoadingCache = Caffeine.newBuilder()
            .maximumSize(10_000)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            // Either: Build with a synchronous computation that is wrapped as asynchronous
            .buildAsync(key -> createExpensiveGraph(key));
            // Or: Build with a asynchronous computation that returns a future
            // .buildAsync((key, executor) -> createExpensiveGraphAsync(key, executor));

 String key = "name1";

// 查询并在缺失的情况下使用异步的方式来构建缓存
CompletableFuture<Object> graph = asyncLoadingCache.get(key);
// 查询一组缓存并在缺失的情况下使用异步的方式来构建缓存
List<String> keys = new ArrayList<>();
keys.add(key);
CompletableFuture<Map<String, Object>> graphs = asyncLoadingCache.getAll(keys);
// 异步转同步
loadingCache = asyncLoadingCache.synchronous();

// Evict based on the number of entries in the cache
// 根据缓存的计数进行驱逐
LoadingCache<Key, Graph> graphs = Caffeine.newBuilder()
    .maximumSize(10_000)
    .build(key -> createExpensiveGraph(key));

// Evict based on the number of vertices in the cache
// 根据缓存的权重来进行驱逐（权重只是用于确定缓存大小，不会用于决定该缓存是否被驱逐）
LoadingCache<Key, Graph> graphs = Caffeine.newBuilder()
    .maximumWeight(10_000)
    .weigher((Key key, Graph graph) -> graph.vertices().size())
    .build(key -> createExpensiveGraph(key));

LoadingCache<Key, Graph> graphs = Caffeine.newBuilder()
    .expireAfterAccess(5, TimeUnit.MINUTES)
    .build(key -> createExpensiveGraph(key));
LoadingCache<Key, Graph> graphs = Caffeine.newBuilder()
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .build(key -> createExpensiveGraph(key));

FakeTicker ticker = new FakeTicker(); // Guava's testlib
Cache<Key, Graph> cache = Caffeine.newBuilder()
    .expireAfterWrite(10, TimeUnit.MINUTES)
    .executor(Runnable::run)
    .ticker(ticker::read)
    .maximumSize(10)
    .build();

cache.put(key, graph);
ticker.advance(30, TimeUnit.MINUTES)
assertThat(cache.getIfPresent(key), is(nullValue());

Cache<Key, Graph> graphs = Caffeine.newBuilder()
    .removalListener((Key key, Graph graph, RemovalCause cause) ->
        System.out.printf("Key %s was removed (%s)%n", key, cause))
    .build();

LoadingCache<Key, Graph> graphs = Caffeine.newBuilder()
    .maximumSize(10_000)
    // 指定在创建缓存或者最近一次更新缓存后经过固定的时间间隔，刷新缓存
    .refreshAfterWrite(1, TimeUnit.MINUTES)
    .build(key -> createExpensiveGraph(key));

Cache<Key, Graph> graphs = Caffeine.newBuilder()
    .maximumSize(10_000)
    .recordStats()
    .build();

        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity</artifactId>
            <version>1.7</version>
        </dependency>

VelocityEngine ve = new VelocityEngine();
ve.setProperty(RuntimeConstants.RESOURCE_LOADER, "classpath");
ve.setProperty("classpath.resource.loader.class", ClasspathResourceLoader.class.getName());
ve.init();
VelocityContext context = new VelocityContext();
context.put("date", getMyTimestampFunction());
Template t = ve.getTemplate( "templates/email_html_new.vm" );
StringWriter writer = new StringWriter();
t.merge( context, writer );

package io.mindflow.agent.util;

import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.VelocityEngine;
import org.apache.velocity.runtime.RuntimeConstants;
import org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader;

import java.io.File;
import java.io.FileWriter;
import java.io.StringWriter;

/**
 * @author Ricky Fung
 */
public abstract class VelocityUtils {
    static VelocityEngine ve;
    static {
        ve = new VelocityEngine();
        ve.setProperty(RuntimeConstants.RESOURCE_LOADER, "classpath");
        ve.setProperty("classpath.resource.loader.class", ClasspathResourceLoader.class.getName());
        ve.init();
    }
    public static void generateHtml(String inputVmFilePath, String outputHtmlFilePath,
                                    VelocityContext context) throws Exception {
        try {
            Template template = ve.getTemplate(inputVmFilePath, "UTF-8");
            File outputFile = new File(outputHtmlFilePath);
            FileWriter writer = new FileWriter(outputFile);
            template.merge(context, writer);
            writer.close();
        } catch (Exception ex) {
            throw ex;
        }
    }

    public static String generateHtml(String inputVmFilePath, VelocityContext context) throws Exception {
        try {
            Template template = ve.getTemplate(inputVmFilePath, "UTF-8");
            StringWriter writer = new StringWriter(4096);
            template.merge(context, writer);
            String data = writer.toString();
            writer.close();
            return data;
        } catch (Exception ex) {
            throw ex;
        }
    }
}

/**
 * @author Ricky Fung
 */
public class TemplatePdfTest {

    @Test
    public void testGetHtml() throws Exception {
        List<Map<String, String>> list = new ArrayList<>();
        for (int i=0; i<50; i++) {
            Map<String, String> map = new HashMap<>(8);
            map.put("productName", "爱盈宝21000"+i);
            map.put("lockPeriod", String.format("2018年3月至2020年%s月", i+1));
            map.put("profitRate", "8.6%");
            map.put("dueState", i%2 == 0? "是":"否");
            list.add(map);
        }
        Map map = new HashMap(4);
        map.put("list", list);

        VelocityContext context = new VelocityContext(map);
        //VelocityUtils.generateHtml("templates/report.vm", "my.html", context);
        String html = VelocityUtils.generateHtml("templates/report.vm", context);
        System.out.println(html);

        //
        File file = new File(String.format("test_%s.pdf", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(LocalDateTime.now())));

        FileOutputStream fos = new FileOutputStream(file);
        PdfUtils.createPDF(fos, html);
    }
}

import java.math.BigDecimal;

/**
 * @author Ricky Fung
 */
public abstract class DecimalUtils {
    private static final int DEFAULT_SCALE = 8;
    private static final int ZERO = 0;

    //=======基本类型
    public static BigDecimal valueOf(double num) {
        return new BigDecimal(Double.toString(num));
    }

    public static BigDecimal valueOf(float num) {
        return new BigDecimal(Float.toString(num));
    }

    public static BigDecimal valueOf(int num) {
        return new BigDecimal(Integer.toString(num));
    }

    public static BigDecimal valueOf(long num) {
        return new BigDecimal(Long.toString(num));
    }

    //=======包装类型
    public static BigDecimal valueOf(Double num) {
        return new BigDecimal(num.toString());
    }

    public static BigDecimal valueOf(Float num) {
        return new BigDecimal(num.toString());
    }

    public static BigDecimal valueOf(Integer num) {
        return new BigDecimal(num.toString());
    }

    public static BigDecimal valueOf(Long num) {
        return new BigDecimal(num.toString());
    }

    public static BigDecimal valueOf(String val) {
        return new BigDecimal(val);
    }

    //=======格式化为字符串
    public static String format(BigDecimal bd) {
        return bd.setScale(2, BigDecimal.ROUND_HALF_UP).toString();
    }

    public static String format(BigDecimal bd, int scale) {
        return bd.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    public static String format(BigDecimal bd, int scale, int roundingMode) {
        return bd.setScale(scale, roundingMode).toString();
    }

    //=======设置精度
    public static BigDecimal setScale(BigDecimal bd, int scale) {
        return bd.setScale(scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 
     * @param bd
     * @param scale
     * @param roundingMode 取值参考 BigDecimal.ROUND_HALF_UP 等
     * @return
     */
    public static BigDecimal setScale(BigDecimal bd, int scale, int roundingMode) {
        return bd.setScale(scale, roundingMode);
    }

    //=======求最小值
    public static int min(int num1, int num2) {
        return num1 < num2 ? num1 : num2;
    }
    public static int min(int num1, int num2, int num3) {
        int min = num1 < num2 ? num1 : num2;
        return min < num3 ? min : num3;
    }

    public static long min(long num1, long num2) {
        return num1 < num2 ? num1 : num2;
    }
    public static long min(long num1, long num2, long num3) {
        long min = num1 < num2 ? num1 : num2;
        return min < num3 ? min : num3;
    }

    public static BigDecimal min(BigDecimal num1, BigDecimal num2) {
        return num1.compareTo(num2) < ZERO ? num1 : num2;
    }
    public static BigDecimal min(BigDecimal num1, BigDecimal num2, BigDecimal num3) {
        BigDecimal min = num1.compareTo(num2) < ZERO ? num1 : num2;
        return min.compareTo(num3) < ZERO ? min : num3;
    }

    //=======求最大值
    public static int max(int num1, int num2) {
        return num1 > num2 ? num1 : num2;
    }
    public static int max(int num1, int num2, int num3) {
        int max = num1 > num2 ? num1 : num2;
        return max > num3 ? max : num3;
    }

    public static long max(long num1, long num2) {
        return num1 > num2 ? num1 : num2;
    }
    public static long max(long num1, long num2, long num3) {
        long max = num1 > num2 ? num1 : num2;
        return max > num3 ? max : num3;
    }

    public static BigDecimal max(BigDecimal num1, BigDecimal num2) {
        return num1.compareTo(num2) > ZERO ? num1 : num2;
    }
    public static BigDecimal max(BigDecimal num1, BigDecimal num2, BigDecimal num3) {
        BigDecimal max = num1.compareTo(num2) > ZERO ? num1 : num2;
        return max.compareTo(num3) > ZERO ? max : num3;
    }

    //=======加法
    public static BigDecimal add(int v1, int v2) {
        BigDecimal b1 = new BigDecimal(Integer.toString(v1));
        BigDecimal b2 = new BigDecimal(Integer.toString(v2));
        return b1.add(b2);
    }
    public static BigDecimal add(long v1, long v2) {
        BigDecimal b1 = new BigDecimal(Long.toString(v1));
        BigDecimal b2 = new BigDecimal(Long.toString(v2));
        return b1.add(b2);
    }
    public static BigDecimal add(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.add(b2);
    }

    public static BigDecimal add(BigDecimal b1, BigDecimal b2) {
        return b1.add(b2);
    }

    //=======减法
    public static BigDecimal sub(int v1, int v2) {
        BigDecimal b1 = new BigDecimal(Integer.toString(v1));
        BigDecimal b2 = new BigDecimal(Integer.toString(v2));
        return b1.subtract(b2);
    }

    public static BigDecimal sub(long v1, long v2) {
        BigDecimal b1 = new BigDecimal(Long.toString(v1));
        BigDecimal b2 = new BigDecimal(Long.toString(v2));
        return b1.subtract(b2);
    }

    public static BigDecimal sub(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.subtract(b2);
    }

    public static BigDecimal sub(BigDecimal b1, BigDecimal b2) {
        return b1.subtract(b2);
    }

    //=======乘法
    public static BigDecimal mul(int v1, int v2) {
        BigDecimal b1 = new BigDecimal(Integer.toString(v1));
        BigDecimal b2 = new BigDecimal(Integer.toString(v2));
        return b1.multiply(b2);
    }

    public static BigDecimal mul(long v1, long v2) {
        BigDecimal b1 = new BigDecimal(Long.toString(v1));
        BigDecimal b2 = new BigDecimal(Long.toString(v2));
        return b1.multiply(b2);
    }

    public static BigDecimal mul(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.multiply(b2);
    }

    public static BigDecimal mul(BigDecimal b1, BigDecimal b2) {
        return b1.multiply(b2);
    }

    //=======除法
    public static BigDecimal div(int v1, int v2) {
        BigDecimal b1 = new BigDecimal(Integer.toString(v1));
        BigDecimal b2 = new BigDecimal(Integer.toString(v2));
        return b1.divide(b2, DEFAULT_SCALE, BigDecimal.ROUND_HALF_UP);//四舍五入
    }

    public static BigDecimal div(long v1, long v2) {
        BigDecimal b1 = new BigDecimal(Long.toString(v1));
        BigDecimal b2 = new BigDecimal(Long.toString(v2));
        return b1.divide(b2, DEFAULT_SCALE, BigDecimal.ROUND_HALF_UP);//四舍五入,保留两位小数
    }

    public static BigDecimal div(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.divide(b2, DEFAULT_SCALE, BigDecimal.ROUND_HALF_UP);//四舍五入
    }

    public static BigDecimal div(BigDecimal b1, BigDecimal b2) {
        return b1.divide(b2, DEFAULT_SCALE, BigDecimal.ROUND_HALF_UP);//四舍五入
    }

    /**
     * 除法
     * @param v1
     * @param v2
     * @param scale
     * @param roundingMode 参考 BigDecimal.ROUND_HALF_UP
     * @return
     */
    public static BigDecimal div(double v1, double v2, int scale, int roundingMode) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.divide(b2, scale, roundingMode);
    }

    public static BigDecimal div(BigDecimal b1, BigDecimal b2, int scale) {
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP);//四舍五入
    }

    public static BigDecimal div(BigDecimal b1, BigDecimal b2, int scale, int roundingMode) {
        return b1.divide(b2, scale, roundingMode);
    }
}

import org.apache.commons.codec.binary.Base64;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;

/**
 * AES 加密/解密
 * @author Ricky Fung
 */
public abstract class AESUtils {
    private static final Charset UTF_8 = StandardCharsets.UTF_8;
    private static String ALGORITHM_AES = "AES";
    private static final int SECRET_KEY_LENGTH = 16;

    //密钥(不要修改此属性值，否则后果不堪设想)
    private static final String DEFAULT_SECRET_KEY = "DEV_2020_FUCKING_COV";

    public static String encrypt(String plainText) {
        return encrypt(plainText, DEFAULT_SECRET_KEY);
    }

    /**
     * AES加密
     * @param plainText
     * @param secret
     * @return
     */
    public static String encrypt(String plainText, String secret) {
        try {
            //1.产生key
            SecretKey secretKey = genSecretKey(secret);
            //2.加密
            Cipher cipher = Cipher.getInstance(ALGORITHM_AES);
            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
            byte[] data = plainText.getBytes(UTF_8);
            byte[] result = cipher.doFinal(data);

            return base64EncodeStr(result);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public static String decrypt(String cipherText) {
        return decrypt(cipherText, DEFAULT_SECRET_KEY);
    }

    /**
     * AES解密
     * @param cipherText
     * @param secret
     * @return
     */
    public static String decrypt(String cipherText, String secret) {
        try {
            //1.产生key
            SecretKey secretKey = genSecretKey(secret);
            //2.加密
            Cipher cipher = Cipher.getInstance(ALGORITHM_AES);
            cipher.init(Cipher.DECRYPT_MODE, secretKey);
            byte[] c = base64Decode(cipherText);
            byte[] buf = cipher.doFinal(c);

            return new String(buf, UTF_8);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    //---------

    private static SecretKey genSecretKey(String myKey) {
        try {
            byte[] key = myKey.getBytes(UTF_8);
            MessageDigest sha = MessageDigest.getInstance("SHA-1");
            key = sha.digest(key);
            key = Arrays.copyOf(key, SECRET_KEY_LENGTH);
            return new SecretKeySpec(key, ALGORITHM_AES);
        } catch (NoSuchAlgorithmException e) {
            throw new IllegalArgumentException("不支持的算法");
        }
    }

    private static byte[] base64Decode(String cipherText) {
        return Base64.decodeBase64(cipherText);
    }

    //----

    private static String base64EncodeStr(byte[] buf) {
        byte[] data = Base64.encodeBase64(buf);
        return new String(data, UTF_8);
    }

    private static byte[] base64Encode(byte[] buf) {
        return Base64.encodeBase64(buf);
    }

}

    @Value("${config.list.ids: 1,2,3}")
    private List<String> idList;

    @Value("${config.list.ids: 1,2,3}")
    private String[]  idList;

    @Value("#{'${topic.list}'.split(',')}")
    private List<String> topicList;

topic.list: topic1,topic2,topic3

@Value("#{${config.maps}}")  
private Map<String,String> maps;

config.maps: "{key1: 'value1', key2: 'value2'}"

@Value("${ES.CLUSTER_NAME}")
private static String CLUSTER_NAME;

private static String CLUSTER_NAME;
 
@Value("${ES.CLUSTER_NAME}")
public void setClusterName(String clusterName) {
CLUSTER_NAME = clusterName;
}