【Mybatis】Mybatis 二级缓存全详解教程

【Mybatis-Plus】Mybatis-Plus 二级缓存全详解

一,Mybatis-Plus介绍

MyBatis-Plus(简称MP)是一个基于 MyBatis 的增强工具,它简化了 MyBatis 的开发,并且提供了许多便利的功能,帮助开发者更高效地进行持久层的开发。

二,Mybatis-Plus缓存级别 一级缓存,二级缓存

MyBatis-Plus 与 MyBatis 一样,也依赖于 MyBatis 的缓存机制,包括一级缓存(本地缓存)和二级缓存(全局缓存)。

  1. 一级缓存(本地缓存)

    • 一级缓存是指在同一个 SqlSession 内部的缓存。它默认是开启的,且无法关闭。
    • 当执行查询语句时,如果之前已经从数据库中查询过相同的结果,则会直接从缓存中获取结果,而不需要再次查询数据库。
    • 一级缓存的作用范围是 SqlSession 级别的,也就是说,只有在同一个 SqlSession 中执行的查询操作才会共享同一个一级缓存。
    • 当 SqlSession 关闭时,一级缓存将被清空,这意味着一级缓存的生命周期与 SqlSession 是一致的。
  2. 二级缓存(全局缓存)

    • 二级缓存是指多个 SqlSession 之间共享的缓存,它的作用范围是 Mapper 级别的。
    • 二级缓存需要手动开启和配置,可以通过在 Mapper 接口或者 XML 配置文件中添加 <cache> 标签来配置。
    • 当执行查询语句时,如果之前已经从数据库中查询过相同的结果,并且该结果被保存在二级缓存中,则会直接从缓存中获取结果,而不需要再次查询数据库。
    • 二级缓存的生命周期是全局的,在多个 SqlSession 中共享,但是它需要考虑缓存的一致性和并发访问的安全性。
    • 在更新数据时,需要手动清除或刷新二级缓存,以保证数据的正确性。

总的来说,一级缓存是 SqlSession 级别的缓存,而二级缓存是 Mapper 级别的缓存。一级缓存默认开启且无法关闭,而二级缓存需要手动配置开启。

Spring Boot 整合Mybatis 开启二级缓存

图片来源与CSDN 半缘修道_半缘君
在这里插入图片描述

1.POM依赖

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
	<groupId>com.baomidou</groupId>
	<artifactId>mybatis-plus-boot-starter</artifactId>
	<version>3.3.2</version>
</dependency>
<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<scope>runtime</scope>
</dependency>

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

2.类代码

1. 编写Redis工具类RedisUtils
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.CollectionUtils;
 
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
 
/**
 *
 * Redis工具类,一般企业开发常用的一个工具类,不会去用原生的redis配置类
 *
 */
 
public final class RedisUtils {
 
    private RedisTemplate<String, Object> redisTemplate;
 
    public RedisUtils(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    public Object execute(RedisCallback action){
        Object execute = redisTemplate.execute(action);
        return execute;
    }
 
    /**
     * 删除Collection<String>集合中的key
     * @param keys
     * @return
     */
    public Long del(Collection<String> keys){
        Long delete = redisTemplate.delete(keys);
        return delete;
    }
 
    /**
     * 模糊查询key
     * @param str 模糊查询的条件
     * @return
     */
    public Set<String> keys(String str){
        Set<String> keys = redisTemplate.keys(str);
        return keys;
    }
 
    /**
     * 消息订阅与发布:发布
     * @param channel
     * @param message
     */
    public void convertAndSend(String channel, Object message){
        redisTemplate.convertAndSend(channel,message);
    }
 
    /**
     * 如果不存在且保存的时间大于0即可创建成功,否则创建失败
     * @param key 键
     * @param value 值
     * @param time 缓存的时间
     * @return
     */
    public boolean setNx(String key,Object value,long time){
        try {
            if (time > 0) {
                return redisTemplate.opsForValue().setIfAbsent(key,value,time,TimeUnit.SECONDS);
            } else {
                return false;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
 
    /**
     * 如果不存在才创建成功,否则就创建失败
     * @param key
     * @param value
     * @return
     */
    public boolean setNx(String key,Object value){
        try {
            return redisTemplate.opsForValue().setIfAbsent(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    // =============================common============================
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
            }
        }
    }
    // ============================String=============================
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }
    // ================================Map=================================
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }
    // ============================set=============================
    public Set<Object> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0) {
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    // ===============================list=================================
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}
2.ApplicationContextUtil
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
 
/**
 * @ClassName : ApplicationContextUtil
 * @Description : 手动获取bean的工具类
 */
@Component
public class ApplicationContextUtil implements ApplicationContextAware {
    private static ApplicationContext context;
 
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.context = applicationContext;
    }
 
    /**
     *
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName) {
        return context.getBean(beanName);
    }
}
3.MybatisRedisCache
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.cache.Cache;
import org.springframework.data.redis.connection.RedisServerCommands;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.util.DigestUtils;
 
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
 
/**
 * @ClassName : MybatisRedisCache
 * @Description : mybatis-plus结合redis自定义缓存管理
 * @author ZJ
 */
@Slf4j
public class MybatisPlusRedisCache implements Cache {
 
 
    /**
     * 注意,这里无法通过@Autowired等注解的方式注入bean,只能手动获取
     */
    private RedisUtils redisUtil;
 
    /**
     * 手动获取bean
     *
     * @return
     */
    private void getRedisUtil() {
        redisUtil = (RedisUtils) ApplicationContextUtil.getBean("redisUtils");
    }
 
 
    // 读写锁
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);
 
 
    private String id;
 
    public MybatisPlusRedisCache(final String id) {
        if (id == null) {
            throw new IllegalArgumentException("Cache instances require an ID");
        }
        log.info("二级缓存id:{}",id);
        this.id = id;
    }
 
 
    @Override
    public String getId() {
        return this.id;
    }
 
    @Override
    public void putObject(Object key, Object value) {
        log.info("存入缓存");
 
        if (redisUtil == null) {
            getRedisUtil();//获取bean
        }
 
        try {
            //将key加密后存入
            redisUtil.hset(this.id,this.MD5Encrypt(key),value);
        } catch (Exception e) {
            log.error("存入缓存失败!");
            e.printStackTrace();
        }
 
 
    }
 
    @Override
    public Object getObject(Object key) {
        log.info("获取缓存");
 
        if (redisUtil == null) {
            getRedisUtil();//获取bean
        }
 
        try {
            if (key != null) {
                return redisUtil.hget(this.id,this.MD5Encrypt(key));
            }
        } catch (Exception e) {
            log.error("获取缓存失败!");
            e.printStackTrace();
        }
 
        return null;
    }
 
    @Override
    public Object removeObject(Object key) {
        log.info("删除缓存");
 
        if (redisUtil == null) {
            getRedisUtil();//获取bean
        }
 
 
        try {
            if (key != null) {
                redisUtil.del(this.MD5Encrypt(key));
            }
        } catch (Exception e) {
            log.error("删除缓存失败!");
            e.printStackTrace();
        }
 
        return null;
    }
 
    @Override
    public void clear() {
        log.info("清空缓存");
        if (redisUtil == null) {
            getRedisUtil();//获取bean
        }
 
        try {
            redisUtil.del(this.id);
        } catch (Exception e) {
            log.error("清空缓存失败!");
            e.printStackTrace();
        }
 
    }
 
    @Override
    public int getSize() {
        if (redisUtil == null) {
            getRedisUtil();//获取bean
        }
        Long size = (Long)redisUtil.execute((RedisCallback<Long>) RedisServerCommands::dbSize);
        return size.intValue();
    }
 
    @Override
    public ReadWriteLock getReadWriteLock() {
        return this.readWriteLock;
    }
 
    /**
     * MD5加密存储key,以节约内存
     */
    private String MD5Encrypt(Object key){
        String s = DigestUtils.md5DigestAsHex(key.toString().getBytes());
        return s;
    }
 
}
4,编写RedisConfig配置类
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import lombok.extern.slf4j.Slf4j;
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.StringRedisSerializer;
 
@Configuration
@Slf4j
public class RedisConfig {
 
    /**redis配置模板**/
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
 
        //为了开发的方便,一般直接使用<String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
 
        //json的序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(
                LaissezFaireSubTypeValidator.instance ,
                ObjectMapper.DefaultTyping.NON_FINAL,
                JsonTypeInfo.As.PROPERTY);
        jackson2JsonRedisSerializer.setObjectMapper(om);
 
        //String的序列化
        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;
    }
 
    @Bean(name="redisUtils")
    public RedisUtils redisUtils(final RedisTemplate<String, Object> redisTemplate) {
        final RedisUtils jedisService = new RedisUtils(redisTemplate);
        return jedisService;
    }
 
}

3.在Spring Boot中整合MyBatis,可以通过以下步骤开启二级缓存:

  1. 配置mybatis-config.xml文件:
    在mybatis-config.xml文件中,需要添加如下配置:
<configuration>
  <settings>
    <setting name="cacheEnabled" value="true"/> <!-- 开启二级缓存 -->
    <setting name="lazyLoadingEnabled" value="true"/> <!-- 开启延迟加载 -->
    <setting name="aggressiveLazyLoading" value="false"/> <!-- 关闭积极的延迟加载 -->
  </settings>
  <typeAliases>
    ...
  </typeAliases>
  <mappers>
    ...
  </mappers>
</configuration>
  1. 配置mapper.xml文件:
    在mapper.xml文件中,需要添加如下配置:
<mapper namespace="com.example.myexcel.dao.InsuranceSettlementMapper">

    <resultMap type="com.example.myexcel.pojo.entity.InsuranceSettlementEntity" id="insuranceSettlementMap">
        <result property="insuranceName" column="insurance_name"/>
        <result property="credentialNo" column="credential_no"/>
        <result property="drugApplyId" column="drug_apply_id"/>
        <result property="totalAmount" column="total_amount"/>
    </resultMap>
    <cache-ref namespace="com.example.myexcel.dao.InsuranceSettlementMapper"/>

</mapper>
  1. 配置application.yml文件:
    在application.yml文件中,需要添加如下配置:
# 开启MyBatis二级缓存
mybatis-plus:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.example.myexcel.pojo.entity
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #开启sql日志
    #缓存开启
    cache-enabled: true
  1. 配置接口类:
    你还可以通过在mapper接口上添加@CacheNamespace注解来启用并配置二级缓存。例如:
@Mapper
@CacheNamespace(implementation= MybatisPlusRedisCache.class,eviction=MybatisPlusRedisCache.class)
public interface InsuranceSettlementMapper extends BaseMapper<InsuranceSettlementEntity> {
}
  1. 配置Redis:
    如果使用Redis作为二级缓存的实现,需要在application.yml文件中添加如下配置:
# Redis配置
  redis:
    database: 15
    host: 
    port: 6379
    password: 123456  # 密码(默认为空)
    timeout: 6000ms  # 连接超时时长(毫秒)
    lettuce:
      pool:
        max-active: 1000  # 连接池最大连接数(使用负值表示没有限制)
        max-wait: -1ms      # 连接池最大阻塞等待时间(使用负值表示没有限制)
        max-idle: 10      # 连接池中的最大空闲连接
        min-idle: 5       # 连接池中的最小空闲连接
@Test
    public void query(){

        log.info("*****************************************************************************************");
        List<InsuranceSettlementEntity> list = insuranceSettlementService.list();
        log.info("列表:{}",list);
    }

缓存查询列表测试结果:先查询缓存,发现没有数据后查询数据再存入缓存
在这里插入图片描述
缓存查询列表测试结果:先查询缓存,发现有数据直接返回数据
在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/526250.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

申请专利有用吗 好处

申请专利&#xff1a;一项值得考虑的策略 随着科技的快速发展和市场竞争的日益激烈&#xff0c;创新成为了企业或个人取得竞争优势的关键。在这样的背景下&#xff0c;申请专利成为了许多创新者保护自己创意和技术的重要手段。 申请专利真的有用吗&#xff1f; 申请专利可以…

CS162 Operating System笔记

What is an Operating System? it’s typically a special layer of software that provides the application access to hardware resources.So.it’s convenient abs fractions of complex hardware devices.

数位递增数-第12届蓝桥杯选拔赛Python真题精选

[导读]&#xff1a;超平老师的Scratch蓝桥杯真题解读系列在推出之后&#xff0c;受到了广大老师和家长的好评&#xff0c;非常感谢各位的认可和厚爱。作为回馈&#xff0c;超平老师计划推出《Python蓝桥杯真题解析100讲》&#xff0c;这是解读系列的第46讲。 数位递增数&#…

【软考】23种设计模式详解,记忆方式,并举例说明

23种设计模式详解&#xff0c;举例说明 一、创建型模式1.1、抽象工厂模式&#xff08;Abstract Factory&#xff09;1.1.1、简介1.1.2、意图与应用场景1.1.3、结构1.1.4、优缺点1.1.4、示例代码&#xff08;简化版&#xff09; 1.2、建造者模式&#xff08;Builder&#xff09;…

微信小程序-接入sse数据流并实现打字机效果( ChatGPT )

从流中获取的数据格式如下 小程序调用SSE接口 const requestTask wx.request({url: xxx, // 需要请求的接口地址enableChunked: true, // enableChunked必须为truemethod: "GET",timeout: 120000,success(res) {console.log(res.data)},fail: function (error) {//…

DNFOMP:杂乱环境中自动驾驶汽车导航的动态神经场最优运动规划器

DNFOMP&#xff1a;杂乱环境中自动驾驶汽车导航的动态神经场最优运动规划器 附赠自动驾驶学习资料和量产经验&#xff1a;链接 摘要 本文介绍了DNFOMP&#xff1a;杂乱环境中自动驾驶汽车导航的动态神经场最优运动规划器。动态变化环境中的运动规划是自动驾驶中最复杂的挑战之…

fakebook-攻防世界

题目 先目录扫描一下 dirseach 打开flag.php是空白的 访问robots.txt,访问user.php.bak <?php class UserInfo { public $name ""; public $age 0; public $blog ""; public function __construct($name, $age, $blog) { …

01 _ 分布式缘何而起:从单兵,到游击队,到集团军

这里先来聊聊什么是分布式。 与其直接用些抽象、晦涩的技术名词去给分布式下一个定义&#xff0c;还不如从理解分布式的发展驱动因素开始&#xff0c;我们一起去探寻它的本质&#xff0c;自然而然地也就清楚它的定义了。 这里将介绍分布式的起源&#xff0c;是如何从单台计算…

基于java+springboot+vue实现的健身房管理系统(文末源码+Lw)23-223

摘 要 传统办法管理信息首先需要花费的时间比较多&#xff0c;其次数据出错率比较高&#xff0c;而且对错误的数据进行更改也比较困难&#xff0c;最后&#xff0c;检索数据费事费力。因此&#xff0c;在计算机上安装健身房管理系统软件来发挥其高效地信息处理的作用&#xf…

Python异常值分析

异常值分析是检验数据是否有录入错误以及含有不合常理的数据。忽视异常值的存在是十分危险的&#xff0c;不加剔除地把异常值包括进数据的计算分析过程中&#xff0c;对结果会产生不良影响&#xff1b;重视异常值的出现&#xff0c;分析其产生的原因&#xff0c;常常成为发现问…

Grafana告警(邮件)自定义模板配置

一年前给客户部署配置过grafana&#xff0c;告警配置也是用的原始的&#xff0c;客户在使用过程中只需要一些核心点信息&#xff0c;想要实现这个就需要用Grafana的自定义告警模板以及编辑邮件模板。 通知模板 模板信息的配置中查阅了相关资料&#xff0c;自己组装了一套&…

获取淘宝销量API商品详情页原数据APP接口:测试key获取(含测试链接)

淘宝/天猫获得淘宝app商品详情原数据 API 返回值说明 item_get_app-获得淘宝app商品详情原数据 公共参数 名称类型必须描述keyString是调用key&#xff08;必须以GET方式拼接在URL中&#xff09;secretString是调用密钥api_nameString是API接口名称&#xff08;包括在请求地…

静态中间继电器 HJZ-J908 AC380V 导轨安装 JOSEF约瑟

系列型号&#xff1a; HJZ-J902静态中间继电器&#xff1b;HJZ-J905静态中间继电器&#xff1b; HJZ-J907静态中间继电器&#xff1b;HJZ-J907L静态中间继电器&#xff1b; HJZ-J908静态中间继电器&#xff1b;HJZ-J909静态中间继电器&#xff1b; HJZ-J910静态中间继电器&…

以XX公司为例的Acrel1000DP分布式光伏监控系统在5.98MW分布式光伏10KV并网系统的应用

分布式光伏监控系统 目前&#xff0c;光伏电站中装设的电力二次系统主要有光伏后台监控系统、计量系统、远动通讯屏、调度数据网屏、防孤岛保护装置、电能质量在线监测装置、频率电压紧急控制装置等&#xff0c;部分光伏电站还建设有向发电集团传输数据的系统。 分布式光伏监…

基于 SSM 物业管理系统设计与实现(内附设计LW + PPT+ 源码下载)

摘 要 进入二十一世纪以来&#xff0c;计算机技术蓬勃发展&#xff0c;人们的生活发生了许多变化。很多时候人们不需要亲力亲为的做一些事情&#xff0c;通过网络即可完成以往需要花费很多时间的操作&#xff0c;这可以提升人们的生活质量。计算机技术对人们生活的改变不仅仅包…

[C++][算法基础]模拟散列表(哈希表)

维护一个集合&#xff0c;支持如下几种操作&#xff1a; I x&#xff0c;插入一个整数 x&#xff1b;Q x&#xff0c;询问整数 x 是否在集合中出现过&#xff1b; 现在要进行 N 次操作&#xff0c;对于每个询问操作输出对应的结果。 输入格式 第一行包含整数 N&#xff0c;…

JS小项目-计算器

需求&#xff1a;根据素材制作如图所示页面&#xff0c;在页面输入第一个数和第二个数&#xff0c;单击&#xff08;加&#xff09;、&#xff0d;&#xff08;减&#xff09;、&#xff0a;&#xff08;乘&#xff09;、&#xff0f;&#xff08;除&#xff09;按钮时&#xf…

动态规划刷题(算法竞赛、蓝桥杯)--区间DP

1、题目链接&#xff1a;[NOI1995] 石子合并 - 洛谷 #include <bits/stdc.h> using namespace std; const int N210; int n,a[N],s[N]; int f[N][N];//存最小值 int g[N][N];//存最大值 int main(){memset(f,0x3f,sizeof f);//求最小初始化为无穷大 memset(g,-0x3f,size…

智慧能耗预付费系统解决方案——用户侧能源计量及收费

安科瑞电气股份有限公司 祁洁 15000363176 一、方案组织架构 二、方案特点 &#xff08;1&#xff09;多样组网&#xff0c;多样设备接入&#xff0c;多样部署&#xff1b; &#xff08;2&#xff09;集团管理、项目分级、分层拓扑&#xff1b; &#xff08;3&#xff09…

ImageView显示叠加图

imageView显示叠加图&#xff1a;背景是绿色&#xff0c;中间为add图标 <ImageViewandroid:id"id/iv_add_food"android:layout_width"80dp"android:layout_height"80dp"android:layout_below"id/iv_filter"android:layout_marginTo…