莴苣核心库中的客户端莴苣在哪里存储数据？

问题描述

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>redis</groupId>
    <artifactId>spring-data-redis-example</artifactId>
    <version>0.0.1</version>
    <packaging>jar</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>

        <version.mapstruct>1.3.0.Final</version.mapstruct>
        <version.apache.maven.plugins>3.8.1</version.apache.maven.plugins>
    </properties>

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

    <!--    <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.3.0</version>
        </dependency>-->


    <!--    <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.8.1</version>
        </dependency>-->


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
            <version>5.3.3.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct</artifactId>
            <version>${version.mapstruct}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>

            <plugin> 
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${version.apache.maven.plugins}</version>
                <groupId>org.apache.maven.plugins</groupId>

                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <annotationProcessorPaths>
                        <path>
                            <groupId>org.mapstruct</groupId>
                            <artifactId>mapstruct-processor</artifactId>
                            <version>${version.mapstruct}</version>
                        </path>
                    </annotationProcessorPaths>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

这是一个配置文件java。

@Configuration
public class RedisConfig {

    @Value("${spring.redis.host}")
    private String hostName;

    @Bean
    LettuceConnectionFactory lettuceConnectionFactory() {

        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();

        redisStandaloneConfiguration.setHostName(this.hostName);

        LettuceConnectionFactory lettuceConnectionFactory =
                new LettuceConnectionFactory(redisStandaloneConfiguration);


        return lettuceConnectionFactory;
    }

    @Bean
    public RedisTemplate<String,Object> redisTemplate() {
        final RedisTemplate<String,Object> template = new RedisTemplate<>();
        template.setConnectionFactory(lettuceConnectionFactory());
        template.setValueSerializer(new GenericToStringSerializer<>(Object.class));
        return template;
    }

    /**
     * <b>MessageSubscriber</b> is  a implementation
     * of {@link org.springframework.data.redis.connection.MessageListener}
     * The MessageSubscriber is developed in the app
     * @return
     */
    @Bean
    MessageListenerAdapter messageListener() {
        return new MessageListenerAdapter(new MessageSubscriber());
    }


    @Bean
    RedisMessageListenerContainer redisContainer() {

        final RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(lettuceConnectionFactory());
        container.addMessageListener(messageListener(),topic());
        return container;
    }

    /**
     * <b>MessagePublisherImpl</b> is a implementation of {@link redis.service.message.MessagePublisher}
     * The MessagePublisher is developed in the application
     * @return
     */
    @Bean
    MessagePublisher redisPublisher() {

        return new MessagePublisherImpl(redisTemplate(),topic());
    }

    @Bean
    ChannelTopic topic() {
        return new ChannelTopic("pubsub:queue");
    }
}

这是Redis服务器的配置文件

bind 0.0.0.0
protected-mode yes
port 6379
tcp-backlog 511
timeout 0
tcp-keepalive 300
pidfile /var/run/redis/redis-server.pid
loglevel notice
logfile /data/log/redis-server.log
databases 16
always-show-logo yes
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb
dir /data/bases
slave-serve-stale-data yes
slave-read-only yes
repl-diskless-sync no
repl-diskless-sync-delay 5
repl-disable-tcp-nodelay no
slave-priority 100
lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
slave-lazy-flush no
appendonly yes
appendfilename "appendonly.aof"
appendfsync everysec
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes
aof-use-rdb-preamble no
lua-time-limit 5000
slowlog-log-slower-than 10000
slowlog-max-len 128
latency-monitor-threshold 0
notify-keyspace-events ""
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
list-max-ziplist-size -2
list-compress-depth 0
set-max-intset-entries 512
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
hll-sparse-max-bytes 3000
activerehashing yes
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit slave 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
hz 10
aof-rewrite-incremental-fsync yes

存储库

@Repository
public class RedisRepositoryImpl implements RedisRepository {
    private static final String KEY = "Movie";
    
    private RedisTemplate<String,Object> redisTemplate;
    private HashOperations hashOperations;
    
    @Autowired
    public RedisRepositoryImpl(RedisTemplate<String,Object> redisTemplate){
        this.redisTemplate = redisTemplate;
    }

    @PostConstruct
    private void init(){
        hashOperations = redisTemplate.opsForHash();
    }
    
    public void add(final Movie movie) {
        hashOperations.put(KEY,movie.getId(),movie.getName());
    }

    public void delete(final String id) {
        hashOperations.delete(KEY,id);
    }
    
    public Movie findMovie(final String id){
        return (Movie) hashOperations.get(KEY,id);
    }
    
    public Map<Object,Object> findAllMovies(){
        return hashOperations.entries(KEY);
    }

  
}

休息
创建：

@RestController
@RequestMapping("api")
public class CreateRestController {

    private RedisCreateService service;

    @Autowired
    public CreateRestController(RedisCreateService service) {
        this.service = service;
    }

    @PostMapping("keys")
    public ResponseEntity<String> add( @RequestParam String key,@RequestParam String value){

        service.add(key,value);

        return new ResponseEntity<>(HttpStatus.OK);
    }
}

阅读：

@RestController
@RequestMapping("api")
public class ReadRestController {

    private RedisReadService service;

    @Autowired
    public ReadRestController(RedisReadService service) {
        this.service = service;
    }

    @GetMapping("values")
    public @ResponseBody Map<String,String> findAll(){

        Map<String,String> all = service.getAll();

        return all;
    }

    @RequestMapping("keys/all")
    public @ResponseBody Map<String,String> keys() {

        Map<String,String> keys = service.getKeys();

        return keys;
    }
}

数据已保存并读取得很好。我假定它们已保存到具有内存实现的redis数据库中，尽管我没有专门配置。我推断是因为当我通过redis-cli发送命令时，无法通过查询的键得到答案。

但是，当应用程序运行时，数据将被保存并正在读取。

在停止应用程序然后启动应用程序之后，数据已丢失。

此外，我使用插件-redis简单。如果我在redis-cli上工作，我会看到数据。在应用程序中工作时，看不到此数据。

请任何人向我解释一下。我必须如何配置我的应用程序。

解决方法

您没有设置密钥序列化程序，因此它使用JDK序列化程序作为默认值。因此，密钥实际上并未在Redis服务器中存储为String。

在配置中将有关redis的代码更改为此，然后重试。

    @Bean
public RedisTemplate<String,Object> redisTemplate() {
    final RedisTemplate<String,Object> template = new RedisTemplate<>();
    template.setConnectionFactory(lettuceConnectionFactory());
    template.setKeySerializer(new GenericToStringSerializer<>(Object.class));
    template.setValueSerializer(new Jackson2JsonRedisSerializer<>(Object.class));
    return template;
}

默认情况下，Redis应该具有持久性，重新启动后您应该会看到数据。如果不是，请检查您的redis日志并找到其中的信息。以前，我看到redis无法持久，因为它没有足够的文件权限来将数据保存在目录中。

docker java java lettuce redis spring-boot

莴苣核心库中的客户端莴苣在哪里存储数据？

问题描述

解决方法

相关问答