Elasticsearch8.x集成SpringBoot3.x

news2025/4/18 23:52:38

Elasticsearch8.x集成SpringBoot3.x

    • 配置项目
      • 引入依赖
      • 添加配置文件
      • 导入ca证书到项目中
      • 添加配置
    • 实战操作
      • 创建mapping
      • 创建文档
      • 查询更新
      • 全量更新
      • 删除数据
      • 批量操作(bulk)
      • 基本搜索
      • 复杂布尔搜索
      • 嵌套(nested)搜索
      • 分页查询
      • 滚动分页查询
      • After分页查询
      • 词条(terms)聚合
      • 日期聚合

配置项目

引入依赖


        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.16</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>co.elastic.clients</groupId>
            <artifactId>elasticsearch-java</artifactId>
            <version>8.8.0</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.12.3</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.12.3</version>
        </dependency>
        <dependency>
            <groupId>jakarta.json</groupId>
            <artifactId>jakarta.json-api</artifactId>
            <version>2.0.1</version>
        </dependency>

添加配置文件

application.yaml

spring:
  elasticsearch:
    rest:
      scheme: https
      host: localhost
      port: 9200
      username: elastic
      password: 123456
      crt: classpath:ca.crt

导入ca证书到项目中

从任意一个es容器中，拷贝证书到resources目录下，根据个人的目录来

/usr/share/elasticsearch/config/certs/ca

添加配置

package com.lglbc.elasticsearch;

import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.json.jackson.JacksonJsonpMapper;
import co.elastic.clients.transport.ElasticsearchTransport;
import co.elastic.clients.transport.TransportUtils;
import co.elastic.clients.transport.rest_client.RestClientTransport;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.elasticsearch.client.RestClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ResourceLoader;

import javax.net.ssl.SSLContext;
import java.io.IOException;

/**
 * @Description TODO
 * @Author 关注公众号 “乐哥聊编程” 领取资料和源码 
 * @Date 2023/07/14 21:04
 */
@Configuration
public class ElasticConfig {
    @Value("${spring.elasticsearch.rest.scheme}")
    private String scheme;
    @Value("${spring.elasticsearch.rest.host}")
    private String host;
    @Value("${spring.elasticsearch.rest.port}")
    private int port;
    @Value("${spring.elasticsearch.rest.crt}")
    private String crt;
    @Value("${spring.elasticsearch.rest.username}")
    private String username;
    @Value("${spring.elasticsearch.rest.password}")
    private String password;
    @Autowired
    private ResourceLoader resourceLoader;

    @Bean
    public ElasticsearchClient elasticsearchClient() throws IOException {

        SSLContext sslContext = TransportUtils
                .sslContextFromHttpCaCrt(resourceLoader.getResource(crt).getFile());
        BasicCredentialsProvider credsProv = new BasicCredentialsProvider();
        credsProv.setCredentials(
                AuthScope.ANY, new UsernamePasswordCredentials(username, password)
        );

        RestClient restClient = RestClient
                .builder(new HttpHost(host, port, scheme))
                .setHttpClientConfigCallback(hc -> hc
                        .setSSLContext(sslContext)
                        .setDefaultCredentialsProvider(credsProv)
                )
                .build();

// Create the transport and the API client
        ElasticsearchTransport transport = new RestClientTransport(restClient, new JacksonJsonpMapper());
        ElasticsearchClient client = new ElasticsearchClient(transport);
        return client;
    }
}

实战操作

创建mapping

    @Test
    public void testCreateMapping() throws IOException {
        PutMappingRequest mappingRequest = new PutMappingRequest.Builder().index("lglbc_java_demo")
                .properties("order_no", builder ->
                        builder.keyword(type -> type)
                ).properties("order_time", builder ->
                        builder.date(type -> type.format("yyyy-MM-dd HH:mm:ss"))
                ).properties("good_info", type -> type.nested(
                        nested -> nested
                                .properties("good_price", builder ->
                                        builder.double_(subType -> subType))
                                .properties("good_count", builder ->
                                        builder.integer(subType -> subType))
                                .properties("good_name", builder ->
                                        builder.text(subType ->
                                                subType.fields("keyword", subTypeField -> subTypeField.keyword(subSubType -> subSubType)))
                                ))
                ).properties("buyer", builder ->
                        builder.keyword(type -> type)
                ).properties("phone", builder ->
                        builder.keyword(type -> type)
                )
                .build();
        ElasticsearchIndicesClient indices = elasticsearchClient.indices();
        if (indices.exists(request -> request.index("lglbc_java_demo")).value()) {
            indices.delete(request -> request.index("lglbc_java_demo"));
        }
        indices.create(request -> request.index("lglbc_java_demo"));
        indices.putMapping(mappingRequest);
    }

创建文档

@Test
    public void testAddData() throws IOException {
        OrderInfo orderInfo = new OrderInfo("1001", new Date(), "李白", "13098762567");
        List<OrderInfo.GoodInfo> goodInfos = new ArrayList<>();
        goodInfos.add(new OrderInfo.GoodInfo("苹果笔记本", 30.5d, 30));
        goodInfos.add(new OrderInfo.GoodInfo("苹果手机", 20.5d, 10));
        orderInfo.setGoodInfo(goodInfos);
        IndexRequest<OrderInfo> request = IndexRequest.of(i -> i
                .index("lglbc_java_demo")
                .id(orderInfo.getOrderNo())
                .document(orderInfo)
        );
        OrderInfo orderInfo2 = new OrderInfo("1002", new Date(), "苏轼", "13098762367");
        List<OrderInfo.GoodInfo> goodInfos2 = new ArrayList<>();
        goodInfos2.add(new OrderInfo.GoodInfo("华为笔记本", 18.5d, 15));
        goodInfos2.add(new OrderInfo.GoodInfo("苹果手机", 20.5d, 10));
        orderInfo2.setGoodInfo(goodInfos2);
        IndexRequest<OrderInfo> request2 = IndexRequest.of(i -> i
                .index("lglbc_java_demo")
                .id(orderInfo2.getOrderNo())
                .document(orderInfo2)
        );
        elasticsearchClient.index(request);
        elasticsearchClient.index(request2);
    }

查询更新

    @Test
    public void testUpdateDataByQuery() throws IOException {
        UpdateByQueryRequest request = UpdateByQueryRequest.of(i -> i
                .index("lglbc_java_demo")
                .query(query -> query.term(term -> term.field("order_no").value("1001")))
                .script(script -> script.inline(inline -> inline.lang("painless").source("ctx._source['buyer'] = 'java 更新->乐哥聊编程'")))
        );
        elasticsearchClient.updateByQuery(request);
    }

全量更新

    @Test
    public void testUpdateData() throws IOException {
        OrderInfo orderInfo3 = new OrderInfo("1002", new Date(), "苏轼3", "13098762367");
        List<OrderInfo.GoodInfo> goodInfos3 = new ArrayList<>();
        goodInfos3.add(new OrderInfo.GoodInfo("华为笔记本", 18.5d, 15));
        goodInfos3.add(new OrderInfo.GoodInfo("苹果手机", 20.5d, 10));
        orderInfo3.setGoodInfo(goodInfos3);
        UpdateRequest request = UpdateRequest.of(i -> i
                .index("lglbc_java_demo")
                .id(orderInfo3.getOrderNo())
                .doc(orderInfo3)
        );
        elasticsearchClient.update(request, OrderInfo.class);
    }

删除数据

    @Test
    public void testDelete() throws IOException {
        DeleteRequest request = DeleteRequest.of(i -> i
                .index("lglbc_java_demo")
                .id("1002")
        );
        elasticsearchClient.delete(request);
    }

批量操作(bulk)

    @Test
    public void testBulkOperation() throws IOException {
        testCreateMapping();
        BulkRequest.Builder br = new BulkRequest.Builder();
        List<OrderInfo> orders = getOrders();
        for (OrderInfo orderInfo : orders) {
            br.operations(op -> op
                    .index(idx -> idx
                            .index("lglbc_java_demo")
                            .document(orderInfo)
                    )
            );
        }
        elasticsearchClient.bulk(br.build());
    }

基本搜索

    @Test
    public void testBaseSearch() throws IOException {
        SearchRequest request = SearchRequest.of(i -> i
                .index("lglbc_java_demo")
                .query(query -> query.term(
                        term -> term.field("order_no").value("1001")
                )));
        SearchResponse<OrderInfo> response = elasticsearchClient.search(request, OrderInfo.class);
        List<Hit<OrderInfo>> hits = response.hits().hits();
        List<OrderInfo> orderInfos = new ArrayList<>();
        for (Hit hit : hits) {
            orderInfos.add((OrderInfo) hit.source());
        }
        System.out.println(JSONUtil.toJsonStr(orderInfos));
    }

复杂布尔搜索

    @Test
    public void testBoolSearch() throws IOException {
        SearchRequest request = SearchRequest.of(i -> i
                .index("lglbc_java_demo")
                .query(query -> query.bool(bool -> bool
                        .filter(filterQuery -> filterQuery.term(term -> term.field("buyer").value("李白")))
                        .must(must -> must.term(term -> term.field("order_no").value("1004"))))));
        SearchResponse<OrderInfo> response = elasticsearchClient.search(request, OrderInfo.class);
        List<Hit<OrderInfo>> hits = response.hits().hits();
        List<OrderInfo> orderInfos = new ArrayList<>();
        for (Hit hit : hits) {
            orderInfos.add((OrderInfo) hit.source());
        }
        System.out.println(JSONUtil.toJsonStr(orderInfos));
    }

嵌套(nested)搜索

    @Test
    public void testNestedSearch() throws IOException {
        SearchRequest request = SearchRequest.of(i -> i
                .index("lglbc_java_demo")
                .query(query -> query.nested(nested -> nested
                        .path("good_info")
                        .query(nestedQuery -> nestedQuery.bool(
                                        bool -> bool
                                                .must(must -> must.range(range -> range.field("good_info.good_count").gte(JsonData.of("16"))))
                                                .must(must2 -> must2.range(range -> range.field("good_info.good_price").gte(JsonData.of("30"))))
                                )
                        )
                )));
        SearchResponse<OrderInfo> response = elasticsearchClient.search(request, OrderInfo.class);
        List<Hit<OrderInfo>> hits = response.hits().hits();
        List<OrderInfo> orderInfos = new ArrayList<>();
        for (Hit hit : hits) {
            orderInfos.add((OrderInfo) hit.source());
        }
        System.out.println(JSONUtil.toJsonStr(orderInfos));
    }

分页查询

   @Test
    public void testBasePageSearch() throws IOException {
        SearchRequest request = SearchRequest.of(i -> i
                .index("lglbc_java_demo")
                .from(0)
                .size(2).query(query -> query.matchAll(matchAll -> matchAll)));
        SearchResponse<OrderInfo> response = elasticsearchClient.search(request, OrderInfo.class);
        List<Hit<OrderInfo>> hits = response.hits().hits();
        List<OrderInfo> orderInfos = new ArrayList<>();
        for (Hit hit : hits) {
            orderInfos.add((OrderInfo) hit.source());
        }
        System.out.println(orderInfos.size());

        request = SearchRequest.of(i -> i
                .index("lglbc_java_demo")
                .from(2)
                .size(2).query(query -> query.matchAll(matchAll -> matchAll)));
        response = elasticsearchClient.search(request, OrderInfo.class);
        hits = response.hits().hits();
        orderInfos = new ArrayList<>();
        for (Hit hit : hits) {
            orderInfos.add((OrderInfo) hit.source());
        }
        System.out.println(orderInfos.size());

        request = SearchRequest.of(i -> i
                .index("lglbc_java_demo")
                .from(4)
                .size(2).query(query -> query.matchAll(matchAll -> matchAll)));
        response = elasticsearchClient.search(request, OrderInfo.class);
        hits = response.hits().hits();
        orderInfos = new ArrayList<>();
        for (Hit hit : hits) {
            orderInfos.add((OrderInfo) hit.source());
        }
        System.out.println(orderInfos.size());
    }

滚动分页查询

@Test
    public void testScrollPageSearch() throws IOException {
        String scrollId = null;
        while (true) {
            List<OrderInfo> orderInfos = new ArrayList<>();
            if (StringUtils.isBlank(scrollId)) {
                SearchRequest request = SearchRequest.of(i -> i
                        .index("lglbc_java_demo")
                        .scroll(Time.of(time -> time.time("1m")))
                        .size(2)
                        .query(query -> query.matchAll(matchAll -> matchAll)));
                SearchResponse<OrderInfo> response = elasticsearchClient.search(request, OrderInfo.class);
                List<Hit<OrderInfo>> hits = response.hits().hits();
                for (Hit hit : hits) {
                    orderInfos.add((OrderInfo) hit.source());
                }
                scrollId = response.scrollId();
            } else {
                String finalScrollId = scrollId;
                ScrollRequest request = ScrollRequest.of(i -> i
                        .scroll(Time.of(time -> time.time("1m")))
                        .scrollId(finalScrollId));
                ScrollResponse response = elasticsearchClient.scroll(request, OrderInfo.class);
                List<Hit<OrderInfo>> hits = response.hits().hits();
                for (Hit hit : hits) {
                    orderInfos.add((OrderInfo) hit.source());
                }
                scrollId = response.scrollId();
            }
            if (CollectionUtil.isEmpty(orderInfos)) {
                break;
            }
            System.out.println(orderInfos.size());
        }
    }

After分页查询

@Test
    public void testAfterPageSearch() throws IOException {
        final List<FieldValue>[] sortValue = new List[]{new ArrayList<>()};
        while (true) {
            List<OrderInfo> orderInfos = new ArrayList<>();
            SearchRequest request = SearchRequest.of(i -> {
                SearchRequest.Builder sort1 = i
                        .index("lglbc_java_demo")
                        .size(2)
                        .sort(Lists.list(
                                SortOptions.of(sort -> sort.field(field -> field.field("order_no").order(SortOrder.Desc))))
                        );
                if (CollectionUtil.isNotEmpty(sortValue[0])) {
                    sort1.searchAfter(sortValue[0]);
                }
                return sort1
                        .query(query -> query.matchAll(matchAll -> matchAll));
            });
            SearchResponse<OrderInfo> response = elasticsearchClient.search(request, OrderInfo.class);
            List<Hit<OrderInfo>> hits = response.hits().hits();
            for (Hit hit : hits) {
                orderInfos.add((OrderInfo) hit.source());
                sortValue[0] = hit.sort();
            }
            if (CollectionUtil.isEmpty(orderInfos)) {
                break;
            }
            System.out.println(orderInfos.size());
        }

    }

词条(terms)聚合

@Test
    public void testTermsAgg() throws IOException {
        SearchRequest request = SearchRequest.of(i -> i
                .index("lglbc_java_demo")
                .query(query -> query
                        .matchAll(match->match))
                .aggregations("agg_term_buyer",agg->agg
                        .dateHistogram(dateHistogram->dateHistogram
                                .field("order_time")
                                .calendarInterval(CalendarInterval.Day))));
        SearchResponse<Void> search = elasticsearchClient.search(request, Void.class);
        Map<String, Aggregate> aggregations = search.aggregations();
        Aggregate aggregate = aggregations.get("agg_term_buyer")
                ;
        Buckets<StringTermsBucket> buckets = ((StringTermsAggregate) aggregate._get()).buckets();
        for (StringTermsBucket bucket : buckets.array()) {
            String key = bucket.key()._toJsonString();
            long l = bucket.docCount();
            System.out.println(key+":::"+l);
        }
    }

日期聚合

@Test
    public void testDateAgg() throws IOException {
        SearchRequest request = SearchRequest.of(i -> i
                .index("lglbc_java_demo")
                .query(query -> query
                        .matchAll(match->match))
                .aggregations("agg_date_buyer",agg->agg
                        .dateHistogram(dateHistogram->dateHistogram
                                .field("order_time")
                                .calendarInterval(CalendarInterval.Day))));
        SearchResponse<Void> search = elasticsearchClient.search(request, Void.class);
        Map<String, Aggregate> aggregations = search.aggregations();
        Aggregate aggregate = aggregations.get("agg_date_buyer");
        List<DateHistogramBucket> buckets = ((DateHistogramAggregate) aggregate._get()).buckets().array();
        System.out.println(aggregate);
        for (DateHistogramBucket bucket : buckets) {
            String key = bucket.keyAsString();
            long l = bucket.docCount();
            System.out.println(key+":::"+l);
        }
    }

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

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

相关文章

基于labview的多功能数据采集系统

基于labview的多功能数据采集系统

基于labview的多功能数据采集系统&#xff08;可定制功能&#xff09; 包含基于NI温度采集卡。电流采集卡。电压采集卡的数据采集功能 数据存储 报表存储 数据处理与分析 生产者消费者架构 有需要可联系
阅读更多...
SpringMVC基础一（SpringMVC运行原理）

SpringMVC基础一（SpringMVC运行原理）

先了解MVC&#xff0c;在JavaWeb基础五中。 回忆servlet&#xff0c;在javaweb基础二中。 创建一个web项目&#xff1a; 1、新建maven项目&#xff0c;导入依赖。&#xff08;junit、springmvc、spring-webmvc、servlet-api、jsp-api、jstl&#xff09; <groupId>org…
阅读更多...
蓝桥杯刷题--宝石组合

蓝桥杯刷题--宝石组合

在一个神秘的森林里&#xff0c;住着一个小精灵名叫小蓝。有一天&#xff0c;他偶然发现了一个隐藏在树洞里的宝藏&#xff0c;里面装满了闪烁着美丽光芒的宝石。这些宝石都有着不同的颜色和形状&#xff0c;但最引人注目的是它们各自独特的 “闪亮度” 属性。每颗宝石都有一个…
阅读更多...
红宝书第三十一讲：通俗易懂的包管理器指南：npm 与 Yarn

红宝书第三十一讲：通俗易懂的包管理器指南：npm 与 Yarn

红宝书第三十一讲&#xff1a;通俗易懂的包管理器指南&#xff1a;npm 与 Yarn 资料取自《JavaScript高级程序设计&#xff08;第5版&#xff09;》。 查看总目录&#xff1a;红宝书学习大纲 一、基础概念 包管理器&#xff1a;帮你自动下载和管理第三方代码库&#xff08;如…
阅读更多...
进程状态的转换

进程状态的转换

进程处于运行态时&#xff0c;它必须已获得所需的资源&#xff0c;在运行结束后就撤销。只有在时间片到或出现了比现在进程优先级更高的进程时才转变成就绪态。 就绪 → 运行​​ ​​触发条件​​&#xff1a;进程被​​调度器选中​​&#xff08;如时间片轮转或优先级调度&…
阅读更多...
SpringAOP新链浅析

SpringAOP新链浅析

前言 在复现CCSSSC软件攻防赛的时候发现需要打SpringAOP链子&#xff0c;于是跟着前人的文章自己动手调试了一下 参考了大佬的文章 https://gsbp0.github.io/post/springaop/#%E6%B5%81%E7%A8%8B https://mp.weixin.qq.com/s/oQ1mFohc332v8U1yA7RaMQ 正文 依赖于Spring-AO…
阅读更多...
【动手学深度学习】现代卷积神经网络：ALexNet

【动手学深度学习】现代卷积神经网络：ALexNet

【动手学深度学习】现代卷积神经网络&#xff1a;ALexNet 1&#xff0c;ALexNet简介2&#xff0c;AlexNet和LeNet的对比3&#xff0c; AlexNet模型详细设计4&#xff0c;AlexNet采用ReLU激活函数4.1&#xff0c;ReLU激活函数4.2&#xff0c;sigmoid激活函数4.3&#xff0c;为什…
阅读更多...
PyTorch深度学习框架60天进阶学习计划 - 第37天：元学习框架

PyTorch深度学习框架60天进阶学习计划 - 第37天：元学习框架

PyTorch深度学习框架60天进阶学习计划 - 第37天&#xff1a;元学习框架 嘿&#xff0c;朋友们&#xff01;欢迎来到我们PyTorch进阶之旅的第37天。今天我们将深入探索一个非常有趣且强大的领域——元学习(Meta-Learning)&#xff0c;也被称为"学会学习"(Learning to…
阅读更多...
【中检在线-注册安全分析报告】

【中检在线-注册安全分析报告】

前言 由于网站注册入口容易被黑客攻击&#xff0c;存在如下安全问题&#xff1a; 1. 暴力破解密码&#xff0c;造成用户信息泄露 2. 短信盗刷的安全问题&#xff0c;影响业务及导致用户投诉 3. 带来经济损失&#xff0c;尤其是后付费客户&#xff0c;风险巨大&#xff0c;造…
阅读更多...
UE5 运行时动态将玩家手部模型设置为相机的子物体

UE5 运行时动态将玩家手部模型设置为相机的子物体

在编辑器里&#xff0c;我们虽然可以手动添加相机&#xff0c;但是无法将网格体设置为相机的子物体&#xff0c;只能将相机设置为网格体的子物体 但是为了使用方便&#xff0c;我们希望将网格体设置为相机的子物体&#xff0c;这样我们直接旋转相机就可以旋转网格体&#xff0…
阅读更多...
EasyExcel-一款好用的excel生成工具

EasyExcel-一款好用的excel生成工具

EasyExcel是一款处理excel的工具类&#xff0c;主要特点如下&#xff08;官方&#xff09;&#xff1a; 特点 高性能读写&#xff1a;FastExcel 专注于性能优化&#xff0c;能够高效处理大规模的 Excel 数据。相比一些传统的 Excel 处理库&#xff0c;它能显著降低内存占用。…
阅读更多...
WEB攻防-Java安全JNDIRMILDAP五大不安全组件RCE执行不出网不回显

WEB攻防-Java安全JNDIRMILDAP五大不安全组件RCE执行不出网不回显

目录 1. RCE执行-5大类函数调用 1.1 Runtime方式 1.2 Groovy执行命令 1.3 脚本引擎代码注入 1.4 ProcessImpl 1.5 ProcessBuilder 2. JNDI注入(RCE)-RMI&LDAP&高版本 2.1 RMI服务中的JNDI注入场景 2.2 LDAP服务中的JNDI注入场景 攻击路径示例&#…
阅读更多...
DrissionPage移动端自动化：从H5到原生App的跨界测试

DrissionPage移动端自动化：从H5到原生App的跨界测试

一、移动端自动化测试的挑战与机遇 移动端测试面临多维度挑战&#xff1a; 设备碎片化&#xff1a;Android/iOS版本、屏幕分辨率差异 混合应用架构&#xff1a;H5页面与原生组件的深度耦合 交互复杂性&#xff1a;多点触控、手势操作、传感器模拟 性能监控&#xff1a;内存…
阅读更多...
从 Excel 到你的表格应用：条件格式功能的嵌入实践指南

从 Excel 到你的表格应用：条件格式功能的嵌入实践指南

一、引言 在日常工作中&#xff0c;面对海量数据时&#xff0c;如何快速识别关键信息、发现数据趋势或异常值&#xff0c;是每个数据分析师面临的挑战。Excel的条件格式功能通过自动化的视觉标记&#xff0c;帮助用户轻松应对这一难题。 本文将详细介绍条件格式的应用场景&am…
阅读更多...
STM32单片机入门学习——第22节: [7-2] AD单通道AD多通道

STM32单片机入门学习——第22节: [7-2] AD单通道AD多通道

写这个文章是用来学习的,记录一下我的学习过程。希望我能一直坚持下去,我只是一个小白,只是想好好学习,我知道这会很难&#xff0c;但我还是想去做&#xff01; 本文写于&#xff1a;2025.04.07 STM32开发板学习——第22节: [7-2] AD单通道&AD多通道 前言开发板说明引用解…
阅读更多...
【Survival Analysis】【机器学习】【1】

【Survival Analysis】【机器学习】【1】

前言&#xff1a; 今年在做的一个博士课题项目&#xff0c;主要是利用病人的数据&#xff0c;训练出一个AI模型&#xff0c;做因果分析&#xff0c; 以及个性化治疗。自己一直是做通讯AI方向的&#xff0c;这个系列主要参考卡梅隆大学的教程&#xff0c;以及临床医生的角度 了…
阅读更多...
JavaScript---原型和原型链

JavaScript---原型和原型链

目录 一、引用类型皆为对象 二、原型和原型链是什么 三、__proto__与prototype 总结 四、原型链顶层 五、constructor 六、函数对象的原型链 一、引用类型皆为对象 原型和原型链都是来源于对象而服务于对象&#xff1a; JavaScript中一切引用类型都是对象&#xff0c;…
阅读更多...
离散数学问题集--问题5.9

离散数学问题集--问题5.9

问题 5.9 综合了计算机组成原理、数字逻辑和离散数学中的关键概念&#xff0c;旨在帮助学生理解二进制算术运算的硬件实现、逻辑门与算术运算的关系&#xff0c;以及如何使用数学方法来验证数字系统的正确性。它强调了从规范到实现再到验证的完整过程。 思想 函数抽象&#xf…
阅读更多...
Java—HTML：CSS选择器

Java—HTML：CSS选择器

今天我要介绍的知识点内容是Java HTML中的CSS选择器&#xff1b; CSS选择器用于定位HTML元素并为其添加样式。它允许我们控制网页的颜色、字体、布局和其他视觉元素。通过分离内容与样式。 下面我将介绍CSS中选择器的使用&#xff0c;并作举例说明&#xff1b; 选择器基本语…
阅读更多...
SSM阶段性总结

SSM阶段性总结

0 Pojo类 前端给后端&#xff1a;DTO 后端给前端&#xff1a;VO 数据库&#xff1a;PO/VO 业务处理逻辑&#xff1a;BO 统称pojo 1 代理模式 实现静态代理&#xff1a; 1定义接口2实现类3写一个静态代理类4这样在调用时就可以使用这个静态代理类来实现某些功能 实现动态代…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023