wfspredefinedquerycriteriahandler.java

esri的ArcGIS Server超级学习模板程序（for java）

package com.esri.solutions.jitk.web.wfs.data.query;

import com.esri.adf.web.data.WebLayerInfo;
import com.esri.adf.web.data.geometry.WebGeometry;
import com.esri.adf.web.data.geometry.WebSpatialReference;
import com.esri.adf.web.data.query.PredefinedQueryCriteria;
import com.esri.adf.web.data.query.QueryCriteria;
import com.esri.adf.web.data.query.QueryCriteriaHandler;
import com.esri.adf.web.data.query.QueryFunctionality;
import com.esri.adf.web.data.query.QueryResult;
import com.esri.adf.web.data.query.WebQuery;

import com.esri.solutions.jitk.data.gml.IWebGeometryConverter;
import com.esri.solutions.jitk.data.gml.WebGeometryConversionNotSupported;
import com.esri.solutions.jitk.data.gml.WebGeometryConverterFactory;
import com.esri.solutions.jitk.datasources.ogc.filters.Filter;
import com.esri.solutions.jitk.datasources.ogc.filters.FilterLogicalOperator;
import com.esri.solutions.jitk.datasources.ogc.filters.IFilter;
import com.esri.solutions.jitk.datasources.ogc.filters.IntersectsClause;
import com.esri.solutions.jitk.datasources.ogc.filters.LogicalOperatorClause;
import com.esri.solutions.jitk.datasources.ogc.gml.IGMLGeometry;
import com.esri.solutions.jitk.datasources.ogc.wfs.CoordinateReferenceSystem;
import com.esri.solutions.jitk.datasources.ogc.wfs.FeatureCollection;
import com.esri.solutions.jitk.datasources.ogc.wfs.FeatureType;
import com.esri.solutions.jitk.datasources.ogc.wfs.FeatureTypeDescription;
import com.esri.solutions.jitk.datasources.ogc.wfs.IQuery;
import com.esri.solutions.jitk.datasources.ogc.wfs.IWFSClient;
import com.esri.solutions.jitk.datasources.ogc.wfs.Query;
import com.esri.solutions.jitk.web.wfs.adapters.SQLWhereClauseAdapter;
import com.esri.solutions.jitk.web.wfs.data.WFSWebLayerInfo;

import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;

import java.io.ByteArrayOutputStream;

import java.util.List;


public class WFSPredefinedQueryCriteriaHandler extends WFSQueryCriteria
    implements QueryCriteriaHandler {
    private static final Logger _logger = LogManager.getLogger(WFSPredefinedQueryCriteriaHandler.class);

    public List<QueryResult> handleCriteria(QueryCriteria qc,
        List<?extends WebLayerInfo> layerList, WebQuery webQuery,
        QueryFunctionality qf) {
        return this.handleCriteria(qc, layerList, webQuery, qf, null);
    }

    public List<QueryResult> handleCriteria(QueryCriteria qc,
        List<?extends WebLayerInfo> layerList, WebQuery webQuery,
        QueryFunctionality qf, WebGeometry geometry) {
        _logger.debug("handleCriteria called");

        List<QueryResult> results = null;

        WFSWebLayerInfo layerInfo = getWFSWeblayerInfo(qf, layerList);

        if (layerInfo == null) {
            return results;
        }

        if (qc instanceof PredefinedQueryCriteria) {
            PredefinedQueryCriteria pc = (PredefinedQueryCriteria) qc;
            results = query(pc, qf, layerInfo, webQuery, geometry);
        } else {
            _logger.error(
                "QueryCriteria not PredefinedQueryCriteria, query can not be processed");
        }

        return results;
    }

    protected List<QueryResult> query(PredefinedQueryCriteria pc,
        QueryFunctionality qf, WFSWebLayerInfo layerInfo, WebQuery webQuery,
        WebGeometry geometry) {
        List<QueryResult> results = null;

        try {
            String whereClause = pc.getWhereClause();
            String layerName = layerInfo.getName();
            FeatureTypeDescription ftd = layerInfo.getFeatureTypeDescription();
            WebSpatialReference wsr = webQuery.getWebContext()
                                              .getSpatialReference();

            CoordinateReferenceSystem crs = getCrs(wsr, ftd);
            IWFSClient wfs = getWFSClient(qf.getResource());

            if (crs == null) {
                throw new Exception(
                    "WFS service does not support spatial reference ID");
            }

            _logger.debug("WHERE Clause:" + whereClause);

            _logger.debug("Building filter");

            SQLWhereClauseAdapter wca = new SQLWhereClauseAdapter(whereClause);
            IFilter filter = wca.getFilter();

            // handle the geometry if there is one
            if (geometry != null) {
                IntersectsClause ic = null;
                LogicalOperatorClause andClause = null;

                ic = this.createIntersectsClause(webQuery,
                        layerInfo.getFeatureType(), geometry);

                if (ic != null) {
                    andClause = new LogicalOperatorClause(FilterLogicalOperator.AND);

                    andClause.appendClause(ic);
                    
                    // append the clause created by the SQLWhereClauseAdapter
                    andClause.appendClause(filter.getClauses().get(0));

                    // create a new filter that will contain just the logical operator clause
                    filter = new Filter();

                    // add the logical operator clause
                    filter.pushClause(andClause);
                }
            }

            if (_logger.isDebugEnabled() && (filter != null)) {
                ByteArrayOutputStream outStream = new ByteArrayOutputStream();
                filter.toXML(outStream);

                String actualResult = outStream.toString();
                _logger.debug("Generated Filter: " + actualResult);
            }

            _logger.debug("Building query");

            IQuery query = new Query();
            query.setCrs(crs);
            query.setFilter(filter);
            query.setTypeName(layerName);

            _logger.debug("Performing get feature request to WFS");

            int maxRec = (pc.getMaxRecordCount() <= 0) ? 500
                                                       : pc.getMaxRecordCount();
            FeatureCollection fc = wfs.getFeatures(query, maxRec);

            _logger.debug("Converting WFS feature collection to ADF results");

            WFSResultsBuilder resultBuilder = new WFSResultsBuilder();
            results = resultBuilder.buildQueryResults(webQuery, layerInfo, fc);
        } catch (Exception ex) {
            _logger.error("Exception performing feature query against WFS", ex);
        }

        return results;
    }

    protected IntersectsClause createIntersectsClause(WebQuery webQuery,
        FeatureType featureType, WebGeometry geometry) {
        IntersectsClause ic = null;
        IGMLGeometry gmlGeom = null;

        gmlGeom = this.createGMLGeometry(webQuery, geometry);

        ic = new IntersectsClause();
        ic.setGMLGeometry(gmlGeom);
        ic.setShapePropertyName(featureType.getShapeElement().getName());

        return ic;
    }

    protected IGMLGeometry createGMLGeometry(WebQuery webQuery,
        WebGeometry geometry) {
        IGMLGeometry gmlGeom = null;
        IWebGeometryConverter converter = null;

        try {
            converter = WebGeometryConverterFactory.getInstance(webQuery.getWebContext(),
                    geometry);

            gmlGeom = converter.toGMLGeometry(geometry);
        } catch (WebGeometryConversionNotSupported ex) {
            _logger.warn("Cannot convert WebGeometry to GML - unsupported type");
            _logger.error("Cannot convert WebGeometry to GML - unsupported type",
                ex);
        }

        return gmlGeom;
    }
}