君哥聊编程
君哥聊编程

SpringBoot2+Redis动态切换db数据源(db)最佳实践

动态DB切换代码已开源，有用star一下
https://github.com/it235/knife4j-redis-lettuce

需求

在使用Redis的时候，默认是16个库，非常小的项目默认0库就够了，但是对于体量稍微大一些的项目，需要将其他各个库充分利用，比如：

  • db0存公用的热点缓存
  • db1存商品服务的缓存
  • db2存订单相关的缓存
  • db3存库存相关的缓存
  • …

这个时候我们就需要实现多库切换进行操作，接下来我们看看如何在SpringBoot中实现多DB的切换动作。

实现

lettuce默认实现(只能取1个db)

  • 添加Maven依赖（版本默认采用当前parent的）
    <dependencies>
        <dependency>
            <groupId>com.fasterxml.jackson.coregroupId>
            <artifactId>jackson-databindartifactId>
        dependency>
        <dependency>
            <groupId>org.apache.commonsgroupId>
            <artifactId>commons-pool2artifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redis-reactiveartifactId>
        dependency>
    dependencies>
  • yml配置
    spring:
  redis:
    host: 192.168.0.245
    password: 123456
    port: 6379
    database: 1 # 使用库 1
    timeout: 60s
    lettuce: # lettuce基于netty，线程安全，支持并发
      pool:
        max-active: 8
        max-wait: -1ms
        max-idle: 2
        min-idle: 0
  • Configuration配置
    
import com.alibaba.fastjson.parser.ParserConfig;
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.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@EnableCaching
@Configuration
public class FastJsonRedisConfig {

    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String,Object> template = new RedisTemplate <>();
        template.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>();
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

以上我们就可以注入restTemplate进行redis的相关操作了，这样做只能满足最基本的取db0的操作，如果要使用到其他库，接下来我们看第二种方案

动态切换DB

源码：https://github.com/it235/knife4j-redis-lettuce

思路

如果要动态切换DB，我们需要考虑以下几个问题：

  • DB个数该如何指定？比如项目只采用0-5库
  • DB切换时直接用一个redisTemplate是否可以？
  • DB1切换到DB2后，其他线程如果要继续使用DB1该如何选取？
  • 工具类该如何封装？

构思：接下来我构思来解决上面几个问题

  1. DB个数指定，我们能否通过yml配置文件指定个数，比如：[0,1,2,3,4,5,6]这样
  2. DB切换时redisTemplate一个显然可以，代码如下，但不是特别合适，因为database的指定是在connectionFactory.setDatabase(num);这里完成，所以我们需要操作连接工厂，通过最上面实现的代码可以看到，factory是由redisTemplate去指定的template.setConnectionFactory(factory);，如果我们采用一个redisTemplate的方式，那么我们要不停的进行resetConnection的方式。
    	//不推荐使用该方式
	@Autowired
    private StringRedisTemplate redisTemplate;
 
    public void setDataBase(int num) {
        LettuceConnectionFactory connectionFactory = (LettuceConnectionFactory) redisTemplate.getConnectionFactory();
        if (connectionFactory != null && num != connectionFactory.getDatabase()) {
        	//切换DB
            connectionFactory.setDatabase(num);
            //是否允许多个线程操作共用同一个缓存连接，默认 true，false 时每个操作都将开辟新的连接
            connectionFactory.setShareNativeConnection(false);
            this.redisTemplate.setConnectionFactory(connectionFactory);
            connectionFactory.resetConnection();
        }
    }

这里我们最合适的方式，就是为每个库建立一个单独的redisTemplate，然后通过一个Map维护，需要时告诉我具体的dbNum，我来根据你想要的从池子中取出进行操作即可，这样也不会涉及到db的频繁切换

多redisTemplate难点

  1. 如何通过factory创建多个？
  2. 如何维护Bean的生命周期？yml如何规划
  3. redis工具类该如何定义？

动手实现

  • 第一步，定义理想中的yml
    # 此处Key由spring改为自己定义的
knife4j:
  redis:
    # 是否采用json序列化方式，若不采用jackson序列化
    jsonSerialType: 'Fastjson'
    host: localhost
    password: knife
    port: 6379
    databases: [0,1,2,3,4,5,6] # 要使用的库，会根据此处填写的库生成redisTemplate
    timeout: 60s
    lettuce: # lettuce基于netty，线程安全，支持并发
      pool:
        max-active: 50
        max-wait: -1ms
        max-idle: 8
        min-idle: 0
  • 第二步，读取yml，并创建redisTemplate注入到Spring容器中
    package com.github.it235.register;

/**
 * @description: 根据yml创建redisTemplate并注入到Spring容器
 * @author: www.it235.com
 * @date: Created in 2020/9/27 15:27
 */
public class Knife4jRedisRegister implements EnvironmentAware, ImportBeanDefinitionRegistrar {

    private static final Logger logger = LoggerFactory.getLogger(Knife4jRedisRegister.class);

    private static Map<String, Object> registerBean = new ConcurrentHashMap<>();

    private Environment environment;
    private Binder binder;

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
        this.binder = Binder.get(this.environment);
    }

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        RedisEntity redisEntity;
        try {
            redisEntity = binder.bind("knife4j.redis", RedisEntity.class).get();
        } catch (NoSuchElementException e) {
            logger.error("Failed to configure knife4j redis: 'knife4j.redis' attribute is not specified and no embedded redis could be configured.");
            return;
        }
        boolean onPrimary = true;

        //根据多个库实例化出多个连接池和Template
        List<Integer> databases = redisEntity.getDatabases();
        for (Integer database : databases) {
            //单机模式
            RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
            configuration.setHostName(String.valueOf(redisEntity.getHost()));
            configuration.setPort(Integer.parseInt(String.valueOf(redisEntity.getPort())));
            configuration.setDatabase(database);
            String password = redisEntity.getPassword();
            if (password != null && !"".equals(password)) {
                RedisPassword redisPassword = RedisPassword.of(password);
                configuration.setPassword(redisPassword);
            }

            //池配置
            GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();

            RedisProperties.Pool pool = redisEntity.getLettuce().getPool();
            genericObjectPoolConfig.setMaxIdle(pool.getMaxIdle());
            genericObjectPoolConfig.setMaxTotal(pool.getMaxActive());
            genericObjectPoolConfig.setMinIdle(pool.getMinIdle());
            if (pool.getMaxWait() != null) {
                genericObjectPoolConfig.setMaxWaitMillis(pool.getMaxWait().toMillis());
            }
            Supplier<LettuceConnectionFactory> lettuceConnectionFactorySupplier = () -> {
                LettuceConnectionFactory factory = (LettuceConnectionFactory) registerBean.get("LettuceConnectionFactory" + database);
                if (factory != null) {
                    return factory;
                }
                LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder builder = LettucePoolingClientConfiguration.builder();
                Duration shutdownTimeout = redisEntity.getLettuce().getShutdownTimeout();
                if(shutdownTimeout == null){
                    shutdownTimeout = binder.bind("knife4j.redis.shutdown-timeout", Duration.class).get();
                }
                if (shutdownTimeout != null) {
                    builder.shutdownTimeout(shutdownTimeout);
                }
                LettuceClientConfiguration clientConfiguration = builder.poolConfig(genericObjectPoolConfig).build();
                factory = new LettuceConnectionFactory(configuration, clientConfiguration);
                registerBean.put("LettuceConnectionFactory" + database, factory);
                return factory;
            };

            LettuceConnectionFactory lettuceConnectionFactory = lettuceConnectionFactorySupplier.get();
            BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(LettuceConnectionFactory.class, lettuceConnectionFactorySupplier);
            AbstractBeanDefinition factoryBean = builder.getRawBeanDefinition();
            factoryBean.setPrimary(onPrimary);
            beanDefinitionRegistry.registerBeanDefinition("lettuceConnectionFactory" + database, factoryBean);
            // StringRedisTemplate
            GenericBeanDefinition stringRedisTemplate = new GenericBeanDefinition();
            stringRedisTemplate.setBeanClass(StringRedisTemplate.class);
            ConstructorArgumentValues constructorArgumentValues = new ConstructorArgumentValues();
            constructorArgumentValues.addIndexedArgumentValue(0, lettuceConnectionFactory);
            stringRedisTemplate.setConstructorArgumentValues(constructorArgumentValues);
            stringRedisTemplate.setAutowireMode(AutowireCapableBeanFactory.AUTOWIRE_BY_NAME);
            beanDefinitionRegistry.registerBeanDefinition("stringRedisTemplate" + database, stringRedisTemplate);
            // 定义RedisTemplate对象
            GenericBeanDefinition redisTemplate = new GenericBeanDefinition();
            redisTemplate.setBeanClass(RedisTemplate.class);
            redisTemplate.getPropertyValues().add("connectionFactory", lettuceConnectionFactory);
            redisTemplate.setAutowireMode(AutowireCapableBeanFactory.AUTOWIRE_BY_NAME);
            JsonSerialType jsonSerialType = redisEntity.getJsonSerialType();
            RedisSerializer stringRedisSerializer = null;
            Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = null;
            if(jsonSerialType != null && jsonSerialType == JsonSerialType.Fastjson){
                //若配置，则采用该方式
                jackson2JsonRedisSerializer = new CustomFastJsonRedisSerializer<>(Object.class);
                ParserConfig.getGlobalInstance().setAutoTypeSupport(false);
                stringRedisSerializer = new CustomStringRedisSerializer();
            } else {
                // 内置默认序列化(此处若不设置则采用默认的JDK设置，也可以在使用使自定义序列化方式)
                jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
                ObjectMapper om = new ObjectMapper();
                om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
                om.activateDefaultTyping(om.getPolymorphicTypeValidator(), ObjectMapper.DefaultTyping.NON_FINAL);
                jackson2JsonRedisSerializer.setObjectMapper(om);
                stringRedisSerializer = new StringRedisSerializer();
            }
            // key采用String的序列化方式，value采用json序列化方式
            redisTemplate.getPropertyValues().add("keySerializer",stringRedisSerializer);
            redisTemplate.getPropertyValues().add("hashKeySerializer",stringRedisSerializer);
            redisTemplate.getPropertyValues().add("valueSerializer",jackson2JsonRedisSerializer);
            redisTemplate.getPropertyValues().add("hashValueSerializer",jackson2JsonRedisSerializer);

            //注册Bean
            beanDefinitionRegistry.registerBeanDefinition("redisTemplate" + database, redisTemplate);
            logger.info("Registration redis ({}) !", database);
            if (onPrimary) {
                onPrimary = false;
            }
        }
    }
}
  • 第三步，创建redisManager进行管理redisTemplate
/**
 * @description: 给工具类提供manager，由先的configuration进行初始化和赋值
 * @author: www.it235.com
 * @date: Created in 2020/9/27 15:27
 */
public class Knife4jRedisManager {

    private Map<String, RedisTemplate> redisTemplateMap;

    private Map<String, StringRedisTemplate> stringRedisTemplateMap;

    public Knife4jRedisManager(Map<String, RedisTemplate> redisTemplateMap ,
                               Map<String, StringRedisTemplate> stringRedisTemplateMap) {
        this.redisTemplateMap = redisTemplateMap;
        this.stringRedisTemplateMap = stringRedisTemplateMap;
    }

    public RedisTemplate redisTemplate(int dbIndex) {
        RedisTemplate redisTemplate = redisTemplateMap.get("redisTemplate" + dbIndex);
        return redisTemplate;
    }

    public StringRedisTemplate stringRedisTemplate(int dbIndex) {
        StringRedisTemplate stringRedisTemplate = stringRedisTemplateMap.get("stringRedisTemplate" + dbIndex);
        stringRedisTemplate.setEnableTransactionSupport(true);
        return stringRedisTemplate;
    }

    public Map<String, RedisTemplate> getRedisTemplateMap() {
        return redisTemplateMap;
    }

    public Map<String, StringRedisTemplate> getStringRedisTemplateMap() {
        return stringRedisTemplateMap;
    }
}
  • 第四部，创建Configuration，管理redisTemplate，加载redisManager
/**
 * @description: 核心配置，取出spring中的redisTemplate暂存到map中，并初始化redisManager
 * @author: www.it235.com
 * @date: Created in 2020/9/27 15:27
 */
@AutoConfigureBefore({RedisAutoConfiguration.class})
@Import(Knife4jRedisRegister.class)
@EnableCaching
@Configuration
public class Knife4jRedisConfiguration implements EnvironmentAware , ApplicationContextAware {

    private static final Logger logger = LoggerFactory.getLogger(Knife4jRedisConfiguration.class);

    private static String key1 = "redisTemplate";
    private static String key2 = "stringRedisTemplate";

    Map<String, RedisTemplate> redisTemplateMap = new HashMap<>();
    Map<String, StringRedisTemplate> stringRedisTemplateMap = new HashMap<>();
    private Binder binder;
    private Environment environment;

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
        this.binder = Binder.get(this.environment);
    }
    @PostConstruct
    public Map<String,RedisTemplate> initRedisTemplate(){
        RedisEntity redisEntity;
        try {
            redisEntity = binder.bind("knife4j.redis", RedisEntity.class).get();
        } catch (NoSuchElementException e) {
            throw new RuntimeException("Failed to configure knife4j redis: 'knife4j.redis' attribute is not specified and no embedded redis could be configured.");
        }

        //根据多个库实例化出多个连接池和Template
        List<Integer> databases = redisEntity.getDatabases();
        if(databases == null || databases.size() == 0){
            logger.warn("no config property knife4j.redis.databases , default use db0！！！");
            databases.add(0);
        }

        //根据指定的数据库个数来加载对应的RedisTemplate
        for (Integer database : databases) {
            String key = key1 + database;
            RedisTemplate redisTemplate = applicationContext.getBean(key , RedisTemplate.class);
            if(redisTemplate != null){
                redisTemplateMap.put(key , redisTemplate);
            }

            key = key2 + database;
            if(stringRedisTemplateMap != null){
                StringRedisTemplate stringRedisTemplate = applicationContext.getBean(key , StringRedisTemplate.class);
                stringRedisTemplateMap.put(key , stringRedisTemplate);
            }
        }
        if(redisTemplateMap.size() == 0 && stringRedisTemplateMap.size() == 0){
            throw new RuntimeException("load redisTemplate failure , please check knife4j.redis property config！！！");
        }
        return redisTemplateMap;
    }

    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }


    @Bean
    public Knife4jRedisManager knife4jRedisManager(){
        return new Knife4jRedisManager(redisTemplateMap , stringRedisTemplateMap);
    @Bean
    public RedisBaseUtil redisBaseUtil(){
        return new RedisBaseUtil();
    }
}

spring.factories配置

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.github.it235.config.Knife4jRedisConfiguration\
  • 第五部，编写工具类

/**
 * @description: redis工具类基类，集成通用的方法，由`configuration`进行初始化
 * @author: jianjun.ren
 * @date: Created in 2020/9/27 11:20
 */
public class RedisBaseUtil {

    @Autowired
    protected Knife4jRedisManager knife4jRedisManager;

    protected int defaultDB = 0;

    public void delete(String key) {
        delete(0,key);
    }
    public void delete(int dbIndex ,String key) {
        knife4jRedisManager.redisTemplate(dbIndex).delete(key);
    }

    public boolean set(String key, Object value) {
        return set(0,key,value);
    }
    public boolean set(int dbIndex ,String key, Object value) {
        try {
            knife4jRedisManager.redisTemplate(dbIndex).opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    public void delete(Collection keys){
        delete(defaultDB , keys);
    }
    public void delete(int dbIndex ,Collection keys){
        knife4jRedisManager.redisTemplate(dbIndex).delete(keys);
    }

    public Set getKeys(String redisKey) {
        return getKeys(0,redisKey);
    }
    public Set getKeys(int dbIndex ,String redisKey) {
        Set keys = knife4jRedisManager.redisTemplate(dbIndex).opsForHash().keys(redisKey);
        Set retKeys = new HashSet<>();
        for (Object key : keys) {
            retKeys.add(String.valueOf(key));
        }
        return retKeys;
    }

    /**
     * 每个redis
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        return expire(defaultDB , key,time);
    }
    public boolean expire(int dbIndex ,String key, long time) {
        try {
            if (time > 0) {
                knife4jRedisManager.redisTemplate(dbIndex).expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(int dbIndex , String key) {
        return knife4jRedisManager.redisTemplate(dbIndex).getExpire(key, TimeUnit.SECONDS);
    }
    public long getExpire(String key) {
        return getExpire(defaultDB , key);
    }
    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        return hasKey(defaultDB , key);
    }
    public boolean hasKey(int dbIndex ,String key) {
        try {
            return knife4jRedisManager.redisTemplate(dbIndex).hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
}


    

  • 编写测试类
    • 



@RestController
@RequestMapping("/test")
public class RedisTestController {

    @Autowired
    private RedisBaseUtil redisBaseUtil;

    /**
     * 单值操作测试
     * @param key
     * @return
     */
    @GetMapping("/val/{key}")
    public String test(@PathVariable("key") String key){
        redisBaseUtil.set(key , "默认库设置");
        redisBaseUtil.set(1 , key , "指定1库设置值");
        //查看key是否存在
        boolean flag = redisValUtil.hasKey(1, key);
        System.out.println("指定1库获取值：" + flag);
        return "ok";
    }
}



到此测试并查看数据库，就会发现，基础功能已经完成了。
 如果有帮助，别忘了star三连：https://github.com/it235/knife4j-redis-lettuce

























你可能感兴趣的:(#,SpringBoot2.0,redis,spring,boot,动态切换Redis数据源DB)






    

  • python-记录字符串种字符出现次数
酸辣小太阳.
python入门python算法

    该类题目用字典明显方便，先上代码：s=input("请输入一个字符串:")num={}foriins:num[i]=s.count(i)forkey,valueinnum.items():print('{key}:{value}次'.format(key=key,value=value))运行结果：这里有几个值得关注的点：1.为字典添值前，需要先创建字典，这里num={}是动态创建，2.计数可以直
    

    • 

  • qt C++ 连接西门子PLC，读取整个DB块数据
忒可君
数据库qtc++

    在QtC++中连接西门子PLC并读取整个DB块的数据，可以使用第三方库Snap7。以下是一些关键步骤和代码示例：建立连接：首先需要使用ConnectTo方法建立与PLC的连接。你需要提供PLC的IP地址、机架号（rack）和插槽号（slot）。intreg=client->ConnectTo("192.168.0.1",0,1);if(reg==0){qDebug()DBRead(1,0,size
    

    • 

  • MongoDB ：第五章：MongoDB 插入更新删除查询文档
2401_84558091
作者\/mongodb数据库

    “_id”:ObjectId(“56064f89ade2f21f36b03136”),“title”:“MongoDB”,“description”:“MongoDB是一个Nosql数据库”,“by”:“菜鸟教程”,“url”:“http://www.runoob.com”,“tags”:[“mongodb”,“database”,“NoSQL”],“likes”:100}可以看到标题(title
    

    • 

  • 这可能是全网最详细的 Spring Cloud OAuth2 单点登录使用教程了，妈妈再也不用担心我被面试官吊打了！
2401_84558091
程序员java面试学习

    最后对于很多Java工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。再分享一波我的Java面试真题+视频学习详解+技能进阶书籍本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收
    

    • 

  • mysql mha自动切换_mha+mysql自动切换
佐罗 先生
mysqlmha自动切换

    manager:192.168.2.254master:192.168.2.252slave:192.168.2.253VIP:192.168.2.144操作系统：centos6.564位1.配置ssh互信(root用户每台都执行)#ssh-keygen#ssh-copy-id192.168.2.252#ssh-copy-id192.168.2.253#ssh-copy-id192.168.2.2
    

    • 

  • mysql的双机热备自动切换_mysql双主热备宕机自动切换
weixin_39621794
mysql的双机热备自动切换

    一、定义通常说的「双机热备」是指两台机器都在运行，但并不是两台机器都同时在提供服务。当提供服务的一台出现故障的时候，另外一台会马上自动接管并且提供服务，而且切换的时间非常短。二、原理Keepalived的工作原理是VRRP(VirtualRouterRedundancyProtocol)虚拟路由冗余协议。在VRRP中有两组重要的概念：VRRP路由器和虚拟路由器，主控路由器和备份路由器。VRRP路由
    

    • 

  • 服务器每秒钟执行命令数量是什么_Redis的内部运作机制
weixin_39753791
服务器每秒钟执行命令数量是什么

    本文将分五个部分来分析和总结Redis的内部机制，分别是：Redis数据库、Redis客户端、Redis事件、Redis服务器的初始化步骤、Redis命令的执行过程。首先介绍一下Redis服务器的状态结构。Redis使用一个类型为“redisServer”的数据结构来保存整个Redis服务器的状态(每个属性按照即将讲解的顺序进行排序)：structredisServer{intdbnum;//服务
    

    • 

  • Redis的各种机制
LLYYYYSS
redisredis

    一、Redis的持久化机制1.简介Redis有两种持久化机制，分别是RDB和AOF，RDB：每个一段时间保存一个快照；AOF：保存每次写的操作指令；2.RDB（1）RDB的概念RDB：每隔一段时间，把内存中的数据写入磁盘的临时文件，作为快照，恢复的时候把快照文件读进内存。如果宕机重启，那么内存里的数据肯定会没有的，因为RDB的存在，那么重启redis后，则会恢复。（2）备份与恢复备份：内存备份--
    

    • 

  • Redis缓存机制(详解)
就是有缘人
redis缓存数据库

    1.Redis是什么?*redis是*一个运行在内存上的key-value存储系统。是NoSQL数据库之一2.缓存穿透,缓存击穿,缓存雪崩/**缓存穿透*/它会先查询Redis,Redis没有会查询数据库,数据库也没有这就是缓存穿透业界主流解决方案:布隆过滤器布隆过滤器的使用步骤布隆过滤器的使用步骤:1.针对现有所有数据,生成布隆过滤器2.在业务逻辑层,判断Redis之前先检查这个id是否在布隆过
    

    • 

  • NoSQL之REDIS配置与优化
m0_73868728
nosqlredis数据库

    一、Redis简介Redis（RemoteDictionaryServer）是一个开源的、使用C语言编写的NoSQL数据库，它基于内存运行并支持持久化，采用key-value的存储形式。Redis因其高性能、丰富的数据类型支持和原子性操作而广泛应用于缓存、实时分析系统、排行榜等多种场景。二、Redis的安装1.使用包管理器安装对于大多数Linux发行版，可以使用包管理器直接安装Redis。例如，在
    

    • 

  • 【深入学习Redis丨第三篇】深入详解Redis高可用集群模式
陈橘又青
深入学习Redis学习redis数据库高可用集群

    前言本文我们将介绍Redis的四种模式及各自优缺点分析。Redis一共4种模式：1、主从复制模式2、(Sentinel)哨兵模式3、(Cluster)集群模式4、代理模式文章目录前言1.**主从模式****1.1简介****1.2工作机制**2.**哨兵模式****2.1简介****2.2工作机制****2.3注意点**3.**Cluster模式****3.1简介****3.2工作机制****3.
    

    • 

  • MySQL-MHA手动切换
泰山与水
#MySQLmysql数据库服务器

    环境检查当前数据库集群环境运行状态，包括主从复制状态和SSH能力检查主从复制状态在MHA的manager服务器执行命令：asterha_check_repl--conf={MHA路径}/conf/app.cnf检查主从SSH服务在MHA的manager服务器执行命令：masterha_check_ssh--conf={MHA路径}/conf/app.cnf校验主库和其他从库的GTID一致性获取主从
    

    • 

  • 数据库有关c语言
h海棠溪
数据库学习c语言linux

    数据库的概念SQL（StructuredQueryLanguage）是一种专门用来与数据库进行交互的编程语言，它允许用户查询、更新和管理关系型数据库中的数据。关系型数据库是基于表（Table）的数据库，其中表由行（Row）和列（Column）组成，每一行代表一个记录（Record），每一列代表一个字段（Field）。非关系型数据库MongoDB1、分类：大型中型小型ORACLEMYSQL/MSSQ
    

    • 

  • C语言详细笔记--动态存储分配
Jasmine5606
C语言c语言笔记算法c#开发语言

    动态存储分配是指程序运行过程中在需要时显示地申请内存空间、在不需要时释放内存空间的一种方法。通过使用动态存储分配，程序员可以在函数执行部分的任何地方使用动态存储分配函数或者回收内存空间，从而有效地使用内存空间。目录一、malloc()函数二、free()函数一、malloc()函数malloc()函数用于分配内存空间，函数原型如下：void*malloc(unsignedintsize);功能：在
    

    • 

  • 【Redis】Redis 集群搭建与管理: 原理、实现与操作
Hsu琛君珩
Redisredisbootstrap数据库

    目录集群(Cluster)基本概念数据分片算法哈希求余⼀致性哈希算法哈希槽分区算法(Redis使⽤)集群搭建(基于docker)第⼀步:创建⽬录和配置第⼆步:编写docker-compose.yml第三步:启动容器第四步:构建集群主节点宕机演⽰效果处理流程1)故障判定2)故障迁移集群扩容第⼀步:把新的主节点加⼊到集群第⼆步:重新分配slots第三步:给新的主节点添加从节点集群缩容(选学)第⼀步:删
    

    • 

  • java-redis-击穿
Flying_Fish_Xuan
javaredisspringboot

    Java与Redis之缓存击穿问题解决方案1.背景：缓存的基本概念在高并发系统中，缓存是一个非常重要的优化手段。它的基本思想是将热点数据缓存在高速的存储系统（如Redis、Memcached）中，从而减轻数据库等持久层的压力，并加快请求响应速度。常见的缓存模式有：缓存读写：读取数据时优先从缓存中获取，如果缓存中没有数据，则从数据库或其他持久化存储中获取并缓存。缓存失效策略：缓存系统通常会为每条缓存
    

    • 

  • 多进程把文件当做锁使用(python)
kuaileXG
python开发语言

    #test.pyimportfcntlimportosimporttimedefacquire_lock(filename):fd=os.open(filename,os.O_RDWR|os.O_CREAT)try:fcntl.flock(fd,fcntl.LOCK_EX|fcntl.LOCK_NB)exceptBlockingIOError:print("Fileislockedbyanothe
    

    • 

  • vue如何实现路由缓存
大宁宁吖
vue.js缓存前端

    （以下示例皆是以vue3+vite+ts项目为例）场景一：所有路由都可以进行缓存在渲染路由视图对应的页面进行缓存设置，代码如下：：用来渲染当前路由对应的视图。v-slot：解构router-view的插槽属性来访问当前路由的组件(Component)和路由对象(route)。：用于实现页面路由切换时的过渡动画效果，可省略。name="router-fade"：定义过渡动画类名为router-fad
    

    • 

  • 【脚手架 第一篇章】介绍一下若依微服务版框架
蜗牛 | ICU
脚手架专栏微服务架构云原生

    若依框架（RuoYi）是一个广泛使用的开源框架，它提供了多种版本以满足不同开发需求。以下是关于若依框架微服务版（RuoYi-Cloud）的详细介绍：一、概述RuoYi-Cloud是基于SpringCloud和SpringBoot的分布式微服务架构平台，专为构建大型分布式系统提供完整的解决方案。它集成了众多微服务特性，如服务发现、配置管理、负载均衡等，适合需要高可扩展性和高可用性的企业级应用。二、技
    

    • 

  • spring boot整合mybatis-plus
兴趣互联

    MyBatis-Plus（简称MP）是一个MyBatis的增强工具，在MyBatis的基础上只做增强不做改变，为简化开发、提高效率而生。整合mybatis-plus只需要在pom.xml中引入mybatis-plus-boot-starter启动器(目前最新版本3.4.0)com.baomidoumybatis-plus-boot-starter3.3.2
    

    • 

  • Percona-toolkit工具详解
小一_d28d

    1.pt工具安装[root@master~]#yuminstall-ypercona-toolkit-3.1.0-2.el7.x86_64.rpm2.常用工具使用介绍2.1pt-archiver归档表#重要参数--limit100每次取100行数据用pt-archive处理--txn-size100设置100行为一个事务提交一次，--where'id>/root/db/checksum.logpt
    

    • 

  • Java Web安全与Spring Config对象实战
福建低调

    本文还有配套的精品资源，点击获取简介：本课程深入探讨JavaWeb开发中的安全实践，包括认证与授权、输入验证、CSRF和XSS防护以及SQL注入防御等关键安全措施。同时，介绍SpringSecurity框架的应用，以及Config对象在Spring配置管理中的作用，包括依赖注入和外部化配置。课程还包括实战演练，通过设置安全环境和安全漏洞模拟，帮助开发者提升应用的安全性和故障排查能力。1.Web安全
    

    • 

  • unity连接mysql并读取所有数据库_Unity 3D 连接Mysql数据库
地理沙龙

    usingUnityEngine;usingSystem;usingSystem.Data;usingSystem.Collections;usingMySql.Data.MySqlClient;usingMySql.Data;usingSystem.IO;publicclassSqlAccess{publicstaticMySqlConnectiondbConnection;//如果只是在本地的
    

    • 

  • heidisql linux 安装_Linux和Windows下Mysql数据库安装详解
吴钧泽
heidisqllinux安装

    目录数据库原理数据库简介文件存储对数据的存储需求一直存在。保存数据的方式，经历了手工管理、文件管理等阶段，直至数据库管理阶段。文件存储方式保存数据的弊端：缺乏对数据的整体管理,数据不便修改；不利于数据分析和共享;数据量急剧增长,大量数据不可能长期保存在文件中。数据库应运而生，是人们存放数据、访问数据、操作数据的存储仓库。DB和DBMS数据库(Database,简称DB)是按照数据结构来组织、存储和
    

    • 

  • 两个byte数组拼接_java中两个byte数组实现合并的示例
甄公子
两个byte数组拼接

    今天在于硬件进行交互的过程中,要到了了需要两个数组进行合并,然后对数组进行反转和加密操作,以下是两个byte数组合并的方法。/****@paramdata1*@paramdata2*@returndata1与data2拼接的结果*/publicstaticbyte[]addBytes(byte[]data1,byte[]data2){byte[]data3=newbyte[data1.length
    

    • 

  • 从理论到实践：MySQL 性能优化和高可用架构，一次讲清
程序猿java易
mysql性能优化架构

    数据库系统作为IT业务系统的核心，其高可用性和容灾能力对整个业务系统的连续性和数据完整性起着至关重要的作用，是企业正常运营的基石尤其是在性能优化与高可用架构两方面，很多从业多年的DBA限于生产环境的固定体系，往往盲人摸象，难窥全局。而性能优化和高可用又是一对存在根本矛盾的特性。可以说，掌握了这两项技术的平衡，就掌握了MySQL的绝大部分内容，也就把握了数据库核心技术的最主流脉络。这本《MySQL性
    

    • 

  • MHA+MYCAT 高可用架构
第九系艾文
linuxLinuxtools服务器数据库mycatmhalinux

    架构图如下：本次是4服务器架构如下环境：centos7.2x64mariadb10.4MHA5.7MyCat1.6.7IP规划IP功能10.1.41.166VIP10.1.41.167master,mycat,mha.node10.1.41.168slave(master),mha.node10.1.41.165slave,mycat,keepalived10.1.41.169slave,myca
    

    • 

  • (代码可运行)Bootstrap框架的HTML示例
程序员大侠
前端CSShtmlbootstrap前端

    Bootstrap：一套流行的前端开发框架，基于HTML、CSS和JavaScript，适用于快速构建响应式Web应用。以下是一个使用Bootstrap构建的简单响应式Web应用的HTML示例：BootstrapExampleHello,Bootstrap!CardtitleSomequickexampletexttobuildonthecardtitleandmakeupthebulkofthe
    

    • 

  • 【Java】已解决：org.springframework.transaction.TransactionTimedOutException
屿小夏
java数据库开发语言

    文章目录一、分析问题背景场景描述二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.transaction.TransactionTimedOutException一、分析问题背景在Spring框架中，TransactionTimedOutException是一种常见的事务超时异常。通常，这种异常发生在数据库操作时间超过了预设的事务超时时间
    

    • 

  • 使用Python将多张图片转换为动态GIF图像
FLK_9090
python开发语言pillow

    在本文中，我们将学习如何使用Python编写代码，将多张静态图片转换为一个动态的GIF图像。无论你的图片格式是JPEG（.jpg）还是PNG（.png），我们都将使用Python中的PIL库来实现这一功能。通过本文的学习，你将了解如何利用Python编写简洁、高效的代码来处理图像，并创建出生动的动画效果。介绍动态GIF图像是一种在网络上广泛使用的图像格式，它可以将一系列静态图片串联起来，形成连续的
    

    • 

  • java短路运算符和逻辑运算符的区别
3213213333332132
java基础

    
/*
* 逻辑运算符——不论是什么条件都要执行左右两边代码
* 短路运算符——我认为在底层就是利用物理电路的“并联”和“串联”实现的
* 原理很简单，并联电路代表短路或（||），串联电路代表短路与（&&）。
*
* 并联电路两个开关只要有一个开关闭合，电路就会通。
* 类似于短路或（||），只要有其中一个为true（开关闭合）是
    

    • 

  • Java异常那些不得不说的事
白糖_
javaexception

    一、在finally块中做数据回收操作
比如数据库连接都是很宝贵的，所以最好在finally中关闭连接。
JDBCAgent jdbc = new JDBCAgent();
try{
jdbc.excute("select * from ctp_log");
}catch(SQLException e){
...
}finally{
jdbc.close(); 
    

    • 

  • utf-8与utf-8(无BOM)的区别
dcj3sjt126com
PHP

    BOM——Byte Order Mark，就是字节序标记   在UCS 编码中有一个叫做"ZERO WIDTH NO-BREAK SPACE"的字符，它的编码是FEFF。而FFFE在UCS中是不存在的字符，所以不应该出现在实际传输中。UCS规范建议我们在传输字节流前，先传输 字符"ZERO WIDTH NO-BREAK SPACE"。这样如
    

    • 

  • JAVA Annotation之定义篇
周凡杨
java注解annotation入门注释

        Annotation: 译为注释或注解
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, pa
    

    • 

  • tomcat的多域名、虚拟主机配置
g21121
tomcat

    众所周知apache可以配置多域名和虚拟主机，而且配置起来比较简单，但是项目用到的是tomcat，配来配去总是不成功。查了些资料才总算可以，下面就跟大家分享下经验。
很多朋友搜索的内容基本是告诉我们这么配置：
在Engine标签下增面积Host标签，如下：
<Host name="www.site1.com" appBase="webapps"
    

    • 

  • Linux SSH 错误解析（Capistrano 的cap 访问错误 Permission ）
510888780
linuxcapistrano

    
1.ssh -v [email protected] 出现
Permission denied (publickey,gssapi-keyex,gssapi-with-mic,password).
错误
运行状况如下：
OpenSSH_5.3p1, OpenSSL 1.0.1e-fips 11 Feb 2013
debug1: Reading configuratio
    

    • 

  • log4j的用法
Harry642
javalog4j

    一、前言：     log4j 是一个开放源码项目，是广泛使用的以Java编写的日志记录包。由于log4j出色的表现，     当时在log4j完成时，log4j开发组织曾建议sun在jdk1.4中用log4j取代jdk1.4 的日志工具类，但当时jdk1.4已接近完成，所以sun拒绝使用log4j，当在java开发中
    

    • 

  • mysql、sqlserver、oracle分页，java分页统一接口实现
aijuans
oraclejave

    
定义：pageStart 起始页，pageEnd 终止页,pageSize页面容量
oracle分页：
　　　　select * from ( select mytable.*,rownum num from (实际传的SQL) where rownum<=pageEnd) where num>=pageStart
sqlServer分页：
 
    

    • 

  • Hessian 简单例子
antlove
javaWebservicehessian

    hello.hessian.MyCar.java
package hessian.pojo;
import java.io.Serializable;
public class MyCar implements Serializable {
private static final long serialVersionUID = 473690540190845543
    

    • 

  • 数据库对象的同义词和序列
百合不是茶
sql序列同义词ORACLE权限

    回顾简单的数据库权限等命令;
解锁用户和锁定用户
alter user scott account lock/unlock;
//system下查看系统中的用户
select * dba_users;
//创建用户名和密码
create user wj identified by wj;
identified by
//授予连接权和建表权
grant connect to 
    

    • 

  • 使用Powermock和mockito测试静态方法
bijian1013
持续集成单元测试mockitoPowermock

            实例：
package com.bijian.study;
import static org.junit.Assert.assertEquals;
import java.io.IOException;
import org.junit.Before;
import org.junit.Test;
import or
    

    • 

  • 精通Oracle10编程SQL(6)访问ORACLE
bijian1013
oracle数据库plsql

    /*
*访问ORACLE
*/
--检索单行数据
--使用标量变量接收数据
DECLARE
v_ename emp.ename%TYPE;
v_sal emp.sal%TYPE;
BEGIN
select ename,sal into v_ename,v_sal
from emp where empno=&no;
dbms_output.pu
    

    • 

  • 【Nginx四】Nginx作为HTTP负载均衡服务器
bit1129
nginx

     Nginx的另一个常用的功能是作为负载均衡服务器。一个典型的web应用系统，通过负载均衡服务器，可以使得应用有多台后端服务器来响应客户端的请求。一个应用配置多台后端服务器，可以带来很多好处：
  负载均衡的好处
增加可用资源
增加吞吐量
加快响应速度，降低延时
出错的重试验机制
Nginx主要支持三种均衡算法：
round-robin
l
    

    • 

  • jquery-validation备忘
白糖_
jquerycssF#Firebug

    留点学习jquery validation总结的代码：
 
function checkForm(){
validator = $("#commentForm").validate({// #formId为需要进行验证的表单ID
errorElement :"span",// 使用"div"标签标记错误， 默认:&
    

    • 

  • solr限制admin界面访问（端口限制和http授权限制）
ronin47
限定Ip访问

    solr的管理界面可以帮助我们做很多事情，但是把solr程序放到公网之后就要限制对admin的访问了。
可以通过tomcat的http基本授权来做限制，也可以通过iptables防火墙来限制。
我们先看如何通过tomcat配置http授权限制。
第一步： 在tomcat的conf/tomcat-users.xml文件中添加管理用户，比如：
<userusername="ad
    

    • 

  • 多线程-用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1
bylijinnan
java多线程

    
public class IncDecThread {
private int j=10;
/*
* 题目:用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1
* 两个问题：
* 1、线程同步--synchronized
* 2、线程之间如何共享同一个j变量--内部类
*/
public static 
    

    • 

  • 买房历程
cfyme

     
 
2015-06-21: 万科未来城，看房子
 
2015-06-26: 办理贷款手续，贷款73万，贷款利率5.65=5.3675
 
2015-06-27: 房子首付,签完合同
 
2015-06-28，央行宣布降息 0.25，就2天的时间差啊，没赶上。
 
首付，老婆找他的小姐妹接了5万，另外几个朋友借了1-
    

    • 

  • [军事与科技]制造大型太空战舰的前奏
comsci
制造

    
       天气热了........空调和电扇要准备好..........
       最近,世界形势日趋复杂化,战争的阴影开始覆盖全世界..........
       所以,我们不得不关
    

    • 

  • dateformat
dai_lm
DateFormat

    
"Symbol Meaning Presentation Ex."
"------ ------- ------------ ----"
"G era designator (Text) AD"
"y year
    

    • 

  • Hadoop如何实现关联计算
datamachine
mapreducehadoop关联计算

        选择Hadoop，低成本和高扩展性是主要原因，但但它的开发效率实在无法让人满意。
    以关联计算为例。
    假设：HDFS上有2个文件，分别是客户信息和订单信息，customerID是它们之间的关联字段。如何进行关联计算，以便将客户名称添加到订单列表中？
  &nbs
    

    • 

  • 用户模型中修改用户信息时，密码是如何处理的
dcj3sjt126com
yii

    当我添加或修改用户记录的时候对于处理确认密码我遇到了一些麻烦，所有我想分享一下我是怎么处理的。
场景是使用的基本的那些(系统自带)，你需要有一个数据表(user)并且表中有一个密码字段(password),它使用 sha1、md5或其他加密方式加密用户密码。
面是它的工作流程: 当创建用户的时候密码需要加密并且保存，但当修改用户记录时如果使用同样的场景我们最终就会把用户加密过的密码再次加密，这
    

    • 

  • 中文 iOS/Mac 开发博客列表
dcj3sjt126com
Blog

     
本博客列表会不断更新维护，如果有推荐的博客，请到此处提交博客信息。
本博客列表涉及的文章内容支持 定制化Google搜索，特别感谢 JeOam 提供并帮助更新。
本博客列表也提供同步更新的OPML文件（下载OPML文件），可供导入到例如feedly等第三方定阅工具中，特别感谢 lcepy 提供自动转换脚本。这里有导入教程。 
    

    • 

  • js去除空格，去除左右两端的空格
蕃薯耀
去除左右两端的空格js去掉所有空格js去除空格

    js去除空格，去除左右两端的空格
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>&g
    

    • 

  • SpringMVC4零配置--web.xml
hanqunfeng
springmvc4

    servlet3.0+规范后，允许servlet，filter，listener不必声明在web.xml中，而是以硬编码的方式存在，实现容器的零配置。
ServletContainerInitializer：启动容器时负责加载相关配置
package javax.servlet;
import java.util.Set;
public interface ServletContainer
    

    • 

  • 《开源框架那些事儿21》：巧借力与借巧力
j2eetop
框架UI

    同样做前端UI，为什么有人花了一点力气，就可以做好？而有的人费尽全力，仍然错误百出？我们可以先看看几个故事。
故事1：巧借力，乌鸦也可以吃核桃
有一个盛产核桃的村子，每年秋末冬初，成群的乌鸦总会来到这里，到果园里捡拾那些被果农们遗落的核桃。
核桃仁虽然美味，但是外壳那么坚硬，乌鸦怎么才能吃到呢？原来乌鸦先把核桃叼起，然后飞到高高的树枝上，再将核桃摔下去，核桃落到坚硬的地面上，被撞破了，于是，
    

    • 

  • JQuery EasyUI 验证扩展
可怜的猫
jqueryeasyui验证

      最近项目中用到了前端框架-- EasyUI，在做校验的时候会涉及到很多需要自定义的内容，现把常用的验证方式总结出来，留待后用。
  以下内容只需要在公用js中添加即可。
  使用类似于如下：
<input class="easyui-textbox" name="mobile" id="mobile&
    

    • 

  • 架构师之httpurlconnection----------读取和发送(流读取效率通用类)
nannan408

    1.前言.
   如题.
2.代码.
/*
* Copyright (c) 2015, S.F. Express Inc. All rights reserved.
*/
package com.test.test.test.send;
import java.io.IOException;
import java.io.InputStream
    

    • 

  • Jquery性能优化
r361251
JavaScriptjquery

    一、注意定义jQuery变量的时候添加var关键字
这个不仅仅是jQuery，所有javascript开发过程中，都需要注意，请一定不要定义成如下：
$loading = $('#loading'); //这个是全局定义，不知道哪里位置倒霉引用了相同的变量名，就会郁闷至死的
二、请使用一个var来定义变量
如果你使用多个变量的话，请如下方式定义：
. 代码如下:
var page 
    

    • 

  • 在eclipse项目中使用maven管理依赖
tjj006
eclipsemaven

    概览:
如何导入maven项目至eclipse中
建立自有Maven  Java类库服务器
建立符合maven代码库标准的自定义类库
Maven在管理Java类库方面有巨大的优势，像白衣所说就是非常“环保”。
我们平时用IDE开发都是把所需要的类库一股脑的全丢到项目目录下，然后全部添加到ide的构建路径中，如果用了SVN/CVS，这样会很容易就 把
    

    • 

  • 中国天气网省市级联页面
x125858805
级联

    1、页面及级联js
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
&l
    

    •