Redis基础操作

Hash数据类型

@Service
public class RedisHashService {


    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private static final String HASH_KEY = "hashKey";

    @Data
    static
    class InnerTestClass {

        private String realName;

        private Integer sex;
    }

    public void sout() {

        redisTemplate.opsForHash().put(HASH_KEY, "id", 0);
        redisTemplate.opsForHash().put(HASH_KEY, "name", "sy");

        InnerTestClass innerTestClass = new InnerTestClass();

        innerTestClass.setRealName("cs");
        innerTestClass.setSex(1);

        redisTemplate.opsForHash().put(HASH_KEY, "inner", innerTestClass);

        System.out.println(redisTemplate.opsForHash().get(HASH_KEY, "id"));

        System.out.println(redisTemplate.opsForHash().get(HASH_KEY, "name"));

        System.out.println(redisTemplate.opsForHash().get(HASH_KEY, "inner"));

        System.out.println(redisTemplate.opsForHash().keys(HASH_KEY));

        List<Object> values = redisTemplate.opsForHash().values(HASH_KEY);

        values.forEach(item -> {

            if (item instanceof InnerTestClass) {
                System.out.println(JSON.toJSONString(item));
            } else {

                System.out.println("--" + item);

            }
        });

        System.out.println(redisTemplate.opsForHash().size(HASH_KEY));

        redisTemplate.opsForHash().delete(HASH_KEY, "id");

        System.out.println(redisTemplate.opsForHash().hasKey(HASH_KEY, "id"));
    }

}

List数据类型

@Service
public class RedisListService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private static final String KEY = "listKey";

    public void test() {

        redisTemplate.delete(KEY);
        redisTemplate.delete("newKey");

        // 左侧插入数据
        redisTemplate.opsForList().leftPush(KEY, 1);

        // 左侧插入数据
        redisTemplate.opsForList().leftPush(KEY, 0);

        // 左侧插入数据
        redisTemplate.opsForList().leftPush(KEY, -1);

        // 右侧插入数据
        redisTemplate.opsForList().rightPush(KEY, 2);

        // 右侧插入数据
        redisTemplate.opsForList().rightPush(KEY, 3);

        //取出列表中的所有元素
        List<Object> list = redisTemplate.opsForList().range(KEY, 0, -1);

        System.out.println("此时列表数据为：" + list);

        System.out.println("从左侧取出并移除一个数据: " + redisTemplate.opsForList().leftPop(KEY));

        System.out.println("从右侧取出并移除一个数据: " + redisTemplate.opsForList().rightPop(KEY));

        System.out.println("输出索引下标为1 的数据: " + redisTemplate.opsForList().index(KEY, 1));

        System.out.println("从列表的右侧取出一条数据，并将此数据 newKey 左侧push: " + redisTemplate.opsForList().rightPopAndLeftPush(KEY, "newKey"));

        System.out.println("输出原list长度: " + redisTemplate.opsForList().size(KEY));

        System.out.println("输出newKey列表数据: " + redisTemplate.opsForList().range("newKey", 0, -1));
    }
}

一个简单的redis分布式锁实现

@Service
public class RedisLockService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;


    public void saveAndGet(String value) {

        redisTemplate.opsForValue().set("csValue", value);

        value = (String) redisTemplate.opsForValue().get("csValue");

        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        System.out.println(value);

    }

    public void setIfAbsent() {

        ExecutorService executorService = createExecutorService();

        executorService.execute(this::lockTest);

        executorService.execute(this::lockTest);
    }

    public void lockTest() {

        String lockKey = "lockKey";

        while (!Boolean.TRUE.equals(redisTemplate.opsForValue().setIfAbsent(lockKey, "0"))) {

            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            System.out.println("其他线程持有锁，请等待 当前线程:" + Thread.currentThread().getName());

        }

        saveAndGet(String.format("%s线程修改", Thread.currentThread().getName()));

        redisTemplate.delete(lockKey);
    }


    private ExecutorService createExecutorService() {

        ThreadFactory factory = new ThreadFactoryBuilder().setNameFormat("custom-thread-%d").build();

        return new ThreadPoolExecutor(4,
                10,
                1,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(10),
                factory);
    }

}