Redis在支付中的应用

首先需要引入jar包

org.springframework.boot
spring-boot-starter-data-redis

以下为业务常用方法：
package cn.lemonit.zhrs_wp.server.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.core.BoundZSetOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;

import java.io.Serializable;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**

• Created by Administrator on 2019/4/26.
  */
  @Component
  public class RedisUtil {

  @Autowired
  private RedisTemplate redisTemplate;

  @Bean
  public RedisTemplate redisTemplateInit() {
  //设置序列化Key的实例化对象
  redisTemplate.setKeySerializer(new StringRedisSerializer());
  //设置序列化Value的实例化对象
  redisTemplate.setValueSerializer(new StringRedisSerializer());
  return redisTemplate;
  }
  /**

  • 批量删除对应的value
  • @param keys
    /
    public void remove(final String… keys) {
    for (String key : keys) {
    remove(key);
    }
    }
    /*
  • 批量删除key
  • @param pattern
    /
    public void removePattern(final String pattern) {
    Set keys = redisTemplate.keys(pattern);
    if (keys.size() > 0)
    redisTemplate.delete(keys);
    }
    /*
  • 删除对应的value
  • @param key
    /
    public void remove(final String key) {
    if (exists(key)) {
    redisTemplate.delete(key);
    }
    }
    /*
  • 判断缓存中是否有对应的value
  • @param key
  • @return
    /
    public boolean exists(final String key) {
    return redisTemplate.hasKey(key);
    }
    /*
  • 读取缓存
  • @param key
  • @return
    /
    public String get(final String key) {
    Object result = null;
    redisTemplate.setValueSerializer(new StringRedisSerializer());
    ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
    result = operations.get(key);
    if(result==null){
    return null;
    }
    return result.toString();
    }
    /*
  • 写入缓存
  • @param key
  • @param value
  • @return
    /
    public boolean set(final String key, Object value) {
    boolean result = false;
    try {
    ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
    operations.set(key, value);
    result = true;
    } catch (Exception e) {
    e.printStackTrace();
    }
    return result;
    }
    /*
  • 写入缓存
  • @param key
  • @param value
  • @return
    */
    public boolean set(final String key, Object value, Long expireTime) {
    boolean result = false;
    try {
    ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
    operations.set(key, value);
    redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
    result = true;
    } catch (Exception e) {
    e.printStackTrace();
    }
    return result;
    }

  public boolean hmset(String key, Map<String, String> value) {
  boolean result = false;
  try {
  redisTemplate.opsForHash().putAll(key, value);
  result = true;
  } catch (Exception e) {
  e.printStackTrace();
  }
  return result;
  }

  public Map<String,String> hmget(String key) {
  Map<String,String> result =null;
  try {
  result= redisTemplate.opsForHash().entries(key);
  } catch (Exception e) {
  e.printStackTrace();
  }
  return result;
  }

  /**

  • 递增
  • @param key 键
  • @paramby 要增加几(大于0)
  • @return
    /
    public long incr(String key, long delta) {
    if (delta < 0) {
    throw new RuntimeException(“递增因子必须大于0”);
    }
    return redisTemplate.opsForValue().increment(key, delta);
    }
    /*
  • 递减
  • @param key 键
  • @paramby 要减少几(小于0)
  • @return
    /
    public long decr(String key, long delta) {
    if (delta < 0) {
    throw new RuntimeException(“递减因子必须大于0”);
    }
    return redisTemplate.opsForValue().increment(key, -delta);
    }
    /*
  • redis zset可已设置排序（案例，热搜）
  • @param key 键
  • @paramby
  • @return
    */
    public void zadd(String key ,String name) {
    BoundZSetOperations<Object, Object> boundZSetOperations = redisTemplate.boundZSetOps(key);
    //自增长后的数据
    boundZSetOperations.incrementScore(name,1);
    }
    }

package cn.lemonit.zhrs_wp.server.utils;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

/**

• Created by Administrator on 2019/12/10.
  */
  @Component
  public class RedisLock {

  Logger logger = LoggerFactory.getLogger(this.getClass());

  @Autowired
  private StringRedisTemplate redisTemplate;
  /**

  • 加锁

  • @param key 商品id

  • @param value 当前时间+超时时间 本业务用于微信支付后处理本身业务导致第一次回调没处理完第二次回调又进来的情况，本参数传入end_time

  • @return
    */
    public boolean lock(String key, String value) {
    if (redisTemplate.opsForValue().setIfAbsent(key, value)) { //这个其实就是setnx命令，只不过在java这边稍有变化，返回的是boolea
    return true;
    }

    //避免死锁，且只让一个线程拿到锁
    String currentValue = redisTemplate.opsForValue().get(key);
    //如果锁过期了
    if (!StringUtils.isEmpty(currentValue) && Long.parseLong(currentValue) < System.currentTimeMillis()) {
    //获取上一个锁的时间
    String oldValues = redisTemplate.opsForValue().getAndSet(key, value);

     /*
        只会让一个线程拿到锁
        如果旧的value和currentValue相等，只会有一个线程达成条件，因为第二个线程拿到的oldValue已经和currentValue不一样了
      */
     if (!StringUtils.isEmpty(oldValues) && oldValues.equals(currentValue)) {
         return true;
     }
    

    }
    return false;
    }

  /**

  • 解锁
  • @param key
  • @param value
    */
    public void unlock(String key, String value) {
    try {
    String currentValue = redisTemplate.opsForValue().get(key);
    if (!StringUtils.isEmpty(currentValue) && currentValue.equals(value)) {
    redisTemplate.opsForValue().getOperations().delete(key);
    }
    } catch (Exception e) {
    logger.error("『redis分布式锁』解锁异常，{}", e);
    }
    }
    }