Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more contributor license * agreements. See the NOTICE file distributed with this work for additional information regarding * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance with the License. You may obtain a * copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express * or implied. See the License for the specific language governing permissions and limitations under * the License. */ package org.apache.geode.pdx.internal; import static org.apache.logging.log4j.message.MapMessage.MapFormat.JSON; import java.io.DataInput; import java.io.DataOutput; import java.io.IOException; import java.nio.ByteBuffer; import java.text.SimpleDateFormat; import java.util.Arrays; import java.util.Collection; import java.util.Iterator; import java.util.List; import java.util.SortedSet; import java.util.TreeSet; import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.ObjectMapper; import org.apache.commons.lang.StringUtils; import org.apache.geode.InternalGemFireException; import org.apache.geode.distributed.internal.DMStats; import org.apache.geode.internal.ClassPathLoader; import org.apache.geode.internal.DSCODE; import org.apache.geode.internal.InternalDataSerializer; import org.apache.geode.internal.Sendable; import org.apache.geode.internal.cache.GemFireCacheImpl; import org.apache.geode.internal.tcp.ByteBufferInputStream; import org.apache.geode.internal.tcp.ByteBufferInputStream.ByteSource; import org.apache.geode.internal.tcp.ByteBufferInputStream.ByteSourceFactory; import org.apache.geode.pdx.JSONFormatter; import org.apache.geode.pdx.PdxInstance; import org.apache.geode.pdx.PdxSerializationException; import org.apache.geode.pdx.WritablePdxInstance; /** * Implementation code in this class must be careful to not directly call super class state. Instead * it must call {@link #getUnmodifiableReader()} and access the super class state using it. This * class could be changed to not extend PdxReaderImpl but to instead have an instance variable that * is a PdxReaderImpl but that would cause this class to use more memory. * * We do not use this normal java io serialization when serializing this class in GemFire because * Sendable takes precedence over Serializable. * * */ public class PdxInstanceImpl extends PdxReaderImpl implements PdxInstance, Sendable, ConvertableToBytes { private static final long serialVersionUID = -1669268527103938431L; private static final boolean USE_STATIC_MAPPER = Boolean.getBoolean("PdxInstance.use-static-mapper"); static final ObjectMapper mapper = USE_STATIC_MAPPER ? createObjectMapper() : null; private static ObjectMapper createObjectMapper() { ObjectMapper mapper = new ObjectMapper(); mapper.setDateFormat(new SimpleDateFormat("MM/dd/yyyy")); mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); mapper.configure(com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true); return mapper; } private transient volatile Object cachedObjectForm; /** * Computes the hash code once and stores it. This is added to address the issue of identity value * getting changed for each hash code call (as new objects instances are created in each call for * the same object). The value 0 means the hash code is not yet computed (this avoids using extra * variable for this), if the computation returns 0, it will be set to 1. This doesn't break the * equality rule, where hash code can be same for non-equal objects. */ private static final int UNUSED_HASH_CODE = 0; private transient volatile int cachedHashCode = UNUSED_HASH_CODE; private static final ThreadLocal<Boolean> pdxGetObjectInProgress = new ThreadLocal<Boolean>(); public PdxInstanceImpl(PdxType pdxType, DataInput in, int len) { super(pdxType, createDis(in, len)); } protected PdxInstanceImpl(PdxReaderImpl original) { super(original); } private static PdxInputStream createDis(DataInput in, int len) { PdxInputStream dis; if (in instanceof PdxInputStream) { dis = new PdxInputStream((ByteBufferInputStream) in, len); try { int bytesSkipped = in.skipBytes(len); int bytesRemaining = len - bytesSkipped; while (bytesRemaining > 0) { in.readByte(); bytesRemaining--; } } catch (IOException ex) { throw new PdxSerializationException("Could not deserialize PDX", ex); } } else { byte[] bytes = new byte[len]; try { in.readFully(bytes); } catch (IOException ex) { throw new PdxSerializationException("Could not deserialize PDX", ex); } dis = new PdxInputStream(bytes); } return dis; } public static boolean getPdxReadSerialized() { return pdxGetObjectInProgress.get() == null; } public static void setPdxReadSerialized(boolean readSerialized) { if (!readSerialized) { pdxGetObjectInProgress.set(true); } else { pdxGetObjectInProgress.remove(); } } public Object getField(String fieldName) { return getUnmodifiableReader(fieldName).readField(fieldName); } private PdxWriterImpl convertToTypeWithNoDeletedFields(PdxReaderImpl ur) { PdxOutputStream os = new PdxOutputStream(); PdxType pt = new PdxType(ur.getPdxType().getClassName(), !ur.getPdxType().getNoDomainClass()); GemFireCacheImpl gfc = GemFireCacheImpl .getForPdx("PDX registry is unavailable because the Cache has been closed."); TypeRegistry tr = gfc.getPdxRegistry(); PdxWriterImpl writer = new PdxWriterImpl(pt, tr, os); for (PdxField field : pt.getFields()) { if (!field.isDeleted()) { writer.writeRawField(field, ur.getRaw(field)); } } writer.completeByteStreamGeneration(); return writer; } // Sendable implementation public void sendTo(DataOutput out) throws IOException { PdxReaderImpl ur = getUnmodifiableReader(); if (ur.getPdxType().getHasDeletedField()) { PdxWriterImpl writer = convertToTypeWithNoDeletedFields(ur); writer.sendTo(out); } else { out.write(DSCODE.PDX); out.writeInt(ur.basicSize()); out.writeInt(ur.getPdxType().getTypeId()); ur.basicSendTo(out); } } public byte[] toBytes() { PdxReaderImpl ur = getUnmodifiableReader(); if (ur.getPdxType().getHasDeletedField()) { PdxWriterImpl writer = convertToTypeWithNoDeletedFields(ur); return writer.toByteArray(); } else { byte[] result = new byte[PdxWriterImpl.HEADER_SIZE + ur.basicSize()]; ByteBuffer bb = ByteBuffer.wrap(result); bb.put(DSCODE.PDX); bb.putInt(ur.basicSize()); bb.putInt(ur.getPdxType().getTypeId()); ur.basicSendTo(bb); return result; } } // this is for internal use of the query engine. public Object getCachedObject() { Object result = this.cachedObjectForm; if (result == null) { result = getObject(); this.cachedObjectForm = result; } return result; } private String extractTypeMetaData() { Object type = this.getField("@type"); if (type != null) { if (type instanceof String) { return (String) type; } else { throw new PdxSerializationException("Could not deserialize as invalid className found"); } } else { return null; } } @Override public Object getObject() { if (getPdxType().getNoDomainClass()) { // In case of Developer Rest APIs, All PdxInstances converted from Json will have a className // =__GEMFIRE_JSON. // Following code added to convert Json/PdxInstance into the Java object. if (this.getClassName().equals("__GEMFIRE_JSON")) { // introspect the JSON, does the @type meta-data exist. String className = extractTypeMetaData(); if (StringUtils.isNotBlank(className)) { try { String JSON = JSONFormatter.toJSON(this); ObjectMapper objMapper = USE_STATIC_MAPPER ? mapper : createObjectMapper(); Object classInstance = objMapper.readValue(JSON, ClassPathLoader.getLatest().forName(className)); return classInstance; } catch (Exception e) { throw new PdxSerializationException( "Could not deserialize as java class type could not resolved", e); } } } return this; } boolean wouldReadSerialized = PdxInstanceImpl.getPdxReadSerialized(); if (!wouldReadSerialized) { return getUnmodifiableReader().basicGetObject(); } else { PdxInstanceImpl.setPdxReadSerialized(false); try { return getUnmodifiableReader().basicGetObject(); } finally { PdxInstanceImpl.setPdxReadSerialized(true); } } } @Override public int hashCode() { if (this.cachedHashCode != UNUSED_HASH_CODE) { // Already computed. return this.cachedHashCode; } PdxReaderImpl ur = getUnmodifiableReader(); // Compute hash code. Collection<PdxField> fields = ur.getPdxType().getSortedIdentityFields(); int hashCode = 1; for (PdxField ft : fields) { switch (ft.getFieldType()) { case CHAR: case BOOLEAN: case BYTE: case SHORT: case INT: case LONG: case DATE: case FLOAT: case DOUBLE: case STRING: case BOOLEAN_ARRAY: case CHAR_ARRAY: case BYTE_ARRAY: case SHORT_ARRAY: case INT_ARRAY: case LONG_ARRAY: case FLOAT_ARRAY: case DOUBLE_ARRAY: case STRING_ARRAY: case ARRAY_OF_BYTE_ARRAYS: { ByteSource buffer = ur.getRaw(ft); if (!buffer.equals(ByteSourceFactory.create(ft.getFieldType().getDefaultBytes()))) { hashCode = hashCode * 31 + buffer.hashCode(); } break; } case OBJECT_ARRAY: { Object[] oArray = ur.readObjectArray(ft); if (oArray != null) { // default value of null does not modify hashCode. hashCode = hashCode * 31 + Arrays.deepHashCode(oArray); } break; } case OBJECT: { Object objectValue = ur.readObject(ft); if (objectValue == null) { // default value of null does not modify hashCode. } else if (objectValue.getClass().isArray()) { Class<?> myComponentType = objectValue.getClass().getComponentType(); if (myComponentType.isPrimitive()) { ByteSource buffer = getRaw(ft); hashCode = hashCode * 31 + buffer.hashCode(); } else { hashCode = hashCode * 31 + Arrays.deepHashCode((Object[]) objectValue); } } else { hashCode = hashCode * 31 + objectValue.hashCode(); } break; } default: throw new InternalGemFireException("Unhandled field type " + ft.getFieldType()); } } int result = (hashCode == UNUSED_HASH_CODE) ? (hashCode + 1) : hashCode; this.cachedHashCode = result; return result; } @Override public boolean equals(Object obj) { if (obj == this) return true; if (obj == null) { // GemFireCacheImpl.getInstance().getLogger().info("DEBUG equals#0 o1=<" + this + "> o2=<" + // obj + ">"); return false; } if (!(obj instanceof PdxInstanceImpl)) { // if (!result) { // GemFireCacheImpl.getInstance().getLogger().info("DEBUG equals#1 o1=<" + this + "> o2=<" + // obj + ">"); // } return false; } final PdxInstanceImpl other = (PdxInstanceImpl) obj; PdxReaderImpl ur2 = other.getUnmodifiableReader(); PdxReaderImpl ur1 = getUnmodifiableReader(); if (!ur1.getPdxType().getClassName().equals(ur2.getPdxType().getClassName())) { // GemFireCacheImpl.getInstance().getLogger().info("DEBUG equals#2 o1=<" + this + "> o2=<" + // obj + ">"); return false; } SortedSet<PdxField> myFields = ur1.getPdxType().getSortedIdentityFields(); SortedSet<PdxField> otherFields = ur2.getPdxType().getSortedIdentityFields(); if (!myFields.equals(otherFields)) { // It is not ok to modify myFields and otherFields in place so make copies myFields = new TreeSet<PdxField>(myFields); otherFields = new TreeSet<PdxField>(otherFields); addDefaultFields(myFields, otherFields); addDefaultFields(otherFields, myFields); } Iterator<PdxField> myFieldIterator = myFields.iterator(); Iterator<PdxField> otherFieldIterator = otherFields.iterator(); while (myFieldIterator.hasNext()) { PdxField myType = myFieldIterator.next(); PdxField otherType = otherFieldIterator.next(); switch (myType.getFieldType()) { case CHAR: case BOOLEAN: case BYTE: case SHORT: case INT: case LONG: case DATE: case FLOAT: case DOUBLE: case STRING: case BOOLEAN_ARRAY: case CHAR_ARRAY: case BYTE_ARRAY: case SHORT_ARRAY: case INT_ARRAY: case LONG_ARRAY: case FLOAT_ARRAY: case DOUBLE_ARRAY: case STRING_ARRAY: case ARRAY_OF_BYTE_ARRAYS: { ByteSource myBuffer = ur1.getRaw(myType); ByteSource otherBuffer = ur2.getRaw(otherType); if (!myBuffer.equals(otherBuffer)) { // GemFireCacheImpl.getInstance().getLogger().info("DEBUG equals#4 o1=<" + this + "> // o2=<" + obj + ">"); return false; } } break; case OBJECT_ARRAY: { Object[] myArray = ur1.readObjectArray(myType); Object[] otherArray = ur2.readObjectArray(otherType); if (!Arrays.deepEquals(myArray, otherArray)) { // GemFireCacheImpl.getInstance().getLogger().info("DEBUG equals#5 o1=<" + this + "> // o2=<" + obj + ">"); return false; } } break; case OBJECT: { Object myObject = ur1.readObject(myType); Object otherObject = ur2.readObject(otherType); if (myObject != otherObject) { if (myObject == null) { // GemFireCacheImpl.getInstance().getLogger().info("DEBUG equals#6 o1=<" + this + "> // o2=<" + obj + ">"); return false; } if (otherObject == null) { // GemFireCacheImpl.getInstance().getLogger().info("DEBUG equals#7 o1=<" + this + "> // o2=<" + obj + ">"); return false; } if (myObject.getClass().isArray()) { // for bug 42976 Class<?> myComponentType = myObject.getClass().getComponentType(); Class<?> otherComponentType = otherObject.getClass().getComponentType(); if (!myComponentType.equals(otherComponentType)) { // GemFireCacheImpl.getInstance().getLogger().info("DEBUG equals#8 o1=<" + this + "> // o2=<" + obj + ">"); return false; } if (myComponentType.isPrimitive()) { ByteSource myBuffer = getRaw(myType); ByteSource otherBuffer = other.getRaw(otherType); if (!myBuffer.equals(otherBuffer)) { // GemFireCacheImpl.getInstance().getLogger().info("DEBUG equals#9 o1=<" + this + // "> o2=<" + obj + ">"); return false; } } else { if (!Arrays.deepEquals((Object[]) myObject, (Object[]) otherObject)) { // GemFireCacheImpl.getInstance().getLogger().info("DEBUG equals#10 o1=<" + this + // "> o2=<" + obj + ">"); return false; } } } else if (!myObject.equals(otherObject)) { // GemFireCacheImpl.getInstance().getLogger().info("DEBUG equals#11 fn=" + // myType.getFieldName() + " myFieldClass=" + myObject.getClass() + " // otherFieldCLass=" + otherObject.getClass() + " o1=<" + this + "> o2=<" + obj + ">" // + "myObj=<" + myObject + "> otherObj=<" + otherObject + ">"); return false; } } } break; default: throw new InternalGemFireException("Unhandled field type " + myType.getFieldType()); } } return true; } /** * Any fields that are in otherFields but not in myFields are added to myFields as defaults. When * adding fields they are inserted in the natural sort order. Note: myFields may be modified by * this call. */ private static void addDefaultFields(SortedSet<PdxField> myFields, SortedSet<PdxField> otherFields) { for (PdxField f : otherFields) { if (!myFields.contains(f)) { myFields.add(new DefaultPdxField(f)); } } } @Override public String toString() { StringBuilder result = new StringBuilder(); PdxReaderImpl ur = getUnmodifiableReader(); result.append("PDX[").append(ur.getPdxType().getTypeId()).append(",").append(ur.getPdxType().getClassName()) // .append(",limit=").append(this.dis.size()) .append("]{"); boolean firstElement = true; for (PdxField fieldType : ur.getPdxType().getSortedIdentityFields()) { if (firstElement) { firstElement = false; } else { result.append(", "); } ; result.append(fieldType.getFieldName()); // result.append(':').append(fieldType.getTypeIdString()); // DEBUG // result.append(':').append(getAbsolutePosition(fieldType)); // DEBUG result.append("="); try { // TODO check to see if getField returned an array and if it did use Arrays.deepToString result.append(ur.readField(fieldType.getFieldName())); } catch (RuntimeException e) { result.append(e); } } result.append("}"); return result.toString(); } public List<String> getFieldNames() { return getPdxType().getFieldNames(); } @Override PdxUnreadData getReadUnreadFieldsCalled() { return null; } protected void clearCachedState() { this.cachedHashCode = UNUSED_HASH_CODE; this.cachedObjectForm = null; } public WritablePdxInstance createWriter() { if (isEnum()) { throw new IllegalStateException("PdxInstances that are an enum can not be modified."); } return new WritablePdxInstanceImpl(getUnmodifiableReader()); } protected PdxReaderImpl getUnmodifiableReader() { return this; } protected PdxReaderImpl getUnmodifiableReader(String fieldName) { return this; } // All PdxReaderImpl methods that might change the ByteBuffer position // need to be synchronized so that they are done atomically. // This fixes bug 43178. // primitive read methods all use absolute read methods so they do not set position // so no sync is needed. Fixed width fields all use absolute read methods. @Override public synchronized String readString(String fieldName) { return super.readString(fieldName); } @Override public synchronized Object readObject(String fieldName) { return super.readObject(fieldName); } @Override public synchronized Object readObject(PdxField ft) { return super.readObject(ft); } @Override public synchronized char[] readCharArray(String fieldName) { return super.readCharArray(fieldName); } @Override public synchronized boolean[] readBooleanArray(String fieldName) { return super.readBooleanArray(fieldName); } @Override public synchronized byte[] readByteArray(String fieldName) { return super.readByteArray(fieldName); } @Override public synchronized short[] readShortArray(String fieldName) { return super.readShortArray(fieldName); } @Override public synchronized int[] readIntArray(String fieldName) { return super.readIntArray(fieldName); } @Override public synchronized long[] readLongArray(String fieldName) { return super.readLongArray(fieldName); } @Override public synchronized float[] readFloatArray(String fieldName) { return super.readFloatArray(fieldName); } @Override public synchronized double[] readDoubleArray(String fieldName) { return super.readDoubleArray(fieldName); } @Override public synchronized String[] readStringArray(String fieldName) { return super.readStringArray(fieldName); } @Override public synchronized Object[] readObjectArray(String fieldName) { return super.readObjectArray(fieldName); } @Override public synchronized Object[] readObjectArray(PdxField ft) { return super.readObjectArray(ft); } @Override public synchronized byte[][] readArrayOfByteArrays(String fieldName) { return super.readArrayOfByteArrays(fieldName); } @Override public synchronized Object readField(String fieldName) { return super.readField(fieldName); } @Override protected synchronized Object basicGetObject() { DMStats stats = InternalDataSerializer.getDMStats(null); long start = stats.startPdxInstanceDeserialization(); try { return super.basicGetObject(); } finally { stats.endPdxInstanceDeserialization(start); } } // override getRaw to fix bug 43569 @Override protected synchronized ByteSource getRaw(PdxField ft) { return super.getRaw(ft); } @Override protected synchronized void basicSendTo(DataOutput out) throws IOException { super.basicSendTo(out); } @Override protected synchronized void basicSendTo(ByteBuffer bb) { super.basicSendTo(bb); } public String getClassName() { return getPdxType().getClassName(); } public boolean isEnum() { return false; } public Object getRawField(String fieldName) { return getUnmodifiableReader(fieldName).readRawField(fieldName); } public Object getDefaultValueIfFieldExistsInAnyPdxVersions(String fieldName, String className) throws FieldNotFoundInPdxVersion { PdxType pdxType = GemFireCacheImpl .getForPdx("PDX registry is unavailable because the Cache has been closed.").getPdxRegistry() .getPdxTypeForField(fieldName, className); if (pdxType == null) { throw new FieldNotFoundInPdxVersion( "PdxType with field " + fieldName + " is not found for class " + className); } return pdxType.getPdxField(fieldName).getFieldType().getDefaultValue(); } }