Flink代碼1

原創 從精通到陌生 2021-11-17 13:34

1.maven依賴

       <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-java</artifactId>
            <version>1.10.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-java_2.12</artifactId>
            <version>1.10.1</version>
        </dependency>

        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-kafka-0.11_2.12</artifactId>
            <version>1.10.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.bahir</groupId>
            <artifactId>flink-connector-redis_2.11</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-elasticsearch6_2.12</artifactId>
            <version>1.10.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.44</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-statebackend-rocksdb_2.12</artifactId>
            <version>1.10.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-planner_2.12</artifactId>
            <version>1.10.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-table-planner-blink_2.12</artifactId>
            <version>1.10.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-csv</artifactId>
            <version>1.10.1</version>
        </dependency>

2.sensor.txt

sensor_1,1547718199,35.8
sensor_6,1547718201,15.4
sensor_7,1547718202,6.7
sensor_10,1547718205,38.1
sensor_1,1547718207,36.3
sensor_1,1547718209,32.8
sensor_1,1547718212,37.1

 

3.bean

// 傳感器溫度讀數的數據類型
public class SensorReading {
    // 屬性：id，時間戳，溫度值
    private String id;
    private Long timestamp;
    private Double temperature;

    public SensorReading() {
    }

    public SensorReading(String id, Long timestamp, Double temperature) {
        this.id = id;
        this.timestamp = timestamp;
        this.temperature = temperature;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Long getTimestamp() {
        return timestamp;
    }

    public void setTimestamp(Long timestamp) {
        this.timestamp = timestamp;
    }

    public Double getTemperature() {
        return temperature;
    }

    public void setTemperature(Double temperature) {
        this.temperature = temperature;
    }

    @Override
    public String toString() {
        return "SensorReading{" +
                "id='" + id + '\'' +
                ", timestamp=" + timestamp +
                ", temperature=" + temperature +
                '}';
    }
}

 

4.source

public class SourceTest1_Collection {
    public static void main(String[] args) throws Exception {
        //創建執行環境
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        //從集合中讀取數據
        DataStream<SensorReading> dataStream = env.fromCollection(Arrays.asList(
                new SensorReading("sensor_1", 1547718199L, 35.8),
                new SensorReading("sensor_6", 1547718201L, 15.4),
                new SensorReading("sensor_7", 1547718202L, 6.7),
                new SensorReading("sensor_10", 1547718205L, 38.1)
        ));
        DataStream<Integer> integerDataStream = env.fromElements(1,2,4,67,189);

        //打印輸出
        dataStream.print("data");
        integerDataStream.print("int");

        //執行
        env.execute();

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

        // 從文件讀取數據
        DataStream<String> dataStream = env.readTextFile("D:\\workspace\\flinkworld\\src\\main\\resources\\sensor.txt");

        // 打印輸出
        dataStream.print();

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

        Properties properties = new Properties();
        properties.setProperty("bootstrap.servers", "localhost:9092");
        properties.setProperty("group.id", "consumer-group");
        properties.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty("auto.offset.reset", "latest");

        // 從文件讀取數據
        DataStream<String> dataStream = env.addSource( new FlinkKafkaConsumer011<String>("sensor", new SimpleStringSchema(), properties));

        // 打印輸出
        dataStream.print();

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

        // 從文件讀取數據
        DataStream<SensorReading> dataStream = env.addSource( new MySensorSource() );

        // 打印輸出
        dataStream.print();

        env.execute();

    }
    //實現自定義的SourceFunction
    public static class MySensorSource implements SourceFunction<SensorReading> {
        //定義一個標識位，用來控制數據的產生
        private boolean running = true;
        @Override
        public void run(SourceContext<SensorReading> ctx) throws Exception {
            //定義一個隨機數發生器
            Random random = new Random();

            //設置10個傳感器的初始溫度
            HashMap<String, Double> sensorTempMap = new HashMap<>();
            for(int i = 0; i< 10; i++) {
                sensorTempMap.put("sensor_"+(i+1),60+random.nextGaussian()*20);
            }

            while (running) {
                for(String sensorId : sensorTempMap.keySet()) {
                    // 在當前溫度基礎上隨機波動
                    Double newtemp = sensorTempMap.get(sensorId) + random.nextGaussian();
                    sensorTempMap.put(sensorId,newtemp);
                    ctx.collect(new SensorReading(sensorId,System.currentTimeMillis(),newtemp));
                }
                //控制輸出頻率
                Thread.sleep(2000L);
            }

        }

        @Override
        public void cancel() {
            running = false;
        }
    }
}

 

5.transform

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

        // 從文件讀取數據
        DataStream<String> inputStream = env.readTextFile("D:\\workspace\\flinkworld\\src\\main\\resources\\sensor.txt");

        //1.map,把String轉換成長度輸出
        DataStream<Integer> mapStream = inputStream.map(new MapFunction<String, Integer>() {
            @Override
            public Integer map(String value) throws Exception {
                return value.length();
            }
        });

        //2. flatmap,按逗號分字段
        DataStream<String> flatMapStream = inputStream.flatMap(new FlatMapFunction<String, String>() {
            @Override
            public void flatMap(String value, Collector<String> out) throws Exception {
                String[] fields = value.split(",");
                for(String field : fields) {
                    out.collect(field);
                }
            }
        });

        // 3. filter, 篩選sensor_1開頭的id對應的數據
        DataStream<String> filterStream = inputStream.filter(new FilterFunction<String>() {
            @Override
            public boolean filter(String value) throws Exception {
                return value.startsWith("sensor_1");
            }
        });

        // 打印輸出
        mapStream.print("map");
        flatMapStream.print("flatMap");
        filterStream.print("filter");

        env.execute();
    }
}
public class TransformTest2_RollingAggregation {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(4);

        // 從文件讀取數據
        DataStream<String> inputStream = env.readTextFile("D:\\workspace\\flinkworld\\src\\main\\resources\\sensor.txt");

        // 轉換成SensorReading類型
//        DataStream<SensorReading> dataStream = inputStream.map(new MapFunction<String, SensorReading>() {
//            @Override
//            public SensorReading map(String value) throws Exception {
//                String[] fields = value.split(",");
//                return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
//            }
//        });

        DataStream<SensorReading> dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        } );

        // 分組
        KeyedStream<SensorReading, Tuple> keyedStream = dataStream.keyBy("id");
        KeyedStream<SensorReading, String> keyedStream1 = dataStream.keyBy(data -> data.getId());

        DataStream<Long> dataStream1 = env.fromElements(1L, 34L, 4L, 657L, 23L);
        KeyedStream<Long, Integer> keyedStream2 = dataStream1.keyBy(new KeySelector<Long, Integer>() {
            @Override
            public Integer getKey(Long value) throws Exception {
                return value.intValue() % 2;
            }
        });

        //        KeyedStream<SensorReading, String> keyedStream1 = dataStream.keyBy(SensorReading::getId);

        // 滾動聚合，取當前最大的溫度值
        DataStream<SensorReading> resultStream = keyedStream.maxBy("temperature");

        resultStream.print("result");

        keyedStream1.print("key1");
        keyedStream2.sum(0).print("key2");
        env.execute();
    }
}
public class TransformTest3_Reduce {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        // 從文件讀取數據
        DataStream<String> inputStream = env.readTextFile("D:\\workspace\\flinkworld\\src\\main\\resources\\sensor.txt");

        // 轉換成SensorReading類型
        DataStream<SensorReading> dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        // 分組
        KeyedStream<SensorReading, Tuple> keyedStream = dataStream.keyBy("id");

        // reduce聚合，取最大的溫度值，以及當前最新的時間戳
        SingleOutputStreamOperator<SensorReading> resultStream = keyedStream.reduce(new ReduceFunction<SensorReading>() {
            @Override
            public SensorReading reduce(SensorReading value1, SensorReading value2) throws Exception {
                return new SensorReading(value1.getId(), value2.getTimestamp(), Math.max(value1.getTemperature(), value2.getTemperature()));
            }
        });

        keyedStream.reduce( (curState, newData) -> {
            return new SensorReading(curState.getId(), newData.getTimestamp(), Math.max(curState.getTemperature(), newData.getTemperature()));
        });

        resultStream.print();
        env.execute();
    }
}


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

        // 從文件讀取數據
        DataStream<String> inputStream = env.readTextFile("D:\\workspace\\flinkworld\\src\\main\\resources\\sensor.txt");

        // 轉換成SensorReading
        DataStream<SensorReading> dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        } );

        // 1. 分流，按照溫度值30度爲界分爲兩條流
        SplitStream<SensorReading> splitStream = dataStream.split(new OutputSelector<SensorReading>() {
            @Override
            public Iterable<String> select(SensorReading value) {
                return (value.getTemperature() > 30) ? Collections.singletonList("high") : Collections.singletonList("low");
            }
        });

        DataStream<SensorReading> highTempStream = splitStream.select("high");
        DataStream<SensorReading> lowTempStream = splitStream.select("low");
        DataStream<SensorReading> allTempStream = splitStream.select("high", "low");

        highTempStream.print("high");
        lowTempStream.print("low");
        allTempStream.print("all");

        // 2. 合流 connect，將高溫流轉換成二元組類型，與低溫流連接合並之後，輸出狀態信息
        DataStream<Tuple2<String, Double>> warningStream = highTempStream.map(new MapFunction<SensorReading, Tuple2<String, Double>>() {
            @Override
            public Tuple2<String, Double> map(SensorReading value) throws Exception {
                return new Tuple2<>(value.getId(), value.getTemperature());
            }
        });

        ConnectedStreams<Tuple2<String, Double>, SensorReading> connectedStreams = warningStream.connect(lowTempStream);

        DataStream<Object> resultStream = connectedStreams.map(new CoMapFunction<Tuple2<String, Double>, SensorReading, Object>() {
            @Override
            public Object map1(Tuple2<String, Double> value) throws Exception {
                return new Tuple3<>(value.f0, value.f1, "high temp warning");
            }

            @Override
            public Object map2(SensorReading value) throws Exception {
                return new Tuple2<>(value.getId(), "normal");
            }
        });

        resultStream.print();

        // 3. union聯合多條流
//        warningStream.union(lowTempStream);
        highTempStream.union(lowTempStream, allTempStream);

        env.execute();
    }
}


 






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

        // 從文件讀取數據
        DataStream<String> inputStream = env.readTextFile("D:\\workspace\\flinkworld\\src\\main\\resources\\sensor.txt");

        // 轉換成SensorReading類型
        DataStream<SensorReading> dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        DataStream<Tuple2<String, Integer>> resultStream = dataStream.map( new MyMapper() );

        resultStream.print();

        env.execute();
    }

    public static class MyMapper0 implements MapFunction<SensorReading, Tuple2<String, Integer>>{
        @Override
        public Tuple2<String, Integer> map(SensorReading value) throws Exception {
            return new Tuple2<>(value.getId(), value.getId().length());
        }
    }

    // 實現自定義富函數類
    public static class MyMapper extends RichMapFunction<SensorReading, Tuple2<String, Integer>>{
        @Override
        public Tuple2<String, Integer> map(SensorReading value) throws Exception {
//            getRuntimeContext().getState();
            return new Tuple2<>(value.getId(), getRuntimeContext().getIndexOfThisSubtask());
        }

        @Override
        public void open(Configuration parameters) throws Exception {
            // 初始化工作，一般是定義狀態，或者建立數據庫連接
            System.out.println("open");
        }

        @Override
        public void close() throws Exception {
            // 一般是關閉連接和清空狀態的收尾操作
            System.out.println("close");
        }
    }
}






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

        // 從文件讀取數據
        DataStream<String> inputStream = env.readTextFile("D:\\workspace\\flinkworld\\src\\main\\resources\\sensor.txt");

        // 轉換成SensorReading類型
        DataStream<SensorReading> dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        dataStream.print("input");

        // 1. shuffle
        DataStream<String> shuffleStream = inputStream.shuffle();

//        shuffleStream.print("shuffle");

        // 2. keyBy

//        dataStream.keyBy("id").print("keyBy");

        // 3. global
        dataStream.global().print("global");

        env.execute();
    }
}




 


6.sink




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

//        // 從文件讀取數據
//        DataStream<String> inputStream = env.readTextFile("D:\workspace\flinkworld\src\main\resources\sensor.txt");

        Properties properties = new Properties();
        properties.setProperty("bootstrap.servers", "localhost:9092");
        properties.setProperty("group.id", "consumer-group");
        properties.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        properties.setProperty("auto.offset.reset", "latest");

        // 從文件讀取數據
        DataStream<String> inputStream = env.addSource( new FlinkKafkaConsumer011<String>("sensor", new SimpleStringSchema(), properties));

        // 轉換成SensorReading類型
        DataStream<String> dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2])).toString();
        });

        dataStream.addSink( new FlinkKafkaProducer011<String>("localhost:9092", "sinktest", new SimpleStringSchema()));

        env.execute();
    }
}






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

        // 從文件讀取數據
        DataStream<String> inputStream = env.readTextFile("D:\\workspace\\flinkworld\\src\\main\\resources\\sensor.txt");

        // 轉換成SensorReading類型
        DataStream<SensorReading> dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        // 定義jedis連接配置
        FlinkJedisPoolConfig config = new FlinkJedisPoolConfig.Builder()
                .setHost("localhost")
                .setPort(6379)
                .build();

        dataStream.addSink( new RedisSink<>(config, new MyRedisMapper()));

        env.execute();
    }

    // 自定義RedisMapper
    public static class MyRedisMapper implements RedisMapper<SensorReading>{
        // 定義保存數據到redis的命令，存成Hash表，hset sensor_temp id temperature
        @Override
        public RedisCommandDescription getCommandDescription() {
            return new RedisCommandDescription(RedisCommand.HSET, "sensor_temp");
        }

        @Override
        public String getKeyFromData(SensorReading data) {
            return data.getId();
        }

        @Override
        public String getValueFromData(SensorReading data) {
            return data.getTemperature().toString();
        }
    }
}






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

        // 從文件讀取數據
        DataStream<String> inputStream = env.readTextFile("D:\\workspace\\flinkworld\\src\\main\\resources\\sensor.txt");

        // 轉換成SensorReading類型
        DataStream<SensorReading> dataStream = inputStream.map(line -> {
            String[] fields = line.split(",");
            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
        });

        // 定義es的連接配置
        ArrayList<HttpHost> httpHosts = new ArrayList<>();
        httpHosts.add(new HttpHost("localhost", 9200));

        dataStream.addSink(new ElasticsearchSink.Builder<SensorReading>(httpHosts, new MyEsSinkFunction()).build());

        env.execute();
    }

    // 實現自定義的ES寫入操作
    public static class MyEsSinkFunction implements ElasticsearchSinkFunction<SensorReading>{
        @Override
        public void process(SensorReading element, RuntimeContext ctx, RequestIndexer indexer) {
            // 定義寫入的數據source
            HashMap<String, String> dataSource = new HashMap<>();
            dataSource.put("id", element.getId());
            dataSource.put("temp", element.getTemperature().toString());
            dataSource.put("ts", element.getTimestamp().toString());

            // 創建請求，作爲向es發起的寫入命令
            IndexRequest indexRequest = Requests.indexRequest()
                    .index("sensor")
                    .type("readingdata")
                    .source(dataSource);

            // 用index發送請求
            indexer.add(indexRequest);
        }
    }
}






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

        // 從文件讀取數據
//        DataStream<String> inputStream = env.readTextFile("D:\workspace\flinkworld\src\main\resources\sensor.txt");
//
//        // 轉換成SensorReading類型
//        DataStream<SensorReading> dataStream = inputStream.map(line -> {
//            String[] fields = line.split(",");
//            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
//        });

        DataStream<SensorReading> dataStream = env.addSource(new SourceTest4_UDF.MySensorSource());

        dataStream.addSink(new MyJdbcSink());

        env.execute();
    }

    // 實現自定義的SinkFunction
    public static class MyJdbcSink extends RichSinkFunction<SensorReading> {
        // 聲明連接和預編譯語句
        Connection connection = null;
        PreparedStatement insertStmt = null;
        PreparedStatement updateStmt = null;

        @Override
        public void open(Configuration parameters) throws Exception {
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
            insertStmt = connection.prepareStatement("insert into sensor_temp (id, temp) values (?, ?)");
            updateStmt = connection.prepareStatement("update sensor_temp set temp = ? where id = ?");
        }

        // 每來一條數據，調用連接，執行sql
        @Override
        public void invoke(SensorReading value, Context context) throws Exception {
            // 直接執行更新語句，如果沒有更新那麼就插入
            updateStmt.setDouble(1, value.getTemperature());
            updateStmt.setString(2, value.getId());
            updateStmt.execute();
            if( updateStmt.getUpdateCount() == 0 ){
                insertStmt.setString(1, value.getId());
                insertStmt.setDouble(2, value.getTemperature());
                insertStmt.execute();
            }
        }

        @Override
        public void close() throws Exception {
            insertStmt.close();
            updateStmt.close();
            connection.close();
        }
    }
}




 











    





發表評論














所有評論



還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.







相關文章








Qt/C++音視頻開發71-指定mjpeg/h264格式採集本地攝像頭/存儲文件到mp4/設備推流/採集推流






一、前言
用ffmpeg採集本地攝像頭，如果不指定格式的話，默認小分辨率比如640x480使用rawvideo格式，大分辨率比如1280x720使用mjpeg格式，當然前提是這個攝像頭設備要支持這些格式。目前市面上有一些廠家做的本地設備支持






飛揚青雲

2024-04-25 14:40:54









git命令下，mac環境下載依賴相關報錯問題解決方案






1.安裝fundry框架curl -L https://foundry.paradigm.xyz | bash
2.寫入環境變量source /Users/xx/.bashrc
3.foundryup
問題1報錯：致命錯誤：無法訪問 'h






西紅柿愛喫馬鈴薯

2024-04-25 14:40:34









Python函數參數爲列表問題






def ADD(a):
print(3,a,hex(id(a)))
a.remove(2)
print(3,a,hex(id(a)))
a=a.append(10)






Danlis

2024-04-25 14:39:54









使用 NestJS 和 qrcode.js 創建 QR 碼生成器 API






前言
QR碼（Quick Response Code）是一種二維碼，於1994年開發。它能快速存儲和識別數據，包含黑白方塊圖案，常用於掃描獲取信息。QR碼具有高容錯性和快速讀取的優點，廣泛應用於廣告、支付、物流等領域。通過掃描QR碼，用戶可






葡萄城技術團隊

2024-04-25 14:39:44









ebpf在Android安全上的應用：ebpf的一些基礎知識(上篇)






ebpf在Android安全上的應用：ebpf的一些基礎知識(上篇)
一、ebpf介紹
eBPF 是一項革命性的技術，起源於 Linux 內核，它可以在特權上下文中（如操作系統內核）運行沙盒程序。它用於安全有效地擴展內核的功能，而無需通過更






windy_2

2024-04-25 14:36:53









CIRCLEQ_INSERT_AFTER, C語言循環隊列






 
CMakeLists.txt
# CMakeList.txt : CMake project for llist, include source and define
# project specific logic here.
#






mingzhanghui

2024-04-25 14:34:32









[MDP.BlazorCore] 快速建立跨Web、App執行的BlazorApp專案






團隊資源受限的時候，使用Blazor開發應用系統，只需開發一份程式碼及使用一種程式語言，就同時產出Web跟App應用系統。
本篇文章，紀錄使用MDP.BlazorCore所提供的樣板，快速建立跨Web、App執行的BlazorApp專案。為






Clark159

2024-04-25 14:32:42









Hessian矩陣以及在血管增強中的應用——OpenCV實現【2024年更新】






有別於廣爲人知的Sobel、Canny等一階算法，基於Hessian矩陣能夠得到圖像二階結果，這將幫助我們深入分析圖像本質。
Hessian矩陣在圖像處理中有着廣泛的應用：其中在圖像分割領域，包括邊緣檢測、紋理分析等；在圖像增強領域，包括邊






jsxyhelu

2024-04-25 14:32:02









七天.NET 8操作SQLite入門到實戰 - （2）第七天Blazor班級管理頁面編寫和接口對接






前言
上一章節我們引入BootstrapBlazor UI組件完成了EasySQLite後臺界面的基本架子的搭建，本章節的主要內容是Blazor班級管理頁面編寫和接口對接。
七天.NET 8 操作 SQLite 入門到實戰詳細教程
第一天






追逐時光

2024-04-25 14:30:41









WPF開源輕便、快速的桌面啓動器






前言
今天大姚給大家分享一款WPF開源、簡單、輕便、快速的桌面啓動器（支持多主題、多語言：簡體中文、繁體中文、英文等）：CurvaLauncher。
WPF介紹
WPF 是一個強大的桌面應用程序框架，用於構建具有豐富用戶界面的 Window






追逐時光

2024-04-25 14:30:41









MySQL 分庫分表方案，總結太全了。。






來源：https://www.cnblogs.com/405845829qq/p/7552736.html
前言
公司最近在搞服務分離，數據切分方面的東西，因爲單張包裹表的數據量實在是太大，並且還在以每天60W的量增長。 之前瞭解過數據庫的






Java技術棧

2024-04-25 14:30:11









公司來了個新同事，把 DDD 運用得爐火純青！






前言
我們生活中都聽說了DDD，也瞭解了DDD，那麼怎麼將一個新項目從頭開始按照DDD的過程進行劃分與架構設計呢？
一、專業術語
各種服務
IAAS：基礎設施服務，Infrastructure-as-a-service
PAAS：平臺服務






Java技術棧

2024-04-25 14:30:11









抖音的倒水問題, 計算機bfs求解






暴力求解 bfs方法.並且找到的一定是最少步驟
問題:
抖音上面又來了一個倒水遊戲
例子: 3個杯子, 容量12, 9, 5 上來12是滿的. 然後都沒有刻度只能倒到一個滿這種倒法, 然後最後希望倒出2個6ml的.
# 抖音上面又來了一個倒






張博的博客

2024-04-25 14:28:41









tar和zip包加密解密壓縮






 
 
1、概述
嗯，最近有些機密文件無處安放，因爲太機密了，後來確定加密後放到服務器上。研究一番後發現tar和zip命令都能實現，所以在此記錄一下。
壓縮：tar -zcvf - ./packageTest | openssl des3






馬昌偉

2024-04-25 14:22:40









解決mysql 事務死鎖的方法






使用以下命令查看引擎的狀態
SHOW ENGINE INNODB STATUS;
 
如果有事務死鎖可以看到如下圖的關鍵字
 
找到上圖的線程id 使用 kill 57763 .解決問題。
問題回放，事務死鎖如何產生？ 本地調試






雨V幕

2024-04-25 14:22:00