Flink【基于时间的双流联结 Demo】

前言

        

1、基于时间的双流联结（Join）

        对于两条流的合并，很多情况我们并不是简单地将所有数据放在一起，而是希望根据某个字段的值将它们联结起来，“配对”去做处理。例如用传感器监控火情时，我们需要将大量温度传感器和烟雾传感器采集到的信息，按照传感器 ID 分组、再将两条流中数据合并起来，如果同时超过设定阈值就要报警。
        我们发现，这种需求与关系型数据库中表的 join 操作非常相近。事实上，Flink 中两条流的 connect 操作，就可以通过 keyBy 指定键进行分组后合并，实现了类似于 SQL 中的 join 操作；另外 connect 支持处理函数，可以使用自定义状态和 TimerService 灵活实现各种需求，其实已经能够处理双流合并的大多数场景。不过处理函数是底层接口，所以尽管 connect 能做的事情多，但在一些具体应用场景下还是显得太过抽象了。比如，如果我们希望统计固定时间内两条流数据的匹配情况，那就需要设置定时器、自定义触发逻辑来实现——其实这完全可以用窗口（window）来表示。为了更方便地实现基于时间的合流操作，Flink 的 DataStrema API 提供了两种内置的 join 算子，以及coGroup 算子。

SQL 中 join 一般会翻译为“连接”；这里为了区分不同的算子，一般的合流操作connect 翻译为“连接”，而把 join 翻译为“联结”。

1.1、窗口联结（Join）

如果我们希望将两条流的数据进行合并、且同样针对某段时间进行处理和统计（将属于同一窗口内的两条流相同 key 的数据合并到一起）。Flink 为这种场景专门提供了一个窗口联结（window join）算子，可以定义时间窗口，并将两条流中共享一个公共键（key）的数据放在窗口中进行配对处理。

1.1.1、窗口联结的调用

        窗口联结在代码中的实现，首先需要调用 DataStream 的.join()方法来合并两条流，得到一个 JoinedStreams；接着通过.where()和.equalTo()方法指定两条流中联结的 key；然后通过.window()开窗口，并调用.apply()传入联结窗口函数进行处理计算。通用调用形式如下：

stream1.join(stream2)
 .where(<KeySelector>)    // 指定第一条流中的 key选择器
 .equalTo(<KeySelector>)    // 指定第二条流中的 key选择器
 .window(<WindowAssigner>)    // 定义窗口
 .apply(<JoinFunction>)    // 定义合并逻辑，返回结果

        上面代码中.where()的参数是键选择器（KeySelector），用来指定第一条流中的 key；而.equalTo()传入的 KeySelector 则指定了第二条流中的 key。两者相同的元素，如果在同一窗口中，就可以匹配起来，并通过一个“联结函数”（JoinFunction）进行处理了。
        这里.window()传入的就是窗口分配器，之前讲到的三种时间窗口都可以用在这里：滚动窗口（tumbling window）、滑动窗口（sliding window）和会话窗口（session window）。而后面调用.apply()可以看作实现了一个特殊的窗口函数。注意：这里只能调用.apply()，没有其他替代的方法。

传入的 JoinFunction 也是一个函数类接口，使用时需要实现内部的.join()方法。这个方法有两个参数，分别表示两条流中成对匹配的数据。JoinFunction 在源码中的定义如下：

public interface JoinFunction<IN1, IN2, OUT> extends Function, Serializable {
 OUT join(IN1 first, IN2 second) throws Exception;
}

这里的 JoinFunciton 并不是真正的“窗口函数”，它只是定义了窗口函数在调用时对匹配数据的具体处理逻辑。

1.1.2、窗口联结的原理

        JoinFunction 中的两个参数，分别代表了两条流中的匹配的数据。那什么时候就会匹配好数据，调用.join()方法呢？
        事实上，两条流的数据到来之后，首先会按照 key 分组、进入对应的窗口中存储；当到达窗口结束时间时，算子会先统计出窗口内两条流的数据的所有组合，也就是对两条流中的数据做一个笛卡尔积（相当于表的交叉连接，cross join），然后进行遍历，把每一对匹配的数据，作为参数(first，second)传入 JoinFunction 的.join()方法进行计算处理，得到的结果直接输出。所以窗口中每有一对数据成功联结匹配，JoinFunction 的.join()方法就会被调用一次，并输出一个结果。

除了 JoinFunction，在.apply()方法中还可以传入 FlatJoinFunction，用法非常类似，只是内部需要实现的.join()方法没有返回值。结果的输出是通过收集器（Collector）来实现的，所以对于一对匹配数据可以输出任意条结果。 

1.1.3、案例

package com.lyh.watermark;

import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.JoinFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.tuple.Tuple3;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;

public class WindowJoinDemo {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        SingleOutputStreamOperator<Tuple2<String, Integer>> ds1 = env.fromElements(
                Tuple2.of("a", 1),
                Tuple2.of("a", 2),
                Tuple2.of("b", 1),
                Tuple2.of("c", 1)
        ).assignTimestampsAndWatermarks(
                WatermarkStrategy.<Tuple2<String, Integer>>forMonotonousTimestamps()
                        .withTimestampAssigner((value, ts) -> (value.f1 * 1000L))
        );

        SingleOutputStreamOperator<Tuple3<String, Integer,Integer>> ds2 = env.fromElements(
                Tuple3.of("a", 1,1),
                Tuple3.of("a", 6,1),
                Tuple3.of("b", 1,1),
                Tuple3.of("c", 5,1)
        ).assignTimestampsAndWatermarks(
                WatermarkStrategy.<Tuple3<String, Integer,Integer>>forMonotonousTimestamps()
                        .withTimestampAssigner((value, ts) -> (value.f1 * 1000L))
        );

        // window join
        DataStream<String> join = ds1.join(ds2)
                .where(r1 -> r1.f0) // 流1 的 key选择器
                .equalTo(r2 -> r2.f0)// 流2 的key选择器
                .window(TumblingEventTimeWindows.of(Time.seconds(5)))
                // apply 的参数: param1: 流1的类型 param2: 流2的类型 param3: 返回值类型
                .apply(new JoinFunction<Tuple2<String, Integer>, Tuple3<String, Integer, Integer>, String>() {
                    @Override
                    public String join(Tuple2<String, Integer> first, Tuple3<String, Integer, Integer> second) throws Exception {
                        return first + " <------> " + second;
                    }
                });

        join.print();

        env.execute();
    }
}

这里，我们定义了两条数据流：

  流1            流2
(编号,时间s) (编号,时间s,其它)
("a", 1)     ("a", 1,1)
("a", 2)     ("a", 6,1)
("b", 1)     ("b", 1,1)
("c", 1)     ("c", 5,1)

并划分窗口大小为 5s，希望能够对同一时间窗口内两条流的数据进行一个联结。

运行结果：

(a,1) <------> (a,1,1)
(a,2) <------> (a,1,1)
(b,1) <------> (b,1,1)

可以看到，对于不在同一时间窗口内的数据，它是无法联结的。

总结

  1. 必须落在同一时间窗口内的数据才能匹配
  2. 根据 key 进行匹配
  3. 只能匹配相同 key 的，类似于 inner join
SELECT * FROM table1 t1, table2 t2 WHERE t1.id = t2.id;

1.2、间隔联结（Interval join）

        Flink 并不建议使用 窗口联结（Window Join），因为缺点很明显：在有些场景下，我们要处理的时间间隔可能并不是固定的。比如，在交易系统中，需要实时地对每一笔交易进行核验，保证两个账户转入转出数额相等，也就是所谓的“实时对账”。两次转账的数据可能写入了不同的日志流，它们的时间戳应该相差不大，所以我们可以考虑只统计一段时间内是否有出账入账的数据匹配。这时显然不应该用滚动窗口或滑动窗口来处理——因为匹配的两个数据有可能刚好“卡在”窗口边缘两侧，于是窗口内就都没有匹配了；会话窗口虽然时间不固定，但也明显不适合这个场景。 基于时间的窗口联结已经无能为力了。
        为了应对这样的需求，Flink 提供了一种叫作“间隔联结”（interval join）的合流操作。顾名思义，间隔联结的思路就是针对一条流的每个数据，开辟出其时间戳前后的一段时间间隔，看这期间是否有来自另一条流的数据匹配。

1.2.1、间隔联结的原理

        间隔联结具体的定义方式是，我们给定两个时间点，分别叫作间隔的“上界”（upperBound）和“下界”（lowerBound）；于是对于一条流（不妨叫作 A）中的任意一个数据元素 a，就可以开辟一段时间间隔：[a.timestamp + lowerBound, a.timestamp + upperBound],即以 a 的时间戳为中心，下至下界点、上至上界点的一个闭区间：我们就把这段时间作为可以匹配另一条流数据的“窗口”范围。所以对于另一条流（不妨叫 B）中的数据元素 b，如果它的时间戳落在了这个区间范围内，a 和 b 就可以成功配对，进而进行计算输出结果。所以匹配的条件为：a.timestamp + lowerBound <= b.timestamp <= a.timestamp + upperBound这里需要注意，做间隔联结的两条流 A 和 B，也必须基于相同的 key；下界 lowerBound应该小于等于上界 upperBound，两者都可正可负；间隔联结目前只支持事件时间语义。

1.2.2、案例

package com.lyh.watermark;

import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.JoinFunction;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.tuple.Tuple3;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.co.ProcessJoinFunction;
import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.util.Collector;

public class IntervalJoinDemo {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        SingleOutputStreamOperator<Tuple2<String, Integer>> ds1 = env.fromElements(
                Tuple2.of("a", 1),
                Tuple2.of("a", 2),
                Tuple2.of("b", 2),
                Tuple2.of("c", 3)
        ).assignTimestampsAndWatermarks(
                WatermarkStrategy.<Tuple2<String, Integer>>forMonotonousTimestamps()
                        .withTimestampAssigner((value, ts) -> (value.f1 * 1000L))
        );

        SingleOutputStreamOperator<Tuple3<String, Integer,Integer>> ds2 = env.fromElements(
                Tuple3.of("a", 1,1),
                Tuple3.of("a", 3,1),
                Tuple3.of("b", 1,1),
                Tuple3.of("c", 2,1)
        ).assignTimestampsAndWatermarks(
                WatermarkStrategy.<Tuple3<String, Integer,Integer>>forMonotonousTimestamps()
                        .withTimestampAssigner((value, ts) -> (value.f1 * 1000L))
        );

        // interval join

        // 1. 分别做 keyby
        KeyedStream<Tuple2<String, Integer>, String> ks1 = ds1.keyBy(r1 -> r1.f0);
        KeyedStream<Tuple3<String, Integer, Integer>, String> ks2 = ds2.keyBy(r2 -> r2.f0);
        //2. 调用 interval join
        SingleOutputStreamOperator<String> process = ks1.intervalJoin(ks2)
                .between(Time.seconds(-2L), Time.seconds(2L))
                .process(new ProcessJoinFunction<Tuple2<String, Integer>, Tuple3<String, Integer, Integer>, String>() {
                    @Override
                    public void processElement(Tuple2<String, Integer> left, Tuple3<String, Integer, Integer> right, Context ctx, Collector<String> out) throws Exception {
                        out.collect(left + " <--------> " + right);
                    }
                });

        process.print();

        env.execute();
    }
}

我们同样定义了两条流：

​  流1            流2
(编号,时间s) (编号,时间s,其它)
("a", 1)     ("a", 1,1)
("a", 2)     ("a", 3,1)
("b", 2)     ("b", 1,1)
("c", 3)     ("c", 2,1)

运行结果：

(a,1) <--------> (a,1,1)
(a,1) <--------> (a,3,1)
(a,2) <--------> (a,1,1)
(a,2) <--------> (a,3,1)
(b,2) <--------> (b,1,1)
(c,3) <--------> (c,2,1)

可以看到，划分上下界相当于划分了一个[a.timestamp + lowerBound, a.timestamp + upperBound]的窗口（但其实不是窗口）。

1.3、迟到数据的处理

如果划分上下界后，还有迟到的数据怎么办？也就是两条流的 key 是可以匹配的，但是水位线已经被来了的数据推进到超出上界了，所以已经触发计算输出了，而这时候比如 ks1 有一条数据姗姗来迟，它是属于上下界范围内的，但是由于我们的水位线已经推进到超出上下界范围之外了，那么这个时候怎么处理呢？

        我们会把它放到侧输出流，一般做一个展示或者输出。

package com.lyh.watermark;

import org.apache.flink.api.common.eventtime.WatermarkStrategy;
import org.apache.flink.api.common.functions.MapFunction;
import org.apache.flink.api.common.typeinfo.Types;
import org.apache.flink.api.java.tuple.Tuple;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.api.java.tuple.Tuple3;
import org.apache.flink.streaming.api.datastream.KeyedStream;
import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.co.ProcessJoinFunction;
import org.apache.flink.streaming.api.windowing.time.Time;
import org.apache.flink.util.Collector;
import org.apache.flink.util.OutputTag;

import java.time.Duration;

public class IntervalJoinWithLateDemo {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        SingleOutputStreamOperator<Tuple2<String, Integer>> ds1 = env
                .socketTextStream("localhost",9999)
                .map(new MapFunction<String, Tuple2<String, Integer>>() {
                    @Override
                    public Tuple2<String, Integer> map(String value) throws Exception {
                        String[] datas = value.split(",");
                        return Tuple2.of(datas[0],Integer.valueOf(datas[1]));
                    }
                })
        .assignTimestampsAndWatermarks(
                WatermarkStrategy.<Tuple2<String, Integer>>forBoundedOutOfOrderness(Duration.ofSeconds(3))
                        .withTimestampAssigner((value, ts) -> (value.f1 * 1000L))
        );

        SingleOutputStreamOperator<Tuple3<String, Integer,Integer>> ds2 = env
                .socketTextStream("localhost",8888)
                .map(new MapFunction<String, Tuple3<String, Integer,Integer>>() {
                    @Override
                    public Tuple3<String, Integer,Integer> map(String value) throws Exception {
                        String[] datas = value.split(",");
                        return Tuple3.of(datas[0],Integer.valueOf(datas[1]),Integer.valueOf(datas[2]));
                    }
                })
                .assignTimestampsAndWatermarks(
                        WatermarkStrategy
                                // 允许迟到 3s
                                .<Tuple3<String, Integer,Integer>>forBoundedOutOfOrderness(Duration.ofSeconds(3))
                                .withTimestampAssigner((value, ts) -> (value.f1 * 1000L)
                ));

        // interval join

        // 1. 分别做 keyby
        KeyedStream<Tuple2<String, Integer>, String> ks1 = ds1.keyBy(r1 -> r1.f0);
        KeyedStream<Tuple3<String, Integer, Integer>, String> ks2 = ds2.keyBy(r2 -> r2.f0);
        //2. 调用 interval join
        OutputTag<Tuple2<String,Integer>> ks1Late = new OutputTag<>("ks1-late", Types.TUPLE(Types.STRING, Types.INT));
        OutputTag<Tuple3<String,Integer,Integer>> ks2Late = new OutputTag<>("ks2-late", Types.TUPLE(Types.STRING, Types.INT,Types.INT));
        SingleOutputStreamOperator<String> process = ks1.intervalJoin(ks2)
                .between(Time.seconds(-2L), Time.seconds(2L))
                .sideOutputLeftLateData(ks1Late)
                .sideOutputRightLateData(ks2Late)
                .process(new ProcessJoinFunction<Tuple2<String, Integer>, Tuple3<String, Integer, Integer>, String>() {
                    @Override
                    public void processElement(Tuple2<String, Integer> left, Tuple3<String, Integer, Integer> right, Context ctx, Collector<String> out) throws Exception {
                        out.collect(left + " <--------> " + right);
                    }
                });

        process.print("主流");
        process.getSideOutput(ks1Late).print("ks1 迟到数据");
        process.getSideOutput(ks2Late).print("ks2 迟到数据");

        env.execute();
    }
}

运行结果：

主流> (a,4) <--------> (a,3,3)
主流> (a,10) <--------> (a,11,11)
ks1 迟到数据> (a,3)
ks2 迟到数据> (a,5,5)

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

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

相关文章

大数据入门-什么是Flink

大数据入门-什么是Flink

这里简单介绍Flink的概念、架构、特性等。至于比较详细的介绍&#xff0c;会单独针对这个组件进行详细介绍&#xff0c;可以关注博客后续阅读。 一、概念 Apache Flink 是一个框架和分布式处理引擎&#xff0c;用于在无边界和有边界数据流上进行有状态的计算。 Flink的四大基…
阅读更多...
KubeVirt下gpu operator实践(GPU直通)

KubeVirt下gpu operator实践(GPU直通)

KubeVirt下gpu operator实践(GPU直通) 参考《在 KubeVirt 中使用 GPU Operator》&#xff0c;记录gpu operator在KubeVirt下实践的过程&#xff0c;包括虚拟机配置GPU直通&#xff0c;容器挂载GPU设备等。 KubeVirt 提供了一种将主机设备分配给虚拟机的机制。该机制具有通用性…
阅读更多...
How to update the content of one column in Mysql

How to update the content of one column in Mysql

How to update the content of one column in Mysql by another column name? UPDATE egg.eggs_record SET sold 2024-11-21 WHERE id 3 OR id 4;UPDATE egg.eggs_record SET egg_name duck egg WHERE id 2;
阅读更多...
【K8S系列】imagePullSecrets配置正确，但docker pull仍然失败，进一步排查详细步骤

【K8S系列】imagePullSecrets配置正确，但docker pull仍然失败，进一步排查详细步骤

如果 imagePullSecrets 配置正确，但在执行 docker pull 命令时仍然失败，可能存在以下几种原因。以下是详细的排查步骤和解决方案。 1. 检查 Docker 登录凭证 确保你使用的是与 imagePullSecrets 中相同的凭证进行 Docker 登录： 1.1 直接登录 在命令行中，执行以下命令： …
阅读更多...
机器学习基础06

机器学习基础06

目录 1.梯度下降 1.1梯度下降概念 1.2梯度下降公式 1.3学习率 1.4实现梯度下降 1.5API 1.5.1随机梯度下降SGD 1.5.2小批量梯度下降MBGD 1.6梯度下降优化 2.欠拟合过拟合 2.1欠拟合 2.2过拟合 2.3正则化 2.3.1L1正则项&#xff08;曼哈顿距离&#xff09; 2.3.2…
阅读更多...
徒手从零搭建一套ELK日志平台

徒手从零搭建一套ELK日志平台

徒手从零搭建一套ELK日志平台 日志分析的概述日志分析的作用主要收集工具集中式日志系统主要特点采集日志分类ELK概述初级版ELK终极版ELK高级版ELKELK收集日志的两种形式 搭建ELK平台Logstash工作原理Logstash核心概念环境准备安装部署docker添加镜像加速器安装部署Elasticsear…
阅读更多...
开源科学工程技术软件介绍 – EDA工具KLayout

开源科学工程技术软件介绍 – EDA工具KLayout

link 今天向各位知友介绍的 KLayout是一款由德国团队开发的开源EDA工具。 KLayout是使用C开发的&#xff0c;用户界面基于Qt。它支持Windows、MacOS和Linux操作系统。安装程序可以从下面的网址下载&#xff1a; https://www.klayout.de/build.html KLayout图形用户界面&…
阅读更多...
Linux离线安装Docker命令，简单镜像操作

Linux离线安装Docker命令，简单镜像操作

解压安装包 首先&#xff0c;使用 tar 命令解压 docker-27.3.1.tgz 安装包&#xff1a; tar -zxvf docker-27.3.1.tgz 将二进制文件移动到可执行路径上的目录 接着&#xff0c;将解压出来的 Docker 二进制文件复制到系统的可执行路径&#xff08;通常是 /usr/bin/&#xff09…
阅读更多...
Redis中常见的数据类型及其应用场景

Redis中常见的数据类型及其应用场景

五种常见数据类型 Redis中的数据类型指的是 value存储的数据类型&#xff0c;key都是以String类型存储的&#xff0c;value根据场景需要&#xff0c;可以以String、List等类型进行存储。 各数据类型介绍&#xff1a; Redis数据类型对应的底层数据结构 String 类型的应用场景 常…
阅读更多...
redis中的set类型及常用命令

redis中的set类型及常用命令

集合就是把一些有关联的数据放到一起。与list不同的是&#xff0c;集合中的顺序不重要&#xff0c;变换了元素的顺序&#xff0c;仍是同一个集合。集合中的元素是不能重复的。和list类似&#xff0c;集合中的每个元素&#xff0c;也都是string类型。 关于集合的相关命令 sadd/…
阅读更多...
Python的顺序表

Python的顺序表

一、脑图 二、封装一个顺序表的类 1.构造函数 class SeqList:#显性定义出构造函数def __init__(self,capacity 10):#初始化顺序表 &#xff0c;设置初始容量和已有元素self.capacity capacity #线性表的最大容量self.size 0 #已存储的元素个数self.data [None]*capacity…
阅读更多...
OpenCV从入门到精通实战(九)——基于dlib的疲劳监测 ear计算

OpenCV从入门到精通实战(九)——基于dlib的疲劳监测 ear计算

本文实现Python库d和OpenCV来实现眼部闭合检测&#xff0c;主要用于评估用户是否眨眼。 步骤一&#xff1a;导入必要的库和设置参数 首先&#xff0c;代码导入了必要的Python库&#xff0c;如dlib、OpenCV和scipy。通过argparse设置了输入视频和面部标记预测器的参数。 from…
阅读更多...
windows下，用CMake编译qt项目，出现错误By not providing “FindQt5.cmake“...

windows下，用CMake编译qt项目，出现错误By not providing “FindQt5.cmake“...

开发环境&#xff1a;windows10 qt5.14&#xff0c; 编译器msvc2017x64&#xff0c;CMake3.30&#xff1b; 现象&#xff1a; CMakeList文件里&#xff0c;如有find_package(Qt5 COMPONENTS Widgets REQUIRED) target_link_libraries(dis_lib PRIVATE Qt5::Widgets) 用CMak…
阅读更多...
基于SpringBoot+Vue的影院管理系统(含演示视频+运行截图+说明文档)

基于SpringBoot+Vue的影院管理系统(含演示视频+运行截图+说明文档)

web启动链接地址&#xff1a; http://localhost:8082&#xff08;管理端&#xff09; http://localhost:8081&#xff08;用户端&#xff09; http://localhost:8082&#xff08;员工端&#xff09; 一、项目介绍 基于框架的系统&#xff0c;系统分为用户、员工和管理员三个…
阅读更多...
SpringBoot3+Vue3开发图书馆管理系统

SpringBoot3+Vue3开发图书馆管理系统

1 项目介绍 图书馆管理系统&#xff0c;管理图书、用户、借书、还书、实时监测归还是否逾期&#xff0c;逾期未归还会生成违规记录。违规状态不可借阅图书。需缴纳罚金&#xff0c;消除违规记录。可动态设置图书最多累计借阅数量上限和最长借阅天数上限&#xff0c;当用户满足…
阅读更多...
Figure 02迎重大升级！！人形机器人独角兽[Figure AI]商业化加速

Figure 02迎重大升级！！人形机器人独角兽[Figure AI]商业化加速

11月19日知名人形机器人独角兽公司【Figure AI】发布公司汽车巨头【宝马】最新合作进展&#xff0c;旗下人形机器人Figure 02在生产线上的性能得到了显著提升&#xff0c;机器人组成自主舰队&#xff0c;依托端到端技术&#xff0c;速度提高了400%&#xff0c;执行任务成功率提…
阅读更多...
Oracle之Rman非归档模式下的完全恢复

Oracle之Rman非归档模式下的完全恢复

引言 首先Oracle必须处在非归档模式下才能模拟各种情况，Oracle处在非归档模式，做数据库脱机备份，并且rman的参数使用快闪恢复区作为备份文件的存储目录，配置了控制文件的自动备份。 联机全备 示例1：控制文件、数据文件以及重做日志文件丢失的恢复 数据文件以及重做日志…
阅读更多...
Android Google登录接入

Android Google登录接入

官方文献&#xff1a; 1、前期准备&#xff1a; https://developers.google.cn/identity/sign-in/android/legacy-start-integrating?hlzh-cnhttps://developers.google.cn/identity/sign-in/android/legacy-start-integrating?hlzh-cn 2、具体开发&#xff1a; 新版 Googl…
阅读更多...
Java 同步锁性能的最佳实践：从理论到实践的完整指南

Java 同步锁性能的最佳实践：从理论到实践的完整指南

目录 一、同步锁性能分析 &#xff08;一&#xff09;性能验证说明 1. 使用同步锁的代码示例 2. 不使用同步锁的代码示例 3. 结果与讨论 &#xff08;二&#xff09;案例初步优化分析说明 1. 使用AtomicInteger原子类尝试优化分析 2. 对AtomicInteger原子类进一步优化 …
阅读更多...
Docker+Nginx | Docker(Nginx) + Docker(fastapi)反向代理

Docker+Nginx | Docker(Nginx) + Docker(fastapi)反向代理

在DockerHub搜 nginx&#xff0c;第一个就是官方镜像库&#xff0c;这里使用1.27.2版本演示 1.下载镜像 docker pull nginx:1.27.2 2.测试运行 docker run --name nginx -p 9090:80 -d nginx:1.27.2 这里绑定了宿主机的9090端口&#xff0c;只要访问宿主机的9090端口&#…
阅读更多...
最新文章

Copyright @ 2022~2023