1、单个类型转换

一次只能转换出一个 Geometry

geojson中只有一个 Feature 的情况

  1. import com.fasterxml.jackson.core.JsonProcessingException;
  2. import lombok.Data;
  3. import org.locationtech.jts.geom.*;
  4. import org.locationtech.jts.io.ParseException;
  5. import org.locationtech.jts.io.WKTReader;
  7. import java.util.List;
  8. import java.util.Map;
  9. /**
  10.  * Created on 2021/9/10--20:08.
  11.  *
  12.  * @author fengyuhao
  13.  * @Description GeoJson 转 Geometry
  14.  */
  15. public class GeoJsonToGeometry {
  17.     private static final int SRID = 4326;
  18.     private static final String TYPES = "Point,LineString,Polygon,MultiPoint,MultiLineString,MultiPolygon";
  20.     /**
  21.      * 将 GeoJson 转换为对应的 Geometry 类型,默认 srid = 4326
  22.      * @param geoJson       geoJson
  23.      */
  24.     public static GeoJson getGeometryByGeoJson(String geoJson,String type) throws Exception {
  25.         return getGeometryByGeoJson(geoJson,type,SRID);
  26.     }
  28.     /**
  29.      * 支持转换所有类型，将 GeoJson 转换为对应的 Geometry 类型,默认 srid = 4326
  30.      * @param geoJson           geoJson
  31.      */
  32.     public static GeoJson getGeometryByGeoJson(String geoJson) throws Exception {
  33.         return getGeometryByGeoJson(geoJson,TYPES,SRID);
  34.     }
  36.     /**
  37.      * 支持转换所有类型，将 GeoJson 转换为对应的 Geometry 类型
  38.      * @param geoJson           geoJson
  39.      */
  40.     public static GeoJson getGeometryByGeoJson(String geoJson,int srid) throws Exception {
  41.         return getGeometryByGeoJson(geoJson,TYPES,srid);
  42.     }
  44.     /**
  45.      * 将 GeoJson 转换为对应的 Geometry 类型
  46.      * @param geoJson       geoJson
  47.      * @param srid          SRID
  48.      */
  49.     public static GeoJson getGeometryByGeoJson(String geoJson,String type,int srid) throws Exception {
  50.         List<Map<String, Object>> list = null;
  51.         try {
  52.             list = (List<Map<String, Object>>) OtherUtil.OBJECT_MAPPER.readValue(geoJson, Map.class).get("features");
  53.         } catch (JsonProcessingException e) {
  54.             e.printStackTrace();
  55.         }
  56.         if (list == null) {
  57.             throw new Exception("Json 转换异常");
  58.         }
  59.         // 获取属性信息
  60.         Map<String, Object> properties = (Map<String, Object>)list.get(0).get("properties");
  61.         GeoJson geo = getProperties(properties);
  63.         // 获取 geometry
  64.         Map<String, Object> geometry = (Map<String, Object>)list.get(0).get("geometry");
  65.         if(!type.toUpperCase().contains(geometry.get("type").toString().toUpperCase())){
  66.             throw new Exception("不支持的 Geometry 类型");
  67.         }
  68.         switch (geometry.get("type").toString().toUpperCase()) {
  69.             case "POINT":
  70.                 geo.setGeom(getPoint((List<Double>) geometry.get("coordinates"),srid));
  71.                 break;
  72.             case "LINESTRING":
  73.                 geo.setGeom(getLineString((List<Object>) geometry.get("coordinates"),srid));
  74.                 break;
  75.             case "POLYGON":
  76.                 geo.setGeom(getPolygon((List<Object>) geometry.get("coordinates"),srid));
  77.                 break;
  78.             case "MULTIPOINT":
  79.                 geo.setGeom(getMultiPoint((List<Object>) geometry.get("coordinates"),srid));
  80.                 break;
  81.             case "MULTILINESTRING":
  82.                 geo.setGeom(getMultiLineString((List<Object>) geometry.get("coordinates"),srid));
  83.                 break;
  84.             case "MULTIPOLYGON":
  85.                 geo.setGeom(getMultiPolygon((List<Object>) geometry.get("coordinates"),srid));
  86.                 break;
  87.             default:
  88.                 throw new Exception("不支持的 Geometry 类型");
  89.         }
  90.         return geo;
  91.     }
  93.     /**
  94.      * [[
  95.      *    [122.19794471743876,30.241048024596722],[122.19349009648414,30.235207526854044],
  96.      *    [122.20655698914918,30.23401962566707],[122.19794471743876,30.241048024596722]
  97.      * ]]
  98.      * POLYGON((-71.1776585052917 42.3902909739571,-71.1776820268866 42.3903701743239,
  99.      *         -71.1775826583081 42.3903033653531,-71.1776585052917 42.3902909739571))
  100.      */
  101.     private static Polygon getPolygon(List<Object> coordinates,int srid) throws ParseException {
  102.         coordinates = (List<Object>)coordinates.get(0);
  103.         StringBuilder str = new StringBuilder();
  104.         str.append("POLYGON((");
  105.         List<Double> coordinate;
  106.         for(Object obj : coordinates){
  107.             coordinate = (List<Double>) obj;
  108.             str.append(coordinate.get(0)).append(" ").append(coordinate.get(1)).append(",");
  109.         }
  110.         str.deleteCharAt(str.length() - 1).append("))");
  112.         Polygon polygon = (Polygon) new WKTReader().read(str.toString());
  113.         polygon.setSRID(srid);
  114.         return polygon;
  115.     }
  117.     /**
  118.      * [[119.001,34.001],[120.001,35.001]]
  119.      * LINESTRING(1 2, 3 4)
  120.      */
  121.     private static LineString getLineString(List<Object> coordinates,int srid) throws ParseException {
  122.         StringBuilder str = new StringBuilder();
  123.         List<Double> coordinate;
  124.         str.append("LINESTRING(");
  125.         for(Object obj : coordinates){
  126.             coordinate = (List<Double>) obj;
  127.             str.append(coordinate.get(0)).append(" ").append(coordinate.get(1)).append(",");
  128.         }
  129.         str.deleteCharAt(str.length() - 1).append(")");
  130.         LineString lineString = (LineString) new WKTReader().read(str.toString());
  131.         lineString.setSRID(srid);
  132.         return lineString;
  133.     }
  135.     /**
  136.      * [119,34]
  137.      * POINT(1 2)
  138.      */
  139.     private static Point getPoint(List<Double> coordinates,int srid) throws ParseException {
  140.         Point point = (Point) new WKTReader().read("POINT("+coordinates.get(0)+" "+coordinates.get(1)+")");
  141.         point.setSRID(srid);
  142.         return point;
  143.     }
  145.     /**
  146.      * [ [122.19794471743876,30.241048024596722],[122,30] ]
  147.      * MULTIPOINT(1 2, 3 4)
  148.      */
  149.     private static MultiPoint getMultiPoint(List<Object> coordinates,int srid) throws ParseException {
  150.         StringBuilder str = new StringBuilder();
  151.         List<Double> coordinate;
  152.         str.append("MultiPoint(");
  153.         for(Object obj : coordinates){
  154.             coordinate = (List<Double>) obj;
  155.             str.append(coordinate.get(0)).append(" ").append(coordinate.get(1)).append(",");
  156.         }
  157.         str.deleteCharAt(str.length() - 1).append(")");
  158.         MultiPoint multiPoint = (MultiPoint) new WKTReader().read(str.toString());
  159.         multiPoint.setSRID(srid);
  160.         return multiPoint;
  161.     }
  163.     /**
  164.      * [
  165.      *  [[119,35],[120,35]],
  166.      *  [[119,34],[122,34]]
  167.      * ]
  168.      * MULTILINESTRING((1 2, 3 4), (4 5, 6 7))
  169.      */
  170.     private static MultiLineString getMultiLineString(List<Object> coordinates,int srid) throws ParseException {
  171.         StringBuilder str = new StringBuilder();
  172.         str.append("MULTILINESTRING(");
  173.         List<Double> coordinate;
  174.         for(Object obj : coordinates){
  175.             str.append("(");
  176.             for(Object data : (List<Object>)obj){
  177.                 coordinate = (List<Double>) data;
  178.                 str.append(coordinate.get(0)).append(" ").append(coordinate.get(1)).append(",");
  179.             }
  180.             str.deleteCharAt(str.length() - 1).append("),");
  181.         }
  182.         str.deleteCharAt(str.length() -1).append(")");
  183.         MultiLineString multiLineString = (MultiLineString) new WKTReader().read(str.toString());
  184.         multiLineString.setSRID(srid);
  185.         return multiLineString;
  186.     }
  188.     /**
  189.      * [
  190.      *    [[ [122,30],[123,30],[122,31],[122,30] ]],
  191.      *    [[ [122,33],[123,33],[122.5,34],[122,33] ]]
  192.      * ]
  193.      * MULTIPOLYGON((
  194.      *                  (0 0 1,20 0 1,20 20 1,0 20 1,0 0 1),
  195.      *                  (5 5 3,5 7 3,7 7 3,7 5 3,5 5 3)
  196.      *             ))
  197.      */
  198.     private static MultiPolygon getMultiPolygon(List<Object> coordinates,int srid) throws ParseException {
  199.         StringBuilder str = new StringBuilder();
  200.         str.append("MULTIPOLYGON((");
  201.         List<Double> coordinate;
  202.         for(Object obj1 : coordinates){
  203.             for(Object obj2 :(List<Object>)obj1){
  204.                 str.append("(");
  205.                 for(Object obj3 : (List<Object>)obj2){
  206.                     coordinate = (List<Double>) obj3;
  207.                     str.append(coordinate.get(0)).append(" ").append(coordinate.get(1)).append(",");
  208.                 }
  209.                 str.deleteCharAt(str.length() - 1).append("),");
  210.             }
  211.         }
  212.         str.deleteCharAt(str.length() - 1).append("))");
  213.         MultiPolygon multiPolygon = (MultiPolygon) new WKTReader().read(str.toString());
  214.         multiPolygon.setSRID(srid);
  215.         return multiPolygon;
  216.     }
  219.     private static GeoJson getProperties(Map<String, Object> properties) {
  220.         GeoJson geoJson = new GeoJson();
  221.         if(properties == null){
  222.             return geoJson;
  223.         }
  224.         geoJson.setName(properties.getOrDefault("name","").toString());
  225.         return geoJson;
  226.     }
  228.     @Data
  229.     public static class GeoJson{
  230.         private Geometry geom;
  231.         private String name;
  232.     }
  235.         public static void main(String[] args) throws Exception {
  236.         String geoPoint = "{\"type\": \"FeatureCollection\"," +
  237.                 "\"features\": [{" +
  238.                 "\"type\": \"Feature\"," +
  239.                 "\"geometry\": {\"type\": \"Point\"," +
  240.                 "\"coordinates\": [119,34]}," +
  241.                 "\"properties\": null" +
  242.                 "}]" +
  243.                 "}";
  244.         String geoLineString = "{\"type\": \"FeatureCollection\"," +
  245.                 "\"features\": [{" +
  246.                 "\"type\": \"Feature\"," +
  247.                 "\"geometry\": {\"type\": \"LineString\"," +
  248.                 "\"coordinates\": [[119.001,34.001],[120.001,35.001]]}," +
  249.                 "\"properties\":{\"name\":\"names\"}" +
  250.                 "}]" +
  251.                 "}";
  252.         String geoPolygon = "{\"type\":\"FeatureCollection\"," +
  253.                 "\"features\":[{" +
  254.                 "\"type\":\"Feature\"," +
  255.                 "\"geometry\":{\"type\":\"Polygon\"," +
  256.                 "\"coordinates\":[[ [122.19794471743876,30.241048024596722],[122.19349009648414,30.235207526854044]," +
  257.                 "[122.20655698914918,30.23401962566707],[122.19794471743876,30.241048024596722] ]]}," +
  258.                 "\"properties\":{\"name\":\"names\"}" +
  259.                 "}]" +
  260.                 "}";
  261.         String geoMultiPoint = "{\"type\": \"FeatureCollection\"," +
  262.                 "\"features\": [{" +
  263.                 "\"type\": \"Feature\"," +
  264.                 "\"geometry\": { \"type\": \"MultiPoint\"," +
  265.                 "\"coordinates\": [[122.19794471743876,30.241048024596722],[122,30]]}," +
  266.                 "\"properties\": null" +
  267.                 "}]" +
  268.                 "}";
  269.         String geoMultiLineString = "{\"type\":\"FeatureCollection\"," +
  270.                 "\"features\":[{" +
  271.                 "\"type\":\"Feature\"," +
  272.                 "\"geometry\":{\"type\":\"MultiLineString\"," +
  273.                 "\"coordinates\":[[[119,35],[120,35]],[[119,34],[122,34]]]}," +
  274.                 "\"properties\":null" +
  275.                 "}]" +
  276.                 "}";
  277.         String geoMultiPolygon = "{\"type\":\"FeatureCollection\"," +
  278.                 "\"features\":[{" +
  279.                 "\"type\":\"Feature\"," +
  280.                 "\"geometry\":{\"type\":\"MultiPolygon\"," +
  281.                 "\"coordinates\":[" +
  282.                 "[[ [122,30],[123,30],[122,31],[122,30] ]]," +
  283.                 "[[ [122,33],[123,33],[122.5,34],[122,33] ]]" +
  284.                 "]" +
  285.                 "}," +
  286.                 "\"properties\":{\"id\":\"10\"}" +
  287.                 "}]" +
  288.                 "}";
  290.         GeoJson geoJson = getGeometryByGeoJson(geoLineString,"Polygon,LineString",4326);
  291.         System.out.println(geoJson.getGeom());
  292.     }
  294. }

2、多类型转换

geojson 文件中有几个 Feature 就转换出多少 Geometry

  1. package com.zjic.common.utils;
  3. import com.fasterxml.jackson.core.JsonProcessingException;
  4. import lombok.Data;
  5. import org.locationtech.jts.geom.*;
  6. import org.locationtech.jts.io.ParseException;
  7. import org.locationtech.jts.io.WKTReader;
  9. import java.util.ArrayList;
  10. import java.util.HashMap;
  11. import java.util.List;
  12. import java.util.Map;
  14. /**
  15.  * Created on 2021/9/10--20:08.
  16.  *
  17.  * @author fengyuhao
  18.  * @Description GeoJson 转 Geometry, 仅支持读取 properties 中的 "name" 属性
  19.  */
  20. public class GeoJsonToGeometry {
  22.     private static final int SRID = 4326;
  23.     private static final String TYPES = "Point,LineString,Polygon,MultiPoint,MultiLineString,MultiPolygon";
  25.     /**
  26.      * 将 GeoJson 转换为对应的 Geometry 类型,默认 srid = 4326
  27.      * @param geoJson       geoJson
  28.      * @param type          geoJson 类型
  29.      */
  30.     public static List<GeoJson> getGeometryByGeoJson(String geoJson,String type) throws Exception {
  31.         return getGeometryByGeoJson(geoJson,type,SRID);
  32.     }
  34.     /**
  35.      * 支持转换所有类型，将 GeoJson 转换为对应的 Geometry 类型,默认 srid = 4326
  36.      * @param geoJson           geoJson
  37.      */
  38.     public static List<GeoJson> getGeometryByGeoJson(String geoJson) throws Exception {
  39.         return getGeometryByGeoJson(geoJson,TYPES,SRID);
  40.     }
  42.     /**
  43.      * 支持转换所有类型，将 GeoJson 转换为对应的 Geometry 类型
  44.      * @param geoJson           geoJson
  45.      * @param srid              srid
  46.      */
  47.     public static List<GeoJson> getGeometryByGeoJson(String geoJson,int srid) throws Exception {
  48.         return getGeometryByGeoJson(geoJson,TYPES,srid);
  49.     }
  51.     /**
  52.      * 将 GeoJson 转换为对应的 Geometry 类型
  53.      * @param geoJson       geoJson
  54.      * @param srid          SRID
  55.      */
  56.     public static List<GeoJson> getGeometryByGeoJson(String geoJson,String type,int srid) throws Exception {
  57.         List<Map<String, Object>> list;
  58.         try {
  59.             list = (List<Map<String, Object>>) CommonUtil.OBJECT_MAPPER.readValue(geoJson, Map.class).get("features");
  60.         } catch (JsonProcessingException e) {
  61.             throw new Exception("Json 转换异常");
  62.         }
  63.         if (list == null) {
  64.             throw new Exception("Json 转换异常");
  65.         }
  66.         List<GeoJson> res = new ArrayList<>(list.size()+1);
  67.         for(Map<String, Object> data : list){
  68.             // 获取属性信息
  69.             Map<String, Object> properties = (Map<String, Object>)data.getOrDefault("properties",new HashMap<>());
  70.             GeoJson geo = getProperties(properties);
  71.             // 获取 geometry
  72.             Map<String, Object> geometry = (Map<String, Object>)data.get("geometry");
  73.             if(!type.toUpperCase().contains(geometry.get("type").toString().toUpperCase())){
  74.                 throw new Exception("Geometry 类型错误：期望的类型为"+type);
  75.             }
  76.             switch (geometry.get("type").toString().toUpperCase()) {
  77.                 case "POINT":
  78.                     geo.setGeom(getPoint((List<Double>) geometry.get("coordinates"),srid));
  79.                     break;
  80.                 case "LINESTRING":
  81.                     geo.setGeom(getLineString((List<Object>) geometry.get("coordinates"),srid));
  82.                     break;
  83.                 case "POLYGON":
  84.                     geo.setGeom(getPolygon((List<Object>) geometry.get("coordinates"),srid));
  85.                     break;
  86.                 case "MULTIPOINT":
  87.                     geo.setGeom(getMultiPoint((List<Object>) geometry.get("coordinates"),srid));
  88.                     break;
  89.                 case "MULTILINESTRING":
  90.                     geo.setGeom(getMultiLineString((List<Object>) geometry.get("coordinates"),srid));
  91.                     break;
  92.                 case "MULTIPOLYGON":
  93.                     geo.setGeom(getMultiPolygon((List<Object>) geometry.get("coordinates"),srid));
  94.                     break;
  95.                 default:
  96.                     throw new Exception("不支持的 Geometry 类型");
  97.             }
  98.             res.add(geo);
  99.         }
  100.         return res;
  101.     }
  103.     /**
  104.      * [[
  105.      *    [122.19794471743876,30.241048024596722],[122.19349009648414,30.235207526854044],
  106.      *    [122.20655698914918,30.23401962566707],[122.19794471743876,30.241048024596722]
  107.      * ]]
  108.      * POLYGON((-71.1776585052917 42.3902909739571,-71.1776820268866 42.3903701743239,
  109.      *         -71.1775826583081 42.3903033653531,-71.1776585052917 42.3902909739571))
  110.      */
  111.     private static Polygon getPolygon(List<Object> coordinates,int srid) throws ParseException {
  112.         coordinates = (List<Object>)coordinates.get(0);
  113.         StringBuilder str = new StringBuilder();
  114.         str.append("POLYGON((");
  115.         List<Double> coordinate;
  116.         for(Object obj : coordinates){
  117.             coordinate = (List<Double>) obj;
  118.             str.append(coordinate.get(0)).append(" ").append(coordinate.get(1)).append(",");
  119.         }
  120.         str.deleteCharAt(str.length() - 1).append("))");
  122.         Polygon polygon = (Polygon) new WKTReader().read(str.toString());
  123.         polygon.setSRID(srid);
  124.         return polygon;
  125.     }
  127.     /**
  128.      * [[119.001,34.001],[120.001,35.001]]
  129.      * LINESTRING(1 2, 3 4)
  130.      */
  131.     private static LineString getLineString(List<Object> coordinates,int srid) throws ParseException {
  132.         StringBuilder str = new StringBuilder();
  133.         List<Double> coordinate;
  134.         str.append("LINESTRING(");
  135.         for(Object obj : coordinates){
  136.             coordinate = (List<Double>) obj;
  137.             str.append(coordinate.get(0)).append(" ").append(coordinate.get(1)).append(",");
  138.         }
  139.         str.deleteCharAt(str.length() - 1).append(")");
  140.         LineString lineString = (LineString) new WKTReader().read(str.toString());
  141.         lineString.setSRID(srid);
  142.         return lineString;
  143.     }
  145.     /**
  146.      * [119,34]
  147.      * POINT(1 2)
  148.      */
  149.     private static Point getPoint(List<Double> coordinates,int srid) throws ParseException {
  150.         Point point = (Point) new WKTReader().read("POINT("+coordinates.get(0)+" "+coordinates.get(1)+")");
  151.         point.setSRID(srid);
  152.         return point;
  153.     }
  155.     /**
  156.      * [ [122.19794471743876,30.241048024596722],[122,30] ]
  157.      * MULTIPOINT(1 2, 3 4)
  158.      */
  159.     private static MultiPoint getMultiPoint(List<Object> coordinates,int srid) throws ParseException {
  160.         StringBuilder str = new StringBuilder();
  161.         List<Double> coordinate;
  162.         str.append("MultiPoint(");
  163.         for(Object obj : coordinates){
  164.             coordinate = (List<Double>) obj;
  165.             str.append(coordinate.get(0)).append(" ").append(coordinate.get(1)).append(",");
  166.         }
  167.         str.deleteCharAt(str.length() - 1).append(")");
  168.         MultiPoint multiPoint = (MultiPoint) new WKTReader().read(str.toString());
  169.         multiPoint.setSRID(srid);
  170.         return multiPoint;
  171.     }
  173.     /**
  174.      * [
  175.      *  [[119,35],[120,35]],
  176.      *  [[119,34],[122,34]]
  177.      * ]
  178.      * MULTILINESTRING((1 2, 3 4), (4 5, 6 7))
  179.      */
  180.     private static MultiLineString getMultiLineString(List<Object> coordinates,int srid) throws ParseException {
  181.         StringBuilder str = new StringBuilder();
  182.         str.append("MULTILINESTRING(");
  183.         List<Double> coordinate;
  184.         for(Object obj : coordinates){
  185.             str.append("(");
  186.             for(Object data : (List<Object>)obj){
  187.                 coordinate = (List<Double>) data;
  188.                 str.append(coordinate.get(0)).append(" ").append(coordinate.get(1)).append(",");
  189.             }
  190.             str.deleteCharAt(str.length() - 1).append("),");
  191.         }
  192.         str.deleteCharAt(str.length() -1).append(")");
  193.         MultiLineString multiLineString = (MultiLineString) new WKTReader().read(str.toString());
  194.         multiLineString.setSRID(srid);
  195.         return multiLineString;
  196.     }
  198.     /**
  199.      * [
  200.      *    [[ [122,30],[123,30],[122,31],[122,30] ]],
  201.      *    [[ [122,33],[123,33],[122.5,34],[122,33] ]]
  202.      * ]
  203.      * MULTIPOLYGON((
  204.      *                  (0 0 1,20 0 1,20 20 1,0 20 1,0 0 1),
  205.      *                  (5 5 3,5 7 3,7 7 3,7 5 3,5 5 3)
  206.      *             ))
  207.      */
  208.     private static MultiPolygon getMultiPolygon(List<Object> coordinates,int srid) throws ParseException {
  209.         StringBuilder str = new StringBuilder();
  210.         str.append("MULTIPOLYGON((");
  211.         List<Double> coordinate;
  212.         for(Object obj1 : coordinates){
  213.             for(Object obj2 :(List<Object>)obj1){
  214.                 str.append("(");
  215.                 for(Object obj3 : (List<Object>)obj2){
  216.                     coordinate = (List<Double>) obj3;
  217.                     str.append(coordinate.get(0)).append(" ").append(coordinate.get(1)).append(",");
  218.                 }
  219.                 str.deleteCharAt(str.length() - 1).append("),");
  220.             }
  221.         }
  222.         str.deleteCharAt(str.length() - 1).append("))");
  223.         MultiPolygon multiPolygon = (MultiPolygon) new WKTReader().read(str.toString());
  224.         multiPolygon.setSRID(srid);
  225.         return multiPolygon;
  226.     }
  229.     private static GeoJson getProperties(Map<String, Object> properties) {
  230.         GeoJson geoJson = new GeoJson();
  231.         if(properties == null){
  232.             return geoJson;
  233.         }
  234.         geoJson.setName(properties.getOrDefault("name","").toString());
  235.         return geoJson;
  236.     }
  238.     @Data
  239.     public static class GeoJson{
  240.         private Geometry geom;
  241.         private String name;
  242.     }
  245.     public static void main(String[] args) throws Exception {
  246. //        String geoPoint = "{\"type\": \"FeatureCollection\"," +
  247. //                "\"features\": [{" +
  248. //                "\"type\": \"Feature\"," +
  249. //                "\"geometry\": {\"type\": \"Point\"," +
  250. //                "\"coordinates\": [119,34]}," +
  251. //                "\"properties\": null" +
  252. //                "}]" +
  253. //                "}";
  254.         String geoPoints = "{ \"type\": \"FeatureCollection\", \"features\": [ { \"type\": \"Feature\", \"geometry\": { \"type\": \"Point\", \"coordinates\": [ 120.915783542, 30.882011484 ] }, \"properties\": { \"name\": \"魏塘站\", \"gid\": 1 } }, { \"type\": \"Feature\", \"geometry\": { \"type\": \"Point\", \"coordinates\": [ 120.989985292, 30.952577374 ] }, \"properties\": { \"name\": \"红旗塘站\", \"gid\": 2 } }, { \"type\": \"Feature\", \"geometry\": { \"type\": \"Point\", \"coordinates\": [ 120.835532968, 30.997386357 ] }, \"properties\": { \"name\": \"下甸庙站\", \"gid\": 3 } }, { \"type\": \"Feature\", \"geometry\": { \"type\": \"Point\", \"coordinates\": [ 120.954403108, 31.019139073 ] }, \"properties\": { \"name\": \"太浦河站\", \"gid\": 4 } } ] }";
  255.         String geoLineString = "{\"type\": \"FeatureCollection\"," +
  256.                 "\"features\": [{" +
  257.                 "\"type\": \"Feature\"," +
  258.                 "\"geometry\": {\"type\": \"LineString\"," +
  259.                 "\"coordinates\": [[119.001,34.001],[120.001,35.001]]}," +
  260.                 "\"properties\":{\"name\":\"names\"}" +
  261.                 "}]" +
  262.                 "}";
  263.         String geoPolygon = "{\"type\":\"FeatureCollection\"," +
  264.                 "\"features\":[{" +
  265.                 "\"type\":\"Feature\"," +
  266.                 "\"geometry\":{\"type\":\"Polygon\"," +
  267.                 "\"coordinates\":[[ [122.19794471743876,30.241048024596722],[122.19349009648414,30.235207526854044]," +
  268.                 "[122.20655698914918,30.23401962566707],[122.19794471743876,30.241048024596722] ]]}," +
  269.                 "\"properties\":{\"name\":\"names\"}" +
  270.                 "}]" +
  271.                 "}";
  272.         String geoMultiPoint = "{\"type\": \"FeatureCollection\"," +
  273.                 "\"features\": [{" +
  274.                 "\"type\": \"Feature\"," +
  275.                 "\"geometry\": { \"type\": \"MultiPoint\"," +
  276.                 "\"coordinates\": [[122.19794471743876,30.241048024596722],[122,30]]}," +
  277.                 "\"properties\": null" +
  278.                 "}]" +
  279.                 "}";
  280.         String geoMultiLineString = "{\"type\":\"FeatureCollection\"," +
  281.                 "\"features\":[{" +
  282.                 "\"type\":\"Feature\"," +
  283.                 "\"geometry\":{\"type\":\"MultiLineString\"," +
  284.                 "\"coordinates\":[[[119,35],[120,35]],[[119,34],[122,34]]]}," +
  285.                 "\"properties\":null" +
  286.                 "}]" +
  287.                 "}";
  288.         String geoMultiPolygon = "{\"type\":\"FeatureCollection\"," +
  289.                 "\"features\":[{" +
  290.                 "\"type\":\"Feature\"," +
  291.                 "\"geometry\":{\"type\":\"MultiPolygon\"," +
  292.                 "\"coordinates\":[" +
  293.                 "[[ [122,30],[123,30],[122,31],[122,30] ]]," +
  294.                 "[[ [122,33],[123,33],[122.5,34],[122,33] ]]" +
  295.                 "]" +
  296.                 "}," +
  297.                 "\"properties\":{\"id\":\"10\"}" +
  298.                 "}]" +
  299.                 "}";
  301.         List<GeoJson> geoJson = getGeometryByGeoJson(geoPoints,"MultiPolygon",4326);
  302.         System.out.println(geoJson);
  303.     }
  304. }