Spring之redisyi一主一从复制（非哨兵模式）

看了好几天redis了，公司从刚开始的redisluster变成了redis主从，原因是rediscluster不可控，其实是我水平没到，万一出点啥事，我这个负责人都解决不了，那就完了！大数据平台下，如果缓存崩了，所有操作提前全都干到数据库，很能造成数据库的崩溃，所以改用简单的主从复制模式，这样即可控，又直观，下面我将自己这几天整理的代码整理如下：

如果配置一主一从的redis服务：在使用pool的时候要注意，jedis提供两个pool：JedisPool和ShardedJedisPool ,本文使用JedisPool。

数据量较大时需要shard（多机环境），这个时候要用ShardedJedisPool。ShardedJedis是基于一致性哈希算法实现的分布式Redis集群客户端

注意：使用该代码前提是：成功安装redis并已经启动redis主从服务，否则拒绝连接，那是很。。。的

工程目录：



本人习惯：按目录顺序一次往下帖代码

1、创建加载连接池工具

package com.test.connection;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

public class ClientConnect {

//主库
private JedisPool masterJedisPool;
//从库
private JedisPool slaveJedisPool;

//设置主库
public void setMasterJedisPool(JedisPool masterJedisPool) {
this.masterJedisPool = masterJedisPool;
}
//设置从库
public void setSlaveJedisPool(JedisPool slaveJedisPool) {
this.slaveJedisPool = slaveJedisPool;
}

//获取主库
public Jedis getMasterJedisPool() {
Jedis jedis=null;
try{
jedis=masterJedisPool.getResource();

}catch(Exception e){
e.printStackTrace();
masterJedisPool.returnBrokenResource(jedis);
}
return jedis;
}

//获取从库
public Jedis getSlaveJedisPool() {
Jedis jedis=null;
try{
jedis=slaveJedisPool.getResource();

}catch(Exception e){
e.printStackTrace();
slaveJedisPool.returnBrokenResource(jedis);
}
return jedis;
}

/**
* 关闭池
* @param Jedis
* @param flag flag=1为从库，flag=0为主库
*/
@SuppressWarnings("deprecation")
public void closeJedisPool(Jedis jedis,int flag) {

if(flag==0){
masterJedisPool.close();
System.out.println("开始返回主Pool资源。。。");
if(masterJedisPool.isClosed()){
try{
masterJedisPool.returnResource(jedis);
System.out.println("返回主Pool资源成功");

}catch(Exception e){
e.printStackTrace();
}
}
}

if(flag==1){
slaveJedisPool.close();
System.out.println("开始返回从Pool资源。。。");
if(slaveJedisPool.isClosed()){
try{
slaveJedisPool.returnResource(jedis);
System.out.println("返回从Pool资源成功");

}catch(Exception e){
e.printStackTrace();
}
}
}
}
}

2、为了好看和隐私性强，创建加载路径

package com.test.constant;

public class SysConstants {

public static final String PATH = "classpath:/context/applicationContext.xml";
public static final String BEAN="clientConnect";
}

3、创建实体类

package com.test.entities;

public class User {

protected String companyId;
public String getCompanyId() {
return companyId;
}
public void setCompanyId(String companyId) {
this.companyId = companyId;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getTell() {
return tell;
}
public void setTell(String tell) {
this.tell = tell;
}
protected String id;
protected String name;
protected String age;
protected String address;
protected String tell;
}

4、创建操作主数据库的工具方法：
package com.test.Impl;

import java.util.List;

import com.test.entities.User;

import redis.clients.jedis.Jedis;
/**
*
* @author root
*操作主库，实现增、删、改功能
*/
public class MasterRedisImpl {

Jedis jedis;
public MasterRedisImpl(Jedis jedis){
this.jedis=jedis;
}

/**
* 添加
* @param list
*/
public void INSERT(List<User> list) {

for(int i=0;i<list.size();i++){
User user=list.get(i);

//主键
String key = "user:userId:"+user.getId();
//值1
String field1 = "name:";
String value1 = user.getName();
jedis.hset(key, field1, value1);

//值2
String field2 = "age:";
String value2 = user.getAge();
jedis.hset(key, field2, value2);

//值3
String field3 = "address:";
String value3 = user.getAddress();
jedis.hset(key, field3, value3);

//值4
String field4 = "tell:";
String value4 = user.getTell();
jedis.hset(key, field4, value4);

/**
* 添加键值list
* key1=user:userId:
* value1=1,2,3,4,5,6
*
* key2=user:name:
* value2=zhao,hai,dong
*
* key3=user:age
* value3=11,12 ,12,13
*/
//id->list
String listKey="user:userId:";
String listValue="user:userId:"+user.getId();

jedis.lpush(listKey, listValue);
//name->list
String listKey1="user:name:";
String listValue1="user:name:"+user.getName()+":"+user.getId();

jedis.rpush(listKey1, listValue1);

// 添加外键

jedis.sadd("user:userId:"+user.getId()+":companyId:", user.getCompanyId());
}

}

/**
* 删除hash表中指定key的n个指定字段
*
* @param key
* @param fields
*/
public void DELETE(String key,String []fields){
String field=null;
for(int i=0;i<fields.length;i++){
field=fields[i];
jedis.hdel(key, field); //删除xjj.h1中的f1和f2
}
}

/**
* 删除hash表中指定key的所有字段
*/
public void DELETEVALUE(String key){
jedis.del(key);
}

/**
* 移除集合中一个或多个成员
*/
public void DELETESET(String key,String []fields){

String field=null;
for(int i=0;i<fields.length;i++){
field=fields[i];
jedis.srem(key, field);
}

}

/**
* LPOP key：移出并获取列表的第一个元素
* @param key
*/
public String DELETELIST(String key){

return jedis.lpop(key);
}
}
5、创建操作从数据库的工具方法：
package com.test.Impl;

import java.util.List;
import java.util.Set;

import redis.clients.jedis.Jedis;

/**
*
* @author root
*读取从库读数据
*/
public class SlaveRedisImpl {

Jedis jedis;
public SlaveRedisImpl(Jedis slaveJedis) {
this.jedis=slaveJedis;
}

/**
* 查询
* 返回哈希表 key中给定域 field的值
*/
public String SELECT(String key,String field){

return jedis.hget(key, field);

}
public String SELECT(String key){

return jedis.get(key);

}

/**
* 查询list,获取指定位置的元素
* @param key
* @return
*/
public List<String> SELECTLIST(String key,int start,int end){

return jedis.lrange(key, start, end);

}

/**
* 在set中获取key对应所有的vlaue
* @param key
* @return
*/
public Set<String> SELECTSET(String key){
return jedis.smembers(key);
}

}
6、创建applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd">
<context:property-placeholder location="classpath:/property/redis.properties" />
<!-- 连接池配置 -->
<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxIdle" value="${redis.maxIdle}" />
<property name="maxTotal" value="${redis.maxTotal}" />
<property name="maxWaitMillis" value="${redis.maxWaitMillis}" />
<property name="testOnBorrow" value="${redis.testOnBorrow}" />
</bean>
<!-- 连接池 -->
<bean id="masterJedisPool" class="redis.clients.jedis.JedisPool">
<constructor-arg index="0" ref="poolConfig"/>
<constructor-arg index="1" value="127.0.0.1" type="java.lang.String"/>
<constructor-arg index="2" value="6379" type="int"/>
</bean>

<bean id="slaveJedisPool" class="redis.clients.jedis.JedisPool">
<constructor-arg index="0" ref="poolConfig"/>
<constructor-arg index="1" value="127.0.0.1" type="java.lang.String"/>
<constructor-arg index="2" value="6380" type="int"/>
</bean>

<bean id="clientConnect" class="com.test.connection.ClientConnect">
<property name="masterJedisPool" ref="masterJedisPool"/>
<property name="slaveJedisPool" ref="slaveJedisPool"/>
</bean>

</beans>

连接池配置文件redis.properties:
redis.maxIdle=300
redis.maxTotal=600
redis.maxWaitMillis=1000
redis.testOnBorrow=true

下来当然是测试了：

package com.test.main;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

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

import com.test.Impl.MasterRedisImpl;
import com.test.Impl.SlaveRedisImpl;
import com.test.connection.ClientConnect;
import com.test.constant.SysConstants;
import com.test.entities.User;

import redis.clients.jedis.Jedis;

public class Test {

/**
* 节点信息
* redis.clients.jedis.Jedis@6ceadf59
* redis.clients.jedis.Jedis@e3b7c27
* @param args
*/

public static void main(String[] args) {
@SuppressWarnings("resource")
ApplicationContext ctx = new ClassPathXmlApplicationContext(SysConstants.PATH);
ClientConnect redisUtils = (ClientConnect) ctx.getBean(SysConstants.BEAN);

List<User>list=new ArrayList<>();

for(int i=0;i<10;i++){
User user=new User();
user.setId(i+"");
user.setAddress("gansu"+i);
user.setAge(i+"");
user.setName("zhd"+i);
user.setCompanyId("1010111"+i);
user.setTell("15309853180");
list.add(user);
}

//获取主redis库
Jedis mastrJedis=redisUtils.getMasterJedisPool();
//操作主redis库
MasterRedisImpl mastedao=new MasterRedisImpl(mastrJedis);

//添加数据
mastedao.INSERT(list);

//获取从redis库
Jedis slaveJedis=redisUtils.getSlaveJedisPool();

//操作从redis库
SlaveRedisImpl slavedao=new SlaveRedisImpl(slaveJedis);
//查询
String keyHash="user:userId:5";
String filed="name:";
String keyList="user:name:";
int start=0;
int end=2;
String keySet="user:userId:4:companyId:";

String hashValue=slavedao.SELECT(keyHash,filed);
System.out.println("hashValue:"+hashValue);

List<String> listValue=slavedao.SELECTLIST(keyList, start,end);
System.out.println("listValue:"+listValue.toString());

Set<String> valueSet=slavedao.SELECTSET(keySet);

Iterator<String> it = valueSet.iterator();
while (it.hasNext()) {
String str = it.next();
System.out.println("valueSet:"+str);
}
}
}

以上代码，是我自己整理的，并且完全可以使用的代码，小菜鸟门完全可以复制粘帖；