这段时间在研究Redis，作为缓存界的新宠，现在使用它的公司越来越多。本文使用的是最新稳定版Redis3.0.实现的具体逻辑是：

    1. 用户登录首先判断是否在redis缓存中，如果在redis缓存中，直接登录成功；

    2. 若用户未在redis缓存，则访问Mysql，判断用户是否存在，如果不存在，则提示用户注册；如果存在，则登录成功；

    3. 在mysql存在并登录成功的同时，将改条数据用Redis Hash类型进行缓存，并设置过期时间为30分钟；

    4. 设置redis最大内存，若超出内存范围，则使用FIFO方式进行清除。

本文实现方式为最简单的模拟方式，有的代码有进一步封装得必要。

一、首先创建两个类，一个类连接Mysql，一个类连接Redis，并复写相关方法

1.mysql

 1 public class Mysql {
 2 
 3          public Connection conn;
 4 
 5          {
 6 
 7                  try {
 8 
 9                           Class.forName("com.mysql.jdbc.Driver");
10 
11                           conn=DriverManager.getConnection("jdbc:mysql://localhost/spring","root","root");
12 
13                  } catch (ClassNotFoundException e) {
14 
15                           e.printStackTrace();
16 
17                  } catch (SQLException e) {
18 
19                           e.printStackTrace();
20 
21                  }
22 
23          }
24 
25  
26 
27 }

2.redis

  1 public class Redis extends Jedis {
  2 
  3  
  4 
  5          public Jedis redis;
  6 
  7          {
  8 
  9                  redis = new Jedis("192.168.217.128", 6379);
 10 
 11                  redis.auth("root");
 12 
 13          }
 14 
 15  
 16 
 17          // public static void main(String[] args) {
 18 
 19          // System.out.println(redis.get("name"));
 20 
 21          // System.out.println(redis.keys("*"));
 22 
 23          // // redis.sinter(keys);
 24 
 25          // }
 26 
 27  
 28 
 29          public String get(String key) {
 30 
 31                  return redis.get("name");
 32 
 33          }
 34 
 35  
 36 
 37          public String set(String key, String value) {
 38 
 39                  return redis.set(key, value);
 40 
 41          }
 42 
 43  
 44 
 45          public Long del(String... keys) {
 46 
 47                  return redis.del(keys);
 48 
 49          }
 50 
 51  
 52 
 53          // 键值增加字符
 54 
 55          public Long append(String key, String str) {
 56 
 57                  return redis.append(key, str);
 58 
 59          }
 60 
 61  
 62 
 63          public Boolean exists(String key) {
 64 
 65                  return redis.exists(key);
 66 
 67          }
 68 
 69  
 70 
 71          // Need research
 72 
 73          public Long setnx(String key, String value) {
 74 
 75                  return redis.setnx(key, value);
 76 
 77          }
 78 
 79  
 80 
 81          public String setex(String key, String value, int seconds) {
 82 
 83                  return redis.setex(key, seconds, value);
 84 
 85          }
 86 
 87  
 88 
 89          public Long setrange(String key, String str, int offset) {
 90 
 91                  return redis.setrange(key, offset, str);
 92 
 93          }
 94 
 95  
 96 
 97          public List<String> mget(String... keys) {
 98 
 99                  return redis.mget(keys);
100 
101          }
102 
103  
104 
105          public String mset(String... keys) {
106 
107                  return redis.mset(keys);
108 
109          }
110 
111  
112 
113          public Long msetnx(String... keysvalues) {
114 
115                  return redis.msetnx(keysvalues);
116 
117          }
118 
119  
120 
121          public String getset(String key, String value) {
122 
123                  return redis.getSet(key, value);
124 
125          }
126 
127  
128 
129          public String hmset(String key, Map<String, String> hash) {
130 
131                  return redis.hmset(key, hash);
132 
133          }
134 
135  
136 
137          public Map<String, String> hgetall(String key) {
138 
139                  return redis.hgetAll(key);
140 
141          }
142 
143  
144 
145          public String hget(final String key, final String field) {
146 
147                  return redis.hget(key, field);
148 
149          }
150 
151  
152 
153          public Long hset(final String key, final String field, final String value) {
154 
155                  return redis.hset(key, field, value);
156 
157          }
158 
159  
160 
161          public Long expire(final String key, final int seconds) {
162 
163                  return redis.expire(key, seconds);
164 
165          }
166 
167  
168 
169          public Boolean hexists(final String key, final String field) {
170 
171                  return redis.hexists(key, field);
172 
173          }
174 
175  
176 
177 }

3.二、逻辑具体实现：

 1 public class Main {
 2 
 3          Mysql mysql=new Mysql();
 4 
 5          Redis redis=new Redis();
 6 
 7          ResultSet rs=null;
 8 
 9         
10 
11          //模拟登陆缓存
12 
13          @Test
14 
15          public void redisLogin() throws SQLException{
16 
17                  //正常业务的ID是通过UI的request.getParamenter()获取
18 
19                  String id="9028935b527d22cc01527d235aea0142";
20 
21                  String sql="select * from user where id_='"+id+"'";
22 
23                  String username;
24 
25                  if(redis.hexists("user_"+id, "username_")){
26 
27                           username=redis.hget("user_"+id, "username_");
28 
29                           System.out.println("Welcome Redis! User "+username+" login success");
30 
31                  }else{
32 
33                           rs=mysql.conn.createStatement().executeQuery(sql);
34 
35                           if(rs.next()==false){
36 
37                                    System.out.println("Mysql no register, Please register first");
38 
39                           }else{
40 
41                                    username=rs.getString("username_");
42 
43                                    System.out.println("Welcome Mysql ! User "+username+" login success");
44 
45                                    redis.hset("user_"+id, "username_", username);
46 
47                                    //30分钟未操作就过期
48 
49                                    redis.expire("user_"+id, 1800);
50 
51                           }
52 
53                  }
54 
55                 
56 
57          }
58 
59 }