Redis简单入门

news2024/11/14 11:09:14

Redis简介

Redis是一个开源的使用C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value的NoSQL数据库。特点如下:

  • 读写速度快：Redis官网测试读写能到10万左右每秒。速度快的原因这里简单说一下，第一是因为数据存储在内存中，我们知道机器访问内存的速度是远远大于访问磁盘的，其次是Redis采用单线程的架构，避免了上下文的切换和多线程带来的竞争，也就不存在加锁释放锁的操作，减少了CPU的消耗，第三点是采用了非阻塞IO多路复用机制。
  • 数据结构丰富： Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构
  • 支持持久化：Redis提供了RDB和AOF两种持久化策略，能最大限度地保证Redis服务器宕机重启后数据不会丢失。
  • 支持高可用：可以使用主从复制，并且提供哨兵机制，保证服务器的高可用。
  • 客户端语言多：因为Redis受到社区和各大公司的广泛认可，所以客户端语言涵盖了所有的主流编程语言，比如Java，C，C++，PHP，NodeJS等等

数据类型

string类型

简单的key-value模型。string数据结构是一种简单动态字符串(simple dynamic string, SDS)。
应用场景

  • 计数器(全局，当服务是多个实例时)
  • 可以做缓存(将对象转换为JSON字符串)
  • 使用setnx(set if not exist)命令做分布式锁
> set key value
OK
> get key
value
> exists key
1
> strlen key
5
> del key
1
> get key
null

@Test
public void testString() {
    redisTemplate.opsForValue().set("key", 1, 1, TimeUnit.MINUTES);

    Object value = redisTemplate.opsForValue().get("key");
    System.out.println(value); // 1
    Long key = redisTemplate.opsForValue().increment("key");
    System.out.println(key); // 2
    Object value1 = redisTemplate.opsForValue().get("key");
    System.out.println(value1); // 2
}
list类型

list是一个双向链表，是有序的，可以做列表，用lrange实现读取，高性能分页

rpush myList value1 # 向list的头部(右边)添加元素
rpush myList value2 value3 # 向list的头部(右边)添加多个元素
lpop myList # 将list的尾部(左边)元素取出
lrange myList 0 1 # 查看对应下标的list列表
lrange myList 0 -1 # 查看列表中的所有元素
llen myList # 查看链表长度

在这里插入图片描述

@Test
public void testList() {
    redisTemplate.opsForList().rightPush("list", "value1");
    redisTemplate.opsForList().rightPush("list", "value2");
    redisTemplate.opsForList().rightPush("list", "value3");

    Object value = redisTemplate.opsForList().leftPop("list");
    System.out.println(value); // value1
    List list1 = redisTemplate.opsForList().range("list", 0, 1);
    System.out.println(list1); // [value2, value3]
    List list2 = redisTemplate.opsForList().range("list", 0, -1);
    System.out.println(list2); // [value2, value3]
    Long size = redisTemplate.opsForList().size("list");
    System.out.println(size); // 2
}
hash类型

hash类似Java的HashMap，内部都是数组加链表的形式。

> hset userInfoKey name "tong" description "dev" age "24"
> hexists userInfoKey name # 查看key对应的value中的字段是否存在
> hget userInfoKey name # 获取存储在哈希表中指定字段的值
> hgetall userInfoKey # 获取在哈希表中指定key的所有字段和值
> hkeys userInfoKey # 获取key列表
> hvals userInfoKey # 获取value列表
> hset userInfoKey name "aloneness" # 修改某个字段对应的值

@Test
public void testHash() {
    redisTemplate.opsForHash().put("userInfoKey", "name", "tong");
    redisTemplate.opsForHash().put("userInfoKey", "description", "dev");
    redisTemplate.opsForHash().put("userInfoKey", "age", "24");

    Object value = redisTemplate.opsForHash().get("userInfoKey", "name");
    System.out.println(value); // tong
    Map<String, String> userInfoKey = redisTemplate.opsForHash().entries("userInfoKey");
    for (Map.Entry<String, String> entry : userInfoKey.entrySet()) {
        System.out.println(entry.getKey() + "  " + entry.getValue());
    }
}
set类型

set类似Java的HashSet。set类型是一种无序集合，不允许重复的数据。

> sadd mySet value1 value2 # 添加元素进去
> smembers mySet # 查看set中的所有元素
> scard mySet # 查看set的长度
> sismember mySet value1 # 检查某个元素是否存在set中，只能接受单个元素

@Test
public void testSet() {
    redisTemplate.opsForSet().add("mySet", "value1");
    redisTemplate.opsForSet().add("mySet", "value2");
    redisTemplate.opsForSet().add("mySet", "value1");

    Object value = redisTemplate.opsForSet().isMember("mySet", "value1");
    System.out.println(value); // true
    Set mySet = redisTemplate.opsForSet().members("mySet");
    System.out.println(mySet); // [value1, value2]
}
zset类型

和set相对比，zset增加了一个权重参数score，集合的元素可以按照score进行有序排列，还可以通过score的范围来获取元素的列表。最主要的应用场景是排行榜，可以根据某个权重进行排序。

> zadd myZset 3.0 value1 # 添加元素到sorted set中，3.0为权重
> zadd myZset 2.0 value2 1.0 value3 # 一次添加多个元素
> zcard myZset # 查看元素数量
> zscore myZset value1 # 查看某个value的权重
> zrange myZset 0 -1 # 顺序输出某个范围内的元素
> zrevrange myZset 0 1 # 逆序输出某个范围区间的元素

@Test
public void testZSet() {
    redisTemplate.opsForZSet().add("myZSet", "value1", 3.0);
    redisTemplate.opsForZSet().add("myZSet", "value2", 2.0);
    redisTemplate.opsForZSet().add("myZSet", "value3", 1.0);
    redisTemplate.opsForZSet().add("myZSet", "value2", 5.0);

    Set mySet = redisTemplate.opsForZSet().range("myZSet", 0, 10);
    System.out.println(mySet); // [value3, value1, value2]
    Set reverseRange = redisTemplate.opsForZSet().reverseRange("myZSet", 0, 10);
    System.out.println(reverseRange); // [value2, value1, value3]
}

使用场景

缓存热点数据

热点数据：经常被查询，但未被修改或删除的数据，一般有两种数据保存方式

  • 读取前，先去读Redis，如果没有数据，读取数据库，将数据拉入Redis。这种方案针对实时性不高的数据。还需要注意缓存击穿的问题。(提升查询性能，一般将数据写到ES)
  • 数据增删改的时候，同时对Redis增删改。实时性强，适用于数据量不大的场景，例如：系统配置，数据字典，等等一些配置。
限时业务的应用

可以使用Redis的expire命令设置键的有效时间，到时间后Redis会删除它。利用这一特性可以运用在限时的优惠活动信息，手机验证码，session有效期等业务场景。

@Test
public void testExpire() throws InterruptedException {
     redisTemplate.opsForValue().set("key", "value");
     redisTemplate.expire("key", 1, TimeUnit.SECONDS);
     System.out.println(redisTemplate.opsForValue().get("key")); // value

     Thread.sleep(2000);
     System.out.println(redisTemplate.opsForValue().get("key")); // null
}
计数器、流水号生成

Redis由于incrby命令可以实现原子性的递增，所以可以运用于高并发的秒杀活动、分布式序列号的生成、具体业务还体现在比如限制一个手机号发多少条短信、一个接口一分钟限制多少请求、一个接口一天限制调用多少次等等。
流水号的生成

@Component
public class SeriesCode {

   private static final int ID_LENGTH = 6;

   /**
    * SC2210-000011
    */
   private static final String SERIES_CODE_FORMAT = "SC%s-%s";

   /**
    * 32天 一个月
    */
   private static final long EXPIRE_DAYS = 32;

   @Autowired
   private RedisTemplate redisTemplate;

   public String getSeriesCode() {
       String monthStr = LocalDate.now().format(DateTimeFormatter.ofPattern("yyMM"));
       String monthRedisKey = String.format("month:key:%s", monthStr);

       if (!redisTemplate.hasKey(monthRedisKey)) {
           redisTemplate.opsForValue().set(monthRedisKey, 0, EXPIRE_DAYS, TimeUnit.DAYS);
       }
       long incr = redisTemplate.opsForValue().increment(monthRedisKey);
       String code = String.format(SERIES_CODE_FORMAT, monthStr, formatChar(incr, ID_LENGTH));
       String cacheKey = String.format("month:key:%s", code);
       if (redisTemplate.hasKey(cacheKey)) {
           return getSeriesCode();
       } else {
           redisTemplate.opsForValue().set(cacheKey, 1, EXPIRE_DAYS, TimeUnit.DAYS);
           return code;
       }
   }

   private static String formatChar(long incr, int length) {
       StringBuilder sb = new StringBuilder();
       for (int i = 0; i < length; i++) {
           sb.append("0");
       }
       DecimalFormat df = new DecimalFormat(sb.toString());
       return df.format(incr);
   }
}
分布式锁

利用了Redis的setnx(set if not exist)命令，如果不存在设置成功返回1，否则返回0。可以应用在表单防重，幂等性处理。

@Component
public class RedisLock {

   @Resource
   private RedisTemplate<String, String> redisTemplate;

   public boolean lock(String key, Integer delayTime) {
       long currentTime = System.currentTimeMillis();
       if (redisTemplate.opsForValue().setIfAbsent(key, String.valueOf(currentTime))) {
           return true;
       }

       String keyTime = redisTemplate.opsForValue().get(key);

       if (StringUtils.isEmpty(keyTime)) {
           if (redisTemplate.opsForValue().setIfAbsent(key, String.valueOf(currentTime))) {
               return true;
           } else {
               return false;
           }
       }

       long keyCurrentTime = Long.parseLong(keyTime) + delayTime;

       /**
        * 判断是否死锁
        */
       if (keyCurrentTime < currentTime) {
           redisTemplate.opsForValue().getOperations().delete(key);
           if (redisTemplate.opsForValue().setIfAbsent(key, String.valueOf(currentTime))) {
               return true;
           }
       }
       return false;
   }

   public void unlock(String key) {
       redisTemplate.opsForValue().getOperations().delete(key);
   }
}

 @Test
 public void testRedisLock() {
     String lockKey = "lock:redis";
     boolean lock = redisLock.lock(lockKey, 3000);
     System.out.println(lock); // true

     boolean lock1 = redisLock.lock(lockKey, 3000);
     System.out.println(lock1); // false

     redisLock.unlock(lockKey);

     boolean lock2 = redisLock.lock(lockKey, 3000);
     System.out.println(lock2); // true
 }
延时操作

可以使用Redisson组件，构建一个延迟队列。
引入依赖

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.7.0</version>
</dependency>

构建延时队列

@Slf4j
@Component
public class RedisDelayQueue {

    @Autowired
    private RedissonClient redissonClient;

    /**
     * 入队
     */
    public <T> void addQueue(T t, long delay, TimeUnit timeUnit) {
        RBlockingQueue<T> blockingFairQueue = redissonClient.getBlockingQueue(t.getClass().getName());
        RDelayedQueue<T> delayedQueue = redissonClient.getDelayedQueue(blockingFairQueue);
        delayedQueue.offer(t, delay, timeUnit);
    }

    /**
     * 出队
     */
    public <T> void getQueue(Class zClass, TaskEventListener taskEventListener) {
        RBlockingQueue<T> blockingFairQueue = redissonClient.getBlockingQueue(zClass.getName());
        // 由于此线程需要常驻，可以新建线程，不用交给线程池管理
        Thread thread = new Thread(() -> {
            while (true) {
                try {
                    T t = blockingFairQueue.take();
                    log.info(Thread.currentThread().getName() + "取得数据后，开始处理");
                    taskEventListener.invoke(t);
                } catch (InterruptedException e) {
                    log.error(e.getMessage());
                }
            }
        });
        thread.start();
    }

    /**
     * 延时回调监听
     */
    public abstract static class TaskEventListener<T> {
        /**
         * 执行方法
         */
        public abstract void invoke(T t);
    }
}

延时队列出队，并调用自定义的回调方法

@Component
@Slf4j
public class GetQueue {

    @Autowired
    private RedisDelayQueue redisDelayQueue;

    @PostConstruct
    public void init() {
        redisDelayQueue.getQueue(Meta.class, new TaskEventListenerDemo());
    }
    
    public static class Meta {
        String value;

        public String getValue() {
            return value;
        }

        public void setValue(String value) {
            this.value = value;
        }

        @Override
        public String toString() {
            return "Meta{" +
                    "value='" + value + '\'' +
                    '}';
        }
    }
}

@Slf4j
public class TaskEventListenerDemo extends RedisDelayQueue.TaskEventListener {
    @Override
    public void invoke(Object o) {
        // 延迟队列到期了
        log.info("延迟队列到期了，出队：{}", o);
    }
}

测试延时队列

@Test
public void test() throws InterruptedException {
    GetQueue.Meta meta = new GetQueue.Meta();
    meta.setValue("hello, redission");
    log.info("开始添加到队列中...");
    redisDelayQueue.addQueue(meta, 30, TimeUnit.SECONDS);

    Thread.sleep(1000 * 60);
}

Redisson组件的简单使用

Redisson是一个分布式的Redis客户端，支持很多分布式的操作。
引入依赖

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.7.0</version>
</dependency>

创建Redisson客户端

@Configuration
public class RedissonConfig {

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

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

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

    @Value("${spring.redis.database:0}")
    private Integer database;

    @Bean
    public RedissonClient redissonClient(){
        Config config = new Config();
        //单机配置
        config.useSingleServer().setAddress("redis://"+host+":"+port);
        config.useSingleServer().setPassword(password);

        //集群配置
        //config.useClusterServers().addNodeAddress(".... 可变参数 .");

//        //主从
//        config.useMasterSlaveServers()
//                .setMasterAddress("主节点配置")
//                .addSlaveAddress("从节点配置 可变参数");
//        //哨兵配置
//        config.useSentinelServers().addSentinelAddress("哨兵配置地址 可变参数")
//                .setMasterName("主库地址")
//                .setTimeout(50000)
//                .setMasterConnectionPoolSize(10)
//                .setSlaveConnectionPoolSize(5);
//
//
        config.setEventLoopGroup(new NioEventLoopGroup());
        RedissonClient redisson = Redisson.create(config);
        return redisson;
    }
}

分布式锁的简易使用

@Test
public void test() throws InterruptedException {
    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
    CountDownLatch countDownLatch = new CountDownLatch(50);
    for (int i = 0; i < 50; i++) {
        scheduledExecutorService.execute(new Worker(i, countDownLatch));
    }
    countDownLatch.await();
    scheduledExecutorService.shutdown();
}

public class Worker implements Runnable {
    private int i;
    private CountDownLatch countDownLatch;
    public Worker(int i, CountDownLatch countDownLatch) {
        this.i = i;
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        RLock lock = redissonClient.getLock("redisson:lock");
        try {
            // 1. 最常见的使用方法
            lock.lock();
            // 2. 支持过期解锁功能，10秒钟以后自动解锁，无需调用unlock方法手动解锁
            // lock.lock(10, TimeUnit.SECONDS);
            // 3. 尝试加锁，最多等待2秒，上锁以后5秒自动解锁
            // boolean res = lock.tryLock(2, 5, TimeUnit.SECONDS);
            // if (res) {
                doTask(i);
            // }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            countDownLatch.countDown();
        }
    }

    void doTask(int i) {
        System.out.println(Thread.currentThread().getName() + " sleep " + i);
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

注意事项

Key、Value序列化

引入spring-boot-starter-data-redis依赖会自动注入两个RedisTemplate，RedisTemplate默认使用的是JdkSerializationRedisSerializer，StringRedisTemplate默认使用的是StringRedisSerializer，当使用RedisTemplate做自增操作会报错，无法序列化。这需要我们自定义RedisTemplate并设置序列化。
在这里插入图片描述
我们可以将key设置为StringRedisSerializer，value设置为Jackson2JsonRedisSerializer

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
    redisTemplate.setConnectionFactory(redisConnectionFactory);

    // 设置键（key）的序列化采用StringRedisSerializer。
    StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
    redisTemplate.setKeySerializer(stringRedisSerializer);
    redisTemplate.setHashKeySerializer(stringRedisSerializer);

    // 设置值（value）的序列化采用Jackson2JsonRedisSerializer
    Jackson2JsonRedisSerializer<Object> redisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
    redisTemplate.setValueSerializer(redisSerializer);
    redisTemplate.setHashValueSerializer(redisSerializer);
    redisTemplate.afterPropertiesSet();
    return redisTemplate;
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

标准有效的项目开发流程

标准有效的项目开发流程

代码版本管理在项目中&#xff0c;代码的版本管理非常重要。每个需求版本的代码开发在版本控制里都应该经过以下几个步骤。在master分支中拉取该需求版本的两个分支&#xff0c;一个feature分支&#xff0c;一个release分支&#xff1b;feature分支用于接受个人分支merge过来的…
阅读更多...
二叉树DFS、BFS

二叉树DFS、BFS

目录 1&#xff0c;DFS遍历 2&#xff0c;DFS遍历OJ实战 力扣 144. 二叉树的前序遍历 力扣 94. 二叉树的中序遍历 力扣 145. 二叉树的后序遍历 力扣 105. 从前序与中序遍历序列构造二叉树 力扣 106. 从中序与后序遍历序列构造二叉树 力扣 889. 根据前序和后序遍历构造二…
阅读更多...
C++中的new、operator new与placement new

C++中的new、operator new与placement new

new operator 当我们使用了new关键字去创建一个对象时&#xff0c;你知道背后做了哪些事情吗&#xff1f; A* a new A;实际上这样简单的一行语句&#xff0c; 背后做了以下三件事情&#xff1a; 分配内存,如果类A重载了operator new&#xff0c;那么将调用A::operator new(…
阅读更多...
TencentOS安装并运行多版本php

TencentOS安装并运行多版本php

TencentOS版本3.1安装并运行php7&#xff0c;现在需要同时运行一个php8. php选择使用了php v8.0.27 采用编译安装的方式&#xff0c;编译命令如下&#xff1a; ./configure --prefix/application/php8 --with-config-file-path/application/php8/etc --with-mhash --with-o…
阅读更多...
51单片机学习笔记-4矩阵键盘

51单片机学习笔记-4矩阵键盘

4 矩阵键盘 [toc] 注&#xff1a;笔记主要参考B站江科大自化协教学视频“51单片机入门教程-2020版 程序全程纯手打 从零开始入门”。 注&#xff1a;工程及代码文件放在了本人的Github仓库。 4.1 矩阵键盘介绍 在键盘中按键数量较多时&#xff0c;为了减少I/O口的占用&#…
阅读更多...
vuex中 this.$store.dispatch() 与 this.$store.commit()

vuex中 this.$store.dispatch() 与 this.$store.commit()

一、理解 this.$store.dispatch 分发 actions-> 调用 mutations->改变 states 二、思考 1、为什么不直接分发 mutation mutation 有必须同步执行的限制&#xff0c;而 Action 不受约束&#xff0c;可以在 action 内部执行异步操作2、Action 通常是异步的&#xff0c;…
阅读更多...
配置日志输出到指定位置的文件，单独报错error级别以上的日志，按日志类别打印日志

配置日志输出到指定位置的文件，单独报错error级别以上的日志，按日志类别打印日志

目录1.配置文件2.测试程序&#xff1a;工具&#xff1a;log4j的jar包、配置文件log4j.properties(文件名自定义)、eclipse或IDEA 更多参考&#xff1a;https://www.cnblogs.com/ITtangtang/p/3926665.html、 1.配置文件 新建一个配置文件log4j.properties&#xff08;我把它放…
阅读更多...
区块链游戏走出一地鸡毛，元宇宙3D国风链游或成最大受益者

区块链游戏走出一地鸡毛，元宇宙3D国风链游或成最大受益者

曾推出过《Cytus》《Deemo》《聚爆》等知名游戏的雷亚&#xff0c;其CEO游名扬在接受采访时曾谈到&#xff0c;游戏产业是文化产业加上科技产业的组合体&#xff0c;这两者是组成游戏产业的主要部分。看游戏的趋势&#xff0c;就要针对文化和科技的趋势上来看。 这话没错。 20…
阅读更多...
flutter StreamController，ValueListenableBuilder，NotificationListener

flutter StreamController，ValueListenableBuilder，NotificationListener

FutureBuilder &#xff08;异步数据更新&#xff09; StreamBuilder &#xff08;异步数据更新&#xff09; 构造函数 特点 接收多个异步操作的结果class StreamBuilder<T> extends StreamBuilderBase<T, AsyncSnapshot<T>>{}单订阅&#xff1a;StreamCo…
阅读更多...
在Linux中进行Hbase搭建

在Linux中进行Hbase搭建

在公网IP为x.x.x.x、y.y.y.y和z.z.z.z并装有Centos8的服务器上进行hadoop集群搭建、zookeeper集群搭建和hbase搭建&#xff0c;都安装hadoop-3.1.3、server-jre-8u202-linux-x64、apache-zookeeper-3.6.4-bin和hbase-2.5.0-bin。 环境准备&#xff08;三台服务器都一样&#x…
阅读更多...
基于javaweb宠物领养平台管理系统设计和实现

基于javaweb宠物领养平台管理系统设计和实现

基于javaweb宠物领养平台管理系统设计和实现 博主介绍&#xff1a;5年java开发经验&#xff0c;专注Java开发、定制、远程、文档编写指导等,csdn特邀作者、专注于Java技术领域 作者主页 超级帅帅吴 Java毕设项目精品实战案例《500套》 欢迎点赞 收藏 ⭐留言 文末获取源码联系方…
阅读更多...
C++基础——C++ 判断

C++基础——C++ 判断

C基础——C 判断C 判断判断语句C if 语句语法流程图? : 运算符C 判断 判断结构要求程序员指定一个或多个要评估或测试的条件&#xff0c;以及条件为真时要执行的语句&#xff08;必需的&#xff09;和条件为假时要执行的语句&#xff08;可选的&#xff09;。 下面是大多数编…
阅读更多...
DAMA数据管理知识体系指南之数据管理概述

DAMA数据管理知识体系指南之数据管理概述

第2章 数据管理 2.1 引言 2.2 使命和目标 使命 在信息的可用性、安全性和质量方面&#xff0c;满足并超越企业中所有利益相关者的信息要求。 战略目标 &#xff08;1&#xff09;理解企业和所有利益相关者的信息需求。 &#xff08;2&#xff09;获取、存储、保护和确保数据资…
阅读更多...
堆的结构及函数接口、堆排序，TopK

堆的结构及函数接口、堆排序，TopK

本篇内容涉及到二叉树的概念及性质&#xff0c;可参考文章 树和二叉树的概念及性质 文章目录一、堆的概念二、堆的存储结构三、堆的函数接口1. 初始化及销毁2. 打印函数3. 堆的插入4. 堆的删除5. 取堆顶、判空、数据个数四、建堆算法和时间复杂度1. 向上调整建堆2. 向下调整建堆…
阅读更多...
CTFshow--web--红包题第二弹

CTFshow--web--红包题第二弹

查看源代码&#xff0c;按注释提示&#xff0c;构造参数试试?cmdaa<?php #error_reporting(0); ?> <html lang"zh-CN"><head><meta http-equiv"Content-Type" content"text/html; charsetUTF-8" /><meta name&quo…
阅读更多...
MATLAB绘制爱心曲线并导出

MATLAB绘制爱心曲线并导出

MATLAB绘制爱心曲线并导出 爱心曲线的表达式&#xff1a; f(x)x2/3e3(π−x2)1/2sin(aπx)f(x)x^{2/3}\frac e 3(\pi-x^2)^{1/2}sin(a\pi x) f(x)x2/33e​(π−x2)1/2sin(aπx) f (x,a)x.^2.^(1/3)exp(1)/3*(pi-x.^2).^(1/2).*sin(a*pi*x); h figure(color,[1 1 1]); set(g…
阅读更多...
应用系统与钉钉集成案例及操作步骤

应用系统与钉钉集成案例及操作步骤

1、准备钉钉应用 1.1、注册钉钉账号 作为钉钉的企业管理员&#xff0c;首先登录钉钉官网&#xff0c;注册一个钉钉账号。 如果已经有账号&#xff0c;则直接使用即可。 钉钉官网&#xff1a;https://www.dingtalk.com/ 1.2、开通企业团队 企业管理员使用账号登录钉钉。 如…
阅读更多...
如何限制docker容器使用内存大小

如何限制docker容器使用内存大小

本文介绍如何通过docker运行参数配置限制docker容器可以使用的内存上限。docker容器默认可以使用全部宿主机的所有内存和 swap 分区&#xff0c;比如宿主机的内存是32G&#xff0c;则运行一个docker容器最多可以分配到32G内存&#xff0c;如果启用了多个docker容器&#xff0c;…
阅读更多...
CSS实现文本显示两行

CSS实现文本显示两行

效果图 text-overflow: ellipsis;display: -webkit-box;-webkit-line-clamp: 2;-webkit-box-orient: vertical;display: -moz-box;-moz-line-clamp: 2;-moz-box-orient: vertical;overflow-wrap: break-word;word-break: break-all;white-space: normal;overflow: hidden;text-…
阅读更多...
SAP ADM100-2.2 SAP系统开启过程中的配置文件

SAP ADM100-2.2 SAP系统开启过程中的配置文件

SAP系统的每个实例需要的数据都在文件系统中，包括所有实例都需要访问的全局数据（Globally）和个别实例需要访问的数据。在文件系统汇总，实例需要的数据被包含在usr/sap目录，在这里被进一步组织到子目录。 【注意】：业务数据和相关数据被存储在数据库中，数据库根据不同的制…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023