001: /*
002: * The contents of this file are subject to the terms
003: * of the Common Development and Distribution License
004: * (the "License"). You may not use this file except
005: * in compliance with the License.
006: *
007: * You can obtain a copy of the license at
008: * https://jwsdp.dev.java.net/CDDLv1.0.html
009: * See the License for the specific language governing
010: * permissions and limitations under the License.
011: *
012: * When distributing Covered Code, include this CDDL
013: * HEADER in each file and include the License file at
014: * https://jwsdp.dev.java.net/CDDLv1.0.html If applicable,
015: * add the following below this CDDL HEADER, with the
016: * fields enclosed by brackets "[]" replaced with your
017: * own identifying information: Portions Copyright [yyyy]
018: * [name of copyright owner]
019: */
020: /*
021: * $Id: ReceivingServlet.java,v 1.2 2007/07/16 16:41:18 ofung Exp $
022: * $Revision: 1.2 $s
023: * $Date: 2007/07/16 16:41:18 $
024: */
025:
026: /*
027: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
028: *
029: * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
030: *
031: * The contents of this file are subject to the terms of either the GNU
032: * General Public License Version 2 only ("GPL") or the Common Development
033: * and Distribution License("CDDL") (collectively, the "License"). You
034: * may not use this file except in compliance with the License. You can obtain
035: * a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
036: * or glassfish/bootstrap/legal/LICENSE.txt. See the License for the specific
037: * language governing permissions and limitations under the License.
038: *
039: * When distributing the software, include this License Header Notice in each
040: * file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
041: * Sun designates this particular file as subject to the "Classpath" exception
042: * as provided by Sun in the GPL Version 2 section of the License file that
043: * accompanied this code. If applicable, add the following below the License
044: * Header, with the fields enclosed by brackets [] replaced by your own
045: * identifying information: "Portions Copyrighted [year]
046: * [name of copyright owner]"
047: *
048: * Contributor(s):
049: *
050: * If you wish your version of this file to be governed by only the CDDL or
051: * only the GPL Version 2, indicate your decision by adding "[Contributor]
052: * elects to include this software in this distribution under the [CDDL or GPL
053: * Version 2] license." If you don't indicate a single choice of license, a
054: * recipient has the option to distribute your version of this file under
055: * either the CDDL, the GPL Version 2 or to extend the choice of license to
056: * its licensees as provided above. However, if you add GPL Version 2 code
057: * and therefore, elected the GPL Version 2 license, then the option applies
058: * only if the new code is made subject to such option by the copyright
059: * holder.
060: */
061: package translator;
062:
063: import java.io.*;
064: import java.util.*;
065: import java.util.logging.Level;
066: import java.util.logging.Logger;
067:
068: import javax.servlet.ServletConfig;
069: import javax.servlet.ServletException;
070: import javax.servlet.http.*;
071: import javax.xml.soap.*;
072:
073: /**
074: * Sample servlet that receives messages containing text to be translated,
075: * does the translation, and sends back a message with translations as
076: * attachments -or- in SOAPBody of the reply message.
077: *
078: * @author Manveen Kaur (manveen.kaur@sun.com)
079: *
080: */
081:
082: public class ReceivingServlet extends HttpServlet {
083:
084: private static String NS_PREFIX = "saaj";
085: private static String NS_URI = "http://java.sun.com/saaj/samples/translation";
086: private static Logger logger = Logger
087: .getLogger("Samples/Translator");
088:
089: private String french = "";
090: private String german = "";
091: private String italian = "";
092:
093: static MessageFactory msgFactory = null;
094:
095: public void init(ServletConfig servletConfig)
096: throws ServletException {
097: super .init(servletConfig);
098: try {
099: // Initialize it to the default.
100: msgFactory = MessageFactory.newInstance();
101: } catch (SOAPException ex) {
102: throw new ServletException(
103: "Unable to create message factory"
104: + ex.getMessage());
105: }
106: }
107:
108: public void doPost(HttpServletRequest req, HttpServletResponse resp)
109: throws ServletException, IOException {
110:
111: try {
112: // Get all the headers from the HTTP request.
113: MimeHeaders headers = getHeaders(req);
114:
115: // Get the body of the HTTP request.
116: InputStream is = req.getInputStream();
117:
118: // Now internalize the contents of a HTTP request and
119: // create a SOAPMessage
120: SOAPMessage msg = msgFactory.createMessage(headers, is);
121:
122: SOAPMessage reply = null;
123:
124: // There are no replies in case of an OnewayListener.
125: reply = onMessage(msg);
126:
127: if (reply != null) {
128:
129: // Need to saveChanges 'cos we're going to use the
130: // MimeHeaders to set HTTP response information. These
131: // MimeHeaders are generated as part of the save.
132:
133: if (reply.saveRequired()) {
134: reply.saveChanges();
135: }
136:
137: resp.setStatus(HttpServletResponse.SC_OK);
138:
139: putHeaders(reply.getMimeHeaders(), resp);
140:
141: // Write out the message on the response stream.
142: OutputStream os = resp.getOutputStream();
143: reply.writeTo(os);
144:
145: os.flush();
146:
147: } else
148: resp.setStatus(HttpServletResponse.SC_NO_CONTENT);
149:
150: } catch (Exception ex) {
151: throw new ServletException("POST failed " + ex.getMessage());
152: }
153: }
154:
155: static MimeHeaders getHeaders(HttpServletRequest req) {
156:
157: Enumeration enumeration = req.getHeaderNames();
158: MimeHeaders headers = new MimeHeaders();
159:
160: while (enumeration.hasMoreElements()) {
161: String headerName = (String) enumeration.nextElement();
162: String headerValue = req.getHeader(headerName);
163:
164: StringTokenizer values = new StringTokenizer(headerValue,
165: ",");
166: while (values.hasMoreTokens())
167: headers
168: .addHeader(headerName, values.nextToken()
169: .trim());
170: }
171:
172: return headers;
173: }
174:
175: static void putHeaders(MimeHeaders headers, HttpServletResponse res) {
176:
177: Iterator it = headers.getAllHeaders();
178: while (it.hasNext()) {
179: MimeHeader header = (MimeHeader) it.next();
180:
181: String[] values = headers.getHeader(header.getName());
182: if (values.length == 1)
183: res.setHeader(header.getName(), header.getValue());
184: else {
185: StringBuffer concat = new StringBuffer();
186: int i = 0;
187: while (i < values.length) {
188: if (i != 0)
189: concat.append(',');
190: concat.append(values[i++]);
191: }
192:
193: res.setHeader(header.getName(), concat.toString());
194: }
195: }
196: }
197:
198: // This is the application code for handling the message.. Once the
199: // message is received the application can retrieve the soap part, the
200: // attachment part if there are any, or any other information from the
201: // message.
202:
203: public SOAPMessage onMessage(SOAPMessage message) {
204: SOAPMessage msg = null;
205:
206: try {
207:
208: System.out
209: .println("\n************** REQUEST ***************\n");
210:
211: message.writeTo(System.out);
212: FileOutputStream os = new FileOutputStream("request.msg");
213: message.writeTo(os);
214: os.close();
215:
216: SOAPEnvelope envelope = message.getSOAPPart().getEnvelope();
217: SOAPHeader header = envelope.getHeader();
218: SOAPBody body = envelope.getBody();
219:
220: // Extracting Proxy information from SOAPHeader.
221: String host = extract(envelope, header, "ProxyHost");
222:
223: String port = extract(envelope, header, "ProxyPort");
224:
225: String translationAs = extract(envelope, header,
226: "TranslationAs");
227:
228: // Extracting text to be translated from SOAPBody.
229: String text = extract(envelope, body, "Text");
230:
231: TranslationService ts;
232:
233: if ((host == null) || (host.equals("")) || (port == null)
234: || (port.equals(""))) {
235: ts = new TranslationService();
236: } else {
237: ts = new TranslationService(host, port);
238: }
239:
240: // Translate using the Translation Web-Service.
241: german = ts.translate(text,
242: TranslationService.ENGLISH_TO_GERMAN);
243: french = ts.translate(text,
244: TranslationService.ENGLISH_TO_FRENCH);
245: italian = ts.translate(text,
246: TranslationService.ENGLISH_TO_ITALIAN);
247:
248: // Create reply message
249: msg = msgFactory.createMessage();
250:
251: if (translationAs.equals("body")) {
252: addInSOAPBody(msg);
253: } else {
254: addAsAttachments(msg);
255: }
256:
257: if (msg.saveRequired())
258: msg.saveChanges();
259:
260: } catch (Exception e) {
261: logger.log(Level.SEVERE,
262: "Error in processing or replying to a message", e);
263: }
264:
265: return msg;
266: }
267:
268: private void addInSOAPBody(SOAPMessage msg) {
269: try {
270:
271: SOAPEnvelope envelope = msg.getSOAPPart().getEnvelope();
272: SOAPBody body = envelope.getBody();
273:
274: // Adding the translated text to SOAPBody.
275: body
276: .addBodyElement(
277: envelope.createName("FrenchText",
278: NS_PREFIX, NS_URI)).addTextNode(
279: french);
280:
281: body
282: .addBodyElement(
283: envelope.createName("GermanText",
284: NS_PREFIX, NS_URI)).addTextNode(
285: german);
286:
287: body.addBodyElement(
288: envelope.createName("ItalianText", NS_PREFIX,
289: NS_URI)).addTextNode(italian);
290:
291: } catch (Exception e) {
292: logger.log(Level.SEVERE,
293: "Error in adding translation to the body", e);
294: }
295: }
296:
297: private void addAsAttachments(SOAPMessage msg) {
298: // Adding the translations as attachments.
299: try {
300:
301: SOAPEnvelope envelope = msg.getSOAPPart().getEnvelope();
302:
303: AttachmentPart ap_french = msg.createAttachmentPart(french,
304: "text/plain; charset=ISO-8859-1");
305: msg.addAttachmentPart(ap_french);
306:
307: AttachmentPart ap_german = msg.createAttachmentPart(german,
308: "text/plain; charset=ISO-8859-1");
309: msg.addAttachmentPart(ap_german);
310:
311: AttachmentPart ap_italian = msg.createAttachmentPart(
312: italian, "text/plain; charset=ISO-8859-1");
313: msg.addAttachmentPart(ap_italian);
314:
315: } catch (Exception e) {
316: logger.log(Level.SEVERE,
317: "Error in adding translations as attachments", e);
318: }
319: }
320:
321: // extract the value of the first child element under element
322: // with this localname
323: private String extract(SOAPEnvelope envelope, SOAPElement element,
324: String localname) throws SOAPException {
325:
326: Iterator it = element.getChildElements(envelope.createName(
327: localname, NS_PREFIX, NS_URI));
328:
329: if (it.hasNext()) {
330: SOAPElement e = (SOAPElement) it.next();
331: return e.getValue();
332: }
333: logger.severe("Could not extract " + localname
334: + " from message");
335: return null;
336: }
337:
338: }
|