private static void generateSerializationSignature(Class<?> instanceType, CRC32 crc, SerializationPolicy policy) throws UnsupportedEncodingException { crc.update(getSerializedTypeName(instanceType).getBytes(RPCServletUtils.CHARSET_UTF8)); if (excludeImplementationFromSerializationSignature(instanceType)) { return; Class<?> customSerializer = hasCustomFieldSerializer(instanceType); if (customSerializer != null) { generateSerializationSignature(customSerializer, crc, policy); } else if (instanceType.isArray()) { generateSerializationSignature(instanceType.getComponentType(), crc, policy); } else if (Enum.class.isAssignableFrom(instanceType) && !Enum.class.equals(instanceType)) { if (!instanceType.isEnum()) { Field[] fields = applyFieldSerializationPolicy(instanceType, policy); Set<String> clientFieldNames = policy.getClientFieldNamesForEnhancedClass(instanceType); for (Field field : fields) { crc.update(getSerializedTypeName(field.getType()).getBytes(RPCServletUtils.CHARSET_UTF8)); generateSerializationSignature(superClass, crc, policy);
/** * Returns the {@link Class} which can serialize the given instance type, or * <code>null</code> if this class has no custom field serializer. * * Note that arrays never have custom field serializers. */ public static Class<?> hasCustomFieldSerializer(Class<?> instanceType) { assert (instanceType != null); if (instanceType.isArray()) { return null; } Class<?> result; result = classCustomSerializerCache.get(instanceType); if (result == null) { result = computeHasCustomFieldSerializer(instanceType, false); if (result == null) { /* * Use (result == instanceType) as a sentinel value when the class has * no custom field serializer. We avoid using null as the sentinel * value, because that would necessitate an additional containsKey() * check in the most common case. */ result = instanceType; } classCustomSerializerCache.put(instanceType, result); } return (result == instanceType) ? null : result; }
@Override protected String getObjectTypeSignature(Object instance) throws SerializationException { assert (instance != null); Class<?> clazz = getClassForSerialization(instance); if (hasFlags(FLAG_ELIDE_TYPE_NAMES)) { if (serializationPolicy instanceof TypeNameObfuscator) { return ((TypeNameObfuscator) serializationPolicy).getTypeIdForClass(clazz); } throw new SerializationException("The GWT module was compiled with RPC " + "type name elision enabled, but " + serializationPolicy.getClass().getName() + " does not implement " + TypeNameObfuscator.class.getName()); } else { return SerializabilityUtil.encodeSerializedInstanceReference(clazz, serializationPolicy); } }
/** * Find the Class that a given type refers to. * * @param type The type of interest * @return The Class that type represents */ public static Class<?> getClassFromType(Type type, DequeMap<TypeVariable<?>, Type> resolvedTypes) { Type actualType = findActualType(type, resolvedTypes); if (actualType instanceof Class) { return (Class<?>) actualType; } if (type instanceof ParameterizedType) { return getClassFromType(((ParameterizedType) actualType).getRawType(), resolvedTypes); } return null; }
} else if (superType instanceof Class) { return findExpectedInstanceClass((Class<?>) superType, expectedType, resolvedTypes, expectedInstanceClasses, expectedParameterTypes); } else if (superType instanceof ParameterizedType) { return findExpectedInstanceClass(rawClass, expectedType, resolvedTypes, expectedInstanceClasses, expectedParameterTypes); Type[] upperBounds = wildcardType.getUpperBounds(); for (Type boundType : upperBounds) { if (findExpectedInstanceClassFromSuper(boundType, expectedType, resolvedTypes, expectedInstanceClasses, expectedParameterTypes)) { return true;
findInstanceParameters(instanceClass, resolvedTypes, expectedParameterTypes); Type actualType = findActualType(expectedType, resolvedTypes); if (!findExpectedInstanceClass(instanceClass, actualType, resolvedTypes, expectedInstanceClasses, expectedParameterTypes)) { findInstanceParameters(expectedClass, resolvedTypes, expectedParameterTypes);
SerializabilityUtil.decodeSerializedInstanceReference(typeSignature); instanceClass = Class.forName(serializedInstRef.getName(), false, classLoader); validateTypeVersions(instanceClass, serializedInstRef); Type[] expectedParameterTypes = null; if (expectedType != null) { SerializabilityUtil.resolveTypes(expectedType, resolvedTypes); expectedParameterTypes = SerializabilityUtil.findExpectedParameterTypes( instanceClass, expectedType, resolvedTypes); if (expectedParameterTypes == null) { throw new SerializedTypeViolationException("Attempt to deserialize an object of type " + instanceClass.toString() + " when an object of type " + SerializabilityUtil.findActualType(expectedType, resolvedTypes).toString() + " is expected"); Class<?> customSerializer = SerializabilityUtil.hasServerCustomFieldSerializer(instanceClass); SerializabilityUtil.releaseTypes(expectedType, resolvedTypes);
private void serializeImpl(Object instance, Class<?> instanceClass) throws SerializationException { assert (instance != null); Class<?> customSerializer = SerializabilityUtil.hasCustomFieldSerializer(instanceClass); if (customSerializer != null) { // Use custom field serializer @SuppressWarnings("unchecked") CustomFieldSerializer<Object> customFieldSerializer = (CustomFieldSerializer<Object>) SerializabilityUtil.loadCustomFieldSerializer(customSerializer); if (customFieldSerializer == null) { serializeWithCustomSerializer(customSerializer, instance, instanceClass); } else { customFieldSerializer.serializeInstance(this, instance); } } else if (instanceClass.isArray()) { serializeArray(instanceClass, instance); } else if (instanceClass.isEnum()) { writeInt(((Enum<?>) instance).ordinal()); } else { // Regular class instance serializeClass(instance, instanceClass); } }
Field[] serializableFields = SerializabilityUtil.applyFieldSerializationPolicy(instanceClass, serializationPolicy); for (Field declField : serializableFields) { Type[] superParameterTypes = SerializabilityUtil.findExpectedParameterTypes( superClass, superClass, resolvedTypes); deserializeImpl(SerializabilityUtil.hasServerCustomFieldSerializer(superClass), superClass, instance, expectedType, superParameterTypes, resolvedTypes);
if (!findExpectedInstanceClass(instanceClass, boundType, resolvedTypes, expectedInstanceClasses, expectedParameterTypes)) { return false; for (Type type : lowerBounds) { Class<?> boundClass = getClassFromType(type, resolvedTypes); for (Type type : upperBounds) { if (!findExpectedInstanceClass(instanceClass, type, resolvedTypes, expectedInstanceClasses, expectedParameterTypes)) { return false; if (findExpectedInstanceClassFromSuper(instanceClass.getGenericSuperclass(), expectedType, resolvedTypes, expectedInstanceClasses, localTypes)) { for (int i = 0; i < expectedParameterTypes.length; ++i) { for (Type interfaceType : interfaces) { Type[] localTypes = expectedParameterTypes.clone(); if (findExpectedInstanceClassFromSuper(interfaceType, expectedType, resolvedTypes, expectedInstanceClasses, localTypes)) { for (int i = 0; i < expectedParameterTypes.length; ++i) {
/** * Instantiable types are primitives, {@line IsSerializable}, types with * custom serializers, and any arrays of those types. Merely * {@link Serializable} types cannot be instantiated or serialized directly * (only as super types of legacy serializable types). */ private boolean isInstantiable(Class<?> clazz) { if (clazz.isPrimitive()) { return true; } if (clazz.isArray()) { return isInstantiable(clazz.getComponentType()); } if (IsSerializable.class.isAssignableFrom(clazz)) { return true; } return SerializabilityUtil.hasCustomFieldSerializer(clazz) != null; } }
for (int j = 0; !haveMatch && j < instanceTypes.length; ++j) { if (expectedParameterTypes[i] == instanceTypes[j]) { Type capturedType = findActualType(instanceTypes[j], resolvedTypes); if (!(capturedType instanceof TypeVariable)) { expectedParameterTypes[i] = capturedType; Type superParameter = findInstanceParameter(expectedParameterTypes[i], instanceClass.getGenericSuperclass(), resolvedTypes); if (!(superParameter instanceof TypeVariable)) { for (Type interfaceType : interfaceTypes) { Type interfaceParameter = findInstanceParameter(expectedParameterTypes[i], interfaceType, resolvedTypes); if (!(interfaceParameter instanceof TypeVariable)) { expectedParameterTypes[i] = interfaceParameter;
CustomFieldSerializer<Object> customFieldSerializer = (CustomFieldSerializer<Object>) SerializabilityUtil .loadCustomFieldSerializer(customSerializer); if (customFieldSerializer == null) { deserializeWithCustomFieldDeserializer(customSerializer, instanceClass, instance, return deserializeArray(instanceClass, instance); Type actualExpectedType = SerializabilityUtil.findActualType(expectedType, resolvedTypes); if (actualExpectedType instanceof GenericArrayType) { Type arrayType = ((GenericArrayType) actualExpectedType).getGenericComponentType();
/** * @deprecated use {@link #applyFieldSerializationPolicy(Class, SerializationPolicy)} instead. */ @Deprecated public static Field[] applyFieldSerializationPolicy(Class<?> clazz) { return applyFieldSerializationPolicy(clazz, false); }
private static Field[] applyFieldSerializationPolicy(Class<?> clazz, boolean includeFinalFields) { Field[] serializableFields = classSerializableFieldsCache.get(clazz); if (serializableFields == null) { ArrayList<Field> fieldList = new ArrayList<Field>(); Field[] fields = clazz.getDeclaredFields(); for (Field field : fields) { if (fieldQualifiesForSerialization(field, includeFinalFields)) { fieldList.add(field); } } serializableFields = fieldList.toArray(new Field[fieldList.size()]); // sort the fields by name Arrays.sort(serializableFields, 0, serializableFields.length, FIELD_COMPARATOR); classSerializableFieldsCache.put(clazz, serializableFields); } return serializableFields; }
SerializabilityUtil.decodeSerializedInstanceReference(typeSignature); instanceClass = Class.forName(serializedInstRef.getName(), false, classLoader); validateTypeVersions(instanceClass, serializedInstRef); Type[] expectedParameterTypes = null; if (expectedType != null) { SerializabilityUtil.resolveTypes(expectedType, resolvedTypes); expectedParameterTypes = SerializabilityUtil.findExpectedParameterTypes( instanceClass, expectedType, resolvedTypes); if (expectedParameterTypes == null) { throw new SerializedTypeViolationException("Attempt to deserialize an object of type " + instanceClass.toString() + " when an object of type " + SerializabilityUtil.findActualType(expectedType, resolvedTypes).toString() + " is expected"); Class<?> customSerializer = SerializabilityUtil.hasServerCustomFieldSerializer(instanceClass); SerializabilityUtil.releaseTypes(expectedType, resolvedTypes);
private void serializeImpl(Object instance, Class<?> instanceClass) throws SerializationException { assert (instance != null); Class<?> customSerializer = SerializabilityUtil.hasCustomFieldSerializer(instanceClass); if (customSerializer != null) { // Use custom field serializer @SuppressWarnings("unchecked") CustomFieldSerializer<Object> customFieldSerializer = (CustomFieldSerializer<Object>) SerializabilityUtil.loadCustomFieldSerializer(customSerializer); if (customFieldSerializer == null) { serializeWithCustomSerializer(customSerializer, instance, instanceClass); } else { customFieldSerializer.serializeInstance(this, instance); } } else if (instanceClass.isArray()) { serializeArray(instanceClass, instance); } else if (instanceClass.isEnum()) { writeInt(((Enum<?>) instance).ordinal()); } else { // Regular class instance serializeClass(instance, instanceClass); } }
findInstanceParameters(instanceClass, resolvedTypes, expectedParameterTypes); Type actualType = findActualType(expectedType, resolvedTypes); if (!findExpectedInstanceClass(instanceClass, actualType, resolvedTypes, expectedInstanceClasses, expectedParameterTypes)) { findInstanceParameters(expectedClass, resolvedTypes, expectedParameterTypes);
Field[] serializableFields = SerializabilityUtil.applyFieldSerializationPolicy(instanceClass, serializationPolicy); for (Field declField : serializableFields) { Type[] superParameterTypes = SerializabilityUtil.findExpectedParameterTypes( superClass, superClass, resolvedTypes); deserializeImpl(SerializabilityUtil.hasServerCustomFieldSerializer(superClass), superClass, instance, expectedType, superParameterTypes, resolvedTypes);
if (!findExpectedInstanceClass(instanceClass, boundType, resolvedTypes, expectedInstanceClasses, expectedParameterTypes)) { return false; for (Type type : lowerBounds) { Class<?> boundClass = getClassFromType(type, resolvedTypes); for (Type type : upperBounds) { if (!findExpectedInstanceClass(instanceClass, type, resolvedTypes, expectedInstanceClasses, expectedParameterTypes)) { return false; if (findExpectedInstanceClassFromSuper(instanceClass.getGenericSuperclass(), expectedType, resolvedTypes, expectedInstanceClasses, localTypes)) { for (int i = 0; i < expectedParameterTypes.length; ++i) { for (Type interfaceType : interfaces) { Type[] localTypes = expectedParameterTypes.clone(); if (findExpectedInstanceClassFromSuper(interfaceType, expectedType, resolvedTypes, expectedInstanceClasses, localTypes)) { for (int i = 0; i < expectedParameterTypes.length; ++i) {