发表于: 2018-03-06 23:55:43
1 759
今天完成的事情:
今天首先是安装了Redis:
不知道是因为什么,Redis的安装显得格外的复杂,每次安装好后都无法运行,最后好不容易找到了一个比较稳定的安装方式:
安装好后,就需要远程连接服务器:
redis现在的版本开启redis-server后,redis-cli只能访问到127.0.0.1,因为在配置文件中固定了ip,
因此需要修改redis.conf(有的版本不是这个文件名,只要找到相对应的conf后缀的文件即可)文件以下几个地方。
1.bind 127.0.0.1改为 #bind 127.0.0.1
2.protected-mode yes 改为 protected-mode no
3.加入 daemonize yes
然后根据配置文件启动redis:
redis-server路径 redis.conf路径
就可以看到如下图案:
然后可以根据netstat -tunlp | grep redis命令查看redis服务器是否启动。
然后可以在本地连接到服务器:telnet ip 6379
.png)

到这里,redis的安装就完成了。
——————————————————————————————————————————————————————————————
Java spring集成redis:
配置文件:
<context:property-placeholder
ignore-resource-not-found="true" location="classpath*:application.properties"/>
<!-- redis缓存数据库的相关配置 -->
<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxIdle" value="${redis.maxIdle}"/>
<property name="maxActive" value="${redis.maxActive}"/>
<property name="maxWait" value="${redis.maxWait}"/>
<property name="testOnBorrow" value="${redis.testOnBorrow}"/>
</bean>
<bean id="connectionFactory"
class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}"
p:pool-config-ref="poolConfig"/>
<bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
<property name="connectionFactory" ref="connectionFactory"/>
</bean>
这里需要注意的是,当项目有多个配置文件的时候,需要在context中添加ignore-resource-not-found="true"属性。
然后是配置文件application.properties:
# Redis settings
redis.host=IP
redis.port=6379(端口)
redis.pass=(密码,)
redis.maxIdle=300
redis.maxActive=600
redis.maxWait=1000
redis.testOnBorrow=true
程序运行结果如下:
代码如下:
DAO层:
@Repository("RedisCacheDao")
public class RedisCacheDaoImpl implements RedisCacheDao {
private static final Logger logger = Logger
.getLogger(RedisCacheDaoImpl.class.getName());
static final byte[] ngHisByte = SerializeUtil.serialize("WANDA_NGHIS");
@Resource
protected RedisTemplate<Serializable, Serializable> redisTemplate;
/**
* 根据key删除数据
*
* @param key
* 键
* @return boolean 删除成功或失败的标志
***/
@Override
public boolean deleteKey(final String key) {
boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection)
throws DataAccessException {
byte[] keyByte = SerializeUtil.serialize(key);
Boolean flag = false;
if (connection.hExists(ngHisByte, keyByte)) {
logger.info("存在该键,执行删除");
flag = connection.hDel(ngHisByte, keyByte);
}
return flag;
}
});
return result;
}
/**
* 根据key存储object
*
* @param key
* 键
* @param value
* 要存储的对象Object
* @return boolean 存储成功或失败的标志
***/
@Override
public boolean saveObject(final String key, final Object value) {
boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
@Override
public Boolean doInRedis(RedisConnection connection)
throws DataAccessException {
byte[] keyByte = SerializeUtil.serialize(key);
byte[] valueByte = SerializeUtil.serialize(value);
Boolean flag = false;
if (connection.hExists(ngHisByte, keyByte)) {
logger.info("数据已存在,先删除旧数据");
connection.hDel(ngHisByte, keyByte);
}
flag = connection.hSet(ngHisByte, keyByte, valueByte);
return flag;
}
});
return result;
}
/**
* 根据key获取object
*
* @param key
* 键
* @return Object 与key对应的object
***/
@Override
public Object getObject(final String key) {
Object result = redisTemplate.execute(new RedisCallback<Object>() {
@Override
public Object doInRedis(RedisConnection connection)
throws DataAccessException {
Object returnObject = null;
byte[] keyByte = SerializeUtil.serialize(key);
if (connection.hExists(ngHisByte, keyByte)) {
logger.info("数据存在--开始读取");
returnObject = SerializeUtil
.unserialize(connection.hGet(ngHisByte, keyByte));
} else {
logger.info("数据不存在");
}
return returnObject;
}
});
return result;
}
}
DAO接口:
public interface RedisCacheDao
{
/**
* 根据key存储object
*
* @param key 键
* @param value 要存储的对象Object
* @return boolean 存储成功或失败的标志
* ***/
public abstract boolean saveObject(String key, Object value);
/**
* 根据key获取object
*
* @param key 键
* @return Object 与key对应的object
* ***/
public abstract Object getObject(String key);
/**
* 根据key删除数据
*
* @param key 键
* @return boolean 删除成功或失败的标志
* ***/
public abstract boolean deleteKey(String key);
}
实现层:
@Service
public class RedisCacheServiceImpl implements RedisCacheService {
private static final Logger logger = Logger
.getLogger(RedisCacheServiceImpl.class);
@Autowired
private RedisCacheDao redisCacheDao;
@Override
public boolean putSessionObject(String id, Object sessionObject) {
boolean flag = false;
if (sessionObject != null && id != null && id.trim().length() > 0) {
flag = redisCacheDao.saveObject(id, sessionObject);
logger.info("数据缓存标志:" + flag);
} else {
logger.info("参数含空值或null,缓存失败" + flag);
}
return flag;
}
@Override
public boolean clearSessionObject(String id) {
boolean flag = false;
if (id != null && id.trim().length() > 0) {
flag = redisCacheDao.deleteKey(id);
logger.info("缓存清空标志:" + flag);
} else {
logger.info("参数含空值或null,清空缓存失败");
}
return flag;
}
@Override
public Object getsessionObject(String id) {
Object sessionObject = new Object();
if (id != null && id.trim().length() > 0) {
sessionObject = redisCacheDao.getObject(id);
} else {
logger.info("参数含空值或null,获取缓存失败");
}
return sessionObject;
}
}
服务层接口:
public interface RedisCacheService {
/**
* 根据id缓存数据。 参数说明:id和sessionObject不允许为null或空值。 数据库若已存在同名键,则会覆盖掉
***/
public boolean putSessionObject(String id, Object sessionObject);
/**
* 根据id删除已缓存的数据。 参数说明:id不允许为null和空值
***/
public boolean clearSessionObject(String id);
/**
* 根据id获取已缓存的缓存数据。 参数说明:id不允许为null和空值
***/
public Object getsessionObject(String id);
}
序列化工具:
/***
* 序列化和反序列化工具
*
* @author Juveniless
* ***/
public class SerializeUtil
{
private static final Logger logger = Logger.getLogger(SerializeUtil.class);
/**
* 序列化
*
* @param object
* @return
*/
public static byte[] serialize(Object object)
{
byte[] bytes = null;
if (object != null)
{
ObjectOutputStream oos = null;
ByteArrayOutputStream baos = null;
try
{
// 序列化
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
oos.writeObject(object);
bytes = baos.toByteArray();
}
catch (Exception e)
{
e.printStackTrace();
logger.error("序列化出现异常:", e);
}
finally
{
close(oos);
close(baos);
}
}
return bytes;
}
/**
* 反序列化
*
* @param bytes
* @return Object
*/
public static Object unserialize(byte[] bytes)
{
Object returnObject = new Object();
if (bytes != null)
{
ByteArrayInputStream bais = null;
ObjectInputStream ois = null;
try
{
// 反序列化
bais = new ByteArrayInputStream(bytes);
ois = new ObjectInputStream(bais);
returnObject = ois.readObject();
}
catch (Exception e)
{
e.printStackTrace();
logger.error("反序列化出现异常:", e);
}
finally
{
close(bais);
close(ois);
}
}
else
{
returnObject = null;
}
return returnObject;
}
/**
* 关闭io流对象
*
* @param closeable
*/
public static void close(Closeable closeable)
{
if (closeable != null)
{
try
{
closeable.close();
}
catch (Exception e)
{
e.printStackTrace();
logger.error("关闭io流对象出现异常:", e);
}
}
}
}
控制层:
@RequestMapping("/")
public String view() {
logger.info("你已通过springMVC进入controller方法");
logger.info("-------存储数据---------");
redisCacheService.putSessionObject("123","wwwwwww");
logger.info("-------读取数据---------");
redisCacheService.getsessionObject("123");
logger.info("-------删除数据---------");
redisCacheService.clearSessionObject("123");
logger.info("-------删除后再次读取数据---------");
redisCacheService.getsessionObject("123");
return "index";
}
明天计划的事情:
遇到的问题:
1.redis安装好后无法运行。
2.redis与spring集成之后,会报错还没找到办法
收获:
大致学习了redis的使用。
评论