public Object readObject(final ObjectDataInput in) { try { final boolean isNull = in.readBoolean(); if (isNull) { return null; } final int typeId = in.readInt(); final SerializerAdapter serializer = serializerFor(typeId); if (serializer == null) { if (active) { throw new HazelcastSerializationException( "There is no suitable de-serializer for type " + typeId); } throw new HazelcastInstanceNotActiveException(); } if (typeId == SerializationConstants.CONSTANT_TYPE_PORTABLE && in instanceof PortableContextAwareInputStream) { ClassDefinition classDefinition = new ClassDefinitionImpl(); classDefinition.readData(in); classDefinition = serializationContext.registerClassDefinition(classDefinition); PortableContextAwareInputStream ctxIn = (PortableContextAwareInputStream) in; ctxIn.setClassDefinition(classDefinition); } Object obj = serializer.read(in); if (managedContext != null) { obj = managedContext.initialize(obj); } return obj; } catch (Throwable e) { handleException(e); } return null; }
public void writeObject(final ObjectDataOutput out, final Object obj) { final boolean isNull = obj == null; try { out.writeBoolean(isNull); if (isNull) { return; } final SerializerAdapter serializer = serializerFor(obj.getClass()); if (serializer == null) { if (active) { throw new HazelcastSerializationException( "There is no suitable serializer for " + obj.getClass()); } throw new HazelcastInstanceNotActiveException(); } out.writeInt(serializer.getTypeId()); if (obj instanceof Portable) { final Portable portable = (Portable) obj; ClassDefinition classDefinition = serializationContext.lookupOrRegisterClassDefinition(portable); classDefinition.writeData(out); } serializer.write(out, obj); } catch (Throwable e) { handleException(e); } }
public <T> T toObject(final Object object) { if (!(object instanceof Data)) { return (T) object; } Data data = (Data) object; if (data.bufferSize() == 0 && data.isDataSerializable()) { return null; } try { final int typeId = data.type; final SerializerAdapter serializer = serializerFor(typeId); if (serializer == null) { if (active) { throw new HazelcastSerializationException( "There is no suitable de-serializer for type " + typeId); } throw new HazelcastInstanceNotActiveException(); } if (typeId == SerializationConstants.CONSTANT_TYPE_PORTABLE) { serializationContext.registerClassDefinition(data.classDefinition); } Object obj = serializer.read(data); if (managedContext != null) { obj = managedContext.initialize(obj); } return (T) obj; } catch (Throwable e) { handleException(e); } return null; }
private void registerClassDefinition( ClassDefinition cd, Map<Integer, ClassDefinition> classDefMap, boolean checkClassDefErrors) { for (int i = 0; i < cd.getFieldCount(); i++) { FieldDefinition fd = cd.get(i); if (fd.getType() == FieldType.PORTABLE || fd.getType() == FieldType.PORTABLE_ARRAY) { int classId = fd.getClassId(); ClassDefinition nestedCd = classDefMap.get(classId); if (nestedCd != null) { ((ClassDefinitionImpl) cd).addClassDef(nestedCd); registerClassDefinition(nestedCd, classDefMap, checkClassDefErrors); serializationContext.registerClassDefinition(nestedCd); } else if (checkClassDefErrors) { throw new HazelcastSerializationException( "Could not find registered ClassDefinition for class-id: " + classId); } } } serializationContext.registerClassDefinition(cd); }
@SuppressWarnings("unchecked") public Data toData(Object obj, PartitioningStrategy strategy) { if (obj == null) { return null; } if (obj instanceof Data) { return (Data) obj; } try { final SerializerAdapter serializer = serializerFor(obj.getClass()); if (serializer == null) { if (active) { throw new HazelcastSerializationException( "There is no suitable serializer for " + obj.getClass()); } throw new HazelcastInstanceNotActiveException(); } final byte[] bytes = serializer.write(obj); final Data data = new Data(serializer.getTypeId(), bytes); if (obj instanceof Portable) { final Portable portable = (Portable) obj; data.classDefinition = serializationContext.lookup(portable.getFactoryId(), portable.getClassId()); } if (strategy == null) { strategy = globalPartitioningStrategy; } if (strategy != null) { Object pk = strategy.getPartitionKey(obj); if (pk != null && pk != obj) { final Data partitionKey = toData(pk, EMPTY_PARTITIONING_STRATEGY); data.partitionHash = (partitionKey == null) ? -1 : partitionKey.getPartitionHash(); } } return data; } catch (Throwable e) { handleException(e); } return null; }
SerializationServiceImpl( InputOutputFactory inputOutputFactory, int version, ClassLoader classLoader, Map<Integer, ? extends DataSerializableFactory> dataSerializableFactories, Map<Integer, ? extends PortableFactory> portableFactories, Collection<ClassDefinition> classDefinitions, boolean checkClassDefErrors, ManagedContext managedContext, PartitioningStrategy partitionStrategy, int initialOutputBufferSize, boolean enableCompression, boolean enableSharedObject) { this.inputOutputFactory = inputOutputFactory; this.classLoader = classLoader; this.managedContext = managedContext; this.globalPartitioningStrategy = partitionStrategy; this.outputBufferSize = initialOutputBufferSize; PortableHookLoader loader = new PortableHookLoader(portableFactories, classLoader); serializationContext = new SerializationContextImpl(this, loader.getFactories().keySet(), version); for (ClassDefinition cd : loader.getDefinitions()) { serializationContext.registerClassDefinition(cd); } dataSerializerAdapter = new StreamSerializerAdapter( this, new DataSerializer(dataSerializableFactories, classLoader)); portableSerializer = new PortableSerializer(serializationContext, loader.getFactories()); portableSerializerAdapter = new StreamSerializerAdapter(this, portableSerializer); registerConstant(DataSerializable.class, dataSerializerAdapter); registerConstant(Portable.class, portableSerializerAdapter); registerConstant(Byte.class, new ByteSerializer()); registerConstant(Boolean.class, new BooleanSerializer()); registerConstant(Character.class, new CharSerializer()); registerConstant(Short.class, new ShortSerializer()); registerConstant(Integer.class, new IntegerSerializer()); registerConstant(Long.class, new LongSerializer()); registerConstant(Float.class, new FloatSerializer()); registerConstant(Double.class, new DoubleSerializer()); registerConstant(byte[].class, new TheByteArraySerializer()); registerConstant(char[].class, new CharArraySerializer()); registerConstant(short[].class, new ShortArraySerializer()); registerConstant(int[].class, new IntegerArraySerializer()); registerConstant(long[].class, new LongArraySerializer()); registerConstant(float[].class, new FloatArraySerializer()); registerConstant(double[].class, new DoubleArraySerializer()); registerConstant(String.class, new StringSerializer()); safeRegister(Date.class, new DateSerializer()); safeRegister(BigInteger.class, new BigIntegerSerializer()); safeRegister(BigDecimal.class, new BigDecimalSerializer()); safeRegister(Externalizable.class, new Externalizer(enableCompression)); safeRegister(Serializable.class, new ObjectSerializer(enableSharedObject, enableCompression)); safeRegister(Class.class, new ClassSerializer()); safeRegister(Enum.class, new EnumSerializer()); registerClassDefinitions(classDefinitions, checkClassDefErrors); }