ServletOutputStream.java
上传用户:tanyanyong
上传日期:2013-06-23
资源大小:1355k
文件大小:11k
源码类别:

电子政务应用

开发平台:

MultiPlatform

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999 The Apache Software Foundation.  All rights 
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer. 
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution, if
  20.  *    any, must include the following acknowlegement:  
  21.  *       "This product includes software developed by the 
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowlegement may appear in the software itself,
  24.  *    if and wherever such third-party acknowlegements normally appear.
  25.  *
  26.  * 4. The names "The Jakarta Project", "Tomcat", and "Apache Software
  27.  *    Foundation" must not be used to endorse or promote products derived
  28.  *    from this software without prior written permission. For written 
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache"
  32.  *    nor may "Apache" appear in their names without prior written
  33.  *    permission of the Apache Group.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation.  For more
  51.  * information on the Apache Software Foundation, please see
  52.  * <http://www.apache.org/>.
  53.  *
  54.  * ====================================================================
  55.  *
  56.  * This source code implements specifications defined by the Java
  57.  * Community Process. In order to remain compliant with the specification
  58.  * DO NOT add / change / or delete method signatures!
  59.  */
  60. package javax.servlet;
  61. import java.io.OutputStream;
  62. import java.io.IOException;
  63. import java.io.CharConversionException;
  64. import java.text.MessageFormat;
  65. import java.util.ResourceBundle;
  66. /**
  67.  * Provides an output stream for sending binary data to the
  68.  * client. A <code>ServletOutputStream</code> object is normally retrieved 
  69.  * via the {@link ServletResponse#getOutputStream} method.
  70.  *
  71.  * <p>This is an abstract class that the servlet container implements.
  72.  * Subclasses of this class
  73.  * must implement the <code>java.io.OutputStream.write(int)</code>
  74.  * method.
  75.  *
  76.  * 
  77.  * @author  Various
  78.  * @version  $Version$
  79.  *
  80.  * @see  ServletResponse
  81.  *
  82.  */
  83. public abstract class ServletOutputStream extends OutputStream {
  84.     private static final String LSTRING_FILE = "javax.servlet.LocalStrings";
  85.     private static ResourceBundle lStrings =
  86. ResourceBundle.getBundle(LSTRING_FILE);
  87.     
  88.     /**
  89.      *
  90.      * Does nothing, because this is an abstract class.
  91.      *
  92.      */
  93.     protected ServletOutputStream() { }
  94.     /**
  95.      * Writes a <code>String</code> to the client, 
  96.      * without a carriage return-line feed (CRLF) 
  97.      * character at the end.
  98.      *
  99.      *
  100.      * @param s the <code>String</code to send to the client
  101.      *
  102.      * @exception IOException  if an input or output exception occurred
  103.      *
  104.      */
  105.     public void print(String s) throws IOException {
  106. if (s==null) s="null";
  107. int len = s.length();
  108. for (int i = 0; i < len; i++) {
  109.     char c = s.charAt (i);
  110.     //
  111.     // XXX NOTE:  This is clearly incorrect for many strings,
  112.     // but is the only consistent approach within the current
  113.     // servlet framework.  It must suffice until servlet output
  114.     // streams properly encode their output.
  115.     //
  116.     if ((c & 0xff00) != 0) { // high order byte must be zero
  117. String errMsg = lStrings.getString("err.not_iso8859_1");
  118. Object[] errArgs = new Object[1];
  119. errArgs[0] = new Character(c);
  120. errMsg = MessageFormat.format(errMsg, errArgs);
  121. throw new CharConversionException(errMsg);
  122.     }
  123.     write (c);
  124. }
  125.     }
  126.     /**
  127.      * Writes a <code>boolean</code> value to the client,
  128.      * with no carriage return-line feed (CRLF) 
  129.      * character at the end.
  130.      *
  131.      * @param b the <code>boolean</code> value 
  132.      * to send to the client
  133.      *
  134.      * @exception IOException  if an input or output exception occurred
  135.      *
  136.      */
  137.     public void print(boolean b) throws IOException {
  138. String msg;
  139. if (b) {
  140.     msg = lStrings.getString("value.true");
  141. } else {
  142.     msg = lStrings.getString("value.false");
  143. }
  144. print(msg);
  145.     }
  146.     /**
  147.      * Writes a character to the client,
  148.      * with no carriage return-line feed (CRLF) 
  149.      * at the end.
  150.      *
  151.      * @param c the character to send to the client
  152.      *
  153.      * @exception IOException  if an input or output exception occurred
  154.      *
  155.      */
  156.     public void print(char c) throws IOException {
  157. print(String.valueOf(c));
  158.     }
  159.     /**
  160.      *
  161.      * Writes an int to the client,
  162.      * with no carriage return-line feed (CRLF) 
  163.      * at the end.
  164.      *
  165.      * @param i the int to send to the client
  166.      *
  167.      * @exception IOException  if an input or output exception occurred
  168.      *
  169.      */  
  170.     public void print(int i) throws IOException {
  171. print(String.valueOf(i));
  172.     }
  173.  
  174.     /**
  175.      * 
  176.      * Writes a <code>long</code> value to the client,
  177.      * with no carriage return-line feed (CRLF) at the end.
  178.      *
  179.      * @param l the <code>long</code> value 
  180.      * to send to the client
  181.      *
  182.      * @exception IOException  if an input or output exception 
  183.      * occurred
  184.      * 
  185.      */
  186.     public void print(long l) throws IOException {
  187. print(String.valueOf(l));
  188.     }
  189.     /**
  190.      *
  191.      * Writes a <code>float</code> value to the client,
  192.      * with no carriage return-line feed (CRLF) at the end.
  193.      *
  194.      * @param f the <code>float</code> value
  195.      * to send to the client
  196.      *
  197.      * @exception IOException if an input or output exception occurred
  198.      *
  199.      *
  200.      */
  201.     public void print(float f) throws IOException {
  202. print(String.valueOf(f));
  203.     }
  204.     /**
  205.      *
  206.      * Writes a <code>double</code> value to the client,
  207.      * with no carriage return-line feed (CRLF) at the end.
  208.      * 
  209.      * @param d the <code>double</code> value
  210.      * to send to the client
  211.      *
  212.      * @exception IOException  if an input or output exception occurred
  213.      *
  214.      */
  215.     public void print(double d) throws IOException {
  216. print(String.valueOf(d));
  217.     }
  218.     /**
  219.      * Writes a carriage return-line feed (CRLF)
  220.      * to the client.
  221.      *
  222.      *
  223.      *
  224.      * @exception IOException  if an input or output exception occurred
  225.      *
  226.      */
  227.     public void println() throws IOException {
  228. print("rn");
  229.     }
  230.     /**
  231.      * Writes a <code>String</code> to the client, 
  232.      * followed by a carriage return-line feed (CRLF).
  233.      *
  234.      *
  235.      * @param s the </code>String</code> to write to the client
  236.      *
  237.      * @exception IOException  if an input or output exception occurred
  238.      *
  239.      */
  240.     public void println(String s) throws IOException {
  241. print(s);
  242. println();
  243.     }
  244.     /**
  245.      *
  246.      * Writes a <code>boolean</code> value to the client, 
  247.      * followed by a 
  248.      * carriage return-line feed (CRLF).
  249.      *
  250.      *
  251.      * @param b the <code>boolean</code> value 
  252.      * to write to the client
  253.      *
  254.      * @exception IOException  if an input or output exception occurred
  255.      *
  256.      */
  257.     public void println(boolean b) throws IOException {
  258. print(b);
  259. println();
  260.     }
  261.     /**
  262.      *
  263.      * Writes a character to the client, followed by a carriage
  264.      * return-line feed (CRLF).
  265.      *
  266.      * @param c the character to write to the client
  267.      *
  268.      * @exception IOException  if an input or output exception occurred
  269.      *
  270.      */
  271.     public void println(char c) throws IOException {
  272. print(c);
  273. println();
  274.     }
  275.     /**
  276.      *
  277.      * Writes an int to the client, followed by a 
  278.      * carriage return-line feed (CRLF) character.
  279.      *
  280.      *
  281.      * @param i the int to write to the client
  282.      *
  283.      * @exception IOException  if an input or output exception occurred
  284.      *
  285.      */
  286.     public void println(int i) throws IOException {
  287. print(i);
  288. println();
  289.     }
  290.     /**  
  291.      *
  292.      * Writes a <code>long</code> value to the client, followed by a 
  293.      * carriage return-line feed (CRLF).
  294.      *
  295.      *
  296.      * @param l the <code>long</code> value to write to the client
  297.      *
  298.      * @exception IOException  if an input or output exception occurred
  299.      *
  300.      */  
  301.     public void println(long l) throws IOException {
  302. print(l);
  303. println();
  304.     }
  305.     /**
  306.      *
  307.      * Writes a <code>float</code> value to the client, 
  308.      * followed by a carriage return-line feed (CRLF).
  309.      *
  310.      * @param f the <code>float</code> value 
  311.      * to write to the client
  312.      *
  313.      *
  314.      * @exception IOException  if an input or output exception 
  315.      * occurred
  316.      *
  317.      */
  318.     public void println(float f) throws IOException {
  319. print(f);
  320. println();
  321.     }
  322.     /**
  323.      *
  324.      * Writes a <code>double</code> value to the client, 
  325.      * followed by a carriage return-line feed (CRLF).
  326.      *
  327.      *
  328.      * @param d the <code>double</code> value
  329.      * to write to the client
  330.      *
  331.      * @exception IOException  if an input or output exception occurred
  332.      *
  333.      */
  334.     public void println(double d) throws IOException {
  335. print(d);
  336. println();
  337.     }
  338. }