• java 使用GeoTools工具 geojson 与shp 相互转换

    记录使用geotools工具，实现shp和geojson数据互转

     

     爬坑：不使用依赖：vividsolutions ，因为 1.8 与 geotools 20以后版本jts 不一致，会报错。

    1. <dependency>
    2.     <groupId>com.vividsolutions</groupId>
    3.     <artifactId>jts</artifactId>
    4.     <version>1.8</version>
    5.     <type>pom</type>
    6. </dependency>

    ----------------------------------------------------------开启编码-------------------------------------------------------

    1. 引起pom依赖jar

    
    
        org.geotools
        gt-shapefile
        20.3
    
    
        org.geotools
        gt-api
        20.3
    
    
        org.geotools
        gt-geojson
        20.3
    
    
        org.geotools
        gt-geometry
        20.3
    
    
        org.geotools
        gt-jts-wrapper
        20.3
    
    
        org.geotools
        gt-main
        20.3
    
    
        org.geotools
        gt-epsg-hsql
        20.3
    
    
        org.geotools
        gt-opengis
        20.3
    
    
        org.geotools
        gt-data
        20.3
    
    
        org.geotools
        gt-referencing
        20.3
    
    
        com.alibaba
        fastjson
        1.2.83
    




    
        
            org.apache.maven.plugins
            maven-compiler-plugin
            3.0
            
                1.8
                1.8
                true

    2. 上代码，自动识别坐标系，默认为84坐标

    1. import com.alibaba.fastjson.JSON;
    2. import com.alibaba.fastjson.JSONArray;
    3. import com.alibaba.fastjson.JSONObject;
    4. import org.geotools.referencing.CRS;
    5. import org.locationtech.jts.geom.*;
    6. import org.geotools.data.FeatureWriter;
    7. import org.geotools.data.Transaction;
    8. import org.geotools.data.shapefile.ShapefileDataStore;
    9. import org.geotools.data.shapefile.ShapefileDataStoreFactory;
    10. import org.geotools.data.simple.SimpleFeatureCollection;
    11. import org.geotools.data.simple.SimpleFeatureIterator;
    12. import org.geotools.data.simple.SimpleFeatureSource;
    13. import org.geotools.feature.simple.SimpleFeatureTypeBuilder;
    14. import org.geotools.geojson.feature.FeatureJSON;
    15. import org.geotools.geojson.geom.GeometryJSON;
    16. import org.geotools.referencing.crs.DefaultGeographicCRS;
    17. import org.opengis.feature.simple.SimpleFeature;
    18. import org.opengis.feature.simple.SimpleFeatureType;
    19. import org.opengis.referencing.crs.CoordinateReferenceSystem;
    20.  
    21. import java.io.*;
    22. import java.nio.charset.Charset;
    23. import java.util.*;
    24.  
    25. /**
    26.  * @author qiaobing1226
    27.  * @since 2022/10/28 上午10:52
    28.  * 参考：https://blog.csdn.net/qiaobing1226/article/details/127612665
    29.  */
    30. public class Shp2GeojsonUtils {
    31.     private static final String POINT = "Point";
    32.     private static final String MULTIPOINT = "MultiPoint";
    33.     private static final String LINESTRING = "LineString";
    34.     private static final String MULTILINESTRING = "MultiLineString";
    35.     private static final String POLYGON = "Polygon";
    36.     private static final String MULTIPOLYGON = "MultiPolygon";
    37.     private static final String THE_GEOM = "the_geom";
    38.     private static final String PROPERTIES = "properties";
    39.     private static final String GEOMETRY = "geometry";
    40.     private static final String GBK = "GBK";
    41.  
    42.     /**
    43.      * geoJson转换为shp文件
    44.      *
    45.      * @param jsonPath
    46.      * @param shpPath
    47.      * @return
    48.      */
    49.     public static Map geoJson2Shape(String jsonPath, String shpPath) {
    50.         Map map = new HashMap<>();
    51.         GeometryJSON geoJson = new GeometryJSON();
    52.         try {
    53.             JSONObject json = readGeoJsonFile(jsonPath);
    54.             JSONArray features = (JSONArray) json.get("features");
    55.             JSONObject feature0 = JSONObject.parseObject(features.get(0).toString());
    56.             // 获取属性名称
    57.             Set properties = JSONObject.parseObject(feature0.getString(PROPERTIES)).keySet();
    58.             String strType = ((JSONObject) feature0.get(GEOMETRY)).getString("type");
    59.             String strCrs = json.getJSONObject("crs").getJSONObject(PROPERTIES).getString("name");
    60.             CoordinateReferenceSystem crs = CRS.decode(strCrs);
    61.             ShapefileDataStore shapefileDataStore = dataStore(properties, strType, shpPath, crs);
    62.             if (shapefileDataStore == null) {
    63.                 return map;
    64.             }
    65.             // 设置Writer
    66.             FeatureWriter writer = shapefileDataStore.getFeatureWriter(shapefileDataStore.getTypeNames()[0],
    67.                     Transaction.AUTO_COMMIT);
    68.             for (int i = 0, len = features.size(); i < len; i++) {
    69.                 String strFeature = features.get(i).toString();
    70.                 Reader reader = new StringReader(strFeature);
    71.                 SimpleFeature feature = writer.next();
    72.                 switch (strType) {
    73.                     case POINT:
    74.                         feature.setAttribute(THE_GEOM, geoJson.readPoint(reader));
    75.                         break;
    76.                     case MULTIPOINT:
    77.                         feature.setAttribute(THE_GEOM, geoJson.readMultiPoint(reader));
    78.                         break;
    79.                     case LINESTRING:
    80.                         feature.setAttribute(THE_GEOM, geoJson.readLine(reader));
    81.                         break;
    82.                     case MULTILINESTRING:
    83.                         feature.setAttribute(THE_GEOM, geoJson.readMultiLine(reader));
    84.                         break;
    85.                     case POLYGON:
    86.                         feature.setAttribute(THE_GEOM, geoJson.readPolygon(reader));
    87.                         break;
    88.                     case MULTIPOLYGON:
    89.                         feature.setAttribute(THE_GEOM, geoJson.readMultiPolygon(reader));
    90.                         break;
    91.                 }
    92.                 Iterator iterator = properties.iterator();
    93.                 while (iterator.hasNext()) {
    94.                     String str = iterator.next().toString();
    95.                     JSONObject element = JSONObject.parseObject(features.get(i).toString());
    96.                     feature.setAttribute(str, JSONObject.parseObject(element.getString(PROPERTIES)).get(str));
    97.                 }
    98.                 writer.write();
    99.             }
    100.             writer.close();
    101.             shapefileDataStore.dispose();
    102.             map.put("status", 200);
    103.             map.put("message", "shp转换success");
    104.         } catch (Exception e) {
    105.             map.put("status", 400);
    106.             map.put("message", e.getMessage());
    107.             e.printStackTrace();
    108.         }
    109.         return map;
    110.     }
    111.  
    112.     /**
    113.      * 读取geojosn文件
    114.      *
    115.      * @param jsonPath
    116.      * @return
    117.      */
    118.     private static JSONObject readGeoJsonFile(String jsonPath) {
    119.         // 读文件到Stringbuffer
    120.         StringBuffer sb = new StringBuffer();
    121.         BufferedReader br = null;
    122.         try {
    123.             br = new BufferedReader(new FileReader(jsonPath));
    124.             String str;
    125.             while ((str = br.readLine()) != null) {// 逐行读取
    126.                 sb.append(str + "\r\n");
    127.             }
    128.             br.close();
    129.         } catch (Exception e) {
    130.             if (br != null) {
    131.                 try {
    132.                     br.close();
    133.                 } catch (Exception exception) {
    134.                     exception.printStackTrace();
    135.                 }
    136.             }
    137.             e.printStackTrace();
    138.         }
    139.         return JSONObject.parseObject(sb.toString());
    140.     }
    141.  
    142.     /**
    143.      * 设置shp文件属性
    144.      *
    145.      * @param properties
    146.      * @param strType
    147.      * @param shpPath
    148.      * @return
    149.      */
    150.     private static ShapefileDataStore dataStore(Set properties, String strType, String shpPath, CoordinateReferenceSystem crs) {
    151.         try {
    152.             Class geoType = null;
    153.             switch (strType) {
    154.                 case POINT:
    155.                     geoType = Point.class;
    156.                     break;
    157.                 case MULTIPOINT:
    158.                     geoType = MultiPoint.class;
    159.                     break;
    160.                 case LINESTRING:
    161.                     geoType = LineString.class;
    162.                     break;
    163.                 case MULTILINESTRING:
    164.                     geoType = MultiLineString.class;
    165.                     break;
    166.                 case POLYGON:
    167.                     geoType = Polygon.class;
    168.                     break;
    169.                 case MULTIPOLYGON:
    170.                     geoType = MultiPolygon.class;
    171.                     break;
    172.             }
    173.             // 创建shape文件对象
    174.             File file = new File(shpPath);
    175.             Map params = new HashMap();
    176.             params.put(ShapefileDataStoreFactory.URLP.key, file.toURI().toURL());
    177.             ShapefileDataStore ds = (ShapefileDataStore) new ShapefileDataStoreFactory().createNewDataStore(params);
    178.             // 定义图形信息和属性信息
    179.             SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder();
    180.             //默认84坐标
    181.             tb.setCRS(crs == null ? DefaultGeographicCRS.WGS84 : crs);
    182.             tb.setName("shapefile");
    183.             // 类型，Point/MultiPoint/LineString/MultiLineString/Polygon/MultiPolygon
    184.             tb.add("the_geom", geoType);
    185.             Iterator propertiesIter = properties.iterator();
    186.             // 设置属性
    187.             while (propertiesIter.hasNext()) {
    188.                 String str = propertiesIter.next().toString();
    189.                 // 此处设置为string
    190.                 tb.add(str, String.class);
    191.             }
    192.             ds.createSchema(tb.buildFeatureType());
    193.             // 设置编码
    194.             Charset charset = Charset.forName(GBK);
    195.             ds.setCharset(charset);
    196.             return ds;
    197.         } catch (Exception ex) {
    198.             ex.printStackTrace();
    199.         }
    200.         return null;
    201.  
    202.     }
    203.  
    204.     /**
    205.      * shp文件转换geojson数据
    206.      *
    207.      * @param shpPath
    208.      * @return
    209.      */
    210.     public static Map shp2Geojson(String shpPath, String jsonPath) {
    211.         Map map = new HashMap();
    212.         //新建json对象
    213.  
    214.         JSONObject geojsonObject = new JSONObject();
    215.         geojsonObject.put("type", "FeatureCollection");
    216.         try {
    217.             JSONArray array = new JSONArray();
    218.             String fileName = readShpContent(shpPath, array);
    219.             geojsonObject.put("features", array);
    220.             geojsonObject.put("name", fileName);
    221.             String crs = getCoordinateSystemWKT(shpPath);
    222.             //GEOGCS表示这个是地址坐标系,PROJCS则表示是平面投影坐标系
    223.             JSONObject crsJson = new JSONObject();
    224.             JSONObject proJson = new JSONObject();
    225.             crsJson.put("type", "name");
    226.             if (crs.startsWith("PROJCS")) {
    227.                 proJson.put("name", "urn:ogc:def:crs:EPSG::3857");
    228.                 crsJson.put("properties", proJson);
    229.             } else {
    230.                 proJson.put("name", "urn:ogc:def:crs:OGC:1.3:CRS84");
    231.                 crsJson.put("properties", proJson);
    232.             }
    233.             geojsonObject.put("crs", crsJson);
    234.  
    235. //            itertor.close();
    236.  
    237.             long startTime = System.currentTimeMillis();
    238.  
    239.             //将json字符串使用字符流写入文件
    240. /*            File outputfile=new File(jsonPath);
    241.             BufferedWriter bufferedWriter=new BufferedWriter(new FileWriter(outputfile));
    242.             bufferedWriter.write(JSON.toJSONString(geojsonObject));
    243.             bufferedWriter.flush();
    244.             bufferedWriter.close();*/
    245.             File outputfile = new File(jsonPath);
    246.             FileOutputStream fileOutputStream = new FileOutputStream(outputfile);
    247.             OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "utf-8");
    248.             outputStreamWriter.write(JSON.toJSONString(geojsonObject));
    249.             outputStreamWriter.flush();
    250.             outputStreamWriter.close();
    251.  
    252.             //将json字符串使用字节流写入文件
    253. /*            File outputfile=new File(jsonPath);
    254.             BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(new FileOutputStream(outputfile));
    255.             byte[] bytes= JSON.toJSONString(geojsonObject).getBytes("utf-8");
    256.             bufferedOutputStream.write(bytes);
    257.             //fileOutputStream.write(JSON.toJSONString(geojsonObject));
    258.             bufferedOutputStream.flush();
    259.             bufferedOutputStream.close();*/
    260.  
    261. //            long endTime=System.currentTimeMillis();
    262. //            System.out.println("当前程序耗时："+(endTime-startTime)+"ms");
    263.         } catch (Exception e) {
    264.             map.put("status", "failure");
    265.             map.put("message", e.getMessage());
    266.             e.printStackTrace();
    267.  
    268.         }
    269. //
    270.         return geojsonObject;
    271.     }
    272.  
    273.     private static String readShpContent(String shpPath, JSONArray array) {
    274.         String fileName = "";
    275.         try {
    276.             FeatureJSON fjson = new FeatureJSON();
    277.             //获取featurecollection
    278.             File file = new File(shpPath);
    279.             ShapefileDataStore shpDataStore = null;
    280.             shpDataStore = new ShapefileDataStore(file.toURL());
    281.             //设置编码
    282. /*            Charset charset = Charset.forName("GBK");
    283.             shpDataStore.setCharset(charset);*/
    284.             fileName = shpDataStore.getTypeNames()[0];
    285.             SimpleFeatureSource featureSource = null;
    286.             featureSource = shpDataStore.getFeatureSource(fileName);
    287.             SimpleFeatureCollection result = featureSource.getFeatures();
    288.             SimpleFeatureIterator itertor = result.features();
    289.  
    290.             //遍历feature转为json对象
    291.             while (itertor.hasNext()) {
    292.                 SimpleFeature feature = itertor.next();
    293.                 StringWriter writer = new StringWriter();
    294.                 fjson.writeFeature(feature, writer);
    295.                 String temp = writer.toString();
    296.                 Object geometry = JSONObject.parseObject(temp).getString(GEOMETRY);
    297.                 byte[] b = temp.getBytes("iso8859-1");
    298.                 temp = new String(b, GBK);
    299.                 JSONObject json = JSON.parseObject(temp);
    300.                 array.add(json);
    301.             }
    302.             itertor.close();
    303.         } catch (Exception e) {
    304.             e.printStackTrace();
    305.         }
    306.         return fileName;
    307.     }
    308.  
    309.     /**
    310.      * 获取Shape文件的坐标系信息,GEOGCS表示这个是地址坐标系,PROJCS则表示是平面投影坐标系
    311.      *
    312.      * @shpPath
    313.      */
    314.     public static String getCoordinateSystemWKT(String shpPath) {
    315.         ShapefileDataStoreFactory factory = new ShapefileDataStoreFactory();
    316.         ShapefileDataStore dataStore = null;
    317.         try {
    318.             dataStore = (ShapefileDataStore) factory.createDataStore(new File(shpPath).toURI().toURL());
    319.             return dataStore.getSchema().getCoordinateReferenceSystem().toWKT();
    320.         } catch (UnsupportedOperationException | IOException e) {
    321.             e.printStackTrace();
    322.         } finally {
    323.             dataStore.dispose();
    324.         }
    325.         return "";
    326.     }
    327.  
    328.     /**
    329.      * 工具类测试方法
    330.      *
    331.      * @param args
    332.      */
    333.     public static void main(String[] args) throws Exception {
    334.         Shp2GeojsonUtils shpToGeojson = new Shp2GeojsonUtils();
    335. //        // shape2Geojson
    336.         String shpPath = "/Users/ecarx/Desktop/geojson/上下高架mct/123/AD_Road.shp";
    337.         String jsonPath = "/Users/ecarx/Desktop/geojson/AD_Road.geojson";
    338.         Map map = shpToGeojson.shp2Geojson(shpPath, jsonPath);
    339.  
    340.         // geojson2Shape
    341. //        String shpPath = "/Users/ecarx/Desktop/geojson/上下高架mct/123/AD_Road.shp";
    342. //        String jsonPath = "/Users/ecarx/Desktop/geojson/上下高架mct/AD_Road.geojson";
    343. //        Map map = shpToGeojson.geoJson2Shape(jsonPath, shpPath);
    344. //        System.out.println(map.toString());
    345.     }
    346. }

  • 相关阅读:
    开发中，遇到后端返回的数据列表不更新怎么办？
    什么是地理信息系统（GIS）？
    从实现一个React到深度理解React框架核心原理
    PTA 编程题（C语言）-- 连续因子
    合并单元格
    TS第一讲-----基础类型
    同样的SQL，怎么突然就慢了？
    R语言作图——Heatmap(热图)
    【编程题】【Scratch二级】2021.12 绘制多边形
    day82【Leetcode】
  • 原文地址：https://blog.csdn.net/qiaobing1226/article/details/127612665