（六）Redis的java客户端

开放远程连接

CentOS7

# 开放端口
firewall-cmd --permanent --add-port=8080/tcp
# 查询端口是否开放
firewall-cmd --query-port=8080/tcp
# 重新载入
firewall-cmd --reload
# 移除指定的端口
firewall-cmd --permanent --remove-port=8080/tcp

1、redis非本机要开放远程连接端口和配置

Redis开放远程连接

1、开放6379端口

2、修改配置

- 修改 protected-mode yes 改为：protected-mode no
- 注释掉 #bind 127.0.0.1，或绑定客户端ip

Jedis连接

依赖

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.0.1</version>
</dependency>

单节点：

@Test
public void testJedis() {
    try (Jedis connect = new Jedis("192.168.0.109", 7001)) {
        String set = connect.set("name", "ha");
        Assert.assertEquals(connect.get("name"), "ha");
    }
}

连接池

@Test
public void testJedisPool() {
    JedisPoolConfig config = new JedisPoolConfig();

    config.setMaxTotal(8);
    config.setMaxIdle(8);
    config.setMinIdle(0);
    config.setMaxWaitMillis(8);

    config.setTestOnBorrow(true);
    config.setTestOnReturn(true);

    // 连接耗尽的时候，是否阻塞，false会抛出异常，true阻塞直到超时。默认为true。
    config.setBlockWhenExhausted(true);
    // JedisPool pool = new JedisPool(config, "192.168.0.109", 6379, 2000, password);
    JedisPool pool = new JedisPool(config, "192.168.0.109", 6379, 2000);
    try (Jedis client = pool.getResource()) {
        client.set("name", "aaa");
        Assert.assertEquals(client.get("name"), "ld");
    }
}

sentinel

@Test
public void testRedisSentinel() throws InterruptedException {
    String masterName = "mymaster";
    Set<String> sentinelSet = new HashSet<>();
    sentinelSet.add("192.168.0.109:26379");
    sentinelSet.add("192.168.0.109:26380");
    sentinelSet.add("192.168.0.109:26381");
    JedisSentinelPool pool = new JedisSentinelPool(masterName, sentinelSet);
    int count = 0;
    while (true) {
        try (Jedis resource = pool.getResource()) {
            HostAndPort currentHostMaster = pool.getCurrentHostMaster();
            String host = currentHostMaster.getHost();
            int port = currentHostMaster.getPort();
            resource.set("host" + count, host);
            resource.set("port" + count, String.valueOf(port));
            List<String> valueList = resource.mget("host" + count, "port" + count);
            log.info("host" + count + " {}, port" + count + " {};", valueList.get(0), valueList.get(1));
        } catch (Exception e) {
            e.printStackTrace();
        }
        Thread.sleep(1000);
        count++;
        if (count == 10000) {
            break;
        }
        log.info("count = {}", count);
    }
}

集群

@Slf4j
public class JedisClusterTest {

    private JedisCluster jedisCluster;

    @Before
    public void init() {
        Set<HostAndPort> nodeList = new HashSet<>();
        nodeList.add(new HostAndPort("192.168.0.109",6379));
        nodeList.add(new HostAndPort("192.168.0.110",6379));
        nodeList.add(new HostAndPort("192.168.0.111",6379));
        nodeList.add(new HostAndPort("192.168.0.109",6380));
        nodeList.add(new HostAndPort("192.168.0.110",6380));
        nodeList.add(new HostAndPort("192.168.0.111",6380));
        this.jedisCluster = new JedisCluster(nodeList, 2000);
    }

    @Test
    public void testJedisCluster() {
        for (int i = 0; i < 1000; i++) {
            String result = jedisCluster.set("key" + i, "value" + i);
            log.info("result: {}", result);
        }
        for (int i = 0; i < 1000; i++) {
            String value = jedisCluster.get("key" + i);
            log.info("key: {}, value: {}", "key" + i, value);
        }
        // 不能使用keys *
        // Set<String> keys = jedisCluster.keys("*");
        // keys.forEach(log::info);
    }
}

springboot-redis
依赖

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

单节点使用

  • 配置
spring:
  redis:
    host: 127.0.0.1
    port: 6379
  • 配置类
/**
 * 基本配置，如果没有额外配置，可不编写此类配置文件，直接使用默认自动配置
 */
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        return redisTemplate;
    }
}
  • 使用
@SpringBootTest(classes = RedisApplication.class)
@RunWith(SpringRunner.class)
public class RedisTemplateTest {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Test
    public void test() throws Exception {

        // 保存字符串
        stringRedisTemplate.opsForValue().set("aaa", "222");
        Assert.assertEquals("222", stringRedisTemplate.opsForValue().get("aaa"));

    }

}

缓存使用

  • service接口
package com.zuizui.boot.redis.service;

import com.zuizui.boot.redis.entity.SysUser;

/**
 * @author zuier
 */
public interface SysUserService {

    /**
     * 根据id获取用户
     *
     * @param id Long
     * @return SysUser
     */
    SysUser getById(Long id);

    /**
     * 存储user
     *
     * @param sysUser SysUser
     * @return SysUser
     */
    SysUser save(SysUser sysUser);

    /**
     * 更新user
     *
     * @param sysUser SysUser
     * @return SysUser
     */
    SysUser update(SysUser sysUser);

    /**
     * 根据id删除
     *
     * @param id Long
     */
    void del(Long id);
}
  • service实现
package com.zuizui.boot.redis.service.impl;

import com.zuizui.boot.redis.entity.SysUser;
import com.zuizui.boot.redis.service.SysUserService;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author zuier
 */
@Service
@CacheConfig(cacheNames = "sys-user")
public class SysUserServiceImpl implements SysUserService {

    private Map<Long, SysUser> sysUserMap = new ConcurrentHashMap<>();

    {
        Date date = new Date();
        for (int i = 0; i < 10; i++) {
            sysUserMap.put((long) i, new SysUser((long) i, "user" + i, "pass" + i, "name" + i, "email" + i, "phone" + i, date, date, 0));
        }
    }

    @Override
    @Cacheable
    public SysUser getById(Long id) {
        return sysUserMap.get(id);
    }

    @Override
    @CachePut(cacheNames = "sys-user", key = "#sysUser.id")
    public SysUser save(SysUser sysUser) {
        sysUserMap.put(sysUser.getId(), sysUser);
        return sysUser;
    }

    @Override
    @CachePut(key = "#sysUser.id")
    public SysUser update(SysUser sysUser) {
        SysUser sysUser1 = sysUserMap.get(sysUser.getId());
        if (sysUser1 == null) {
            return null;
        }
        sysUserMap.put(sysUser.getId(), sysUser);
        return sysUser;
    }

    @Override
    @CacheEvict
    public void del(Long id) {
        sysUserMap.remove(id);
    }
}
  • 缓存配置：可在注解中指定
package com.zuizui.boot.redis.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;

import java.time.Duration;
import java.util.HashMap;
import java.util.Map;

/**
 * @author zuier
 */
@Configuration
public class RedisCacheConfig {

    /**
     * 缓存key生成器
     * @return KeyGenerator
     */
    @Bean
    public KeyGenerator simpleKeyGenerator() {
        return (o, method, objects) -> {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append(o.getClass().getSimpleName());
            stringBuilder.append(".");
            stringBuilder.append(method.getName());
            stringBuilder.append("[");
            for (Object obj : objects) {
                stringBuilder.append(obj.toString());
            }
            stringBuilder.append("]");
            return stringBuilder.toString();
        };
    }

    /**
     * 缓存管理器
     * @param redisConnectionFactory RedisConnectionFactory
     * @return CacheManager
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        return new RedisCacheManager(
                RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
                // 默认策略，未配置的 key 会使用这个
                this.getRedisCacheConfigurationWithTtl(600),
                // 指定 key 策略
                this.getRedisCacheConfigurationMap()
        );
    }

    private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>(2);
        redisCacheConfigurationMap.put("cacheName1", this.getRedisCacheConfigurationWithTtl(3000));
        redisCacheConfigurationMap.put("cacheName2", this.getRedisCacheConfigurationWithTtl(18000));
        return redisCacheConfigurationMap;
    }

    private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
        redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
                RedisSerializationContext
                        .SerializationPair
                        .fromSerializer(jackson2JsonRedisSerializer)
        ).entryTtl(Duration.ofSeconds(seconds));

        return redisCacheConfiguration;
    }

}

cluster 集群

  • 配置：application.yml
spring:
  redis:
    cluster:
      max-redirects: 5
      nodes:
        - 192.168.0.109:6379
        - 192.168.0.109:6380
        - 192.168.0.110:6379
        - 192.168.0.110:6380
        - 192.168.0.111:6379
        - 192.168.0.111:6380
    timeout: 1000ms
    jedis:
      pool:
        max-wait: 1ms
        max-idle: 8
        min-idle: 0
        max-active: 50
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest(classes = RedisClusterApplication.class)
public class RedisClusterTest {

    @Resource
    private RedisTemplate redisTemplate;

    @Test
    public void env() {
        Assert.assertNotNull(redisTemplate);
    }

    @Test
    @SuppressWarnings("unchecked")
    public void string() {
        for (int i = 0; i < 10; i++) {
            redisTemplate.opsForValue().set("spring" + i, "boot" + i);
            Object spring = redisTemplate.opsForValue().get("spring" + i);
            Assert.assertEquals("boot" + i, String.valueOf(spring));
        }
    }
}

原文地址：https://www.cnblogs.com/zuier/p/10648342.html

时间： 2024-10-20 07:55:14

（六）Redis的java客户端的相关文章

Tedis：淘宝的Redis的Java客户端开发包

http://www.open-open.com/lib/view/open1389880631976.html Tedis Tedis是另一个redis的java客户端 Tedis的目标是打造一个可在生产环境直接使用的高可用Redis解决方案.参见https://github.com/alibaba/tb_tddl Feature 高可用,Tedis使用多写随机读做HA确保redis的高可用 高性能,使用特殊的线程模型,使redis的性能不限制在客户端 多种使用方式,如果你只有一个redis实

Redis介绍 &amp;&amp; Java客户端操作Redis

Redis介绍 && Java客户端操作Redis 本文内容 redis介绍 redis的 shell 客户端简介 redis的 java 客户端简介 环境配置 redis 2.8.17 64bit JDK1.6 redis介绍 大多数时候,我们都将 redis 称作是内存数据库,它在运行过程中,将键值对信息存储在内存中,同时在后台以异步的形式写入本地数据库中(默认是:dump.rdb,在 redis.conf 中配置,如果需要考虑安全的持久化需求需要开启 AOF 功能,详细介绍可以查看这

redis的java客户端Jedis简单封装

经过我们团队的一番讨论,最终决定使用redis来进行我们的业务缓存.redis会将数据缓存到内存中,运行效率会很快.同时异步将数据写入到磁盘中,进行持久化. 且redis支持主从同步,支持分布式部署,支持N多数据结构,这对于我们有着莫大的吸引力. 参见:http://blog.csdn.net/yichenlian/article/details/27207383 我们团队讨论的焦点是在于redis的灾备恢复问题.由于redis的持久化是异步的,总会有一点时间内存中数据和磁盘数据不同步的情况(当

try redis(四) -java 客户端jedis 使用

不同的计算机语言针对redis,都有自己的客户端. 官网上也列出了客户端的 http://www.redis.io/clients java客户端如下: 感觉客户端无非也就是做些连接和拼接命令的事情.所以不费心思比较哪个好了,就选第一个吧.一般第一个应该都是不错的. 选择jedis ,发现他的代码是 GitHub 托管的,开源的.地址为 https://github.com/xetorthio/jedis 找到 maven dependency <dependency> <groupId

Redis的Java客户端Jedis的八种调用方式(事务、管道、分布式)介绍

jedis是一个著名的key-value存储系统,而作为其官方推荐的java版客户端jedis也非常强大和稳定,支持事务.管道及有jedis自身实现的分布式. 在这里对jedis关于事务.管道和分布式的调用方式做一个简单的介绍和对比: 一.普通同步方式 最简单和基础的调用方式: 1 @Test 2 public void test1Normal() { 3 Jedis jedis = new Jedis("localhost"); 4 long start = System.curre

[转载] 使用Redis的Java客户端Jedis

转载自http://aofengblog.blog.163.com/blog/static/631702120147298317919/ 在实际的项目开发中,各种语言是使用Redis的客户端库来与Redis交互.针对Java语言,Redis官方推荐Jedis. Jedis提供了多种操作方式:单机单连接方式.单机连接池方式.多机分布式+连接池方式. 预备 jedis-2.5.2commons-pool2-2.2.jar 使用单连接 此方式仅建议用于开发环境做调试用. // 创建连接String h

使用Redis的Java客户端Jedis

转载自:http://aofengblog.blog.163.com/blog/static/631702120147298317919/ 前一篇文章<Redis命令指南>讲解了通过命令行的方式执行Key=>的存储操作,在实际的项目开发中,各种语言是使用Redis的客户端库来与Redis交互.针对Java语言,Redis官方推荐Jedis. Jedis提供了多种操作方式:单机单连接方式.单机连接池方式.多机分布式+连接池方式. 预备 jedis-2.5.2commons-pool2-2.

redis在java客户端的操作

redis高性能,速度快,效率高的特点,用来做缓存服务器是很不错的选择.(和memcache相似)redis在客户端的操作步骤: 1.redis单机版操作 1.1通过Jedis对象操作 (1)将安装redis服务的服务器的ip地址和redis的端口号作为构造参数传递给Jedis,用来创建一个Jedis对象 Jedis jedis  = new Jedis(ip,port); (2)通过第一步创建的jedis对象,操作redis的5大数据类型(hash类型,string类型,list类型,set类

使用Java客户端对Redis进行操作

一.背景 上篇文章我们介绍了如何在centos7下面进行安装单机版redis以及redis集群.这篇文章,我们来聊一聊如何使用java客户端来进行操作redis.我们知道redis的java客户端有很多,如:jedis.redission等.这篇文章着重介绍我们平常使用最多的redis的java客户端jedis. 二.通过单元测试来小试牛刀 1.首先在maven的pom.xml中引入jedis-client的依赖 <dependency> <groupId>redis.client