java使用jedis连接redis

清疚 2021-06-24 15:57 561阅读 0赞

在安装好redis后需要修改redis.conf的几个配置：  
\#requirepass foobared //将\#删除并将foobared改成自己密码  
bind 127.0.0.1(bind localhost) //将其注释掉，否则只能允许本机访问  
daemonize yes //将其改为no 这样当启动redis服务后，不会出现redis的logo，不用新开窗口  
protected-mode yes //将其改为no，让其不以保护模式运行  
修改配置后，启动redis-server时在后面带上配置文件否则连接就会报错（redis-server /usr/redis.conf）  
java连接redis需要引两个jar包：jedis 和 commons-pool：

<dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>commons-pool</groupId>
            <artifactId>commons-pool</artifactId>
            <version>1.6</version>
        </dependency>

项目中使用spring管理连接的基本信息，redis.properties代码：

##redis数据库的相关配置
    ##连接地址ip
    redis.addr = redisip地址
    ##端口号
    redis.port = 6379
    ##访问密码
    redis.auth = //在redis.conf中设置
    ##控制一个pool最多可以有多少个状态为Idle(空)的jedis实例默认值为8
    redis.maxIdle = 200
    ##可用的最大连接实例数 默认为8
    redis.maxActive = 1024
    ##等待可用连接的最大时间单位为毫秒 默认为-1表示永不超时，一旦超过等待时间则直接抛出
    redis.maxWait = 10000
    redis.timeOut = 10000
    ##设置为true则会在borrow一个jedis实例时，提前做validate操作
    redis.testOnBorrow =false

applicationContext.xml中的配置：

<context:property-placeholder location="classpath:redis.properties" />
    
        <bean id="redisUtil" class="com.wellness.platfront.common.util.RedisUtil">
               <property name="addr"><value>${redis.addr}</value></property>
               <property name="port"><value>${redis.port}</value></property>
               <property name="auth"><value>${redis.auth}</value></property>
               <property name="maxIdle"><value>${redis.maxIdle}</value></property>
               <property name="maxActive"><value>${redis.maxActive}</value></property>
               <property name="maxWait"><value>${redis.maxWait}</value></property>
               <property name="timeOut"><value>${redis.timeOut}</value></property>
               <property name="testOnBorrow"><value>${redis.testOnBorrow}</value></property>
           </bean>

RedisUtil中代码：

package com.wellness.platfront.common.util;
    
    import java.io.Serializable;
    import java.util.ArrayList;
    import java.util.List;
    
    import javax.annotation.Resource;
    
    import org.hibernate.SessionFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.stereotype.Component;
    import org.springframework.stereotype.Service;
    
    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;
    
    /** * 用于连接redis的工具类 * @author yangfuren * @since 2017/11/21 */
    public class RedisUtil implements Serializable{ 
    
        private static final long serialVersionUID = 1L;
        //Redis服务器IP
        private static String addr;
    
        //Redis的端口号
        private static int port;
    
        //访问密码
        private static String auth;
    
        //可用连接实例的最大数目，默认值为8；
        //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
        private static int maxActive;
    
        //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
        private static int maxIdle;
    
        //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
        private static int maxWait;
        private static int timeOut;
    
        //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
        private static boolean testOnBorrow;
    
        public static Jedis jedis;//非切片额客户端连接
    
        public static JedisPool jedisPool;//非切片连接池
    
        public static ShardedJedis shardedJedis;//切片额客户端连接
    
        public static ShardedJedisPool shardedJedisPool;//切片连接池
    
        /** 切片池和非切片池的区别主要在于有没有主从redis 主从redis主要用于分布式系统 * 分布式系统使用切片连接池 一般系统使用非切片池 * 初始化非切片池 */
        private static void initialPool() 
        { 
            // 池基本配置 
            JedisPoolConfig config = new JedisPoolConfig();
            System.out.println(addr);
            config.setMaxTotal(maxActive); 
            config.setMaxIdle(maxIdle); 
            config.setMaxWaitMillis(maxWait); 
            config.setTestOnBorrow(testOnBorrow);
            jedisPool = new JedisPool(config, addr, port);
        }
    
        /** * 初始化切片池 */ 
        private static  void initialShardedPool() 
        { 
            // 池基本配置 
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(maxActive); 
            config.setMaxIdle(maxIdle); 
            config.setMaxWaitMillis(maxWait); 
            config.setTestOnBorrow(testOnBorrow);
            // slave链接 
            List<JedisShardInfo> shards = new ArrayList<JedisShardInfo>(); 
            shards.add(new JedisShardInfo(addr, port, auth)); 
            // 构造池 
            shardedJedisPool = new ShardedJedisPool(config, shards); 
        }
        /** * 非切片池返回jedis * @return */
        public  static Jedis returnJedis(){
            initialPool(); 
            initialShardedPool();
            try {
                 jedis = jedisPool.getResource();
                 jedis.auth(auth);
            } catch (Exception e) {
                System.out.println("连接jedisPool失败!");
            }
            return jedis;
        }
        /** * 切片池返回ShardedJedis * @return */
        public  static ShardedJedis returnShareJedis(){
            initialPool(); 
            initialShardedPool();
            try {
                  shardedJedis = shardedJedisPool.getResource(); 
            } catch (Exception e) {
                System.out.println("连接shardedJedisPool失败!");
            }
            return shardedJedis;
        }
    
        public static String getAddr() {
            return addr;
        }
    
        public static void setAddr(String addr) {
            RedisUtil.addr = addr;
        }
    
        public static int getPort() {
            return port;
        }
    
        public static void setPort(int port) {
            RedisUtil.port = port;
        }
    
        public static String getAuth() {
            return auth;
        }
    
        public static void setAuth(String auth) {
            RedisUtil.auth = auth;
        }
    
        public static int getMaxActive() {
            return maxActive;
        }
    
        public static void setMaxActive(int maxActive) {
            RedisUtil.maxActive = maxActive;
        }
    
        public static int getMaxIdle() {
            return maxIdle;
        }
    
        public static void setMaxIdle(int maxIdle) {
            RedisUtil.maxIdle = maxIdle;
        }
    
        public static int getMaxWait() {
            return maxWait;
        }
    
        public static void setMaxWait(int maxWait) {
            RedisUtil.maxWait = maxWait;
        }
    
        public static int getTimeOut() {
            return timeOut;
        }
    
        public static void setTimeOut(int timeOut) {
            RedisUtil.timeOut = timeOut;
        }
    
        public static boolean isTestOnBorrow() {
            return testOnBorrow;
        }
    
        public static void setTestOnBorrow(boolean testOnBorrow) {
            RedisUtil.testOnBorrow = testOnBorrow;
        }
       }

测试代码现在basicAction中调用RedisUtil并返回jedis：

private static RedisUtil redisUtil = new RedisUtil();
        public Jedis jedis = getJedis();
        //返回jedis
        public static Jedis getJedis(){
            return redisUtil.returnJedis();
        }

在具体action中使用redis：

jedis.set("ceshikey", "111");
                System.out.println(jedis.get("ceshikey"));

控制台打印结果则操作成功。