java使用GeoTools读取shp文件并画图

你的名字 2022-10-11 13:41 184阅读 0赞

GeoTools是ArcGis地图与java对象的桥梁，恰如jdbc之于oracle与java。  
shp文件本身是存有地理对象边界坐标、对象中心城市及城市编号的多多边形字符串。  
需要使用的依赖如下

<dependency>
                <groupId>org.geotools</groupId>
                <artifactId>gt-shapefile</artifactId>
                <version>${geotools.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.geotools</groupId>
                <artifactId>gt-swing</artifactId>
                <version>${geotools.version}</version>
            </dependency>
            
            <dependency>
                <groupId>dom4j</groupId>
                <artifactId>dom4j</artifactId>
                <version>1.6.1</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.47</version>
            </dependency>

对象：

public class CutProperty { 
    
        private String province;
        private int x;
        private int y;
    
        /** * 图片宽 * */
        private int width;
    
        /** * 图片高 * */
        private int height;
    
        /** * 画图时线条粗细 * */
        private float weight;
    
        /** * 地图坐标右边界 * */
        private int rightborder;
    
        /** * 地图坐标放大倍数 * */
        private int bei;
    
        /** * 文字大小 * */
        private int stringsize;

来自@author yukun24@126.com的工具类，读取shp文件：

package com.gwhn.geotools;
    
    import org.geotools.data.FeatureWriter;
    import org.geotools.data.FileDataStoreFactorySpi;
    import org.geotools.data.Transaction;
    import org.geotools.data.shapefile.ShapefileDataStore;
    import org.geotools.data.shapefile.ShapefileDataStoreFactory;
    import org.geotools.data.simple.SimpleFeatureIterator;
    import org.geotools.data.simple.SimpleFeatureSource;
    import org.geotools.feature.FeatureCollection;
    import org.geotools.feature.simple.SimpleFeatureTypeBuilder;
    import org.geotools.referencing.crs.DefaultGeographicCRS;
    import org.junit.Test;
    import org.locationtech.jts.geom.*;
    import org.opengis.feature.Property;
    import org.opengis.feature.simple.SimpleFeature;
    import org.opengis.feature.simple.SimpleFeatureType;
    
    import java.io.File;
    import java.io.Serializable;
    import java.nio.charset.Charset;
    import java.util.*;
    
    public class ShapeUtil { 
    
        //读shp文件【几何信息+属性信息】
        public List<Property> SHPRead(String path) throws Exception { 
            List<Property> propertyList = new ArrayList<>();
            //基于上面新建的shapfile文件，进行读取
    
            //构建shapefile数据存储的实例
            ShapefileDataStoreFactory dataStoreFactory = new ShapefileDataStoreFactory();
    
            //基于路径构建文件对象
            File file = new File(path);
    
            //构建一个已存在的shapfile数据源
            //ShapefileDataStore:数据存储实现，允许从Shapefiles读取和写入
            ShapefileDataStore ds = (ShapefileDataStore) dataStoreFactory.createDataStore(file.toURI().toURL());
    
            //设置编码，防止中文读取乱码
            ds.setCharset(Charset.forName("UTF-8"));
    
            //getFeatureSource():ContentFeatureSource
            //这个特性是由 FeatureCollection提供的操作完成的。单独的特征记忆实现由子类提供:
            //SimpleFeatureSource特征资源明确地使用FeatureCollection【集合】，可迭代
            SimpleFeatureSource featureSource = ds.getFeatureSource();
    
            //getFeatures():以FeatureCollection的形式检索所有特性。
            //一个用于处理FeatureCollection的实用工具类。提供一个获取FeatureCollection实例的机制
            FeatureCollection<SimpleFeatureType, SimpleFeature> result = featureSource.getFeatures();
    
            System.out.println("几何对象总共有：" + result.size());
            //features():返回一个FeatureIterator迭代器
            SimpleFeatureIterator it = (SimpleFeatureIterator) result.features();
    
            while (it.hasNext()) { 
                SimpleFeature feature = it.next();
                //迭代属性【属性我们可以理解为一个几何对象的属性节点，也就是对一个几何图形的描述字段】
                Iterator<Property> ip = feature.getProperties().iterator();
    // System.out.println("========================");
                //再来个while
                while (ip.hasNext()) { 
                    Property pro = ip.next();
    // System.out.println(pro.getName()+" = "+pro.getValue());
                    propertyList.add(pro);
                }//end 属性迭代
            }
            it.close();
            return propertyList;
        }
       
    }

来自@author yukun24@126.com的工具类，此处用来将shp中获取的字符串转化为多多边形对象MultiPolygon

package com.gwhn.geotools;
    
    
    import org.locationtech.jts.geom.*;
    import org.locationtech.jts.io.ParseException;
    import org.locationtech.jts.io.WKTReader;
    
    import java.util.List;
    
    /** * 几何对象构建器 * * @author yukun24@126.com * @version V1.0.1 * @blob http://blog.csdn.net/appleyk * @date 2017年12月8日10:38:49 */
    
    //单例模式
    public class GeometryCreator { 
    
        public static GeometryCreator geometryCreator = null;
    
        private GeometryFactory geometryFactory = new GeometryFactory();
    
        public GeometryCreator() { 
        }
    
        /** * 返回本类的唯一实例 * * @return */
        public static GeometryCreator getInstance() { 
            if (geometryCreator == null) { 
                return new GeometryCreator();
            }
            return geometryCreator;
        }
    
    
        /** * 1.构建点 */
    
        /** * 1.1根据X，Y坐标构建一个几何对象： 点 【Point】 * * @param x * @param y * @return */
        public Point createPoint(double x, double y) { 
            Coordinate coord = new Coordinate(x, y);
            Point point = geometryFactory.createPoint(coord);
            return point;
        }
    
        /** * 1.2根据几何对象的WKT描述【String】创建几何对象： 点 【Point】 * * @return * @throws ParseException */
        public Point createPointByWKT(String PointWKT) throws ParseException { 
            WKTReader reader = new WKTReader(geometryFactory);
            Point point = (Point) reader.read(PointWKT);
            return point;
        }
    
        /** * 1.3根据几何对象的WKT描述【String】创建几何对象：多点 【MultiPoint】 * * @return * @throws ParseException */
        public MultiPoint createMulPointByWKT(String MPointWKT) throws ParseException { 
            WKTReader reader = new WKTReader(geometryFactory);
            MultiPoint mpoint = (MultiPoint) reader.read(MPointWKT);
            return mpoint;
        }
    
    
        /** * 2.构建线 */
    
    
        /** * 2.1根据两点 创建几何对象：线 【LineString】 * * @param ax * @param ay * @param bx * @param by * @return */
        public LineString createLine(double ax, double ay, double bx, double by) { 
            Coordinate[] coords = new Coordinate[]{ new Coordinate(ax, ay), new Coordinate(bx, by)};
            LineString line = geometryFactory.createLineString(coords);
            return line;
        }
    
        /** * 2.2根据线的WKT描述创建几何对象：线 【LineString】 * * @param LineStringWKT * @return * @throws ParseException */
        public LineString createLineByWKT(String LineStringWKT) throws ParseException { 
            WKTReader reader = new WKTReader(geometryFactory);
            LineString line = (LineString) reader.read("LINESTRING(0 0, 2 0)");
            return line;
        }
    
        /** * 2.3根据点组合的线数组，创建几何对象：多线 【MultiLineString】 * * @param list * @return */
        public MultiLineString createMLine(List<Coordinate[]> list) { 
    
            MultiLineString ms = null;
    
    
            if (list == null) { 
                return ms;
            }
    
            LineString[] lineStrings = new LineString[list.size()];
    
    
    // Coordinate[] coords1 = new Coordinate[] {new Coordinate(2, 2), new Coordinate(2, 2)}; 
    // LineString line1 = geometryFactory.createLineString(coords1); 
    // 
    // Coordinate[] coords2 = new Coordinate[] {new Coordinate(2, 2), new Coordinate(2, 2)}; 
    // LineString line2 = geometryFactory.createLineString(coords2); 
    
            int i = 0;
            for (Coordinate[] coordinates : list) { 
                lineStrings[i] = geometryFactory.createLineString(coordinates);
            }
    
            ms = geometryFactory.createMultiLineString(lineStrings);
    
            return ms;
        }
    
    
        /** * 2.4根据几何对象的WKT描述【String】创建几何对象 ： 多线【MultiLineString】 * * @param MLineStringWKT * @return * @throws ParseException */
        public MultiLineString createMLineByWKT(String MLineStringWKT) throws ParseException { 
            WKTReader reader = new WKTReader(geometryFactory);
            MultiLineString line = (MultiLineString) reader.read(MLineStringWKT);
            return line;
        }
    
    
        /** * 3.构建多边形 */
    
    
        /** * 3.1 根据几何对象的WKT描述【String】创建几何对象：多边形 【Polygon】 * * @param PolygonWKT * @return * @throws ParseException */
        public Polygon createPolygonByWKT(String PolygonWKT) throws ParseException { 
            WKTReader reader = new WKTReader(geometryFactory);
            Polygon polygon = (Polygon) reader.read(PolygonWKT);
            return polygon;
        }
    
        /** * 3.2 根据几何对象的WKT描述【String】创建几何对象： 多多边形 【MultiPolygon】 * * @param MPolygonWKT * @return * @throws ParseException */
        public MultiPolygon createMulPolygonByWKT(String MPolygonWKT) throws ParseException { 
            WKTReader reader = new WKTReader(geometryFactory);
            MultiPolygon mpolygon = (MultiPolygon) reader.read(MPolygonWKT);
            return mpolygon;
        }
    
        /** * 根据多边形数组 进行多多边形的创建 * * @param polygons * @return * @throws ParseException */
        public MultiPolygon createMulPolygonByPolygon(Polygon[] polygons) throws ParseException { 
    
            return geometryFactory.createMultiPolygon(polygons);
        }
    
        /** * 4.构建几何对象集合 */
    
    
        /** * 4.1 根据几何对象数组，创建几何对象集合：【GeometryCollection】 * * @return * @throws ParseException */
        public GeometryCollection createGeoCollect(Geometry[] geoArray) throws ParseException { 
    // LineString line = createLine(125.12,25.4,85.63,99.99); 
    // Polygon poly = createPolygonByWKT("POLYGON((20 10, 30 0, 40 10, 30 20, 20 10))"); 
    // Geometry g1 = geometryFactory.createGeometry(line); 
    // Geometry g2 = geometryFactory.createGeometry(poly); 
    // Geometry[] geoArray = new Geometry[]{g1,g2}; 
            GeometryCollection gc = geometryFactory.createGeometryCollection(geoArray);
            return gc;
        }
    
    
        /** * 5.构建圆 */
    
        /** * 5.1 根据圆点以及半径创建几何对象：特殊的多边形--圆 【Polygon】 * * @param x * @param y * @param RADIUS * @return */
        public Polygon createCircle(double x, double y, final double RADIUS) { 
    
            final int SIDES = 32;//圆上面的点个数
    
            Coordinate coords[] = new Coordinate[SIDES + 1];
            for (int i = 0; i < SIDES; i++) { 
                double angle = ((double) i / (double) SIDES) * Math.PI * 2.0;
                double dx = Math.cos(angle) * RADIUS;
                double dy = Math.sin(angle) * RADIUS;
                coords[i] = new Coordinate((double) x + dx, (double) y + dy);
            }
            coords[SIDES] = coords[0];
            //线性环
            LinearRing ring = geometryFactory.createLinearRing(coords);
            Polygon polygon = geometryFactory.createPolygon(ring, null);
            return polygon;
        }
    
    
        /** * 6.构建环 */
    
        /** * 6.1 根据WKT创建环 * * @param ringWKT * @return * @throws ParseException */
        public LinearRing createLinearRingByWKT(String ringWKT) throws ParseException { 
            WKTReader reader = new WKTReader(geometryFactory);
            LinearRing ring = (LinearRing) reader.read(ringWKT);
            return ring;
        }
    
    }

有xml如下：

<?xml version="1.0" encoding="UTF-8"?>
    <application>
        
        <module name="Http">
    
            <group name="FileExport">
                <configValue key="ShapePath">D:/testspace/spd/rain/</configValue>
                <configValue key="ProvinceShapePath">D:/testspace/spd/Provinces_shp/</configValue>
                <configValue key="ProvincePath">D:\testspace\spd\output\</configValue>
                <configValue key="ExportPath">D:\testspace\spd\Export\</configValue>
                <configValue key="PropertyPath">D:\testspace\spd\Export\</configValue>
            </group>
            
        </module>
    </application>

xml读取以获取shp文件位置和图片输出位置：

package com.gwhn.Util;
    
    import org.dom4j.Attribute;
    import org.dom4j.Document;
    import org.dom4j.Element;
    import org.dom4j.Text;
    import org.dom4j.io.SAXReader;
    
    import java.io.File;
    import java.util.Iterator;
    
    /** * @author banxian * @date 2021/1/21 15:56 */
    public class YereeXmlContext { 
    
        /** * 根据一二三级字节点的key，迭代到第三级节点根据三级key获取值 *  * <module name="Http"> * <group name="FileUpload"> * <configValue key="TempDir">D:\\temp\\upload\\</configValue> * </group> * </module> * * @param key1 * @param key2 * @param key3 * @return * @author banxian * @date: 2021/1/21 19:51 */
        public String getXmlValue(String key1, String key2, String key3) { 
            try { 
                //1.创建Reader对象
                SAXReader reader = new SAXReader();
                //2.加载xml
                String directoryPath = Thread.currentThread().getContextClassLoader().getResource("config.xml").getPath();//获取项目根目录
                Document document = reader.read(new File(directoryPath));
                //3.获取根节点
                Element rootElement = document.getRootElement();
                Element moduleElement = getTargetElement(key1, rootElement);
                Element groupElement = getTargetElement(key2, moduleElement);
                Element configElement = getTargetElement(key3, groupElement);
                Attribute attribute = (Attribute) configElement.attributes().get(0);
                String key = attribute.getValue();
                Text text3 = (Text) configElement.content().get(0);
                String value = text3.getText();
                return value;
            } catch (Exception e) { 
                e.printStackTrace();
            }
            return null;
        }
    
        /** * 获取和targetKey匹配的一个子节点 * * @param targetKey * @param parentElement * @return * @author banxian * @date: 2021/1/21 19:53 */
        public Element getTargetElement(String targetKey, Element parentElement) { 
            Iterator iterator = parentElement.elementIterator();
            Element childElement = null;
            while (iterator.hasNext()) { 
                Element element = (Element) iterator.next();
                Attribute attribute = (Attribute) element.attributes().get(0);
                String key = attribute.getValue();
                if (key.equals(targetKey) || key == targetKey) { 
                    childElement = element;
                    break;
                }
            }
            return childElement;
        }
    }

核心类：用多边形绘图

package com.gwhn.Util;
    
    import com.gwhn.entity.CutProperty;
    import org.locationtech.jts.geom.Coordinate;
    import org.locationtech.jts.geom.Geometry;
    import org.locationtech.jts.geom.MultiPolygon;
    
    import java.awt.*;
    import java.awt.image.BufferedImage;
    import java.util.List;
    
    /** * @author banxian * @date 2021/6/28 12:37 */
    public class PolygonUtil { 
    
        ImageUtils imageUtils = new ImageUtils();
        TxtUtil txtUtil = new TxtUtil();
    
        /** * 根据多多边形画图 * @param path * @param cutProperty * @param multiPolygonList * @return * @author banxian * @date: 2021/6/30 15:31 */
        public void graphicsByMultiPolygon(String path, List<MultiPolygon> multiPolygonList, CutProperty cutProperty) { 
            try { 
                int imageWidth = cutProperty.getWidth();// 图片的宽度
                int imageHeight = cutProperty.getHeight();// 图片的高度
                BufferedImage image = new BufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_INT_RGB);
                Graphics2D graphics = (Graphics2D) image.getGraphics();
                graphics.setColor(Color.white);
                graphics.fillRect(0, 0, imageWidth, imageHeight);
                graphics.setColor(Color.black);
                int m = cutProperty.getBei() / 100;
                graphics.setStroke(new BasicStroke(cutProperty.getWeight() * m));//线条粗细
                Font font = new Font("宋体", Font.BOLD, 1200);
                graphics.setFont(font);
                graphics.drawString(cutProperty.getProvince(),  12500, 1500);
                for (MultiPolygon multiPolygon : multiPolygonList) { 
                    int num = multiPolygon.getNumGeometries();
                    for (int i = 0; i < num; i++) { 
                        Geometry geometry = multiPolygon.getGeometryN(i);
                        drawPolygon(geometry, cutProperty, graphics);
                    }
                }
                imageUtils.createImage(path, image);
                System.out.println(path + ":" + font.getSize());
            } catch (
                    Exception e) { 
                e.printStackTrace();
            }
    
        }
    
        /** * 画出一个多边形 * @param geometry * @param cutProperty * @param graphics2D * @return * @author banxian * @date: 2021/6/28 12:37 */
        public void drawPolygon(Geometry geometry, CutProperty cutProperty, Graphics2D graphics2D) { 
            int m = cutProperty.getBei() / 100;
            Double xtemp = Double.valueOf(cutProperty.getX() * m);
            Double ytemp = Double.valueOf(cutProperty.getY() * m);
    
            //处理飞地
            if (geometry.toString().contains("),")) { 
                String geoStr = geometry.toString();
                String tempStr = geoStr.substring(9, geoStr.length() - 1) + ",";
                while (tempStr.contains("),")) { 
                    String temp = tempStr.substring(0, tempStr.indexOf("),") + 2);
                    tempStr = tempStr.substring(temp.length()).trim();
                    Polygon polygon = txtUtil.getPolygonByStr(temp,cutProperty);
                    graphics2D.drawPolygon(polygon);
                }
            } else { 
                Coordinate[] coordinates = geometry.getCoordinates();
                Polygon polygon = new Polygon();
                Double x, y;
                for (int j = 0; j < coordinates.length; j++) { 
                    Coordinate coordinate = coordinates[j];
                    x = coordinate.getX() * cutProperty.getBei() - xtemp;
                    y = cutProperty.getRightborder() * m - coordinate.getY() * cutProperty.getBei() - ytemp;
                    polygon.addPoint(x.intValue(), y.intValue());
                }
                graphics2D.drawPolygon(polygon);
            }
        }
    }

工具类：处理特殊的边界，一般由飞地、岛屿组成

package com.gwhn.Util;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONArray;
    import com.alibaba.fastjson.JSONObject;
    import com.gwhn.entity.CutProperty;
    
    import java.awt.*;
    import java.io.*;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /** * @author banxian * @date 2021/5/10 15:57 */
    public class TxtUtil { 
    
        public Polygon getPolygonByStr(String polygonStr,CutProperty cutProperty) { 
            polygonStr = polygonStr.substring(1, polygonStr.length() - 2) + ",";
            List<String> polygonStrList = new ArrayList<>();
            while (polygonStr.contains(",")) { 
                String pointStr = polygonStr.substring(0, polygonStr.indexOf(",")).trim();
                polygonStrList.add(pointStr);
                polygonStr = polygonStr.substring(polygonStr.indexOf(",") + 1);
            }
            return transPointStrToPolygon(polygonStrList, cutProperty);
        }
    
        public Polygon transPointStrToPolygon(List<String> polygonStrList,CutProperty cutProperty) { 
            int m = cutProperty.getBei() / 100;
            Double xtemp = Double.valueOf(cutProperty.getX() * m);
            Double ytemp = Double.valueOf(cutProperty.getY() * m);
            Polygon polygon = new Polygon();
            for (String pointStr : polygonStrList) { 
                Double x = Double.parseDouble(pointStr.substring(0, pointStr.indexOf(" ")));
                Double y = Double.parseDouble(pointStr.substring(pointStr.indexOf(" ")).trim());
                x = x * cutProperty.getBei() - xtemp;
                y = cutProperty.getRightborder()*m - y * cutProperty.getBei()-ytemp;
                polygon.addPoint(x.intValue(), y.intValue());
            }
            return polygon;
        }
    
        //读取json文件
        public String readJsonFile(String fileName) { 
            String jsonStr = "";
            try { 
                File jsonFile = new File(fileName);
                FileReader fileReader = new FileReader(jsonFile);
                Reader reader = new InputStreamReader(new FileInputStream(jsonFile), "utf-8");
                int ch = 0;
                StringBuffer sb = new StringBuffer();
                while ((ch = reader.read()) != -1) { 
                    sb.append((char) ch);
                }
                fileReader.close();
                reader.close();
                jsonStr = sb.toString();
                return jsonStr;
            } catch (IOException e) { 
                e.printStackTrace();
                return null;
            }
        }
    
        /** * 读取json获取图片剪切参数 * * @param * @return * @author banxian * @date: 2021/6/25 8:16 */
        public Map<String, CutProperty> getCutPropertyMap() { 
            String path = Thread.currentThread().getContextClassLoader().getResource("property.json").getPath();//获取项目根目录
            String s = readJsonFile(path);
            JSONObject jsonObject = JSON.parseObject(s);
            JSONArray jsonArray = jsonObject.getJSONArray("properties");//构建JSONArray数组
            List<CutProperty> cutPropertyList = jsonArray.toJavaList(CutProperty.class);
            Map<String, CutProperty> cutPropertyMap = new HashMap();
            for (CutProperty cutProperty : cutPropertyList) { 
                cutPropertyMap.put(cutProperty.getProvince(), cutProperty);
            }
            return cutPropertyMap;
        }
        
    }

核心类：从读到的shp文件数据中提取字符串转化为多多边形，绘图

package com.gwhn.controller;
    
    import com.gwhn.Util.PolygonUtil;
    import com.gwhn.Util.TxtUtil;
    import com.gwhn.Util.YereeXmlContext;
    import com.gwhn.entity.CutProperty;
    import com.gwhn.geotools.GeometryCreator;
    import com.gwhn.geotools.ShapeUtil;
    import org.locationtech.jts.geom.MultiPolygon;
    import org.opengis.feature.Property;
    
    import java.io.File;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    
    /** * @author banxian * @date 2021/6/1 8:12 */
    public class ShpPictureController { 
        PolygonUtil polygonUtil = new PolygonUtil();
        TxtUtil txtUtil = new TxtUtil();
        Map<String, CutProperty> cutPropertyMap = txtUtil.getCutPropertyMap();
    
        /** * 根据国家shp文件画出中国地图 * @param * @return * @author banxian * @date: 2021/6/28 12:35 */
        public void doNation() { 
            YereeXmlContext yereeXmlContext = new YereeXmlContext();
            GeometryCreator geometryCreator = new GeometryCreator();
            String shapePath = yereeXmlContext.getXmlValue("Http", "FileExport", "ProvincePath") + "province.shp";
            ShapeUtil shapeUtil = new ShapeUtil();
            try { 
                List<Property> propertyList = shapeUtil.SHPRead(shapePath);
                List<MultiPolygon> multiPolygonList = new ArrayList<>();
                for (int i = 0; i * 8 < propertyList.size(); i++) { 
                    Property property = propertyList.get(i * 8);
                    String valueStr = property.getValue().toString();
                    MultiPolygon multiPolygon = geometryCreator.createMulPolygonByWKT(valueStr);
                    multiPolygonList.add(multiPolygon);
                }
                String path = yereeXmlContext.getXmlValue("Http", "FileExport", "ExportPath");
                File newFileDir = new File(path);
                //如果不存在 则创建
                if (!newFileDir.exists()) { 
                    newFileDir.mkdirs();
                }
    // String picturName = imageUtils.genImageName() + ".jpg";
                String picturName = "中国.jpg";
                CutProperty cutProperty = cutPropertyMap.get("中国");
                polygonUtil.graphicsByMultiPolygon(path + picturName, multiPolygonList, cutProperty);
            } catch (Exception e) { 
                e.printStackTrace();
            }
            System.out.println("完成");
        }
    
        /** * 根据分省shp文件画出地图 * @param * @return * @author banxian * @date: 2021/6/28 12:35 */
        public void doProvince() { 
            YereeXmlContext yereeXmlContext = new YereeXmlContext();
            GeometryCreator geometryCreator = new GeometryCreator();
            ShapeUtil shapeUtil = new ShapeUtil();
            String shapeDirPath = yereeXmlContext.getXmlValue("Http", "FileExport", "ProvinceShapePath");
    
            List<File> fileList = new ArrayList<>();
            fileList = getFileList(shapeDirPath, fileList);
            for (int j = 0; j < fileList.size(); j++) { 
                File file = fileList.get(j);
                if (file.getName().contains(".shp")) { 
                    File parentFile = file.getParentFile();
                    String province = parentFile.getName();
                    System.out.println(province);
                    int size = 7;
                    if (province.equals("湖北") || province == "湖北" || province.equals("安徽") || province == "安徽") { 
                        size = 10;
                    }
                    CutProperty cutProperty = cutPropertyMap.get(province);
                    try { 
                        List<Property> propertyList = shapeUtil.SHPRead(file.getPath());
                        List<MultiPolygon> multiPolygonList = new ArrayList<>();
                        for (int i = 0; i * size < propertyList.size(); i++) { 
                            String valueStr = propertyList.get(i * size).getValue().toString();
                            MultiPolygon multiPolygon = geometryCreator.createMulPolygonByWKT(valueStr);
                            multiPolygonList.add(multiPolygon);
                        }
                        String path = yereeXmlContext.getXmlValue("Http", "FileExport", "ExportPath");
                        ;
                        File newFileDir = new File(path);
                        //如果不存在 则创建
                        if (!newFileDir.exists()) { 
                            newFileDir.mkdirs();
                        }
                        String picturName = province + ".jpg";
                        polygonUtil.graphicsByMultiPolygon(path + picturName, multiPolygonList, cutProperty);
                    } catch (Exception e) { 
                        e.printStackTrace();
                    }
                }
            }
            System.out.println("完成");
        }
    
        /** * 获取shp文件集合 * @param dirPath * @param fileList * @return * @author banxian * @date: 2021/6/28 12:36 */
        public List<File> getFileList(String dirPath, List<File> fileList) { 
            File dir = new File(dirPath);
            if (!dir.exists()) { 
                dir.mkdirs();
            }
            for (File file : dir.listFiles()) { 
                if (!file.isDirectory()) { 
                    fileList.add(file);
                } else { 
                    getFileList(file.getPath(), fileList);
                }
            }
            return fileList;
        }
    
    }

地图坐标截取参数

{
      "properties": [
        {
          "province": "中国",
          "x": 8000,
          "y": 18600,
          "width": 25000,
          "height": 15000,
          "weight": 5.0,
          "bei":350,
          "rightborder": 25000,
          "stringsize": 500
        },
        {
          "province": "上海",
          "x": 12050,
          "y": 21800,
          "width": 23000,
          "height": 16000,
          "weight": 0.8,
          "bei": 10000,
          "rightborder": 25000,
          "stringsize": 500
        },
        {
          "province": "云南",
          "x": 9700,
          "y": 22000,
          "width": 25000,
          "height": 25000,
          "weight": 2.0,
          "bei": 2500,
          "rightborder": 25000,
          "stringsize": 50
        },
        {
          "province": "内蒙古",
          "x": 9000,
          "y": 19000,
          "width": 25000,
          "height": 15000,
          "weight": 3.0,
          "bei": 600,
          "rightborder": 25000,
          "stringsize": 180
        },
        {
          "province": "北京",
          "x": 11515,
          "y": 20830,
          "width": 25000,
          "height": 25000,
          "weight": 1.0,
          "bei": 10000,
          "rightborder": 25000,
          "stringsize": 600
        },
        {
          "province": "吉林",
          "x": 12100,
          "y": 20200,
          "width": 25000,
          "height": 17000,
          "weight": 2.0,
          "bei": 2100,
          "rightborder": 25000,
          "stringsize": 40
        },
        {
          "province": "四川",
          "x": 9600,
          "y": 21500,
          "width": 25000,
          "height": 20000,
          "weight": 2.0,
          "bei": 1900,
          "rightborder": 25000,
          "stringsize": 40
        },
        {
          "province": "天津",
          "x": 11600,
          "y": 20920,
          "width": 25000,
          "height": 25000,
          "weight": 1.0,
          "bei": 10000,
          "rightborder": 25000,
          "stringsize": 600
        },
        {
          "province": "宁夏",
          "x": 10400,
          "y": 20960,
          "width": 20000,
          "height": 25000,
          "weight": 1.0,
          "bei": 4210,
          "rightborder": 25000,
          "stringsize": 40
        },
        {
          "province": "安徽",
          "x": 11350,
          "y": 21500,
          "width": 25000,
          "height": 22000,
          "weight": 1.0,
          "bei": 3300,
          "rightborder": 25000,
          "stringsize": 25
        },
        {
          "province": "山东",
          "x": 11430,
          "y": 21050,
          "width": 25000,
          "height": 20000,
          "weight": 1.0,
          "bei": 2900,
          "rightborder": 25000,
          "stringsize": 35
        },
        {
          "province": "山西",
          "x": 10900,
          "y": 20850,
          "width": 25000,
          "height": 25000,
          "weight": 1.0,
          "bei": 3500,
          "rightborder": 25000,
          "stringsize": 25
        },
        {
          "province": "广东",
          "x": 10750,
          "y": 22400,
          "width": 25000,
          "height": 15000,
          "weight": 1.0,
          "bei": 2200,
          "rightborder": 25000,
          "stringsize": 40
        },
        {
          "province": "广西",
          "x": 10400,
          "y": 22200,
          "width": 25000,
          "height": 18000,
          "weight": 1.0,
          "bei": 2600,
          "rightborder": 25000,
          "stringsize": 35
        },
        {
          "province": "新疆",
          "x": 7200,
          "y": 19800,
          "width": 25000,
          "height": 20000,
          "weight": 2.0,
          "bei": 900,
          "rightborder": 25000,
          "stringsize": 150
        },
        {
          "province": "江苏",
          "x": 11550,
          "y": 21400,
          "width": 25000,
          "height": 25000,
          "weight": 1.0,
          "bei": 4000,
          "rightborder": 25000,
          "stringsize": 25
        },
        {
          "province": "江西",
          "x": 11250,
          "y": 21950,
          "width": 25000,
          "height": 25000,
          "weight": 1.0,
          "bei": 4000,
          "rightborder": 25000,
          "stringsize": 25
        },
        {
          "province": "河北",
          "x": 11250,
          "y": 20600,
          "width": 25000,
          "height": 25000,
          "weight": 1.0,
          "bei": 3000,
          "rightborder": 25000,
          "stringsize": 40
        },
        {
          "province": "河南",
          "x": 10900,
          "y": 21200,
          "width": 25000,
          "height": 23000,
          "weight": 1.0,
          "bei": 2700,
          "rightborder": 25000,
          "stringsize": 25
        },
        {
          "province": "浙江",
          "x": 11800,
          "y": 21800,
          "width": 25000,
          "height": 25000,
          "weight": 1.0,
          "bei": 5000,
          "rightborder": 25000,
          "stringsize": 25
        },
        {
          "province": "湖北",
          "x": 10800,
          "y": 21500,
          "width": 25000,
          "height": 20000,
          "weight": 1.0,
          "bei": 3000,
          "rightborder": 25000,
          "stringsize": 30
        },
        {
          "province": "湖南",
          "x": 10800,
          "y": 21900,
          "width": 25000,
          "height": 25000,
          "weight": 1.0,
          "bei": 3500,
          "rightborder": 25000,
          "stringsize": 25
        },
        {
          "province": "甘肃",
          "x": 9000,
          "y": 20300,
          "width": 25000,
          "height": 25000,
          "weight": 2.0,
          "bei": 1200,
          "rightborder": 25000,
          "stringsize": 70
        },
        {
          "province": "福建",
          "x": 11550,
          "y": 22050,
          "width": 25000,
          "height": 25000,
          "weight": 1.0,
          "bei": 4000,
          "rightborder": 25000,
          "stringsize": 25
        },
        {
          "province": "西藏",
          "x": 7500,
          "y": 21000,
          "width": 25000,
          "height": 15000,
          "weight": 1.5,
          "bei": 1000,
          "rightborder": 25000,
          "stringsize": 100
        },
        {
          "province": "贵州",
          "x": 10350,
          "y": 21900,
          "width": 25000,
          "height": 25000,
          "weight": 1.0,
          "bei": 3200,
          "rightborder": 25000,
          "stringsize": 35
        },
        {
          "province": "辽宁",
          "x": 11850,
          "y": 20500,
          "width": 25000,
          "height": 25000,
          "weight": 1.0,
          "bei": 3300,
          "rightborder": 25000,
          "stringsize": 25
        },
        {
          "province": "重庆",
          "x": 10500,
          "y": 21700,
          "width": 25000,
          "height": 25000,
          "weight": 1.0,
          "bei": 4700,
          "rightborder": 25000,
          "stringsize": 20
        },
        {
          "province": "陕西",
          "x": 10450,
          "y": 21000,
          "width": 25000,
          "height": 25000,
          "weight": 1.0,
          "bei": 2900,
          "rightborder": 25000,
          "stringsize": 25
        },
        {
          "province": "青海",
          "x": 8700,
          "y": 20900,
          "width": 25000,
          "height": 15000,
          "weight": 2.0,
          "bei": 1500,
          "rightborder": 25000,
          "stringsize": 70
        },
        {
          "province": "黑龙江",
          "x": 12000,
          "y": 19500,
          "width": 25000,
          "height": 18000,
          "weight": 1.0,
          "bei": 1500,
          "rightborder": 25000,
          "stringsize": 60
        }
      ]
    }

测试类

public static void main(String[] args) { 
            try { 
                ShpPictureController shpPictureController = new ShpPictureController();
    // shpPictureController.doProvince();
                shpPictureController.doNation();
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }

最终画出的图片效果如下:  
![百度百度百度百度百度百度百度百度][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29MZW5nWXVlSHVu_size_16_color_FFFFFF_t_70]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L29MZW5nWXVlSHVu_size_16_color_FFFFFF_t_70]: /images/20221005/8abe74610a7a4b8fbbd5e9bd197ad5b6.png