DefaultStringifier.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:6k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.io;
  19. import java.io.IOException;
  20. import java.nio.charset.UnsupportedCharsetException;
  21. import java.util.ArrayList;
  22. import org.apache.commons.codec.binary.Base64;
  23. import org.apache.hadoop.conf.Configuration;
  24. import org.apache.hadoop.io.serializer.Deserializer;
  25. import org.apache.hadoop.io.serializer.Serialization;
  26. import org.apache.hadoop.io.serializer.SerializationFactory;
  27. import org.apache.hadoop.io.serializer.Serializer;
  28. import org.apache.hadoop.util.GenericsUtil;
  29. /**
  30.  * DefaultStringifier is the default implementation of the {@link Stringifier}
  31.  * interface which stringifies the objects using base64 encoding of the
  32.  * serialized version of the objects. The {@link Serializer} and
  33.  * {@link Deserializer} are obtained from the {@link SerializationFactory}.
  34.  * <br>
  35.  * DefaultStringifier offers convenience methods to store/load objects to/from
  36.  * the configuration.
  37.  * 
  38.  * @param <T> the class of the objects to stringify
  39.  */
  40. public class DefaultStringifier<T> implements Stringifier<T> {
  41.   private static final String SEPARATOR = ",";
  42.   private Serializer<T> serializer;
  43.   private Deserializer<T> deserializer;
  44.   private DataInputBuffer inBuf;
  45.   private DataOutputBuffer outBuf;
  46.   public DefaultStringifier(Configuration conf, Class<T> c) {
  47.     SerializationFactory factory = new SerializationFactory(conf);
  48.     this.serializer = factory.getSerializer(c);
  49.     this.deserializer = factory.getDeserializer(c);
  50.     this.inBuf = new DataInputBuffer();
  51.     this.outBuf = new DataOutputBuffer();
  52.     try {
  53.       serializer.open(outBuf);
  54.       deserializer.open(inBuf);
  55.     } catch (IOException ex) {
  56.       throw new RuntimeException(ex);
  57.     }
  58.   }
  59.   public T fromString(String str) throws IOException {
  60.     try {
  61.       byte[] bytes = Base64.decodeBase64(str.getBytes("UTF-8"));
  62.       inBuf.reset(bytes, bytes.length);
  63.       T restored = deserializer.deserialize(null);
  64.       return restored;
  65.     } catch (UnsupportedCharsetException ex) {
  66.       throw new IOException(ex.toString());
  67.     }
  68.   }
  69.   public String toString(T obj) throws IOException {
  70.     outBuf.reset();
  71.     serializer.serialize(obj);
  72.     byte[] buf = new byte[outBuf.getLength()];
  73.     System.arraycopy(outBuf.getData(), 0, buf, 0, buf.length);
  74.     return new String(Base64.encodeBase64(buf));
  75.   }
  76.   public void close() throws IOException {
  77.     inBuf.close();
  78.     outBuf.close();
  79.     deserializer.close();
  80.     serializer.close();
  81.   }
  82.   /**
  83.    * Stores the item in the configuration with the given keyName.
  84.    * 
  85.    * @param <K>  the class of the item
  86.    * @param conf the configuration to store
  87.    * @param item the object to be stored
  88.    * @param keyName the name of the key to use
  89.    * @throws IOException : forwards Exceptions from the underlying 
  90.    * {@link Serialization} classes. 
  91.    */
  92.   public static <K> void store(Configuration conf, K item, String keyName)
  93.   throws IOException {
  94.     DefaultStringifier<K> stringifier = new DefaultStringifier<K>(conf,
  95.         GenericsUtil.getClass(item));
  96.     conf.set(keyName, stringifier.toString(item));
  97.     stringifier.close();
  98.   }
  99.   /**
  100.    * Restores the object from the configuration.
  101.    * 
  102.    * @param <K> the class of the item
  103.    * @param conf the configuration to use
  104.    * @param keyName the name of the key to use
  105.    * @param itemClass the class of the item
  106.    * @return restored object
  107.    * @throws IOException : forwards Exceptions from the underlying 
  108.    * {@link Serialization} classes.
  109.    */
  110.   public static <K> K load(Configuration conf, String keyName,
  111.       Class<K> itemClass) throws IOException {
  112.     DefaultStringifier<K> stringifier = new DefaultStringifier<K>(conf,
  113.         itemClass);
  114.     try {
  115.       String itemStr = conf.get(keyName);
  116.       return stringifier.fromString(itemStr);
  117.     } finally {
  118.       stringifier.close();
  119.     }
  120.   }
  121.   /**
  122.    * Stores the array of items in the configuration with the given keyName.
  123.    * 
  124.    * @param <K> the class of the item
  125.    * @param conf the configuration to use 
  126.    * @param items the objects to be stored
  127.    * @param keyName the name of the key to use
  128.    * @throws IndexOutOfBoundsException if the items array is empty
  129.    * @throws IOException : forwards Exceptions from the underlying 
  130.    * {@link Serialization} classes.         
  131.    */
  132.   public static <K> void storeArray(Configuration conf, K[] items,
  133.       String keyName) throws IOException {
  134.     DefaultStringifier<K> stringifier = new DefaultStringifier<K>(conf, 
  135.         GenericsUtil.getClass(items[0]));
  136.     try {
  137.       StringBuilder builder = new StringBuilder();
  138.       for (K item : items) {
  139.         builder.append(stringifier.toString(item)).append(SEPARATOR);
  140.       }
  141.       conf.set(keyName, builder.toString());
  142.     }
  143.     finally {
  144.       stringifier.close();
  145.     }
  146.   }
  147.   /**
  148.    * Restores the array of objects from the configuration.
  149.    * 
  150.    * @param <K> the class of the item
  151.    * @param conf the configuration to use
  152.    * @param keyName the name of the key to use
  153.    * @param itemClass the class of the item
  154.    * @return restored object
  155.    * @throws IOException : forwards Exceptions from the underlying 
  156.    * {@link Serialization} classes.
  157.    */
  158.   public static <K> K[] loadArray(Configuration conf, String keyName,
  159.       Class<K> itemClass) throws IOException {
  160.     DefaultStringifier<K> stringifier = new DefaultStringifier<K>(conf,
  161.         itemClass);
  162.     try {
  163.       String itemStr = conf.get(keyName);
  164.       ArrayList<K> list = new ArrayList<K>();
  165.       String[] parts = itemStr.split(SEPARATOR);
  166.       for (String part : parts) {
  167.         if (!part.equals(""))
  168.           list.add(stringifier.fromString(part));
  169.       }
  170.       return GenericsUtil.toArray(itemClass, list);
  171.     }
  172.     finally {
  173.       stringifier.close();
  174.     }
  175.   }
  176. }