我使用的工具是 Intellij idea 2019..3.4(idea) 和redis(redis-4.0.1）在spring项目直接添加redis连接部分：

一、代码设计：

1、在配置文件application.yml里面（在最后）添加redis的配置。（这是我后面遇到问题解决之后的，记得每行都置顶。）

redis如何从hive中获取数据 redis怎么获取数据_redis

2、 在pom文件添加redis依赖包

<!-- redis依赖包 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
			<exclusions>
				<exclusion>
					<groupId>io.lettuce</groupId>
					<artifactId>lettuce-core</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>

3、在项目config里添加redis数据源的config

package com.dcits.config.redis;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
@EnableCaching //开启注解
public class redisconfig extends CachingConfigurerSupport{


    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂

        template.setConnectionFactory(factory);

        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonSeial.setObjectMapper(om);

        // 值采用json序列化
        template.setValueSerializer(jacksonSeial);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());

        // 设置hash key 和value序列化模式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jacksonSeial);
        template.afterPropertiesSet();

        return template;
    }

    /**
     * 对hash类型的数据操作
     */
    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    /**
     * 对redis字符串类型数据操作
     */
    @Bean
    public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForValue();
    }

    /**
     * 对链表类型的数据操作
     */
    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    /**
     * 对无序集合类型的数据操作
     */
    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    /**
     *  对有序集合类型的数据操作
     */
    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }
}

4、在until包添加redis的基本方法（只是添加了一些目前使用到的 如果要使用到其他方法  就继续添加你要用到的方法就好）。

package com.dcits.utils.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtils {
 
	@Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public RedisUtils(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key,long time){
        try {
            if(time>0){
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key){
        return redisTemplate.getExpire(key,TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key){
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String ... key){
        if(key!=null&&key.length>0){
            if(key.length==1){
                redisTemplate.delete(key[0]);
            }else{
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    //============================String=============================
    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public Object get(String key){
        return key==null?null:redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key,Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key,Object value,long time){
        try {
            if(time>0){
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            }else{
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

}

5、添加redis的controller （做一个简单的定义一个key并取出）

package com.dcits.controller.redis;


import com.dcits.team.Team;
import com.dcits.utils.redis.RedisUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

import redis.clients.jedis.Jedis;

@RequestMapping("/redis")
@RestController
public class RedisController {

    private RedisTemplate<String, Object> redisTemplate;

    private static int ExpireTime = 60;   // redis中存储的过期时间60s

    @Resource
    private RedisUtils redisUtil;

    public RedisController(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }


    @RequestMapping("getleo")
    public Object getleo(){
        redisTemplate.opsForValue().set("num","123");//设置一个key（num），值为123
        return redisTemplate.opsForValue().get("num"); //返回num的值
    }


}

 二、（执行代码）打开打开redis服务器端

 首先打开redis服务器端：可以测试连接一下：

redis如何从hive中获取数据 redis怎么获取数据_redis如何从hive中获取数据_02

三、测试

1、没有打开redis服务器的话会遇到问题：

问题：Cannot get Jedis connection; nested exception is redis.clients.jedis.exceptions.JedisConnectionException: Failed connecting to host localhost:6379   如下图

redis如何从hive中获取数据 redis怎么获取数据_序列化_03

 原因：没有打开redis服务器   解决方法：在Linux打开redis服务器即可

2、打开redis之后遇到问题：

NOAUTH Authentication required.; nested exception is redis.clients.jedis.exceptions.JedisDataException: NOAUTH Authentication required.

redis如何从hive中获取数据 redis怎么获取数据_java_04

 查看了很多解决方法（以下5个方法自己根据情况对着排除）：1）、原因1说因为服务器端设置密码了，配置文件却没有写上（排除）  2）、防火墙没有关闭（本来就是关闭状态 排除） 3）、服务器设置密码，要将密码注释掉（虽然觉得不应该呀  但是还是尝试了一下  没有用）4）、原因4说识别不出来配置文件的代码，让在代码上添加连接的主机号和密码（如 下图）

redis如何从hive中获取数据 redis怎么获取数据_java_05

5）方法：更改tomcat的conf目录下的context.xml，添加如下代码

redis如何从hive中获取数据 redis怎么获取数据_java_06

亲测！！！以上5个办法都对我没有用！！！ （当然，还是要一一排除的  有问题的时候不要直接不排除就不测试以上5个问题。）

最后  我查看配置文件application.yml的时候发现我的redis配置都是自动匹配到上两行的servlet，所以我就将其置顶格了。然后我就成功连接了啦！！

redis如何从hive中获取数据 redis怎么获取数据_redis如何从hive中获取数据_07

原因图：

redis如何从hive中获取数据 redis怎么获取数据_序列化_08

解决后的配置文件图：

redis如何从hive中获取数据 redis怎么获取数据_redis