[深圳|结业弟子]JAVA-苏晔|2018年03月06日的日报-技能树.IT修真院

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

1 761

今天完成的事情：

今天首先是安装了Redis：

不知道是因为什么，Redis的安装显得格外的复杂，每次安装好后都无法运行，最后好不容易找到了一个比较稳定的安装方式：

https://www.cnblogs.com/KunGe-13/p/8340309.html

安装好后，就需要远程连接服务器：

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"/>

</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>

这里需要注意的是，当项目有多个配置文件的时候，需要在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";
}