【java学习】java web Redis学习总结 经典

javazx

第一章 Redis

redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类keyvalue存储的不足，在部 分场合可以对关系数据库起到很好的补充作用。它提供了Python，Ruby，Erlang，PHP客户端，使用很方便。问题是这个项目还很新，可能还不足够稳定。

一.1 LINUX下面安装redis

     Redis是一种高级key-value数据库。它跟memcached类似，不过数据可以持久化，而且支持的数据类型很丰富。有字符串，链表，集 合和有序集合。支持在服务器端计算集合的并，交和补集(difference)等，还支持多种排序功能。所以Redis也可以被看成是一个数据结构服务 器。

Redis的所有数据都是保存在内存中，然后不定期的通过异步方式保存到磁盘上(这称为“半持久化模式”)；也可以把每一次数据变化都写入到一个append only file(aof)里面(这称为“全持久化模式”)。

1． 下载地址：

$ wget http://redis.googlecode.com/files/redis-2.6.13.tar.gz

2． 解压缩

$ tar xzf redis-2.6.13.tar.gz

3． 编译

$ cd redis-2.6.13

$ make

$make install

$cp redis.conf /etc/

3 a) P9 U& P$ U3 U9 X3 O

安装成功之后会在src文件夹内有redis-server和redis-cli两个命令

建议将其放到bin下

sudo cp redis-server /usr/local/bin/

sudo cp redis-cli /usr/local/bin/

参数介绍：

make install命令执行完成后，会在/usr/local/bin目录下生成本个可执行文件，分别是redis-server、redis-cli、redis-benchmark、redis-check-aof 、redis-check-dump，它们的作用如下：

redis-server：Redis服务器的daemon启动程序

redis-cli：Redis命令行操作工具。也可以用telnet根据其纯文本协议来操作

redis-benchmark：Redis性能测试工具，测试Redis在当前系统下的读写性能

redis-check-aof：数据修复

redis-check-dump：检查导出工具

一.2 配置文件参数

redis.conf 文件配置如下：
daemonize yes  #以后台daemon方式运行redis
* j! C* ]" C( n7 t) E$ Rpidfile "/var/run/redis.pid"  #redis以后台运行，默认pid文件路径/var/run/redis.pid
8 z" i) R; w; r. iport 6379  #默认端口
& K3 Y6 E0 l5 w% Q3 v# u6 Ybind 127.0.0.1 #默认绑定本机所有ip地址，为了安全，可以只监听内网ip
timeout 300 #客户端超时设置，单位为秒
loglevel verbose  #设置日志级别，支持四个级别：debug、notice、verbose、warning
logfile stdout  #日志记录方式，默认为标准输出，logs不写文件，输出到空设备/deb/null
logfile "/usr/local/redis/var/redis.log"  #可以指定日志文件路径
databases 16  #开启数据库的数量
; N$ }  |- Z+ h/ ssave 900 1
save 300 10
' M% h8 g; M9 y. J4 Tsave 60 10000
6 l% G$ h& {9 \& N; @创建本地数据库快照，格式：save * *
900秒内，执行1次写操作
300秒内，执行10次写操作
60秒内，执行10000次写操作
, A* n, q. M5 H: x" L) M: [rdbcompression yes #启用数据库lzf压缩，也可以设置为no
dbfilename dump.rdb  #本地快照数据库名称
+ C0 m% Y& @- L4 N; ^3 A  s! P6 Ddir "/usr/local/redis/var/"   #本地快照数据库存放目录
requirepass 123456  #设置redis数据库连接密码
maxclients 10000 #同一时间最大客户端连接数，0为无限制
maxmemory 1024MB #设定redis最大使用内存，值要小于物理内存，必须设置
+ m/ w- C0 W  |8 G, Rappendonly yes  #开启日志记录，相当于MySQL的binlog
appendfilename "appendonly.aof"   #日志文件名，注意：不是目录路径
) l' I8 H" h9 |  ^, i- fappendfsync everysec #每秒执行同步，还有两个参数always、no一般设置为everysec，相当于MySQL事物日志的写方式
5 l1 L+ y6 G5 ]/ N:wq! #保存退出

一.3 启动和关闭

启动redis服务

    [root@Architect redis-1.2.6]# pwd  

    /usr/local/redis-1.2.6  

    [root@Architect redis-1.2.6]# redis-server /etc/redis.conf  

查看进程，确认redis已经启动

    [root@Architect redis-1.2.6]# ps -ef | grep redis  

    root       401 29222  0 18:06 pts/3    00:00:00 grep redis  

    root     29258     1  0 16:23 ?        00:00:00 redis-server /etc/redis.conf  

如果这里启动redis服务失败，一般情况下是因为redis.conf文件有问题，建议检查或找个可用的配置文件进行覆盖，

避免少走弯路，这里建议，修改redis.conf，设置redis进程为后台守护进程

    # By default Redis does not run as a daemon. Use 'yes' if you need it.  

    # Note that Redis will write a pid file in /var/run/redis.pid when daemonized.  

    daemonize yes  

一.4 测试redis

    [root@Architect redis-1.2.6]# redis-cli -a 33e9redis

    redis> set name songbin  

    OK  

    redis> get name   

"songbin"  

2 A9 N: [3 p  m& F7 Z: x0 nredis-cli -a 123456  #连接redis数据库，注意:-a后面跟redis数据库密码
set name 111cn.net  #写数据
0 T  d0 t* w3 k. Q/ H6 bget name  #读取数据
exit #退出redis数据库控制台 quit

  ~' |- c, D- |& d0 ~! I: e; b' L/ s
9 v5 R7 O6 B1 N# [& g! `# d

5：关闭redis服务

    redis-cli shutdown  

redis服务关闭后，缓存数据会自动dump到硬盘上，硬盘地址为redis.conf中的配置项dbfilename dump.rdb所设定强制备份数据到磁盘，使用如下命令

redis-cli save 或者 redis-cli -p 6380 save（指定端口）

一.5 redis启动脚本

启动脚本(startRedis.sh)：

#/opt/redis-2.8.6/redis.conf为redis配置文件目录

#nohup /usr/local/bin/redis-server  /redis/redis-2.8.6/redis.conf &

redis-2.8.6/src/redis-server redis-2.8.6/redis.conf &

停止脚本(stopRedis.sh)：

redis-2.8.6/src/redis-cli -p 6379 -a 33e9redis  shutdown

两个脚本放在和redis安装目录同级，如下图所示：

启动命令如下： ./startRedis.sh

输入 ps -ef |grep redis 查看是否启动成功。

关闭命令如下：./stopRedis.sh

如果报错：-bash: ./stopRedis.sh: 权限不够

则要增加权限：

localhost redis]# chmod u+x stopRedis.sh

[root@localhost redis]# ./stoRedis.sh

一.6 安全性

    为redis设置密码：设置客户端连接后进行任何其他指定前需要实用的密码。

警告：因为redis速度非常快，所以在一台较好的服务器下，一个外部用户可以在一秒钟进行150k次的密码尝试，这意味着你需要指定非常非常强大的密码来防止暴力破解。

修改密码的方法：

    只需要在redis的配置文件redis.conf中开启requirepass就可以了，比如我设置我的访问密码是mypassword。

requirepass mypassword

在redis.conf中加入这一行代码之后，我们杀死原来的redis进程：

pkill redis然后重新启动redis：

/usr/local/redis-2.8.1/src/redis-server /user/local/redis-2.8.1/redis.conf

然后我们用/usr/local/redis-2.8.1/src/redis-cli发现还能登陆进来，但是当我们执行操作的时候，比如keys *就会如下错误：

127.0.0.1:6379> keys *
(error) NOAUTH Authentication required.

没有必要的授权验证。

在这里redis支持两种授权方式，一种就是直接用auth命令进行授权：

0 B8 I- I1 h, E- b1 W

第一次输入了一个错误的密码test，授权失败，第二次输入正确的密码，返回ok，授权成功，之后就可以进行所有的操作。

如果我们不想每次登录进来之后都要用auth进行授权，那么我们可以采用另一种授权方式，就是在登陆客户端的时候用-a 来指定密码

sh-3.2# /usr/local/redis-2.8.1/src/redis-cli -a mypassword

上面的密码如果输错，也能进入，但是之后不能进行操作。需要用auth重新进行授权。

第二章 二、主从复制

    Redis主从复制配置和使用都非常简单。通过主从复制可以允许多个slave server拥有和master server相同的数据库副本。

redis主从复制的特点：

1.一台master可以拥有多个slave（1对多的关系）

2.多个slave可以连接同一个master外，还可以连接到其他slave（这样做的原因是如果masterdown掉之后其中的一台slave立马可以充当master的角色，这样整个服务流程不受影响）

3.中从复制不会阻塞master，在同步数据的同时，master可以继续处理client请求。

4.提高系统的伸缩性

redis主从复制的过程：

1.slave与master建立连接，发送sync同步命令。

2.Master会启动一个后台进程，将数据库快照保存到文件中，同时master主进程会开始收集新得写命令并缓存。

3.后台完成保存后，将文件发送给slave

4.slave将文件保存到硬盘上

配置主从服务器：

配置slave服务器很简单，只需要在slave的配置文件中加入以下配置：

slaveof masterip masterport

如果主机开启了登录验证，那么还需要加入下面这句：

masterauth authpassword

然后启动从机，首先主机会发快照给从机，从机的数据库会更新到和主机相同的状态，然后往主机里写内容，从机也会随之更新。

如果我们在从机上写数据那么会报错：

(error) READONLY You can't write against a read only slave.

我们可以用info命令来查看主从服务器的信息，在从机上用info命令可以看到

role：slave

master_host:masterip

master_port:masterport

master_link_status:up证明和主机处在连接状态

在主机上用info命令

role：master

同时连接着几台从机

connected_slaves:1

同时可以查看连接到主机上=6379,state=online,offset=1709,lag=1
- @' p  {8 y5 B3 ^

第三章 Jedis使用三.1 入门实例

RedisUtil 代码如下：

package com.test;

5 H" I; {& V. T5 t. A% F& Z

import redis.clients.jedis.Jedis;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.JedisPoolConfig;

public final class RedisUtil {

    //Redis服务器IP

    private static String ADDR = "192.168.0.100";

" z: w3 E7 k* `4 y* n

    //Redis的端口号

    private static int PORT = 6379;

1 }' y2 ?5 l- a; ^

    //访问密码

    private static String AUTH = "admin";

    //可用连接实例的最大数目，默认值为8；

    //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。

    private static int MAX_ACTIVE = 1024;

3 Q9 J) r' Z. N- N4 G8 ~7 Q8 ?% I) B

    //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。

    private static int MAX_IDLE = 200;

* i$ ~# r' m: _" S' I

    //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；

    private static int MAX_WAIT = 10000;

. a9 e; T3 ^2 c7 a' p! O+ H1 i

    private static int TIMEOUT = 10000;

    //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；

    private static boolean TEST_ON_BORROW = true;

    private static JedisPool jedisPool = null;

9 J8 r( K" N! L2 t" T

    /**

     * 初始化Redis连接池

     */

    static {

        try {

            JedisPoolConfig config = new JedisPoolConfig();

            config.setMaxActive(MAX_ACTIVE);

            config.setMaxIdle(MAX_IDLE);

            config.setMaxWait(MAX_WAIT);

            config.setTestOnBorrow(TEST_ON_BORROW);

            jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, AUTH);

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    /**

     * 获取Jedis实例

     * @return

     */

    public synchronized static Jedis getJedis() {

        try {

            if (jedisPool != null) {

                Jedis resource = jedisPool.getResource();

                return resource;

            } else {

                return null;

            }

        } catch (Exception e) {

            e.printStackTrace();

            return null;

        }

    }

% p; D9 k( g, T$ `3 w

    /**

     * 释放jedis资源

     * @param jedis

     */

    public static void returnResource(final Jedis jedis) {

        if (jedis != null) {

            jedisPool.returnResource(jedis);

        }

    }

}

TestRedis 代码如下：

package com.test;

& @4 h' G& }  H8 J

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

  ~  n( K2 K0 z3 J

import org.junit.Before;

import org.junit.Test;

# ], d, ^% m( Q" `# K

import redis.clients.jedis.Jedis;

3 H3 N* k" G0 F. ?$ [1 b

public class TestRedis {

    private Jedis jedis;

' n4 T0 ?, {9 {. @, [. c+ j1 M

    @Before

    public void setup() {

        //连接redis服务器，192.168.0.100:6379

        jedis = new Jedis("192.168.0.100", 6379);

        //权限认证

        jedis.auth("admin");  

    }

1 o7 l! ?6 l0 T: V5 A

    /**

     * redis存储字符串

     */

    @Test

    public void testString() {

        //-----添加数据----------  

        jedis.set("name","xinxin");//向key-->name中放入了value-->xinxin  

        System.out.println(jedis.get("name"));//执行结果：xinxin  

: q: M$ B! {8 Q, v' i  m- G- Z2 t

        jedis.append("name", " is my lover"); //拼接

        System.out.println(jedis.get("name"));

        jedis.del("name");  //删除某个键

        System.out.println(jedis.get("name"));

        //设置多个键值对

        jedis.mset("name","liuling","age","23","qq","476777XXX");

        jedis.incr("age"); //进行加1操作

        System.out.println(jedis.get("name") + "-" + jedis.get("age") + "-" + jedis.get("qq"));

; \+ `7 S# ]/ h* t( C8 V5 h

    }

! a& \5 R, J& m- v# b

    /**

     * redis操作Map

     */

    @Test

    public void testMap() {

        //-----添加数据----------  

        Map<String, String> map = new HashMap<String, String>();

        map.put("name", "xinxin");

        map.put("age", "22");

        map.put("qq", "123456");

        jedis.hmset("user",map);

        //取出user中的name，执行结果:[minxr]-->注意结果是一个泛型的List  

        //第一个参数是存入redis中map对象的key，后面跟的是放入map中的对象的key，后面的key可以跟多个，是可变参数  

        List<String> rsmap = jedis.hmget("user", "name", "age", "qq");

        System.out.println(rsmap);  

        //删除map中的某个键值  

        jedis.hdel("user","age");

        System.out.println(jedis.hmget("user", "age")); //因为删除了，所以返回的是null  

        System.out.println(jedis.hlen("user")); //返回key为user的键中存放的值的个数2

        System.out.println(jedis.exists("user"));//是否存在key为user的记录 返回true  

        System.out.println(jedis.hkeys("user"));//返回map对象中的所有key  

        System.out.println(jedis.hvals("user"));//返回map对象中的所有value

        Iterator<String> iter=jedis.hkeys("user").iterator();  

        while (iter.hasNext()){  

            String key = iter.next();  

            System.out.println(key+":"+jedis.hmget("user",key));  

        }  

    }

! M9 c% b& r) u& m3 I# |1 B

    /**

     * jedis操作List

     */  

    @Test  

    public void testList(){  

        //开始前，先移除所有的内容  

        jedis.del("java framework");  

        System.out.println(jedis.lrange("java framework",0,-1));  

        //先向key java framework中存放三条数据  

        jedis.lpush("java framework","spring");  

        jedis.lpush("java framework","struts");  

        jedis.lpush("java framework","hibernate");  

        //再取出所有数据jedis.lrange是按范围取出，  

        // 第一个是key，第二个是起始位置，第三个是结束位置，jedis.llen获取长度 -1表示取得所有  

        System.out.println(jedis.lrange("java framework",0,-1));  

- ~5 i. M8 S. \2 l, B

        jedis.del("java framework");

        jedis.rpush("java framework","spring");  

        jedis.rpush("java framework","struts");  

        jedis.rpush("java framework","hibernate");

        System.out.println(jedis.lrange("java framework",0,-1));

    }  

+ e! V6 }8 K! ^9 k+ b8 d

    /**

     * jedis操作Set

     */  

    @Test  

    public void testSet(){  

        //添加  

        jedis.sadd("user","liuling");  

        jedis.sadd("user","xinxin");  

        jedis.sadd("user","ling");  

        jedis.sadd("user","zhangxinxin");

        jedis.sadd("user","who");  

        //移除noname  

        jedis.srem("user","who");  

        System.out.println(jedis.smembers("user"));//获取所有加入的value  

        System.out.println(jedis.sismember("user", "who"));//判断 who 是否是user集合的元素  

        System.out.println(jedis.srandmember("user"));  

        System.out.println(jedis.scard("user"));//返回集合的元素个数  

    }  

: t4 ~, t8 }4 t1 f% D- Y

    @Test  

    public void test() throws InterruptedException {  

        //jedis 排序  

        //注意，此处的rpush和lpush是List的操作。是一个双向链表（但从表现来看的）  

        jedis.del("a");//先清除数据，再加入数据进行测试  

        jedis.rpush("a", "1");  

        jedis.lpush("a","6");  

        jedis.lpush("a","3");  

        jedis.lpush("a","9");  

        System.out.println(jedis.lrange("a",0,-1));// [9, 3, 6, 1]  

        System.out.println(jedis.sort("a")); //[1, 3, 6, 9]  //输入排序后结果  

        System.out.println(jedis.lrange("a",0,-1));  

    }  

1 }6 x  `9 J4 F" ^0 `3 _

    @Test

    public void testRedisPool() {

        RedisUtil.getJedis().set("newname", "中文测试");

        System.out.println(RedisUtil.getJedis().get("newname"));

    }

}

四.1 配置要求

1.Spring3.2.8以上。

2.redis2.6及以上。

3.Jdk1.6以上。

4.包含Jedis,JRedis,SRP and Lettuce，四个文件。

- z6 h# l6 v. [& g3 @+ }& T8 I

1109162935

啦啦啦啦啦啦啦

背包走的缓慢

不错好资源 可以用