SpringBoot2.x项目模块整合之elasticSearch 6.x（geo使用等）

最新推荐文章于 2024-03-04 11:52:24 发布
最新推荐文章于 2024-03-04 11:52:24 发布
阅读量2.9k 收藏 5
点赞数 2
分类专栏： springboot 文章标签： springboot-es geo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lx1309244704/article/details/88895119
版权

elasticsearch安装：https://blog.csdn.net/u012888052/article/details/79710429

ik分词安装：https://blog.csdn.net/u012888052/article/details/81941912

springboot整合：https://blog.csdn.net/chen_2890/article/details/83895646（这篇总结的很到位）

我这里主要将就geo的使用：

如果使用geo功能必须使用ElasticsearchTemplate，必须使用Mapping先去创建然后在添加数据，否则会出现geo类型错误

使用Repository基本查询：

依赖包

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>Springboot-elasticsearch</groupId>
	<artifactId>Springboot-elasticsearch</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	 <!-- 定义公共资源版本 -->
	<!--<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.8.RELEASE</version>
		<relativePath />
	</parent> -->
	
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.2.RELEASE</version>
		<relativePath />
	</parent>

	<dependencies>
		<!-- elasticsearch -->
		<!-- springboot-data-elasticsearch 提供了面向对象的方式操作elasticsearch -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
		</dependency>
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.5</version><!--$NO-MVN-MAN-VER$ -->
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

VehicleDto实体类

package com.es.dto;

import java.io.Serializable;
import java.util.List;

import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;

@Document(indexName = "vehicle", type = "special" , shards = 1, replicas = 0)
public class VehicleDto implements Serializable {

	private static final long serialVersionUID = -5483287283894740770L;
	
	@Id
	private Long id;
	
	@Field(type = FieldType.Text)
	private String carDriver;
	
	@Field(type = FieldType.Text)
	private String carType;
	
	//1：ik_smart：做最粗粒度的拆分；2：ik_max_word：做最细粒度的拆分
	@Field(type = FieldType.Text,analyzer = "ik_max_word", searchAnalyzer = "ik_max_word")
	private String carName;
	
	@Field(type = FieldType.Text)
	private String status;
	
	@Field(type = FieldType.Text)
	private int price;
	
	//嵌套实体使用FieldType.Nested
	@Field(type=FieldType.Nested,includeInParent=true)
	private List<AddressPointDto> addressPointDto;
	
	public VehicleDto() {
		
	}

	public Long getId() {
		return id;
	}

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

	public String getCarDriver() {
		return carDriver;
	}

	public void setCarDriver(String carDriver) {
		this.carDriver = carDriver;
	}

	public String getCarType() {
		return carType;
	}

	public void setCarType(String carType) {
		this.carType = carType;
	}

	public String getCarName() {
		return carName;
	}

	public void setCarName(String carName) {
		this.carName = carName;
	}

	public String getStatus() {
		return status;
	}

	public void setStatus(String status) {
		this.status = status;
	}

	public int getPrice() {
		return price;
	}

	public void setPrice(int price) {
		this.price = price;
	}

	public List<AddressPointDto> getAddressPointDto() {
		return addressPointDto;
	}

	public void setAddressPointDto(List<AddressPointDto> addressPointDto) {
		this.addressPointDto = addressPointDto;
	}

	@Override
	public String toString() {
		return "VehicleDto [id=" + id + ", carDriver=" + carDriver + ", carType=" + carType + ", carName=" + carName
				+ ", status=" + status + ", price=" + price + ", addressPointDto=" + addressPointDto + "]";
	}

}

嵌套实体AddressPointDto

package com.es.dto;

import java.io.Serializable;
import java.util.Date;

import org.elasticsearch.common.geo.GeoPoint;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.DateFormat;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
import org.springframework.data.elasticsearch.annotations.GeoPointField;

import com.fasterxml.jackson.annotation.JsonFormat;


@Document(indexName ="vehiclepoint", type = "specialpoint" , shards = 1, replicas = 0)
public class AddressPointDto implements Serializable {

	private static final long serialVersionUID = -5483287283894740770L;
	
	@Id
	private Long id;
	
//	@Field(type = FieldType.String)//1.5.8 spring-boot使用类型
	//1：ik_smart：做最粗粒度的拆分；2：ik_max_word：做最细粒度的拆分
	@Field(type = FieldType.Text,analyzer = "ik_max_word", searchAnalyzer = "ik_max_word")//使用ik分词器
	private String name;
	
	//必须使用@Field注解，否则使用精确匹配查询字段需要type.Keyword
//	@Field(type = FieldType.Keyword)
	@Field(type = FieldType.Text)
//	@Field(type = FieldType.String)//1.5.8 spring-boot使用类型
	private String type;
	
	@Field( type = FieldType.Date,format = DateFormat.custom,pattern = "yyyy-MM-dd HH:mm:ss")
    @JsonFormat (shape = JsonFormat.Shape.STRING, pattern ="yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
    private Date xjTime;
	
//	@Field(type = FieldType.String,analyzer = "ik_max_word", searchAnalyzer = "ik_max_word")//1.5.8 spring-boot使用类型
	@Field(type = FieldType.Text,analyzer = "ik_max_word", searchAnalyzer = "ik_max_word")
	private String remark;
	
	@GeoPointField
    private GeoPoint address;

	public AddressPointDto() {
	}

	public Long getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

	public GeoPoint getAddress() {
		return address;
	}

	public void setAddress(GeoPoint address) {
		this.address = address;
	}

	public Date getXjTime() {
		return xjTime;
	}

	public void setXjTime(Date xjTime) {
		this.xjTime = xjTime;
	}

	public String getRemark() {
		return remark;
	}

	public void setRemark(String remark) {
		this.remark = remark;
	}

	@Override
	public String toString() {
		return "VehiclePointEsDto [id=" + id + ", name=" + name + ", type=" + type + ", xjTime=" + xjTime + ", remark="
				+ remark + ", address=" + address + "]";
	}

}

VehicleRepository接口

package com.es.service;

import java.util.List;

import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import org.springframework.stereotype.Component;

import com.es.dto.VehicleDto;


@Component
public interface VehicleRepository extends ElasticsearchRepository<VehicleDto, Long>{

    /**
     * @return
     */
    List<VehicleDto> findByCarDriver(String carDriver,Pageable pageable);
    
    /**
     * @param name
     * @return
     */
    List<VehicleDto> findByAddressPointDtoName(String name,Pageable pageable); 
    
    /**
     * @param id1
     * @param id2
     * @return
     */
    List<VehicleDto> findByCarDriverAndPrice(String carDriver,int price,Pageable pageable);
    
    /**
     * @return
     */
    List<VehicleDto> findByCarDriverOrCarType(String carDriver,String carType,Pageable pageable);
    
    /**
     * @param id1
     * @param id2
     * @return
     */
    List<VehicleDto> findByPriceBetween(int price1, int price2);
}

VehicleService接口

package com.es.api;

import java.util.List;

import org.springframework.data.domain.Pageable;

import com.es.dto.VehicleDto;

public interface VehicleService {
	
	public void set(VehicleDto dto);
	
	public void setAll(Iterable<VehicleDto> ite);
	
	public void del(Long id);
	
	public VehicleDto findById(Long id);
	
	public List<VehicleDto> findAll();
	
	public List<VehicleDto> findCarDriver(String carDriver,Pageable pageable);
	
	public List<VehicleDto> findByAddressPointDtoName(String name,Pageable pageable); 
	
	public List<VehicleDto> findByCarDriverAndPrice(String carDriver,int price,Pageable pageable);
	
	public List<VehicleDto> findByCarDriverOrCarType(String carDriver,String carType,Pageable pageable);
	
	public List<VehicleDto> findByPriceBetween(int price1, int price2);
	
}

VehicleServiceImpl实现类

package com.es.service.impl;

import java.util.List;
import java.util.Optional;

import org.assertj.core.util.Lists;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;

import com.es.api.VehicleService;
import com.es.dto.VehicleDto;
import com.es.service.VehicleRepository;

@Service
public class VehicleServiceImpl implements VehicleService{
	
	private @Autowired VehicleRepository vehicleRepository;
	
	@Override
	public void set(VehicleDto dto) {
		vehicleRepository.save(dto);
	}

	@Override
	public void setAll(Iterable<VehicleDto> ite) {
//		vehicleRepository.save(ite);
		vehicleRepository.saveAll(ite);
	}
	
	@Override
	public void del(Long id) {
		vehicleRepository.deleteById(id);
	}
	

	
	@Override
	public VehicleDto findById(Long id) {
//		VehicleEsDto dto = vehicleRepository.findOne(id);
//		return dto;
		Optional<VehicleDto> dto = vehicleRepository.findById(id);
		return dto.get();
	}

	@Override
	public List<VehicleDto> findAll() {
		List<VehicleDto> list = Lists.newArrayList(vehicleRepository.findAll());
		return list;
	}

	@Override
	public List<VehicleDto> findCarDriver(String carDriver, Pageable pageable) {
		List<VehicleDto> list = vehicleRepository.findByCarDriver(carDriver, pageable);
		return list;
	}

	@Override
	public List<VehicleDto> findByCarDriverAndPrice(String carDriver, int price, Pageable pageable) {
		List<VehicleDto> list = vehicleRepository.findByCarDriverAndPrice(carDriver, price, pageable);
		return list;
	}

	@Override
	public List<VehicleDto> findByCarDriverOrCarType(String carDriver, String carType, Pageable pageable) {
		List<VehicleDto> list = vehicleRepository.findByCarDriverOrCarType(carDriver, carType, pageable);
		return list;
	}

	@Override
	public List<VehicleDto> findByPriceBetween(int price1, int price2) {
		List<VehicleDto> list = vehicleRepository.findByPriceBetween(price1, price2);
		return list;
	}

	@Override
	public List<VehicleDto> findByAddressPointDtoName(String name,Pageable pageable) {
		List<VehicleDto> list = vehicleRepository.findByAddressPointDtoName(name,pageable);
		return list;
	}

}

ElasticsearchTemplate 使用

VehicleTemplateService接口

package com.es.api;

import java.util.List;

import com.es.dto.VehicleDto;

public interface VehicleTemplateService {
	
	public void bulkIndex(List<VehicleDto> personList);
	
	public List<VehicleDto> queryForList(double lat, double lon);
	
	public List<VehicleDto> queryDto();
	
}

VehicleTemplateServiceImpl实现类

package com.es.service.impl;

import java.util.ArrayList;
import java.util.List;

import org.elasticsearch.common.geo.GeoPoint;
import org.elasticsearch.common.unit.DistanceUnit;
import org.elasticsearch.index.query.GeoDistanceQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.sort.GeoDistanceSortBuilder;
import org.elasticsearch.search.sort.SortBuilders;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.query.IndexQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.query.SearchQuery;
import org.springframework.stereotype.Service;

import com.es.api.VehicleTemplateService;
import com.es.dto.VehicleDto;

@Service
public class VehicleTemplateServiceImpl implements VehicleTemplateService{
	
	private @Autowired ElasticsearchTemplate elasticsearchTemplate;

	public void bulkIndex(List<VehicleDto> vehicleDto) {
		int counter = 0;
        List<IndexQuery> queries = new ArrayList<>();
        //https://github.com/spring-projects/spring-data-elasticsearch/wiki/Geo-indexing-and-request
        //必须使用Mapping先去创建然后在添加数据，否则会出现geo类型错误
        elasticsearchTemplate.createIndex(VehicleDto.class);
        elasticsearchTemplate.putMapping(VehicleDto.class);
        for (VehicleDto vehiclePointEsDto : vehicleDto) {
            IndexQuery indexQuery = new IndexQuery();
            indexQuery.setId(vehiclePointEsDto.getId() + "");
                indexQuery.setObject(vehiclePointEsDto);
                //上面的那几步也可以使用IndexQueryBuilder来构建
                //IndexQuery index = new IndexQueryBuilder().withId(VehiclePointEsDto.getId() + "").withObject(VehicleDto).build();
                queries.add(indexQuery);
                if (counter % 500 == 0) {
                    elasticsearchTemplate.bulkIndex(queries);
                    queries.clear();
                    System.out.println("bulkIndex counter : " + counter);
            }
            counter++;
        }
        if (queries.size() > 0) {
            elasticsearchTemplate.bulkIndex(queries);
            System.out.println("运行完成");
        }
        System.out.println("bulkIndex completed.");
	}
	
	 /**
    *
    geo_distance: 查找距离某个中心点距离在一定范围内的位置
    geo_bounding_box: 查找某个长方形区域内的位置
    geo_distance_range: 查找距离某个中心的距离在min和max之间的位置
    geo_polygon: 查找位于多边形内的地点。
    sort可以用来排序
    */
	@Override
	public List<VehicleDto> queryForList(double lat, double lon) {
		Long nowTime = System.currentTimeMillis();
        //查询某经纬度10000米范围内
        GeoDistanceQueryBuilder builder = QueryBuilders.geoDistanceQuery("addressPointDto.address").point(lat, lon)
                .distance(10000, DistanceUnit.METERS);
       
        GeoDistanceSortBuilder sortBuilder = SortBuilders
//        		.geoDistanceSort("address")
        		.geoDistanceSort("addressPointDto.address",new GeoPoint(lat, lon))//高版本使用
        		.point(lat, lon)
                .unit(DistanceUnit.METERS)
                .order(SortOrder.ASC);
        //分页查询50条
//		Pageable pageable = new PageRequest(0, 50);
        //查询经纬度10000米范围内，并根据坐标排序
//        NativeSearchQueryBuilder builder1 = new NativeSearchQueryBuilder().withFilter(builder).withPageable(pageable).withSort(sortBuilder);
        /**
         * 使用QueryBuilder
         * termQuery("key", obj) 完全匹配(不进行分词匹配)
         * termsQuery("key", obj1, obj2..)   一次匹配多个值
         * matchQuery("key", Obj) 单个匹配(分词匹配), field不支持通配符, 前缀具高级特性
         * multiMatchQuery("text", "field1", "field2"..);  匹配多个字段, field有通配符忒行
         * matchAllQuery();         匹配所有文件
         * matchPhraseQuery() 类似于数据库里的“%名字57%”这种
         */
        //查询经纬度10000米范围内，name字段的值为名字57，并根据坐标排序
//        QueryBuilder queryBuilder = QueryBuilders.termQuery("name", "名字57");
//        NativeSearchQueryBuilder builder1 = new NativeSearchQueryBuilder().withQuery(queryBuilder).withFilter(builder).withPageable(pageable).withSort(sortBuilder);
//        NativeSearchQueryBuilder builder1 = new NativeSearchQueryBuilder().withQuery(QueryBuilders.termQuery("name", "名字57")).withFilter(builder).withPageable(pageable).withSort(sortBuilder);
		
        /**
         * 组合查询
         * must(QueryBuilders) :   AND
         * mustNot(QueryBuilders): NOT
         * should:                  : OR
         */
        QueryBuilder queryBuilder = QueryBuilders.boolQuery().must(QueryBuilders.matchQuery("carDriver", "李四")).should(QueryBuilders.matchQuery("addressPointDto.name", "李四"));
//        QueryBuilder queryBuilder = QueryBuilders.boolQuery().must(QueryBuilders.matchQuery("remark", "祖国"));
//        QueryBuilder queryBuilder = QueryBuilders.boolQuery().must(QueryBuilders.matchQuery("name", "名字57")).mustNot(QueryBuilders.matchQuery("id", "43")).should(QueryBuilders.matchQuery("type", "类型36"));
        NativeSearchQueryBuilder builder1 = new NativeSearchQueryBuilder().withQuery(queryBuilder).withFilter(builder).withPageable(PageRequest.of(0,50)).withSort(sortBuilder);
        SearchQuery searchQuery = builder1.build();
 
        //queryForList默认是分页，走的是queryForPage，默认10个
        List<VehicleDto> VehiclePointEsDtoList = elasticsearchTemplate.queryForList(searchQuery, VehicleDto.class);
 
        System.out.println("耗时：" + (System.currentTimeMillis() - nowTime));
        return VehiclePointEsDtoList;
	}

	@Override
	public List<VehicleDto> queryDto() {
		 NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder().withQuery(QueryBuilders.termQuery("carDriver", "张三1"));
	     SearchQuery searchQuery = builder.build();
	 
        //queryForList默认是分页，走的是queryForPage，默认10个
        List<VehicleDto> VehiclePointEsDtoList = elasticsearchTemplate.queryForList(searchQuery, VehicleDto.class);
        return VehiclePointEsDtoList;
	}

}

elasticsearchTest 测试类

package com.es;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Random;

import org.elasticsearch.common.geo.GeoPoint;
import org.elasticsearch.index.query.QueryBuilders;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.query.SearchQuery;
import org.springframework.test.context.junit4.SpringRunner;

import com.es.api.VehicleService;
import com.es.api.VehicleTemplateService;
import com.es.dto.AddressPointDto;
import com.es.dto.VehicleDto;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = ElasticSearchApplication.class)
public class elasticsearchTest {
	
	@Autowired
    private VehicleService vehicleService;
	@Autowired
    private ElasticsearchTemplate elasticsearchTemplate;
	@Autowired
    private VehicleTemplateService vehicleTemplateService;
	
	
	@Test
    public void queryGeos(){
		double lat = 39.929986;
        double lon = 116.395645;
        List<VehicleDto> list = vehicleTemplateService.queryForList(lat, lon);
        System.out.println(list);
	}
	
	@Test
    public void bulkIndex(){
		List<VehicleDto> list = new ArrayList<>();
    	double lat = 39.929986;
        double lon = 116.395645;
    	List<AddressPointDto> addressPointDto = new ArrayList<>();
        for (int i = 1 ; i < 10; i++) {
            double max = 0.00001;
            double min = 0.000001;
            Random random = new Random();
            double s = random.nextDouble() % (max - min + 1) + max;
            DecimalFormat df = new DecimalFormat("######0.000000");
            // System.out.println(s);
            String lons = df.format(s + lon);
            String lats = df.format(s + lat);
            Double dlon = Double.valueOf(lons);
            Double dlat = Double.valueOf(lats);
 
            AddressPointDto person = new AddressPointDto();
            person.setId(Long.valueOf(i));
            person.setName("李四" + i);
            person.setType("类型" + i);
            person.setXjTime(new Date());
            if(i%2 == 0) {
            	person.setRemark("我爱中国，我爱祖国"+i);
            }
            if(i%3 == 0) {
            	person.setRemark("我不爱美国，我爱祖国"+i);
            }else{
            	person.setRemark("我不爱日本，我爱祖国"+i);
            }
            
            person.setAddress(new GeoPoint(dlat,dlon));
            addressPointDto.add(person);
        }
    	for (int j = 0; j < 10; j++) {
    		VehicleDto vehicleDto = new VehicleDto();
    		vehicleDto.setId(Long.valueOf(j));
        	vehicleDto.setCarDriver("李四"+j);
        	vehicleDto.setCarName(j+".2米");
        	vehicleDto.setCarType(j+"");
        	vehicleDto.setPrice(j*1000);
        	vehicleDto.setStatus("1");
        	vehicleDto.setAddressPointDto(addressPointDto);
        	list.add(vehicleDto);
		}
    	
    	System.out.println("list:"+list);
		vehicleTemplateService.bulkIndex(list);
	}
	
	@Test
    public void queryDto(){
//		 Pageable pageable = new PageRequest(0, 5);
//		 NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder().withQuery(QueryBuilders.matchQuery("carDriver", "张三1"));
		 NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder().withQuery(QueryBuilders.matchQuery("addressPointDto.name", "张三1")).withPageable(PageRequest.of(0,5));
	     SearchQuery searchQuery = builder.build();
	 
        //queryForList默认是分页，走的是queryForPage，默认10个
        List<VehicleDto> vehicleDto = elasticsearchTemplate.queryForList(searchQuery, VehicleDto.class);
		System.err.println("findAll:"+vehicleDto);
	 }
	
	
	@Test
    public void findByAddressPointDtoName(){
		String name = "张三1";
		List<VehicleDto> list = vehicleService.findByAddressPointDtoName(name,PageRequest.of(0,5));
		System.err.println("findAll:"+list);
	 }
	
	@Test
    public void findByCarDriverAndPrice(){
		String carDriver = "张三1";
		int price = 1000;
//		Pageable pageable = new PageRequest(0, 5);
		List<VehicleDto> list = vehicleService.findByCarDriverAndPrice(carDriver, price, PageRequest.of(0,5));
		System.err.println("findAll:"+list);
	 }
	
	@Test
    public void findAll(){
		 List<VehicleDto> list = vehicleService.findAll();
		 System.err.println("findAll:"+list);
	 }
	
	@Test
    public void del(){
		Long id = 18L;
		vehicleService.del(id);
	}
	
	/**
     * 创建Index
     */
    @Test
    public void createIndex(){
    	List<VehicleDto> list = new ArrayList<>();
    	double lat = 39.929986;
        double lon = 116.395645;
    	List<AddressPointDto> addressPointDto = new ArrayList<>();
        for (int i = 1 ; i < 10; i++) {
            double max = 0.00001;
            double min = 0.000001;
            Random random = new Random();
            double s = random.nextDouble() % (max - min + 1) + max;
            DecimalFormat df = new DecimalFormat("######0.000000");
            // System.out.println(s);
            String lons = df.format(s + lon);
            String lats = df.format(s + lat);
            Double dlon = Double.valueOf(lons);
            Double dlat = Double.valueOf(lats);
 
            AddressPointDto person = new AddressPointDto();
            person.setId(Long.valueOf(i));
            person.setName("张三" + i);
            person.setType("类型" + i);
            person.setXjTime(new Date());
            if(i%2 == 0) {
            	person.setRemark("我爱中国，我爱祖国"+i);
            }
            if(i%3 == 0) {
            	person.setRemark("我不爱美国，我爱祖国"+i);
            }else{
            	person.setRemark("我不爱日本，我爱祖国"+i);
            }
            
            person.setAddress(new GeoPoint(dlat,dlon));
            addressPointDto.add(person);
        }
    	for (int j = 30; j < 40; j++) {
    		VehicleDto vehicleDto = new VehicleDto();
    		vehicleDto.setId(Long.valueOf(j));
        	vehicleDto.setCarDriver("赵六"+j);
        	vehicleDto.setCarName(j+".2米");
        	vehicleDto.setCarType(j+"");
        	vehicleDto.setPrice(j*1000);
        	vehicleDto.setStatus("1");
        	vehicleDto.setAddressPointDto(addressPointDto);
        	list.add(vehicleDto);
		}
    	
//    	vehicleService.set(vehicleDto);
    	System.out.println("list:"+list);
    	//如果需要使用到geo必须用ElasticsearchTemplate的方式添加
    	vehicleService.setAll(list);
    }
}

github地址：https://github.com/LX1309244704/SpringBoot-master/tree/master/springboot-es

尔笑惹千愁
关注
专栏目录
【微服务】RedisSearch 使用详解
congge
10-07 6574
RedisJson使用详解
ElasticSearch基础
MR_T3的博客
02-19 971
ElasticSearch基础知识与使用
SpringBoot2.0整合Elasticsearch6.0使用ElasticsearchRepository接口实践
01-23
SpringBoot2.0整合Elasticsearch6.0,使用SpringBoot对ES支持ElasticsearchRepository接口API，ElasticsearchTemplate接口API实现ES的增删改查实践
SpringBoot2.x集成Elasticsearch6.4.2
热门推荐
ThisLX的博客
11-06 2万+
1、配置JDK环境变量 略 2、Linux安装ElasticSearch6.4.2 下载地址：https://www.elastic.co/cn/downloads/elasticsearch 将下载的zip包移动到/usr/local/（目录自定） 使用unzip进行解压 启动脚本在bin目录下 使用./elasticsearch命令启动，但是不能使用root用户，因此我们需要创建用户。 #创建...
springboot 2 整合Elasticsearch 6.x
太多的虚幻
06-11 1万+
添加核心依赖 &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.elasticsearch&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;elasticsearch&amp;lt;/artifactId&amp;gt; &amp;lt;/depe
springboot2.0集成elasticsearch6.3.2
大神，带带我的博客
08-23 4789
1.maven依赖 &lt;parent&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-parent&lt;/artifactId&gt; &lt;version&gt;2.0.0.RELEASE&lt;/vers...
Springboot整合ES地理位置查询
weixin_44008460的博客
09-10 2591
ES的地理位置查询 1、背景 店铺有实体类，在地图上搜索显示当前位置附近店铺，并显示距当前位置距离；当前位置由前端传参（经度与纬度）。 比如我们有很多的4s店，给用户一个app，在某个地方的时候，可以根据当前的地理位置搜索一下，自己附近的4s店。 （刚学会代码实现，做个笔记，原理和源码暂时没研究） 2、代码示例 /** * @description: 门店实体 **/ ...
spring-boot-demo：springboot 2.1+整合各种技术
01-29
springboot 2.0+整合各种技术 点击添加springboot全系列技术交流qq群： 所有的测试用例均在springboot默认生成的测试文件夹下的测试类里 √：完结“”：正在更&times;：待更 模块快速预览： ：常见的设计模式：观察者...
ElasticSearch知识概括
weixin_41005188的博客
12-29 1430
ElasticSearch知识概括
Lucene 和 Kibana、ElasticSeach、Spring Data ElasticSearch
qq_40286307的博客
11-27 522
什么是全文检索 数据分类 生活中的数据总体分为两种：结构化数据和非结构化数据。 结构化数据 - 行数据，可以用二维表结构来逻辑表达实现的数据；指具有固定格式或有限长度的数据，如数据库，元数据等。 非结构化数据 - 指不定长或无固定格式的数据，如邮件，word 文档等磁盘上的文件。 结构化数据搜索 常见的结构化数据也就是数据库中的数据。 在数据库中搜索很容易实现，通常都是使用 SQL 语句进行查询，而且能很快的得到查询结果。 客户端请求 ----> 连接器 连接器 ----> 缓存区 连接器 -
springboot整合ElasticSearch集群
03-29
springboot 2.0.2集成elasticsearch5.5.1，并使用集群模式，亲测可用！！！
SpringBoot2.x配置Elasticsearch与使用Kibana
Dong_Zi8的博客
04-29 348
下载时首先看自己项目springBoot版本 需要对应 本项目使用SpringBoot2.2.5，Elasticsearch6.8.6 Elasticsearch安装和使用 下载Elasticsearch6.2.2的zip包，并解压到指定目录，下载地址：https://www.elastic.co/cn/downloads/past-releases/elasticsearch-6-8-6 进入bin目录下安装分词器，执行命令 elasticsearch-plugin install https://g
SpringBoot整合Redis的GEO实现查找附近门店功能
最新发布
qq_19527577的博客
03-04 1052
GIS代表地理信息系统，是一种用于收集、存储、分析、管理和显示地理空间数据的技术。GIS利用计算机软件和硬件来创建、管理、分析和可视化地理信息，使用户能够更好地了解和解决地理空间问题。下面是基于百度的地图经纬度定位系统，大家可以自己体验下，你给它一个经纬度，他能给你定位到地图的某一个点。也就是当前经纬度的位置。根据这个坐标我们查出来附近的人，或者附近的门店之类的。在去了解基于位置的附近服务之前，我们先来看一下什么是GIS技术。之后新增的一个数据类型，是一种用于处理地理位置信息的数据结构。
Day16_08_ES教程之SpringBoot整合ElasticSearch
一一哥
07-07 646
SpringBoot整合ElasticSearch 一. 前言 1. 版本概述 SpringBoot2.x 的spring-boot-starter-data-elasticsearch中可以支持Elasticsearch 6.X版本.而SpringBoot1.x版本的spring-boot-starter-data-elasticsearch,默认只能支持Elasticsearch 2.X...
SpringBoot Data ElasticSearch 4.* 使用 GeoPoint 坐标位置获取范围内数据
TCLms的博客
03-04 1864
近期项目需要用到ElasticSearch根据坐标获取范围内的数据，却很少见到关于4.*版本关于GeoPoint新型写法的详细文章，在官方文档中，对于新人而言却又很难理解使用。本文将记录使用GeoPoint根据地理位置获取数据的案例。
Elasticsearch——Geopoint字段类型
qq_37107851的博客
08-21 2894
geo_point类型的字段接受经纬度对，可以使用： 在边界框内、距离中心点一定距离内、多边形内或geo_shape查询内查找地质点的步骤。 按地理位置或距离中心点聚合文档。 将距离整合到文档的相关性得分中。 按距离对文档进行排序。 指定geopoint点有五种方式，如下所示： PUT my-index-000001 { "mappings": { "properties": { "location": { "type":
elasticsearch整合springboot的地理位置功能介绍
weixin_43083853的博客
05-22 1246
前面的文章提到了，如果要实现附近的人或者获取POI点的功能，可以使用redis的geo类型。但是提前得把这些数据的信息存进redis，redis是基于内存查找的，相较于硬盘，内存的资源显得更贵一点，所以将大量的数据存入redis显然不是很合适，这里我们介绍另一种方式来实现此功能，使用elasticsearch的GeoPoint和GeoShape类型。GeoPoint和GeoShape是elasticsearch中表示地理位置的两种方式GeoPoint，顾名思义是针对于坐标点的地理位置操作。
【elasticsearch】地理范围查询geo_point、geo_shape
weixin_42068745的博客
11-01 5033
需求 使用多边形查询小区的座栋 方案一 使用geo_point 1.在es中添加geoPoint字段 PUT /index/_mapping/type { "properties": { "geoPoint":{ "type": "geo_point" } } } 2.楼栋实体类添加geoPoint字段 import org.springframework.data.elasticsearch.core.geo.GeoPoint; public cla
SpringBoot整合SpringDataElasticSearch 完成地理搜索 附近人搜索 距离搜索
深度
03-19 3675
找了很多教程，就是由于各种原因运行不起来，在百度中 遇到了以下文章帮助了我 SpringData Elastic 地理搜索https://www.jianshu.com/p/7373a194a2a3 1. 环境配置 1.1 依赖 <!-- Springboot的版本为 2.1.3.RELEASE --> <dependency> <gr...
springboot2.6.X整合elasticsearch
05-19
在Spring Boot 2.6.x中，可以使用Spring Data Elasticsearch来整合Elasticsearch。Spring Data Elasticsearch提供了一组用于构建Elasticsearch应用程序的API，并且可以轻松地与Spring Boot集成。下面是整合步骤： 1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值