【day07】springboot+redis

 <!--redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

yml文件，数据库名database和密码password不要写，库名不指定默认为db0，密码不指定默认为空

spring:
  datasource:
    url: jdbc:oracle:thin:@192.168.0.141:1522:orcl19c
    driver-class-name: oracle.jdbc.OracleDriver
    username: DDZNPF
    password: DDZNPF
  redis:
    # redis数据库索引(默认为0)，我们使用索引为3的数据库，避免和其他数据库冲突
#    database: 3
    # redis服务器地址（默认为localhost）
    host: 127.0.0.1
    # redis端口（默认为6379）
    port: 6379
    # redis访问密码（默认为空）
    password:
    # redis连接超时时间（单位毫秒）
    connect-timeout: 10000
    # redis连接池配置
    jedis:
      pool:
        # 最大可用连接数（默认为8，负数表示无限）
        max-active: 8
        # 最大空闲连接数（默认为8，负数表示无限）
        max-idle: 8
        # 最小空闲连接数（默认为0，该值只有为正数才有用）
        min-idle: 0
        # 从连接池中获取连接最大等待时间（默认为-1，单位为毫秒，负数表示无限）
        max-wait: -1

Redisutil工具类

package com.example.ddznpf.util;

import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Service;

@Service
public class RedisUtil {
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存设置时效时间
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime, TimeUnit timeUnit) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, timeUnit);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 批量删除对应的value
     *
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 批量删除key
     *
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0) {
            redisTemplate.delete(keys);
        }
    }

    /**
     * 删除对应的value
     *
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 判断缓存中是否有对应的value
     *
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 读取缓存
     *
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * 哈希 添加
     *
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.put(key, hashKey, value);
    }

    /**
     * 哈希获取数据
     *
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.get(key, hashKey);
    }

    /**
     * 列表添加
     *
     * @param k
     * @param v
     */
    public void lPush(String k, Object v) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k, v);
    }

    /**
     * 列表获取
     *
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List<Object> lRange(String k, long l, long l1) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(k, l, l1);
    }

    /**
     * 集合添加
     *
     * @param key
     * @param value
     */
    public void add(String key, Object value) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key, value);
    }

    /**
     * 集合获取
     *
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.members(key);
    }

    /**
     * 有序集合添加
     *
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }

    /**
     * 有序集合获取
     *
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    }
}

controller层，遇到的问题：将逻辑写到util里，然后controller中new一个util，调用方法，会报空指针异常，初步猜想可能是因为我重新new一个实例，redisutil则会自动注入失败，所以还是老老实实的把逻辑写在controller层吧。

@RestController
@RequestMapping("/dingTalkLogin")
public class DingtalkLoginController extends BaseController {
    /**
     * @Description: 获取企业内部应用的access_token
     * @Param: [app_key，app_secret]
     * @return: java.lang.Object
     * @Author: 宋泽美
     * @Date: 2021/3/15
     */
    @RequestMapping(value = "/getAccessToken")
    public Object getAccessToken() {
        PageData pd = this.getPageData();
        String access_token = "";
        Result result = null;
        try {
            //查询缓存中是否存在
            String redis_key = "access_token";
            boolean hasKey = redisUtil.exists(redis_key);
            if (hasKey) {
                //获取缓存
                Object object = redisUtil.get(redis_key);
                access_token = object.toString();
                System.out.println("redis中有token，从redis缓存获取数据：" + access_token);
                result = new Result(ResultCode.SELECT_SUCCESS.getCode(), ResultCode.SELECT_SUCCESS.getMsg(), access_token);
            } else {
                //访问钉钉接口获取token
                DingTalkClient client = new DefaultDingTalkClient("https://oapi.dingtalk.com/gettoken");
                OapiGettokenRequest request = new OapiGettokenRequest();
                request.setAppkey(pd.getString("app_key"));//app_key
                request.setAppsecret(pd.getString("app_secret"));//app_secret
                request.setHttpMethod("GET");
                OapiGettokenResponse response = client.execute(request);
                String body = response.getBody();
                PageData pageData = JSONObject.parseObject(body, PageData.class);
                System.out.println(pageData);
                access_token = pageData.getString("access_token");
                System.out.println("redis中无token，访问钉钉接口获取数据：" + access_token);
                result = new Result(ResultCode.SELECT_SUCCESS.getCode(), ResultCode.SELECT_SUCCESS.getMsg(), access_token);
                //数据插入缓存（set中的参数含义：key值，user对象，缓存存在时间10（long类型），时间单位）
                boolean set = redisUtil.set(redis_key, access_token, 2L, TimeUnit.HOURS);
                if (set) {
                    System.out.println("access_token插入redis缓存-成功");
                } else {
                    System.out.println("access_token插入redis缓存-失败");
                }
            }
        } catch (Exception e) {
            //打印输出异常
            e.printStackTrace();
        }
        return result;
    }

基础controller层代码

public class BaseController {

    /**
     * 注入全部service
     */
    @Autowired
    protected PfTemplateService pfTemplateService;
    @Autowired
    protected PfProjectService pfProjectService;
    @Autowired
    protected PfProjectScoreService pfProjectScoreService;
    @Autowired
    protected PfActivityService pfActivityService;
    @Autowired
    protected PfActivityUserService pfActivityUserService;
    @Autowired
    protected PfPsyCprService pfPsyCprService;
    @Autowired
    protected PfActivityScoreService pfActivityScoreService;
    @Autowired
    protected RedisUtil redisUtil;

    protected PageData pd;

    /**
     * 创建session、Request、Response等对象
     */
    protected HttpServletRequest request;
    protected HttpServletResponse response;
    protected HttpSession session;

    /**
     * 在每个子类方法调用之前先调用
     * 设置request,response,session这三个对象
     */
    @ModelAttribute
    public void setReqAndRes(HttpServletRequest request, HttpServletResponse response) {
        this.request = request;
        this.response = response;
        this.session = request.getSession(true);
    }

    /**
     * 得到32位的uuid
     *
     * @return
     */
    public String get32UUID() {
        return UuidUtil.get32UUID();
    }

    /**
     * new PageData对象
     *
     * @return
     */
    public PageData getPageData() {
        return new PageData(this.getRequest());
    }

    /**
     * 得到request对象
     *
     * @return
     */
    public HttpServletRequest getRequest() {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        return request;
    }
}

Redis可视化工具
下载地址