Elasticsearch(三)

news2025/1/10 23:40:33

Elasticsearch(三)

数据聚合

聚合的分类

文档:https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations.html

聚合可以实现对文档数据的统计、分析、运算。聚合常见的有三类:

  • 桶聚合:用来对文档做分组

    • TermAggregation:按文档字段值分组
    • Date Histogram:按照日期阶梯分组,例如一周为一组,或者一月为一组
  • 度量聚合:可以计算一些值,比如:最大值、最小值、平均值等

    • Avg:求平均值
    • Max:求最大值
    • Min:求最小值
    • Stats:同时求max、min、avg、sum等
  • 管道聚合:其它聚合的结果为基础做聚合

DSL实现Bucket聚合

现在,我们要统计所有数据中的酒店品牌有几种,此时可以根据酒店品牌名称做聚合。类型为term类型,DSL示例:

GET /hotel/_search
{
  "size":0,  // 设置size为0,结果中不包含文档,只包含聚合结果
  "aggs": {  // 定义聚合
    "brandAgg": {  //给聚合起个名字
      "terms": {   //集合类型,按照品牌值聚合,所以选择term
        "field": "brand",  // 参与聚合的字段
        "size": 20 // 希望获取聚合结果数量
      }
    }
  }
}

Bucket聚合-聚合结果排序

默认情况下,Bucket聚合会统计Bucket的文档数量,记为_count,并且按照_count降序排序。

我们可以修改结果排序方式:

GET /hotel/_search
{
  "size":0,
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20,
        "order": {
          "_count": "asc" // 按照_count升序排序
        }
      }
    }
  }
}

Bucket聚合-限定聚合范围

默认情况下,Bucket聚合是对索引库的所有文档做聚合,我们可以限定要聚合文档范围,只要添加query条件即可:

GET /hotel/_search
{
  "query": {
    "range": {
      "price": {
        "lte": 200 // 只对200元以下的文档聚合
      }
    }
  }, 
  "size":0,
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20
      }
    }
  }
}

DSL实现Metrics聚合

例如,我们要求获取每个品牌的用户评分min、max、avg等值。

我们可以利用stats聚合:

GET /hotel/_search
{
  "size":0,
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20
      },
      "aggs": {
        "scoreAgg": {
          "stats": {
            "field": "score"
          }
        }
      }
    }
  }
}

对结果的平均值做排序

GET /hotel/_search
{
  "size":0,
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20,
        "order":{
            "scoreAgg.avg": "desc" // 排序
          }
      },
      "aggs": {
        "scoreAgg": {
          "stats": {
            "field": "score"
          }
        }
      }
    }
  }
}

RestAPI实现聚合

img

解析聚合结果

img

案例:在IUserService中定义方法,实现对品牌、城市、星级的聚合

声明接口

Map<String, List<String>> filters();

实现

    @Override
    public Map<String, List<String>> filters(){
        // 1.准备Request
        SearchRequest request = new SearchRequest("hotel");
        request.source().size(0);
        request.source().aggregation(AggregationBuilders
                .terms("brandAgg")
                .field("brand")
                .size(100));
        request.source().aggregation(AggregationBuilders
                .terms("cityAgg")
                .field("city")
                .size(100));
        request.source().aggregation(AggregationBuilders
                .terms("starAgg")
                .field("starName")
                .size(100));
        SearchResponse search = null;
        Map<String,List<String>> map = new HashMap<>();
        try {
            search = client.search(request, RequestOptions.DEFAULT);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        List<String> brandList = getAggByName(search, "brandAgg");
        map.put("品牌",brandList);
        List<String> cityList = getAggByName(search, "cityAgg");
        map.put("城市",cityList);
        List<String> starList = getAggByName(search, "starAgg");
        map.put("星级",starList);
        return map;
    }

    private static List<String> getAggByName(SearchResponse search, String aggName) {
        Aggregations aggregations = search.getAggregations();
        Terms brandTerms = aggregations.get(aggName);
        List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
        ArrayList<String> list = new ArrayList<>();
        for (Terms.Bucket bucket : buckets) {
            String key = bucket.getKeyAsString();
            list.add(key);
        }
        return list;
    }

对接前端

    @Override
    public Map<String, List<String>> filters(RequestParams params){
        // 1.准备Request
        SearchRequest request = new SearchRequest("hotel");
        buildBasicQuery(params, request);
        request.source().size(0);
        buildAggregation(request);
        SearchResponse search = null;
        Map<String,List<String>> map = new HashMap<>();
        try {
            search = client.search(request, RequestOptions.DEFAULT);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        List<String> brandList = getAggByName(search, "brandAgg");
        map.put("品牌",brandList);
        List<String> cityList = getAggByName(search, "cityAgg");
        map.put("城市",cityList);
        List<String> starList = getAggByName(search, "starAgg");
        map.put("星级",starList);
        return map;
    }

    private static void buildAggregation(SearchRequest request) {
        request.source().aggregation(AggregationBuilders
                .terms("brandAgg")
                .field("brand")
                .size(100));
        request.source().aggregation(AggregationBuilders
                .terms("cityAgg")
                .field("city")
                .size(100));
        request.source().aggregation(AggregationBuilders
                .terms("starAgg")
                .field("starName")
                .size(100));
    }

    private static List<String> getAggByName(SearchResponse search, String aggName) {
        Aggregations aggregations = search.getAggregations();
        Terms brandTerms = aggregations.get(aggName);
        List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
        ArrayList<String> list = new ArrayList<>();
        for (Terms.Bucket bucket : buckets) {
            String key = bucket.getKeyAsString();
            list.add(key);
        }
        return list;
    }

    private static void buildBasicQuery(RequestParams params, SearchRequest request) {
        // 2.准备DSL
        // 构建BooleanQuery
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        // 关键字搜索
        String key = params.getKey();
        if (StringUtils.isBlank(key)) {
            boolQuery.must(QueryBuilders.matchAllQuery());
        } else {
            boolQuery.must(QueryBuilders.matchQuery("all", key));
        }
        // 城市条件
        if (params.getCity() != null && !params.getCity().equals("")) {
            boolQuery.filter(QueryBuilders.termQuery("city", params.getCity()));
        }
        // 品牌条件
        if (params.getBrand() != null && !params.getBrand().equals("")) {
            boolQuery.filter(QueryBuilders.termQuery("brand", params.getBrand()));
        }
        // 星级条件
        if (params.getStarName() != null && !params.getStarName().equals("")) {
            boolQuery.filter(QueryBuilders.termQuery("starName", params.getStarName()));
        }
        // 价格条件
        if (params.getMinPrice() != null && params.getMaxPrice() != null) {
            boolQuery.filter(QueryBuilders.rangeQuery("price").gte(params.getMinPrice()).lte(params.getMaxPrice()));
        }
        // 2.算分
        FunctionScoreQueryBuilder functionScoreQueryBuilder = QueryBuilders
                .functionScoreQuery(boolQuery, new FunctionScoreQueryBuilder.FilterFunctionBuilder[]{
                        new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                                QueryBuilders.termQuery("isAD",true),
                                ScoreFunctionBuilders.weightFactorFunction(10)
                        )
                });

        request.source().query(functionScoreQueryBuilder);
    }

自动补全

使用拼音分词器

官网:https://github.com/medcl/elasticsearch-analysis-pinyin

  • 解压
  • 上传到虚拟机中,elasticsearch的plugin目录
  • 重启es
  • 测试

自定义分词器

elasticsearch中分词器的组成包含三部分:

  • character filters:在tokenizer之前对文本进行处理。例如删除字符、替换字符
  • tokenizer:将文本按照一定的规则切割成词条。例如keyword,就是不分词;还有ik_smart
  • tokenizer filter:将tokenizer输出的词条做进一步处理。例如大小写转换、同义词处理、拼音处理等

img

可以通过创建索引库时,通过settings来配置自定义analyzer(分词器):

img

// 自定义拼音分词器
PUT /test
{
  "settings": {
    "analysis": {
      "analyzer": { 
        "my_analyzer": { 
          "tokenizer": "ik_max_word",
          "filter": "py"
        }
      },
      "filter": {
        "py": { 
          "type": "pinyin",
          "keep_full_pinyin": false,
          "keep_joined_full_pinyin": true,
          "keep_original": true,
          "limit_first_letter_length": 16,
          "remove_duplicated_term": true,
          "none_chinese_pinyin_tokenize": false
        }
      }
    }
  }
}

拼音分词器适合在创建倒排索引的时候使用,但不能在搜索的时候使用。

img

因此字段在创建倒排索引时应该使用my_analyzer分词器;字段在搜索时应该使用ik_smart分词器

PUT /test
{
  "settings": {
    "analysis": {
      "analyzer": { 
        "my_analyzer": { 
          "tokenizer": "ik_max_word",
          "filter": "py"
        }
      },
      "filter": {
        "py": { 
          "type": "pinyin",
          "keep_full_pinyin": false,
          "keep_joined_full_pinyin": true,
          "keep_original": true,
          "limit_first_letter_length": 16,
          "remove_duplicated_term": true,
          "none_chinese_pinyin_tokenize": false
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "name":{
        "type": "text",
        "analyzer": "my_analyzer",
        "search_analyzer": "ik_smart"
      }
    }
  }
}

completion suggester查询

es提供了Completion Suggester查询来实现自动补全功能。这个查询会匹配以用户输入内容开头的词条并返回。为了提高补全查询效率,对于文档中字段的类型有一些约束:

  • 参与补全查询的字段必须时completion类型
  • 字段的内容一般是用来补全的多个词条形成的数组。

img

查询语法:

GET /test2/_search
{
  "suggest": {
    "titleSuggest": {
      "text": "s",
      "completion": {
        "field": "title",
        "skip_duplicates":true,
        "size":10
      }
    }
  }
}

案例:实现hotel索引库的自动补全、拼音搜索功能

1.修改hotel索引库,设置自定义拼音分词器

2.修改索引库的name、all字段、使用自定义分词器

3.索引库添加一个新字段suggestion,类型为completion类型,使用自定义分词器

4.给HotelDoc类添加suggestion类型,内容包含brand、business

5.重新导入数据到hotel库

PUT /hotel
{
  "settings": {
    "analysis": {
      "analyzer": {
        "text_anlyzer": {
          "tokenizer": "ik_max_word",
          "filter": "py"
        },
        "completion_analyzer": {
          "tokenizer": "keyword",
          "filter": "py"
        }
      },
      "filter": {
        "py": {
          "type": "pinyin",
          "keep_full_pinyin": false,
          "keep_joined_full_pinyin": true,
          "keep_original": true,
          "limit_first_letter_length": 16,
          "remove_duplicated_term": true,
          "none_chinese_pinyin_tokenize": false
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "id":{
        "type": "keyword"
      },
      "name":{
        "type": "text",
        "analyzer": "text_anlyzer",
        "search_analyzer": "ik_smart",
        "copy_to": "all"
      },
      "address":{
        "type": "keyword",
        "index": false
      },
      "price":{
        "type": "integer"
      },
      "score":{
        "type": "integer"
      },
      "brand":{
        "type": "keyword",
        "copy_to": "all"
      },
      "city":{
        "type": "keyword"
      },
      "starName":{
        "type": "keyword"
      },
      "business":{
        "type": "keyword",
        "copy_to": "all"
      },
      "location":{
        "type": "geo_point"
      },
      "pic":{
        "type": "keyword",
        "index": false
      },
      "all":{
        "type": "text",
        "analyzer": "text_anlyzer",
        "search_analyzer": "ik_smart"
      },
      "suggestion":{
          "type": "completion",
          "analyzer": "completion_analyzer"
      }
    }
  }
}

RestAPI实现自动补全

请求构造API:

img

结果解析

img

案例:实现酒店搜索页面输入框的自动补全

    @Override
    public List<String> getSuggestions(String prefix) {
        SearchRequest request = new SearchRequest("hotel");
        request.source().suggest(new SuggestBuilder().addSuggestion(
                "suggestions",
                SuggestBuilders.completionSuggestion("suggestion")
                        .prefix(prefix)
                        .skipDuplicates(true)
                        .size(10)
        ));
        SearchResponse search = null;
        try {
            search = client.search(request, RequestOptions.DEFAULT);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        Suggest suggest = search.getSuggest();
        CompletionSuggestion suggestions = suggest.getSuggestion("suggestions");
        List<String> list = new ArrayList<>();
        for (CompletionSuggestion.Entry.Option option : suggestions.getOptions()) {
            String text = option.getText().string();
            list.add(text);
        }
        return list;
    }

数据同步

数据同步问题分析

es中的酒店数据来自于mysql数据库,因此mysql数据发生改变时,es也必须跟着改变,这个就是es的数据同步

img

方案一:同步调用

  • 优点:实现简单,粗暴
  • 缺点:业务耦合度高

img

方案二:异步调用

  • 优点:低耦合,实现难度一般
  • 缺点:依赖mq的可靠性

img

方案三:监听binlog

  • 优点:完全解除服务间耦合
  • 缺点:开启binlog增加数据库负担、实现复杂度高

img

案例:利用MQ实现mysql与es数据同步

定义交换机,队列,routingkey的常量

package cn.itcast.hotel.constants;

/**
 * @author xc
 * @date 2023/5/12 13:06
 */
public class MqConstants {
    /**
     * 交换机
     */
    private final static String HOTEL_EXCHANGE = "hotel.topic";

    /**
     * 监听新增和修改的队列
     */
    private final static String HOTEL_INSERT_QUEUE = "hotel.insert.queue";

    /**
     * 监听删除的队列
     */
    private final static String HOTEL_DELETE_QUEUE = "hotel.delete.queue";

    /**
     * 新增或修改的RoutingKey
     */
    private final static String HOTEL_INSERT_KEY = "hotel.insert";
    /**
     * 删除key
     */
    private final static String HOTEL_DELETE_KEY = "hotel.delete";

}

声明exchange、queue、RoutingKey

package cn.itcast.hotel.config;

import cn.itcast.hotel.constants.MqConstants;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author xc
 * @date 2023/5/12 13:30
 */
@Configuration
public class MqConfig {
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange(MqConstants.HOTEL_EXCHANGE,true,false);
    }

    @Bean
    public Queue insertQueue(){
        return new Queue(MqConstants.HOTEL_INSERT_QUEUE,true);
    }

    @Bean
    public Queue deleteQueue(){
        return new Queue(MqConstants.HOTEL_DELETE_QUEUE,true);
    }

    @Bean
    public Binding insertQueueBinding(){
        return BindingBuilder.bind(insertQueue()).to(topicExchange()).with(MqConstants.HOTEL_INSERT_KEY);
    }

    @Bean
    public Binding deleteQueueBinding(){
        return BindingBuilder.bind(deleteQueue()).to(topicExchange()).with(MqConstants.HOTEL_DELETE_KEY);
    }
}

发送消息

    @PostMapping
    public void saveHotel(@RequestBody Hotel hotel){
        hotelService.save(hotel);
        rabbitTemplate.convertAndSend(MqConstants.HOTEL_EXCHANGE,MqConstants.HOTEL_INSERT_KEY,hotel.getId());
    }

    @PutMapping()
    public void updateById(@RequestBody Hotel hotel){
        if (hotel.getId() == null) {
            throw new InvalidParameterException("id不能为空");
        }
        hotelService.updateById(hotel);
        rabbitTemplate.convertAndSend(MqConstants.HOTEL_EXCHANGE,MqConstants.HOTEL_INSERT_KEY,hotel.getId());

    }

    @DeleteMapping("/{id}")
    public void deleteById(@PathVariable("id") Long id) {
        hotelService.removeById(id);
        rabbitTemplate.convertAndSend(MqConstants.HOTEL_EXCHANGE,MqConstants.HOTEL_DELETE_KEY,id);

    }

监听消息

    @Override
    public void deleteById(Long id) {
        DeleteRequest request = new DeleteRequest("hotel",id.toString());
        try {
            client.delete(request, RequestOptions.DEFAULT);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void insertById(Long id) {
        Hotel hotel = getById(id);
        HotelDoc hotelDoc = new HotelDoc(hotel);
        IndexRequest request = new IndexRequest("hotel").id(hotel.getId().toString());
        request.source(JSON.toJSONString(hotelDoc), XContentType.JSON);
        try {
            client.index(request,RequestOptions.DEFAULT);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

集群

ES集群结构

单机的elasticsearch做数据存储,必然面临两个问题:海量数据存储问题、单点故障问题。

  • 海量数据存储问题:检索库从逻辑上拆分为N个片,存储到多个节点
  • 单点故障问题:将分片数据在不同节点备份

部署es集群

我们会在单机上利用docker容器运行多个es实例来模拟es集群。不过生产环境推荐大家每一台服务节点仅部署一个es的实例。

部署es集群可以直接使用docker-compose来完成,但这要求你的Linux虚拟机至少有4G的内存空间

1.创建es集群

首先编写一个docker-compose文件,内容如下:

version: '2.2'
services:
  es01:
    image: elasticsearch:7.12.1
    container_name: es01
    environment:
      - node.name=es01
      - cluster.name=es-docker-cluster
      - discovery.seed_hosts=es02,es03
      - cluster.initial_master_nodes=es01,es02,es03
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    volumes:
      - data01:/usr/share/elasticsearch/data
    ports:
      - 9200:9200
    networks:
      - elastic
  es02:
    image: elasticsearch:7.12.1
    container_name: es02
    environment:
      - node.name=es02
      - cluster.name=es-docker-cluster
      - discovery.seed_hosts=es01,es03
      - cluster.initial_master_nodes=es01,es02,es03
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    volumes:
      - data02:/usr/share/elasticsearch/data
    ports:
      - 9201:9200
    networks:
      - elastic
  es03:
    image: elasticsearch:7.12.1
    container_name: es03
    environment:
      - node.name=es03
      - cluster.name=es-docker-cluster
      - discovery.seed_hosts=es01,es02
      - cluster.initial_master_nodes=es01,es02,es03
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    volumes:
      - data03:/usr/share/elasticsearch/data
    networks:
      - elastic
    ports:
      - 9202:9200
volumes:
  data01:
    driver: local
  data02:
    driver: local
  data03:
    driver: local

networks:
  elastic:
    driver: bridge

es运行需要修改一些linux系统权限,修改/etc/sysctl.conf文件

vi /etc/sysctl.conf

添加下面的内容:

vm.max_map_count=262144

然后执行命令,让配置生效:

sysctl -p

通过docker-compose启动集群:

docker-compose up -d

2.集群状态监控

kibana可以监控es集群,不过新版本需要依赖es的x-pack 功能,配置比较复杂。

这里推荐使用cerebro来监控es集群状态,官方网址:https://github.com/lmenezes/cerebro

img

访问http://localhost:9000 即可进入管理界面:

输入你的elasticsearch的任意节点的地址和端口,点击connect即可:

绿色的条,代表集群处于绿色(健康状态)。

img

3.创建索引库

1)利用kibana的DevTools创建索引库

在DevTools中输入指令:

PUT /itcast
{
  "settings": {
    "number_of_shards": 3, // 分片数量
    "number_of_replicas": 1 // 副本数量
  },
  "mappings": {
    "properties": {
      // mapping映射定义 ...
    }
  }
}

2)利用cerebro创建索引库

利用cerebro还可以创建索引库:

img

填写索引库信息:

img

点击右下角的create按钮:

4.查看分片效果

回到首页,即可查看索引库分片效果:

img

ES集群的节点角色

es中集群节点有不同的职责划分:

img

es中每个节点角色都有自己的不同职责,因此建议集群部署时,每个节点都有独立的角色。

img

ES集群的脑裂

默认情况下,每个节点都是master eligible节点,因此一旦master节点宕机,其他候选节点选举一个成为主节点。当主节点与其它节点网络故障时,可能发生脑裂问题。

为了避免脑裂,需要要求选票超过(eligible节点数量+1)/2才能当选为主,因此eligible节点数量最好是奇数。

ES集群的分布式存储

当新增文档时,应该保存到不同分片,保证数据均衡,那么coordinating node如何确定数据该存储到哪个分片呢?

es会通过hash算法来计算文档应该存储到哪个分片

img

说明:

  • _routing默认是文档id
  • 算法与分片数量有关,因此索引库一旦创建,分片数量不能修改

img

img

ES集群的故障转移

集群的master节点会监控集群中的节点状态,如果发现有节点宕机,会立即将宕机节点分片数据迁移到其它节点,确保数据安全,这个叫做故障转移。

img

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

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

相关文章

【P22】JMeter 调试后置处理程序(Debug PostProcessor)

&#xff08;1&#xff09;、测试计划右键 <<< 添加 <<< 线程&#xff08;用户&#xff09;<<< 线程组 默认参数即可 &#xff08;2&#xff09;、线程组右键 <<< 添加 <<< 取样器 <<< 调试取样器 默认参数即可 &…

SQL复习(一)——安装

1 mysql卸载 reference&#xff1a;https://blog.csdn.net/m0_67392273/article/details/126066580 Step1:停止MySql服务 在卸载之前&#xff0c;先停止MySQL8.0的服务 搜索“服务”&#xff0c;找到“MySQL”&#xff0c;右键点击选择“停止” Step2&#xff1a;软件的卸…

Unittest自动化测试之unittestunittest_生成测试报告

unittest_生成测试报告 测试报告为测试结果的统计即展示&#xff0c;是自动化测试不可或缺的一部分&#xff0c;利用unittest 可以生成测试报告 方式一、使用第三方 HTMLTestRunner 执行测试用例集&#xff0c;生成网页版测试报告&#xff08;推荐&#xff09; HTMLTestRunn…

5年软测经验去面试25k测试岗,看到这样的面试题我还是心虚了....

我是着急忙慌的准备简历——5年软件测试经验&#xff0c;可独立测试大型产品项目&#xff0c;熟悉项目测试流程...薪资要求&#xff1f;5年测试经验起码能要个25K吧 我加班肝了一页半简历&#xff0c;投出去一周&#xff0c;面试电话倒是不少&#xff0c;自信满满去面试&#…

系统掌握入河排污口设置论证技术、方法及报告编制框架

在短时间内较系统的掌握入河排污口设置论证技术、方法及报告编制框架&#xff0c;学习内容以城镇生活污水厂、造纸项目、石化项目、制药项目案例为线索&#xff0c;系统讲解入河排污口设置论证报告书编制过程&#xff0c;并以水质模型为手段&#xff0c;讲解水质影响预测模型的…

Voice Control for ChatGPT 沉浸式的与ChatGPT进行交流学习。

Voice Control for ChatGPT 日常生活中&#xff0c;我们与亲人朋友沟通交流一般都是喜欢语音的形式来完成的&#xff0c;毕竟相对于文字来说语音就不会显的那么的苍白无力&#xff0c;同时最大的好处就是能解放我们的双手吧&#xff0c;能更快实现两者间的对话&#xff0c;沟通…

华为OD机试真题 Java 实现【简单的自动曝光】【2023Q1 100分】

一、题目描述 一个图像有 n 个像素点&#xff0c;存储在一个长度为 n 的数组 img 里&#xff0c;每个像素点的取值范围[0,255]的正整数。 请你给图像每个像素点值加上一个整k(可以是负数)&#xff0c;得到新图 newlmg&#xff0c;使得新图 newlmg 的所有像素平均值最接近中位…

响应式设计和移动端优化:如何实现页面在不同设备上的适配和优化

章节一&#xff1a;介绍响应式设计和移动端优化 响应式设计是一种使网页能够自适应不同设备和屏幕尺寸的设计方法。它通过使用流式网格布局、媒体查询和弹性图片等技术&#xff0c;使得网页能够在不同分辨率和设备上呈现出最佳的布局和用户体验。 移动端优化则是针对移动设备…

青训营 x 训练营结营测试题目(前端方向)

文章目录 &#x1f4cb;前言&#x1f3af;选择题&#xff08;含多选&#xff09;&#x1f4dd;最后 &#x1f4cb;前言 这篇文章的内容是23年6月青训营 x 训练营结营题目&#xff0c;题目一共有25题&#xff0c;题目类型为选择题&#xff0c;包括了单选题和多选题&#xff0c;…

WiFi(Wireless Fidelity)基础(十二)

目录 一、基本介绍&#xff08;Introduction&#xff09; 二、进化发展&#xff08;Evolution&#xff09; 三、PHY帧&#xff08;&#xff08;PHY Frame &#xff09; 四、MAC帧&#xff08;MAC Frame &#xff09; 五、协议&#xff08;Protocol&#xff09; 六、安全&#x…

VHDL直流电机模糊控制器的设计与实现

在直流电机控制策略方面,属于智能控制理论的模糊控制其突出优点在于它不依赖于被控对象的模型,因此本设计尝试将模糊控制理论应用于直流电机转速控制,并将模糊控制器实现于FPGA(Field Programmable Gate Array)芯片上。在实现方法上本设计采用模糊查表控制法实现模糊控制器…

【C++】-static在类和对象中的作用和细节(下)

&#x1f496;作者&#xff1a;小树苗渴望变成参天大树 ❤️‍&#x1fa79;作者宣言&#xff1a;认真写好每一篇博客 &#x1f4a8;作者gitee:gitee &#x1f49e;作者专栏&#xff1a;C语言,数据结构初阶,Linux,C 文章目录 前言 前言 今天我们来讲一个static对类的对象的作用…

安全基础第十二天:nginx相关配置和nginx-host绕过

目录 一、nginx的动静分离 1.动静分离的原理 2.动静分离实验&#xff08;centos做为放置静态资源的服务器&#xff0c;ubuntu做为请求的web服务器&#xff09; &#xff08;1&#xff09;在centos的/usr/local/nginx/html下创建一个静态文件static &#xff08;2&#xff09…

目标检测概述

传统目标检测 任务目标 从图像中找出相应的物体位置 目标检测的核心目的在于&#xff0c;估计出目标在图像中的坐标。 问题定义 目标检测的结果是什么&#xff1f; 预测出目标在图像中的位置。 位置如何表示&#xff1f; 通常采用水平矩形框的形式估计目标。 在opencv中…

为什么Java要求多用组合,少用继承?

前言&#xff1a; 最近有一个要好的朋友去阿里大厂面试Java高级工程师&#xff0c;在第二轮面试的过程中&#xff0c;面试官提了一个问题&#xff1a;“解释下Java项目中为什么要求多用组合&#xff0c;少用继承&#xff1f;”。朋友觉得这个题目既熟悉&#xff0c;又陌生&…

【LeetCode】504. 七进制数

504. 七进制数&#xff08;简单&#xff09; 方法一&#xff1a;七进制数预处理 思路 这里我利用了提示&#xff0c;得知 |num| < 10^7 &#xff0c;因此所使用到的七进制数肯定也小于等于 107 &#xff0c;我将 7 的次方数算出来&#xff0c;预存在数组 seven 中。 后续…

ADUC834BSZ-ASEMI代理亚德诺ADUC834BSZ原厂芯片

编辑-Z ADUC834BSZ特征&#xff1a; 2个独立ADC&#xff08;16位和24位分辨率&#xff09; 24位无缺失代码&#xff0c;主ADC 21位rms&#xff08;18.5位p-p&#xff09;有效分辨率20 Hz 偏移漂移10 nV/C&#xff0c;增益漂移0.5 ppm/C 62 KB片上闪存/EE程序存储器 4 KB…

C++(Qt)读取.mat文件(可以读取多级变量)

全网最全&#xff0c;从安装环境和配置环境变量&#xff08;配置环境变量是大坑&#xff09;&#xff0c;然后再到需要的SDK库&#xff0c;再到代码详细解读。 首先就是需要安装matlab&#xff0c;注意&#xff1a;你使用的编译器版本需要和MATLAB版本相互兼容&#xff01;&am…

使用模板构建泛型栈

目录 一.构造栈 使用构造函数 代码&#xff1a; 二.销毁栈 使用析构函数 代码 三.判空&#xff0c;判满 四.扩容 代码 五.入栈&#xff0c;出栈 代码 六.取栈顶元素 代码 代码合集 template< class T>模板 T为当前栈的数据类型 栈类型有三个属性&#x…