GeoTools is used to convert GeoJSON to Shp

The complete code for this feature is as follows:

/** * Save features to SHP format **@paramFeatures *@paramTYPE Element TYPE *@paramShpPath SHP save path *@returnWhether the file is saved successfully */
public static boolean saveFeaturesToShp(List<SimpleFeature> features, SimpleFeatureType TYPE, String shpPath) {
    try {
        ShapefileDataStoreFactory dataStoreFactory = new ShapefileDataStoreFactory();
        File shpFile = new File(shpPath);
        Map<String, Serializable> params = new HashMap<>();
        params.put("url", shpFile.toURI().toURL());
        params.put("create spatial index", Boolean.TRUE);

        ShapefileDataStore newDataStore =
                (ShapefileDataStore) dataStoreFactory.createNewDataStore(params);
        newDataStore.setCharset(StandardCharsets.UTF_8);

        newDataStore.createSchema(TYPE);

        Transaction transaction = new DefaultTransaction("create");
        String typeName = newDataStore.getTypeNames()[0];
        SimpleFeatureSource featureSource = newDataStore.getFeatureSource(typeName);

        if (featureSource instanceof SimpleFeatureStore) {
            SimpleFeatureStore featureStore = (SimpleFeatureStore) featureSource;
            SimpleFeatureCollection collection = new ListFeatureCollection(TYPE, features);
            featureStore.setTransaction(transaction);
            try {
                featureStore.addFeatures(collection);
                FileUtil.generateCpgFile(shpPath, StandardCharsets.UTF_8);
                transaction.commit();
            } catch (Exception problem) {
                problem.printStackTrace();
                transaction.rollback();
            } finally{ transaction.close(); }}else {
            System.out.println(typeName + " does not support read/write access"); }}catch (IOException e) {
        return false;
    }
    return true;
}

/**
 * GeoJson to Shp
 *
 * @paramGeojsonPath Path to the geoJSON file *@paramShpPath SHP file path *@returnWhether the conversion was successful */
public static boolean transformGeoJsonToShp(String geojsonPath, String shpPath) {
    try {
        // open geojson
        InputStream in = new FileInputStream(geojsonPath);
        GeometryJSON gjson = new GeometryJSON();
        FeatureJSON fjson = new FeatureJSON(gjson);
        FeatureCollection<SimpleFeatureType, SimpleFeature> features = fjson.readFeatureCollection(in);
        // convert schema for shapefile
        SimpleFeatureType schema = features.getSchema();
        GeometryDescriptor geom = schema.getGeometryDescriptor();
        // Geojson file properties
        List<AttributeDescriptor> attributes = schema.getAttributeDescriptors();
        // Geojson file space type (must be first)
        GeometryType geomType = null;
        List<AttributeDescriptor> attribs = new ArrayList<>();
        for (AttributeDescriptor attrib : attributes) {
            AttributeType type = attrib.getType();
            if (type instanceof GeometryType) {
                geomType = (GeometryType) type;
            } else{ attribs.add(attrib); }}if (geomType == null)
            return false;

        // Create GT using geomType
        GeometryTypeImpl gt = new GeometryTypeImpl(new NameImpl("the_geom"), geomType.getBinding(),
                geom.getCoordinateReferenceSystem() == null ? DefaultGeographicCRS.WGS84 : geom.getCoordinateReferenceSystem(), // If no user is specified, the default value is wGS84
                geomType.isIdentified(), geomType.isAbstract(), geomType.getRestrictions(),
                geomType.getSuper(), geomType.getDescription());

        // Create an identifier
        GeometryDescriptor geomDesc = new GeometryDescriptorImpl(gt, new NameImpl("the_geom"), geom.getMinOccurs(),
                geom.getMaxOccurs(), geom.isNillable(), geom.getDefaultValue());

        // The the_geom attribute must be the first
        attribs.add(0, geomDesc);

        SimpleFeatureType outSchema = new SimpleFeatureTypeImpl(schema.getName(), attribs, geomDesc, schema.isAbstract(),
                schema.getRestrictions(), schema.getSuper(), schema.getDescription());
        List<SimpleFeature> outFeatures = new ArrayList<>();
        try (FeatureIterator<SimpleFeature> features2 = features.features()) {
            while (features2.hasNext()) {
                SimpleFeature f = features2.next();
                SimpleFeature reType = DataUtilities.reType(outSchema, f, true); reType.setAttribute(outSchema.getGeometryDescriptor().getName(), f.getAttribute(schema.getGeometryDescriptor().getName())); outFeatures.add(reType); }}return saveFeaturesToShp(outFeatures, outSchema, shpPath);
    } catch (IOException e) {
        e.printStackTrace();
        return false; }}Copy the code

Shp To GeoJSON

GeoTools has many tutorials on shapefiles and is well supported and relatively simple, but it should be noted that converting shapefiles to GEOJSON should generate CRS. The conversion code is as follows:

public static boolean transformShpToGeoJson(String shpPath, String geojsonPath) {
    try {
        File file = new File(shpPath);
        FileDataStore myData = FileDataStoreFinder.getDataStore(file);
        // Set the decoding mode
        ((ShapefileDataStore) myData).setCharset(StandardCharsets.UTF_8);
        SimpleFeatureSource source = myData.getFeatureSource();
        SimpleFeatureType schema = source.getSchema();
        Query query = new Query(schema.getTypeName());

        FeatureCollection<SimpleFeatureType, SimpleFeature> collection = source.getFeatures(query);
        FeatureJSON fjson = new FeatureJSON();
        File geojson = new File(geojsonPath);
        try (FeatureIterator<SimpleFeature> featureIterator = collection.features();
             StringWriter writer = new StringWriter();
             BufferedWriter buffer = new BufferedWriter(Files.newBufferedWriter(geojson.toPath(), StandardCharsets.UTF_8))) {
            writer.write("{\"type\":\"FeatureCollection\",\"crs\":");
            fjson.writeCRS(schema.getCoordinateReferenceSystem(), writer);
            writer.write(",");
            writer.write("\"features\":");
            writer.write("[");
            while (featureIterator.hasNext()) {
                SimpleFeature feature = featureIterator.next();
                fjson.writeFeature(feature, writer);
                if (featureIterator.hasNext())
                    writer.write(",");
            }
            writer.write("]");
            writer.write("}");
            buffer.write(writer.toString());
            return true;
        } catch (IOException e) {
            return false; }}catch (IOException e) {
        return false; }}Copy the code

Afterword.

Conversion of GeoJSON to Shapefile was a very common problem with GISer, and the software HE developed, POIKit, provided this functionality. Currently, geoJSON is converted to SHP, and SHP is converted to GeoJSON/CSV.

code

You can find my Spatial Format conversion utility class here.