/**
 * @author Ricky Fung
 */
@Service
public class GiftExchangeService {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Resource(name = "giftService")
    private GiftService giftService;

    @Resource(name = "userService")
    private UserService userService;

    @Resource(name = "userPointService")
    private UserPointService userPointService;

    /**
     * 提交兑换礼品请求
     * @param activityId 活动id
     * @param userId 用户id
     * @param giftId 活动礼品id
     * @param quantity 兑换数量
     * @return
     */
    public ApiResult<Boolean> submit(Integer activityId, Long userId, Long giftId, int quantity) {
        logger.info("活动-兑换礼品, 用户userId:{}, activityId:{}, giftId:{}, quantity:{} 请求处理开始",
                userId, activityId, giftId, quantity);
        //1.校验参数
        if (giftId==null || giftId.longValue() <1) {
            return ApiResult.buildInvalidParameterResult("giftId必须大于0");
        }
        if (quantity < 1) {
            return ApiResult.buildInvalidParameterResult("quantity必须大于0");
        }

        //2.查询用户兑换的礼品信息
        ActivityGift activityGift = giftService.getGiftById(activityId, giftId);
        if (activityGift==null) {
            return ApiResult.buildFailureResult(1001, "礼品id不存在");
        }

        //3.用户信息
        User user = userService.getUserById(userId);
        if (user==null) {
            return ApiResult.buildFailureResult(1002, "用户不存在");
        }

        //4.1 校验库存数量
        int count = giftService.getGiftStock(giftId);
        if (count<1) {
            return ApiResult.buildFailureResult(1003, "礼品库存不足");
        }

        //加分布式锁
        String lockKey = String.format("%s:%s", GiftConstant.GIFT_EXCHANGE_USER_LOCK_KEY, userId);
        DistributedLock lock = distributedLockClient.getLock(lockKey);
        try {
            boolean success = lock.tryLock(0, 30, TimeUnit.SECONDS);
            if (!success) {
                logger.info("活动-兑换礼品, 用户userId:{} activityId:{}, giftId:{} 用户加锁失败",
                        userId, activityId, giftId);
                return ApiResult.buildFailureResult(1004, "请勿重复操作");
            }
            //加锁成功
            try {
                //4.2 可用积分校验
                UserPoint userPoint = userPointService.getUserPoint(userId, activityId);
                if (userPoint==null) {
                    return ApiResult.buildFailureResult(1005, "对不起，您的兑换卡数量不足");
                }
                int requiredPoint = activityGift.getPointValue() * quantity;
                if (userPoint.getAvailablePoint().intValue() < requiredPoint) {
                    logger.info("活动-兑换礼品, 用户userId:{} activityId:{} 当前可用积分:{} 不满足兑换要求:{}",
                            userId, activityId, userPoint.getAvailablePoint(), requiredPoint);
                    return ApiResult.buildFailureResult(1005, "对不起，您的可用积分不足");
                }

                //5.1 减库存
                boolean updateSuccess = giftService.decreaseGiftStock(giftId, quantity);
                if (!updateSuccess) {
                    logger.info("活动-兑换礼品, 用户userId:{} activityId:{}, giftId:{} 更新礼品库存失败",
                            userId, activityId, giftId);
                    return ApiResult.buildFailureResult(1003, "礼品库存不足");
                }
                //5.2 创建用户活动礼品记录
                ActivityUserGift record = giftService.createOrder(activityId, userId, activityGift, quantity);
                //5.3 减用户可用积分并保存兑换记录
                ApiResult<Long> result = giftService.saveUserGift(userPoint, requiredPoint, record);
                if (result.isSuccess()) {
                    Long id = result.getData();
                    logger.info("活动-兑换礼品, 用户userId:{} activityId:{}, giftId:{}, quantity:{} 兑换成功id:{}",
                            userId, activityId, giftId, quantity, id);

                    //发放活动奖品
                    sendActivityGift(userId, activityId, id);
                    return ApiResult.buildSuccessResult(Boolean.TRUE);
                }
            } finally {
                //释放锁
                lock.unlock();
            }
        } catch (InterruptedException e) {
            logger.error(String.format("活动-兑换礼品, 用户userId:%s, activityId:%s, giftId:%s, quantity:%s 加锁异常",
                    userId, activityId, giftId, quantity));
        } catch (UserPointShortageException e) {
            logger.error("活动-兑换礼品, 用户userId:{} activityId:{}, giftId:{}, quantity:{} 兑换失败-更新用户可用积分失败",
                    userId, activityId, giftId, quantity);
            return ApiResult.buildFailureResult(1005, "对不起，您的兑换卡数量不足");
        } catch (Exception e) {
            logger.error(String.format("活动-兑换礼品, 用户userId:%s activityId:%s, giftId:%s, quantity:%s 兑换异常",
                    userId, activityId, giftId, quantity), e);
        }
        return ApiResult.buildSystemErrorResult();
    }

    private void sendActivityGift(Long userId, Integer activityId, Long id) {
        //发送 发放活动礼品mq消息

    }
}

/**
 * @author Ricky Fung
 */
@Service
public class GiftService {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private final DefaultRedisScript<Long> stockScript;

    public GiftService() {
        this.stockScript = new DefaultRedisScript<>();
        stockScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("scripts/stock_decr.lua")));
        stockScript.setResultType(Long.class);
    }

    /**
     * 获取活动礼品库存数量
     * @param giftId
     * @return
     */
    public int getGiftStock(Long giftId) {
        String key = getActivityAwardStockKey(giftId);
        String str = stringRedisTemplate.opsForValue().get(key);
        int count = 0;
        if (StringUtils.isNotEmpty(str)) {
            count = Integer.parseInt(str);
            if (count < 0) {
                count = 0;
            }
        }
        return count;
    }

    /**
     * 扣减活动礼品库存
     * @param giftId
     * @param quantity
     * @return
     */
    public boolean decreaseGiftStock(Long giftId, int quantity) {
        String key = getActivityAwardStockKey(giftId);
        //LUA脚本保证原子性
        Long update = stringRedisTemplate.execute(stockScript, Collections.singletonList(key), String.valueOf(quantity));
        logger.info("活动-兑换礼品, giftId:{} 减库存quantity:{} 后的结果:{}",
                giftId, quantity, update);
        return update >= 0;
    }

    private String getActivityAwardStockKey(Long giftId) {
        return String.format("%s:%s", "stock", giftId);
    }

}

    @Transactional(rollbackFor = Exception.class)
    public ApiResult<Long> saveUserGift(UserPoint userPoint, int requiredPoint, ActivityUserGift record) {
        Long id = userPoint.getId();
        //1.扣减用户可用积分
        int update = userPointMapper.updateUserAvailablePoint(id, requiredPoint);
        if (update<1) {
            throw new UserPointShortageException("可用积分不足");
        }
        //2.插入兑换礼品记录
        activityUserGiftMapper.insert(record);
        return ApiResult.buildSuccessResult(record.getId().longValue());
    }

    public ActivityGift getGiftById(Integer activityId, Long giftId) {
        return activityGiftMapper.findGiftById(giftId);
    }

    public ActivityUserGift createOrder(Integer activityId, Long userId, ActivityGift activityGift, int quantity) {
        ActivityUserGift userGift = new ActivityUserGift();
        //赋值
        return userGift;
    }

  <update id="updateUserAvailablePoint">
    update activity_user_point
    set available_point = available_point - #{requiredPoint}
	where id=#{id} and available_point >=#{requiredPoint};
  </update>

CREATE TABLE `activity_user_point` (
`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
`activity_id` bigint(20) NOT NULL COMMENT '活动id',
`user_id` bigint(20) unsigned NOT NULL COMMENT '用户id',
`name` varchar(45) NOT NULL COMMENT '用户真实姓名',
`total_point` bigint(20) NOT NULL DEFAULT '0' COMMENT '用户获得总积分数',
`available_point` bigint(20) unsigned NOT NULL DEFAULT '0' COMMENT '用户可用的积分数',
`version` int(10) NOT NULL DEFAULT '1' COMMENT '版本号',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
`update_time` datetime DEFAULT NULL COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uniq_user_id` (`user_id`,`activity_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='动用户积分表';

local investment_key = KEYS[1]
local point_key = KEYS[2]

local investmentAmount = tonumber(ARGV[1])
local pointUnit = tonumber(ARGV[2])

local totalInvestmentAmount = tonumber(redis.call("INCRBY", investment_key, investmentAmount))
local totalPoints = math.floor(totalInvestmentAmount / pointUnit);

redis.call("SET", point_key, totalPoints)

return {totalInvestmentAmount, totalPoints}

local stocks_key = KEYS[1]
local acquiredNum = tonumber(ARGV[1])

local current = tonumber(redis.call("GET", stocks_key))
if current == nil then
  current = 0
end
local success = -1;
if current >= acquiredNum then
    success = tonumber(redis.call("DECRBY", stocks_key, acquiredNum))
end

return success

| -- 4bit-- | ---------- 28bit ---------- | ------------ 32bit ------------ |

package io.mindflow.architect.luckcode.service;

import org.springframework.stereotype.Service;

/**
 * 生成抽奖码算法
 * @author Ricky Fung
 */
@Service
public class LuckyCodeService {
    private static final int DICT_BIT_LENGTH = 5;
    private static final int DICT_MASK = (1 << DICT_BIT_LENGTH) - 1;
    private static final int DICT_LENGTH = (1 << DICT_BIT_LENGTH);

    private static final int CODE_LENGTH = 13;

    //码表
    private final char[] dict;

    public LuckyCodeService(char[] dict) {
        if (dict==null || dict.length!= DICT_LENGTH) {
            throw new IllegalArgumentException("码表不合法");
        }
        this.dict = dict;
    }

    //-----------
    /**
     * 序列号
     */
    private static final int SEQUENCE_BIT_LENGTH = 32;
    private static final long SEQUENCE_MASK = (1L << SEQUENCE_BIT_LENGTH) - 1;

    /**
     * 用户id
     */
    private static final int USER_ID_BIT_LENGTH = 28;
    private static final long USER_ID_MASK = (1L << USER_ID_BIT_LENGTH) - 1;
    private static final int USER_LEFT_SHIFT_BITS = SEQUENCE_BIT_LENGTH;

    /**
     * 填充位
     */
    private static final int PADDING_BIT_LENGTH = 4;
    private static final long PADDING_MASK = (1L << PADDING_BIT_LENGTH) - 1;
    private static final int PADDING_LEFT_SHIFT_BITS = USER_ID_BIT_LENGTH + SEQUENCE_BIT_LENGTH;

    private static final long PADDING_NUM = 0;

    /**
     * 根据userId和seq 生成一个新的唯一64bit值
     * @param userId
     * @param seq
     * @return
     */
    public long getUid(long userId, long seq) {
        long uid = PADDING_NUM << PADDING_LEFT_SHIFT_BITS | ((userId & USER_ID_MASK) << USER_LEFT_SHIFT_BITS) | seq & SEQUENCE_MASK;
        return uid;
    }

    /**
     * 转换为定长码
     * @param id
     * @return
     */
    public String getFixedLengthCode(long id) {
        //2.转换为字符串
        StringBuilder sb = new StringBuilder(CODE_LENGTH);
        for (int i=0; i<CODE_LENGTH; i++) {
            int mod = (int) (id & DICT_MASK);
            sb.append(dict[mod]);
            id = id >> DICT_BIT_LENGTH;
        }
        StringBuilder rs = sb.reverse();
        return rs.toString();
    }

    public String getCode(long id) {
        //2.转换为字符串
        StringBuilder sb = new StringBuilder(CODE_LENGTH);
        while (id != 0) {
            int mod = (int) (id & DICT_MASK);
            sb.append(dict[mod]);
            id = id >> DICT_BIT_LENGTH;
        }
        StringBuilder rs = sb.reverse();
        return rs.toString();
    }
}

import io.mindflow.architect.luckcode.service.LuckyCodeService;
import org.junit.Before;
import org.junit.Test;

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

    private LuckyCodeService codeService;

    @Before
    public void init() {
        char[] dict = {'A', 'B', 'C', 'D',
                'E', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T',
                'U', 'V', 'W', 'X', 'Y', 'Z', '2', '3', '4', '5', '6', '7', '8', '9'};

        this.codeService = new LuckyCodeService(dict);
    }

    @Test
    public void testBatch() {
        long userId = 24000000l;
        long seq = 364000000l;

        for (int i=0; i<20; i++) {
            long uid = codeService.getUid(userId, seq+i);
            System.out.println(uid +"\t"+codeService.getFixedLengthCode(uid));
        }
    }
}

103079215468000000	AC5TYAAL5EN2A
103079215468000001	AC5TYAAL5EN2B
103079215468000002	AC5TYAAL5EN2C
103079215468000003	AC5TYAAL5EN2D
103079215468000004	AC5TYAAL5EN2E
103079215468000005	AC5TYAAL5EN2F
103079215468000006	AC5TYAAL5EN2G
103079215468000007	AC5TYAAL5EN2H
103079215468000008	AC5TYAAL5EN2J
103079215468000009	AC5TYAAL5EN2K
103079215468000010	AC5TYAAL5EN2L
103079215468000011	AC5TYAAL5EN2M
103079215468000012	AC5TYAAL5EN2N
103079215468000013	AC5TYAAL5EN2P
103079215468000014	AC5TYAAL5EN2Q
103079215468000015	AC5TYAAL5EN2R
103079215468000016	AC5TYAAL5EN2S
103079215468000017	AC5TYAAL5EN2T
103079215468000018	AC5TYAAL5EN2U
103079215468000019	AC5TYAAL5EN2V

/**
 * 纪元, 2018-08-01 00:00:00
*/
private static final long epoch = new DateTime(2018, 8, 1, 0, 0, 0).getMillis();

long seconds = (System.currentTimeMillis() - epoch)/1000;
long uid = PADDING_NUM << PADDING_LEFT_SHIFT_BITS | ((seconds & TIMESTAMP_MASK) << TIMESTAMP_LEFT_SHIFT_BITS) | seq & SEQUENCE_MASK;

local key = KEYS[1] --限流KEY（一秒一个）
local limit = tonumber(ARGV[1])        --限流大小
local current = tonumber(redis.call('get', key))
if current + 1 > limit then --如果超出限流大小
    return 0
else  --请求数+1，并设置2秒过期
    redis.call("INCRBY", key,"1")
    redis.call("expire", key,"2")
    return 1
end

redis-cli --ldb --eval /tmp/script.lua mykey somekey , arg1 arg2

import java.lang.annotation.*;

/**
 * @author Ricky Fung
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface RequiredAuth {

}

/**
 * @author Ricky Fung
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface OptionalAuth {

}

import org.apache.commons.lang3.StringUtils;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @author Ricky Fung
 */
public class AuthInterceptor extends HandlerInterceptorAdapter {
    private static final String AUTHORIZATION_HEADER = "Authorization";

    @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, true);
        }
        OptionalAuth optionalAuth = AnnotationUtils.findAnnotation(handlerMethod.getMethod(), OptionalAuth.class);
        if (optionalAuth != null) {
            return checkAuth(request, false);
        }
        return true;
    }

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

    private boolean checkAuth(HttpServletRequest request, boolean required) {
        String token = request.getHeader(AUTHORIZATION_HEADER);
        if (StringUtils.isEmpty(token) && required) {
            throw new InvalidTokenException("token为空");
        }
        RequestContext context;
        try {
            //JWT
            context = decodeJwt(token);
        } catch (Exception e) {
            if (required) {
                throw new InvalidTokenException("token非法", e);
            }
            context = new DefaultRequestContext(null, null);
        }
        RequestContextHolder.setContext(context);
        return true;
    }

    private RequestContext decodeJwt(String token) throws Exception {
        //JWT
        RequestContext context = new DefaultRequestContext(0L, "");
        return context;
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @author Ricky Fung
 */
@ControllerAdvice
public class GlobalExceptionHandler {
    private static final Logger LOGGER = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    @ExceptionHandler
    @ResponseBody
    public ApiResult exceptionHandler(InvalidTokenException ex) {
        return ApiResult.buildFailureResult(403, "请先登录");
    }

    @ExceptionHandler
    @ResponseBody
    public ApiResult exceptionHandler(IllegalArgumentException ex) {
        return ApiResult.buildInvalidParameterResult(ex.getMessage());
    }

    @ExceptionHandler
    @ResponseBody
    public ApiResult exceptionHandler(Exception ex) {
        LOGGER.error("系统异常", ex);
        return ApiResult.buildSystemErrorResult();
    }
}

/**
 * @author Ricky Fung
 */
public interface RequestContext {

    Long getUserId();

    String getNickname();

}

/**
 * @author Ricky Fung
 */
public class DefaultRequestContext implements RequestContext {
    private Long userId;
    private String nickname;

    public DefaultRequestContext(Long userId, String nickname) {
        this.userId = userId;
        this.nickname = nickname;
    }

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

    @Override
    public String getNickname() {
        return this.nickname;
    }
}

/**
 * @author Ricky Fung
 */
public class RequestContextHolder {
    private static final ThreadLocal<RequestContext> THREAD_LOCAL = new ThreadLocal<>();

    public static void setContext(RequestContext context) {
        THREAD_LOCAL.set(context);
    }

    public static RequestContext getContext() {
        return THREAD_LOCAL.get();
    }

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

/**
 * @author Ricky Fung
 */
public class InvalidTokenException extends RuntimeException {

    public InvalidTokenException() {
    }

    public InvalidTokenException(String message) {
        super(message);
    }

    public InvalidTokenException(String message, Throwable cause) {
        super(message, cause);
    }
}

/**
 * @author Ricky Fung
 */
public class ApiResult<T> {
    public static final int SUCCESS_CODE = 1;
    public static final String SUCCESS_MESSAGE = "OK";

    /**  **/
    public static final int INVALID_REQUEST_PARAMETER = 400;
    public static final int SYSTEM_ERROR_CODE = 500;

    private int code;
    private String message;
    private T data;

    public ApiResult() {
    }

    public ApiResult(int code, String message, T data) {
        this.code = code;
        this.message = message;
        this.data = data;
    }

    /**
     * 请求成功
     * @param <T>
     * @return
     */
    public static <T> ApiResult buildSuccessResult() {
        return new ApiResult(SUCCESS_CODE, SUCCESS_MESSAGE, null);
    }
    /**
     * 请求成功
     * @param data
     * @param <T>
     * @return
     */
    public static <T> ApiResult buildSuccessResult(T data) {
        return new ApiResult(SUCCESS_CODE, SUCCESS_MESSAGE, data);
    }

    /**
     * 参数非法
     * @param message
     * @param <T>
     * @return
     */
    public static <T> ApiResult buildInvalidParameterResult(String message) {
        return new ApiResult(INVALID_REQUEST_PARAMETER, message, null);
    }

    /**
     * 定制错误(有特定业务含义)
     * @param code
     * @param message
     * @param <T>
     * @return
     */
    public static <T> ApiResult buildFailureResult(int code, String message) {
        return new ApiResult(code, message, null);
    }

    public static <T> ApiResult buildFailureResult(int code, String message, T data) {
        return new ApiResult(code, message, data);
    }

    /**
     * 系统异常
     * @param <T>
     * @return
     */
    public static <T> ApiResult buildSystemErrorResult() {
        return new ApiResult(SYSTEM_ERROR_CODE, "服务器开小差了，请稍后再试！", null);
    }

    public boolean isSuccess() {
        return code == SUCCESS_CODE;
    }

    public int getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }

    public T getData() {
        return data;
    }
}

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author Ricky Fung
 */
@RestController
@RequestMapping("/api/demo")
public class DemoController {

    @RequiredAuth
    @GetMapping
    public ApiResult hello() {
        
        return ApiResult.buildSystemErrorResult();
    }
}

CREATE TABLE `investment_cmpt_detail` (
`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
`activity_id` int(10) NOT NULL COMMENT '活动id',
`user_id` bigint(20) unsigned NOT NULL COMMENT '用户id',
`name` varchar(45) NOT NULL COMMENT '用户真实姓名',
`buy_amount` decimal(10,2) NOT NULL COMMENT '购买理财计划金额',
`buy_record_detail_id` bigint(20) unsigned NOT NULL COMMENT '购买理财计划详情id',
`buy_time` datetime DEFAULT NULL COMMENT '购买时间',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
`update_time` datetime DEFAULT NULL COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uniq_user_id` (`user_id`,`activity_id`,`buy_record_detail_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='规模擂台赛用户投资明细表';

    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 setScale(BigDecimal bd, int scale) {
        return bd.setScale(scale, BigDecimal.ROUND_HALF_UP);
    }

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

import java.math.BigDecimal;

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

    //------------
    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 String format(BigDecimal bd, int scale) {
        return bd.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

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

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

    //-----------
    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 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 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 div(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.divide(b2,2, BigDecimal.ROUND_HALF_UP);//四舍五入,保留两位小数
    }
}

    @Test
    public void testMoney() {
        NumberFormat nf = new DecimalFormat("¥##.####");
        Double d = 87654.4545454;
        String str = nf.format(d);
        System.out.println(str);
    }

    @Test
    public void testMoney() {
        NumberFormat nf = new DecimalFormat("#,###.##");
        Double d = 87654321.456;
        String str = nf.format(d);
        System.out.println(str);
    }

$ git checkout -b feature-xxx develop
Switched to a new branch "feature-xxx"

git checkout -b release-1.2 develop
Switched to a new branch "release-1.2"

$ git checkout master
Switched to branch 'master'
$ git merge --no-ff release-1.2
Merge made by recursive.
(Summary of changes)
$ git tag -a 1.2

$ git checkout develop
Switched to branch 'develop'
$ git merge --no-ff release-1.2
Merge made by recursive.
(Summary of changes)

$ git branch -d release-1.2
Deleted branch release-1.2 (was ff452fe).

$ git checkout -b hotfix-1.2.1 master
Switched to a new branch "hotfix-1.2.1"

apple$ vim ~/.bash_profile

alias ll='ls -alF'
alias la='ls -A'
alias l='ls -CF'

apple$ source ~/.bash_profile

appledeMacBook-Pro-181:activity apple$ ll
total 40
drwxr-xr-x  16 apple  staff    512 Nov 12 17:40 ./
drwxr-xr-x  22 apple  staff    704 Nov  6 18:56 ../
drwxr-xr-x  15 apple  staff    480 Nov 13 11:42 .git/
-rw-r--r--   1 apple  staff    440 Sep  5 11:30 .gitignore
drwxr-xr-x   9 apple  staff    288 Nov 13 12:03 .idea/
-rw-r--r--   1 apple  staff     20 Nov 12 17:40 README.md
drwxr-xr-x   5 apple  staff    160 Nov 13 11:42 activity-admin/
drwxr-xr-x   4 apple  staff    128 Nov 13 11:42 activity-common/
drwxr-xr-x   5 apple  staff    160 Nov 13 11:42 activity-core/
drwxr-xr-x   5 apple  staff    160 Nov 13 11:42 activity-jms/
drwxr-xr-x   9 apple  staff    288 Nov 13 11:42 activity-mobile/
drwxr-xr-x   4 apple  staff    128 Nov 13 11:42 activity-mysql/
drwxr-xr-x   4 apple  staff    128 Nov 13 11:42 activity-redis/
drwxr-xr-x   5 apple  staff    160 Nov 13 11:42 activity-schedule/
drwxr-xr-x   8 apple  staff    256 Nov 13 11:42 activity-web/
-rw-r--r--   1 apple  staff  10467 Sep 11 14:52 pom.xml

import java.util.concurrent.TimeUnit;

/**
 * @author Ricky Fung
 */
public interface DistributedLock {

    void lock();

    boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException;

    boolean isLocked();

    boolean isHeldByCurrentThread();

    void forceUnlock();

    void unlock();
}

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

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;


/**
 * @author Ricky Fung
 */
public class RedisDistributedLock implements DistributedLock {
    /** 唯一标识id **/
    private String requestId;
    /** 锁名称 **/
    private String lockKey;

    private RedisTemplate redisTemplate;
    private final List<String> keys = new ArrayList<>(1);

    // 添加操作
    private DefaultRedisScript<Long> lockScript;

    // 删除操作
    private DefaultRedisScript<Long> unlockScript;

    // 查询
    private DefaultRedisScript<Long> heldByScript;

    RedisDistributedLock(String requestId, String lockKey, RedisTemplate redisTemplate) {
        this.requestId = requestId;
        this.lockKey = lockKey;
        this.redisTemplate = redisTemplate;
        //
        this.keys.add(this.lockKey);
        //init
        init();
    }

    private void init() {
        // Lock script
        lockScript = new DefaultRedisScript<>();
        lockScript.setScriptText(RedisScriptProvider.getInstance().getLockScript());
        lockScript.setResultType(Long.class);

        // unlock script
        unlockScript = new DefaultRedisScript<>();
        unlockScript.setScriptText(RedisScriptProvider.getInstance().getUnlockScript());
        unlockScript.setResultType(Long.class);

        //held by current thread script
        heldByScript = new DefaultRedisScript<>();
        heldByScript.setScriptText(RedisScriptProvider.getInstance().getHoldByScript());
        heldByScript.setResultType(Long.class);
    }

    @Override
    public void lock() {
        while (true) {
            boolean success = tryAcquire(30L, TimeUnit.SECONDS);
            if (success) {
                return;
            }
            try {
                TimeUnit.MILLISECONDS.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    @Override
    public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
        long time = unit.toMillis(waitTime);
        long current = System.currentTimeMillis();
        boolean res = tryAcquire(leaseTime, unit);
        // lock acquired
        if (res) {
            return true;
        }
        time -= (System.currentTimeMillis() - current);
        if (time <= 0) {
            return false;
        }
        while (true) {
            long currentTime = System.currentTimeMillis();
            res = tryAcquire(leaseTime, unit);
            // lock acquired
            if (res) {
                return true;
            }
            time -= (System.currentTimeMillis() - currentTime);
            if (time <= 0) {
                return false;
            }
        }
    }

    @Override
    public boolean isLocked() {
        return redisTemplate.hasKey(lockKey);
    }

    @Override
    public boolean isHeldByCurrentThread() {
        Long update = (Long) redisTemplate.execute(heldByScript, keys, getLockValue());
        if (update==1) {
            return true;
        }
        return false;
    }

    @Override
    public void forceUnlock() {
        redisTemplate.delete(lockKey);
    }

    @Override
    public void unlock() {
        Long update = (Long) redisTemplate.execute(unlockScript, keys, getLockValue());
    }

    //-------------
    private boolean tryAcquire(long leaseTime, TimeUnit unit) {
        Long update = (Long) redisTemplate.execute(lockScript, keys, getLockValue(), "NX", "PX", String.valueOf(unit.toMillis(leaseTime)));
        if (update==1) {
            return true;
        }
        return false;
    }
    //--------------

    private String getLockValue() {
        return String.format("%s:%d", requestId, Thread.currentThread().getId());
    }
}

/**
 * @author Ricky Fung
 */
public class RedisScriptProvider {
    private final String lockScript;
    private final String unlockScript;
    private final String holdByScript;

    private RedisScriptProvider() {
        this.lockScript = "local key = KEYS[1]\n" +
                "local lockValue = ARGV[1]\n" +
                "local milliseconds = tonumber(ARGV[4])\n" +
                "\n" +
                "local allowed_num = 0\n" +
                "local result = redis.call(\"set\", key, lockValue, ARGV[3], milliseconds, ARGV[2])\n" +
                "if result == nil then\n" +
                "    if redis.call(\"get\", key) == lockValue then\n" +
                "        allowed_num = 1\n" +
                "    end\n" +
                "else\n" +
                "    allowed_num = 1\n" +
                "end\n" +
                "\n" +
                "return allowed_num";

        this.unlockScript = "local locks_key = KEYS[1]\n" +
                "if redis.call(\"get\", locks_key) == ARGV[1] then\n" +
                "    return redis.call('del', locks_key)\n" +
                "else\n" +
                "    return 0\n" +
                "end";

        this.holdByScript = "local locks_key = KEYS[1]\n" +
                "if redis.call(\"get\", locks_key) == ARGV[1] then\n" +
                "    return 1\n" +
                "else\n" +
                "    return 0\n" +
                "end";
    }

    public static RedisScriptProvider getInstance() {
        return Singleton.INSTANCE;
    }

    public String getLockScript() {
        return lockScript;
    }

    public String getUnlockScript() {
        return unlockScript;
    }

    public String getHoldByScript() {
        return holdByScript;
    }

    private static class Singleton {
        private static final RedisScriptProvider INSTANCE = new RedisScriptProvider();
    }

}

/**
 * @author Ricky Fung
 */
public interface DistributedLockClient {

    DistributedLock getLock(String lockKey);
}

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

/**
 * @author Ricky Fung
 */
public class DefaultDistributedLockClient implements DistributedLockClient {

    private RedisTemplate redisTemplate;

    public DefaultDistributedLockClient(RedisTemplate redisTemplate) {
        Assert.notNull(redisTemplate, "redisTemplate is null");
        this.redisTemplate = redisTemplate;
    }

    @Override
    public DistributedLock getLock(String lockKey) {
        return new RedisDistributedLock(UUIDUtils.getCompactId(), lockKey, redisTemplate);
    }

}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.StringRedisTemplate;

/**
 * @author Ricky Fung
 */
@Configuration
public class DistributedLockConfiguration {

    @Bean
    public DistributedLockClient distributedLockClient(StringRedisTemplate redisTemplate) {
        return new DefaultDistributedLockClient(redisTemplate);
    }
}

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

/**
 * @author Ricky Fung
 */
public class DistributedLockClientTest extends BaseSpringJUnitTest {

    @Resource(name = "distributedLockClient")
    private DistributedLockClient distributedLockClient;

    private String lockKey = String.format("%s:%s", RedisConstant.KEY_PREFIX, "lock");

    @Test
    @Ignore
    public void testLock() {
        DistributedLock lock = distributedLockClient.getLock(lockKey);
        try {
            boolean success = lock.tryLock(0, 30, TimeUnit.SECONDS);
            if (!success) {
                System.out.println("加锁失败");
                return;
            }

            try {
                //write your business code
                System.out.println("加锁成功");
            } finally {
                lock.unlock();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

local key = KEYS[1]
local lockValue = ARGV[1]
local milliseconds = tonumber(ARGV[4])

local allowed_num = 0
local result = redis.call("set", key, lockValue, ARGV[3], milliseconds, ARGV[2])
if result == nil then
    if redis.call("get", key) == lockValue then
        allowed_num = 1
    end
else
    allowed_num = 1
end

return allowed_num

local locks_key = KEYS[1]
if redis.call("get", locks_key) == ARGV[1] then
    return redis.call('del', locks_key)
else
    return 0
end

local locks_key = KEYS[1]
if redis.call("get", locks_key) == ARGV[1] then
    return 1
else
    return 0
end

import org.apache.commons.lang3.StringUtils;
import javax.servlet.http.HttpServletRequest;

/**
 * @author Ricky Fung
 */
public abstract class IpUtils {
    private static final String UNKNOWN_HOST = "unknown";

    /**
     * 获取用户真实IP地址，不使用request.getRemoteAddr();的原因是有可能用户使用了代理软件方式避免真实IP地址,
     * 参考文章： http://developer.51cto.com/art/201111/305181.htm
     *
     * 可是，如果通过了多级反向代理的话，X-Forwarded-For的值并不止一个，而是一串IP值，究竟哪个才是真正的用户端的真实IP呢？
     * 答案是取X-Forwarded-For中第一个非unknown的有效IP字符串。
     *
     * 如：X-Forwarded-For：192.168.1.110, 192.168.1.120, 192.168.1.130,
     * 192.168.1.100
     *
     * 用户真实IP为： 192.168.1.110
     *
     * @param request
     * @return
     */
    public static String getIpAddress(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if (StringUtils.isBlank(ip) || UNKNOWN_HOST.equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (StringUtils.isBlank(ip) || UNKNOWN_HOST.equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (StringUtils.isBlank(ip) || UNKNOWN_HOST.equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_CLIENT_IP");
        }
        if (StringUtils.isBlank(ip) || UNKNOWN_HOST.equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_X_FORWARDED_FOR");
        }
        if (StringUtils.isBlank(ip) || UNKNOWN_HOST.equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        return ip;
    }

}

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.6</version>
</dependency>

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.2</version>
</dependency>

<foreach collection="list" item="item" open="(" close=")" separator="," index="index">
   #{item.xx}, #{item.xx}
</foreach>

collection="list"    其中list是固定的，如果是数组就是array
item="item"         循环中每一项的别名
open=""             开始标识，比如删除in (id1,id2)， open="(" close=")"
close=""            结束标识
separator=","       分隔符号
index="index"       下标值

<!-- 批量保存用户,并返回每个用户插入的ID -->
<insert id="batchSave" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id">
    INSERT INTO `tb_user`(`username`, age)
    VALUES
    <foreach collection="list" item="item" separator=",">
        (#{item.username}, #{item.age})
    </foreach>
</insert>

<!-- 批量删除用户 -->
<delete id="batchDelete" parameterType="java.util.List">
    DELETE FROM `tb_user` WHERE id IN
    <foreach collection="list" item="item" open="(" close=")" separator=",">
        #{id}
    </foreach>
</delete>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.demo.dao.UserMapper">
    <resultMap id="BaseResultMap" type="com.demo.model.UserDO">
        <id column="id" jdbcType="BIGINT" property="id" />
        <result column="user_id" jdbcType="BIGINT" property="userId" />
        <result column="age" jdbcType="INTEGER" property="age" />
        <result column="name" jdbcType="VARCHAR" property="name" />
        <result column="total_amount" jdbcType="DECIMAL" property="totalAmount" />
        <result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
        <result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
    </resultMap>

    <sql id="Base_Column_List">
        id, age, user_id, name, total_amount, create_time, update_time
    </sql>

    <select id="selectByPrimaryKey" parameterType="java.lang.Long" resultMap="BaseResultMap">
        select
        <include refid="Base_Column_List"/>
        from t_user
        where id = #{id}
    </select>

    <insert id="insert" parameterType="com.demo.model.UserDO" useGeneratedKeys="true" keyProperty="id">
        insert into t_user (
        activity_id, 
        user_id,
        name,
        total_amount,
        create_time,
        update_time)
        values (
        #{activityId}, 
        #{userId},
        #{name},
        #{totalAmount},
        now(),
        now())
    </insert>

    <!-- 批量保存用户,并返回每个用户插入的ID -->
    <insert id="batchInsert" parameterType="java.util.List" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO `t_user`(user_id, `name`, total_amount, create_time, update_time)
        VALUES
        <foreach collection="list" item="item" separator=",">
            (#{item.userId}, #{item.name}, #{item.totalAmount}, now(), now())
        </foreach>
    </insert>

    <delete id="batchDelete" parameterType="java.util.List">
        DELETE FROM `t_user` WHERE id IN
        <foreach collection="list" item="item" open="(" close=")" separator=",">
            #{id}
        </foreach>
    </delete>
</mapper>

/**
 * @author Ricky Fung
 */
public interface UserMapper {

    UserDO selectByPrimaryKey(Long id);

    int insert(UserDO record);

    int batchInsert(List<UserDO> list);

    int batchDelete(List<Long> idList);
}

CREATE TABLE `questions` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
  `title` varchar(255) NOT NULL COMMENT '题目内容',
  `mode` smallint(10) NOT NULL COMMENT '模式，0:单选，1:多选',
  `option_count` smallint(10) NOT NULL COMMENT '候选项数量',
  `answer_items` varchar(20) NOT NULL COMMENT '正确答案序号列表',
  `create_time` datetime NOT NULL COMMENT '创建时间',
  `update_time` datetime NOT NULL COMMENT '更新时间',
  PRIMARY KEY (`id`),
  KEY `idx_user_id` (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='答题题库表';

CREATE TABLE `answer_options` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
  `question_id` bigint(20) unsigned NOT NULL COMMENT '关联题库id',
  `seq` int(10) NOT NULL COMMENT '序号',
  `content` varchar(40) NOT NULL COMMENT '内容',
  `create_time` datetime NOT NULL COMMENT '创建时间',
  `update_time` datetime NOT NULL COMMENT '更新时间',
  PRIMARY KEY (`id`),
  KEY `idx_question_id` (`question_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='答题候选项表';

for (int i=0; i<1000000; i++) {
     String url = "http://abc.com/share.jsp?uid="+ i +"&utm_source=wechat";
}

String sign = SignUtils.genSign(MapUtils.buildParamMap(String.valueOf(userId), utmSource), secret);

Map<String, String> param = MapUtils.buildParamMap(userId, utmSource);
boolean match =  SignUtils.checkSign(param, secret, sign);

import java.util.*;

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

    /**
     * 计算签名
     * @param param
     * @param secret
     * @return
     */
    public static String genSign(Map<String, String> param, String secret) {
        Map<String, String> map = new TreeMap<String, String>(
                new Comparator<String>() {
                    public int compare(String o1, String o2) {
                        // 降序排序
                        return o1.compareTo(o2);
                    }
                });
        //全部加入
        map.putAll(param);

        Set<String> keySet = map.keySet();
        Iterator<String> it = keySet.iterator();
        StringBuilder sb = new StringBuilder(256);
        while (it.hasNext()) {
            String key = it.next();
            sb.append(key).append("=").append(map.get(key));
        }
        //添加secret
        sb.append(secret);
        String str = sb.toString();
        return DigestUtils.md5Hex(str);
    }

    /**
     * 校验签名
     * @param param
     * @param secret
     * @param sign
     * @return
     */
    public static boolean checkSign(Map<String, String> param, String secret, String sign) {
        String origin = genSign(param, secret);
        return origin.equals(sign);
    }
}

/**
 * @author Ricky Fung
 */
@Service
public class InvitationCodeService {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    private final char[] dict = new char[]{'1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd',
            'e', 'f', 'g', 'h', 'j', 'k', 'm', 'n', 'p', 'q', 'r', 's', 't',
            'u', 'v', 'w', 'x', 'y', 'z'};

    private static final int DICT_BIT_LENGTH = 5;

    private static final int DICT_MASK = (1 << DICT_BIT_LENGTH) - 1;

    /**
     * 纪元, 2018-08-01 00:00:00
     */
    private static final long epoch = new DateTime(2018, 8, 1, 0, 0, 0).getMillis();

    /**
     * 时间戳位数
     */
    private static final int TIMESTAMP_BIT_LENGTH = 34;

    private static final long TIMESTAMP_MASK = (1L << TIMESTAMP_BIT_LENGTH) - 1;

    /**
     * 随机数
     */
    private static final int RANDOM_BIT_LENGTH = 3;
    private static final long RANDOM_MASK = (1L << RANDOM_BIT_LENGTH) - 1;

    /**
     * 随机数左移位数
     */
    private static final int RANDOM_LEFT_SHIFT_BITS = TIMESTAMP_BIT_LENGTH;
    /**
     * userId 左移位数
     */
    private static final int USER_LEFT_SHIFT_BITS = TIMESTAMP_BIT_LENGTH + RANDOM_BIT_LENGTH;

    /**
     * 所能支持的最大user_id
     */
    private static final long MAX_USER_ID = (1L << (63 - USER_LEFT_SHIFT_BITS)) - 1;

    private static final int CODE_LENGTH = 13;

    /**
     * 不足则填充 零
     */
    private static final char PADDING_CHAR = '0';

    /**
     * 生成招财码
     * @param userId
     * @return
     */
    public String genCode(long userId) {
        String code = getUniqueCode(userId);
        return padding(code, PADDING_CHAR, CODE_LENGTH);
    }

    public String getUniqueCode(long userId) {
        //1.得到一个long值
        long num = getUniqueNum(userId).getUid();
        //2.转换为字符串
        StringBuilder sb = new StringBuilder(CODE_LENGTH);
        while (num != 0) {
            int i = (int) (num & DICT_MASK);
            sb.append(dict[i]);
            num = num >> DICT_BIT_LENGTH;
        }
        StringBuilder rs = sb.reverse();
        return rs.toString();
    }

    /**
     * 产生一个64bit的正整数
     * @param userId
     * @return
     */
    public FortuneUidVO getUniqueNum(long userId) {
        //bugfix: 修复超出范围后死循环导致OOM
        if (userId> MAX_USER_ID) {
            throw new IllegalArgumentException(String.format("userId:%s 超出最大id: %s范围了", userId, MAX_USER_ID));
        }
        //
        long millis = System.currentTimeMillis();
        long thread = Thread.currentThread().getId();
        //
        long uid = (userId << USER_LEFT_SHIFT_BITS | ((thread & RANDOM_MASK) << RANDOM_LEFT_SHIFT_BITS) | ((millis - epoch) & TIMESTAMP_MASK));
        return new FortuneUidVO(userId, thread, epoch, millis, uid);
    }

    private String padding(String str, char padding, int length) {
        if (str.length() >= length) {
            return str;
        }
        StringBuilder sb = new StringBuilder(length);
        if (str.length() < length) {    //填充
            int dist = length - str.length();
            for (int i=0; i<dist; i++) {
                sb.append(padding);
            }
        }
        sb.append(str);
        return sb.toString();
    }

}

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged(new PrivilegedAction<Object>() {
            public Object run() {
                invokeAwareMethods(beanName, bean);
                return null;
            }
        }, getAccessControlContext());
    }
    else {
        invokeAwareMethods(beanName, bean);
    }

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
    invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
                (mbd != null ? mbd.getResourceDescription() : null),
                beanName, "Invocation of init method failed", ex);
    }

    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    return wrappedBean;
}

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
        throws BeansException {

    Object result = existingBean;
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        result = beanProcessor.postProcessAfterInitialization(result, beanName);
        if (result == null) {
            return result;
        }
    }
    return result;
}

public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    if (bean != null) {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        if (!this.earlyProxyReferences.contains(cacheKey)) {
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}

	protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
		if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
			return bean;
		}
		if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
			return bean;
		}
		if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
			this.advisedBeans.put(cacheKey, Boolean.FALSE);
			return bean;
		}

		// Create proxy if we have advice.
		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
		if (specificInterceptors != DO_NOT_PROXY) {
			this.advisedBeans.put(cacheKey, Boolean.TRUE);
			Object proxy = createProxy(
					bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
			this.proxyTypes.put(cacheKey, proxy.getClass());
			return proxy;
		}

		this.advisedBeans.put(cacheKey, Boolean.FALSE);
		return bean;
	}

	@Override
	@Nullable
	protected Object[] getAdvicesAndAdvisorsForBean(
			Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {

		List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
		if (advisors.isEmpty()) {
			return DO_NOT_PROXY;
		}
		return advisors.toArray();
	}

CREATE {DATABASE | SCHEMA} [IF NOT EXISTS] db_name
[create_specification [, create_specification] ...]
create_specification:
[DEFAULT] CHARACTER SET charset_name
| [DEFAULT] COLLATE collation_name

CREATE DATABASE `test` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

CREATE DATABASE `test` DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci ;

CREATE TABLE `operation_user_investment_detail` (
`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
`activity_id` bigint(20) NOT NULL COMMENT '活动id',
`user_id` bigint(20) unsigned NOT NULL COMMENT '用户id',
`name` varchar(40) NOT NULL COMMENT '用户真实姓名',
`buy_amount` decimal(12,2) NOT NULL COMMENT '购买理财计划金额',
`buy_record_detail_id` bigint(20) unsigned NOT NULL COMMENT '购买理财计划详情id',
`buy_time` datetime DEFAULT NULL COMMENT '购买时间',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
`update_time` datetime DEFAULT NULL COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uniq_buy_record_id` (`buy_record_detail_id`, `activity_id`),
KEY `idx_activity_id_user_id` (`activity_id`, `user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='活动后台用户投资记录表';

CREATE TABLE `operation_user_investment_detail` (
`id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
`activity_id` bigint(20) NOT NULL COMMENT '活动id',
`user_id` bigint(20) unsigned NOT NULL COMMENT '用户id',
`name` varchar(40) NOT NULL COMMENT '用户真实姓名',
`buy_amount` decimal(12,2) NOT NULL COMMENT '购买理财计划金额',
`buy_record_detail_id` bigint(20) unsigned NOT NULL COMMENT '购买理财计划详情id',
`buy_time` datetime DEFAULT NULL COMMENT '购买时间',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
`update_time` datetime DEFAULT NULL COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uniq_buy_record_id` (`buy_record_detail_id`, `activity_id`),
KEY `idx_activity_id_user_id` (`activity_id`, `user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='活动后台用户投资记录表';

ALTER TABLE table_name ADD COLUMN new_column_name varchar(20) not null;

ALTER TABLE table_name ADD COLUMN new_column_name varchar(20) not null AFTER column_name;

ALTER TABLE `t_user` ADD COLUMN age varchar(20) not null;

ALTER TABLE `t_user` ADD COLUMN age varchar(20) not null AFTER gender;

//普通索引
ALTER TABLE `table_name` ADD INDEX index_name(`column1`,`column2`,`column3`)
//唯一索引
ALTER TABLE `table_name` ADD UNIQUE INDEX index_name(`column1`,`column2`,`column3`)

ALTER TABLE `operation_user_coin` ADD INDEX idx_activity_id (`activity_id`) ;

ALTER TABLE `operation_user_coin` ADD UNIQUE INDEX uniq_activity_user(`coin_id`,`user_id`);

DROP INDEX index_name ON table_name;

ALTER TABLE table_name DROP index index_name;

ALTER TABLE `wb_blog` DROP INDEX idx_user; 

appledeMacBook-Pro-181:~ apple$ git status
xcrun: error: invalid active developer path (/Library/Developer/CommandLineTools), missing xcrun at: /Library/Developer/CommandLineTools/usr/bin/xcrun

sudo xcode-select -switch /Applications/Xcode.app/Contents/Developer

xcode-select --install

CREATE TABLE `user` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
  `nickname` varchar(45) NOT NULL COMMENT '用户昵称',
  `name` varchar(45) NOT NULL DEFAULT '' COMMENT '用户真实姓名',
  `gender` tinyint(2) unsigned NOT NULL DEFAULT '0' COMMENT '性别, 0:男, 1:女, 2:未知',
  `mobile` varchar(20) NOT NULL DEFAULT '' COMMENT '密码',
  `version` int(10) unsigned NOT NULL DEFAULT 1 COMMENT '版本号',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `update_time` datetime DEFAULT NULL COMMENT '更新时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户表';

CREATE TABLE `user_sign_in` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
  `user_id` bigint(20) unsigned NOT NULL COMMENT '用户id',
  `nickname` varchar(45) NOT NULL COMMENT '用户昵称',
  `last_sign_in_date` int(10) unsigned NOT NULL COMMENT '最近一次签到日期，格式: yyyyMMdd',
  `continuous_sign_in_days` int(10) unsigned NOT NULL COMMENT '连续签到天数',
  `version` int(10) unsigned NOT NULL DEFAULT 1 COMMENT '版本号',
  `create_time` datetime NOT NULL COMMENT '创建时间',
  `update_time` datetime NOT NULL COMMENT '更新时间',
  PRIMARY KEY (`id`),
  KEY `idx_user_id` (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户签到表';

CREATE TABLE `user_sign_in_log` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
  `user_id` bigint(20) unsigned NOT NULL COMMENT '用户id',
  `sign_in_date` int(10) unsigned NOT NULL COMMENT '签到日期，格式: yyyyMMdd',
  `create_time` datetime NOT NULL COMMENT '创建时间',
  `update_time` datetime NOT NULL COMMENT '更新时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uniq_user_id_sign_date` (`user_id`, `sign_in_date`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户签到log表';

package io.mindflow.architect.service;

import io.mindflow.architect.mapper.demo.UserMapper;
import io.mindflow.architect.model.demo.UserDO;
import io.mindflow.architect.model.demo.UserSignInDO;
import io.mindflow.architect.model.demo.UserSignInLogDO;
import io.mindflow.architect.util.DateUtils;
import io.mindflow.architect.util.Ints;
import io.mindflow.architect.web.vo.ApiResult;
import io.mindflow.architect.web.vo.UserSignInResultVO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

/**
 * @author Ricky Fung
 */
@Service
public class SignInService {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private UserMapper userMapper;

    @Resource(name = "signInTxService")
    private SignInTxService signInTxService;

    public ApiResult<UserSignInResultVO> doSignIn(Long userId, Date now) {
        UserDO userDO = userMapper.selectUserById(userId);
        if (userDO==null) {
            return ApiResult.buildFailureResult(1000, "用户不存在");
        }

        Integer signInDate = Integer.parseInt(DateUtils.format(now, DateUtils.DATE_COMPACT_FORMAT));
        try {
            UserSignInDO userSignInDO = signInTxService.queryUserSignInRecord(userId);
            Integer continuousSignInDays;
            if (userSignInDO==null) {
                //第一次签到
                UserSignInDO signInRecord = signInTxService.createUserSignInRecord(userDO, signInDate, now);
                UserSignInLogDO signInLogRecord = signInTxService.createUserSignInLogRecord(userId, signInDate, now);

                //保存
                signInTxService.saveSignIn(userId, signInRecord, signInLogRecord);
                continuousSignInDays = Ints.ONE;
                logger.info("用户签到服务-签到, userId:{}, signIdDate:{} 第一次签到成功", userId, signInDate);
            } else {
                if (userSignInDO.getLastSignInDate().intValue() == signInDate) {
                    return ApiResult.buildFailureResult(1001, "今日已签到");
                }

                boolean continuousSignIn = true;
                //计算时间差
                Date lastSignDate = DateUtils.parseDate(userSignInDO.getLastSignInDate().toString(), DateUtils.DATE_COMPACT_FORMAT);
                if (Math.abs(DateUtils.daysBetween(lastSignDate, now)) > Ints.ONE) {
                    continuousSignIn = false;
                }
                UserSignInDO signInRecord = signInTxService.createUserSignInRecordV1(userSignInDO, continuousSignIn, signInDate, now);
                UserSignInLogDO signInLogRecord = signInTxService.createUserSignInLogRecord(userId, signInDate, now);
                //保存
                signInTxService.saveSignIn(userId, signInRecord, signInLogRecord);
                continuousSignInDays = signInRecord.getContinuousSignInDays();
                logger.info("用户签到服务-签到, userId:{}, signIdDate:{} continuousSignIn:{}, continuousSignInDays:{} 签到成功",
                        userId, signInDate, continuousSignIn, continuousSignInDays);
            }
            UserSignInResultVO resultVO = new UserSignInResultVO();
            resultVO.setContinuousSignInDays(continuousSignInDays);
            return ApiResult.buildSuccessResult(resultVO);
        } catch (Exception e) {
            logger.error("用户签到服务-签到接口异常, userId:{}, signInDate:{}", userId, signInDate, e);
        }
        return ApiResult.buildSystemErrorResult();
    }
}

package io.mindflow.architect.service;

import io.mindflow.architect.mapper.demo.UserSignInLogMapper;
import io.mindflow.architect.mapper.demo.UserSignInMapper;
import io.mindflow.architect.model.demo.UserDO;
import io.mindflow.architect.model.demo.UserSignInDO;
import io.mindflow.architect.model.demo.UserSignInLogDO;
import io.mindflow.architect.util.Ints;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;

/**
 * @author Ricky Fung
 */
@Component
public class SignInTxService {
    @Autowired
    private UserSignInMapper signInMapper;

    @Autowired
    private UserSignInLogMapper signInLogMapper;

    @Transactional
    public int saveSignIn(Long userId, UserSignInDO signInRecord, UserSignInLogDO signInLogRecord) {
        if (signInRecord.getId()==null) {
            signInMapper.insert(signInRecord);
        } else {
            signInMapper.updateByPrimaryKeySelective(signInRecord);
        }

        return signInLogMapper.insert(signInLogRecord);
    }

    //-------
    public UserSignInDO createUserSignInRecordV1(UserSignInDO userSignInDO, boolean continuousSignIn, Integer signInDate, Date now) {
        UserSignInDO signInDO = new UserSignInDO();
        //主键id
        signInDO.setId(userSignInDO.getId());

        signInDO.setLastSignInDate(signInDate);
        if (continuousSignIn) {
            //连续签到
            signInDO.setContinuousSignInDays(userSignInDO.getContinuousSignInDays() + Ints.ONE);
        } else {
            signInDO.setContinuousSignInDays(Ints.ONE);
        }

        signInDO.setVersion(userSignInDO.getVersion());
        signInDO.setUpdateTime(now);
        return signInDO;
    }

    public UserSignInDO createUserSignInRecord(UserDO userDO, Integer signIdDate, Date now) {
        UserSignInDO signInDO = new UserSignInDO();
        signInDO.setUserId(userDO.getId());
        signInDO.setNickname(userDO.getNickname());
        signInDO.setLastSignInDate(signIdDate);
        signInDO.setContinuousSignInDays(Ints.ONE);
        signInDO.setVersion(Ints.ONE);
        signInDO.setCreateTime(now);
        signInDO.setUpdateTime(now);
        return signInDO;
    }

    public UserSignInLogDO createUserSignInLogRecord(Long userId, Integer signIdDate, Date now) {
        UserSignInLogDO signInLogDO = new UserSignInLogDO();
        signInLogDO.setUserId(userId);
        signInLogDO.setSignInDate(signIdDate);
        signInLogDO.setCreateTime(now);
        signInLogDO.setUpdateTime(now);
        return signInLogDO;
    }

    //-------
    public UserSignInDO queryUserSignInRecord(Long userId) {
        return signInMapper.selectByUserId(userId);
    }

    public UserSignInLogDO queryUserSignInRecord(Long userId, Integer signIdDate) {
        return signInLogMapper.selectByUserIdAndDate(userId, signIdDate);
    }

}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="io.mindflow.architect.mapper.demo.UserSignInMapper">
    <resultMap id="BaseResultMap" type="io.mindflow.architect.model.demo.UserSignInDO">
        <id column="id" jdbcType="BIGINT" property="id" />
        <id column="user_id" jdbcType="BIGINT" property="userId" />
        <result column="nickname" jdbcType="VARCHAR" property="nickname" />
        <result column="last_sign_in_date" jdbcType="INTEGER" property="lastSignInDate" />
        <result column="continuous_sign_in_days" jdbcType="INTEGER" property="continuousSignInDays" />
        <result column="version" jdbcType="INTEGER" property="version" />
        <result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
        <result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
    </resultMap>

    <sql id="Base_Column_List">
        id, user_id, nickname, last_sign_in_date, continuous_sign_in_days, version, create_time, update_time
    </sql>

    <select id="selectByUserId" resultMap="BaseResultMap">
        SELECT
        <include refid="Base_Column_List"></include>
        FROM `user_sign_in`
        WHERE  user_id = #{userId}
    </select>

    <insert id="insert" parameterType="io.mindflow.architect.model.demo.UserSignInDO" useGeneratedKeys="true" keyProperty="id">
        insert into `user_sign_in` (
        user_id,
        nickname,
        last_sign_in_date,
        continuous_sign_in_days,
        version,
        create_time,
        update_time)
        values (
        #{userId},
        #{nickname},
        #{lastSignInDate},
        #{continuousSignInDays},
        #{version},
        #{createTime},
        #{updateTime})
    </insert>

    <update id="updateByPrimaryKeySelective" parameterType="io.mindflow.architect.model.demo.UserSignInDO">
        update `user_sign_in`
        <set>
            <if test="userId != null">
                user_id = #{userId},
            </if>
            <if test="nickname != null">
                nickname = #{nickname},
            </if>
            <if test="lastSignInDate != null">
                last_sign_in_date = #{lastSignInDate},
            </if>
            <if test="continuousSignInDays != null">
                continuous_sign_in_days = #{continuousSignInDays},
            </if>
            version = version + 1,
            update_time = now()
        </set>
        where id = #{id}
        AND version = #{version}
    </update>

</mapper>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
    </dependencies>

    /**
     * 更新用户步数
     * @param user
     * @param date
     * @param step
     */
    public void updateUserStep(User user, Date date, int step) {
        String key = getRankingKey(date);
        //计算score，为了让步数大的排在前面
        double score = MAX_STEP - step;
        stringRedisTemplate.opsForZSet().add(key, serializeUser(user), score);
    }

    /**
     * 获取用户在排行榜中的排名
     * @param user
     * @param date
     */
    public long getUserRanking(User user, Date date) {
        String key = getRankingKey(date);
        return stringRedisTemplate.opsForZSet().rank(key, serializeUser(user)).longValue() + 1;
    }

    /**
     * 获取排行榜列表
     * @param date
     * @param num
     * @return
     */
    public List<RankingItem> getTopN(Date date, int num) {
        String key = getRankingKey(date);
        Set<ZSetOperations.TypedTuple<String>> tuples = stringRedisTemplate.opsForZSet().rangeWithScores(key, 0, num);
        if (CollectionUtils.isEmpty(tuples)) {
            return Collections.emptyList();
        }
        List<RankingItem> rankingList = new ArrayList<>(tuples.size());
        for (ZSetOperations.TypedTuple<String> tuple: tuples) {

            RankingItem item = new RankingItem();
            User user = deserializeUser(tuple.getValue());
            item.setUserId(user.getId());
            item.setNickname(user.getNickname());
            //计算用户步数
            Double score = tuple.getScore();
            item.setStep(MAX_STEP - score.intValue());

            rankingList.add(item);
        }
        return rankingList;
    }

/**
 * @author Ricky Fung
 */
public class WechatStepRankingServiceTest extends BaseSpringJUnitTest {

    @Resource(name = "wechatStepRankingService")
    private WechatStepRankingService wechatStepRankingService;

    @Test
    public void testUpdateRanking() {
        Date now = new Date();
        int step = 2000;
        for (int i=0; i<100; i++) {
            User user = new User();
            user.setId(Long.valueOf(i));
            user.setNickname("ws"+i);
            wechatStepRankingService.updateUserStep(user, now, step+i);
        }
    }

    @Test
    public void testRankingList() {
        Date now = new Date();
        List<RankingItem> list = wechatStepRankingService.getTopN(now, 20);
        System.out.println(JsonUtils.toJson(list));
    }

    @Test
    public void testUserRanking() {
        Date now = new Date();
        User user = new User();
        Long userId = 98L;
        user.setId(userId);
        user.setNickname("ws"+userId);
        long rank = wechatStepRankingService.getUserRanking(user, now);
        System.out.println(rank);
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.*;

/**
 * 微信运动-步数排行榜
 * @author Ricky Fung
 */
@Service
public class WechatStepRankingService {

    /**
     * 用户每天步数上限：100万步
     */
    private static final int MAX_STEP = 1000000;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 更新用户步数
     * @param user
     * @param date
     * @param step
     */
    public void updateUserStep(User user, Date date, int step) {
        String key = getRankingKey(date);
        //计算score，为了让步数大的排在前面
        double score = MAX_STEP - step;
        stringRedisTemplate.opsForZSet().add(key, serializeUser(user), score);
    }

    /**
     * 获取排行榜列表
     * @param date
     * @param num
     * @return
     */
    public List<RankingItem> getTopN(Date date, int num) {
        String key = getRankingKey(date);
        Set<ZSetOperations.TypedTuple<String>> tuples = stringRedisTemplate.opsForZSet().rangeWithScores(key, 0, num);
        if (CollectionUtils.isEmpty(tuples)) {
            return Collections.emptyList();
        }
        List<RankingItem> rankingList = new ArrayList<>(tuples.size());
        for (ZSetOperations.TypedTuple<String> tuple: tuples) {

            RankingItem item = new RankingItem();
            User user = deserializeUser(tuple.getValue());
            item.setUserId(user.getId());
            item.setNickname(user.getNickname());
            //计算用户步数
            Double score = tuple.getScore();
            item.setStep(MAX_STEP - score.intValue());

            rankingList.add(item);
        }
        return rankingList;
    }

    /**
     * 获取用户排行榜排名
     * @param user
     * @param date
     */
    public long getUserRanking(User user, Date date) {
        String key = getRankingKey(date);
        return stringRedisTemplate.opsForZSet().rank(key, serializeUser(user)).longValue() + 1;
    }

    private String getRankingKey(Date date) {
        return String.format("%s:%s", "wechat:rank", DateUtils.formatDate(date));
    }

    //----------
    private String serializeUser(User user) {
        return String.format("%s#%s", user.getId(), user.getNickname());
    }

    private User deserializeUser(String str) {
        String[] arr = str.split("#");
        User user = new User();
        user.setId(Long.parseLong(arr[0]));
        user.setNickname(arr[1]);
        return user;
    }
}

public class User {
    private Long id;
    private String nickname;

    //省略 getter/setter
    
}

public class RankingItem {
    private Long userId;
    private String nickname;
    private int step;

    //省略 getter/setter
}

local key = KEYS[1]

local capacity = tonumber(ARGV[1])
local timestamp = tonumber(ARGV[2])
local id = ARGV[3]

local count = redis.call("zcard", key)
local allowed = count < capacity

if allowed then
  redis.call("zadd", key, timestamp, id)
end

return { allowed, count }

local tokens_key = KEYS[1]
local timestamp_key = KEYS[2]

local rate = tonumber(ARGV[1])
local capacity = tonumber(ARGV[2])
local now = tonumber(ARGV[3])
local requested = tonumber(ARGV[4])

local fill_time = capacity/rate
local ttl = math.floor(fill_time*2)

local last_tokens = tonumber(redis.call("get", tokens_key))
if last_tokens == nil then
  last_tokens = capacity
end

local last_refreshed = tonumber(redis.call("get", timestamp_key))
if last_refreshed == nil then
  last_refreshed = 0
end

local delta = math.max(0, now-last_refreshed)
local filled_tokens = math.min(capacity, last_tokens+(delta*rate))
local allowed = filled_tokens >= requested
local new_tokens = filled_tokens
if allowed then
  new_tokens = filled_tokens - requested
end

redis.call("setex", tokens_key, ttl, new_tokens)
redis.call("setex", timestamp_key, ttl, now)

return { allowed, new_tokens }

package org.springframework.scheduling.annotation;

@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Repeatable(Schedules.class)
public @interface Scheduled {

	String cron() default "";

	String zone() default "";

	long fixedDelay() default -1;

	String fixedDelayString() default "";

	long fixedRate() default -1;

	String fixedRateString() default "";

	long initialDelay() default -1;

	String initialDelayString() default "";
}

package org.springframework.scheduling.annotation;

public class ScheduledAnnotationBeanPostProcessor
		implements MergedBeanDefinitionPostProcessor, DestructionAwareBeanPostProcessor,
		Ordered, EmbeddedValueResolverAware, BeanNameAware, BeanFactoryAware, ApplicationContextAware,
		SmartInitializingSingleton, ApplicationListener<ContextRefreshedEvent>, DisposableBean {

}

	@Override
	public Object postProcessAfterInitialization(final Object bean, String beanName) {
		Class<?> targetClass = AopUtils.getTargetClass(bean);
		if (!this.nonAnnotatedClasses.contains(targetClass)) {
			Map<Method, Set<Scheduled>> annotatedMethods = MethodIntrospector.selectMethods(targetClass,
					new MethodIntrospector.MetadataLookup<Set<Scheduled>>() {
						@Override
						public Set<Scheduled> inspect(Method method) {
							Set<Scheduled> scheduledMethods = AnnotatedElementUtils.getMergedRepeatableAnnotations(
									method, Scheduled.class, Schedules.class);
							return (!scheduledMethods.isEmpty() ? scheduledMethods : null);
						}
					});
			if (annotatedMethods.isEmpty()) {
				this.nonAnnotatedClasses.add(targetClass);
				if (logger.isTraceEnabled()) {
					logger.trace("No @Scheduled annotations found on bean class: " + bean.getClass());
				}
			}
			else {
				// Non-empty set of methods
				for (Map.Entry<Method, Set<Scheduled>> entry : annotatedMethods.entrySet()) {
					Method method = entry.getKey();
					for (Scheduled scheduled : entry.getValue()) {
						processScheduled(scheduled, method, bean);
					}
				}
				if (logger.isDebugEnabled()) {
					logger.debug(annotatedMethods.size() + " @Scheduled methods processed on bean '" + beanName +
							"': " + annotatedMethods);
				}
			}
		}
		return bean;
	}

	protected void processScheduled(Scheduled scheduled, Method method, Object bean) {
		try {
			Assert.isTrue(method.getParameterTypes().length == 0,
					"Only no-arg methods may be annotated with @Scheduled");

			Method invocableMethod = AopUtils.selectInvocableMethod(method, bean.getClass());
			Runnable runnable = new ScheduledMethodRunnable(bean, invocableMethod);
			boolean processedSchedule = false;
			String errorMessage =
					"Exactly one of the 'cron', 'fixedDelay(String)', or 'fixedRate(String)' attributes is required";

			Set<ScheduledTask> tasks = new LinkedHashSet<ScheduledTask>(4);

			// Determine initial delay
			long initialDelay = scheduled.initialDelay();
			String initialDelayString = scheduled.initialDelayString();
			if (StringUtils.hasText(initialDelayString)) {
				Assert.isTrue(initialDelay < 0, "Specify 'initialDelay' or 'initialDelayString', not both");
				if (this.embeddedValueResolver != null) {
					initialDelayString = this.embeddedValueResolver.resolveStringValue(initialDelayString);
				}
				try {
					initialDelay = Long.parseLong(initialDelayString);
				}
				catch (NumberFormatException ex) {
					throw new IllegalArgumentException(
							"Invalid initialDelayString value \"" + initialDelayString + "\" - cannot parse into integer");
				}
			}

			// Check cron expression
			String cron = scheduled.cron();
			if (StringUtils.hasText(cron)) {
				Assert.isTrue(initialDelay == -1, "'initialDelay' not supported for cron triggers");
				processedSchedule = true;
				String zone = scheduled.zone();
				if (this.embeddedValueResolver != null) {
					cron = this.embeddedValueResolver.resolveStringValue(cron);
					zone = this.embeddedValueResolver.resolveStringValue(zone);
				}
				TimeZone timeZone;
				if (StringUtils.hasText(zone)) {
					timeZone = StringUtils.parseTimeZoneString(zone);
				}
				else {
					timeZone = TimeZone.getDefault();
				}
				tasks.add(this.registrar.scheduleCronTask(new CronTask(runnable, new CronTrigger(cron, timeZone))));
			}

			// At this point we don't need to differentiate between initial delay set or not anymore
			if (initialDelay < 0) {
				initialDelay = 0;
			}

			// Check fixed delay
			long fixedDelay = scheduled.fixedDelay();
			if (fixedDelay >= 0) {
				Assert.isTrue(!processedSchedule, errorMessage);
				processedSchedule = true;
				tasks.add(this.registrar.scheduleFixedDelayTask(new IntervalTask(runnable, fixedDelay, initialDelay)));
			}
			String fixedDelayString = scheduled.fixedDelayString();
			if (StringUtils.hasText(fixedDelayString)) {
				Assert.isTrue(!processedSchedule, errorMessage);
				processedSchedule = true;
				if (this.embeddedValueResolver != null) {
					fixedDelayString = this.embeddedValueResolver.resolveStringValue(fixedDelayString);
				}
				try {
					fixedDelay = Long.parseLong(fixedDelayString);
				}
				catch (NumberFormatException ex) {
					throw new IllegalArgumentException(
							"Invalid fixedDelayString value \"" + fixedDelayString + "\" - cannot parse into integer");
				}
				tasks.add(this.registrar.scheduleFixedDelayTask(new IntervalTask(runnable, fixedDelay, initialDelay)));
			}

			// Check fixed rate
			long fixedRate = scheduled.fixedRate();
			if (fixedRate >= 0) {
				Assert.isTrue(!processedSchedule, errorMessage);
				processedSchedule = true;
				tasks.add(this.registrar.scheduleFixedRateTask(new IntervalTask(runnable, fixedRate, initialDelay)));
			}
			String fixedRateString = scheduled.fixedRateString();
			if (StringUtils.hasText(fixedRateString)) {
				Assert.isTrue(!processedSchedule, errorMessage);
				processedSchedule = true;
				if (this.embeddedValueResolver != null) {
					fixedRateString = this.embeddedValueResolver.resolveStringValue(fixedRateString);
				}
				try {
					fixedRate = Long.parseLong(fixedRateString);
				}
				catch (NumberFormatException ex) {
					throw new IllegalArgumentException(
							"Invalid fixedRateString value \"" + fixedRateString + "\" - cannot parse into integer");
				}
				tasks.add(this.registrar.scheduleFixedRateTask(new IntervalTask(runnable, fixedRate, initialDelay)));
			}

			// Check whether we had any attribute set
			Assert.isTrue(processedSchedule, errorMessage);

			// Finally register the scheduled tasks
			synchronized (this.scheduledTasks) {
				Set<ScheduledTask> registeredTasks = this.scheduledTasks.get(bean);
				if (registeredTasks == null) {
					registeredTasks = new LinkedHashSet<ScheduledTask>(4);
					this.scheduledTasks.put(bean, registeredTasks);
				}
				registeredTasks.addAll(tasks);
			}
		}
		catch (IllegalArgumentException ex) {
			throw new IllegalStateException(
					"Encountered invalid @Scheduled method '" + method.getName() + "': " + ex.getMessage());
		}
	}

	@Override
	public void afterSingletonsInstantiated() {
		// Remove resolved singleton classes from cache
		this.nonAnnotatedClasses.clear();

		if (this.applicationContext == null) {
			// Not running in an ApplicationContext -> register tasks early...
			finishRegistration();
		}
	}

	@Override
	public void onApplicationEvent(ContextRefreshedEvent event) {
		if (event.getApplicationContext() == this.applicationContext) {
			// Running in an ApplicationContext -> register tasks this late...
			// giving other ContextRefreshedEvent listeners a chance to perform
			// their work at the same time (e.g. Spring Batch's job registration).
			finishRegistration();
		}
	}

	private void finishRegistration() {
		if (this.scheduler != null) {
			this.registrar.setScheduler(this.scheduler);
		}

		if (this.beanFactory instanceof ListableBeanFactory) {
			Map<String, SchedulingConfigurer> configurers =
					((ListableBeanFactory) this.beanFactory).getBeansOfType(SchedulingConfigurer.class);
			for (SchedulingConfigurer configurer : configurers.values()) {
				configurer.configureTasks(this.registrar);
			}
		}

		if (this.registrar.hasTasks() && this.registrar.getScheduler() == null) {
			Assert.state(this.beanFactory != null, "BeanFactory must be set to find scheduler by type");
			try {
				// Search for TaskScheduler bean...
				this.registrar.setTaskScheduler(resolveSchedulerBean(TaskScheduler.class, false));
			}
			catch (NoUniqueBeanDefinitionException ex) {
				logger.debug("Could not find unique TaskScheduler bean", ex);
				try {
					this.registrar.setTaskScheduler(resolveSchedulerBean(TaskScheduler.class, true));
				}
				catch (NoSuchBeanDefinitionException ex2) {
					if (logger.isInfoEnabled()) {
						logger.info("More than one TaskScheduler bean exists within the context, and " +
								"none is named 'taskScheduler'. Mark one of them as primary or name it 'taskScheduler' " +
								"(possibly as an alias); or implement the SchedulingConfigurer interface and call " +
								"ScheduledTaskRegistrar#setScheduler explicitly within the configureTasks() callback: " +
								ex.getBeanNamesFound());
					}
				}
			}
			catch (NoSuchBeanDefinitionException ex) {
				logger.debug("Could not find default TaskScheduler bean", ex);
				// Search for ScheduledExecutorService bean next...
				try {
					this.registrar.setScheduler(resolveSchedulerBean(ScheduledExecutorService.class, false));
				}
				catch (NoUniqueBeanDefinitionException ex2) {
					logger.debug("Could not find unique ScheduledExecutorService bean", ex2);
					try {
						this.registrar.setScheduler(resolveSchedulerBean(ScheduledExecutorService.class, true));
					}
					catch (NoSuchBeanDefinitionException ex3) {
						if (logger.isInfoEnabled()) {
							logger.info("More than one ScheduledExecutorService bean exists within the context, and " +
									"none is named 'taskScheduler'. Mark one of them as primary or name it 'taskScheduler' " +
									"(possibly as an alias); or implement the SchedulingConfigurer interface and call " +
									"ScheduledTaskRegistrar#setScheduler explicitly within the configureTasks() callback: " +
									ex2.getBeanNamesFound());
						}
					}
				}
				catch (NoSuchBeanDefinitionException ex2) {
					logger.debug("Could not find default ScheduledExecutorService bean", ex2);
					// Giving up -> falling back to default scheduler within the registrar...
					logger.info("No TaskScheduler/ScheduledExecutorService bean found for scheduled processing");
				}
			}
		}

		this.registrar.afterPropertiesSet();
	}

	@Override
	public void destroy() {
		synchronized (this.scheduledTasks) {
			Collection<Set<ScheduledTask>> allTasks = this.scheduledTasks.values();
			for (Set<ScheduledTask> tasks : allTasks) {
				for (ScheduledTask task : tasks) {
					task.cancel();
				}
			}
			this.scheduledTasks.clear();
		}
		this.registrar.destroy();
	}

package org.springframework.scheduling.annotation;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(SchedulingConfiguration.class)
@Documented
public @interface EnableScheduling {

}

@Configuration
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public class SchedulingConfiguration {

	@Bean(name = TaskManagementConfigUtils.SCHEDULED_ANNOTATION_PROCESSOR_BEAN_NAME)
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	public ScheduledAnnotationBeanPostProcessor scheduledAnnotationProcessor() {
		return new ScheduledAnnotationBeanPostProcessor();
	}

}

Date: Fri, 08 Nov 2002 09:42:22 +0800

Date now = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
System.out.println(sdf.format(now));

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
System.out.println(sdf.parse("2018-10-17T10:49:53.757+0800"));

    @Test
    public void testJodaTime() {
        Date date = new Date();
        System.out.println(format(date, "yyyy-MM-dd HH:mm:ss.SSS"));
    }

    public static String format(Date date, String format) {
        return new DateTime(date).toString(format);
    }

public void testJodaTime() {
    Date date = parseDate("2018-10-17T02:48:01.000Z", "yyyy-MM-dd'T'HH:mm:ss.SSSZ");
}

public static Date parseDate(String date, String pattern) {
    DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(pattern);
    return DateTime.parse(date, dateTimeFormatter).toDate();
}

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.5</version>
</dependency>

private static final Gson GSON = new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create();

String jsonString = gson.toJson(obj);  

//1.parse object
Person person = gson.fromJson(jsonString, Person.class);  
//2.parse array
List<Person> list = gson.fromJson(jsonString, new TypeToken<List<Person>>(){}.getType());  

import com.google.gson.*;
import org.apache.commons.lang3.StringUtils;

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

/**
 * @author Ricky Fung
 */
public class JsonUtils {
    private static final Gson GSON = new GsonBuilder()
            .registerTypeAdapter(Date.class, new JsonDateSerializer())
            .create();

    public static String toJson(Object obj) {
        return GSON.toJson(obj);
    }

    public static <T> T parseObject(String json, Class<T> classOfT) {
        return GSON.fromJson(json, classOfT);
    }
    public static <T> T parseObject(String json, Type typeOfT) {
        return GSON.fromJson(json, typeOfT);
    }
}

/**
 * gson Date序列化/反序列化
 * @author Ricky Fung
 */
class JsonDateSerializer implements
        JsonSerializer<Date>,JsonDeserializer<Date> {

    @Override
    public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        if (json==null || json.isJsonNull()) {
            return null;
        }
        String dateStr = json.getAsString();
        if (StringUtils.isEmpty(dateStr)) {
            return null;
        }
        return DateUtils.parseDate(dateStr);
    }

    @Override
    public JsonElement serialize(Date src, Type typeOfSrc, JsonSerializationContext context) {
        if (src==null) {
            return null;
        }
        return new JsonPrimitive(DateUtils.format(src));
    }
}

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>23.0</version>
</dependency>

LoadingCache<K, V> caches = CacheBuilder.newBuilder()
                .maximumSize(100)
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .build(new CacheLoader<K, V>() {
                    @Override
                    public V load(K key) throws Exception {
                        return generateValueByKey(key);
                    }
                });
try {
    caches.get(key);
} catch (ExecutionException e) {
    e.printStackTrace();
}

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

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

	public static ClassLoader getDefaultClassLoader() {
		ClassLoader cl = null;
		try {
			cl = Thread.currentThread().getContextClassLoader();
		}
		catch (Throwable ex) {
			// Cannot access thread context ClassLoader - falling back...
		}
		if (cl == null) {
			// No thread context class loader -> use class loader of this class.
			cl = ClassUtils.class.getClassLoader();
			if (cl == null) {
				// getClassLoader() returning null indicates the bootstrap ClassLoader
				try {
					cl = ClassLoader.getSystemClassLoader();
				}
				catch (Throwable ex) {
					// Cannot access system ClassLoader - oh well, maybe the caller can live with null...
				}
			}
		}
		return cl;
	}