linux下安装redis

一、Linux安装redis===================

1，安装Redis

先创建好安装路径：/data1/apps/redis2.6.14

1.1，下载及安装

wget http://redis.googlecode.com/files/redis-2.6.14.tar.gz   #或者直接在reids官方网站下载下来gz包   
tar -zxvf redis-2.6.14.tar.gz     #解压
cd redis-2.6.14    #进入redis安装目录
make PREFIX=/data1/apps/redis2.6.14 install   #安装
mkdir /data1/apps/redis2.6.14/etc    #创建目录同于存放配置文件

cp   redis.conf   /data/apps/redis2.6.14/etc   

1.2，可能会出现的错误提示
>>提示1：
make[3]: gcc：命令未找到
>>解决
yum -y install gcc-c++

>>提示2：
在包含自 adlist.c：34 的文件中:
zmalloc.h:50:31: 错误：jemalloc/jemalloc.h：没有那个文件或目录
zmalloc.h:55:2: 错误：#error "Newer version of jemalloc required"
>>解决

• make的时候加上 MALLOC=libc 参数

　　make PREFIX=/data/apps/redis2.6.14 MALLOC=libc install

　　cp   redis.conf   /etc/    #这个文件是redis启动的配置文件

• 由于redis安装在/data1/apps/redis2.6.14/下，所以

　　cd /data1/apps/redis2.6.14/ 进入这个目下，执行
　　cp redis-benchmark redis-cli redis-server /usr/bin/
　　这样就不用再执行时加上./了，而且可以在任何地方执行

　　echo 1 > /proc/sys/vm/overcommit_memory

• 设置内存分配策略（可选，根据服务器的实际情况进行设置） /proc/sys/vm/overcommit_memory

　　　可选值：0、1、2。
　　0，表示内核将检查是否有足够的可用内存供应用进程使用；如果有足够的可用内存，内存申请允许；否则，内存申请失败，并把错误返回给应用进程。

　　1，表示内核允许分配所有的物理内存，而不管当前的内存状态如何。
　　2，表示内核允许分配超过所有物理内存和交换空间总和的内存
　　值得注意的一点是，redis在dump数据的时候，会fork出一个子进程，理论上child进程所占用的内存和parent是一样的，比如parent 占用的内存为8G，这个时候也要同样分配8G的内存给child,如果内存无法负担，往往会造成redis服务器的down机或者IO负载过高，效率下降。所以这里比较优化的内存分配策略应该设置为 1（表示内核允许分配所有的物理内存，而不管当前的内存状态如何）

• 开启redis端口，修改防火墙配置文件

　　vi /etc/sysconfig/iptables

• 加入端口配置

　　-A INPUT -m state --state NEW -m tcp -p tcp --dport 6379 -j ACCEPT

• 重新加载规则

　　service iptables restart

• 启动redis service

　　redis-server /etc/redis.conf

　　[3862] 19 Feb 23:10:56.339 * Max number of open files set to 10032
　　[3862] 19 Feb 23:10:56.347 # Warning: 32 bit instance detected but no memory limit set. Setting 3 GB maxmemory limit with 'noeviction' policy now.

[3862] 19 Feb 23:10:56.347 # Server started, Redis version 2.6.14
[3862] 19 Feb 23:10:56.347 * The server is now ready to accept connections on port 6379

• 查看进程，确定redis启动成功：

　　ps -ef | grep redis
　　[root@mtycentos ~]# ps -ef | grep redis
　　root 3862 3666 0 23:10 pts/1 00:00:00 redis-server /etc/redis.conf
　　root 3886 3866 0 23:11 pts/0 00:00:00 grep redis

• 如果启动失败，大部分情况下是因为redis.conf的配置有问题。
• 设置redis为后台守护进程：

　　vi /etc/redis.conf
　　# 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 no
　　daemonize yes
　　把no 改为 yes

• 修改完成后关闭redis ： redis-cli shutdown
• 查看是否关闭：ps -ef | grep redis
• 再次启动为守护进程：redis-server /etc/redis.conf

　　[root@mtycentos ~]# ps -ef | grep redis
　　root 3913 1 0 23:16 ? 00:00:00 redis-server /etc/redis.conf
　　root 3917 3866 0 23:16 pts/0 00:00:00 grep redis

　　OK，启动成功

• 测试一把：

　　进入redis客户端命令行：
　　redis-cli 回车
　　redis 127.0.0.1:6379>
　　redis 127.0.0.1:6379> set name hanlu
　　OK
　　redis 127.0.0.1:6379> get name
　　"hanlu"

说明成功了。

• 退出当前命令行：quit

　　关闭redis：
　　redis-cli shutdown

• redis关闭后，缓存数据会自动保存到硬盘上，硬盘地址为redis.conf中的配置项dgfilename dump.rdb
• 强制备份数据到磁盘：

　　redis-cli save or redis-cli -p 6380 save (要制定端口进行备份)

二、redis使用

1、简介

2、常用命令

3、在linux中打开redis服务

4、推荐使用redis管理工具Redis Desktop Manager

5、下面即将redis缓存应用到myeclipse的web项目中：

1）设计思路

2）首先进行Jedis配置

    <!-- redis配置 -->
    <!-- 配置数据源（redis连接池） -->
    <bean id="jedisPoolConfig"
        class="redis.clients.jedis.JedisPoolConfig" scope="singleton">
        <!-- 连接池支持最大的连接数 -->
        <property name="maxActive" value="100" />
        <!-- 连接池最多可空闲的连接数 -->
        <property name="maxIdle" value="10" />
        <!-- 最大等待时间 -->
        <property name="maxWait" value="100" />
        <!-- 取出时是否检测 -->
        <property name="testOnBorrow" value="true" />
    </bean>

    <!-- 配置redis数据库 -->
    <bean id="jedisPool" class="redis.clients.jedis.JedisPool"
        destroy-method="destroy">
        <!-- 构造函数参数 -->
        <!-- 指定连接池 -->
        <constructor-arg ref="jedisPoolConfig" />
        <!-- 指定ip地址 -->
        <constructor-arg value="127.0.0.1" />
        <!-- 指定端口号 -->
        <constructor-arg value="6379" />
    </bean>

    <!-- 注入Javabean(RedisAPI) -->
    <bean id="redisAPI" class="org.sl.util.RedisAPI">
        <property name="jedisPool" ref="jedisPool" />
    </bean>

然后在工具类中创建RedisAPI类

package org.sl.util;

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

/**
 * 工具类--redis数据库
 * @author ty
 *
 */
public class RedisAPI {
    
    //redis数据库对象
    private JedisPool jedisPool;

    public JedisPool getJedisPool() {
        return jedisPool;
    }
    public void setJedisPool(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }
    
    /**
     * 返还连接池方法
     * @param pool
     * @param jedis
     */
    public static void retuen(JedisPool pool,Jedis jedis){
        if(null != jedis){
            pool.returnResource(jedis);
        }
    }
    
    /**
     * redis数据库set方法
     * @param key
     * @param value
     * @return
     */
    public boolean set(String key,String value){
        Jedis jedis = null;
        //捕获异常
        try {
            jedis = jedisPool.getResource();
            jedis.set(key, value);
            return true;
        } catch (Exception e) {
            // TODO: handle exception
            //打印异常信息
            e.printStackTrace();
        }finally{
            retuen(jedisPool,jedis);
        }
        return false;
    }
    
    /**
     * 判断是否有key
     * @param key
     * @return
     */
    public boolean exist(String key){
        boolean flag = false;
        Jedis jedis = null;
        //捕获异常
        try {
            jedis = jedisPool.getResource();
            flag = jedis.exists(key);
        } catch (Exception e) {
            // TODO: handle exception
            //打印异常信息
            e.printStackTrace();
        }finally{
            retuen(jedisPool,jedis);
        }
        return flag;
    }
    
    /**
     * 获取key对应的value
     * @param key
     * @return
     */
    public String get(String key){
        String st = null;
        Jedis jedis = null;
        //捕获异常
        try {
            jedis = jedisPool.getResource();
            st = jedis.get(key);
        } catch (Exception e) {
            // TODO: handle exception
            //打印异常信息
            e.printStackTrace();
        }finally{
            retuen(jedisPool,jedis);
        }
        return st;
    }
}

在对应的Controller中创建一个RedisAPI对象

对应方法中的代码：

/**
     * 登录成功之后进入的方法
     * @return
     */
    @RequestMapping(value="/success")
    public ModelAndView loginSuccess(HttpSession session){
        //使用父类获取session中的当前用户
        User user = this.getSuccessUser();
        //创建一个菜单集合
        List<Menu> mList = null;
        if(null != user){
            //创建一个map集合，为之后其他页面拿到菜单列表
            Map<String, Object> modelMap = new HashMap<String, Object>();
            modelMap.put("user", user);
            
            //获取公告信息
            List<GongGao> gongGaoList = null;
            GongGao gongGao = new GongGao();
            gongGao.setStarNum(0);
            gongGao.setPageSize(5);
            //获取资讯信息
            List<ZiXun> ziXunList = null;
            ZiXun ziXun = new ZiXun();
            ziXun.setStarNum(0);
            ziXun.setPageSize(5);
            ziXun.setState(1);
            
            try {
                gongGaoList = gongGaoService.getShouYeGongGaoList(gongGao);
                ziXunList = ziXunService.getZiXunListFenYe(ziXun);
            } catch (Exception e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
                gongGaoList = null;
            }
            
            //redis存储规则：redis+roleId
            //判断redis里是否有当前用户
            if(!(redisAPI.exist("redis"+user.getRoleId()))){
                //如果没有
                //根据当前用户获取菜单列表mList
                mList = getmListBySuccessUser(user.getRoleId());
                if(null != mList){
                    //把mList转成String
                    JSONArray jsonArray= JSONArray.fromObject(mList);
                    String st = jsonArray.toString();
                    //把mList放到map中
                    modelMap.put("menuList", st);
                    //放进redis中
                    redisAPI.set("redis"+user.getRoleId(), st);
                }
            }else{
                //如果有，直接从redis里取数据
                String st = redisAPI.get("redis"+user.getRoleId());
                if(null != st && !"".equals(st)){
                    //放到Map集合
                    modelMap.put("menuList", st);
                }else{
                    return new ModelAndView("redirect:/");
                }
            }
            if(!redisAPI.exist("redis"+user.getRoleId()+"url")){
                //如果redis中没有当前用户的url列表，就放入redis中
                QuanXian quanXian = new QuanXian();
                quanXian.setRoleId(user.getRoleId());
                try {
                    //获取当前用户的所有权限（url）列表
                    List<Function> functionList = functionService.getFunctionListByRoId(quanXian);
                    if(functionList != null){
                        StringBuffer string = new StringBuffer();
                        for (Function function : functionList) {
                            string.append(function.getFuncUrl());
                        }
                        redisAPI.set("redis"+user.getRoleId()+"url", string.toString());
                    }
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            //把放有菜单列表的Map集合放到session中
            session.setAttribute("gongGaoList", gongGaoList);
            session.setAttribute("ziXunList", ziXunList);
            session.setAttribute(Statics.SESSION_BASE_MODEL, modelMap);
            return new ModelAndView("success",modelMap);
        }
        //如果user为空，返回到系统根目录（登录页面）
        return new ModelAndView("redirect:/");
    }