Java连接操作redis_Java连接mysql

redis官方推荐使用jedis操作redis

导入依赖

    <dependency>



        <groupId>redis.clientsgroupId>
        <artifactId>jedisartifactId>
        <version>③③0version>
    dependency>

直接使用即可

import redis.clients.jedis.Jedis;

public class RedisTest {
public static void main(String[] args) {
    Jedis jedis = new Jedis("12⑦0.0.1", 6379);
    jedis.set("name", "zl");
    System.out.println(jedis.get("name"));
    jedis.lpush("list", "a");
    jedis.lpush("list", "b");
    jedis.lpush("list", "c");
    jedis.lpush("list", "d");
    System.out.println(jedis.lrange("list", 0, -1));
    System.out.println(jedis.keys("*"));
}
}

注意：当多线程使用同一个连接时,是线程不安全的.所以要使用连接池,为每个jedis实例分配一个连接.

相较于jedis,当多线程使用同一连接实例时,它是线程安全的.

依赖引入（创建springboot项目时勾选noSQL中的redis）

<dependency>
 <groupId>org.springframework.bootgroupId>
 <artifactId>spring-boot-starter-data-redisartifactId>
dependency>

一般情况下不直接使用Lettuce,会手动封装一个操作redis的工具类,这个网上有很多,一下提供做参考

package com.zl.utils;

import org.apache.tomcat.util.buf.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * Redis工具类,使用之前请确保RedisTemplate成功注入
 *
 * @author ye17186
 * @version 2019/2/22 10:48
 */
@Component
public class RedisUtils {

private RedisUtils() {
private RedisTemplate redisTemplate;

/**
 * @param key Redis键
 * @param timeout 超时时间
 * @return true=设置成功；false=设置失败
 */
public boolean expire(final String key, final long timeout) {

    return expire(key, timeout, TimeUnit.SECONDS);
/**
 * @param key Redis键
 * @param timeout 超时时间
 * @param unit 时间单位
 * @return true=设置成功；false=设置失败
 */
public boolean expire(final String key, final long timeout, final TimeUnit unit) {

    Boolean ret = redisTemplate.expire(key, timeout, unit);
    return ret != null  ret;
/**
 * @param key 键
 * @return true=删除成功；false=删除失败
 */
public boolean del(final String key) {

    Boolean ret = redisTemplate.delete(key);
    return ret != null  ret;
/**
 * @param keys 键集合
 * @return 成功删除的个数
 */
public long del(final Collection keys) {

    Long ret = redisTemplate.delete(keys);
    return ret == null ? 0 : ret;
/**
 * @param key Redis键
 * @param value 值
 */
public void set(final String key, final Object value) {

    redisTemplate.opsForValue().set(key, value, 1, TimeUnit.MINUTES);
// 存储普通对象操作

/**
 * @param key 键
 * @param value 值
 * @param timeout 有效期,单位秒
 */
public void set(final String key, final Object value, final long timeout) {

/**
 * @param key 键
 * @return 对象
 */
public Object get(final String key) {

    return redisTemplate.opsForValue().get(key);
// 存储Hash操作

/**
 * @param key Redis键
 * @param hKey Hash键
 * @param value 值
 */
public void hPut(final String key, final String hKey, final Object value) {

/**
 * @param key Redis键
 * @param values Hash键值对
 */
public void hPutAll(final String key, final Map values) {

/**
 * @param key Redis键
 * @param hKey Hash键
 * @return Hash中的对象
 */
public Object hGet(final String key, final String hKey) {

    return redisTemplate.opsForHash().get(key, hKey);
/**
 * @param key Redis键
 * @param hKeys Hash键集合
 * @return Hash对象集合
 */
public List