八、黑马程序员酒店demo之全文检索后端代码

已于 2024-05-24 17:22:49 修改
阅读量399 收藏 6
点赞数 5
分类专栏： ElasticSearch 文章标签： 全文检索 mybatis elasticsearch es
于 2024-05-24 12:42:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guyua/article/details/139171888
版权

文末附上项目的下载地址

1、项目代码结构

这里暂不将涉及消息中间件的类放进去。因为是采用的是ES8的RestAPI，所以和黑马程序员的demo有些差距，相关注释没有那么详细。
在这里插入图片描述

2、mapperd代码

package com.toto.es.hotel.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.toto.es.hotel.pojo.Hotel;

public interface HotelMapper extends BaseMapper<Hotel> {
}

3、Hotel代码

package com.toto.es.hotel.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data
@TableName("tb_hotel")
public class Hotel {
    @TableId(type = IdType.INPUT)
    private Long id;
    private String name;
    private String address;
    private Integer price;
    private Integer score;
    private String brand;
    private String city;
    private String starName;
    private String business;
    private String longitude;
    private String latitude;
    private String pic;
}

4、HotelDoc代码

package com.toto.es.hotel.pojo;

import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.*;

@Data
@NoArgsConstructor
public class HotelDoc {
    private String id;
    private String name;
    private String address;
    private Integer price;
    private Integer score;
    private String brand;
    private String city;
    private String starName;
    private String business;
    private String location;
    private String pic;
    private Double distance;
    private Boolean isAD; // 是否是广告
    private List<String> suggestion;

    public HotelDoc(Hotel hotel) {
        this.id = hotel.getId().toString();
        this.name = hotel.getName();
        this.address = hotel.getAddress();
        this.price = hotel.getPrice();
        this.score = hotel.getScore();
        this.brand = hotel.getBrand();
        this.city = hotel.getCity();
        this.starName = hotel.getStarName();
        this.business = hotel.getBusiness();
        this.location = hotel.getLatitude() + ", " + hotel.getLongitude();
        this.pic = hotel.getPic();
        if(this.business.contains("/")){
            String[] arr = this.business.split("/");
            this.suggestion = new ArrayList<>();
            this.suggestion.add(this.brand);
            Collections.addAll(this.suggestion, arr);
        }else if(this.business.contains("、")){
            String[] arr = this.business.split("、");
            this.suggestion = new ArrayList<>();
            this.suggestion.add(this.brand);
            Collections.addAll(this.suggestion, arr);
        }else{
            this.suggestion = Arrays.asList(this.brand, this.business);
        }

    }
}

5、PageResult代码

package com.toto.es.hotel.pojo;

import lombok.Data;

import java.util.List;

@Data
public class PageResult {
    private Long total;
    private List<HotelDoc> hotels;

    public PageResult() {
    }

    public PageResult(Long total, List<HotelDoc> hotels) {
        this.total = total;
        this.hotels = hotels;
    }
}

6、RequestParams代码

package com.toto.es.hotel.pojo;

import lombok.Data;

@Data
public class RequestParams {
    private String key;
    private Integer page;
    private Integer size;
    private String sortBy;

    private String city;
    private String brand;
    private String starName;
    private String minPrice;
    private String maxPrice;
    private String location;
}

7、IHotelService代码

package com.toto.es.hotel.service;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.toto.es.hotel.pojo.Hotel;
import com.toto.es.hotel.pojo.PageResult;
import com.toto.es.hotel.pojo.RequestParams;

import java.io.IOException;
import java.util.List;
import java.util.Map;

public interface IHotelService extends IService<Hotel> {
    PageResult search(RequestParams params);

    Map<String, List<String>> filters(RequestParams params);
    Map<String, List<String>> filters2();
    List<String> getsuggestions(String prefix);

    void insertById(Long id);

    void deleteById(Long id);
}

8、HotelService代码（基于ES8调整）

package com.toto.es.hotel.service.impl;


import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch._types.*;
import co.elastic.clients.elasticsearch._types.aggregations.Aggregate;
import co.elastic.clients.elasticsearch._types.aggregations.Buckets;
import co.elastic.clients.elasticsearch._types.aggregations.StringTermsBucket;
import co.elastic.clients.elasticsearch._types.mapping.GeoPointProperty;
import co.elastic.clients.elasticsearch._types.query_dsl.*;
import co.elastic.clients.elasticsearch.core.DeleteResponse;
import co.elastic.clients.elasticsearch.core.IndexResponse;
import co.elastic.clients.elasticsearch.core.SearchRequest;
import co.elastic.clients.elasticsearch.core.SearchResponse;
import co.elastic.clients.elasticsearch.core.search.CompletionSuggest;
import co.elastic.clients.elasticsearch.core.search.CompletionSuggestOption;
import co.elastic.clients.elasticsearch.core.search.Hit;
import co.elastic.clients.elasticsearch.core.search.Suggestion;
import co.elastic.clients.json.JsonData;
import co.elastic.clients.util.NamedValue;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.toto.es.hotel.mapper.HotelMapper;
import com.toto.es.hotel.pojo.Hotel;
import com.toto.es.hotel.pojo.HotelDoc;
import com.toto.es.hotel.pojo.PageResult;
import com.toto.es.hotel.pojo.RequestParams;
import com.toto.es.hotel.service.IHotelService;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class HotelService extends ServiceImpl<HotelMapper, Hotel> implements IHotelService {

    @Autowired
    private ElasticsearchClient client;
    
    @Override
    public PageResult search(RequestParams params) {
        SearchResponse<HotelDoc> response = null;
        try {
            // 1.创建请求
            SearchRequest.Builder builder = new SearchRequest.Builder();
            // 2.构造请求参数
            buildBasicQuery(builder, params);
            // 3.发送请求
            response = client.search(b -> builder, HotelDoc.class);
            return this.handleResponse(response);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public Map<String, List<String>> filters(RequestParams params) {
        try {
            // 1.创建请求
            SearchRequest.Builder builder = new SearchRequest.Builder();
            // 2.构造请求参数
            buildBasicQuery(builder, params);
            buildAggQuery(builder);
            // 3.发送请求
            SearchResponse<Map> response = client.search(b -> builder, Map.class);
            // 4.1解析结果
            Map<String, List<String>> result = new HashMap<>();
            // 4.1.1 获取品牌聚合结果
            List<String> brandList = getAggByName("brandAgg", response);
            //result.put("品牌", brandList);
            result.put("brand", brandList);
            // 4.1.2 获取城市聚合结果
            List<String> cityList = getAggByName("cityAgg", response);
            //result.put("城市", cityList);
            result.put("city", cityList);
            // 4.1.3 获取星级聚合结果
            List<String> starList = getAggByName("starAgg", response);
            //result.put("星级", starList);
            result.put("starName", starList);
            return result;
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private List<String> getAggByName(String aggName, SearchResponse<Map> response){
        Map<String, Aggregate> aggregations = response.aggregations();
        Aggregate brandAgg = aggregations.get(aggName);
        Buckets<StringTermsBucket> buckets = brandAgg.sterms().buckets();
        List<String> brandList = new ArrayList<>();
        for (StringTermsBucket b : buckets.array()) {
            brandList.add(b.key().stringValue());
            //System.err.println(b.key().stringValue() + " : " + b.docCount());
        }
        return brandList;
    }

    private void buildAggQuery(SearchRequest.Builder builder){

        builder.index("hotel").size(0);

        builder.aggregations("brandAgg", a -> a.terms(t -> t.field("brand").size(100)));

        builder.aggregations("cityAgg", a -> a.terms(t -> t.field("city").size(100)));

        builder.aggregations("starAgg", a -> a.terms(t -> t.field("starName").size(100)));
    }

    private void buildBasicQuery(SearchRequest.Builder builder, RequestParams params) {
        // 2.1 指定索引和分页
        String key = params.getKey();
        int page = params.getPage();
        int size = params.getSize();
        String location = params.getLocation();

        builder.index("hotel");
        builder.from((page - 1) * size).size(size);

        // 2.2 构造查询条件(复核查询)
        BoolQuery.Builder boolQuery = QueryBuilders.bool();
        if(key == null || "".equals(key)){
            MatchAllQuery.Builder allQuery = QueryBuilders.matchAll();
            //builder.query(query -> query.matchAll(matchall -> allQuery));
            boolQuery.must(must -> must.matchAll(ma -> allQuery));
        }else{
            MatchQuery.Builder machQuery = QueryBuilders.match();
            machQuery.field("all").query(key);
            boolQuery.must(must -> must.match(m -> machQuery));
        }

        // 城市条件
        if(params.getCity() != null && !"".equals(params.getCity())){
            TermQuery.Builder termQuery = QueryBuilders.term();
            termQuery.field("city").value(params.getCity());
            boolQuery.filter(filter -> filter.term(t -> termQuery));
        }
        // 品牌条件
        if(params.getBrand() != null && !"".equals(params.getBrand())){
            TermQuery.Builder termQuery = QueryBuilders.term();
            termQuery.field("brand").value(params.getBrand());
            boolQuery.filter(filter -> filter.term(t -> termQuery));
        }
        // 星级条件
        if(params.getStarName() != null && !"".equals(params.getStarName())){
            TermQuery.Builder termQuery = QueryBuilders.term();
            termQuery.field("starName").value(params.getStarName());
            boolQuery.filter(filter -> filter.term(t -> termQuery));
        }
        // 价格条件
        if(params.getMinPrice() != null && params.getMaxPrice() != null){
            RangeQuery.Builder rangeQuery = QueryBuilders.range();
            rangeQuery.field("price").gte(JsonData.fromJson(params.getMinPrice())).lte(JsonData.fromJson(params.getMaxPrice()));
            boolQuery.filter(filter -> filter.range(r -> rangeQuery));
        }

        // 排序条件
        if(params.getSortBy() != null && !"".equals(params.getSortBy())){
            String sortBy = params.getSortBy();
            if("score".equals(sortBy)){
                builder.sort(sort -> sort.field(f -> f.field("score").numericType(FieldSortNumericType.Double).order(SortOrder.Desc)));
            }else if("price".equals(sortBy)){
                builder.sort(sort -> sort.field(f -> f.field("price").numericType(FieldSortNumericType.Double).order(SortOrder.Desc)));
            }
        }

        // 我附近的排序
        if(location != null && !"".equals(location)){
            String[] latlon = location.split(",");
            builder.sort(sort -> sort.geoDistance(geo -> geo.field("location").location(l -> l.latlon(ll -> ll.lat(Double.parseDouble(latlon[0].replace(" ",""))).lon(Double.parseDouble(latlon[1].replace(" ",""))))).unit(DistanceUnit.Kilometers).order(SortOrder.Asc)));
        }
        // 算分控制，置顶
        Query functionScoreQuery = QueryBuilders.functionScore(fun->fun.query(q->q.bool(b -> boolQuery)).functions(fsFunctions -> fsFunctions.filter(f -> f.term(t -> t.field("isAD").value(true))).weight(10D)).boostMode(FunctionBoostMode.Multiply));
        //builder.query(query -> query.bool(mach -> functionScoreQuery));
        builder.query(functionScoreQuery);
    }

    private PageResult handleResponse(SearchResponse<HotelDoc> response) {
        // System.err.println(response.hits().total().value());
        long total = response.hits().total().value();
        List<HotelDoc> hotels = new ArrayList<>();
        for (Hit<HotelDoc> doc : response.hits().hits()) {
            HotelDoc hotelDoc = doc.source();
            List<FieldValue> sortList = doc.sort();
            if(ObjectUtils.isNotEmpty(sortList)){
                hotelDoc.setDistance(sortList.get(0).doubleValue());
            }
            hotels.add(hotelDoc);
        }
        return new PageResult(total, hotels);
    }

    @Override
    public Map<String, List<String>> filters2() {
        try {
            // 1.创建请求
            SearchRequest.Builder builder = new SearchRequest.Builder();
            // 2.构造请求参数
            buildAggQuery(builder);
            // 3.发送请求
            SearchResponse<Map> response = client.search(b -> builder, Map.class);
            // 4.1解析结果
            Map<String, List<String>> result = new HashMap<>();
            // 4.1.1 获取品牌聚合结果
            List<String> brandList = getAggByName("brandAgg", response);
            result.put("品牌", brandList);
            // 4.1.2 获取城市聚合结果
            List<String> cityList = getAggByName("cityAgg", response);
            result.put("城市", cityList);
            // 4.1.3 获取星级聚合结果
            List<String> starList = getAggByName("starAgg", response);
            result.put("星级", starList);
            return result;
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public List<String> getsuggestions(String prefix) {
        List<String> suggestions = new ArrayList<>();
        try {
            SearchResponse<Map> response = client.search(builder ->
                            builder.index("hotel")
                                    .suggest(s -> s.suggesters("suggestions",
                                            suggest -> suggest.prefix(prefix).completion(c -> c.field("suggestion").skipDuplicates(true).size(10)))),
                    Map.class);
            // 获取联想建议
            Map suggestMap = response.suggest();
            if (suggestMap != null) {
                List<?> suggestionList = (List<?>) suggestMap.get("suggestions");
                if (suggestionList != null) {
                    for (Object suggestionInfo : suggestionList) {
                        if (suggestionInfo instanceof Suggestion) {
                            Suggestion suggestion = (Suggestion) suggestionInfo;
                            if (suggestion.isCompletion()) {
                                CompletionSuggest completionSuggest = suggestion.completion();
                                List<CompletionSuggestOption> options = completionSuggest.options();
                                for (CompletionSuggestOption option : options) {
                                    suggestions.add(option.text());
                                }
                            }
                        }
                    }
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return suggestions;
    }

    @Override
    public void insertById(Long id) {
        try {
            Hotel hotel = getById(id);
            HotelDoc hotelDoc = new HotelDoc(hotel); // 使用实体，也可使用HashMap,还可以使用json
            IndexResponse response = client.index(builder -> builder.index("hotel").id(hotelDoc.getId()).document(hotelDoc));
            System.err.println(response);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void deleteById(Long id) {
        try {
            DeleteResponse response = client.delete(builder -> builder.index("hotel").id(id.toString()));
            System.err.println(response);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

9、HotelController代码

package com.toto.es.hotel.web;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.toto.es.hotel.pojo.Hotel;
import com.toto.es.hotel.pojo.PageResult;
import com.toto.es.hotel.pojo.RequestParams;
import com.toto.es.hotel.service.IHotelService;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.io.IOException;
import java.security.InvalidParameterException;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("hotel")
public class HotelController {

    @Resource
    private IHotelService hotelService;

    @RequestMapping("/admin")
    public String login(){
        return "admin";
    }

    @GetMapping("/{id}")
    public Hotel queryById(@PathVariable("id") Long id){
        return hotelService.getById(id);
    }

    @PostMapping("/list")
    public PageResult hotelList(@RequestBody RequestParams params) throws IOException {
        return hotelService.search(params);
    }

    @PostMapping("/filters")
    public Map<String, List<String>> hotelfilters(@RequestBody RequestParams params) throws IOException {
        return hotelService.filters(params);
    }

    @GetMapping("/suggestion")
    public List<String> getSuggestions(@RequestParam("key") String prefix){
        return hotelService.getsuggestions(prefix);
    }

    @PostMapping
    public void saveHotel(@RequestBody Hotel hotel){
        hotelService.save(hotel);
    }

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

    @DeleteMapping("/{id}")
    public void deleteById(@PathVariable("id") Long id) {
        hotelService.removeById(id);
    }

}

10、HotelDemoApplication代码（启动类）

package com.toto.es.hotel;

import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.json.jackson.JacksonJsonpMapper;
import co.elastic.clients.transport.ElasticsearchTransport;
import co.elastic.clients.transport.rest_client.RestClientTransport;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import lombok.extern.slf4j.Slf4j;
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.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.core.env.Environment;

import java.net.InetAddress;
import java.net.UnknownHostException;

@Slf4j
@MapperScan(basePackages = "com.toto.es.hotel.mapper")
@SpringBootApplication
public class HotelDemoApplication {

    public static void main(String[] args) throws UnknownHostException {
        ConfigurableApplicationContext application = SpringApplication.run(HotelDemoApplication.class,args);
        Environment env = application.getEnvironment();
        String ip = InetAddress.getLocalHost().getHostAddress();
        String port = env.getProperty("server.port");
        log.info("\n----------------------------------------------------------\n\t" +
                //"ElasticSearch Demo: \thttp://localhost" + ip + ":" + port + "\n" +
                "ElasticSearch Demo: \thttp://localhost:" + port + "\n" +
                "----------------------------------------------------------");
        openE("http://"+ ip +":" + port + "");
    }

    private static void openE(String url) {
        String runCmd = "cmd   /c   start " + url;
        Runtime run = Runtime.getRuntime();
        try {
            run.exec(runCmd);
        } catch (Exception e) {
            System.out.println("启动项目自动打开浏览器失败");
        }
    }

    // 最新版
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }

    @Bean
    public ElasticsearchClient slasticsearchClient() {
        BasicCredentialsProvider credsProv = new BasicCredentialsProvider();
        credsProv.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("elastic", "elastic"));

        RestClient restClient = RestClient.builder(HttpHost.create("http://127.0.0.1:9200"))
                .setHttpClientConfigCallback(hc -> hc.setDefaultCredentialsProvider(credsProv))
                .build();
        ElasticsearchTransport transport = new RestClientTransport(restClient, new JacksonJsonpMapper());
        return new ElasticsearchClient(transport);
    }
}

11、application.yaml代码

server:
  port: 8089
spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:23306/totograin?useSSL=false
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtual-host: /
logging:
  level:
    com.toto: debug
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS
mybatis-plus:
  configuration:
    map-underscore-to-camel-case: true
  type-aliases-package: com.toto.es.hotel.pojo

12、logback.xml代码

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
    <appender name="consoleLog" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>
                %d{MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
            </pattern>
        </encoder>
    </appender>

    <root level="info">
        <appender-ref ref="consoleLog" />
    </root>
</configuration>

项目下载地址

Grain322
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
黑马2021最新版 SpringCloud基础篇全技术栈导学（RabbitMQ+Docker+Redis+搜索+分布式）
m0_67402026的博客
07-30 1487
也是使用的Ribbon，下面一个例子将Nacos配置成同集群优先的负载均衡策略默认的并不能实现根据同集群优先来实现负载均衡。Nacos中提供了一个NacosRule的实现，可以优先从同集群中挑选实例。1）给order-service配置集群信息springcloudnacoslocalhost8848discoveryHZ#集群名称2）修改负载均衡规则ribboncom.alibaba.cloud.nacos.ribbon.NacosRule#负载均衡规则。...
2021黑马程序员Java面试宝典笔记（完整版）
web18296061989的博客
10-07 557
refresh 是 AbstractApplicationContext 中的一个方法，负责初始化 ApplicationContext 容器，容器必须调用 refresh 才能正常工作。它的内部主要会调用 12 个方法，我们把它们称为 refresh 的 12 个步骤：onRefresh。
springboot2（黑马程序员）入门
lyb2021的博客
12-20 5053
springboot2课程学习 课程特点 课程内容多，知识点杂乱， 课程面向业务需求大 课程定位：小白：完全没有用过springboot技术（目前阶段） 初学者：基于springboot进行ssm框架的整合，掌握第三方的技术与springboot整合版 积累springboot的实战开发的经验 课程模块： 基础篇 学习要求： 能够创建springboot工程 基于springboot实现ssm的框架的整合（springboot的目的本身就是为了简化开发而设计实用
后端学JavaScript
helpluozhao123的博客
01-15 675
一、JavaScript简介绍 二、JavaScript引入方式 JavaScript 引入方式就是 HTML 和 JavaScript 的结合方式。JavaScript引入方式有两种： 内部脚本：将 JS代码定义在HTML页面中 外部脚本：将 JS代码定义在外部 JS文件中，然后引入到 HTML页面中 2.1、内部脚本 在 HTML 中，JavaScript 代码必须位于 <script> 与 </script> 标签之间 代码如下： alert(数据) 是 JavaScrip
SpringCloud(微服务) - 黑马程序员
qwwee123的博客
11-09 847
1.2 修改OrderService中代码发送HTTP请求 2. Eureka（注册中心） 2.1 Eureka的作用 2) 创建启动类EurekaApplication并添加@EnableEurekaServer开启Eureka服务 3) 编写一个application.yml文件，内容如下： 4）启动微服务，然后在浏览器访问：http://127.0.0.1:10086 eureka服务启动不了的尝试换一下Maven的java版本改为8。看到如下页面即成功： 2）修改application.y
Java面试宝典Beta5.0
cillent_boy的专栏
02-15 4168
pdf下载地址：Java面试宝典 第一章内容介绍 20 第二章JavaSE基础 21 一、Java面向对象 21 1. 面向对象都有哪些特性以及你对这些特性的理解 21 2. 访问权限修饰符public、private、protected, 以及不写（默认）时的区别(2017-11-12) 22 3. 如何理解clone对象 22 二、JavaSE语法（2017-11-12-wl） ...
Java学习路线图，全套Java基础视频教程
sebeefe的博客
08-01 1384
扎实的技术基础功+真实项目实战经验，才是好就业的关键。不止于此，黑马程序员帮助已就业学员继续提升！技术的提升永无止步，碎片时间学习进行各种技术强化以上Java学习路线图均有课程+源码+笔记+资料。更多提升课程访问底部，即可获取持续成长技能！...
MySQL8高级优化，持续更新......
weixin_45699541的博客
09-05 1845
索引可以高效获取数据，避免对数据进行全盘扫描（查询速度很慢），索引就是一种数据结构（树）MySQL官方对索引的定义为：索引（index）是帮助MySQL高效获取数据的数据结构（有序）。在数据之外，数据库系统还维护者满足特定查找算法的数据结构，这些数据结构以某种方式引用（指向）数据， 这样就可以在这些数据结构上实现高级查找算法，这种数据结构就是索引。如下面的所示 :此时的索引树是一个平衡二叉树，上图的索引树的建立就是平衡二叉树的建立。此时 查找数据就像二分查找一样了。
JUC（多线程）笔记
qq_46517733的博客
08-12 565
JUC1.JUC概述1.1 JUC简介1.2 进程与线程1.3 线程的状态1.3.1 线程状态枚举类1.3.2 wait/sleep的区别1.4 并行与并发1.4.1 串行模式1.4.2 并行模式1.4.3 并发1.4.4 小结（重点）1.5 管程1.6 用户线程和守护线程1.7 创建线程的方式2.Lock接口2.1 Synchronized2.1.1 Synchronized关键字回顾2.1.2 售票案例2.1.3 多线程编程步骤2.2 什么是Lock2.2.1 Lock接口介绍2.2.2 lock2.2
黑马程序员SSM整合学习项目demo
02-21
感谢黑马，这是一次自己在学习黑马中慢慢自己跟着做起来的项目，是黑马SSM最后阶段的一次小的整合mybais项目
springboot上传excel导入到数据库完整demo(后端代码)
06-08
springboot后端代码,完整实现excel导入或更新mysql数据库,使用编译器引入项目即可执行测试,压缩包包括springboot项目,测试用excel和mysql建表语句
微信小程序demo：微信支付后端demo（java）
03-17
免责声明：本站所有文章和图片均来自用户分享和网络收集，文章和图片版权归原作者及原出处所有，仅供学习与参考，请勿用于商业用途，如果损害了您的权利，请联系网站客服处理。
黑马程序员的SpringCloud教程的demo压缩文件，包含了demo工程以及两个数据库（tb-user和tb-order）
01-14
黑马程序员的SpringCloud教程的demo压缩文件，包含了demo工程以及两个数据库（tb-user和tb-order）
微信小程序后端demo：仿微信：基于node(源代码+截图)
06-19
微信小程序后端demo：仿微信：基于node(源代码+截图)微信小程序后端demo：仿微信：基于node(源代码+截图)微信小程序后端demo：仿微信：基于node(源代码+截图)微信小程序后端demo：仿微信：基于node(源代码+截图)微信...
ES全文检索支持繁简和IK分词检索
最新发布
后端开发
06-21 801
本教程旨在展示如何在ES中引入繁简转换和IK分词插件，使得在检索时无论输入简体还是繁体都能够被检索到。无论用户输入“語法”还是“语法”，检索结果中都能命中包含简体和繁体的相关文档。这种处理方式不仅提升了用户体验，还增强了检索的准确性和全面性。
Elasticsearch中的Term_Filter过滤器技术
屿小夏.的知识博客
06-21 3978
Term Filter作为Elasticsearch中的一项强大功能，为精确匹配和快速过滤文档提供了高效手段。通过深入了解其工作原理、探索多样化的使用场景并遵循最佳实践建议，我们可以充分利用Term Filter来优化搜索应用并提升用户体验。
es深分页问题解决小记
mikelv01的博客
06-19 968
more。
【前端】Git 常用
zhenshu_guo的博客
06-17 657
Git 常用
写一个python 代码的段落检索语言模型 demo 代码
02-07
下面是一个使用 Python 实现的代码段检索语言模型的简单示例： ``` import re import numpy as np import tensorflow as tf def retrieve_sentence(model, input_text, all_sentences): """ 使用语言模型对输入...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Grain322

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值