java单机操作redis3.2.10和集群操作增删改查

先直接附上单机版的连接和增删改查，7000-7005是端口号

package com.yilian.util;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import redis.clients.jedis.Jedis;
public class RedisTest {
    Jedis js = null;
    private String host = "101.236.39.141";
    private int port = 6379;

    /**
    * 链接redis数据库，进行初始化
    *
    * @param hostUrl：链接服务器的ip/名称
    * @param hostPort：主机的端口号
    * @return：返回是否初始化链接成功
    */
    public boolean init(String host, int port) {
    if (js == null) {
    js = new Jedis(host, port);
    }
    if (js != null) {
    System.out.println("初始化成功");
    return true;
    } else {
    return false;
    }
    }

    /**
    * 链接redis数据库，进行初始化
    *
    * @param host：链接服务器的ip/名称
    * @return：返回是否初始化链接成功
    */
    public boolean init(String host) {
    if (js == null) {
    js = new Jedis(host);
    }
    if (js != null) {
    System.out.println("初始化成功");
    return true;
    } else {
    return false;
    }
    }

    /**
    * 新增数据
    *
    * @param key：新增数据的键
    * @param value：新增数据的值
    * @return:返回boolean值，表示是否新增数据成功
    */
    public boolean set(String key, String value) {

    if (js.exists(key)) {
    System.out.println(key + "已存在");
    System.out.println("若要修改数据请使用update()方法");
    return false;
    } else {
    js.set(key, value);
    if (js.exists(key)) {
    if (value.equals(js.get(key))) {
    System.out.println("增加数据成功");
    return true;
    } else {
    System.out.println("增加数据失败");
    return false;
    }
    } else {
    System.out.println("增加数据失败");
    return false;
    }
    }
    }

    /**
    * 添加多条数据
    *
    * @param map:放置多条数据的键值对集合
    * @return:返回boolean值，表示是否新增数据全部成功
    */
    public boolean sets(Map<String, String> map) {
    boolean sets = true;
    for (Entry<String, String> e : map.entrySet()) {
    String key = e.getKey();
    String value = e.getValue();
    boolean set = set(key, value);
    if (!set) {
    sets = false;
    }
    }
    return sets;
    }

    /**
    * 删除数据
    *
    * @param key：要删除数据的key
    * @return：返回boolean值，表示是否删除成功
    */
    public boolean delete(String key) {

    if (js.exists(key)) {
    if (js.del(key) == 1) {
    System.out.println("删除数据成功");
    return true;
    } else {
    System.out.println("删除数据失败");
    return false;
    }
    } else {
    System.out.println(key + "不存在");
    return false;
    }
    }

    /**
    * 删除一组数据
    *
    * @param keys：要删除数据键集合
    * @return：返回boolean值，表示是否全部删除成功
    */
    public boolean deletes(String[] keys) {
    boolean deletes = true;
    for (String key : keys) {
    boolean delete = delete(key);
    if (!delete) {
    deletes = false;
    }
    }
    return deletes;
    }

    /**
    * 修改数据
    *
    * @param key：要修改数据的key
    * @param value：要修改数据的值
    * @return：返回boolean值，表示是否修改成功
    */
    public boolean update(String key, String value) {
    if (js.exists(key)) {
    js.set(key, value);
    if (value.equals(js.get(key))) {
    System.out.println("修改数据成功");
    return true;
    } else {
    System.out.println("修改数据失败");
    return false;
    }
    } else {
    System.out.println(key + "不存在");
    System.out.println("若要新增数据请使用set()方法");
    return false;
    }
    }

    /**
    * 获取表中数据
    *
    * @param key:要查询的key
    * @return:返回查找到的数据；如果键不存在则返回null；
    */
    public String get(String key) {
    if (js.exists(key)) {
    System.out.println(js.get(key));
    return js.get(key);
    } else {
    System.out.println(key + "不存在");
    return null;
    }
    }
    /**
    * 获取多条key的值
    * @param keys：多条key的集合
    * @return
    */
    public Map<String, String> gets(String[] keys) {
    Map<String, String> map = new HashMap<String, String>();
    for (String key : keys) {
    if (js.exists(key)) {
    String value = js.get(key);
    map.put(key, value);
    System.out.println(key + "-" + value);
    } else {
    System.out.println(key + "不存在");
    }
    }
    return map;
    }

    /**
    * 获得所有数据的键
    */
    public void getKeys() {
    Set<String> set = js.keys("*");
    if (set.size() != 0) {
    Iterator<String> it = set.iterator();
    while (it.hasNext()) {
    String key = it.next();
    System.out.println(key);
    }
    } else {
    System.out.println("数据库暂时没有数据");
    }
    }

    /**
    * 查询所有数据
    */
    public void getAll() {
    Set<String> set = js.keys("*");
    if (set.size() != 0) {
    Iterator<String> it = set.iterator();
    while (it.hasNext()) {
    String key = it.next();
    String value = js.get(key);
    System.out.println(key + "-" + value);
    }
    } else {
    System.out.println("数据库暂时没有数据");
    }
    }

    /**
    * 关闭链接
    */
    public void unInit() {
    if (js != null) {
    js.close();
    js = null;
    }
    }

    public static void main(String[] args) {
        RedisTest re=new RedisTest();
        re.init("101.236.39.141", 7000);
        re.set("11", "2");
        re.get("11");
    }
}

集群操作，它会自己按照节点去分发

package com.yilian.util;
import java.util.HashSet;
import java.util.Set;  

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;  

import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
public class ClusterDemo {
	 private static JedisCluster jedisCluster=null;
	    private static Set<HostAndPort> hostAndPorts=null;  

	    public static  Set<HostAndPort> getHostAndPort(String hostAndPort){
	        Set<HostAndPort> hap = new HashSet<HostAndPort>();
	        String[] hosts = hostAndPort.split(",");
	        String[] hs = null;
	        for(String host:hosts){
	            hs=host.split(":");
	            hap.add(new HostAndPort(hs[0], Integer.parseInt(hs[1])));
	        }
	        return hap;
	    }  

	    public boolean set(String key, String value) {
	    	if (jedisCluster.exists(key)) {
	    	System.out.println(key + "已存在");
	    	System.out.println("若要修改数据请使用update()方法");
	    	return false;
	    	} else {
	    		jedisCluster.set(key, value);
	    	if (jedisCluster.exists(key)) {
	    	if (value.equals(jedisCluster.get(key))) {
	    	System.out.println("增加数据成功");
	    	return true;
	    	} else {
	    	System.out.println("增加数据失败");
	    	return false;
	    	}
	    	} else {
	    	System.out.println("增加数据失败");
	    	return false;
	    	}
	    	}
	    	}

	    public static JedisCluster getJedisCluster(){
	        GenericObjectPoolConfig gopc = new GenericObjectPoolConfig();
	        gopc.setMaxTotal(32);
	        gopc.setMaxIdle(4);
	        gopc.setMaxWaitMillis(6000);
	        hostAndPorts = getHostAndPort("101.236.39.141:7000");
	        hostAndPorts = getHostAndPort("101.236.39.141:7003");
	        hostAndPorts = getHostAndPort("101.236.46.113:7001");
	        hostAndPorts = getHostAndPort("101.236.46.113:7004");
	        hostAndPorts = getHostAndPort("101.236.46.114:7002");
	        hostAndPorts = getHostAndPort("101.236.46.114:7005");
	        jedisCluster = new JedisCluster(hostAndPorts,gopc);
	        return jedisCluster;
	    }  

	    public static void main(String[] args) {
	        jedisCluster = getJedisCluster();
	        System.out.println(jedisCluster.get("11"));
	        System.out.println(jedisCluster.get("12"));
	        ClusterDemo d=new ClusterDemo();
	        d.set("14", "4");
	      //  jedisCluster.set("11", "2");
	    }  

}