当前位置: 首页 > 知识库问答 >
问题:

库中的客户机核心存储数据在哪里?

南宫书
2023-03-14
  • 波姆。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);
    }

  
}

>

  • Rest

    创建:

    @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发送命令时,我不会通过查询的键获得答案。

    但是,当应用程序运行时,数据会被保存并读取。

    停止应用程序然后启动应用程序后,数据丢失。

    此外,我使用插件redissimple。如果我从redis cli工作,我会在那里看到数据。当我在应用程序中工作时,我看不到这些数据。

    请大家给我解释一下。我必须如何配置我的应用程序。

  • 共有1个答案

    吴镜
    2023-03-14

    您没有设置密钥序列化器,因此它使用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无法持久化,因为它没有足够的文件权限将数据保存在目录中。

     类似资料:
    • 它是否将其存储在缓存中?我有一个应用程序,但应用程序中没有任何地方。属性是提到的db详细信息。我可以通过邮递员存储数据和查询它。

    • 问题内容: 我已经卸载了wamp服务器,现在我需要恢复数据库。我该如何做? 问题答案: 无论如何,您都可以知道: 感谢MySql论坛的Barry Galbraith http://forums.mysql.com/read.php?10,379153,379167#msg-379167

    • 问题内容: 因此,我最近才开始学习有关数据库如何工作,如何使用SQL ect的知识。并决定开始在我的Java应用程序(特别是H2数据库)中实现嵌入式数据库,并且在我编写代码的计算机上似乎运行良好。 当我移到另一台计算机上继续进行编码时,我注意到,即使我移植了嵌入式数据库文件(h2-*。jar),我在第一台计算机上创建的所有准备好的表也不在第二台计算机上存在。我以某种方式先入为主,即通过数据库引擎生

    • 我有一个多租户数据库。共享数据库有一个租户配置表,该表保存所有租户信息 每个租户数据库都有一个插入触发器,该触发器将新记录插入到将租户id附加到该记录的核心数据库中。 我需要知道插入来自哪个租户数据库,以便能够根据执行该过程的数据库设置租户id。 是否有一个唯一的ID相关的每个数据库,我可以依赖?

    • 问题内容: 因此,我有了这种elasticsearch安装,可以在用logstash插入数​​据时使用kibana可视化它们。 conf文件中的所有内容均已注释,因此它使用的是相对于elasticsearch文件夹的默认文件夹。 这怎么可能? 但是,此命令将删除数据: 谢谢。 ps:忘了说我在窗户上 问题答案: 如果您在Linux上安装了ES,则默认数据文件夹位于(CentOS)或(Ubuntu)

    • 我将redis用于发布/订阅以及服务器端缓存。我的意思是,我的应用服务器将redis服务器作为一个进程运行(也可以作为缓存)。我有几个瘦客户端(运行redis client)以发布/订阅模式连接到此应用服务器。我想知道redis在哪里存储缓存数据?单独在服务器中,或者在客户端中也会有一个副本。如果有近100个Redis客户端通过发布/订阅通道连接到服务器,那么以这种方式使用Redis也是一个好主意