001 /** 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.camel.converter; 018 019 import java.io.BufferedInputStream; 020 import java.io.BufferedOutputStream; 021 import java.io.BufferedReader; 022 import java.io.BufferedWriter; 023 import java.io.ByteArrayInputStream; 024 import java.io.ByteArrayOutputStream; 025 import java.io.File; 026 import java.io.FileInputStream; 027 import java.io.FileNotFoundException; 028 import java.io.FileOutputStream; 029 import java.io.FileReader; 030 import java.io.FileWriter; 031 import java.io.IOException; 032 import java.io.InputStream; 033 import java.io.InputStreamReader; 034 import java.io.ObjectInput; 035 import java.io.ObjectInputStream; 036 import java.io.ObjectOutput; 037 import java.io.ObjectOutputStream; 038 import java.io.OutputStream; 039 import java.io.OutputStreamWriter; 040 import java.io.Reader; 041 import java.io.StringReader; 042 import java.io.UnsupportedEncodingException; 043 import java.io.Writer; 044 import java.net.URL; 045 import java.util.Properties; 046 047 import javax.xml.transform.OutputKeys; 048 import javax.xml.transform.Source; 049 import javax.xml.transform.Transformer; 050 import javax.xml.transform.TransformerException; 051 import javax.xml.transform.TransformerFactory; 052 import javax.xml.transform.dom.DOMSource; 053 import javax.xml.transform.stream.StreamResult; 054 055 import org.apache.camel.Converter; 056 import org.apache.camel.Exchange; 057 import org.apache.camel.util.CollectionStringBuffer; 058 import org.apache.commons.logging.Log; 059 import org.apache.commons.logging.LogFactory; 060 061 /** 062 * Some core java.io based <a 063 * href="http://activemq.apache.org/camel/type-converter.html">Type Converters</a> 064 * 065 * @version $Revision: 63649 $ 066 */ 067 @Converter 068 public final class IOConverter { 069 private static final transient Log LOG = LogFactory.getLog(IOConverter.class); 070 071 /** 072 * Utility classes should not have a public constructor. 073 */ 074 private IOConverter() { 075 } 076 077 @Converter 078 public static InputStream toInputStream(URL url) throws IOException { 079 return url.openStream(); 080 } 081 082 @Converter 083 public static InputStream toInputStream(File file) throws FileNotFoundException { 084 return new BufferedInputStream(new FileInputStream(file)); 085 } 086 087 @Converter 088 public static BufferedReader toReader(File file) throws FileNotFoundException { 089 return new BufferedReader(new FileReader(file)); 090 } 091 092 @Converter 093 public static File toFile(String name) throws FileNotFoundException { 094 return new File(name); 095 } 096 097 @Converter 098 public static OutputStream toOutputStream(File file) throws FileNotFoundException { 099 return new BufferedOutputStream(new FileOutputStream(file)); 100 } 101 102 @Converter 103 public static BufferedWriter toWriter(File file) throws IOException { 104 return new BufferedWriter(new FileWriter(file)); 105 } 106 107 @Converter 108 public static Reader toReader(InputStream in) throws FileNotFoundException { 109 return new InputStreamReader(in); 110 } 111 112 @Converter 113 public static Writer toWriter(OutputStream out) throws FileNotFoundException { 114 return new OutputStreamWriter(out); 115 } 116 117 @Converter 118 public static StringReader toReader(String text) { 119 return new StringReader(text); 120 } 121 122 @Converter 123 public static InputStream toInputStream(String text) { 124 return toInputStream(text, null); 125 } 126 127 @Converter 128 public static InputStream toInputStream(String text, Exchange exchange) { 129 if (exchange != null) { 130 String charsetName = exchange.getProperty(Exchange.CHARSET_NAME, String.class); 131 if (charsetName != null) { 132 try { 133 return toInputStream(text.getBytes(charsetName)); 134 } catch (UnsupportedEncodingException e) { 135 LOG.warn("Can't convert the String into the bytes with the charset " + charsetName, e); 136 } 137 } 138 } 139 return toInputStream(text.getBytes()); 140 } 141 142 @Converter 143 public static InputStream toInputStream(BufferedReader buffer) throws IOException { 144 return toInputStream(toString(buffer), null); 145 } 146 147 @Converter 148 public static InputStream toInputStream(BufferedReader buffer, Exchange exchange) throws IOException { 149 return toInputStream(toString(buffer), exchange); 150 } 151 152 @Converter 153 public static InputStream toInputStrean(DOMSource source) throws TransformerException, IOException { 154 ByteArrayInputStream bais = new ByteArrayInputStream(toString(source).getBytes()); 155 return bais; 156 } 157 158 @Converter 159 public static String toString(byte[] data, Exchange exchange) { 160 if (exchange != null) { 161 String charsetName = exchange.getProperty(Exchange.CHARSET_NAME, String.class); 162 if (charsetName != null) { 163 try { 164 return new String(data, charsetName); 165 } catch (UnsupportedEncodingException e) { 166 LOG.warn("Can't convert the byte to String with the charset " + charsetName, e); 167 } 168 } 169 } 170 return new String(data); 171 } 172 173 174 @Converter 175 public static String toString(File file) throws IOException { 176 return toString(toReader(file)); 177 } 178 179 @Converter 180 public static byte[] toByteArray(File file) throws IOException { 181 return toBytes(toInputStream(file)); 182 } 183 184 @Converter 185 public static byte[] toByteArray(Reader reader) throws IOException { 186 if (reader instanceof BufferedReader) { 187 return toByteArray((BufferedReader)reader); 188 } else { 189 return toByteArray(new BufferedReader(reader)); 190 } 191 } 192 193 @Converter 194 public static String toString(URL url) throws IOException { 195 return toString(toInputStream(url)); 196 } 197 198 @Converter 199 public static String toString(Reader reader) throws IOException { 200 if (reader instanceof BufferedReader) { 201 return toString((BufferedReader)reader); 202 } else { 203 return toString(new BufferedReader(reader)); 204 } 205 } 206 207 @Converter 208 public static String toString(BufferedReader reader) throws IOException { 209 if (reader == null) { 210 return null; 211 } 212 try { 213 CollectionStringBuffer builder = new CollectionStringBuffer("\n"); 214 while (true) { 215 String line = reader.readLine(); 216 if (line == null) { 217 return builder.toString(); 218 } 219 builder.append(line); 220 } 221 } finally { 222 try { 223 reader.close(); 224 } catch (IOException e) { 225 LOG.warn("Failed to close stream: " + e, e); 226 } 227 } 228 } 229 230 @Converter 231 public static byte[] toByteArray(BufferedReader reader) throws IOException { 232 if (reader == null) { 233 return null; 234 } 235 236 StringBuilder sb = new StringBuilder(1024); 237 char[] buf = new char[1024]; 238 try { 239 int len = reader.read(buf); 240 if (len != -1) { 241 sb.append(buf, 0, len); 242 } 243 } finally { 244 try { 245 reader.close(); 246 } catch (IOException e) { 247 LOG.warn("Failed to close stream: " + e, e); 248 } 249 } 250 return sb.toString().getBytes(); 251 } 252 253 @Converter 254 public static String toString(InputStream in) throws IOException { 255 return toString(toReader(in)); 256 } 257 258 @Converter 259 public static String toString(Source source) throws TransformerException, IOException { 260 return toString(source, null); 261 } 262 263 @Converter 264 public static InputStream toInputStream(byte[] data) { 265 return new ByteArrayInputStream(data); 266 } 267 268 @Converter 269 public static ObjectOutput toObjectOutput(OutputStream stream) throws IOException { 270 if (stream instanceof ObjectOutput) { 271 return (ObjectOutput) stream; 272 } else { 273 return new ObjectOutputStream(stream); 274 } 275 } 276 277 @Converter 278 public static ObjectInput toObjectInput(InputStream stream) throws IOException { 279 if (stream instanceof ObjectInput) { 280 return (ObjectInput) stream; 281 } else { 282 return new ObjectInputStream(stream); 283 } 284 } 285 286 @Converter 287 public static byte[] toBytes(InputStream stream) throws IOException { 288 ByteArrayOutputStream bos = new ByteArrayOutputStream(); 289 copy(stream, bos); 290 return bos.toByteArray(); 291 } 292 293 public static void copy(InputStream stream, OutputStream os) throws IOException { 294 byte[] data = new byte[4096]; 295 int read = stream.read(data); 296 while (read != -1) { 297 os.write(data, 0, read); 298 read = stream.read(data); 299 } 300 os.flush(); 301 } 302 303 protected static String toString(Source source, Properties props) throws TransformerException, IOException { 304 ByteArrayOutputStream bos = new ByteArrayOutputStream(); 305 try { 306 StreamResult sr = new StreamResult(bos); 307 Transformer trans = TransformerFactory.newInstance().newTransformer(); 308 if (props == null) { 309 props = new Properties(); 310 props.put(OutputKeys.OMIT_XML_DECLARATION, "yes"); 311 } 312 trans.setOutputProperties(props); 313 trans.transform(source, sr); 314 } finally { 315 bos.close(); 316 } 317 return bos.toString(); 318 } 319 320 }