cql通用增加、修改、删除、查询

cql-service/src/main/java/cn/com/taiji/cql/service/IECqlService.java

@@ -4,14 +4,60 @@ package cn.com.taiji.cql.service;
 import cn.com.taiji.common.domain.PageResult;
 import cn.com.taiji.common.domain.Result;
 import org.geotools.api.feature.FeatureVisitor;
-
 import java.util.List;
 import java.util.Map;
 
 public interface IECqlService {
 
 
+    /**
+     * cql 通用查询接口
+     * @param mapParams
+     * @param cql
+     * @return
+     */
     PageResult cqlQuery4Mysql(Map<String, Object> mapParams, String cql, Map<String,Object> sortMaps, Map<String, Object> pageParams);
 
+
+
+    /**
+     * cql 通用查询接口
+     * @param dsParams
+     * @param paramMaps
+     * @return
+     */
+    PageResult cqlQuery(Map<String, Object> dsParams,Map<String,Object> paramMaps);
+
+    /**
+     * cql 通用增加接口
+     * @param dsParams
+     * @param attributeMap
+     * @return
+     */
+
+    Result cqlAdd(Map<String, Object> dsParams, Map<String, Object> attributeMap);
+
+    /**
+     * cql 通用修改接口
+     * @param dsParams
+     * @param attributeMap
+     * @return
+     */
+
+    Result cqlUpdate(Map<String, Object> dsParams, Map<String, Object> attributeMap,String cql);
+
+    /**
+     * cql 通用删除接口
+     * @param dsParams
+     * @param cql
+     * @return
+     */
+
+    Result cqlRemove(Map<String, Object> dsParams,String cql);
+
+
+
     void cqlAggQuery4Mysql(Map<String, Object> mapParams, String cql, FeatureVisitor visitor);
+
+
 }

cql-service/src/main/java/cn/com/taiji/cql/service/impl/ECqlServiceImpl.java

@@ -2,20 +2,23 @@ package cn.com.taiji.cql.service.impl;
 import cn.com.taiji.common.domain.PageResult;
 import cn.com.taiji.common.domain.Result;
 import cn.com.taiji.common.enums.CommonConstant;
+import cn.com.taiji.common.util.IdGenerator;
 import cn.com.taiji.cql.service.IECqlService;
+import com.alibaba.fastjson.JSONObject;
 import lombok.extern.slf4j.Slf4j;
-import org.geotools.api.data.DataStore;
-import org.geotools.api.data.DataStoreFinder;
-import org.geotools.api.data.Query;
-import org.geotools.api.data.SimpleFeatureSource;
+import org.geotools.api.data.*;
 import org.geotools.api.feature.FeatureVisitor;
 import org.geotools.api.feature.simple.SimpleFeature;
 import org.geotools.api.feature.type.AttributeDescriptor;
 import org.geotools.api.filter.Filter;
+import org.geotools.api.filter.identity.FeatureId;
 import org.geotools.api.filter.sort.SortBy;
 import org.geotools.api.filter.sort.SortOrder;
+import org.geotools.data.collection.ListFeatureCollection;
 import org.geotools.data.simple.SimpleFeatureCollection;
 import org.geotools.data.simple.SimpleFeatureIterator;
+import org.geotools.data.store.ContentFeatureSource;
+import org.geotools.feature.simple.SimpleFeatureBuilder;
 import org.geotools.filter.FilterFactoryImpl;
 import org.geotools.filter.SortByImpl;
 import org.geotools.filter.text.ecql.ECQL;
@@ -231,6 +234,438 @@ public class ECqlServiceImpl implements IECqlService{
 
     }
 
+    /**
+     * cql 通用查询接口
+     * @param dsParams
+     * @param paramMaps
+     * @return
+     */
+    @Override
+    public PageResult cqlQuery(Map<String, Object> dsParams,Map<String,Object> paramMaps) {
+
+        List<Map<String, Object>> dataList = new ArrayList<Map<String, Object>>();
+
+        DataStore dataStore = null;
+
+        String host = dsParams.get(JDBCDataStoreFactory.HOST.key).toString();
+
+        String database = dsParams.get(JDBCDataStoreFactory.DATABASE.key).toString();
+
+        //查询记录总数
+        Long count =0l;
+
+        //当前页数
+        Long pageNumber= CommonConstant.PAGE_NUMBER;
+
+        //一页显示多少条记录
+        Long pageSize=CommonConstant.PAGE_SIZE;
+
+        //总页数
+        Long pageCount =0l;
+
+
+        try {
+
+            dataStore = DataStoreFinder.getDataStore(dsParams);
+
+            if (dataStore != null) {
+
+                log.info("系统连接到位于：" + host + "的空间数据库" + database + "成功！");
+
+                //根据表名获取source
+                SimpleFeatureSource fSource=dataStore.getFeatureSource(dsParams.get("tableName").toString());
+
+
+                FilterFactoryImpl filterFactory = new FilterFactoryImpl();
+
+                //组转cql查询条件
+                Query query = new Query();
+
+                if(paramMaps.containsKey("cql")) {
+
+                    String cql = paramMaps.get("cql").toString();
+
+                    if(cql !=null && !"".equals(cql)){
+
+                        Filter filter = ECQL.toFilter(cql);
+
+                        query.setFilter(filter);
+
+                    }
+                }
+
+                //组装排序参数
+                if(paramMaps.containsKey("sort")){
+
+                    List<SortByImpl> sortByList = new ArrayList<SortByImpl>();
+
+                    JSONObject sortJSONObject = JSONObject.parseObject(paramMaps.get("sort").toString());
+
+                    for(String sortKey : sortJSONObject.keySet()) {
+
+                        Object sortValue = sortJSONObject.get(sortKey);
+
+                        if("asc".equals(sortValue.toString().toLowerCase())){
+
+                            SortByImpl sb = new SortByImpl(filterFactory.property(sortKey),SortOrder.ASCENDING);
+
+                            sortByList.add(sb);
+                        }else{
+
+                            SortByImpl sb = new SortByImpl(filterFactory.property(sortKey),SortOrder.DESCENDING);
+
+                            sortByList.add(sb);
+
+                        }
+
+                    }
+
+                    query.setSortBy(sortByList.toArray(new SortBy[sortByList.size()]));
+
+                }
+
+
+                //组装分页参数
+                if(paramMaps.containsKey("pageSize") && paramMaps.containsKey("pageNumber")){
+
+                    //查询记录总数
+                    count = Long.valueOf(fSource.getCount(query));
+
+                    pageNumber = Long.valueOf(paramMaps.get("pageNumber").toString());
+
+                    pageSize = Long.valueOf(paramMaps.get("pageSize").toString());
+
+                    int startIndex = pageNumber.intValue()-1 <=0?0:pageNumber.intValue()-1;
+
+                    //设置分页查询参数
+                    query.setStartIndex(startIndex*pageSize.intValue());
+
+                    query.setMaxFeatures(pageSize.intValue());
+
+                    //计算总页数
+                    if (count%pageSize ==0){
+
+                        pageCount = count/pageSize;
+
+                    }else{
+
+                        pageCount = count/pageSize +1;
+                    }
+
+                }
+
+
+
+                SimpleFeatureCollection simpleFeatureCollection =fSource.getFeatures(query);
+
+                if(simpleFeatureCollection !=null){
+
+                    // 获取当前矢量数据有哪些属性字段值
+                    List<AttributeDescriptor> attributeList = simpleFeatureCollection.getSchema().getAttributeDescriptors();
+
+
+                    SimpleFeatureIterator simpleFeatureIterator = simpleFeatureCollection.features();
+
+                    while (simpleFeatureIterator.hasNext()){
+                        //获取每一个要素
+                        SimpleFeature simpleFeature = simpleFeatureIterator.next();
+
+                        Map<String, Object> dataMap = new HashMap<String, Object>();
+
+                        String id = simpleFeature.getID();
+                        id = id.substring(id.lastIndexOf(".")+1);
+
+                        dataMap.put("id",id);
+
+                        for(AttributeDescriptor attribute:attributeList){
+
+//                            System.out.println(attribute.getLocalName() + ":" + simpleFeature.getAttribute(attribute.getLocalName()));
+
+                            dataMap.put(attribute.getLocalName(),simpleFeature.getAttribute(attribute.getLocalName()));
+
+                        }
+
+                        dataList.add(dataMap);
+
+
+                    }
+
+                    simpleFeatureIterator.close();
+
+
+                }
+
+                if(!paramMaps.containsKey("pageSize") && !paramMaps.containsKey("pageNumber")){
+
+                    count = Long.valueOf(dataList.size());
+
+                }
+
+            } else {
+
+                log.info("系统连接到位于：" + host + "的空间数据库" + database + "失败！请检查相关参数");
+
+            }
+
+        }catch (Exception e) {
+
+            e.printStackTrace();
+            log.error("系统连接到位于：" + dsParams.get(JDBCDataStoreFactory.HOST.key) + "的空间数据库" + dsParams.get(JDBCDataStoreFactory.DATABASE.key) + "失败！请检查相关参数");
+
+        }finally {
+
+            if(dataStore !=null){
+
+                dataStore.dispose();
+
+            }
+        }
+
+        int respCode = 0;
+
+        String respMsg = "操作成功";
+
+        if(count == 0){
+
+            respCode = 1;
+            respMsg = "操作成功,但没有查找到记录!";
+
+        }
+
+        return PageResult.<List<Map<String, Object>>>builder().datas(dataList).resp_code(respCode).resp_msg(respMsg).pageSize(pageSize).pageNumber(pageNumber).pageCount(pageCount).recordCount(count).build();
+
+
+    }
+
+
+    /**
+     * cql 通用增加接口
+     * @param mapParams
+     * @param attributeMap
+     * @return
+     */
+
+    @Override
+    public Result cqlAdd(Map<String, Object> mapParams, Map<String, Object> attributeMap) {
+
+        int respCode = 0;
+
+        String respMsg = "操作成功";
+
+        if(attributeMap !=null && attributeMap.keySet().size() >0){
+
+            String host = mapParams.get(JDBCDataStoreFactory.HOST.key).toString();
+
+            String database = mapParams.get(JDBCDataStoreFactory.DATABASE.key).toString();
+
+            DataStore dataStore = null;
+
+            try{
+
+                dataStore = DataStoreFinder.getDataStore(mapParams);
+
+                if (dataStore != null) {
+
+                    log.info("系统连接到位于：" + host + "的空间数据库" + database + "成功！");
+
+                    ContentFeatureSource featureSource = (ContentFeatureSource) dataStore.getFeatureSource(mapParams.get("tableName").toString());
+                    SimpleFeatureStore store = (SimpleFeatureStore)featureSource;
+                    SimpleFeatureBuilder featureBuilder = new SimpleFeatureBuilder(store.getSchema());
+
+                    for (Map.Entry<String, Object> attributeEntry : attributeMap.entrySet()) {
+
+                        featureBuilder.set(attributeEntry.getKey(),attributeEntry.getValue());
+
+                    }
+                    SimpleFeature feature = featureBuilder.buildFeature(IdGenerator.getIdStr());
+                    ListFeatureCollection featureCollection = new ListFeatureCollection(store.getSchema(), List.of(feature));
+                    List<FeatureId> addFeatures = store.addFeatures(featureCollection);
+
+                    return Result.of(addFeatures,respCode,respMsg);
+
+                }else{
+
+                    respCode = -1;
+                    respMsg = "系统连接到位于：" + host + "的空间数据库" + database + "失败！";
+
+                }
+
+
+            }catch (Exception exception) {
+
+                exception.printStackTrace();
+
+                log.error("系统连接到位于：" + mapParams.get(JDBCDataStoreFactory.HOST.key) + "的空间数据库" + mapParams.get(JDBCDataStoreFactory.DATABASE.key) + "失败！请检查相关参数");
+
+                respCode = -1;
+                respMsg = "系统连接到位于：" + mapParams.get(JDBCDataStoreFactory.HOST.key) + "的空间数据库" + mapParams.get(JDBCDataStoreFactory.DATABASE.key) + "失败！请检查相关参数";
+
+            }finally {
+
+                if(dataStore !=null){
+
+                    dataStore.dispose();
+
+                }
+            }
+
+
+        }else{
+
+            respCode = 2;
+            respMsg = "删除数据的过滤条件cql为空或者为null";
+        }
+
+        return Result.of(null,respCode,respMsg);
+    }
+
+
+    /**
+     * cql 通用修改接口
+     * @param mapParams
+     * @param attributeMap
+     * @param cql 过滤条件
+     * @return
+     */
+
+    @Override
+    public Result cqlUpdate(Map<String, Object> mapParams, Map<String, Object> attributeMap, String cql) {
+
+        int respCode = 0;
+
+        String respMsg = "操作成功";
+
+        if(cql !=null && !"".equals(cql)){
+
+            String host = mapParams.get(JDBCDataStoreFactory.HOST.key).toString();
+
+            String database = mapParams.get(JDBCDataStoreFactory.DATABASE.key).toString();
+
+            DataStore dataStore = null;
+
+            try{
+
+                dataStore = DataStoreFinder.getDataStore(mapParams);
+
+                if (dataStore != null) {
+
+                    log.info("系统连接到位于：" + host + "的空间数据库" + database + "成功！");
+
+                    String[] names = attributeMap.keySet().toArray(new String[0]);
+
+                    String[] attributeValues = attributeMap.values().toArray(new String[0]);
+
+                    Filter filter = ECQL.toFilter(cql);
+
+                    ContentFeatureSource featureSource = (ContentFeatureSource) dataStore.getFeatureSource(mapParams.get("tableName").toString());
+                    SimpleFeatureStore store = (SimpleFeatureStore)featureSource;
+                    store.modifyFeatures(names,attributeValues,filter);
+
+                }else{
+
+                    respCode = -1;
+                    respMsg = "系统连接到位于：" + host + "的空间数据库" + database + "失败！";
+
+                }
+
+
+            }catch (Exception e) {
+
+                e.printStackTrace();
+                log.error("系统连接到位于：" + mapParams.get(JDBCDataStoreFactory.HOST.key) + "的空间数据库" + mapParams.get(JDBCDataStoreFactory.DATABASE.key) + "失败！请检查相关参数");
+
+                respCode = -1;
+                respMsg = "系统连接到位于：" + mapParams.get(JDBCDataStoreFactory.HOST.key) + "的空间数据库" + mapParams.get(JDBCDataStoreFactory.DATABASE.key) + "失败！请检查相关参数";
+
+            }finally {
+
+                if(dataStore !=null){
+
+                    dataStore.dispose();
+
+                }
+            }
+
+
+        }else{
+
+            respCode = 2;
+            respMsg = "修改数据的过滤条件cql为空或者为null";
+        }
+
+        return Result.of(null,respCode,respMsg);
+    }
+
+    /**
+     * cql 通用删除接口
+     * @param mapParams
+     * @param cql 过滤条件
+     * @return
+     */
+    @Override
+    public Result cqlRemove(Map<String, Object> mapParams, String cql) {
+
+        int respCode = 0;
+
+        String respMsg = "操作成功";
+
+        if(cql !=null && !"".equals(cql)){
+
+            String host = mapParams.get(JDBCDataStoreFactory.HOST.key).toString();
+
+            String database = mapParams.get(JDBCDataStoreFactory.DATABASE.key).toString();
+
+            DataStore dataStore = null;
+
+            try{
+
+                dataStore = DataStoreFinder.getDataStore(mapParams);
+
+                if (dataStore != null) {
+
+                    log.info("系统连接到位于：" + host + "的空间数据库" + database + "成功！");
+
+                    Filter filter = ECQL.toFilter(cql);
+
+                    ContentFeatureSource featureSource = (ContentFeatureSource) dataStore.getFeatureSource(mapParams.get("tableName").toString());
+                    SimpleFeatureStore store = (SimpleFeatureStore)featureSource;
+                    store.removeFeatures(filter);
+
+                }else{
+
+                    respCode = -1;
+                    respMsg = "系统连接到位于：" + host + "的空间数据库" + database + "失败！";
+
+                }
+
+
+            }catch (Exception e) {
+
+                e.printStackTrace();
+                log.error("系统连接到位于：" + mapParams.get(JDBCDataStoreFactory.HOST.key) + "的空间数据库" + mapParams.get(JDBCDataStoreFactory.DATABASE.key) + "失败！请检查相关参数");
+
+                respCode = -1;
+                respMsg = "系统连接到位于：" + mapParams.get(JDBCDataStoreFactory.HOST.key) + "的空间数据库" + mapParams.get(JDBCDataStoreFactory.DATABASE.key) + "失败！请检查相关参数";
+
+            }finally {
+
+                if(dataStore !=null){
+
+                    dataStore.dispose();
+
+                }
+            }
+
+
+        }else{
+
+            respCode = 2;
+            respMsg = "删除数据的过滤条件cql为空或者为null";
+        }
+
+        return Result.of(null,respCode,respMsg);
+    }
+
     @Override
     public void cqlAggQuery4Mysql(Map<String, Object> mapParams, String cql, FeatureVisitor visitor) {
 

tile-common/pom.xml

@@ -62,5 +62,11 @@
             <artifactId>validation-api</artifactId>
             <version>2.0.1.Final</version>
         </dependency>
+
+        <dependency>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-all</artifactId>
+            <version>5.7.19</version>
+        </dependency>
     </dependencies>
 </project>

tile-common/src/main/java/cn/com/taiji/common/util/IdGenerator.java

@@ -0,0 +1,20 @@
+package cn.com.taiji.common.util;
+
+/**
+ * 高效分布式ID生成算法(sequence),基于Snowflake算法优化实现64位自增ID算法。
+ * 其中解决时间回拨问题的优化方案如下：
+ * 1. 如果发现当前时间少于上次生成id的时间(时间回拨)，着计算回拨的时间差
+ * 2. 如果时间差(offset)小于等于5ms，着等待 offset * 2 的时间再生成
+ * 3. 如果offset大于5，则直接抛出异常
+ */
+public class IdGenerator {
+    private static Sequence WORKER = new Sequence();
+
+    public static long getId() {
+        return WORKER.nextId();
+    }
+
+    public static String getIdStr() {
+        return String.valueOf(WORKER.nextId());
+    }
+}

tile-common/src/main/java/cn/com/taiji/common/util/Sequence.java

@@ -0,0 +1,200 @@
+package cn.com.taiji.common.util;
+
+import cn.hutool.core.date.SystemClock;
+import cn.hutool.core.lang.Assert;
+import cn.hutool.core.util.StrUtil;
+import lombok.extern.slf4j.Slf4j;
+
+import java.lang.management.ManagementFactory;
+import java.net.InetAddress;
+import java.net.NetworkInterface;
+import java.util.concurrent.ThreadLocalRandom;
+
+/**
+ * 分布式高效有序ID生成器
+ * 优化开源项目：http://git.oschina.net/yu120/sequence
+ *
+ * Twitter_Snowflake<br>
+ * SnowFlake的结构如下(每部分用-分开):<br>
+ * 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 -
+ * 000000000000 <br>
+ * 1位标识，由于long基本类型在Java中是带符号的，最高位是符号位，正数是0，负数是1，所以id一般是正数，最高位是0<br>
+ * 41位时间截(毫秒级)，注意，41位时间截不是存储当前时间的时间截，而是存储时间截的差值（当前时间截 - 开始时间截)
+ * 得到的值），这里的的开始时间截，一般是我们的id生成器开始使用的时间，由我们程序来指定的（如下下面程序IdWorker类的startTime属性）。41位的时间截，可以使用69年，年T
+ * = (1L << 41) / (1000L * 60 * 60 * 24 * 365) = 69<br>
+ * 10位的数据机器位，可以部署在1024个节点，包括5位datacenterId和5位workerId<br>
+ * 12位序列，毫秒内的计数，12位的计数顺序号支持每个节点每毫秒(同一机器，同一时间截)产生4096个ID序号<br>
+ * 加起来刚好64位，为一个Long型。<br>
+ * SnowFlake的优点是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞(由数据中心ID和机器ID作区分)，并且效率较高，经测试，SnowFlake每秒能够产生26万ID左右。
+ */
+@Slf4j
+public class Sequence {
+    /**
+     * 时间起始标记点，作为基准，一般取系统的最近时间（一旦确定不能变动）
+     */
+    private final long twepoch = 1288834974657L;
+    /**
+     * 机器标识位数
+     */
+    private final long workerIdBits = 5L;
+    private final long datacenterIdBits = 5L;
+    private final long maxWorkerId = -1L ^ (-1L << workerIdBits);
+    private final long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
+    /**
+     * 毫秒内自增位
+     */
+    private final long sequenceBits = 12L;
+    private final long workerIdShift = sequenceBits;
+    private final long datacenterIdShift = sequenceBits + workerIdBits;
+    /**
+     * 时间戳左移动位
+     */
+    private final long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
+    private final long sequenceMask = -1L ^ (-1L << sequenceBits);
+
+    private final long workerId;
+
+    /**
+     * 数据标识 ID 部分
+     */
+    private final long datacenterId;
+    /**
+     * 并发控制
+     */
+    private long sequence = 0L;
+    /**
+     * 上次生产 ID 时间戳
+     */
+    private long lastTimestamp = -1L;
+
+    /**
+     * 时间回拨最长时间(ms)，超过这个时间就抛出异常
+     */
+    private long timestampOffset = 5L;
+
+    public Sequence() {
+        this.datacenterId = getDatacenterId(maxDatacenterId);
+        this.workerId = getMaxWorkerId(datacenterId, maxWorkerId);
+    }
+
+    /**
+     * <p>
+     * 有参构造器
+     * </p>
+     *
+     * @param workerId     工作机器 ID
+     * @param datacenterId 序列号
+     */
+    public Sequence(long workerId, long datacenterId) {
+        Assert.isFalse(workerId > maxWorkerId || workerId < 0,
+                String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
+        Assert.isFalse(datacenterId > maxDatacenterId || datacenterId < 0,
+                String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
+        this.workerId = workerId;
+        this.datacenterId = datacenterId;
+    }
+
+    /**
+     * <p>
+     * 获取 maxWorkerId
+     * </p>
+     */
+    protected static long getMaxWorkerId(long datacenterId, long maxWorkerId) {
+        StringBuilder mpid = new StringBuilder();
+        mpid.append(datacenterId);
+        String name = ManagementFactory.getRuntimeMXBean().getName();
+        if (StrUtil.isNotEmpty(name)) {
+            /*
+             * GET jvmPid
+             */
+            mpid.append(name.split("@")[0]);
+        }
+        /*
+         * MAC + PID 的 hashcode 获取16个低位
+         */
+        return (mpid.toString().hashCode() & 0xffff) % (maxWorkerId + 1);
+    }
+
+    /**
+     * <p>
+     * 数据标识id部分
+     * </p>
+     */
+    protected static long getDatacenterId(long maxDatacenterId) {
+        long id = 0L;
+        try {
+            InetAddress ip = InetAddress.getLocalHost();
+            NetworkInterface network = NetworkInterface.getByInetAddress(ip);
+            if (network == null) {
+                id = 1L;
+            } else {
+                byte[] mac = network.getHardwareAddress();
+                if (null != mac) {
+                    id = ((0x000000FF & (long) mac[mac.length - 1]) | (0x0000FF00 & (((long) mac[mac.length - 2]) << 8))) >> 6;
+                    id = id % (maxDatacenterId + 1);
+                }
+            }
+        } catch (Exception e) {
+            log.warn(" getDatacenterId: " + e.getMessage());
+        }
+        return id;
+    }
+
+    /**
+     * 获取下一个ID
+     *
+     * @return
+     */
+    public synchronized long nextId() {
+        long timestamp = timeGen();
+        //闰秒
+        if (timestamp < lastTimestamp) {
+            long offset = lastTimestamp - timestamp;
+            if (offset <= timestampOffset) {
+                try {
+                    wait(offset << 1);
+                    timestamp = timeGen();
+                    if (timestamp < lastTimestamp) {
+                        throw new RuntimeException(String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", offset));
+                    }
+                } catch (Exception e) {
+                    throw new RuntimeException(e);
+                }
+            } else {
+                throw new RuntimeException(String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", offset));
+            }
+        }
+
+        if (lastTimestamp == timestamp) {
+            // 相同毫秒内，序列号自增
+            sequence = (sequence + 1) & sequenceMask;
+            if (sequence == 0) {
+                // 同一毫秒的序列数已经达到最大
+                timestamp = tilNextMillis(lastTimestamp);
+            }
+        } else {
+            // 不同毫秒内，序列号置为 1 - 100 随机数
+            sequence = ThreadLocalRandom.current().nextLong(1, 101);
+        }
+
+        lastTimestamp = timestamp;
+
+        // 时间戳部分 | 数据中心部分 | 机器标识部分 | 序列号部分
+        return ((timestamp - twepoch) << timestampLeftShift)
+                | (datacenterId << datacenterIdShift)
+                | (workerId << workerIdShift)
+                | sequence;
+    }
+
+    protected long tilNextMillis(long lastTimestamp) {
+        long timestamp = timeGen();
+        while (timestamp <= lastTimestamp) {
+            timestamp = timeGen();
+        }
+        return timestamp;
+    }
+
+    protected long timeGen() {
+        return SystemClock.now();
+    }
+}

tile-web/src/main/java/cn/com/taiji/web/controller/GeoDataSourceController.java

@@ -0,0 +1,177 @@
+package cn.com.taiji.web.controller;
+
+import cn.com.taiji.common.domain.PageResult;
+import cn.com.taiji.common.domain.Result;
+import cn.com.taiji.web.service.IEnterpriseService;
+import cn.com.taiji.web.service.IGeoDataSourceService;
+import cn.com.taiji.web.vo.DeviceVo;
+import cn.com.taiji.web.vo.EnterpriseVo;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+
+/**
+ *数据源控制器
+ *
+ * @author makejava
+ * @since 2021-04-22 16:53:35
+ */
+@Slf4j
+@RestController
+public class GeoDataSourceController {
+
+
+    @Autowired
+    private IGeoDataSourceService geoDataSourceService;
+
+
+    /**
+     *数据源列表查询接口
+     * @param paramMaps
+     */
+    @PostMapping("/geoDsQuery")
+    public PageResult geoDsQuery(@RequestBody Map<String,Object> paramMaps) throws Exception {
+
+        List<Map<String, Object>> dataList = new ArrayList<Map<String, Object>>();
+
+
+        int respCode = 0;
+
+        String respMsg = "操作成功";
+
+        if(paramMaps.containsKey("cql")){
+
+            String cql = paramMaps.get("cql").toString();
+
+            if(cql !=null && !"".equals(cql)){
+
+                return geoDataSourceService.geoDsQuery(paramMaps);
+
+            }else{
+
+                respCode = 2;
+
+                respMsg = "数据源列表查询的过滤条件cql参数为空或者为null!";
+
+            }
+
+        }else{
+
+            respCode = 2;
+
+            respMsg = "数据源列表查询的过滤条件cql参数不存在!";
+
+        }
+
+
+
+        return PageResult.<List<Map<String, Object>>>builder().datas(dataList).resp_code(respCode).resp_msg(respMsg).build();
+    }
+
+
+    /**
+     * 数据源增加接口
+     * @param paramMaps
+     * @return
+     * @throws Exception
+     */
+
+    @PostMapping("/geoDsAddInfo")
+    public Result geoDsAddInfo(@RequestBody Map<String,Object> paramMaps) throws Exception {
+
+        return geoDataSourceService.geoDsAddInfo(paramMaps);
+    }
+
+    /**
+     * 数据源修改接口
+     * @param paramMaps
+     * @return
+     * @throws Exception
+     */
+
+    @PostMapping("/geoDsUpdateInfo")
+    public Result geoDsUpdateInfo(@RequestBody Map<String,Object> paramMaps) throws Exception {
+
+
+        int respCode = 0;
+
+        String respMsg = "操作成功";
+
+        if(paramMaps !=null && paramMaps.keySet().size() >1 && paramMaps.containsKey("cql")){
+
+            String cql = paramMaps.get("cql").toString();
+
+            if(cql !=null && !"".equals(cql)){
+
+                return geoDataSourceService.geoDsUpdateInfo(paramMaps);
+
+            }else{
+
+                respCode = 2;
+
+                respMsg = "数据源修改条件cql参数为空或者为null!";
+
+            }
+
+        }else{
+
+            respCode = 2;
+
+            respMsg = "数据源修改条件cql参数不存在或者数据源修改属性不存在！";
+
+        }
+
+        return Result.of(null,respCode,respMsg);
+    }
+
+    /**
+     * 数据源删除接口
+     * @param paramMaps
+     * @return
+     * @throws Exception
+     */
+
+    @PostMapping("/geoDsRemoveInfo")
+    public Result geoDsRemoveInfo(@RequestBody Map<String,Object> paramMaps) throws Exception {
+
+        int respCode = 0;
+
+        String respMsg = "操作成功";
+
+        if(paramMaps !=null && paramMaps.keySet().size() >0 && paramMaps.containsKey("cql")){
+
+            String cql = paramMaps.get("cql").toString();
+
+            if(cql !=null && !"".equals(cql)){
+
+                return geoDataSourceService.geoDsRemoveInfo(paramMaps);
+
+            }else{
+
+                respCode = 2;
+
+                respMsg = "数据源删除条件cql参数为空或者为null!";
+
+            }
+
+        }else{
+
+            respCode = 2;
+
+            respMsg = "数据源删除条件cql参数不存在！";
+
+        }
+
+        return Result.of(null,respCode,respMsg);
+    }
+
+
+
+}

tile-web/src/main/java/cn/com/taiji/web/service/IGeoDataSourceService.java

@@ -1,8 +1,14 @@
 package cn.com.taiji.web.service;
 
+import cn.com.taiji.common.domain.PageResult;
+import cn.com.taiji.common.domain.Result;
 import cn.com.taiji.cql.model.GeoDataSource;
+import cn.com.taiji.web.vo.DeviceVo;
+import cn.com.taiji.web.vo.EnterpriseVo;
+import org.springframework.web.bind.annotation.RequestBody;
 
 import javax.sql.DataSource;
+import java.util.Map;
 
 public interface IGeoDataSourceService {
 
@@ -13,4 +19,39 @@ public interface IGeoDataSourceService {
     GeoDataSource layerCodeGeoDataSource(String layerCode) throws Exception;
 
     DataSource defaultDataSource() throws Exception;
+
+    /**
+     * 数据源列表查询接口
+     * @param paramMaps
+     * @return
+     */
+
+    PageResult geoDsQuery(Map<String,Object> paramMaps) throws Exception;
+
+    /**
+     * 数据源增加接口
+     * @param paramMaps
+     * @return
+     * @throws Exception
+     */
+
+    Result geoDsAddInfo(Map<String,Object> paramMaps) throws Exception;
+
+    /**
+     * 数据源修改接口
+     * @param paramMaps
+     * @return
+     * @throws Exception
+     */
+
+    Result geoDsUpdateInfo(Map<String,Object> paramMaps) throws Exception;
+
+    /**
+     * 数据源删除接口
+     * @param paramMaps
+     * @return
+     * @throws Exception
+     */
+
+    Result geoDsRemoveInfo(Map<String,Object> paramMaps) throws Exception;
 }

tile-web/src/main/java/cn/com/taiji/web/service/impl/GeoDataSourceServiceImpl.java

@@ -1,6 +1,7 @@
 package cn.com.taiji.web.service.impl;
 
 import cn.com.taiji.common.domain.PageResult;
+import cn.com.taiji.common.domain.Result;
 import cn.com.taiji.cql.model.GeoDataSource;
 import cn.com.taiji.cql.service.IECqlService;
 import cn.com.taiji.web.config.GeoConfig;
@@ -28,6 +29,7 @@ public class GeoDataSourceServiceImpl implements IGeoDataSourceService {
     @Autowired
     private IECqlService ecqlService;
 
+
     @Override
     public GeoDataSource layerCodeGeoDataSource(String layerCode) throws Exception{
 
@@ -80,4 +82,81 @@ public class GeoDataSourceServiceImpl implements IGeoDataSourceService {
         return DataSourceFinder.getDataSource(mapParams);
 
     }
+
+    @Override
+    public PageResult geoDsQuery(Map<String, Object> paramMaps) throws Exception {
+
+        Map<String, Object> dsParams = new HashMap<String, Object>();
+
+        dsParams.put(JDBCDataStoreFactory.DATABASE.key, geoConfig.getDsBase());
+        dsParams.put(JDBCDataStoreFactory.DBTYPE.key, geoConfig.getDbType());
+
+        dsParams.put(JDBCDataStoreFactory.HOST.key, geoConfig.getDsIp());
+        dsParams.put(JDBCDataStoreFactory.PORT.key, geoConfig.getDsPort());
+        dsParams.put(JDBCDataStoreFactory.USER.key, geoConfig.getDsUsername());
+        dsParams.put(JDBCDataStoreFactory.PASSWD.key, geoConfig.getDsPassword());
+        dsParams.put("tableName", "tile_data_source");
+
+        return ecqlService.cqlQuery(dsParams,paramMaps);
+    }
+
+    @Override
+    public Result geoDsAddInfo(Map<String, Object> paramMaps) throws Exception {
+
+        Map<String, Object> dsParams = new HashMap<String, Object>();
+
+        dsParams.put(JDBCDataStoreFactory.DATABASE.key, geoConfig.getDsBase());
+        dsParams.put(JDBCDataStoreFactory.DBTYPE.key, geoConfig.getDbType());
+
+        dsParams.put(JDBCDataStoreFactory.HOST.key, geoConfig.getDsIp());
+        dsParams.put(JDBCDataStoreFactory.PORT.key, geoConfig.getDsPort());
+        dsParams.put(JDBCDataStoreFactory.USER.key, geoConfig.getDsUsername());
+        dsParams.put(JDBCDataStoreFactory.PASSWD.key, geoConfig.getDsPassword());
+        dsParams.put("tableName", "tile_data_source");
+
+        return ecqlService.cqlAdd(dsParams,paramMaps);
+    }
+
+    @Override
+    public Result geoDsUpdateInfo(Map<String, Object> paramMaps) throws Exception {
+
+        Map<String, Object> dsParams = new HashMap<String, Object>();
+
+        dsParams.put(JDBCDataStoreFactory.DATABASE.key, geoConfig.getDsBase());
+        dsParams.put(JDBCDataStoreFactory.DBTYPE.key, geoConfig.getDbType());
+
+        dsParams.put(JDBCDataStoreFactory.HOST.key, geoConfig.getDsIp());
+        dsParams.put(JDBCDataStoreFactory.PORT.key, geoConfig.getDsPort());
+        dsParams.put(JDBCDataStoreFactory.USER.key, geoConfig.getDsUsername());
+        dsParams.put(JDBCDataStoreFactory.PASSWD.key, geoConfig.getDsPassword());
+        dsParams.put("tableName", "tile_data_source");
+
+        String cql = paramMaps.get("cql").toString();
+
+        if(paramMaps.containsKey("cql")){
+
+            paramMaps.remove("cql");
+        }
+
+        return ecqlService.cqlUpdate(dsParams,paramMaps,cql);
+    }
+
+    @Override
+    public Result geoDsRemoveInfo(Map<String, Object> paramMaps) throws Exception {
+
+        Map<String, Object> dsParams = new HashMap<String, Object>();
+
+        dsParams.put(JDBCDataStoreFactory.DATABASE.key, geoConfig.getDsBase());
+        dsParams.put(JDBCDataStoreFactory.DBTYPE.key, geoConfig.getDbType());
+
+        dsParams.put(JDBCDataStoreFactory.HOST.key, geoConfig.getDsIp());
+        dsParams.put(JDBCDataStoreFactory.PORT.key, geoConfig.getDsPort());
+        dsParams.put(JDBCDataStoreFactory.USER.key, geoConfig.getDsUsername());
+        dsParams.put(JDBCDataStoreFactory.PASSWD.key, geoConfig.getDsPassword());
+        dsParams.put("tableName", "tile_data_source");
+
+        String cql = paramMaps.get("cql").toString();
+
+        return ecqlService.cqlRemove(dsParams,cql);
+    }
 }