探花10
文章目录
基于mongodb的地理位置的维护
UserLocation
package com.tanhua.dubbo.server.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.bson.types.ObjectId;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.geo.GeoJsonPoint;
import org.springframework.data.mongodb.core.index.CompoundIndex;
import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.Document;
@Data
@NoArgsConstructor
@AllArgsConstructor
@Document(collection = "user_location")
@CompoundIndex(name = "location_index", def = "{'location': '2dsphere'}")
public class UserLocation implements java.io.Serializable{
private static final long serialVersionUID = 4508868382007529970L;
@Id
private ObjectId id;
@Indexed
private Long userId; //用户id
private GeoJsonPoint location; //x:经度 y:纬度
private String address; //位置描述
private Long created; //创建时间
private Long updated; //更新时间
private Long lastUpdated; //上次更新时间
}
package com.tanhua.dubbo.server.api;
import com.alibaba.dubbo.config.annotation.Service;
import com.tanhua.dubbo.server.pojo.UserLocation;
import com.tanhua.dubbo.server.vo.UserLocationVo;
import org.bson.types.ObjectId;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.geo.Circle;
import org.springframework.data.geo.Distance;
import org.springframework.data.geo.Metrics;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.geo.GeoJsonPoint;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import java.util.List;
@Service(version = "1.0.0")
public class UserLocationApiImpl implements UserLocationApi {
@Autowired
private MongoTemplate mongoTemplate;
@Override
public String updateUserLocation(Long userId, Double longitude, Double latitude, String address) {
UserLocation userLocation = new UserLocation();
userLocation.setAddress(address);
userLocation.setUserId(userId);
userLocation.setLocation(new GeoJsonPoint(longitude, latitude));
// 查询用户的地理位置
Query query = Query.query(Criteria.where("userId").is(userId));
UserLocation ul = this.mongoTemplate.findOne(query, UserLocation.class);
if (null == ul) {
//新增用户位置数据
userLocation.setId(ObjectId.get());
userLocation.setCreated(System.currentTimeMillis());
userLocation.setUpdated(userLocation.getCreated());
userLocation.setLastUpdated(userLocation.getCreated());
this.mongoTemplate.save(userLocation);
return userLocation.getId().toHexString();
} else {
//更新
Update update = Update.update("location", userLocation.getLocation())
.set("updated", System.currentTimeMillis())
.set("lastUpdated", ul.getUpdated())
.set("address", userLocation.getAddress());
this.mongoTemplate.updateFirst(query, update, UserLocation.class);
}
return ul.getId().toHexString();
}
@Override
public UserLocationVo queryByUserId(Long userId) {
Query query = Query.query(Criteria.where("userId").is(userId));
UserLocation userLocation = this.mongoTemplate.findOne(query, UserLocation.class);
if(null != userLocation){
return UserLocationVo.format(userLocation);
}
return null;
}
@Override
public List<UserLocationVo> queryUserFromLocation(Double longitude, Double latitude, Integer range) {
// 根据传入的坐标,进行确定中心点
GeoJsonPoint geoJsonPoint = new GeoJsonPoint(longitude, latitude);
// 画圈的半径
Distance distance = new Distance(range / 1000, Metrics.KILOMETERS);
// 画了一个圆圈
Circle circle = new Circle(geoJsonPoint, distance);
Query query = Query.query(Criteria.where("location").withinSphere(circle));
List<UserLocation> userLocations = this.mongoTemplate.find(query, UserLocation.class);
return UserLocationVo.formatToList(userLocations);
}
}
elasticsearch集群的搭建
两个 Java 客户端都是通过 9300 端口并使用 Elasticsearch 的原生 传输 协议和集群交互。集群中的节点通过端口 9300 彼此通信。如果这个端口没有打开,节点将无法形成一个集群。
jvm.options
-Xms128m
-Xmx128m
-XX:+UseConcMarkSweepGC
-XX:CMSInitiatingOccupancyFraction=75
-XX:+UseCMSInitiatingOccupancyOnly
-XX:+AlwaysPreTouch
-Xss1m
-Djava.awt.headless=true
-Dfile.encoding=UTF-8
-Djna.nosys=true
-XX:-OmitStackTraceInFastThrow
-Dio.netty.noUnsafe=true
-Dio.netty.noKeySetOptimization=true
-Dio.netty.recycler.maxCapacityPerThread=0
-Dlog4j.shutdownHookEnabled=false
-Dlog4j2.disable.jmx=true
-Djava.io.tmpdir=${ES_TMPDIR}
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=data
-XX:ErrorFile=logs/hs_err_pid%p.log
8:-XX:+PrintGCDetails
8:-XX:+PrintGCDateStamps
8:-XX:+PrintTenuringDistribution
8:-XX:+PrintGCApplicationStoppedTime
8:-Xloggc:logs/gc.log
8:-XX:+UseGCLogFileRotation
8:-XX:NumberOfGCLogFiles=32
8:-XX:GCLogFileSize=64m
9-:-Xlog:gc*,gc+age=trace,safepoint:file=logs/gc.log:utctime,pid,tags:filecount=32,filesize=64m
9-:-Djava.locale.providers=COMPAT
10-:-XX:UseAVX=2#单个进程中的最大线程数
vim /etc/sysctl.conf
vm.max_map_count=262144 #立即生效
/sbin/sysctl -p
mkdir /itcast/tanhua/es-cluster/node01 -p
mkdir /itcast/tanhua/es-cluster/node02 -p
mkdir /itcast/tanhua/es-cluster/node03 -p
#复制资料目录下的jvm.options到node01、node02、node03目录
#在node01目录下,创建elasticsearch.yml文件,并输入如下内容:
cluster.name: es-tanhua-cluster
node.name: node01
node.master: true
node.data: true
network.host: 192.168.200.146
http.port: 9200
discovery.zen.ping.unicast.hosts: ["192.168.200.146"]
discovery.zen.minimum_master_nodes: 2
http.cors.enabled: true
http.cors.allow-origin: "*"
#在node02目录下,创建elasticsearch.yml文件,并输入如下内容:
cluster.name: es-tanhua-cluster
node.name: node02
node.master: true
node.data: true
network.host: 192.168.200.146
http.port: 9201
discovery.zen.ping.unicast.hosts: ["192.168.200.146"]
discovery.zen.minimum_master_nodes: 2
http.cors.enabled: true
http.cors.allow-origin: "*"
#在node03目录下,创建elasticsearch.yml文件,并输入如下内容:
cluster.name: es-tanhua-cluster
node.name: node03
node.master: true
node.data: true
network.host: 192.168.200.146
http.port: 9202
discovery.zen.ping.unicast.hosts: ["192.168.200.146"]
discovery.zen.minimum_master_nodes: 2
http.cors.enabled: true
http.cors.allow-origin: "*"
#创建容器
docker create --restart=always --name es-node01 --net host \
-v /itcast/tanhua/es-cluster/node01/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /itcast/tanhua/es-cluster/node01/jvm.options:/usr/share/elasticsearch/config/jvm.options \
-v /itcast/tanhua/es-cluster/node01/es-cluster-node01-data:/usr/share/elasticsearch/data elasticsearch:6.5.4
docker create --restart=always --name es-node02 --net host \
-v /itcast/tanhua/es-cluster/node02/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /itcast/tanhua/es-cluster/node02/jvm.options:/usr/share/elasticsearch/config/jvm.options \
-v /itcast/tanhua/es-cluster/node02/es-cluster-node02-data:/usr/share/elasticsearch/data elasticsearch:6.5.4
docker create --restart=always --name es-node03 --net host \
-v /itcast/tanhua/es-cluster/node03/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /itcast/tanhua/es-cluster/node03/jvm.options:/usr/share/elasticsearch/config/jvm.options \
-v /itcast/tanhua/es-cluster/node03/es-cluster-node03-data:/usr/share/elasticsearch/data elasticsearch:6.5.4
#/itcast/tanhua/es-cluster/node01 权限chmod 777
#启动容器
docker start es-node01 es-node02 es-node03
#或单个启动并查看日志
docker start es-node01 && docker logs -f es-node01
docker start es-node02 && docker logs -f es-node02
docker start es-node03 && docker logs -f es-node03
启动后的结果
需要查看日志,观察哪台机器被选择为master
三台机器的tcp port分别为9300 9301 9302
测试新新建分片
黄色表示副本正在同步
appcation.properties
spring.application.name = itcast-tanhua-elasticsearch
server.port = 18082
spring.data.elasticsearch.cluster-name=es-tanhua-cluster
spring.data.elasticsearch.cluster-nodes=192.168.31.81:9300,192.168.31.81:9301,192.168.31.81:9302依赖
<?xml version="1.0" encoding="UTF-8"?>
<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">
<parent>
<artifactId>my-tanhua</artifactId>
<groupId>cn.itcast.tanhua</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>my-tanhua-elasticsearch</artifactId>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!--其他工具包依赖-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
</project>基于elasticsearchTemplate维护经纬度
UserLocationController
package com.tanhua.es.controller;
import com.tanhua.es.pojo.UserLocationES;
import com.tanhua.es.service.UserLocationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
@RestController
@RequestMapping("es/user/location")
public class UserLocationController {
@Autowired
private UserLocationService userLocationService;
/**
* 更新用户的地理位置
*
* @param param
* @return
*/
@PostMapping
public ResponseEntity<UserLocationES> updateUserLocation(@RequestBody Map<String, Object> param) {
try {
Long userId = Long.valueOf(param.get("userId").toString());
Double longitude = Double.valueOf(param.get("longitude").toString());
Double latitude = Double.valueOf(param.get("latitude").toString());
String address = param.get("address").toString();
boolean result = this.userLocationService.updateUserLocation(userId, longitude, latitude, address);
if (result) {
return ResponseEntity.ok(null);
}
} catch (NumberFormatException e) {
e.printStackTrace();
}
return ResponseEntity.status(HttpStatus.INSUFFICIENT_STORAGE).build();
}
/**
* 查询用户的地理位置
*
* @param userId
* @return
*/
@GetMapping("{userId}")
public ResponseEntity<UserLocationES> queryUserLocation(@PathVariable("userId") Long userId) {
try {
UserLocationES userLocationES = this.userLocationService.queryByUserId(userId);
if (null == userLocationES) {
return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
}
return ResponseEntity.ok(userLocationES);
} catch (Exception e) {
e.printStackTrace();
}
return ResponseEntity.status(HttpStatus.INSUFFICIENT_STORAGE).build();
}
/**
* 搜索附近的人
*
* @param param
* @return
*/
@PostMapping("list")
public ResponseEntity<List<UserLocationES>> queryUserFromLocation(@RequestBody Map<String, Object> param) {
try {
Double longitude = Double.valueOf(param.get("longitude").toString());
Double latitude = Double.valueOf(param.get("latitude").toString());
Double distance = Double.valueOf(param.get("distance").toString());
Integer page = param.get("page") == null ? 1 : Integer.valueOf(param.get("page").toString());
Integer pageSize = param.get("pageSize") == null ? 100 : Integer.valueOf(param.get("pageSize").toString());
Page<UserLocationES> userLocationES = this.userLocationService.queryUserFromLocation(longitude, latitude, distance, page, pageSize);
return ResponseEntity.ok(userLocationES.getContent());
} catch (NumberFormatException e) {
e.printStackTrace();
}
return ResponseEntity.status(HttpStatus.INSUFFICIENT_STORAGE).build();
}
}
UserLocationES
package com.tanhua.es.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.elasticsearch.common.geo.GeoPoint;
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;
import org.springframework.data.elasticsearch.annotations.GeoPointField;
@Data
@NoArgsConstructor
@AllArgsConstructor
@Document(indexName = "tanhua", type = "user_location", shards = 6, replicas = 2)
public class UserLocationES {
@Id
private Long userId; //用户id
@GeoPointField
private GeoPoint location; //x:经度 y:纬度
@Field(type = FieldType.Keyword)
private String address; //位置描述
@Field(type = FieldType.Long)
private Long created; //创建时间
@Field(type = FieldType.Long)
private Long updated; //更新时间
@Field(type = FieldType.Long)
private Long lastUpdated; //上次更新时间
}
UserLocationService
package com.tanhua.es.service;
import com.tanhua.es.pojo.UserLocationES;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.common.geo.GeoPoint;
import org.elasticsearch.common.unit.DistanceUnit;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.GeoDistanceQueryBuilder;
import org.elasticsearch.search.sort.GeoDistanceSortBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.query.*;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.Map;
@Service
public class UserLocationService {
@Autowired
private ElasticsearchTemplate elasticsearchTemplate;
public boolean updateUserLocation(Long userId, Double longitude, Double latitude, String address) {
try {
// 判断索引库是否存在,如果不存在需要创建
if (!this.elasticsearchTemplate.indexExists(UserLocationES.class)) {
//创建索引
this.elasticsearchTemplate.createIndex(UserLocationES.class);
}
// 判断类型是否存在,如果不存在,需要创建
if (!this.elasticsearchTemplate.typeExists("tanhua", "user_location")) {
//创建类型
this.elasticsearchTemplate.putMapping(UserLocationES.class);
}
// 判断用户的位置数据是否存在,如果存在,进行更新操作,如果不存在,插入新的数据
GetQuery getQuery = new GetQuery();
getQuery.setId(userId.toString());
UserLocationES ul = this.elasticsearchTemplate.queryForObject(getQuery, UserLocationES.class);
if (null == ul) {
// 新增位置数据
UserLocationES userLocationES = new UserLocationES();
userLocationES.setAddress(address);
userLocationES.setCreated(System.currentTimeMillis());
userLocationES.setLastUpdated(userLocationES.getCreated());
userLocationES.setUpdated(userLocationES.getCreated());
userLocationES.setUserId(userId);
userLocationES.setLocation(new GeoPoint(latitude, longitude));
IndexQuery indexQuery = new IndexQueryBuilder().withObject(userLocationES).build();
this.elasticsearchTemplate.index(indexQuery); //保存数据到Elasticsearch中
} else {
//更新操作
Map<String, Object> map = new HashMap<>();
map.put("lastUpdated", ul.getUpdated());
map.put("updated", System.currentTimeMillis());
map.put("address", address);
map.put("location", new GeoPoint(latitude, longitude));
UpdateRequest updateRequest = new UpdateRequest();
updateRequest.doc(map);
UpdateQuery updateQuery = new UpdateQueryBuilder().withId(userId.toString())
.withClass(UserLocationES.class)
.withUpdateRequest(updateRequest).build();
this.elasticsearchTemplate.update(updateQuery);
}
return true;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
public UserLocationES queryByUserId(Long userId) {
GetQuery getQuery = new GetQuery();
getQuery.setId(userId.toString());
return this.elasticsearchTemplate.queryForObject(getQuery, UserLocationES.class);
}
/**
* 查询附近的人
*
* @param longitude 经度
* @param latitude 纬度
* @param distance 距离(单位:米)
* @param page 页数
* @param pageSize 页面大小
* @return
*/
public Page<UserLocationES> queryUserFromLocation(Double longitude, Double latitude, Double distance, Integer page, Integer pageSize) {
String fieldName = "location";
// NativeSearchQuery实现了SearchQuery接口
NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
// 分页
PageRequest pageRequest = PageRequest.of(page - 1, pageSize);
nativeSearchQueryBuilder.withPageable(pageRequest);
// 定义bool查询
BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
// geo查询,定义中心点,指定查询范围
GeoDistanceQueryBuilder geoDistanceQueryBuilder = new GeoDistanceQueryBuilder(fieldName);
geoDistanceQueryBuilder.point(latitude , longitude);
geoDistanceQueryBuilder.distance(distance / 1000, DistanceUnit.KILOMETERS);
boolQueryBuilder.must(geoDistanceQueryBuilder);
nativeSearchQueryBuilder.withQuery(boolQueryBuilder);
// 按照距离升序
GeoDistanceSortBuilder geoDistanceSortBuilder = new GeoDistanceSortBuilder(fieldName, latitude, longitude);
geoDistanceSortBuilder.unit(DistanceUnit.KILOMETERS); //距离单位
geoDistanceSortBuilder.order(SortOrder.ASC); //升序
nativeSearchQueryBuilder.withSort(geoDistanceSortBuilder);
return this.elasticsearchTemplate.queryForPage(nativeSearchQueryBuilder.build(), UserLocationES.class);
}
}
评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论