day06-路线规划之微服务

shuhongfan
1 parent 30db74bf
Showing 16 changed files with 839 additions and 15 deletions
.gitignore
.idea/compiler.xml
.idea/encodings.xml
.idea/sl-express.iml
03-资料/maven/settings.xml
sl-express-ms-transport-service/src/main/java/com/sl/transport/enums/ExceptionEnum.java
sl-express-ms-transport-service/src/main/java/com/sl/transport/mq/AuthMQListener.java
sl-express-ms-transport-service/src/main/java/com/sl/transport/repository/impl/OrganRepositoryImpl.java
sl-express-ms-transport-service/src/main/java/com/sl/transport/repository/impl/TransportLineRepositoryImpl.java
sl-express-ms-transport-service/src/main/java/com/sl/transport/service/impl/AgencyServiceImpl.java
sl-express-ms-transport-service/src/main/java/com/sl/transport/service/impl/CostConfigurationServiceImpl.java
sl-express-ms-transport-service/src/main/java/com/sl/transport/service/impl/OLTServiceImpl.java
sl-express-ms-transport-service/src/main/java/com/sl/transport/service/impl/OrganServiceImpl.java
sl-express-ms-transport-service/src/main/java/com/sl/transport/service/impl/ServiceImpl.java
sl-express-ms-transport-service/src/main/java/com/sl/transport/service/impl/TLTServiceImpl.java
sl-express-ms-transport-service/src/main/java/com/sl/transport/service/impl/TransportLineServiceImpl.java
@@ -16,3 +16,4 @@
 *.iml
 out
 gen
+/.idea/
@@ -141,6 +141,8 @@
           <entry name="$MAVEN_REPOSITORY$/org/jsoup/jsoup/1.12.1/jsoup-1.12.1.jar" />
           <entry name="$MAVEN_REPOSITORY$/com/github/javaparser/javaparser-core/3.14.10/javaparser-core-3.14.10.jar" />
           <entry name="$MAVEN_REPOSITORY$/com/fasterxml/jackson/core/jackson-databind/2.10.3/jackson-databind-2.10.3.jar" />
+          <entry name="$MAVEN_REPOSITORY$/com/fasterxml/jackson/core/jackson-annotations/2.10.3/jackson-annotations-2.10.3.jar" />
+          <entry name="$MAVEN_REPOSITORY$/com/fasterxml/jackson/core/jackson-core/2.10.3/jackson-core-2.10.3.jar" />
           <entry name="$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter/5.6.2/junit-jupiter-5.6.2.jar" />
           <entry name="$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-api/5.6.2/junit-jupiter-api-5.6.2.jar" />
           <entry name="$MAVEN_REPOSITORY$/org/apiguardian/apiguardian-api/1.1.0/apiguardian-api-1.1.0.jar" />
@@ -64,6 +64,8 @@
     <file url="file://$PROJECT_DIR$/sentinel/sentinel-core/src/main/java" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/sentinel/sentinel-core/src/main/resources" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/sentinel/sentinel-dashboard/src/main/java" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/sentinel/sentinel-dashboard/src/main/resources" charset="UTF-8" />
+    <file url="file://$PROJECT_DIR$/sentinel/sentinel-dashboard/src/main/webapp" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/sentinel/sentinel-demo/sentinel-demo-annotation-cdi-interceptor/src/main/java" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/sentinel/sentinel-demo/sentinel-demo-annotation-cdi-interceptor/src/main/resources" charset="UTF-8" />
     <file url="file://$PROJECT_DIR$/sentinel/sentinel-demo/sentinel-demo-annotation-spring-aop/src/main/java" charset="UTF-8" />
@@ -2,7 +2,10 @@
 <module type="JAVA_MODULE" version="4">
   <component name="NewModuleRootManager" inherit-compiler-output="true">
     <exclude-output />
-    <content url="file://$MODULE_DIR$" />
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.idea/codeStyles" />
+      <excludeFolder url="file://$MODULE_DIR$/.idea/inspectionProfiles" />
+    </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
@@ -4,10 +4,10 @@
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
  
-    <!-- 本地仓库 -->
-    <localRepository>F:\maven\repository</localRepository>
+    <!-- 锟斤拷锟截仓匡拷 -->
+<!--    <localRepository>F:\maven\repository</localRepository>-->
  
-    <!-- 配置私服中deploy的账号 -->
+    <!-- 锟斤拷锟斤拷私锟斤拷锟斤拷deploy锟斤拷锟剿猴拷 -->
     <servers>
         <server>
             <id>sl-releases</id>
@@ -21,7 +21,7 @@
         </server>
     </servers>
  
-    <!-- 使用阿里云maven镜像，排除私服资源库 -->
+    <!-- 使锟矫帮拷锟斤拷锟斤拷maven锟斤拷锟斤拷锟脚筹拷私锟斤拷锟斤拷源锟斤拷 -->
     <mirrors>
         <mirror>
             <id>mirror</id>
@@ -34,7 +34,7 @@
     <profiles>
         <profile>
             <id>sl</id>
-            <!-- 配置项目deploy的地址 -->
+            <!-- 锟斤拷锟斤拷锟斤拷目deploy锟侥碉拷址 -->
             <properties>
                 <altReleaseDeploymentRepository>
                     sl-releases::default::http://maven.sl-express.com/nexus/content/repositories/releases/
@@ -43,7 +43,7 @@
                     sl-snapshots::default::http://maven.sl-express.com/nexus/content/repositories/snapshots/
                 </altSnapshotDeploymentRepository>
             </properties>
-            <!-- 配置项目下载依赖的私服地址 -->
+            <!-- 锟斤拷锟斤拷锟斤拷目锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷私锟斤拷锟斤拷址 -->
             <repositories>
                 <repository>
                     <id>sl-releases</id>
@@ -70,7 +70,7 @@
     </profiles>
  
     <activeProfiles>
-         <!-- 激活配置 -->
+         <!-- 锟斤拷锟斤拷锟斤拷锟斤拷 -->
         <activeProfile>sl</activeProfile>
     </activeProfiles>
  
@@ -16,7 +16,8 @@ public enum ExceptionEnum implements BaseExceptionEnum {
     TRANSPORT_LINE_ALREADY_EXISTS(1003, "路线已经存在"),
     TRANSPORT_LINE_NOT_FOUND(1004, "路线不存在"),
     TRANSPORT_LINE_TYPE_ERROR(1005, "路线类型错误"),
-    ORGAN_TYPE_ERROR(1006, "机构类型错误");
+    ORGAN_TYPE_ERROR(1006, "机构类型错误"),
+    TRANSPORT_LINE_ORGAN_CANNOT_SAME(1007, "起点、终点机构不能为空");
  
     private Integer code;
     private Integer status;
+package com.sl.transport.mq;
+
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
+import com.sl.transport.common.constant.Constants;
+import com.sl.transport.entity.node.AgencyEntity;
+import com.sl.transport.entity.node.BaseEntity;
+import com.sl.transport.entity.node.OLTEntity;
+import com.sl.transport.entity.node.TLTEntity;
+import com.sl.transport.enums.OrganTypeEnum;
+import com.sl.transport.service.IService;
+import com.sl.transport.utils.OrganServiceFactory;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.amqp.core.ExchangeTypes;
+import org.springframework.amqp.rabbit.annotation.Exchange;
+import org.springframework.amqp.rabbit.annotation.Queue;
+import org.springframework.amqp.rabbit.annotation.QueueBinding;
+import org.springframework.amqp.rabbit.annotation.RabbitListener;
+import org.springframework.stereotype.Component;
+
+/**
+ * 对于权限管家消息的处理
+ */
+@Slf4j
+@Component
+public class AuthMQListener {
+
+    @RabbitListener(bindings = @QueueBinding(
+            value = @Queue(name = Constants.MQ.Queues.AUTH_TRANSPORT),
+            exchange = @Exchange(name = "${rabbitmq.exchange}", type = ExchangeTypes.TOPIC),
+            key = "#"
+    ))
+    public void listenAgencyMsg(String msg) {
+        log.info("接收到消息->{}", msg);
+        JSONObject jsonObject = JSONUtil.parseObj(msg);
+
+//        获取type的值，如果不为ORG，直接return
+        String type = jsonObject.getStr("type");
+        if (!StrUtil.equalsIgnoreCase(type, "ORG")) {
+//            非机构消息
+            return;
+        }
+
+//        获取json中其他值 operation操作类型 content是数组0号下表
+        String operation = jsonObject.getStr("operation");
+        JSONObject content = (JSONObject) jsonObject.getJSONArray("content").getObj(0);
+
+//        取到content中的元素后,获取name机构名称 parentId父机构ID
+        String name = content.getStr("name");
+        Long parentId = content.getLong("parentId");
+
+        IService iService;
+        BaseEntity baseEntity;
+        if (StrUtil.endWith(name, "转运中心")) {
+//            一级转运中心
+            iService = OrganServiceFactory.getBean(OrganTypeEnum.OLT.getCode());
+            baseEntity = new OLTEntity();
+            baseEntity.setParentId(0L);
+        } else if (StrUtil.endWith(name, "分拣中心")) {
+//            二级转运中心
+            iService = OrganServiceFactory.getBean(OrganTypeEnum.TLT.getCode());
+            baseEntity = new TLTEntity();
+            baseEntity.setParentId(parentId);
+        } else if (StrUtil.endWith(name, "营业部")) {
+//            网点
+            iService = OrganServiceFactory.getBean(OrganTypeEnum.AGENCY.getCode());
+            baseEntity = new AgencyEntity();
+            baseEntity.setParentId(parentId);
+        } else {
+            return;
+        }
+
+        baseEntity.setBid(content.getLong("id"));
+        baseEntity.setName(name);
+        baseEntity.setStatus(content.getBool("status"));
+
+
+        switch (operation) {
+            case "ADD": {
+                iService.create(baseEntity);
+                break;
+            }
+            case "UPDATE":{
+                iService.update(baseEntity);
+                break;
+            }
+            case "DEL":{
+                iService.deleteByBid(baseEntity.getBid());
+                break;
+            }
+        }
+    }
+
+
+}
+package com.sl.transport.repository.impl;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.collection.ListUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import com.sl.transport.common.util.BeanUtil;
+import com.sl.transport.domain.OrganDTO;
+import com.sl.transport.enums.OrganTypeEnum;
+import com.sl.transport.repository.OrganRepository;
+import jdk.jfr.Registered;
+import org.neo4j.driver.internal.InternalPoint2D;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.neo4j.core.Neo4jClient;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Map;
+
+@Repository
+public class OrganRepositoryImpl implements OrganRepository {
+
+    @Autowired
+    private Neo4jClient neo4jClient;
+
+    @Override
+    public OrganDTO findByBid(Long bid) {
+        String cypherQuery = StrUtil.format("MATCH (n)\n" +
+                "WHERE n.bid = {}\n" +
+                "RETURN n", bid);
+        return CollUtil.getFirst(executeQuery(cypherQuery));
+    }
+
+    @Override
+    public List<OrganDTO> findByBids(List<Long> bids) {
+        String cypherQuery = StrUtil.format("MATCH (n)\n" +
+                "WHERE n.bid in {}\n" +
+                "RETURN n", bids);
+        return executeQuery(cypherQuery);
+    }
+
+    @Override
+    public List<OrganDTO> findAll(String name) {
+        name = StrUtil.removeAll(name, '\'', '"');
+        String cypherQuery = StrUtil.isEmpty(name) ?
+                "MATCH (n) RETURN n" :
+                StrUtil.format("MATCH (n) WHERE n.name CONTAINS '{}' RETURN n", name);
+        return executeQuery(cypherQuery);
+    }
+
+    private List<OrganDTO> executeQuery(String cypherQuery) {
+        return ListUtil.toList(this.neo4jClient.query(cypherQuery)
+                        .fetchAs(OrganDTO.class)
+                        .mappedBy(((typeSystem, record) -> {
+                            Map<String, Object> map = record.get("n").asMap();
+                            OrganDTO organDTO = BeanUtil.toBean(map, OrganDTO.class);
+                            InternalPoint2D location = (InternalPoint2D) map.get("location");
+                            if (ObjectUtil.isNotEmpty(location)) {
+                                organDTO.setLongitude(location.x());
+                                organDTO.setLatitude(location.y());
+                            }
+
+//                    获取类型
+                            String type = CollUtil.getFirst(record.get("n").asNode().labels());
+                            organDTO.setType(OrganTypeEnum.valueOf(type).getCode());
+                            return organDTO;
+                        })).all()
+        );
+    }
+}
+package com.sl.transport.repository.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.collection.ListUtil;
+import cn.hutool.core.convert.Convert;
+import cn.hutool.core.map.MapUtil;
+import cn.hutool.core.util.PageUtil;
+import cn.hutool.core.util.StrUtil;
+import com.sl.transport.common.util.PageResponse;
+import com.sl.transport.domain.TransportLineNodeDTO;
+import com.sl.transport.domain.TransportLineSearchDTO;
+import com.sl.transport.entity.line.TransportLine;
+import com.sl.transport.entity.node.AgencyEntity;
+import com.sl.transport.entity.node.BaseEntity;
+import com.sl.transport.repository.TransportLineRepository;
+import com.sl.transport.utils.TransportLineUtils;
+import org.neo4j.driver.internal.value.PathValue;
+import org.neo4j.driver.types.Relationship;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.neo4j.core.Neo4jClient;
+import org.springframework.stereotype.Repository;
+import org.neo4j.driver.Record;
+import org.springframework.data.neo4j.core.schema.Node;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * 对于路线的各种操作
+ */
+@Repository
+public class TransportLineRepositoryImpl implements TransportLineRepository {
+
+    @Autowired
+    private Neo4jClient neo4jClient;
+
+    @Override
+    public TransportLineNodeDTO findShortestPath(AgencyEntity start, AgencyEntity end) {
+        return this.findShortestPath(start, end, 10);
+    }
+
+    @Override
+    public TransportLineNodeDTO findShortestPath(AgencyEntity start, AgencyEntity end, int depth) {
+        //获取网点数据在Neo4j中的类型
+        String type = AgencyEntity.class.getAnnotation(Node.class).value()[0];
+        //构造查询语句
+        String cypherQuery = StrUtil.format(
+                "MATCH path = shortestPath((start:{}) -[*..{}]-> (end:{}))\n" +
+                        "WHERE start.bid = $startId AND end.bid = $endId AND start.status = true AND end.status = true\n" +
+                        "RETURN path", type, depth, type);
+        Collection<TransportLineNodeDTO> transportLineNodeDTOS = this.executeQueryPath(cypherQuery, start, end);
+        if (CollUtil.isEmpty(transportLineNodeDTOS)) {
+            return null;
+        }
+        for (TransportLineNodeDTO transportLineNodeDTO : transportLineNodeDTOS) {
+            return transportLineNodeDTO;
+        }
+        return null;
+    }
+
+    private List<TransportLineNodeDTO> executeQueryPath(String cypherQuery, AgencyEntity start, AgencyEntity end) {
+        return ListUtil.toList(this.neo4jClient.query(cypherQuery)
+                .bind(start.getBid()).to("startId") //设置参数
+                .bind(end.getBid()).to("endId") //设置参数
+                .fetchAs(TransportLineNodeDTO.class) //设置响应的类型
+                .mappedBy((typeSystem, record) -> { //对结果进行封装处理
+                    PathValue pathValue = (PathValue) record.get(0);
+                    return TransportLineUtils.convert(pathValue);
+                }).all());
+    }
+
+    @Override
+    public List<TransportLineNodeDTO> findPathList(AgencyEntity start, AgencyEntity end, int depth, int limit) {
+        //获取网点数据在Neo4j中的类型
+        String type = AgencyEntity.class.getAnnotation(Node.class).value()[0];
+        //构造查询语句
+        String cypherQuery = StrUtil.format(
+                "MATCH path = (start:{}) -[*..{}]-> (end:{})\n" +
+                        "WHERE start.bid = $startId AND end.bid = $endId AND start.status = true AND end.status = true\n" +
+                        "UNWIND relationships(path) AS r\n" +
+                        "WITH sum(r.cost) AS cost, path\n" +
+                        "RETURN path ORDER BY cost ASC, LENGTH(path) ASC LIMIT {}", type, depth, type, limit);
+        return this.executeQueryPath(cypherQuery, start, end);
+    }
+
+    @Override
+    public Long queryCount(BaseEntity firstNode, BaseEntity secondNode) {
+        String firstNodeType = firstNode.getClass().getAnnotation(Node.class).value()[0];
+        String secondNodeType = secondNode.getClass().getAnnotation(Node.class).value()[0];
+        String cypherQuery = StrUtil.format(
+                "MATCH (m:{}) -[r]- (n:{})\n" +
+                        "WHERE m.bid = $firstBid AND n.bid = $secondBid\n" +
+                        "RETURN count(r) AS c", firstNodeType, secondNodeType);
+        Optional<Long> optional = this.neo4jClient.query(cypherQuery)
+                .bind(firstNode.getBid()).to("firstBid")
+                .bind(secondNode.getBid()).to("secondBid")
+                .fetchAs(Long.class)
+                .mappedBy((typeSystem, record) -> Convert.toLong(record.get("c")))
+                .one();
+        return optional.orElse(0L);
+    }
+
+    @Override
+    public Long create(BaseEntity firstNode, BaseEntity secondNode, TransportLine transportLine) {
+        String firstNodeType = firstNode.getClass().getAnnotation(Node.class).value()[0];
+        String secondNodeType = secondNode.getClass().getAnnotation(Node.class).value()[0];
+        String cypherQuery = StrUtil.format(
+                "MATCH (m:{} {bid : $firstBid})\n" +
+                        "WITH m\n" +
+                        "MATCH (n:{} {bid : $secondBid})\n" +
+                        "WITH m,n\n" +
+                        "CREATE\n" +
+                        " (m) -[r:IN_LINE {cost:$cost, number:$number, type:$type, name:$name, distance:$distance, time:$time, extra:$extra, startOrganId:$startOrganId, endOrganId:$endOrganId,created:$created, updated:$updated}]-> (n),\n" +
+                        " (m) <-[:OUT_LINE {cost:$cost, number:$number, type:$type, name:$name, distance:$distance, time:$time, extra:$extra, startOrganId:$endOrganId, endOrganId:$startOrganId, created:$created, updated:$updated}]- (n)\n" +
+                        "RETURN count(r) AS c", firstNodeType, secondNodeType);
+        Optional<Long> optional = this.neo4jClient.query(cypherQuery)
+                .bindAll(BeanUtil.beanToMap(transportLine))
+                .bind(firstNode.getBid()).to("firstBid")
+                .bind(secondNode.getBid()).to("secondBid")
+                .fetchAs(Long.class)
+                .mappedBy((typeSystem, record) -> Convert.toLong(record.get("c")))
+                .one();
+        return optional.orElse(0L);
+    }
+
+    @Override
+    public Long update(TransportLine transportLine) {
+        String cypherQuery = "MATCH () -[r]-> ()\n" +
+                "WHERE id(r) = $id\n" +
+                "SET r.cost = $cost , r.number = $number, r.name = $name ,r.distance = $distance ,r.time = $time, r.startOrganId = $startOrganId, r.endOrganId = $endOrganId, r.updated = $updated , r.extra = $extra \n" +
+                "RETURN count(r) AS c";
+        Optional<Long> optional = this.neo4jClient.query(cypherQuery)
+                .bindAll(BeanUtil.beanToMap(transportLine))
+                .fetchAs(Long.class)
+                .mappedBy((typeSystem, record) -> Convert.toLong(record.get("c")))
+                .one();
+        return optional.orElse(0L);
+    }
+
+    @Override
+    public Long remove(Long lineId) {
+        String cypherQuery = "MATCH () -[r]-> ()\n" +
+                "WHERE id(r) = $lineId\n" +
+                "DETACH DELETE r\n" +
+                "RETURN count(r) AS c";
+        Optional<Long> optional = this.neo4jClient.query(cypherQuery)
+                .bind(lineId).to("lineId")
+                .fetchAs(Long.class)
+                .mappedBy((typeSystem, record) -> Convert.toLong(record.get("c")))
+                .one();
+        return optional.orElse(0L);
+    }
+
+    @Override
+    public PageResponse<TransportLine> queryPageList(TransportLineSearchDTO transportLineSearchDTO) {
+        int page = Math.max(transportLineSearchDTO.getPage(), 1);
+        int pageSize = transportLineSearchDTO.getPageSize();
+        int skip = (page - 1) * pageSize;
+        Map<String, Object> searchParam = BeanUtil.beanToMap(transportLineSearchDTO, false, true);
+        MapUtil.removeAny(searchParam, "page", "pageSize");        //构建查询语句，第一个是查询数据，第二个是查询数量
+        String[] cyphers = this.buildPageQueryCypher(searchParam);
+        String cypherQuery = cyphers[0];
+
+        //数据
+        List<TransportLine> list = ListUtil.toList(this.neo4jClient.query(cypherQuery)
+                .bind(skip).to("skip")
+                .bind(pageSize).to("limit")
+                .bindAll(searchParam)
+                .fetchAs(TransportLine.class)
+                .mappedBy((typeSystem, record) -> {
+                    //封装数据
+                    return this.toTransportLine(record);
+                }).all());
+
+        // 数据总数
+        String countCypher = cyphers[1];
+        Long total = this.neo4jClient.query(countCypher)
+                .bindAll(searchParam)
+                .fetchAs(Long.class)
+                .mappedBy((typeSystem, record) -> Convert.toLong(record.get("c")))
+                .one().orElse(0L);
+
+        PageResponse<TransportLine> pageResponse = new PageResponse<>();
+        pageResponse.setPage(page);
+        pageResponse.setPageSize(pageSize);
+        pageResponse.setItems(list);
+        pageResponse.setCounts(total);
+        Long pages = Convert.toLong(PageUtil.totalPage(Convert.toInt(total), pageSize));
+        pageResponse.setPages(pages);
+
+        return pageResponse;
+    }
+
+    private String[] buildPageQueryCypher(Map<String, Object> searchParam) {
+        String queryCypher;
+        String countCypher;
+        if (CollUtil.isEmpty(searchParam)) {
+            //无参数
+            queryCypher = "MATCH (m) -[r]-> (n) RETURN m,r,n ORDER BY id(r) DESC SKIP $skip LIMIT $limit";
+            countCypher = "MATCH () -[r]-> () RETURN count(r) AS c";
+        } else {
+            //有参数
+            String cypherPrefix = "MATCH (m) -[r]-> (n)";
+            StringBuilder sb = new StringBuilder();
+            sb.append(cypherPrefix).append(" WHERE 1=1 ");
+            for (String key : searchParam.keySet()) {
+                Object value = searchParam.get(key);
+                if (value instanceof String) {
+                    if (StrUtil.isNotBlank(Convert.toStr(value))) {
+                        sb.append(StrUtil.format("AND r.{} CONTAINS ${} \n", key, key));
+                    }
+                } else {
+                    sb.append(StrUtil.format("AND r.{} = ${} \n", key, key));
+                }
+            }
+            String cypher = sb.toString();
+            queryCypher = cypher + "RETURN m,r,n ORDER BY id(r) DESC SKIP $skip LIMIT $limit";
+            countCypher = cypher + "RETURN count(r) AS c";
+        }
+        return new String[]{queryCypher, countCypher};
+    }
+
+    @Override
+    public List<TransportLine> queryByIds(Long... ids) {
+        String cypherQuery = "MATCH (m) -[r]-> (n)\n" +
+                "WHERE id(r) in $ids\n" +
+                "RETURN m,r,n";
+        return ListUtil.toList(this.neo4jClient.query(cypherQuery)
+                .bind(ids).to("ids")
+                .fetchAs(TransportLine.class)
+                .mappedBy((typeSystem, record) -> {
+                    //封装数据
+                    return this.toTransportLine(record);
+                }).all());
+    }
+
+    private TransportLine toTransportLine(Record record) {
+        org.neo4j.driver.types.Node startNode = record.get("m").asNode();
+        org.neo4j.driver.types.Node endNode = record.get("n").asNode();
+        Relationship relationship = record.get("r").asRelationship();
+        Map<String, Object> map = relationship.asMap();
+
+        TransportLine transportLine = BeanUtil.toBeanIgnoreError(map, TransportLine.class);
+        transportLine.setStartOrganName(startNode.get("name").asString());
+        transportLine.setStartOrganId(startNode.get("bid").asLong());
+        transportLine.setEndOrganName(endNode.get("name").asString());
+        transportLine.setEndOrganId(endNode.get("bid").asLong());
+        transportLine.setId(relationship.id());
+        return transportLine;
+    }
+
+
+    @Override
+    public TransportLine queryById(Long id) {
+        List<TransportLine> transportLines = this.queryByIds(id);
+        if (CollUtil.isNotEmpty(transportLines)) {
+            return transportLines.get(0);
+        }
+        return null;
+    }
+}
+package com.sl.transport.service.impl;
+
+import com.sl.transport.entity.node.AgencyEntity;
+import com.sl.transport.repository.AgencyRepository;
+import com.sl.transport.service.AgencyService;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AgencyServiceImpl extends ServiceImpl<AgencyRepository, AgencyEntity> implements AgencyService {
+}
@@ -23,23 +23,23 @@ import java.util.stream.Collectors;
  */
 @Service
 public class CostConfigurationServiceImpl implements CostConfigurationService {
-
-    @Resource
-    private StringRedisTemplate stringRedisTemplate;
-
     /**
      * 成本配置 redis key
      */
-    static final String SL_TRANSPORT_COST_REDIS_KEY = "SL_TRANSPORT_COST_CONFIGURATION";
+    private static final String SL_TRANSPORT_COST_REDIS_KEY = "SL_TRANSPORT_COST_CONFIGURATION";
  
     /**
      * 默认成本配置
      */
-    static final Map<Object, Object> DEFAULT_COST = Map.of(
+    private static final Map<Object, Object> DEFAULT_COST = Map.of(
             TransportLineEnum.TRUNK_LINE.getCode(), 0.8,
             TransportLineEnum.BRANCH_LINE.getCode(), 1.2,
             TransportLineEnum.CONNECT_LINE.getCode(), 1.5);
  
+    @Resource
+    private StringRedisTemplate stringRedisTemplate;
+
+
     /**
      * 查询成本配置
      *
+package com.sl.transport.service.impl;
+
+import com.sl.transport.entity.node.OLTEntity;
+import com.sl.transport.repository.OLTRepository;
+import com.sl.transport.service.OLTService;
+import org.springframework.stereotype.Service;
+
+@Service
+public class OLTServiceImpl extends ServiceImpl<OLTRepository, OLTEntity> implements OLTService {
+}
+package com.sl.transport.service.impl;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.lang.tree.Tree;
+import cn.hutool.core.lang.tree.TreeUtil;
+import cn.hutool.core.util.ObjectUtil;
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.sl.transport.common.exception.SLException;
+import com.sl.transport.common.util.BeanUtil;
+import com.sl.transport.domain.OrganDTO;
+import com.sl.transport.enums.ExceptionEnum;
+import com.sl.transport.repository.OrganRepository;
+import com.sl.transport.service.OrganService;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class OrganServiceImpl implements OrganService {
+
+    @Autowired
+    private OrganRepository organRepository;
+
+    @Autowired
+    private ObjectMapper objectMapper;
+
+    @Override
+    public OrganDTO findByBid(Long bid) {
+        OrganDTO organDTO = this.organRepository.findByBid(bid);
+        if (ObjectUtil.isNotEmpty(organDTO)) {
+            return organDTO;
+        }
+        throw new SLException(ExceptionEnum.ORGAN_NOT_FOUND);
+    }
+
+    @Override
+    public List<OrganDTO> findByBids(List<Long> bids) {
+        List<OrganDTO> organDTOS = this.organRepository.findByBids(bids);
+        if (ObjectUtil.isNotEmpty(organDTOS)) {
+            return organDTOS;
+        }
+        throw new SLException(ExceptionEnum.ORGAN_NOT_FOUND);
+    }
+
+    @Override
+    public List<OrganDTO> findAll(String name) {
+        return this.organRepository.findAll(name);
+    }
+
+    @Override
+    public String findAllTree() {
+        List<OrganDTO> organList = this.findAll(null);
+        if (CollUtil.isEmpty(organList)) {
+            return "";
+        }
+
+//        构造树结构
+        List<Tree<Long>> treeNodes = TreeUtil.build(organList, 0L,
+                ((organDTO, tree) -> {
+                    tree.setId(organDTO.getId());
+                    tree.setParentId(organDTO.getParentId());
+                    tree.putAll(BeanUtil.beanToMap(organDTO));
+                    tree.remove("bid");
+                }));
+
+        try {
+            return this.objectMapper.writeValueAsString(treeNodes);
+        } catch (JsonProcessingException e) {
+            throw new SLException("序列化JSON出错！", e);
+        }
+
+    }
+}
+package com.sl.transport.service.impl;
+
+import com.sl.transport.entity.node.BaseEntity;
+import com.sl.transport.repository.BaseRepository;
+import com.sl.transport.service.IService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+/**
+ * 基础服务的实现
+ * @param <R>
+ * @param <T>
+ */
+public class ServiceImpl<R extends BaseRepository,T extends BaseEntity> implements IService<T> {
+
+    @Autowired
+    private R repository;
+
+    @Override
+    public T queryByBid(Long bid) {
+        return (T) this.repository.findByBid(bid).orElse(null);
+    }
+
+    @Override
+    public T create(T t) {
+        return (T) this.repository.save(t);
+    }
+
+    @Override
+    public T update(T t) {
+//        id由neo4j自动生成
+        t.setId(null);
+        return (T) this.repository.save(t);
+    }
+
+    @Override
+    public Boolean deleteByBid(Long bid) {
+        return this.repository.deleteByBid(bid) > 0;
+    }
+}
+package com.sl.transport.service.impl;
+
+import com.sl.transport.entity.node.TLTEntity;
+import com.sl.transport.repository.TLTRepository;
+import com.sl.transport.service.TLTService;
+import org.springframework.stereotype.Service;
+
+@Service
+public class TLTServiceImpl extends ServiceImpl<TLTRepository, TLTEntity> implements TLTService {
+}
+package com.sl.transport.service.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.bean.copier.CopyOptions;
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.convert.Convert;
+import cn.hutool.core.map.MapUtil;
+import cn.hutool.core.util.NumberUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
+import com.itheima.em.sdk.EagleMapTemplate;
+import com.itheima.em.sdk.enums.ProviderEnum;
+import com.itheima.em.sdk.vo.Coordinate;
+import com.sl.transport.common.exception.SLException;
+import com.sl.transport.common.util.PageResponse;
+import com.sl.transport.domain.DispatchConfigurationDTO;
+import com.sl.transport.domain.OrganDTO;
+import com.sl.transport.domain.TransportLineNodeDTO;
+import com.sl.transport.domain.TransportLineSearchDTO;
+import com.sl.transport.entity.line.TransportLine;
+import com.sl.transport.entity.node.AgencyEntity;
+import com.sl.transport.entity.node.BaseEntity;
+import com.sl.transport.entity.node.OLTEntity;
+import com.sl.transport.entity.node.TLTEntity;
+import com.sl.transport.enums.DispatchMethodEnum;
+import com.sl.transport.enums.ExceptionEnum;
+import com.sl.transport.enums.TransportLineEnum;
+import com.sl.transport.repository.TransportLineRepository;
+import com.sl.transport.service.CostConfigurationService;
+import com.sl.transport.service.DispatchConfigurationService;
+import com.sl.transport.service.OrganService;
+import com.sl.transport.service.TransportLineService;
+import org.checkerframework.checker.units.qual.A;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.neo4j.core.Neo4jClient;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.Map;
+
+@Service
+public class TransportLineServiceImpl implements TransportLineService {
+
+    @Autowired
+    private TransportLineRepository transportLineRepository;
+
+    @Autowired
+    private EagleMapTemplate eagleMapTemplate;
+
+    @Autowired
+    private OrganService organService;
+
+    @Autowired
+    private DispatchConfigurationService dispatchConfigurationService;
+
+    @Autowired
+    private CostConfigurationService costConfigurationService;
+
+    @Override
+    public Boolean createLine(TransportLine transportLine) {
+        TransportLineEnum transportLineEnum = TransportLineEnum.codeOf(transportLine.getType());
+        if (null == transportLineEnum) {
+            throw new SLException(ExceptionEnum.TRANSPORT_LINE_TYPE_ERROR);
+        }
+
+        if (ObjectUtil.equal(transportLine.getStartOrganId(), transportLine.getEndOrganId())) {
+            //起点终点不能相同
+            throw new SLException(ExceptionEnum.TRANSPORT_LINE_ORGAN_CANNOT_SAME);
+        }
+
+        BaseEntity firstNode;
+        BaseEntity secondNode;
+        switch (transportLineEnum) {
+            case TRUNK_LINE: {
+                // 干线
+                firstNode = OLTEntity.builder().bid(transportLine.getStartOrganId()).build();
+                secondNode = OLTEntity.builder().bid(transportLine.getEndOrganId()).build();
+                break;
+            }
+            case BRANCH_LINE: {
+                // 支线，起点必须是 二级转运中心
+                firstNode = TLTEntity.builder().bid(transportLine.getStartOrganId()).build();
+                secondNode = OLTEntity.builder().bid(transportLine.getEndOrganId()).build();
+                break;
+            }
+            case CONNECT_LINE: {
+                // 接驳路线，起点必须是 网点
+                firstNode = AgencyEntity.builder().bid(transportLine.getStartOrganId()).build();
+                secondNode = TLTEntity.builder().bid(transportLine.getEndOrganId()).build();
+                break;
+            }
+            default: {
+                throw new SLException(ExceptionEnum.TRANSPORT_LINE_TYPE_ERROR);
+            }
+        }
+
+        if (ObjectUtil.hasEmpty(firstNode, secondNode)) {
+            throw new SLException(ExceptionEnum.START_END_ORGAN_NOT_FOUND);
+        }
+
+        //判断路线是否已经存在
+        Long count = this.transportLineRepository.queryCount(firstNode, secondNode);
+        if (count > 0) {
+            throw new SLException(ExceptionEnum.TRANSPORT_LINE_ALREADY_EXISTS);
+        }
+
+        transportLine.setId(null);
+        transportLine.setCreated(System.currentTimeMillis());
+        transportLine.setUpdated(transportLine.getCreated());
+        //补充信息
+        this.infoFromMap(firstNode, secondNode, transportLine);
+
+        count = this.transportLineRepository.create(firstNode, secondNode, transportLine);
+        return count > 0;
+    }
+
+    /**
+     * 通过地图查询距离、时间，计算成本
+     *
+     * @param firstNode     开始节点
+     * @param secondNode    结束节点
+     * @param transportLine 路线对象
+     */
+    private void infoFromMap(BaseEntity firstNode, BaseEntity secondNode, TransportLine transportLine) {
+        //查询节点数据
+        OrganDTO startOrgan = this.organService.findByBid(firstNode.getBid());
+        if (ObjectUtil.hasEmpty(startOrgan, startOrgan.getLongitude(), startOrgan.getLatitude())) {
+            throw new SLException("请先完善机构信息");
+        }
+        OrganDTO endOrgan = this.organService.findByBid(secondNode.getBid());
+        if (ObjectUtil.hasEmpty(endOrgan, endOrgan.getLongitude(), endOrgan.getLatitude())) {
+            throw new SLException("请先完善机构信息");
+        }
+
+        //查询地图服务商
+        Coordinate origin = new Coordinate(startOrgan.getLongitude(), startOrgan.getLatitude());
+        Coordinate destination = new Coordinate(endOrgan.getLongitude(), endOrgan.getLatitude());
+        //设置高德地图参数，默认是不返回预计耗时的，需要额外设置参数
+        Map<String, Object> param = MapUtil.<String, Object>builder().put("show_fields", "cost").build();
+        String driving = this.eagleMapTemplate.opsForDirection().driving(ProviderEnum.AMAP, origin, destination, param);
+        if (StrUtil.isEmpty(driving)) {
+            return;
+        }
+        JSONObject jsonObject = JSONUtil.parseObj(driving);
+        //时间，单位：秒
+        Long duration = Convert.toLong(jsonObject.getByPath("route.paths[0].cost.duration"), -1L);
+        transportLine.setTime(duration);
+        //距离，单位：米
+        Double distance = Convert.toDouble(jsonObject.getByPath("route.paths[0].distance"), -1d);
+        transportLine.setDistance(NumberUtil.round(distance, 0).doubleValue());
+
+        // 总成本 = 每公里平均成本 * 距离（单位：米） / 1000
+        Double cost = costConfigurationService.findCostByType(transportLine.getType());
+        transportLine.setCost(NumberUtil.round(cost * distance / 1000, 2).doubleValue());
+    }
+
+    @Override
+    public Boolean updateLine(TransportLine transportLine) {
+        // 先查后改
+        TransportLine transportLineData = this.queryById(transportLine.getId());
+        if (null == transportLineData) {
+            throw new SLException(ExceptionEnum.TRANSPORT_LINE_NOT_FOUND);
+        }
+
+        //拷贝数据，忽略null值以及不能修改的字段
+        BeanUtil.copyProperties(transportLine, transportLineData, CopyOptions.create().setIgnoreNullValue(true)
+                .setIgnoreProperties("type", "startOrganId", "startOrganName", "endOrganId", "endOrganName"));
+
+        transportLineData.setUpdated(System.currentTimeMillis());
+        Long count = this.transportLineRepository.update(transportLineData);
+        return count > 0;
+    }
+
+    @Override
+    public Boolean deleteLine(Long id) {
+        Long count = this.transportLineRepository.remove(id);
+        return count > 0;
+    }
+
+    @Override
+    public PageResponse<TransportLine> queryPageList(TransportLineSearchDTO transportLineSearchDTO) {
+        return this.transportLineRepository.queryPageList(transportLineSearchDTO);
+    }
+
+    @Override
+    public TransportLineNodeDTO queryShortestPath(Long startId, Long endId) {
+        AgencyEntity start = AgencyEntity.builder().bid(startId).build();
+        AgencyEntity end = AgencyEntity.builder().bid(endId).build();
+        if (ObjectUtil.hasEmpty(start, end)) {
+            throw new SLException(ExceptionEnum.START_END_ORGAN_NOT_FOUND);
+        }
+        return this.transportLineRepository.findShortestPath(start, end);
+    }
+
+    @Override
+    public TransportLineNodeDTO findLowestPath(Long startId, Long endId) {
+        AgencyEntity start = AgencyEntity.builder().bid(startId).build();
+        AgencyEntity end = AgencyEntity.builder().bid(endId).build();
+
+        if (ObjectUtil.hasEmpty(start, end)) {
+            throw new SLException(ExceptionEnum.START_END_ORGAN_NOT_FOUND);
+        }
+
+        List<TransportLineNodeDTO> pathList = this.transportLineRepository.findPathList(start, end, 10, 1);
+        if (CollUtil.isNotEmpty(pathList)) {
+            return pathList.get(0);
+        }
+        return null;
+    }
+
+    @Override
+    public TransportLineNodeDTO queryPathByDispatchMethod(Long startId, Long endId) {
+        //调度方式配置
+        DispatchConfigurationDTO configuration = this.dispatchConfigurationService.findConfiguration();
+        int method = configuration.getDispatchMethod();
+
+        //调度方式，1转运次数最少，2成本最低
+        if (ObjectUtil.equal(DispatchMethodEnum.SHORTEST_PATH.getCode(), method)) {
+            return this.queryShortestPath(startId, endId);
+        } else {
+            return this.findLowestPath(startId, endId);
+        }
+    }
+
+    @Override
+    public List<TransportLine> queryByIds(Long... ids) {
+        return this.transportLineRepository.queryByIds(ids);
+    }
+
+    @Override
+    public TransportLine queryById(Long id) {
+        return this.transportLineRepository.queryById(id);
+    }
+}