java使用GeoTools读取shp文件并画图的操作代码-eolink官网

java使用GeoTools读取shp文件并画图的操作代码

GeoTools是ArcGis地图与java对象的桥梁，恰如jdbc之于oracle与java。

shp文件本身是存有地理对象边界坐标、对象中心城市及城市编号的多多边形字符串。

需要使用的依赖如下

org.geotools

gt-shapefile

${geotools.version}

org.geotools

gt-swing

${geotools.version}

dom4j

1.6.1

com.alibaba

fastjson

1.2.47

对象：

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 SHPRead(String path) throws Exception {

List 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 result = featureSource.getFeatures();

System.out.println("几何对象总共有：" + result.size());

//features():返回一个FeatureIterator迭代器

SimpleFeatureIterator it = (SimpleFeatureIterator) result.features();

while (it.hasNext()) {

SimpleFeature feature = it.next();

//迭代属性【属性我们可以理解为一个几何对象的属性节点，也就是对一个几何图形的描述字段】

Iterator 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 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如下：

D:/testspace/spd/rain/

D:/testspace/spd/Provinces_shp/

D:\testspace\spd\output\

D:\testspace\spd\Export\

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获取值

* D:\\temp\\upload\\

* @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 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 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 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 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 cutPropertyList = jsonArray.toJavaList(CutProperty.class);

Map 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 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 propertyList = shapeUtil.SHPRead(shapePath);

List 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 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 propertyList = shapeUtil.SHPRead(file.getPath());

List multiPolygonList = new ArrayList<>();

for (int i = 0; i * size < propertyList.size(); i++) {

http:// 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 getFileList(String dirPath, List fileList) {

File dir = new File(dirPath);

if (!dir.exists()) {

dir.mkdirs();

}

for (File file : dir.listFihttp://les()) {

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();

}

最终画出的图片效果如下:

Spring中的aware接口详情

358 2022-10-14

java使用GeoTools读取shp文件并画图的操作代码

java中的接口是类吗

Spring中的aware接口详情

29、OSPF配置实验之被动接口

推荐文章

接口调用是什么意思？几种常用接口调用方式

接口设计原则

8款在线 API 接口文档管理工具

api管理系统是什么？

什么是接口调试？接口调试的步骤有哪些？

api 接口管理系统有哪些？

接口测试有几种测试方法

API文档生成工具有哪些？

微服务和api网关区别

交换机配置步骤

最近发表

热评文章

在线接口文档管理工具推荐，支持在线测试，HTTP接口

开源的在线接口文档wiki工具Mindoc的介绍与使

如何优雅的进行接口设计？接口设计的六大原则是什么？

什么是API测试,api检测公司

软件接口设计怎么做？前后端分离软件接口设计思路

接口管理平台推荐，几大接口管理平台总有一款适合你！