Java GenericTypeInfo类代码示例

import org.apache.flink.api.java.typeutils.GenericTypeInfo; //导入依赖的package包/类
private static <TWarningType extends IWarning> DataStream<TWarningType> toWarningStream(DataStream<LocalWeatherData> localWeatherDataDataStream, IWarningPattern<LocalWeatherData, TWarningType> warningPattern) {
    PatternStream<LocalWeatherData> tempPatternStream = CEP.pattern(
            localWeatherDataDataStream.keyBy(new KeySelector<LocalWeatherData, String>() {
                @Override
                public String getKey(LocalWeatherData localWeatherData) throws Exception {
                    return localWeatherData.getStation().getWban();
                }
            }),
            warningPattern.getEventPattern());

    DataStream<TWarningType> warnings = tempPatternStream.select(new PatternSelectFunction<LocalWeatherData, TWarningType>() {
        @Override
        public TWarningType select(Map<String, List<LocalWeatherData>> map) throws Exception {
            return warningPattern.create(map);
        }
    }, new GenericTypeInfo<TWarningType>(warningPattern.getWarningTargetType()));

    return warnings;
}
 

import org.apache.flink.api.java.typeutils.GenericTypeInfo; //导入依赖的package包/类
@Override
protected StateInternals createStateInternals() {
  MemoryStateBackend backend = new MemoryStateBackend();
  try {
    AbstractKeyedStateBackend<ByteBuffer> keyedStateBackend = backend.createKeyedStateBackend(
        new DummyEnvironment("test", 1, 0),
        new JobID(),
        "test_op",
        new GenericTypeInfo<>(ByteBuffer.class).createSerializer(new ExecutionConfig()),
        1,
        new KeyGroupRange(0, 0),
        new KvStateRegistry().createTaskRegistry(new JobID(), new JobVertexID()));

    keyedStateBackend.setCurrentKey(
        ByteBuffer.wrap(CoderUtils.encodeToByteArray(StringUtf8Coder.of(), "Hello")));

    return new FlinkStateInternals<>(keyedStateBackend, StringUtf8Coder.of());
  } catch (Exception e) {
    throw new RuntimeException(e);
  }
}
 

import org.apache.flink.api.java.typeutils.GenericTypeInfo; //导入依赖的package包/类
private static KeyedStateBackend<ByteBuffer> getKeyedStateBackend(int numberOfKeyGroups,
                                                 KeyGroupRange keyGroupRange) {
  MemoryStateBackend backend = new MemoryStateBackend();
  try {
    AbstractKeyedStateBackend<ByteBuffer> keyedStateBackend = backend.createKeyedStateBackend(
        new DummyEnvironment("test", 1, 0),
        new JobID(),
        "test_op",
        new GenericTypeInfo<>(ByteBuffer.class).createSerializer(new ExecutionConfig()),
        numberOfKeyGroups,
        keyGroupRange,
        new KvStateRegistry().createTaskRegistry(new JobID(), new JobVertexID()));
    keyedStateBackend.setCurrentKey(ByteBuffer.wrap(
        CoderUtils.encodeToByteArray(StringUtf8Coder.of(), "1")));
    return keyedStateBackend;
  } catch (Exception e) {
    throw new RuntimeException(e);
  }
}
 

import org.apache.flink.api.java.typeutils.GenericTypeInfo; //导入依赖的package包/类
/**
 * Recursively converts extracted AvroTypeInfo into a RowTypeInfo nested structure with deterministic field order.
 * Replaces generic Utf8 with basic String type information.
 */
private static TypeInformation<?> convertToTypeInformation(TypeInformation<?> extracted, Schema schema) {
	if (schema.getType() == Schema.Type.RECORD) {
		final List<Schema.Field> fields = schema.getFields();
		final AvroTypeInfo<?> avroTypeInfo = (AvroTypeInfo<?>) extracted;

		final TypeInformation<?>[] types = new TypeInformation<?>[fields.size()];
		final String[] names = new String[fields.size()];
		for (int i = 0; i < fields.size(); i++) {
			final Schema.Field field = fields.get(i);
			types[i] = convertToTypeInformation(avroTypeInfo.getTypeAt(field.name()), field.schema());
			names[i] = field.name();
		}
		return new RowTypeInfo(types, names);
	} else if (extracted instanceof GenericTypeInfo<?>) {
		final GenericTypeInfo<?> genericTypeInfo = (GenericTypeInfo<?>) extracted;
		if (genericTypeInfo.getTypeClass() == Utf8.class) {
			return BasicTypeInfo.STRING_TYPE_INFO;
		}
	}
	return extracted;
}
 

import org.apache.flink.api.java.typeutils.GenericTypeInfo; //导入依赖的package包/类
private static <T> String getSerializerTree(TypeInformation<T> ti, int indent) {
	String ret = "";
	if (ti instanceof CompositeType) {
		ret += StringUtils.repeat(' ', indent) + ti.getClass().getSimpleName() + "\n";
		CompositeType<T> cti = (CompositeType<T>) ti;
		String[] fieldNames = cti.getFieldNames();
		for (int i = 0; i < cti.getArity(); i++) {
			TypeInformation<?> fieldType = cti.getTypeAt(i);
			ret += StringUtils.repeat(' ', indent + 2) + fieldNames[i] + ":" + getSerializerTree(fieldType, indent);
		}
	} else {
		if (ti instanceof GenericTypeInfo) {
			ret += StringUtils.repeat(' ', indent) + "GenericTypeInfo (" + ti.getTypeClass().getSimpleName() + ")\n";
			ret += getGenericTypeTree(ti.getTypeClass(), indent + 4);
		} else {
			ret += StringUtils.repeat(' ', indent) + ti.toString() + "\n";
		}
	}
	return ret;
}
 

import org.apache.flink.api.java.typeutils.GenericTypeInfo; //导入依赖的package包/类
public static void recursivelyRegisterType(TypeInformation<?> typeInfo, ExecutionConfig config, Set<Class<?>> alreadySeen) {
	if (typeInfo instanceof GenericTypeInfo) {
		GenericTypeInfo<?> genericTypeInfo = (GenericTypeInfo<?>) typeInfo;
		Serializers.recursivelyRegisterType(genericTypeInfo.getTypeClass(), config, alreadySeen);
	}
	else if (typeInfo instanceof CompositeType) {
		List<GenericTypeInfo<?>> genericTypesInComposite = new ArrayList<>();
		getContainedGenericTypes((CompositeType<?>)typeInfo, genericTypesInComposite);
		for (GenericTypeInfo<?> gt : genericTypesInComposite) {
			Serializers.recursivelyRegisterType(gt.getTypeClass(), config, alreadySeen);
		}
	}
	else if (typeInfo instanceof ObjectArrayTypeInfo) {
		ObjectArrayTypeInfo<?, ?> objectArrayTypeInfo = (ObjectArrayTypeInfo<?, ?>) typeInfo;
		recursivelyRegisterType(objectArrayTypeInfo.getComponentInfo(), config, alreadySeen);
	}
}
 

import org.apache.flink.api.java.typeutils.GenericTypeInfo; //导入依赖的package包/类
@Override
public <E> void validateCustomPartitioner(Partitioner<E> partitioner, TypeInformation<E> typeInfo) {

	if (keyFields.size() != 1) {
		throw new InvalidProgramException("Custom partitioners can only be used with keys that have one key field.");
	}
	
	if (typeInfo == null) {
		// try to extract key type from partitioner
		try {
			typeInfo = TypeExtractor.getPartitionerTypes(partitioner);
		}
		catch (Throwable t) {
			// best effort check, so we ignore exceptions
		}
	}

	// only check if type is known and not a generic type
	if (typeInfo != null && !(typeInfo instanceof GenericTypeInfo)) {
		// check equality of key and partitioner type
		if (!keyType.equals(typeInfo)) {
			throw new InvalidProgramException("The partitioner is incompatible with the key type. "
				+ "Partitioner type: " + typeInfo + " , key type: " + keyType);
		}
	}
}
 

import org.apache.flink.api.java.typeutils.GenericTypeInfo; //导入依赖的package包/类
@Test
public void testTypeRegistrationFromTypeInfo() {
	ExecutionConfig conf = new ExecutionConfig();
	Serializers.recursivelyRegisterType(new GenericTypeInfo<>(ClassWithNested.class), conf, new HashSet<Class<?>>());

	KryoSerializer<String> kryo = new KryoSerializer<>(String.class, conf); // we create Kryo from another type.

	assertTrue(kryo.getKryo().getRegistration(FromNested.class).getId() > 0);
	assertTrue(kryo.getKryo().getRegistration(ClassWithNested.class).getId() > 0);
	assertTrue(kryo.getKryo().getRegistration(Path.class).getId() > 0);

	// check if the generic type from one field is also registered (its very likely that
	// generic types are also used as fields somewhere.
	assertTrue(kryo.getKryo().getRegistration(FromGeneric1.class).getId() > 0);
	assertTrue(kryo.getKryo().getRegistration(FromGeneric2.class).getId() > 0);
	assertTrue(kryo.getKryo().getRegistration(Node.class).getId() > 0);
}
 

import org.apache.flink.api.java.typeutils.GenericTypeInfo; //导入依赖的package包/类
@Test
public void testDisableGenericTypes() {
	ExecutionConfig conf = new ExecutionConfig();
	TypeInformation<Object> typeInfo = new GenericTypeInfo<Object>(Object.class);

	// by default, generic types are supported
	TypeSerializer<Object> serializer = typeInfo.createSerializer(conf);
	assertTrue(serializer instanceof KryoSerializer);

	// expect an exception when generic types are disabled
	conf.disableGenericTypes();
	try {
		typeInfo.createSerializer(conf);
		fail("should have failed with an exception");
	}
	catch (UnsupportedOperationException e) {
		// expected
	}
}
 

import org.apache.flink.api.java.typeutils.GenericTypeInfo; //导入依赖的package包/类
@Test
public void testObjectArrayKeyRejection() {

	KeySelector<Tuple2<Integer[], String>, Object[]> keySelector =
			new KeySelector<Tuple2<Integer[], String>, Object[]>() {

				@Override
				public Object[] getKey(Tuple2<Integer[], String> value) throws Exception {
					Object[] ks = new Object[value.f0.length];
					for (int i = 0; i < ks.length; i++) {
						ks[i] = new Object();
					}
					return ks;
				}
			};

	ObjectArrayTypeInfo<Object[], Object> keyTypeInfo = ObjectArrayTypeInfo.getInfoFor(
			Object[].class, new GenericTypeInfo<>(Object.class));

	testKeyRejection(keySelector, keyTypeInfo);
}
 

import org.apache.flink.api.java.typeutils.GenericTypeInfo; //导入依赖的package包/类
/**
 * Test if the TypeExtractor is accepting untyped generics,
 * making them GenericTypes
 */
@Test
@Ignore // kryo needed.
public void testPojoWithGenericsSomeFieldsGeneric() {
	TypeInformation<?> typeForClass = TypeExtractor.createTypeInfo(PojoWithGenerics.class);
	Assert.assertTrue(typeForClass instanceof PojoTypeInfo<?>);
	PojoTypeInfo<?> pojoTypeForClass = (PojoTypeInfo<?>) typeForClass;
	for(int i = 0; i < pojoTypeForClass.getArity(); i++) {
		PojoField field = pojoTypeForClass.getPojoFieldAt(i);
		String name = field.field.getName();
		if(name.equals("field1")) {
			Assert.assertEquals(new GenericTypeInfo<Object>(Object.class), field.type);
		} else if (name.equals("field2")) {
			Assert.assertEquals(new GenericTypeInfo<Object>(Object.class), field.type);
		} else if (name.equals("key")) {
			Assert.assertEquals(BasicTypeInfo.INT_TYPE_INFO, field.type);
		} else {
			Assert.fail("Unexpected field "+field);
		}
	}
}
 

import org.apache.flink.api.java.typeutils.GenericTypeInfo; //导入依赖的package包/类
private TypeInformation getFieldType(HCatFieldSchema fieldSchema) {

		switch(fieldSchema.getType()) {
			case INT:
				return BasicTypeInfo.INT_TYPE_INFO;
			case TINYINT:
				return BasicTypeInfo.BYTE_TYPE_INFO;
			case SMALLINT:
				return BasicTypeInfo.SHORT_TYPE_INFO;
			case BIGINT:
				return BasicTypeInfo.LONG_TYPE_INFO;
			case BOOLEAN:
				return BasicTypeInfo.BOOLEAN_TYPE_INFO;
			case FLOAT:
				return BasicTypeInfo.FLOAT_TYPE_INFO;
			case DOUBLE:
				return BasicTypeInfo.DOUBLE_TYPE_INFO;
			case STRING:
				return BasicTypeInfo.STRING_TYPE_INFO;
			case BINARY:
				return PrimitiveArrayTypeInfo.BYTE_PRIMITIVE_ARRAY_TYPE_INFO;
			case ARRAY:
				return new GenericTypeInfo(List.class);
			case MAP:
				return new GenericTypeInfo(Map.class);
			case STRUCT:
				return new GenericTypeInfo(List.class);
			default:
				throw new IllegalArgumentException("Unknown data type \"" + fieldSchema.getType() + "\" encountered.");
		}
	}
 

import org.apache.flink.api.java.typeutils.GenericTypeInfo; //导入依赖的package包/类
/**
 * Returns all GenericTypeInfos contained in a composite type.
 *
 * @param typeInfo {@link CompositeType}
 */
private static void getContainedGenericTypes(CompositeType<?> typeInfo, List<GenericTypeInfo<?>> target) {
	for (int i = 0; i < typeInfo.getArity(); i++) {
		TypeInformation<?> type = typeInfo.getTypeAt(i);
		if (type instanceof CompositeType) {
			getContainedGenericTypes((CompositeType<?>) type, target);
		} else if (type instanceof GenericTypeInfo) {
			if (!target.contains(type)) {
				target.add((GenericTypeInfo<?>) type);
			}
		}
	}
}
 

import org.apache.flink.api.java.typeutils.GenericTypeInfo; //导入依赖的package包/类
@Override
protected <T> TypeSerializer<T> createSerializer(Class<T> type) {
	ExecutionConfig conf = new ExecutionConfig();
	conf.registerTypeWithKryoSerializer(LocalDate.class, LocalDateSerializer.class);
	TypeInformation<T> typeInfo = new GenericTypeInfo<T>(type);
	return typeInfo.createSerializer(conf);
}
 

import org.apache.flink.api.java.typeutils.GenericTypeInfo; //导入依赖的package包/类
@Test
public void testKeyGenericType() {

	TypeInformation<GenericKeyType> genericType = new GenericTypeInfo<>(GenericKeyType.class);
	ExpressionKeys<GenericKeyType> ek = new ExpressionKeys<>("*", genericType);

	Assert.assertArrayEquals(new int[] {0}, ek.computeLogicalKeyPositions());
}