AI专业者开发社区 1 号成员
  •  0 回帖  •  0 浏览  •  4 个月前
 

Java对Redis基本使用

1 引入 jar 包

　　java 是通过 Jedis 对 redis 进行操作的，首先引入 jedis.jar

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


2 建立 redis 连接池

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
import java.util.ArrayList;
import java.util.List;
 
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;
 
public class RedisPool {
     
    // 非切片客户端链接对象
    private Jedis jedis;
    // 非切片链接池对象
    private JedisPool jedisPool;
    // 切片客户端链接对象
    private ShardedJedis shardedJedis;
    // 切片链接池
    private ShardedJedisPool shardedJedisPool;
     
    private String ip = "127.0.0.1";
    private int port = 6379;
 
    public RedisPool(){
        initializePool();
        initializeShardedPool();
        setJedis(jedisPool.getResource());
        setShardedJedis(shardedJedisPool.getResource());
    }
     
    public RedisPool(String ip){
        this.ip = ip;
        initializePool();
        initializeShardedPool();
        setJedis(jedisPool.getResource());
        setShardedJedis(shardedJedisPool.getResource());
    }
     
    public RedisPool(String ip, int port){
        this.ip = ip;
        this.port = port;
        initializePool();
        initializeShardedPool();
        setJedis(jedisPool.getResource());
        setShardedJedis(shardedJedisPool.getResource());
         
    }
     
    // 初始化非切片池
    public void initializePool(){
        //池的配置
        JedisPoolConfig jpc = new JedisPoolConfig();
        //最大空闲连接数
        jpc.setMaxIdle(20);
        jpc.setMaxIdle(5);
        //获取连接时的最大等待毫秒数 
        jpc.setMaxWaitMillis(1000);
        //在空闲时检查有效性, 默认false 
        jpc.setTestOnBorrow(false);
        jedisPool = new JedisPool(jpc, ip, port);
    }
     
    // 初始化切片池
    public void initializeShardedPool(){
        //池的配置
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxIdle(20);
        config.setMaxWaitMillis(1000);
        config.setTestOnBorrow(false);
        // slave链接
        //可以实现集群的功能，配置多个redis服务实现请求的分配进行负载均衡 
        List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>();
        shards.add(new JedisShardInfo(ip, port, "master"));
        // 构造池
        shardedJedisPool = new ShardedJedisPool(config, shards);
    }
     
    public void closeJedisPool(){
        jedisPool.close();
    }
    public void closeShardedJedisPool(){
        shardedJedisPool.close();
    }
 
    public Jedis getJedis() {
        return jedis;
    }
 
    public void setJedis(Jedis jedis) {
        this.jedis = jedis;
    }
 
    public ShardedJedis getShardedJedis() {
        return shardedJedis;
    }
 
    public void setShardedJedis(ShardedJedis shardedJedis) {
        this.shardedJedis = shardedJedis;
    }
}

　　

3 定义操作接口

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import java.util.Map;
import java.util.Set;
 
public interface IRedisService {
 
     
    public Boolean setString(String key, String value);
    public String getString(String key);
    public Boolean existsKey(String key);
    public Long delKey(String key);
    public String typeKey(String key);
    public Set<String> keys(String key);
     
    /**
     * 获得map数据集
     * @param key
     * @return
     */
    public Map<String, String> getMap(String key);
     
    /**
     * 设置map数据集
     * @param key
     * @param map
     * @return
     */
    public Boolean setMap(String key, Map<String, String> map);
     
    /**
     * 获得map字段中的值
     * @param key
     * @param fieldKey
     * @return
     */
    public String getMapFieldValue(String key, String fieldKey);
     
    /**
     * 获得map中多个字段值
     * @param key
     * @param fieldKeys
     * @return
     */
    public Map<String, String> getMapFieldValues(String key, String[] fieldKeys);
     
    /**
     * 设置map中具体的字段值
     * 参考存储格式：{key,map{fieldKey, fieldValue}}
     * @param key
     * @param fieldKey
     * @param fieldValue
     * @return
     */
    public Boolean setMapFieldValue(String key, String fieldKey, String fieldValue);
     
     
}

　　

4 接口实现类

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
 
import com.robert.redis.client.config.RedisPool;
 
import redis.clients.jedis.Jedis;
import redis.clients.jedis.ShardedJedis;
 
public class RedisService implements IRedisService{
 
    private RedisPool redisPool;
     
    public RedisService(){
        redisPool = new RedisPool();
    }
     
    public RedisService(String host){
        redisPool = new RedisPool(host);
    }
     
    public RedisService(String host, int port){
        redisPool = new RedisPool(host, port);
    }
     
    private Jedis getJResource(){
        Jedis jResource = null;
        jResource = redisPool.getJedis();
        return jResource;
    }
    private ShardedJedis getShardResource(){
        ShardedJedis sResource = null;
        sResource = redisPool.getShardedJedis();
        return sResource;
    }
     
    public Boolean setString(String key, String value) {
        boolean result = false;
        ShardedJedis resource = null;
        try{
            resource = getShardResource();
            if(resource != null){
                resource.set(key, value);
                result = true;
            }
             
        }catch(Exception e){
            result = false;
            e.printStackTrace();
        }finally{
            redisPool.closeShardedJedisPool();
        }
        return result;
    }
 
    public String getString(String key) {
        String result = null;
        ShardedJedis resource = null;
        try{
            resource = getShardResource();
            if(resource != null){
                result = resource.get(key);
            }
             
        }catch(Exception e){
            result = null;
            e.printStackTrace();
        }finally{
            redisPool.closeShardedJedisPool();
        }
        return result;
    }
 
    public Boolean existsKey(String key) {
        Boolean result = false;
        ShardedJedis resource = null;
        try{
            resource = getShardResource();
            if(resource != null){
                result = resource.exists(key);
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            redisPool.closeShardedJedisPool();
        }
         
        return result;
    }
 
    public Long delKey(String key) {
        Long result = null;
        ShardedJedis resource = null;
        try{
            resource = getShardResource();
            if(resource != null){
                result = resource.del(key);
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            redisPool.closeShardedJedisPool();
        }
        return result;
    }
 
    public String typeKey(String key) {
        String result = null;
        ShardedJedis resource = null;
        try{
            resource = getShardResource();
            if(resource != null){
                result = resource.type(key);
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            redisPool.closeShardedJedisPool();
        }
        return result;
    }
 
    public Set<String> keys(String key) {
        Set<String> result = null;
        Jedis resource = null;
        try{
            resource = getJResource();
            if(resource != null){
                result = resource.keys(key);
            }
             
        }catch(Exception e){
            result = null;
            e.printStackTrace();
        }finally{
            redisPool.closeJedisPool();
        }
        return result;
    }
 
    public Map<String, String> getMap(String key) {
        Map<String, String> map = null;
        ShardedJedis resource = null;
        try{
            resource = getShardResource();
            if(resource != null && resource.exists(key)){
                map = resource.hgetAll(key);
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            redisPool.closeShardedJedisPool();
        }
        return map;
    }
 
    public Boolean setMap(String key, Map<String, String> map) {
        Boolean result = false;
        ShardedJedis resource = null;
        try{
            resource = getShardResource();
            if(resource != null){
                resource.hmset(key, map);
                result = true;
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            redisPool.closeShardedJedisPool();
        }
        return result;
    }
 
    public String getMapFieldValue(String key, String fieldKey) {
        String result = null;
        ShardedJedis resource = null;
        try{
            resource = getShardResource();
            if(resource != null && resource.hexists(key, fieldKey)){
                result = resource.hget(key, fieldKey);
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            redisPool.closeShardedJedisPool();
        }
        return result;
    }
 
    public Map<String, String> getMapFieldValues(String key, String[] fieldKeys) {
        Map<String, String> map = new HashMap<String, String>();
        ShardedJedis resource = null;
        try{
            resource = getShardResource();
            if(resource != null){
                for(String fieldKey : fieldKeys){
                    map.put(fieldKey, resource.hget(key, fieldKey));
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            redisPool.closeShardedJedisPool();
        }
        return map;
    }
 
    public Boolean setMapFieldValue(String key, String fieldKey, String fieldValue) {
        Boolean result = false;
        ShardedJedis resource = null;
        try{
            resource = getShardResource();
            if(resource != null && resource.exists(key)){
                resource.hset(key, fieldKey, fieldValue);
                result = true;
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            redisPool.closeShardedJedisPool();
        }
        return result;
    }
 
}

　　

5 测试

　　

?
1
2
3
4
5
6
7
public static void main( String[] args )
   {
        
       IRedisService rs = new RedisService();
       rs.setString("test", "Hello Redis!");
       System.out.println(rs.getString("test"));
   }