发表于: 2018-03-06 23:55:43

1 762


今天完成的事情:
今天首先是安装了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
到这里,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的使用。



返回列表 返回列表
评论

    分享到