Java InstantiationUtil.deserializeObject方法代码示例

import org.apache.flink.util.InstantiationUtil; //导入方法依赖的package包/类
/**
 * Restore the state {@code (stateName -> (valueCoder && (namespace -> value)))}
 * for a given {@code keyGroupIdx}.
 *
 * @param keyGroupIdx the id of the key-group to be put in the snapshot.
 * @param in the stream to read from.
 * @param userCodeClassLoader the class loader that will be used to deserialize
 *                            the valueCoder.
 */
public void restoreKeyGroupState(int keyGroupIdx, DataInputStream in,
                                 ClassLoader userCodeClassLoader) throws Exception {
  int localIdx = getIndexForKeyGroup(keyGroupIdx);
  Map<String, Tuple2<Coder<?>, Map<String, ?>>> stateTable = stateTables[localIdx];
  int numStates = in.readShort();
  for (int i = 0; i < numStates; ++i) {
    String stateName = in.readUTF();
    Coder coder = InstantiationUtil.deserializeObject(in, userCodeClassLoader);
    Tuple2<Coder<?>, Map<String, ?>> tuple2 = stateTable.get(stateName);
    if (tuple2 == null) {
      tuple2 = new Tuple2<>();
      tuple2.f0 = coder;
      tuple2.f1 = new HashMap<>();
      stateTable.put(stateName, tuple2);
    }
    Map<String, Object> map = (Map<String, Object>) tuple2.f1;
    int mapSize = in.readInt();
    for (int j = 0; j < mapSize; j++) {
      String namespace = StringUtf8Coder.of().decode(in);
      Object value = coder.decode(in);
      map.put(namespace, value);
    }
  }
}
 

import org.apache.flink.util.InstantiationUtil; //导入方法依赖的package包/类
@Test
public void testSerialization() throws Exception {
	rowOrcInputFormat =
		new OrcRowInputFormat(getPath(TEST_FILE_FLAT), TEST_SCHEMA_FLAT, new Configuration());

	rowOrcInputFormat.selectFields(0, 4, 1);
	rowOrcInputFormat.addPredicate(
		new OrcRowInputFormat.Equals("_col1", PredicateLeaf.Type.STRING, "M"));

	byte[] bytes = InstantiationUtil.serializeObject(rowOrcInputFormat);
	OrcRowInputFormat copy = InstantiationUtil.deserializeObject(bytes, getClass().getClassLoader());

	FileInputSplit[] splits = copy.createInputSplits(1);
	copy.openInputFormat();
	copy.open(splits[0]);
	assertFalse(copy.reachedEnd());
	Row row = copy.nextRecord(null);

	assertNotNull(row);
	assertEquals(3, row.getArity());
	// check first row
	assertEquals(1, row.getField(0));
	assertEquals(500, row.getField(1));
	assertEquals("M", row.getField(2));
}
 

import org.apache.flink.util.InstantiationUtil; //导入方法依赖的package包/类
@Test
public void testSerializability() throws IOException, ClassNotFoundException {
	final Tuple3<Class<? extends SpecificRecord>, SpecificRecord, Row> testData = AvroTestUtils.getComplexTestData();

	final AvroRowSerializationSchema serOrig = new AvroRowSerializationSchema(testData.f0);
	final AvroRowDeserializationSchema deserOrig = new AvroRowDeserializationSchema(testData.f0);

	byte[] serBytes = InstantiationUtil.serializeObject(serOrig);
	byte[] deserBytes = InstantiationUtil.serializeObject(deserOrig);

	AvroRowSerializationSchema serCopy =
		InstantiationUtil.deserializeObject(serBytes, Thread.currentThread().getContextClassLoader());
	AvroRowDeserializationSchema deserCopy =
		InstantiationUtil.deserializeObject(deserBytes, Thread.currentThread().getContextClassLoader());

	final byte[] bytes = serCopy.serialize(testData.f2);
	deserCopy.deserialize(bytes);
	deserCopy.deserialize(bytes);
	final Row actual = deserCopy.deserialize(bytes);

	assertEquals(testData.f2, actual);
}
 

import org.apache.flink.util.InstantiationUtil; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private PojoComparator(PojoComparator<T> toClone) {
	this.keyFields = toClone.keyFields;
	this.comparators = new TypeComparator[toClone.comparators.length];

	for (int i = 0; i < toClone.comparators.length; i++) {
		this.comparators[i] = toClone.comparators[i].duplicate();
	}

	this.normalizedKeyLengths = toClone.normalizedKeyLengths;
	this.numLeadingNormalizableKeys = toClone.numLeadingNormalizableKeys;
	this.normalizableKeyPrefixLen = toClone.normalizableKeyPrefixLen;
	this.invertNormKey = toClone.invertNormKey;

	this.type = toClone.type;

	try {
		this.serializer = (TypeSerializer<T>) InstantiationUtil.deserializeObject(
				InstantiationUtil.serializeObject(toClone.serializer), Thread.currentThread().getContextClassLoader());
	} catch (IOException | ClassNotFoundException e) {
		throw new RuntimeException("Cannot copy serializer", e);
	}
}
 

import org.apache.flink.util.InstantiationUtil; //导入方法依赖的package包/类
@Override
public void read(DataInputView in) throws IOException {
	super.read(in);

	// read in a way that allows the stream to recover from exceptions
	int serializerBytes = in.readInt();
	byte[] buffer = new byte[serializerBytes];
	in.readFully(buffer);
	try {
		typeSerializer = InstantiationUtil.deserializeObject(buffer, userClassLoader);
	} catch (ClassNotFoundException | InvalidClassException e) {
		if (ignoreClassNotFound) {
			// we create a dummy so that all the information is not lost when we get a new checkpoint before receiving
			// a proper typeserializer from the user
			typeSerializer =
					new ClassNotFoundDummyTypeSerializer<>(buffer);
			LOG.warn("Could not find requested TypeSerializer class in classpath. Created dummy.", e);
		} else {
			throw new IOException("Missing class for type serializer.", e);
		}
	}
}
 

import org.apache.flink.util.InstantiationUtil; //导入方法依赖的package包/类
@Test
public void testSerializeEnumSerializer() throws Exception {
	EnumSerializer<PublicEnum> serializer = new EnumSerializer<>(PublicEnum.class);

	// verify original transient parameters
	assertEquals(PublicEnum.FOO.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.FOO).intValue());
	assertEquals(PublicEnum.BAR.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.BAR).intValue());
	assertEquals(PublicEnum.PETER.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.PETER).intValue());
	assertEquals(PublicEnum.NATHANIEL.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.NATHANIEL).intValue());
	assertEquals(PublicEnum.EMMA.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.EMMA).intValue());
	assertEquals(PublicEnum.PAULA.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.PAULA).intValue());
	assertTrue(Arrays.equals(PublicEnum.values(), serializer.getValues()));

	byte[] serializedSerializer = InstantiationUtil.serializeObject(serializer);

	// deserialize and re-verify transient parameters
	serializer = InstantiationUtil.deserializeObject(serializedSerializer, Thread.currentThread().getContextClassLoader());
	assertEquals(PublicEnum.FOO.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.FOO).intValue());
	assertEquals(PublicEnum.BAR.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.BAR).intValue());
	assertEquals(PublicEnum.PETER.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.PETER).intValue());
	assertEquals(PublicEnum.NATHANIEL.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.NATHANIEL).intValue());
	assertEquals(PublicEnum.EMMA.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.EMMA).intValue());
	assertEquals(PublicEnum.PAULA.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.PAULA).intValue());
	assertTrue(Arrays.equals(PublicEnum.values(), serializer.getValues()));
}
 

import org.apache.flink.util.InstantiationUtil; //导入方法依赖的package包/类
@Override
public InputSplit getNextInputSplit(ClassLoader userCodeClassLoader) throws InputSplitProviderException {
	Preconditions.checkNotNull(userCodeClassLoader);

	CompletableFuture<SerializedInputSplit> futureInputSplit = jobMasterGateway.requestNextInputSplit(
		jobVertexID,
		executionAttemptID);

	try {
		SerializedInputSplit serializedInputSplit = futureInputSplit.get(timeout.getSize(), timeout.getUnit());

		if (serializedInputSplit.isEmpty()) {
			return null;
		} else {
			return InstantiationUtil.deserializeObject(serializedInputSplit.getInputSplitData(), userCodeClassLoader);
		}
	} catch (Exception e) {
		throw new InputSplitProviderException("Requesting the next input split failed.", e);
	}
}
 

import org.apache.flink.util.InstantiationUtil; //导入方法依赖的package包/类
private <T> T copyObject(T object) {
	try {
		return InstantiationUtil.deserializeObject(
				InstantiationUtil.serializeObject(object),
				getClass().getClassLoader()
				);
	} catch (IOException | ClassNotFoundException e) {
		throw new RuntimeException("Failed to copy object.", e);
	}
}
 

import org.apache.flink.util.InstantiationUtil; //导入方法依赖的package包/类
protected void validate(ParameterTool parameter) {
	ClosureCleaner.ensureSerializable(parameter);
	validatePrivate(parameter);

	// -------- test behaviour after serialization ------------
	ParameterTool copy = null;
	try {
		byte[] b = InstantiationUtil.serializeObject(parameter);
		copy = InstantiationUtil.deserializeObject(b, getClass().getClassLoader());
	} catch (Exception e) {
		fail();
	}
	validatePrivate(copy);
}
 

import org.apache.flink.util.InstantiationUtil; //导入方法依赖的package包/类
@Override
public void read(DataInputView in) throws IOException {
	super.read(in);

	try (final DataInputViewStream inViewWrapper = new DataInputViewStream(in)) {
		tupleClass = InstantiationUtil.deserializeObject(inViewWrapper, getUserCodeClassLoader());
	} catch (ClassNotFoundException e) {
		throw new IOException("Could not find requested tuple class in classpath.", e);
	}
}
 

import org.apache.flink.util.InstantiationUtil; //导入方法依赖的package包/类
@Override
public void read(DataInputView in) throws IOException {
	super.read(in);

	try (final DataInputViewStream inViewWrapper = new DataInputViewStream(in)) {
		componentClass = InstantiationUtil.deserializeObject(inViewWrapper, getUserCodeClassLoader());
	} catch (ClassNotFoundException e) {
		throw new IOException("Could not find requested element class in classpath.", e);
	}
}
 

import org.apache.flink.util.InstantiationUtil; //导入方法依赖的package包/类
@Test
public void testSerializeReconfiguredEnumSerializer() throws Exception {
	// mock the previous ordering of enum constants to be BAR, PAULA, NATHANIEL
	PublicEnum[] mockPreviousOrder = {PublicEnum.BAR, PublicEnum.PAULA, PublicEnum.NATHANIEL};

	// now, the actual order of FOO, BAR, PETER, NATHANIEL, EMMA, PAULA will be the "new wrong order"
	EnumSerializer<PublicEnum> serializer = new EnumSerializer<>(PublicEnum.class);

	// verify that the serializer is first using the "wrong order" (i.e., the initial new configuration)
	assertEquals(PublicEnum.FOO.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.FOO).intValue());
	assertEquals(PublicEnum.BAR.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.BAR).intValue());
	assertEquals(PublicEnum.PETER.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.PETER).intValue());
	assertEquals(PublicEnum.NATHANIEL.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.NATHANIEL).intValue());
	assertEquals(PublicEnum.EMMA.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.EMMA).intValue());
	assertEquals(PublicEnum.PAULA.ordinal(), serializer.getValueToOrdinal().get(PublicEnum.PAULA).intValue());

	// reconfigure and verify compatibility
	CompatibilityResult<PublicEnum> compatResult = serializer.ensureCompatibility(
		new EnumSerializer.EnumSerializerConfigSnapshot<>(PublicEnum.class, mockPreviousOrder));
	assertFalse(compatResult.isRequiresMigration());

	// serialize and deserialize again the serializer
	byte[] serializedSerializer = InstantiationUtil.serializeObject(serializer);
	serializer = InstantiationUtil.deserializeObject(serializedSerializer, Thread.currentThread().getContextClassLoader());

	// verify that after the serializer was read, the reconfigured constant ordering is untouched
	PublicEnum[] expectedOrder = {PublicEnum.BAR, PublicEnum.PAULA, PublicEnum.NATHANIEL, PublicEnum.FOO, PublicEnum.PETER, PublicEnum.EMMA};

	int i = 0;
	for (PublicEnum constant : expectedOrder) {
		assertEquals(i, serializer.getValueToOrdinal().get(constant).intValue());
		i++;
	}

	assertTrue(Arrays.equals(expectedOrder, serializer.getValues()));
}
 

import org.apache.flink.util.InstantiationUtil; //导入方法依赖的package包/类
@Override
public void collect(StreamRecord<T> record) {
	try {
		ClassLoader cl = record.getClass().getClassLoader();
		T copied = InstantiationUtil.deserializeObject(InstantiationUtil.serializeObject(record.getValue()), cl);
		outputs.add(copied);
	} catch (IOException | ClassNotFoundException ex) {
		throw new RuntimeException("Unable to deserialize record: " + record, ex);
	}
}
 

import org.apache.flink.util.InstantiationUtil; //导入方法依赖的package包/类
@Override
public T deserialize(DataInputView source) throws IOException {
	try (final DataInputViewStream inViewWrapper = new DataInputViewStream(source)) {
		return InstantiationUtil.deserializeObject(
				inViewWrapper,
				Thread.currentThread().getContextClassLoader());
	} catch (ClassNotFoundException e) {
		throw new IOException("Could not deserialize object.", e);
	}
}
 

import org.apache.flink.util.InstantiationUtil; //导入方法依赖的package包/类
public BlockingStatefulInvokable(Environment environment, @Nullable TaskStateSnapshot initialState) {
	super(environment, initialState);

	int subtaskIndex = getIndexInSubtaskGroup();
	if (initialState != null && subtaskIndex < recoveredStates.length) {
		OperatorStateHandle operatorStateHandle = extractSingletonOperatorState(initialState);
		try (FSDataInputStream in = operatorStateHandle.openInputStream()) {
			recoveredStates[subtaskIndex] = InstantiationUtil.deserializeObject(in, getUserCodeClassLoader());
		}
		catch (IOException | ClassNotFoundException e) {
			throw new RuntimeException(e.getMessage(), e);
		}
	}
}