View Javadoc

    1   /*
    2    * Copyright 2012 The Netty Project
    3    *
    4    * The Netty Project licenses this file to you under the Apache License,
    5    * version 2.0 (the "License"); you may not use this file except in compliance
    6    * with the License. You may obtain a copy of the License at:
    7    *
    8    *   http://www.apache.org/licenses/LICENSE-2.0
    9    *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
    12   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
    13   * License for the specific language governing permissions and limitations
    14   * under the License.
    15   */
    16  package org.jboss.netty.handler.codec.serialization;
    17
    18  import java.io.DataOutputStream;
    19  import java.io.IOException;
    20  import java.io.ObjectOutput;
    21  import java.io.ObjectOutputStream;
    22  import java.io.OutputStream;
    23
    24  import org.jboss.netty.buffer.ChannelBuffer;
    25  import org.jboss.netty.buffer.ChannelBufferOutputStream;
    26  import org.jboss.netty.buffer.ChannelBuffers;
    27
    28  /**
    29   * An {@link ObjectOutput} which is interoperable with {@link ObjectDecoder}
    30   * and {@link ObjectDecoderInputStream}.
    31   */
    32  public class ObjectEncoderOutputStream extends OutputStream implements
    33          ObjectOutput {
    34
    35      private final DataOutputStream out;
    36      private final int estimatedLength;
    37
    38      /**
    39       * Creates a new {@link ObjectOutput} with the estimated length of 512
    40       * bytes.
    41       *
    42       * @param out
    43       *        the {@link OutputStream} where the serialized form will be
    44       *        written out
    45       */
    46      public ObjectEncoderOutputStream(OutputStream out) {
    47          this(out, 512);
    48      }
    49
    50      /**
    51       * Creates a new {@link ObjectOutput}.
    52       *
    53       * @param out
    54       *        the {@link OutputStream} where the serialized form will be
    55       *        written out
    56       *
    57       * @param estimatedLength
    58       *        the estimated byte length of the serialized form of an object.
    59       *        If the length of the serialized form exceeds this value, the
    60       *        internal buffer will be expanded automatically at the cost of
    61       *        memory bandwidth.  If this value is too big, it will also waste
    62       *        memory bandwidth.  To avoid unnecessary memory copy or allocation
    63       *        cost, please specify the properly estimated value.
    64       */
    65      public ObjectEncoderOutputStream(OutputStream out, int estimatedLength) {
    66          if (out == null) {
    67              throw new NullPointerException("out");
    68          }
    69          if (estimatedLength < 0) {
    70              throw new IllegalArgumentException("estimatedLength: " + estimatedLength);
    71          }
    72
    73          if (out instanceof DataOutputStream) {
    74              this.out = (DataOutputStream) out;
    75          } else {
    76              this.out = new DataOutputStream(out);
    77          }
    78          this.estimatedLength = estimatedLength;
    79      }
    80
    81      public void writeObject(Object obj) throws IOException {
    82          ChannelBufferOutputStream bout = new ChannelBufferOutputStream(
    83                  ChannelBuffers.dynamicBuffer(estimatedLength));
    84          ObjectOutputStream oout = new CompactObjectOutputStream(bout);
    85          oout.writeObject(obj);
    86          oout.flush();
    87          oout.close();
    88
    89          ChannelBuffer buffer = bout.buffer();
    90          int objectSize = buffer.readableBytes();
    91          writeInt(objectSize);
    92          buffer.getBytes(0, this, objectSize);
    93      }
    94
    95      @Override
    96      public void write(int b) throws IOException {
    97          out.write(b);
    98      }
    99
    100     @Override
    101     public void close() throws IOException {
    102         out.close();
    103     }
    104
    105     @Override
    106     public void flush() throws IOException {
    107         out.flush();
    108     }
    109
    110     public final int size() {
    111         return out.size();
    112     }
    113
    114     @Override
    115     public void write(byte[] b, int off, int len) throws IOException {
    116         out.write(b, off, len);
    117     }
    118
    119     @Override
    120     public void write(byte[] b) throws IOException {
    121         out.write(b);
    122     }
    123
    124     public final void writeBoolean(boolean v) throws IOException {
    125         out.writeBoolean(v);
    126     }
    127
    128     public final void writeByte(int v) throws IOException {
    129         out.writeByte(v);
    130     }
    131
    132     public final void writeBytes(String s) throws IOException {
    133         out.writeBytes(s);
    134     }
    135
    136     public final void writeChar(int v) throws IOException {
    137         out.writeChar(v);
    138     }
    139
    140     public final void writeChars(String s) throws IOException {
    141         out.writeChars(s);
    142     }
    143
    144     public final void writeDouble(double v) throws IOException {
    145         out.writeDouble(v);
    146     }
    147
    148     public final void writeFloat(float v) throws IOException {
    149         out.writeFloat(v);
    150     }
    151
    152     public final void writeInt(int v) throws IOException {
    153         out.writeInt(v);
    154     }
    155
    156     public final void writeLong(long v) throws IOException {
    157         out.writeLong(v);
    158     }
    159
    160     public final void writeShort(int v) throws IOException {
    161         out.writeShort(v);
    162     }
    163
    164     public final void writeUTF(String str) throws IOException {
    165         out.writeUTF(str);
    166     }
    167 }