Java 类org.hibernate.type.SerializationException 实例源码

项目：lams 文件：Configuration.java

/**
 * <b>INTENDED FOR TESTSUITE USE ONLY!</b>
 * <p/>
 * Much like {@link #addCacheableFile(File)} except that here we will fail immediately if
 * the cache version cannot be found or used for whatever reason
 *
 * @param xmlFile The xml file, not the bin!
 *
 * @return The dom "deserialized" from the cached file.
 *
 * @throws SerializationException Indicates a problem deserializing the cached dom tree
 * @throws FileNotFoundException Indicates that the cached file was not found or was not usable.
 */
public Configuration addCacheableFileStrictly(File xmlFile) throws SerializationException, FileNotFoundException {
    final File cachedFile = determineCachedDomFile( xmlFile );

    final boolean useCachedFile = xmlFile.exists()
            && cachedFile.exists()
            && xmlFile.lastModified() < cachedFile.lastModified();

    if ( ! useCachedFile ) {
        throw new FileNotFoundException( "Cached file could not be found or could not be used" );
    }

    LOG.readingCachedMappings( cachedFile );
    Document document = ( Document ) SerializationHelper.deserialize( new FileInputStream( cachedFile ) );
    add( new XmlDocumentImpl( document, "file", xmlFile.getAbsolutePath() ) );
    return this;
}

项目：jadira 文件：AbstractUserType.java

public Serializable disassemble(Object value) throws HibernateException {

        final Serializable result;

        if (value == null) {
            result = null;
        } else {
            final Object deepCopy = deepCopy(value);
            if (!(deepCopy instanceof Serializable)) {
                throw new SerializationException(String.format("deepCopy of %s is not serializable", value), null);
            }
            result = (Serializable) deepCopy;
        }

        return result;
    }

项目：rembrandt 文件：WorkspaceHelper.java

public static SessionQueryBag loadSessionQueryBagFromDB(HttpSession session , Long userId){
    SessionQueryBag queryBag = null;
    UserQuery userQuery = null;
    if(userId != null){
           userQuery = myListLoader.loadUserQuery(userId);
           if(userQuery != null  && userQuery.getQueryContent()!= null){
            session.setAttribute(RembrandtConstants.USER_QUERY, userQuery);
            byte[] objectData = userQuery.getQueryContent();
            Object obj = null;
            try {
                obj = SerializationHelper.deserialize(objectData);
                if(obj != null && obj instanceof SessionQueryBag){
                    queryBag = (SessionQueryBag)obj;
                }
            } catch (SerializationException e) {
                System.out.println(e);
                logger.error(e.getMessage());
                session.removeAttribute(RembrandtConstants.USER_QUERY);
            }   
           }else{
            session.removeAttribute(RembrandtConstants.USER_QUERY);
           }
    }
    return queryBag;

}

项目：Equella 文件：StandardIndexer.java

private List<Field> indexFields(Schema schema, PropBagEx resBag)
{
    List<Field> fields = new ArrayList<Field>();
    if( schema != null )
    {
        try
        {
            XmlSchemaIndexer schemaIndexer = new XmlSchemaIndexer();
            schemaIndexer.indexChildNodes(schema.getRootSchemaNode(), schema.getItemNamePath(), "", "", resBag); //$NON-NLS-1$ //$NON-NLS-2$
            fields.addAll(schemaIndexer.getIndexedFields());
            Set<String> allPaths = schemaIndexer.getPathsIndexed();
            for( String path : allPaths )
            {
                fields.add(indexed(FreeTextQuery.FIELD_ALL, path));
            }
            Map<String, StringBuilder> pathValuesMap = schemaIndexer.getPathValuesMap();
            for( Map.Entry<String, StringBuilder> entry : pathValuesMap.entrySet() )
            {
                fields.add(unstored(entry.getKey() + '*', entry.getValue().toString()));
            }
        }
        catch( SerializationException ex )
        {
            LOGGER.error("Schema causing this issue is " + schema.getId() + " - " //$NON-NLS-1$ //$NON-NLS-2$
                + schema.getUuid(), ex);
            throw ex;
        }
    }
    return fields;
}

项目：data-migration 文件：JsonbUserType.java

@Override
public Serializable disassemble(Object value) throws HibernateException {
    Object copy = deepCopy(value);
    if (copy instanceof Serializable) {
        return (Serializable) copy;
    }
    throw new SerializationException(
            String.format("Cannot serialize '%s', %s is not Serializable.", value, value.getClass()), null);
}

项目：cacheonix-core 文件：SerializationHelper.java

/**
 * <p>Serializes an <code>Object</code> to the specified stream.</p>
 *
 * <p>The stream will be closed once the object is written.
 * This avoids the need for a finally clause, and maybe also exception
 * handling, in the application code.</p>
 *
 * <p>The stream passed in is not buffered internally within this method.
 * This is the responsibility of your application if desired.</p>
 *
 * @param obj  the object to serialize to bytes, may be null
 * @param outputStream  the stream to write to, must not be null
 * @throws IllegalArgumentException if <code>outputStream</code> is <code>null</code>
 * @throws SerializationException (runtime) if the serialization fails
 */
public static void serialize(Serializable obj, OutputStream outputStream) throws SerializationException {
    if (outputStream == null) {
        throw new IllegalArgumentException("The OutputStream must not be null");
    }

 if ( log.isTraceEnabled() ) {
  if ( Hibernate.isInitialized( obj ) ) {
         log.trace( "Starting serialization of object [" + obj + "]" );
  }
  else {
   log.trace( "Starting serialization of [uninitialized proxy]" );
  }
 }

    ObjectOutputStream out = null;
    try {
        // stream closed in the finally
        out = new ObjectOutputStream(outputStream);
        out.writeObject(obj);

    }
    catch (IOException ex) {
        throw new SerializationException("could not serialize", ex);
    }
    finally {
        try {
            if (out != null) out.close();
        }
        catch (IOException ignored) {}
    }
}

项目：perecoder 文件：JsonTypeDescriptor.java

protected byte[] toBytes(T value) {
    try {
        return OBJECT_MAPPER.writeValueAsBytes(value);
    } catch (Exception ex) {
        throw new SerializationException("could not serialize", ex);
    }
}

项目：perecoder 文件：JsonTypeDescriptor.java

protected T fromBytes(byte[] bytes) {
    try {
        return OBJECT_MAPPER.readValue(bytes, getJavaTypeClass());
    } catch (Exception ex) {
        throw new SerializationException("could not deserialize", ex);
    }
}

项目：hibernate-postgres-jsonb 文件：MutableUserType.java

/**
 * Disassembles the object in preparation for serialization.
 * See {@link org.hibernate.usertype.UserType#disassemble(java.lang.Object)}.
 * <p>
 * Expects {@link #deepCopy(Object)} to return a {@code Serializable}.
 * <strong>Subtypes whose {@code deepCopy} implementation returns a
 * non-serializable object must override this method.</strong>
 */
@Override
public Serializable disassemble(Object value) throws HibernateException {
  // also safe for mutable objects
  Object deepCopy = deepCopy(value);

  if (!(deepCopy instanceof Serializable)) {
    throw new SerializationException(
        String.format("deepCopy of %s is not serializable", value), null);
  }

  return (Serializable) deepCopy;
}

项目：Equella 文件：HibernateCsvType.java

private static byte[] toBytes(Object object) throws SerializationException
{
    return SerializationHelper.serialize((Serializable) object);
}

项目：Equella 文件：HibernateCsvType.java

private static Object fromBytes(byte[] bytes) throws SerializationException
{
    return SerializationHelper.deserialize(bytes);
}

项目：lams 文件：CoreMessageLogger.java

@LogMessage(level = WARN)
@Message(value = "Could not deserialize cache file: %s : %s", id = 307)
void unableToDeserializeCache(String path,
                              SerializationException error);