wfsclient.java

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

package com.esri.solutions.jitk.datasources.ogc.wfs;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.PipedInputStream;
import java.util.Map;

import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.log4j.Logger;

import com.esri.solutions.jitk.datasources.exceptions.NetworkConnectionException;
import com.esri.solutions.jitk.datasources.exceptions.RequestBuildingException;
import com.esri.solutions.jitk.datasources.exceptions.ResponseParsingException;
import com.esri.solutions.jitk.datasources.ogc.filters.Filter;
import com.esri.solutions.jitk.datasources.ogc.filters.IFilter;
import com.esri.solutions.jitk.datasources.ogc.filters.WithinClause;
import com.esri.solutions.jitk.datasources.ogc.gml.GMLEnvelope;
import com.esri.solutions.jitk.datasources.ogc.wfs.parsing.DescribeFeaturesResponseParser;
import com.esri.solutions.jitk.datasources.ogc.wfs.parsing.FeatureCollectionParser;
import com.esri.solutions.jitk.datasources.ogc.wfs.parsing.WFSCapabilitiesResponseParser;
import com.esri.solutions.jitk.datasources.w3c.http.HTTPXMLStreamOpener;

public class WFSClient implements IWFSClient {
	private static final Logger _logger = Logger.getLogger(WFSClient.class);
	protected WFSUrlBuilder _urlBuilder;
	
	public WFSClient(String serviceUrl) {
		_urlBuilder = new WFSUrlBuilder(serviceUrl);
	}
	
	public String getURL() {
		return _urlBuilder.getURL();
	}
	
	public WFSCapabilities getCapabilities() 
		throws NetworkConnectionException, ResponseParsingException {
		WFSCapabilities cap = null;
		InputStream is = null;
		
		try {
			HTTPXMLStreamOpener streamOpener = new HTTPXMLStreamOpener();
			is = streamOpener.openHttpGetStream(_urlBuilder.getCapabilitiesUrl());
			WFSCapabilitiesResponseParser responseParser = new WFSCapabilitiesResponseParser();
			cap = responseParser.parse(is);
		}
		catch (Exception ex) {		
			if (is != null) {
				throw new ResponseParsingException(ex.getMessage(), ex.getCause());
			}
			else {
				throw new NetworkConnectionException(ex.getMessage(), ex.getCause());
			}
		}
		
		return cap;
	}
	
	public WFSFeatureDescriptions describeFeatures(Map<String, FeatureTypeDescription> ftd)
		throws NetworkConnectionException, ResponseParsingException {
		WFSFeatureDescriptions fd = null;
		InputStream is = null;
		
		try {
			HTTPXMLStreamOpener streamOpener = new HTTPXMLStreamOpener();
			is = streamOpener.openHttpGetStream(_urlBuilder.describeFeatureTypeUrl());
			DescribeFeaturesResponseParser responseParser = new DescribeFeaturesResponseParser();
			responseParser.setFeatureTypeDescriptions(ftd);
			fd = responseParser.parse(is);
		}
		catch (Exception ex) {
			_logger.warn("Could not perform describeFeature Request", ex);
			
			if (is != null) {
				throw new ResponseParsingException(ex.getMessage(), ex.getCause());
			}
			else {
				throw new NetworkConnectionException(ex.getMessage(), ex.getCause());
			}			
		}
		
		return fd;
	}
	
	public FeatureCollection getFeatures(IQuery query, int maxFeatures) 
		throws NetworkConnectionException, ResponseParsingException, RequestBuildingException {
		FeatureCollection fc = null;
		InputStream is = null;
		PostMethod pm = null;
		Exception caughtException = null;
		PipedInputStream pin = null;
		
		try {	
			WFSGetFeaturesRequest gfr =  new WFSGetFeaturesRequest();
			gfr.setMaxFeatures(maxFeatures);
			gfr.setQuery(query);
			
			if (_logger.isDebugEnabled()) {
				ByteArrayOutputStream outStream = new ByteArrayOutputStream(); 
				gfr.toXML(outStream);
				_logger.debug("Get Features Request: " + outStream.toString());
				outStream.close();
			}
			
			// Convert input stream to output stream
			ByteArrayOutputStream out = new ByteArrayOutputStream();
			gfr.toXML(out);
			ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());

			// Send the request and get a handle to the response stream
			HTTPXMLStreamOpener streamOpener = new HTTPXMLStreamOpener();
			String postUrl = _urlBuilder.getFeatureUrl();
			pm = streamOpener.openHttpPostStream(postUrl, in);
			
			_logger.debug("Get Features Response: " + pm.getResponseBodyAsString());
			is = pm.getResponseBodyAsStream();
			
			FeatureCollectionParser fcp = new FeatureCollectionParser();
			fc = fcp.parse(is);
		}
		catch (Exception ex) {
			caughtException = ex;
			_logger.error("Could not perform getFeature Request", ex);
		}
		finally {
			if (pm != null) {
				pm.releaseConnection();
			}
			
			if (caughtException != null) {
				if (pin == null) {
					throw new RequestBuildingException(caughtException.getMessage(), caughtException.getCause());
				}
				else if (pm == null){
					throw new NetworkConnectionException(caughtException.getMessage(), caughtException.getCause());
				}
				else if (fc == null) {
					throw new ResponseParsingException(caughtException.getMessage(), caughtException.getCause()); 
				}
			}
		}
		
		return fc;		
	}
	
	public static void main(String[] args) {        
		WFSClient wfsClient = new WFSClient("http://williani370:8399/arcgis/services/WfsTest/MapServer/WFSServer");
		WFSCapabilities caps = null;
		
		try {
			caps = wfsClient.getCapabilities();
		}
		catch (NetworkConnectionException ex) {
			_logger.error("NetworkConnectionException", ex);
			return;
		}
		catch (ResponseParsingException ex) {
			_logger.error("ResponseParsingException", ex);
			return;
		}
		
		String title = caps.getServiceIdentification().getTitle();
		
		_logger.debug("Service Title: " + title);
		
		for (FeatureTypeDescription ft : caps.getFeatureTypes()) {
			_logger.debug("FeatureType name: " + ft.getName());
			_logger.debug("FeatureType title: " + ft.getTitle());
			_logger.debug("FeatureType SRS: " + ft.getDefaultSrs());
		}
		
		WFSFeatureDescriptions fd = null;
		
		try {
			fd = wfsClient.describeFeatures(caps.getFeatureTypesAsMap());
		}
		catch (Exception ex) {
			_logger.error("Could not perform descripbe features request");
			return;
		}
		
		Map<String, FeatureType> fts = fd.getFeatureTypes();
		
		for (FeatureType ft : fts.values()) {
			_logger.debug("FeatureType Description for " + ft.getName());
			
			for (FeatureElement fe : ft.getFeatureElements()) {
				_logger.debug("--Name: " + fe.getName());
				_logger.debug("--Type: " + fe.getXsdType());
				_logger.debug("--Min: " + fe.getMinOccurances());
			}
		}
		
		FeatureTypeDescription ftd = caps.getFeatureTypes().get(1);
		FeatureType ft = fts.get(ftd.getTitle());
		String shapeFieldName = ft.getShapeElement().getName();
		
		GMLEnvelope gmlEnv = new GMLEnvelope();
		gmlEnv.setMaxX("71.4062353532711");
		gmlEnv.setMaxY("-66.9692710360024");
		gmlEnv.setMinX("18.9247817993165");
		gmlEnv.setMinY("-178.217598362366");
		
		WithinClause wc = new WithinClause();
		wc.setGMLGeometry(gmlEnv);
		wc.setShapePropertyName(shapeFieldName);
		
		IFilter filter = new Filter();
		filter.pushClause(wc);
		
		IQuery query = new Query();
		query.setFilter(filter);
		query.setTypeName(ftd.getName());
		
		FeatureCollection fc = null;
		try {
			fc = wfsClient.getFeatures(query, 100);
		}
		catch (Exception ex) {
			_logger.error("Could not perform get features request");
			return;
		}
		
		for (FeatureMember fm : fc.getFeatureMembers()) {
			_logger.debug("Name: Shape - Value: ");
			fm.getShapeField().print();
			
			for (FeatureField ff : fm.getFeatureFields().values()) {
				_logger.debug("Name: " + ff.getName() + " - Value: " + ff.getValue());
			}
		}
	}
}