org.jboss.marshalling.Unmarshaller Java Examples

@Override
protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception {
    ByteBuf frame = (ByteBuf) super.decode(ctx, in);
    if (frame == null) {
        return null;
    }

    Unmarshaller unmarshaller = provider.getUnmarshaller(ctx);
    ByteInput input = new ChannelBufferByteInput(frame);

    try {
        unmarshaller.start(input);
        Object obj = unmarshaller.readObject();
        unmarshaller.finish();
        return obj;
    } finally {
        // Call close in a finally block as the ReplayingDecoder will throw an Error if not enough bytes are
        // readable. This helps to be sure that we do not leak resource
        unmarshaller.close();
    }
}
 

@Override
protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception {
    ByteBuf frame = (ByteBuf) super.decode(ctx, in);
    if (frame == null) {
        return null;
    }

    Unmarshaller unmarshaller = provider.getUnmarshaller(ctx);
    ByteInput input = new ChannelBufferByteInput(frame);

    try {
        unmarshaller.start(input);
        Object obj = unmarshaller.readObject();
        unmarshaller.finish();
        return obj;
    } finally {
        // Call close in a finally block as the ReplayingDecoder will throw an Error if not enough bytes are
        // readable. This helps to be sure that we do not leak resource
        unmarshaller.close();
    }
}
 

@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf buffer, List<Object> out) throws Exception {
    if (discardingTooLongFrame) {
        buffer.skipBytes(actualReadableBytes());
        checkpoint();
        return;
    }

    Unmarshaller unmarshaller = provider.getUnmarshaller(ctx);
    ByteInput input = new ChannelBufferByteInput(buffer);
    if (maxObjectSize != Integer.MAX_VALUE) {
        input = new LimitingByteInput(input, maxObjectSize);
    }
    try {
        unmarshaller.start(input);
        Object obj = unmarshaller.readObject();
        unmarshaller.finish();
        out.add(obj);
    } catch (LimitingByteInput.TooBigObjectException ignored) {
        discardingTooLongFrame = true;
        throw new TooLongFrameException();
    } finally {
        // Call close in a finally block as the ReplayingDecoder will throw an Error if not enough bytes are
        // readable. This helps to be sure that we do not leak resource
        unmarshaller.close();
    }
}
 

@Override
public Unmarshaller getUnmarshaller(ChannelHandlerContext ctx) throws Exception {
    Unmarshaller unmarshaller = unmarshallers.get();
    if (unmarshaller == null) {
        unmarshaller = factory.createUnmarshaller(config);
        unmarshallers.set(unmarshaller);
    }
    return unmarshaller;
}
 

@Override
public Unmarshaller getUnmarshaller(ChannelHandlerContext ctx) throws Exception {
    Attribute<Unmarshaller> attr = ctx.channel().attr(UNMARSHALLER);
    Unmarshaller unmarshaller = attr.get();
    if (unmarshaller == null) {
        unmarshaller = super.getUnmarshaller(ctx);
        attr.set(unmarshaller);
    }
    return unmarshaller;
}
 

@Test
public void testMarshalling() throws Exception {
    @SuppressWarnings("RedundantStringConstructorCall")
    String testObject = new String("test");

    final MarshallerFactory marshallerFactory = createMarshallerFactory();
    final MarshallingConfiguration configuration = createMarshallingConfig();

    EmbeddedChannel ch = new EmbeddedChannel(createEncoder());

    ch.writeOutbound(testObject);
    assertTrue(ch.finish());

    ByteBuf buffer = ch.readOutbound();

    Unmarshaller unmarshaller = marshallerFactory.createUnmarshaller(configuration);
    unmarshaller.start(Marshalling.createByteInput(truncate(buffer).nioBuffer()));
    String read = (String) unmarshaller.readObject();
    assertEquals(testObject, read);

    assertEquals(-1, unmarshaller.read());

    assertNull(ch.readOutbound());

    unmarshaller.finish();
    unmarshaller.close();
    buffer.release();
}
 

/**
   * 创建Jboss Unmarshaller解码对象
   * @return Unmarshaller
   * @throws IOException 
   */
  public static Unmarshaller buildUnMarshalling() throws IOException {
final MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory("serial");
final MarshallingConfiguration configuration = new MarshallingConfiguration();
configuration.setVersion(5);
Unmarshaller unmarshaller = marshallerFactory.createUnmarshaller(configuration);
return unmarshaller;
  }
 

public static Counter readCounter(File file) {
	System.out.println("Reading counter from: " + file);
       try (FileInputStream is = new FileInputStream(file)) {
       	final Unmarshaller unmarshaller = marshallerFactory.createUnmarshaller(configuration);
           unmarshaller.start(Marshalling.createByteInput(is));
           Counter counter = (Counter) unmarshaller.readObject();
           unmarshaller.finish();
           is.close();
           return counter;
       } catch (IOException | ClassNotFoundException e) {
           System.err.print("Un-marshalling failed: ");
           e.printStackTrace();
       }
	return null;
}
 

public static <T> T unmarshal(final Unmarshaller unmarshaller, final Class<T> expectedType) throws IOException {
    try {
        return unmarshaller.readObject(expectedType);
    } catch (ClassNotFoundException e) {
        throw ProcessLogger.ROOT_LOGGER.failedToReadObject(e);
    }
}
 

@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf buffer, List<Object> out) throws Exception {
    if (discardingTooLongFrame) {
        buffer.skipBytes(actualReadableBytes());
        checkpoint();
        return;
    }

    Unmarshaller unmarshaller = provider.getUnmarshaller(ctx);
    ByteInput input = new ChannelBufferByteInput(buffer);
    if (maxObjectSize != Integer.MAX_VALUE) {
        input = new LimitingByteInput(input, maxObjectSize);
    }
    try {
        unmarshaller.start(input);
        Object obj = unmarshaller.readObject();
        unmarshaller.finish();
        out.add(obj);
    } catch (LimitingByteInput.TooBigObjectException ignored) {
        discardingTooLongFrame = true;
        throw new TooLongFrameException();
    } finally {
        // Call close in a finally block as the ReplayingDecoder will throw an Error if not enough bytes are
        // readable. This helps to be sure that we do not leak resource
        unmarshaller.close();
    }
}
 

public static void safeFinish(final Unmarshaller unmarshaller) {
    if (unmarshaller != null) try {
        unmarshaller.finish();
    } catch (IOException e) {
        ProcessLogger.PROTOCOL_LOGGER.failedToFinishUnmarshaller(e, unmarshaller);
    }
}
 

@Override
public Unmarshaller getUnmarshaller(ChannelHandlerContext ctx) throws Exception {
    Unmarshaller unmarshaller = unmarshallers.get();
    if (unmarshaller == null) {
        unmarshaller = factory.createUnmarshaller(config);
        unmarshallers.set(unmarshaller);
    }
    return unmarshaller;
}
 

@Override
public Unmarshaller getUnmarshaller(ChannelHandlerContext ctx) throws Exception {
    Attribute<Unmarshaller> attr = ctx.attr(UNMARSHALLER);
    Unmarshaller unmarshaller = attr.get();
    if (unmarshaller == null) {
        unmarshaller = super.getUnmarshaller(ctx);
        attr.set(unmarshaller);
    }
    return unmarshaller;
}
 

@Test
public void testMarshalling() throws IOException, ClassNotFoundException {
    @SuppressWarnings("RedundantStringConstructorCall")
    String testObject = new String("test");

    final MarshallerFactory marshallerFactory = createMarshallerFactory();
    final MarshallingConfiguration configuration = createMarshallingConfig();

    EmbeddedChannel ch = new EmbeddedChannel(createEncoder());

    ch.writeOutbound(testObject);
    assertTrue(ch.finish());

    ByteBuf buffer = (ByteBuf) ch.readOutbound();

    Unmarshaller unmarshaller = marshallerFactory.createUnmarshaller(configuration);
    unmarshaller.start(Marshalling.createByteInput(truncate(buffer).nioBuffer()));
    String read = (String) unmarshaller.readObject();
    assertEquals(testObject, read);

    assertEquals(-1, unmarshaller.read());

    assertNull(ch.readOutbound());

    unmarshaller.finish();
    unmarshaller.close();
    buffer.release();
}
 

@Override
public Unmarshaller getUnmarshaller(ChannelHandlerContext ctx) throws Exception {
    return factory.createUnmarshaller(config);
}
 

public static Unmarshaller getUnmarshaller(final MarshallingConfiguration config) throws IOException {
    return MARSHALLER_FACTORY.createUnmarshaller(config);
}
 

@Override
public Unmarshaller getUnmarshaller(ChannelHandlerContext ctx) throws Exception {
    return factory.createUnmarshaller(config);
}
 

/**
 * Get the {@link Unmarshaller} for the given {@link ChannelHandlerContext}
 */
Unmarshaller getUnmarshaller(ChannelHandlerContext ctx) throws Exception;
 

/**
 * Get the {@link Unmarshaller} for the given {@link ChannelHandlerContext} 为给定的ChannelHandlerContext获取Unmarshaller
 */
Unmarshaller getUnmarshaller(ChannelHandlerContext ctx) throws Exception;
 

/**
 * Logs an error message indicating a failure to finish the unmarshaller.
 *
 * @param cause        the cause of the error.
 * @param unmarshaller the marshaller in error.
 */
@LogMessage(level = ERROR)
@Message(id = 38, value = "Failed to finish the unmarshaller %s")
void failedToFinishUnmarshaller(@Cause Throwable cause, Unmarshaller unmarshaller);