spring集成redis，集成redis集群

最新推荐文章于 2024-09-25 09:21:39 发布
最新推荐文章于 2024-09-25 09:21:39 发布
阅读量68 收藏
点赞数
文章标签： 数据库 java
原文链接：http://www.cnblogs.com/shihaiming/p/6049794.html
版权

原文：http://chentian114.iteye.com/blog/2292323

 

1、通过spring-data-redis集成redis 

pom.xml依赖包 

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.chen</groupId>
    <artifactId>test_redis02</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <build />
    <properties>
        <spring.version>3.1.2.RELEASE</spring.version>
    </properties>

    <dependencies>
        <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>
        <!-- spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>


        <dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.8.1</version>
</dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.7.1.RELEASE</version>
        </dependency>
         <dependency>
     <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.4.2</version>
</dependency> 
    </dependencies>
</project>

 

spring application-reids.xml配置文件 

Java代码   收藏代码 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"   
       xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd  
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
        ">
    
    <!-- 加载配置文件 -->
    <context:property-placeholder location="classpath:redis.properties"/>
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}" />
        <!-- <property name="maxActive" value="${redis.maxActive}" />
        <property name="maxWait" value="${redis.maxWait}" />
        <property name="testOnBorrow" value="${redis.testOnBorrow}" /> -->
    </bean>
    
    <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"  
        p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}"  p:pool-config-ref="poolConfig"/> 
    
    <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">  
        <property name="connectionFactory"   ref="connectionFactory" />  
    </bean>       
    
</beans>

UserDaoImpl.java 

Java代码   收藏代码 
package com.chen.dao;

import java.io.Serializable;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Repository;

import com.chen.pojo.User;
@Repository
public class UserDaoImpl implements UserDao {
    
    @Autowired
    private RedisTemplate<Serializable,Serializable> redisTemplate;

    public void saveUser(final User user) {
        redisTemplate.execute(new RedisCallback<Object>(){
            @Override
            public Object doInRedis(RedisConnection connection)
                    throws DataAccessException {
                String str= "user.uid."+user.getId();
                byte[] key = redisTemplate.getStringSerializer().serialize(str);
                connection.set(key,redisTemplate.getStringSerializer().serialize(user.getName()));
                return null;
            }
        });
    }

    public User getUser(final long id) {
        return redisTemplate.execute(new RedisCallback<User>(){
            @Override
            public User doInRedis(RedisConnection connection) throws DataAccessException {
                byte[] key = redisTemplate.getStringSerializer().serialize("user.uid." + id);
                if(connection.exists(key)) {
                    byte[] value = connection.get(key);
                    String name = redisTemplate.getStringSerializer().deserialize(value);
                    User user = new User();
                    user.setName(name);
                    user.setId(id);
                    return user;
                }
                return null;
            }
        });
    }

}

2、通过jedis集成redis 

spring applicationContext.xml配置文件 

Java代码   收藏代码 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"   
       xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd  
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
        ">
    
    <!-- 加载配置文件 -->
    <context:property-placeholder location="classpath:redis.properties"/>
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}" />
        <!-- <property name="maxActive" value="${redis.maxActive}" />
        <property name="maxWait" value="${redis.maxWait}" />
        <property name="testOnBorrow" value="${redis.testOnBorrow}" /> -->
    </bean>
    <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool" scope="singleton">
        <constructor-arg index="0" ref="jedisPoolConfig" />
        <constructor-arg index="1">
            <list>
                <bean class="redis.clients.jedis.JedisShardInfo">
                    <constructor-arg name="host" value="${redis.host}" />
                    <constructor-arg name="port" value="${redis.port}" />
                    <!-- <constructor-arg name="timeout" value="${redis.timeout}" /> -->
                </bean>
            </list>
        </constructor-arg>
    </bean>
      
    
</beans>

RedisDataSourceImpl.java 

Java代码   收藏代码 
package com.chen.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
@Repository("redisDataSource")
public class RedisDataSourceImpl implements RedisDataSource {
    
    @Autowired
    private ShardedJedisPool shardedJedisPool;
    
    public ShardedJedis getRedisClient() {
        try{
            ShardedJedis shardJedis = shardedJedisPool.getResource();
            return shardJedis;
        }catch(Exception e){
            e.printStackTrace();
        }
        return null;
    }

    public void returnResource(ShardedJedis shardedJedis) {
        shardedJedisPool.returnResource(shardedJedis);
    }

    public void returnResource(ShardedJedis shardedJedis, boolean broken) {
        if(broken){
            shardedJedisPool.returnBrokenResource(shardedJedis);
        }else{
            shardedJedisPool.returnResource(shardedJedis);
        }
    }

}

 

RedisClientTemplate.java 

Java代码   收藏代码 
package com.chen.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import redis.clients.jedis.ShardedJedis;

@Repository("redisClientTemplate")
public class RedisClientTemplate {
    @Autowired
    private RedisDataSource redisDataSource;
    
    public void disconnect(){
        ShardedJedis shardedJedis = redisDataSource.getRedisClient();
        shardedJedis.disconnect();
    }
    
    public String set(String key,String val){
        String result = null ;
        ShardedJedis jedis = redisDataSource.getRedisClient();
        if(jedis ==null)return null;
        boolean broken = false;
        try{
            result = jedis.set(key, val);
        }catch(Exception e){
            e.printStackTrace();
            broken = true ;
        }finally{
            redisDataSource.returnResource(jedis,broken);
        }
        return result;
    }
    
    public String get(String key){
        String result = null;
        ShardedJedis jedis = redisDataSource.getRedisClient();
        if(jedis==null)return result;
        boolean broken = false;
        try{
            result = jedis.get(key);
        }catch(Exception e){
            e.printStackTrace();
            broken= true;
        }finally{
            redisDataSource.returnResource(jedis,broken);
        }
        return result;
    }
}

DemoTest.java 

Java代码   收藏代码
  
package com.chen.demo;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.chen.redis.RedisClientTemplate;

public class DemoTest {
    private static ApplicationContext apx;
    static{
        apx = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
    }
    
    @Test
    public void test1(){
        String key1 = "mykey1"; String val1 = "myvalue1";
        RedisClientTemplate template = (RedisClientTemplate) apx.getBean("redisClientTemplate");
        String result = template.set(key1, val1);
        System.out.println("result="+result);
    }
    
    @Test
    public void test2(){
        String key1 = "mykey1";
        RedisClientTemplate template = (RedisClientTemplate) apx.getBean("redisClientTemplate");
        String val1 = template.get(key1);
        System.out.println(val1);
    }
}

详情见test_spring_redis03.rar源码 

3、通过jedis集成JedisCluster 

spring applicationContext.xml配置文件 

Java代码   收藏代码 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"   
       xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd  
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
        ">
    
    <!-- 加载配置文件 -->
    <context:property-placeholder location="classpath:redis.properties"/>
    <bean name="genericObjectPoolConfig" class="org.apache.commons.pool2.impl.GenericObjectPoolConfig">
        <property name="maxWaitMillis" value="${redis.maxWaitMillis}" />
        <property name="maxTotal" value="${redis.maxTotal}" />
        <property name="minIdle" value="${redis.minIdle}" />
        <property name="maxIdle" value="${redis.maxIdle}" />
    </bean>
    
    <bean id="jedisCluster" class="com.chen.redis.JedisClusterFactory">
        <property name="addressConfig">
            <value>classpath:connect-redis.properties</value>
        </property>
        <property name="addressKeyPrefix" value="address"></property>
        <property name="timeout" value="${redis.timeout}" />
        <property name="maxRedirections" value="${redis.maxRedirections}" />
        <property name="genericObjectPoolConfig" ref="genericObjectPoolConfig"></property>
    </bean>
    
</beans>

集群服务器配置文件 
connect-redis.properties 

Java代码   收藏代码 
address1=192.168.199.130:7001
address2=192.168.199.130:7002
address3=192.168.199.130:7003
address4=192.168.199.130:7004
address5=192.168.199.130:7005
address6=192.168.199.130:7006

 

JedisClusterFactory.java 

Java代码   收藏代码 
package com.chen.redis;  
import java.util.HashSet;  
import java.util.Properties;  
import java.util.Set;  
import java.util.regex.Pattern;  
  
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;  
import org.springframework.beans.factory.FactoryBean;  
import org.springframework.beans.factory.InitializingBean;  
import org.springframework.core.io.Resource;  
  
import redis.clients.jedis.HostAndPort;  
import redis.clients.jedis.JedisCluster;  

public class JedisClusterFactory implements FactoryBean<JedisCluster>, InitializingBean {

    private Resource addressConfig;
    private String addressKeyPrefix ;
    private String password;

    private JedisCluster jedisCluster;
    private Integer timeout;
    private Integer maxRedirections;
    private GenericObjectPoolConfig genericObjectPoolConfig;
    
    private Pattern p = Pattern.compile("^.+[:]\\d{1,5}\\s*$");

    @Override
    public JedisCluster getObject() throws Exception {
        return jedisCluster;
    }

    @Override
    public Class<? extends JedisCluster> getObjectType() {
        return (this.jedisCluster != null ? this.jedisCluster.getClass() : JedisCluster.class);
    }

    @Override
    public boolean isSingleton() {
        return true;
    }



    private Set<HostAndPort> parseHostAndPort() throws Exception {
        try {
            Properties prop = new Properties();
            prop.load(this.addressConfig.getInputStream());

            Set<HostAndPort> haps = new HashSet<HostAndPort>();
            for (Object key : prop.keySet()) {

                if (!((String) key).startsWith(addressKeyPrefix)) {
                    continue;
                }

                String val = (String) prop.get(key);

                boolean isIpPort = p.matcher(val).matches();

                if (!isIpPort) {
                    throw new IllegalArgumentException("ip 或 port 不合法");
                }
                String[] ipAndPort = val.split(":");

                HostAndPort hap = new HostAndPort(ipAndPort[0], Integer.parseInt(ipAndPort[1]));
                haps.add(hap);
            }

            return haps;
        } catch (IllegalArgumentException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new Exception("解析 jedis 配置文件失败", ex);
        }
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        Set<HostAndPort> haps = this.parseHostAndPort();
        
        //jedisCluster = new JedisCluster(haps, timeout, maxRedirections,genericObjectPoolConfig);
        jedisCluster = new JedisCluster(haps, timeout, 2000, maxRedirections, password, genericObjectPoolConfig);
    }
    public void setAddressConfig(Resource addressConfig) {
        this.addressConfig = addressConfig;
    }

    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }

    public void setMaxRedirections(int maxRedirections) {
        this.maxRedirections = maxRedirections;
    }

    public void setAddressKeyPrefix(String addressKeyPrefix) {
        this.addressKeyPrefix = addressKeyPrefix;
    }

    public void setGenericObjectPoolConfig(GenericObjectPoolConfig genericObjectPoolConfig) {
        this.genericObjectPoolConfig = genericObjectPoolConfig;
    }

    public void setPassword(String password) {
        this.password = password;
    }

}

DemoTest.java 

Java代码   收藏代码 
package com.chen.demo;

import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import redis.clients.jedis.JedisCluster;

public class DemoTest {
    private static ApplicationContext apx;
    static{
        apx = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
    }
    
    
    @Test
    public void test1(){
        JedisCluster jedisCluster = (JedisCluster) apx.getBean("jedisCluster");
        String key1="myname1";
        String key2="myname2";
        String key3="myname3";
        System.out.println(jedisCluster.get(key1));
        System.out.println(jedisCluster.get(key2));
        System.out.println(jedisCluster.get(key3));
        
    }
    
    @Test
    public void test2(){
        JedisCluster jedisCluster = (JedisCluster) apx.getBean("jedisCluster");
        String key1="mystring1"; String val1 = "myval1";
        String key2="mystring2"; String val2 = "myval2";
        String key3="mystring3"; String val3 = "myval3";
        System.out.println(jedisCluster.set(key1,val1));
        System.out.println(jedisCluster.set(key2,val2));
        System.out.println(jedisCluster.set(key3,val3));
        System.out.println("----------------------");
        System.out.println(jedisCluster.get(key1));
        System.out.println(jedisCluster.get(key2));
        System.out.println(jedisCluster.get(key3));
    }
}

转载于:https://www.cnblogs.com/shihaiming/p/6049794.html

dgqvhtlwq472235338
关注
Spring集成Redis
KangJinXuan的博客
08-04 2055
Spring集成Redis。
spring集成redis集群需要的jar.zip
07-06
Spring + redis集群的集成 spring-data-redis-1.8.1.RELEASE.jar jedis-2.9.0.jar spring-data-commons-1.8.1.RELEASE.jar commons-pool2-2.4.2.jar
spring 使用redis集群配置
weixin_33859665的博客
12-20 167
上面两篇介绍了redis集群的配置合一些基本的概念，所以接下来当然是要在项目中使用咯，redis的java支持已经做的非常好了，所以我们来试着使用这些api来进行redis的操作，首先我们需要操作redis的架包： &lt;dependency&gt; &lt;groupId&gt;redis.clients&lt;/groupId&gt; &lt...
使用jedis连接调用redis，方式一：spring管理jedis
严老板的技术梦想博客
06-08 1045
一、redis.properties文件 # Redis settings redis.host=ip redis.port=6379 redis.pass=password #客户端超时时间单位是毫秒 默认是2000 redis.timeout=10000 redis.dbIndex=1 redis.dbIndex2=2 redis.CachingTime=900 #最大空闲数 redi...
redis 与 Spring 集成
u010481881的博客
03-28 91
ApplicationContent-reids.xml配置： package com....
使用Spring + Jedis集成Redis
Cowboy
02-08 2254
Redis技术学习,更多资源请访问 https://www.itkc8.com 一、集成环境 Tomcat7 JDK1.7 Jedis-2.7.2 Spring-4.1.6 二、资源依赖 （省略，网上很多） 三、集成过程 1、配置资源池      这里使用Jedis的ShardedJedisPool来管理，我们定义该配置文件为：spring-redis.xml，全部内容如下： ...
Spring Cloud 集成 Redis 发布订阅
程序员们必读的博客，涵盖IT技术、编程经验等领域。
04-09 1218
在当今的软件开发领域，分布式系统已经成为一种主流的架构模式，尤其是在处理大规模、高并发、高可用的业务场景时。然而，随着系统复杂性的增加，缓存机制的重要性也日益凸显。缓存不仅可以帮助我们减轻数据库压力，提高系统响应速度，还能在一定程度上保证系统的稳定性和可靠性。Redis，作为一款开源的、高性能的、支持多种数据结构的NoSQL数据库，已经成为缓存领域的佼佼者。它提供了丰富的数据结构支持，如字符串、哈希、列表、集合和有序集合等，使得开发者能够灵活地根据业务需求进行数据存储和读取。
Redis Spring配置集群
牛肉胡辣汤
07-06 1418
通过本篇博客文章，我们了解了如何使用Spring框架来配置Redis集群。通过配置依赖、指定集群节点、配置RedisTemplate以及使用RedisTemplate，我们可以方便地在Spring项目中使用Redis集群，提高系统的可用性和容错性。希望本文能够对你有所帮助，如果你有任何问题或疑问，请随时在评论区提问或留言。
SpringBoot 集成 Redis 集群
qq_33723676的博客
11-22 3704
springboot集成redis集群 可以看到: 集群状态是 ，如果为 则表示集群状态异常。 集群 Master 数量 集群 节点 数量这里集成了 Redisson 便于使用其中的分布式锁，特意加入了Redisson依赖。 配置文件： redis 配置类：RedisConfigProperties.java RedissonConfig.java RedisTemplateConfig.java RestTemplateConfig.java 在使用
redis,spring集成redis,redis集群
coder_daniu的博客
08-03 437
转自： redis：http://www.runoob.com/redis/redis-java.html spring-data-redis：https://blog.csdn.net/silyvin/article/details/78191810 redisCluster：https://www.cnblogs.com/hjwublog/p/5681700.html...
spring集成redis单节点、集群、哨兵配置
07-09
接下来是**Redis集群配置**。在集群模式下，Redis数据分散在多个节点上，每个节点只负责一部分数据，提高扩展性和可用性。Spring Data Redis提供了ClusterConnectionFactory来处理集群连接。配置需要指定所有节点的...
Spring集成redis集群
01-11
**Spring集成Redis集群详解** 在现代的Web应用程序开发中，数据缓存扮演着至关重要的角色，而Redis作为一款高性能的键值数据存储系统，被广泛应用于缓存、消息队列等多个场景。当业务规模扩大，单机Redis可能无法...
Spring集成Redis集群的配置文件
12-25
Spring集成Redis集群的配置文件
Postgresql特殊关键字
最新发布
czjnoe的博客
09-25 272
表字段名称如果出现这些特殊关键字，则需要通过单引号访问字段，如offset、group。PostgreSQL特殊关键字。
Online DDL (Data Definition Language)
09-23 265
是MySQL中的一个功能，允许在修改表结构（如添加、删除或修改列）的同时，允许对表进行并发读写操作。在传统的DDL操作中，对表结构的修改会导致整个表被锁定，从而阻止其他事务对该表进行读写操作，这可能导致长时间的锁定和性能问题。Online DDL的引入解决了这个问题，它允许在修改表结构的同时，保持对表的并发访问。MySQL从5.6版本开始引入了Online DDL的部分功能，而在8.0版本中对Online DDL进行了进一步的优化。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 897
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 739
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
Redis集群部署与Spring集成详解
本文档详细介绍了如何在Linux系统（如CentOS 7.0 64位）上部署Redis集群以及实现session共享。首先，我们来概述一下关键知识点： 1. **Redis集群基础**： Redis集群由多个Redis实例组成，通常至少包含三个节点，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值