content: package hxy.server.socket.util;
  
  import com.dyuproject.protostuff.LinkedBuffer;
  import com.dyuproject.protostuff.ProtobufIOUtil;
  import com.dyuproject.protostuff.Schema;
  import com.dyuproject.protostuff.runtime.RuntimeSchema;
  import org.objenesis.Objenesis;
  import org.objenesis.ObjenesisStd;
  
  import java.io.InputStream;
  import java.io.UnsupportedEncodingException;
  import java.util.Map;
  import java.util.concurrent.ConcurrentHashMap;
  
  
  /**
   * @author 作者 huangxinyu
   * @version 创建时间：2018年1月9日 下午7:41:24
   * Protostuff序列化工具
   */
  public class ProtoUtil {
      private static Map<Class<?>, Schema<?>> cachedSchema = new ConcurrentHashMap<>();
  
      private static Objenesis objenesis = new ObjenesisStd(true);
  
      private ProtoUtil() {
      }
  
      @SuppressWarnings("unchecked")
      private static <T> Schema<T> getSchema(Class<T> cls) {
          Schema<T> schema = (Schema<T>) cachedSchema.get(cls);
          if (schema == null) {
              schema = RuntimeSchema.createFrom(cls);
              if (schema != null) {
                  cachedSchema.put(cls, schema);
              }
          }
          return schema;
      }
  
      @SuppressWarnings("unchecked")
      public static <T> String serializeToString(T obj) {
          try {
              return new String(serializeToByte(obj), "ISO8859-1");
          } catch (UnsupportedEncodingException e) {
              throw new IllegalStateException(e.getMessage(), e);
          }
      }
  
      public static <T> T deserializeFromString(String data, Class<T> cls) {
          try {
              return deserializeFromByte(data.getBytes("ISO8859-1"), cls);
          } catch (UnsupportedEncodingException e) {
              throw new IllegalStateException(e.getMessage(), e);
          }
      }
  
  
      @SuppressWarnings("unchecked")
      public static <T> byte[] serializeToByte(T obj) {
          Class<T> cls = (Class<T>) obj.getClass();
          LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
          try {
              Schema<T> schema = getSchema(cls);
              return ProtobufIOUtil.toByteArray(obj, schema, buffer);
          } catch (Exception e) {
              throw new IllegalStateException(e.getMessage(), e);
          } finally {
              buffer.clear();
          }
      }
  
      public static <T> T deserializeFromByte(byte[] data, Class<T> cls) {
          try {
              T message = (T) objenesis.newInstance(cls);
              Schema<T> schema = getSchema(cls);
              ProtobufIOUtil.mergeFrom(data, message, schema);
              return message;
          } catch (Exception e) {
              throw new IllegalStateException(e.getMessage(), e);
          }
      }
  
      public static <T> T deserializeFromByte(InputStream data, Class<T> cls) {
          try {
              T message = (T) objenesis.newInstance(cls);
              Schema<T> schema = getSchema(cls);
              ProtobufIOUtil.mergeFrom(data, message, schema);
              return message;
          } catch (Exception e) {
              throw new IllegalStateException(e.getMessage(), e);
          }
      }
  }
  