java简单实现Redis增删查接口

Redis安装

可以去官网下载,也可以用我准备好的Redis

Redis安装包

链接：https://pan.baidu.com/s/1g75dtn5EJZ7tXdTcWTACCw 
提取码：8f65

 下载后解压, 之后双击redis-server.exe打开客户端(不要关,除非不需要了)

打开自己的项目,找到 application.properties

添加

spring.redis.host=localhost
spring.redis.port=6379

 一般来说刚开始都是没有密码的,默认的端口号就是6379

Redis依赖

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

lombok依赖

        <!--data注解-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

JSON依赖

   <!--fastjson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>

RedisConfig.java

package com.qc.sai.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
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.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

@Configuration
public class RedisConfig {


    /**
     * redis配置
     *
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        // 实例化redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        //设置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // key采用String的序列化
        redisTemplate.setKeySerializer(keySerializer());
        // value采用jackson序列化
        redisTemplate.setValueSerializer(valueSerializer());
        // Hash key采用String的序列化
        redisTemplate.setHashKeySerializer(keySerializer());
        // Hash value采用jackson序列化
        redisTemplate.setHashValueSerializer(valueSerializer());
        //执行函数，初始化RedisTemplate
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    /**
     * key类型采用String序列化
     *
     * @return
     */
    private RedisSerializer<String> keySerializer() {
        return new StringRedisSerializer();
    }

    /**
     * value采用JSON序列化
     *
     * @return
     */
    private RedisSerializer<Object> valueSerializer() {
        //设置jackson序列化
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        //设置序列化对象
        jackson2JsonRedisSerializer.setObjectMapper(getMapper());
        return jackson2JsonRedisSerializer;
    }


    /**
     * 使用com.fasterxml.jackson.databind.ObjectMapper
     * 对数据进行处理包括java8里的时间
     *
     * @return
     */
    private ObjectMapper getMapper() {
        ObjectMapper mapper = new ObjectMapper();
        //设置可见性
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        //默认键入对象
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        //设置Java 8 时间序列化
        JavaTimeModule timeModule = new JavaTimeModule();
        timeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        timeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
        timeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
        timeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        timeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
        timeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
        //禁用把时间转为时间戳
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        mapper.registerModule(timeModule);
        return mapper;
    }
}

controller.java

@RestController
@RequestMapping("/sai")
public class SaiController {

    @Autowired
    private SaiService saiService;

    @GetMapping("/getAppVersion")
    public Result<AppVersion> getAppVersion(@RequestParam("key") String key){
        return Result.success(saiService.getAppVersion(key));
    }

    @PostMapping("/insertAppVersion")
    public Result<Void> insertAppVersion(@RequestParam("key") String key,
                                         @RequestBody AppVersion appVersion){
        saiService.insertAppVersion(key, appVersion);
        return Result.success("添加成功");
    }

    @GetMapping("/deleteAppVersion")
    public Result<Void> deleteAppVersion(@RequestParam("key") String key){
        saiService.deleteAppVersion(key);
        return Result.success("删除成功");
    }
}

pojo

@Data
@AllArgsConstructor
@NoArgsConstructor
public class AppVersion implements Serializable {

    private String appId;
    private String curVersion;

    private String bgUrl;
    private String title;
    private String subTitle;
    private String downloadUrl;

}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Result<T> {

    private int code;
    private String msg;
    private T data;

    public static <T> Result<T> success() {
        return success(null);
    }
    public static <T> Result<T> success(String msg) {
        return success(msg, null);
    }
    public static <T> Result<T> success(T t) {
        return success("请求成功", t);
    }
    public static <T> Result<T> success(String message, T t) {
        return new Result<>(200, message, t);
    }

    public static <T> Result<T> fail() {
        return fail(400, "请求失败");
    }
    public static <T> Result<T> fail(int code, String message) {
        return new Result<>(code, message, null);
    }

}

service

public interface SaiService {

    AppVersion getAppVersion(String key);

    void insertAppVersion(String key, AppVersion appVersion);

    void deleteAppVersion(String key);
}

serviceImpl

@Service
public class SaiServiceImpl implements SaiService {

   @Resource
    private RedisTemplate<String, AppVersion>  redisTemplate;

    @Override
    public AppVersion getAppVersion(String key) {
        AppVersion res = redisTemplate.opsForValue().get(key);
        return res;
    }

    @Override
    public void insertAppVersion(String key, AppVersion appVersion){
        redisTemplate.opsForValue().set(key, appVersion);
    }

    @Override
    public void deleteAppVersion(String key) {
        redisTemplate.delete(key);
    }


}

每个接口可以在redis中测试

在刚才解压的redis文件夹中,找到redis-cli.exe双击打开

然后输入 keys *可以查看所有的key,,,,可以看刚才的key是不是存进去了

当然也可以用 exists  key  来查询key是不是存在