在安装好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:
<!-- jedis和commons 用于连接redis -->
<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中的配置:
<!--将properties引入-->
<context:property-placeholder location="classpath:redis.properties" />
<!-- 将redis相关参数注入 -->
<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"));
控制台打印结果则操作成功。