Java Code Examples for io.protostuff.runtime.RuntimeSchema#getSchema()

/**
 * Description: <br>
 * 
 * @author 王伟<br>
 * @taskId <br>
 * @param clazz
 * @param data
 * @param <T> T
 * @return T
 * @throws UtilException <br>
 */
@SuppressWarnings("unchecked")
public static <T> T unserial(final Class<T> clazz, final byte[] data) throws UtilException {
    T result = null;
    if (data != null && data.length > 0) {
        try {
            if (Map.class.isAssignableFrom(clazz)) {
                result = (T) jdkUnserial(data);
            }
            else {
                Schema<T> schema = RuntimeSchema.getSchema(clazz);
                result = clazz.newInstance();
                ProtostuffIOUtil.mergeFrom(data, result, schema);
            }
        }
        catch (Exception e) {
            throw new UtilException(e, ErrorCodeDef.UNSERIALIZE_ERROR, DataUtil.byte2HexStr(data));
        }
    }
    return result;
}
 

@Override
public <T> T readObject(InputBuf inputBuf, Class<T> clazz) {
    Schema<T> schema = RuntimeSchema.getSchema(clazz);
    T msg = schema.newMessage();

    Input input = Inputs.getInput(inputBuf);
    try {
        schema.mergeFrom(input, msg);
        Inputs.checkLastTagWas(input, 0);
    } catch (IOException e) {
        ThrowUtil.throwException(e);
    } finally {
        inputBuf.release();
    }

    return msg;
}
 

@SuppressWarnings("unchecked")
@Override
public <T> byte[] writeObject(T obj) {
    Schema<T> schema = RuntimeSchema.getSchema((Class<T>) obj.getClass());

    LinkedBuffer buf = LinkedBuffers.getLinkedBuffer();
    Output output = Outputs.getOutput(buf);
    try {
        schema.writeTo(output, obj);
        return Outputs.toByteArray(output);
    } catch (IOException e) {
        ThrowUtil.throwException(e);
    } finally {
        LinkedBuffers.resetBuf(buf); // for reuse
    }

    return null; // never get here
}
 

public void testFoo() throws Exception
{
    Schema<Foo> schema = RuntimeSchema.getSchema(Foo.class);

    Foo fooCompare = foo;
    Foo dfoo = new Foo();

    byte[] data = JsonIOUtil.toByteArray(fooCompare, schema, true);
    JsonIOUtil.mergeFrom(data, dfoo, schema, true);
    SerializableObjects.assertEquals(fooCompare, dfoo);
}
 

public void testBaz() throws Exception
{
    Schema<Baz> schema = RuntimeSchema.getSchema(Baz.class);

    for (Baz bazCompare : new Baz[] { baz, negativeBaz })
    {
        Baz dbaz = new Baz();

        byte[] data = JsonIOUtil.toByteArray(bazCompare, schema, false);
        JsonIOUtil.mergeFrom(data, dbaz, schema, false);
        SerializableObjects.assertEquals(bazCompare, dbaz);
    }
}
 

public static <T> T deserialize(byte[] bytes, Class<T> beanClass) {
    if (bytes == null || bytes.length == 0) {
        return null;
    }

    T instance = null;
    try {
        instance = beanClass.newInstance();
    } catch (Exception e) {
        throw new RpcException(e);
    }
    Schema<T> schema = RuntimeSchema.getSchema(beanClass);
    ProtostuffIOUtil.mergeFrom(bytes, instance, schema);
    return instance;
}
 

public void testBar() throws Exception
{
    Schema<Bar> schema = RuntimeSchema.getSchema(Bar.class);

    for (Bar barCompare : new Bar[] { bar, negativeBar })
    {
        Bar dbar = new Bar();

        byte[] data = JsonXIOUtil.toByteArray(barCompare, schema, true, buf());
        JsonIOUtil.mergeFrom(data, dbar, schema, true);
        SerializableObjects.assertEquals(barCompare, dbar);
    }
}
 

public ProtoMarshaller(Type type) {
    if (type != null) {
        Class clazz;
        if (type instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) type;
            clazz = ((Class) pt.getRawType());
        } else {
            clazz = (Class) type;
        }
        this.responseSchema = RuntimeSchema.getSchema(clazz);
    }
}
 

/**
 * 获取某个对象的实例构建器 
 * @param _cls 实例化对象的类
 * @return 对应类的实例构建器
 */
private static < T > Schema< T > _get_schema( Class< T > _cls ) {
	@SuppressWarnings( "unchecked" )
	Schema< T > schema = ( Schema< T > ) cachedSchema.get( _cls );
	if ( schema == null ) {
		schema = RuntimeSchema.getSchema( _cls );
		if ( schema != null ) {
			cachedSchema.put( _cls , schema );
		}
	}
	return schema;
}
 

private static Object readContent(final EventType eventType, final byte[] content) {
    final Class<?> targetClass = eventType.getTargetClass();
    if (targetClass == null) {
        LOG.error("Cannot read clazz header for given EventType value {}, missing mapping", eventType.getValue());
        throw new MessageConversionException("Missing mapping of EventType for value " + eventType.getValue());
    }
    @SuppressWarnings("unchecked")
    final Schema<Object> schema = (Schema<Object>) RuntimeSchema.getSchema(targetClass);
    final Object deserializeEvent = schema.newMessage();
    ProtobufIOUtil.mergeFrom(content, deserializeEvent, schema);
    return deserializeEvent;
}
 

public void testPolymorphic() throws Exception
{
    Schema<Zoo> schema = RuntimeSchema.getSchema(Zoo.class);
    Pipe.Schema<Zoo> pipeSchema = ((RuntimeSchema<Zoo>) schema).getPipeSchema();

    Zoo zoo = PolymorphicSerializationTest.filledZoo();

    // numeric only
    protobufRoundTrip(zoo, schema, pipeSchema, true);
    protostuffRoundTrip(zoo, schema, pipeSchema, true);
}
 

private static byte[] writeClassHeader(final Class<?> clazz) {
    final EventType clazzEventType = EventType.from(clazz);
    if (clazzEventType == null) {
        LOG.error("There is no mapping to EventType for the given class {}", clazz);
        throw new MessageConversionException("Missing EventType for given class : " + clazz);
    }
    @SuppressWarnings("unchecked")
    final Schema<Object> schema = (Schema<Object>) RuntimeSchema
            .getSchema((Class<?>) EventType.class);
    final LinkedBuffer buffer = LinkedBuffer.allocate();
    return ProtobufIOUtil.toByteArray(clazzEventType, schema, buffer);
}
 

public void testPolymorphic() throws Exception
{
    Schema<Zoo> schema = RuntimeSchema.getSchema(Zoo.class);
    Zoo zooCompare = PolymorphicSerializationTest.filledZoo();

    Zoo dzoo = new Zoo();

    byte[] data = JsonXIOUtil.toByteArray(zooCompare, schema, true, buf());

    JsonIOUtil.mergeFrom(data, dzoo, schema, true);
    SerializableObjects.assertEquals(zooCompare, dzoo);
}
 

public void testBaz() throws Exception
{
    Schema<Baz> schema = RuntimeSchema.getSchema(Baz.class);
    Pipe.Schema<Baz> pipeSchema = ((RuntimeSchema<Baz>) schema).getPipeSchema();

    Baz baz = SerializableObjects.baz;

    protobufRoundTrip(baz, schema, pipeSchema, false);
    protostuffRoundTrip(baz, schema, pipeSchema, false);

    // numeric
    protobufRoundTrip(baz, schema, pipeSchema, true);
    protostuffRoundTrip(baz, schema, pipeSchema, true);
}
 

public void testBaz() throws Exception
{
    Schema<Baz> schema = RuntimeSchema.getSchema(Baz.class);

    for (Baz bazCompare : new Baz[] { baz, negativeBaz })
    {
        Baz dbaz = new Baz();

        byte[] data = JsonXIOUtil.toByteArray(bazCompare, schema, true, buf());
        JsonIOUtil.mergeFrom(data, dbaz, schema, true);
        SerializableObjects.assertEquals(bazCompare, dbaz);
    }
}
 

public static <T extends Query> T deserialize(String queryImplClassName, Text columnVisibility, Value value) throws InvalidProtocolBufferException,
                ClassNotFoundException {
    @SuppressWarnings("unchecked")
    Class<T> queryClass = (Class<T>) Class.forName(queryImplClassName);
    byte[] b = value.get();
    Schema<T> schema = RuntimeSchema.getSchema(queryClass);
    T queryImpl = schema.newMessage();
    ProtobufIOUtil.mergeFrom(b, queryImpl, schema);
    queryImpl.setColumnVisibility(columnVisibility.toString());
    return queryImpl;
}
 

public static <T> byte[] encode(T object, Class<T> clazz) {
    Schema<T> schema = RuntimeSchema.getSchema(clazz);
    LinkedBuffer buffer = LinkedBuffer.allocate();
    return ProtostuffIOUtil.toByteArray(object, schema, buffer);
}
 

private static EventType readClassHeader(final byte[] typeInformation) {
    final Schema<EventType> schema = RuntimeSchema.getSchema(EventType.class);
    final EventType deserializedType = schema.newMessage();
    ProtobufIOUtil.mergeFrom(typeInformation, deserializedType, schema);
    return deserializedType;
}
 

@Override
protected ObjectReader createReader(final InputStream is, final Class clazz) throws IOException {
    return new DubboProtostuffReader(RuntimeSchema.getSchema(clazz, STRATEGY), is);
}
 

public static <T> ConnectionSchema<T> getSchema(Class<T> typeClass) {
  final Schema<T> schema = RuntimeSchema.getSchema(typeClass);

  final Instantiator<T> instantiator = findInstantiator(typeClass, schema);
  return new ConnectionSchema<>(schema, instantiator);
}