【学习笔记】GeoServer——使用Java发布图层（SHP文件和DB数据库），附自用工具类

文章目录

- SHP文件发布逻辑
- - 1、获取到geoserver的manager对象
  - 2、调用createWorkArea方法，参入manager，创建空间空间 workArea
  - 3、调用createShpDataPool方法，创建数据存储
  - 4、发布样式Style.
  - 5、发布图层
- 调用业务层库发布shp文件图层
- - - 业务逻辑如下：
  - 1、查询info表，判断是否是已经发布状态isRelease
  - - - 报错：column "is_release" is of type smallint but expression is of type character varying
  - 2、判断发布类型，调用release方法
  - 3、调用publishShpLayer方法，发布图层
- 附带工具类自取如下：

SHP文件发布逻辑

找到283行的releaseShp方法发布图层：传入的参数是实体类+shp文件路径
使用GeoServerPublishUtils的getManager方法，获取到geoserver的manager对象
调用createWorkArea方法，参入manager，创建空间空间 workArea
调用createShpDataPool方法，创建数据存储
调用createStyle方法，创建样式
调用publishShpLayer方法，发布图层
注意：该方法传入了文件对象new File(shpPath)

即可完成发布

1、获取到geoserver的manager对象

public static GeoServerRESTManager getManager(String address, String account, String passWord) throws MalformedURLException {

测试成功，注意传入的地址address就是 ip + /geoserver，比如http://47.110.80.118:8001/geoserver/

2、调用createWorkArea方法，参入manager，创建空间空间 workArea

 	/**
     * 创建工作区间
     *
     * @param manager  geoserver图层管理类
     * @param workArea 工作区间
     * @return boolean
     * @author qqz
     * @date 14:15 2022/2/22
     **/
public static boolean createWorkArea(GeoServerRESTManager manager, String workArea) {

传入的参数一个可以自定义的string作为工作空间的名称。测试通过

传入String workSpace = "java-test-workSpace";

3、调用createShpDataPool方法，创建数据存储

/**
 * 创建shp数据存储
 *
 * @param manager  geoserver图层管理类
 * @param workArea 工作区间
 * @param dataPool 数据存储
 * @param geoPath  图层服务存放地址
 * @param shpName  shp文件名称
 * @return boolean
 * @author qqz
 * @date 14:14 2022/2/22
 **/
public static boolean createShpDataPool(GeoServerRESTManager manager, String workArea, String dataPool, String geoPath, String shpName) throws MalformedURLException {

传入的参数

dataPool ——可以自定义的名称
geoPath—— （数据库里的数据是geoserver安装目录+/data_dir/data/）
shpName——这里传入的是唯一标识，作为文件的存储地址

测试通过

4、发布样式Style.

创建失败，原因不明

5、发布图层

样式先用现有的样式，进入测试

    /**
     * 发布shp图层
     *
     * @param manager   geoserver图层管理类型
     * @param zipFile   zip文件
     * @param workArea  工作区间
     * @param dataPool  数据存储
     * @param styleName 样式名称
     * @param name      图层名称
     * @param srs       坐标系
     * @return boolean
     * @author qqz
     * @date 14:18 2022/2/22
     **/
    public static boolean publishShpLayer(GeoServerRESTManager manager, File zipFile, String workArea, String dataPool, String styleName, String name, String srs) throws FileNotFoundException {

传入了file文件的应该是一个zip文件

报错如下：

解决方案 —— 此时geoserver中datastore已经创建完成了。排查是因为shp、压缩包以及publishShp的参数layerName名称不一致

还是有问题，不过手动操作发布就已经可以成功发布图层了

接下来测试一下连接数据库的测试

调用业务层库发布shp文件图层

业务逻辑如下：

根据传入的id去查询GeoserverPublishInfo表，得到对应的实体列表
遍历实体列表，找出【未发布状态】PublishConfig.UNPUBLISHED == isRelease
调用220行的publish方法
判断实体的图层类型 layerType，判断是shp发布还是数据库发布
发布后会通过boolean判断是否成功
更新isRelease字段，返回结果

1、查询info表，判断是否是已经发布状态isRelease

进入本类的publish方法

报错：column “is_release” is of type smallint but expression is of type character varying

解决，就是数据库字段和实体的类型不对呀，更新一下即可

2、判断发布类型，调用release方法

在这里，我们发现了shpPath的来源，是从数据库中取到的。
在发布图层时，会根据这个路径创建文件

3、调用publishShpLayer方法，发布图层

附带工具类自取如下：

import it.geosolutions.geoserver.rest.GeoServerRESTManager;
import it.geosolutions.geoserver.rest.decoder.RESTDataStore;
import it.geosolutions.geoserver.rest.encoder.GSLayerEncoder;
import it.geosolutions.geoserver.rest.encoder.datastore.GSPostGISDatastoreEncoder;
import it.geosolutions.geoserver.rest.encoder.datastore.GSShapefileDatastoreEncoder;
import it.geosolutions.geoserver.rest.encoder.feature.GSFeatureTypeEncoder;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.charset.Charset;

public class GeoServerPublishUtils {

    /**
     * 获取geoserver图层管理
     *
     * @param address  geoserver服务地址
     * @param account  账号
     * @param passWord 密码
     * @return it.geosolutions.geoserver.rest.GeoServerRESTManager
     * @author qqz
     * @date 17:07 2022/2/22
     **/
    public static GeoServerRESTManager getManager(String address, String account, String passWord) throws MalformedURLException {
        URL u = new URL(address);
        //获取管理对象
        return new GeoServerRESTManager(u, account, passWord);
    }

    /**
     * 创建数据库存储
     *
     * @param manager  geoserver管理类
     * @param workArea 工作区
     * @param dataPool 数据存储
     * @return boolean
     * @author qqz
     * @date 15:12 2022/2/19
     **/
    public static boolean createDBDataPool(GeoServerRESTManager manager, String workArea, String dataPool, String dbHost, int dbPort, String dbUser, String dbPassWord, String dbDataBase, String dbSchema) {
        RESTDataStore restStore = manager.getReader().getDatastore(workArea, dataPool);
        if (restStore == null) {
            GSPostGISDatastoreEncoder store = new GSPostGISDatastoreEncoder(dataPool);

            store.setHost(dbHost);//设置url
            store.setPort(dbPort);//设置端口
            store.setUser(dbUser);// 数据库的用户名
            store.setPassword(dbPassWord);// 数据库的密码
            store.setDatabase(dbDataBase);// 那个数据库;
            store.setSchema(dbSchema); //当前先默认使用public这个schema
            store.setConnectionTimeout(20);// 超时设置
            store.setMaxConnections(20); // 最大连接数
            store.setMinConnections(1);     // 最小连接数
            store.setExposePrimaryKeys(true);
            boolean createStore = manager.getStoreManager().create(workArea, store);
            System.out.println("create store : " + createStore);
            return createStore;
        }
        return true;
    }

    /**
     * 创建shp数据存储
     *
     * @param manager  geoserver图层管理类
     * @param workArea 工作区间
     * @param dataPool 数据存储
     * @param geoPath  图层服务存放地址
     * @param shpName  shp文件名称
     * @return boolean
     * @author qqz
     * @date 14:14 2022/2/22
     **/
    public static boolean createShpDataPool(GeoServerRESTManager manager, String workArea, String dataPool, String geoPath, String shpName) throws MalformedURLException {
        String fileUrl = "file://" + geoPath + "/" + workArea + "/" + dataPool + "/" + shpName;
        URL urlShapeFile = new URL(fileUrl);
        boolean existsDatastore = manager.getReader().existsDatastore(workArea, dataPool);
        if (!existsDatastore) {
            //创建shape文件存储
            GSShapefileDatastoreEncoder store = new GSShapefileDatastoreEncoder(dataPool, urlShapeFile);
            store.setCharset(Charset.forName("GBK"));
            boolean createStore = manager.getStoreManager().create(workArea, store);
            return createStore;
        }
        return true;
    }

    /**
     * 创建工作区间
     *
     * @param manager  geoserver图层管理类
     * @param workArea 工作区间
     * @return boolean
     * @author qqz
     * @date 14:15 2022/2/22
     **/
    public static boolean createWorkArea(GeoServerRESTManager manager, String workArea) {
        boolean existsWorkspace = manager.getReader().existsWorkspace(workArea);
        //判断工作空间是否存在
        if (!existsWorkspace) {
            //创建一个新的存储空间
            boolean createWs = manager.getPublisher().createWorkspace(workArea);
            System.out.println("create ws : " + createWs);
            return createWs;
        }
        return true;
    }

    /**
     *  创建样式
     * @param manager geoserver图层管理类
     * @param obj    反射所需类
     * @param styleName 样式名称
     * @param geoStylePath
     * @return
     */
    public static boolean createStyle(GeoServerRESTManager manager, Object obj, String styleName, String geoStylePath) throws IOException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        boolean existsStyle = manager.getReader().existsStyle(styleName);
        if (!existsStyle) {
            //获取样式格式
            String style = FileUtils.readFileToString(new File(geoStylePath));
            Class clazz = obj.getClass();
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                //获取属性名
                String fieldName = field.getName();
                //首字母转大写
                fieldName = fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
                Method m = clazz.getMethod("get" + fieldName);  // 获取getter方法
                // 执行方法提提取数值
                if (m.invoke(obj) == null) {
                    style = style.replaceAll("@" + fieldName.toLowerCase(), "");
                } else {
                    String value = m.invoke(obj).toString();    // 执行获取数值
                    // 将对应的样式格式，设置为提取到的数值
                    style = style.replaceAll("@" + fieldName.toLowerCase(), value);
                }
            }
            //设置样式名称
            style = style.replaceAll("@sldName", styleName);
            //创建样式
            existsStyle = manager.getPublisher().publishStyle(style);
        }
        return existsStyle;
    }

    /**
     * 发布数据库图层 === 发布数据库
     *
     * @param manager    geoserver图层管理
     * @param workArea   工作区间
     * @param dataPool   数据存储
     * @param styleName  样式名称
     * @param name       图层标题名称
     * @param nativeName 图层名称
     * @param srs        坐标系
     * @return boolean
     * @author qqz
     * @date 14:17 2022/2/22
     **/
    public static boolean publishDBLayer(GeoServerRESTManager manager, String workArea, String dataPool, String styleName, String name, String nativeName, String srs) {
        boolean existsLayer = manager.getReader().existsLayer(workArea, name);
        if (!existsLayer) {
            GSLayerEncoder layerEncoder = new GSLayerEncoder();
            layerEncoder.setEnabled(true);
            //设置图层默认样式
            layerEncoder.setDefaultStyle(styleName);
            GSFeatureTypeEncoder gsFeatureTypeEncoder = new GSFeatureTypeEncoder();
            if (StringUtil.isBlank(name) && StringUtil.isBlank(nativeName)) {
                ExceptionFactory.throwException("表名和标识码为空!");
            } else if (StringUtil.isNotBlank(name) && StringUtil.isNotBlank(nativeName)) {
                gsFeatureTypeEncoder.setName(name);
                gsFeatureTypeEncoder.setNativeName(nativeName);
            } else if (StringUtil.isNotBlank(name)) {
                gsFeatureTypeEncoder.setName(name);
                gsFeatureTypeEncoder.setNativeName(name);
            } else {
                gsFeatureTypeEncoder.setName(nativeName);
                gsFeatureTypeEncoder.setNativeName(nativeName);
            }
            gsFeatureTypeEncoder.setSRS(srs);
            boolean publish = manager.getPublisher().publishDBLayer(workArea, dataPool, gsFeatureTypeEncoder, layerEncoder);
            return publish;
        }
        return true;
    }



        /**
         * 发布shp图层=====shp文件
         *
         * @param manager   geoserver图层管理类型
         * @param zipFile   zip文件
         * @param workArea  工作区间
         * @param dataPool  数据存储
         * @param styleName 样式名称
         * @param layerName 图层名称
         * @param srs       坐标系
         * @return boolean
         * @author qqz
         * @date 14:18 2022/2/22
         **/
    public static boolean publishShpLayer(GeoServerRESTManager manager, File zipFile, String workArea, String dataPool, String styleName, String layerName, String srs)  {
        boolean existsLayer = manager.getReader().existsLayer(workArea, layerName);
        if (!existsLayer) {
            boolean publish = false;
            try {
                publish = manager.getPublisher().publishShp(workArea, dataPool, layerName, zipFile, srs, styleName);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
            return publish;
        }
        return true;
    }

}