Examples with ObjectInputStream java.io.ObjectInputStream used on opensource projects

Example 91 with ObjectInputStream

use of java.io.ObjectInputStream in project byte-buddy by raphw.

the class AgentBuilderDefaultApplicationTest method testSerializableLambda.

@Test
@JavaVersionRule.Enforce(8)
@AgentAttachmentRule.Enforce(redefinesClasses = true)
@IntegrationRule.Enforce
public void testSerializableLambda() throws Exception {
    assertThat(ByteBuddyAgent.install(), instanceOf(Instrumentation.class));
    ClassLoader classLoader = lambdaSamples();
    ClassFileTransformer classFileTransformer = new AgentBuilder.Default().with(poolStrategy).ignore(none()).with(AgentBuilder.LambdaInstrumentationStrategy.ENABLED).installOn(ByteBuddyAgent.getInstrumentation());
    try {
        Class<?> sampleFactory = classLoader.loadClass(LAMBDA_SAMPLE_FACTORY);
        @SuppressWarnings("unchecked") Callable<String> instance = (Callable<String>) sampleFactory.getDeclaredMethod("serializable", String.class).invoke(sampleFactory.getDeclaredConstructor().newInstance(), FOO);
        assertThat(instance.call(), is(FOO));
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
        objectOutputStream.writeObject(instance);
        objectOutputStream.close();
        ObjectInputStream objectInputStream = new ObjectInputStream(new ByteArrayInputStream(outputStream.toByteArray()));
        @SuppressWarnings("unchecked") Callable<String> deserialized = (Callable<String>) objectInputStream.readObject();
        assertThat(deserialized.call(), is(FOO));
        objectInputStream.close();
    } finally {
        ByteBuddyAgent.getInstrumentation().removeTransformer(classFileTransformer);
        AgentBuilder.LambdaInstrumentationStrategy.release(classFileTransformer, ByteBuddyAgent.getInstrumentation());
    }
}

Example 92 with ObjectInputStream

use of java.io.ObjectInputStream in project roboguice by roboguice.

the class MultibinderTest method testMultibinderSetIsSerializable.

public void testMultibinderSetIsSerializable() throws IOException, ClassNotFoundException {
    Injector injector = Guice.createInjector(new AbstractModule() {

        protected void configure() {
            Multibinder.newSetBinder(binder(), String.class).addBinding().toInstance("A");
        }
    });
    Set<String> set = injector.getInstance(Key.get(setOfString));
    ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
    ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteStream);
    try {
        objectOutputStream.writeObject(set);
    } finally {
        objectOutputStream.close();
    }
    ObjectInputStream objectInputStream = new ObjectInputStream(new ByteArrayInputStream(byteStream.toByteArray()));
    try {
        Object setCopy = objectInputStream.readObject();
        assertEquals(set, setCopy);
    } finally {
        objectInputStream.close();
    }
}

Example 93 with ObjectInputStream

use of java.io.ObjectInputStream in project DirectMemory by raffaeleguidi.

the class StandardSerializer method deserialize.

public Serializable deserialize(byte[] source, @SuppressWarnings({ "rawtypes", "unchecked" }) Class clazz) throws IOException, ClassNotFoundException {
    ByteArrayInputStream bis = new ByteArrayInputStream(source);
    ObjectInputStream ois = new ObjectInputStream(bis);
    Serializable obj = (Serializable) ois.readObject();
    ois.close();
    return obj;
}

Example 94 with ObjectInputStream

use of java.io.ObjectInputStream in project orientdb by orientechnologies.

the class OGremlinHelper method cloneObject.

/*
   * Tries to clone any Java object by using 3 techniques: - instanceof (most verbose but faster performance) - reflection (medium
   * performance) - serialization (applies for any object type but has a performance overhead)
   */
@SuppressWarnings({ "rawtypes", "unchecked" })
public static Object cloneObject(final Object objectToClone, final Object previousClone) {
    // Clone any Map (shallow clone should be enough at this level)
    if (objectToClone instanceof Map) {
        Map recycledMap = (Map) previousClone;
        if (recycledMap == null)
            recycledMap = new HashMap();
        else
            recycledMap.clear();
        recycledMap.putAll((Map<?, ?>) objectToClone);
        return recycledMap;
    // Clone any collection (shallow clone should be enough at this level)
    } else if (objectToClone instanceof Collection) {
        Collection recycledCollection = (Collection) previousClone;
        if (recycledCollection == null)
            recycledCollection = new ArrayList();
        else
            recycledCollection.clear();
        recycledCollection.addAll((Collection<?>) objectToClone);
        return recycledCollection;
    // Clone String
    } else if (objectToClone instanceof String) {
        return objectToClone;
    } else if (objectToClone instanceof Number) {
        return objectToClone;
    // Clone Date
    } else if (objectToClone instanceof Date) {
        return (Date) ((Date) objectToClone).clone();
    } else {
        // ***************************************************************************************************************************************
        try {
            Object newClone;
            for (Class<?> obj = objectToClone.getClass(); !obj.equals(Object.class); obj = obj.getSuperclass()) {
                Method[] m = obj.getDeclaredMethods();
                for (int i = 0; i < m.length; i++) {
                    if (m[i].getName().equals("clone")) {
                        m[i].setAccessible(true);
                        newClone = m[i].invoke(objectToClone);
                        System.out.println(objectToClone.getClass() + " cloned by Reflection. Performance can be improved by adding the class to the list of known types");
                        return newClone;
                    }
                }
            }
            throw new Exception("Method clone not found");
        // ***************************************************************************************************************************************
        // 3. Polymorphic clone (Deep cloning by Serialization)
        // ***************************************************************************************************************************************
        } catch (Throwable e1) {
            try {
                final ByteArrayOutputStream bytes = new ByteArrayOutputStream() {

                    public synchronized byte[] toByteArray() {
                        return buf;
                    }
                };
                final ObjectOutputStream out = new ObjectOutputStream(bytes);
                out.writeObject(objectToClone);
                out.close();
                final ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(bytes.toByteArray()));
                System.out.println(objectToClone.getClass() + " cloned by Serialization. Performance can be improved by adding the class to the list of known types");
                return in.readObject();
            // ***************************************************************************************************************************************
            // 4. Impossible to clone
            // ***************************************************************************************************************************************
            } catch (Throwable e2) {
                OLogManager.instance().error(null, "[GremlinHelper] error on cloning object %s, previous %s", e2, objectToClone, previousClone);
                return null;
            }
        }
    }
}

Example 95 with ObjectInputStream

use of java.io.ObjectInputStream in project robovm by robovm.

the class AnnotationMember method rethrowError.

/**
     * Throws contained error (if any) with a renewed stack trace.
     */
public void rethrowError() throws Throwable {
    if (tag == ERROR) {
        // first check for expected types
        if (value instanceof TypeNotPresentException) {
            TypeNotPresentException tnpe = (TypeNotPresentException) value;
            throw new TypeNotPresentException(tnpe.typeName(), tnpe.getCause());
        } else if (value instanceof EnumConstantNotPresentException) {
            EnumConstantNotPresentException ecnpe = (EnumConstantNotPresentException) value;
            throw new EnumConstantNotPresentException(ecnpe.enumType(), ecnpe.constantName());
        } else if (value instanceof ArrayStoreException) {
            ArrayStoreException ase = (ArrayStoreException) value;
            throw new ArrayStoreException(ase.getMessage());
        }
        // got some other error, have to go with deep cloning
        // via serialization mechanism
        Throwable error = (Throwable) value;
        StackTraceElement[] ste = error.getStackTrace();
        ByteArrayOutputStream bos = new ByteArrayOutputStream(ste == null ? 512 : (ste.length + 1) * 80);
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(error);
        oos.flush();
        oos.close();
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        error = (Throwable) ois.readObject();
        ois.close();
        throw error;
    }
}