001: //$HeadURL: https://svn.wald.intevation.org/svn/deegree/base/trunk/src/org/deegree/framework/util/NetWorker.java $
002: /*---------------- FILE HEADER ------------------------------------------
003:
004: This file is part of deegree.
005: Copyright (C) 2001-2008 by:
006: EXSE, Department of Geography, University of Bonn
007: http://www.giub.uni-bonn.de/deegree/
008: lat/lon GmbH
009: http://www.lat-lon.de
010:
011: This library is free software; you can redistribute it and/or
012: modify it under the terms of the GNU Lesser General Public
013: License as published by the Free Software Foundation; either
014: version 2.1 of the License, or (at your option) any later version.
015:
016: This library is distributed in the hope that it will be useful,
017: but WITHOUT ANY WARRANTY; without even the implied warranty of
018: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
019: Lesser General Public License for more details.
020:
021: You should have received a copy of the GNU Lesser General Public
022: License along with this library; if not, write to the Free Software
023: Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
024:
025: Contact:
026:
027: Andreas Poth
028: lat/lon GmbH
029: Aennchenstr. 19
030: 53115 Bonn
031: Germany
032: E-Mail: poth@lat-lon.de
033:
034: Prof. Dr. Klaus Greve
035: Department of Geography
036: University of Bonn
037: Meckenheimer Allee 166
038: 53115 Bonn
039: Germany
040: E-Mail: greve@giub.uni-bonn.de
041:
042:
043: ---------------------------------------------------------------------------*/
044: package org.deegree.framework.util;
045:
046: import java.io.ByteArrayOutputStream;
047: import java.io.IOException;
048: import java.io.InputStream;
049: import java.io.OutputStreamWriter;
050: import java.io.PrintWriter;
051: import java.net.URL;
052: import java.net.URLConnection;
053:
054: import org.deegree.framework.log.ILogger;
055: import org.deegree.framework.log.LoggerFactory;
056:
057: /**
058: * Performs a HTTP request using the service URL submitted to the constructor
059: *
060: * @version $Revision: 9339 $
061: * @author <a href="mailto:poth@lat-lon.de">Andreas Poth</a>
062: */
063: public class NetWorker {
064:
065: private static final ILogger LOG = LoggerFactory
066: .getLogger(NetWorker.class);
067: private static final int GET = 0;
068: private static final int POST = 1;
069: private String contentType = null;
070: private String request = null;
071: private URL url = null;
072: private int reqType = -1;
073: private String encoding = null;
074:
075: /**
076: * constructor for initializing a HTTP GET connection with
077: * with default character encoding
078: * @param url URL to the net resource containing the URI
079: */
080: public NetWorker(URL url) {
081:
082: this .reqType = GET;
083: this .url = url;
084: this .encoding = CharsetUtils.getSystemCharset();
085:
086: }
087:
088: /**
089: * constructor for initializing a HTTP GET connection with a user defined
090: * encoding
091: * @param encoding desired character encoding
092: * @param url URL to the net resource containing the URI
093: */
094: public NetWorker(String encoding, URL url) {
095: this .reqType = GET;
096: this .url = url;
097: this .encoding = encoding;
098:
099: }
100:
101: /**
102: * constructor for initializing a HTTP POST connection with UTF-8 as
103: * character encoding
104: * @param url URL to the net resource (without URI parameters)
105: * @param request request that shall be posted to the net resource
106: */
107: public NetWorker(URL url, String request) {
108:
109: this .reqType = POST;
110: this .url = url;
111: this .request = request;
112: this .encoding = "UTF-8";
113:
114: }
115:
116: /**
117: * constructor for initializing a HTTP POST connection with a user defined
118: * encoding
119: * @param encoding desired character encoding
120: * @param url URL to the net resource (without URI parameters)
121: * @param request request that shall be posted to the net resource
122: */
123: public NetWorker(String encoding, URL url, String request) {
124: this .reqType = POST;
125: this .url = url;
126: this .request = request;
127: this .encoding = encoding;
128:
129: }
130:
131: /**
132: * @return the content type of the response from the connected net resource.
133: * this method shall be called after <tt>getInputStream</tt> or
134: * <tt>getDataAsByteArr</tt> has been called.
135: *
136: */
137: public String getContentType() {
138: return contentType;
139: }
140:
141: /**
142: * sends the request that have been passed to the constructor without
143: * expecting to receive a response.
144: * @throws IOException
145: */
146: public void sendRequest() throws IOException {
147:
148: LOG.logDebug("Trying to send request " + request
149: + " via POST with encoding " + encoding);
150:
151: // open connection to the requested host
152: URLConnection connection = url.openConnection();
153:
154: connection.setDoInput(false);
155:
156: // sets the content type of the request
157: connection.setRequestProperty("Content-Type", "text/xml");
158:
159: if ((reqType == POST) && (request != null)) {
160: connection.setDoOutput(true);
161:
162: // get connection stream
163: OutputStreamWriter osw = new OutputStreamWriter(connection
164: .getOutputStream(), encoding);
165: PrintWriter os = new PrintWriter(osw);
166:
167: // write post request into stream
168: os.print(request);
169: os.close();
170: } else {
171: connection.setDoOutput(false);
172: }
173:
174: LOG.logDebug("Sent request.");
175: }
176:
177: /**
178: * returns an <tt>InputStream</tt> from the et resource
179: *
180: * @return InputStream accessing the net resource
181: *
182: * @throws IOException
183: */
184: public InputStream getInputStream() throws IOException {
185:
186: // open connection to the requested host
187: URLConnection connection = url.openConnection();
188:
189: connection.setDoInput(true);
190:
191: // sets the content type of the request
192: connection.setRequestProperty("Content-Type", "text/xml");
193:
194: // provide result stream
195: InputStream is = null;
196:
197: if ((reqType == POST) && (request != null)) {
198: connection.setDoOutput(true);
199:
200: // get connection stream
201: OutputStreamWriter osw = new OutputStreamWriter(connection
202: .getOutputStream(), encoding);
203: PrintWriter os = new PrintWriter(osw);
204:
205: // write post request into stream
206: os.print(request);
207: os.close();
208: } else {
209: connection.setDoOutput(false);
210: }
211:
212: // reads the content type of the connected net resource
213: try {
214: contentType = connection.getHeaderField("Content-Type");
215: } catch (Exception e) {
216: e.printStackTrace();
217: }
218:
219: // get result of the request
220: try {
221: is = connection.getInputStream();
222: } catch (Exception e) {
223: e.printStackTrace();
224: throw new IOException("could not provide data: " + e);
225: }
226:
227: return is;
228: }
229:
230: /**
231: * performs the request and returns the result as a byte array.
232: *
233: * @param expectedDataSize size a the data in bytes expected to be returned
234: * from the net resource. this value will be replaced if the resource
235: * is able to return the available data size.
236: * @return a byte array containing the content of the net resource
237: *
238: * @throws IOException
239: */
240: public byte[] getDataAsByteArr(int expectedDataSize)
241: throws IOException {
242:
243: InputStream is = getInputStream();
244:
245: if (expectedDataSize <= 0) {
246: expectedDataSize = 10000;
247: }
248:
249: ByteArrayOutputStream bos = new ByteArrayOutputStream(
250: expectedDataSize);
251:
252: int v = 0;
253:
254: // write result to a ByteArrayOutputStream
255: while ((v = is.read()) > -1) {
256: bos.write(v);
257: }
258:
259: bos.flush();
260: bos.close();
261:
262: is.close();
263:
264: // return result as byte array
265: return bos.toByteArray();
266: }
267:
268: /**
269: * Returns the original form of a <tt>URL</tt> as as <tt>String</tt>.
270: * Handles local filenames correctly, C:/foo is formatted as
271: * file:///C:/foo (and not as file:/C:/foo as returned by the toString ()
272: * method of the <tt<URL</tt> object.
273: * <p>
274: * @param url <tt>URL</tt> to be converted
275: * @return <tt>String</tt> representation of the given <tt>URL</tt>
276: */
277: public static synchronized String url2String(URL url) {
278: String port = "";
279:
280: if (url.getPort() != -1) {
281: port = ":" + url.getPort();
282: }
283:
284: String s = url.getProtocol() + "://" + url.getHost() + port
285: + url.getPath();
286:
287: return s;
288: }
289:
290: /**
291: * @param url
292: * @return true if a connection to the submitted <tt>URL</tt> can be opend
293: */
294: public static synchronized boolean existsURL(URL url) {
295: try {
296: URLConnection con = url.openConnection();
297: con.connect();
298: con.getContentType();
299: } catch (Exception e) {
300: return false;
301: }
302: return true;
303: }
304:
305: }
|