Example usage for org.apache.commons.lang SerializationUtils deserialize

Introduction

In this page you can find the example usage for org.apache.commons.lang SerializationUtils deserialize.

Prototype

public static Object deserialize(byte[] objectData) 

Source Link

Document

Deserializes a single Object from an array of bytes.

Usage

From source file:org.datacleaner.test.full.scenarios.JobWithOutputDataStreamsTest.java

@Test(timeout = 30 * 1000)
public void testSimpleBuildAndExecuteScenario() throws Throwable {
    final AnalysisJob job;
    try (final AnalysisJobBuilder ajb = new AnalysisJobBuilder(configuration)) {
        ajb.setDatastore(datastore);/* w w  w .ja v a 2  s.c  o m*/

        ajb.addSourceColumns("customers.contactfirstname");
        ajb.addSourceColumns("customers.contactlastname");
        ajb.addSourceColumns("customers.city");

        final AnalyzerComponentBuilder<MockOutputDataStreamAnalyzer> analyzer1 = ajb
                .addAnalyzer(MockOutputDataStreamAnalyzer.class);

        // analyzer is still unconfigured
        assertEquals(0, analyzer1.getOutputDataStreams().size());

        // now configure it
        final List<MetaModelInputColumn> sourceColumns = ajb.getSourceColumns();
        analyzer1.setName("analyzer1");
        analyzer1.addInputColumn(sourceColumns.get(0));
        assertTrue(analyzer1.isConfigured());

        final List<OutputDataStream> dataStreams = analyzer1.getOutputDataStreams();

        assertEquals(2, dataStreams.size());
        assertEquals("foo bar records", dataStreams.get(0).getName());
        assertEquals("counter records", dataStreams.get(1).getName());

        final OutputDataStream dataStream = analyzer1.getOutputDataStream("foo bar records");
        // assert that the same instance is reused when re-referred to
        assertSame(dataStreams.get(0), dataStream);

        // the stream is still not "consumed" yet
        assertFalse(analyzer1.isOutputDataStreamConsumed(dataStream));

        final AnalysisJobBuilder outputDataStreamJobBuilder = analyzer1
                .getOutputDataStreamJobBuilder(dataStream);
        final List<MetaModelInputColumn> outputDataStreamColumns = outputDataStreamJobBuilder
                .getSourceColumns();
        assertEquals(2, outputDataStreamColumns.size());
        assertEquals("MetaModelInputColumn[foo bar records.foo]", outputDataStreamColumns.get(0).toString());
        assertEquals("MetaModelInputColumn[foo bar records.bar]", outputDataStreamColumns.get(1).toString());

        // the stream is still not "consumed" because no components exist in
        // the output stream
        assertFalse(analyzer1.isOutputDataStreamConsumed(dataStream));

        final AnalyzerComponentBuilder<MockAnalyzer> analyzer2 = outputDataStreamJobBuilder
                .addAnalyzer(MockAnalyzer.class);
        analyzer2.addInputColumns(outputDataStreamColumns);
        analyzer2.setName("analyzer2");
        assertTrue(analyzer2.isConfigured());

        // now the stream is consumed
        assertTrue(analyzer1.isOutputDataStreamConsumed(dataStream));

        job = ajb.toAnalysisJob();
    }

    // do some assertions on the built job to check that the data stream is
    // represented there also
    assertEquals(1, job.getAnalyzerJobs().size());
    final AnalyzerJob analyzerJob1 = job.getAnalyzerJobs().get(0);
    assertEquals("analyzer1", analyzerJob1.getName());
    final OutputDataStreamJob[] outputDataStreamJobs = analyzerJob1.getOutputDataStreamJobs();
    assertEquals(1, outputDataStreamJobs.length);

    final OutputDataStreamJob outputDataStreamJob = outputDataStreamJobs[0];
    assertEquals("foo bar records", outputDataStreamJob.getOutputDataStream().getName());
    final AnalysisJob job2 = outputDataStreamJob.getJob();
    assertEquals(2, job2.getSourceColumns().size());
    assertEquals("foo", job2.getSourceColumns().get(0).getName());
    assertEquals("bar", job2.getSourceColumns().get(1).getName());
    assertEquals(1, job2.getAnalyzerJobs().size());
    final AnalyzerJob analyzerJob2 = job2.getAnalyzerJobs().get(0);
    assertEquals("analyzer2", analyzerJob2.getName());

    // now run the job(s)
    final AnalysisRunnerImpl runner = new AnalysisRunnerImpl(configuration);
    final AnalysisResultFuture resultFuture = runner.run(job);
    resultFuture.await();

    if (resultFuture.isErrornous()) {
        throw resultFuture.getErrors().get(0);
    }

    assertEquals(2, resultFuture.getResults().size());

    final byte[] serialized = SerializationUtils
            .serialize(new SimpleAnalysisResult(resultFuture.getResultMap()));

    final SimpleAnalysisResult deSerializedResult = (SimpleAnalysisResult) SerializationUtils
            .deserialize(serialized);

    // the first result should be trivial - it was also there before issue
    // #224
    final ListResult<?> result1 = (ListResult<?>) deSerializedResult.getResult(analyzerJob1);
    assertNotNull(result1);
    assertEquals(40, result1.getValues().size());

    // this result is the "new part" of issue #224
    final ListResult<?> result2 = (ListResult<?>) deSerializedResult.getResult(analyzerJob2);
    assertNotNull(result2);
    assertEquals(83, result2.getValues().size());
    final Object lastElement = result2.getValues().get(result2.getValues().size() - 1);
    assertEquals("MetaModelInputRow[Row[values=[baz, null]]]", lastElement.toString());
}

---

From source file:org.eclipse.dataset.metadata.Metadata.java

@Override
public IMetadata clone() {
    Metadata c = null;//from w w w.  j  av  a  2 s  . c o m
    try {
        c = (Metadata) super.clone();
        if (metadata != null) {
            HashMap<String, Serializable> md = new HashMap<String, Serializable>();
            c.metadata = md;
            ByteArrayOutputStream os = new ByteArrayOutputStream(512);
            for (String k : metadata.keySet()) {
                Serializable v = metadata.get(k);
                if (v != null) {
                    // TODO: Note that there is a dependency on org.apache.commons.lang that is only used for
                    // accessing SerializationUtils. In reality, the serialize call really is just:
                    // try (ObjectOutputStream out = new ObjectOutputStream(outputStream)) {
                    //    out.writeObject(v);
                    // } finally {
                    //   out.close();
                    // }
                    // and deserialize is similarly simple.
                    SerializationUtils.serialize(v, os);
                    Serializable nv = (Serializable) SerializationUtils.deserialize(os.toByteArray());
                    os.reset();
                    md.put(k, nv);
                } else {
                    md.put(k, null);
                }
            }
        }
        c.shapes = new HashMap<String, int[]>(1);
        for (Entry<String, int[]> e : shapes.entrySet()) {
            int[] s = e.getValue();
            c.shapes.put(e.getKey(), s == null ? null : s.clone());
        }
    } catch (CloneNotSupportedException e) {
        // Allowed for some objects not to be cloned.
    } catch (Throwable e) {
        if (e instanceof ClassNotFoundException) {
            // Fix to http://jira.diamond.ac.uk/browse/SCI-1644
            // Happens when cloning meta data with GridPreferences
        }
        if (e instanceof RuntimeException) {
            throw (RuntimeException) e;
        }
    }
    return c;
}

---

From source file:org.eclipse.dawnsci.analysis.api.metadata.Metadata.java

@Override
public IMetadata clone() {
    Metadata c = null;/*from  w  w  w .j  a  va 2  s. c  om*/
    try {
        c = (Metadata) super.clone();
        if (metadata != null) {
            HashMap<String, Serializable> md = new HashMap<String, Serializable>();
            c.metadata = md;
            ByteArrayOutputStream os = new ByteArrayOutputStream(512);
            for (String k : metadata.keySet()) {
                Serializable v = metadata.get(k);
                if (v != null) {
                    SerializationUtils.serialize(v, os);
                    Serializable nv = (Serializable) SerializationUtils.deserialize(os.toByteArray());
                    os.reset();
                    md.put(k, nv);
                } else {
                    md.put(k, null);
                }
            }
        }
        c.shapes = new HashMap<String, int[]>(1);
        for (Entry<String, int[]> e : shapes.entrySet()) {
            int[] s = e.getValue();
            c.shapes.put(e.getKey(), s == null ? null : s.clone());
        }
    } catch (CloneNotSupportedException e) {
        // Allowed for some objects not to be cloned.
    } catch (Throwable e) {
        if (e instanceof ClassNotFoundException) {
            // Fix to http://jira.diamond.ac.uk/browse/SCI-1644
            // Happens when cloning meta data with GridPreferences
        }
        if (e instanceof RuntimeException) {
            throw (RuntimeException) e;
        }
    }
    return c;
}

---

From source file:org.eobjects.analyzer.cli.MainTest.java

public void testWriteSerializedToFile() throws Throwable {
    String filename = "target/test_write_serialized_to_file.analysis.result.dat";
    Main.main(("-conf examples/conf.xml -job examples/employees_job.xml -of " + filename + " -ot SERIALIZED")
            .split(" "));

    File file = new File(filename);
    assertTrue(file.exists());//from   w w  w  . j  av  a 2 s.c o m

    AnalysisResult result = (AnalysisResult) SerializationUtils.deserialize(new FileInputStream(file));
    assertNotNull(result);
    assertEquals(6, result.getResults().size());
}

---

From source file:org.eobjects.analyzer.reference.SimpleSynonymCatalogTest.java

public void testDeserializePreviousVersion() throws Exception {
    FileInputStream in = new FileInputStream(
            "src/test/resources/analyzerbeans-0.34-simple-synonym-catalog.ser");
    SynonymCatalog sc;/*  w  ww . j  av  a2 s. com*/
    try {
        sc = (SynonymCatalog) SerializationUtils.deserialize(in);
    } finally {
        in.close();
    }

    assertEquals("DNK", sc.getMasterTerm("DNK"));
    assertEquals("NLD", sc.getMasterTerm("NLD"));
    assertEquals("DNK", sc.getMasterTerm("Denmark"));
    assertEquals("NLD", sc.getMasterTerm("The netherlands"));
    assertNull(sc.getMasterTerm("Danemark"));
}

---

From source file:org.eobjects.analyzer.result.AnalyzerResultFutureTest.java

public void testSerializationAndDeserialization() throws Exception {
    final NumberResult result1 = new NumberResult(42);

    final AnalyzerResultFuture<NumberResult> future = new AnalyzerResultFuture<>("foo",
            new ImmutableRef<NumberResult>(result1));

    future.addListener(new Listener<NumberResult>() {
        @Override/*from w  ww. java 2  s.  com*/
        public void onSuccess(NumberResult result) {
            // do nothing - this is just a non-serializable listener
        }

        @Override
        public void onError(RuntimeException error) {
            // do nothing - this is just a non-serializable listener
        }
    });

    final byte[] bytes = SerializationUtils.serialize(future);

    final AnalyzerResultFuture<?> copy = (AnalyzerResultFuture<?>) SerializationUtils.deserialize(bytes);

    assertEquals("foo", copy.getName());
    assertEquals("42", copy.get().toString());
}

---

From source file:org.eobjects.analyzer.result.AnnotatedRowResultTest.java

public void testSerializeAndDeserialize() throws Exception {
    RowAnnotationFactory annotationFactory = new InMemoryRowAnnotationFactory();
    RowAnnotation annotation = annotationFactory.createAnnotation();
    InputColumn<String> col1 = new MockInputColumn<String>("foo", String.class);
    InputColumn<String> col2 = new MockInputColumn<String>("bar", String.class);

    annotationFactory.annotate(new MockInputRow().put(col1, "1").put(col2, "2"), 1, annotation);
    annotationFactory.annotate(new MockInputRow().put(col1, "3").put(col2, "4"), 1, annotation);

    AnnotatedRowsResult result1 = new AnnotatedRowsResult(annotation, annotationFactory, col1);
    performAssertions(result1);/*  w  w  w.  j  ava  2  s.  c o m*/

    AnnotatedRowsResult result2 = (AnnotatedRowsResult) SerializationUtils
            .deserialize(SerializationUtils.serialize(result1));
    performAssertions(result2);
}

---

From source file:org.eobjects.analyzer.storage.RowAnnotationImplTest.java

public void testDeserializeOlderVersion() throws Exception {
    InputStream in = new FileInputStream("src/test/resources/old_row_annotation_impl.ser");

    Object obj = SerializationUtils.deserialize(in);
    in.close();//ww  w  .  j av  a 2 s .c  o  m

    assertTrue(obj instanceof RowAnnotationImpl);
    RowAnnotationImpl annotation = (RowAnnotationImpl) obj;
    assertEquals(10, annotation.getRowCount());
}

---

From source file:org.eobjects.analyzer.test.full.scenarios.AnalyzeDateGapsCompareSchemasAndSerializeResultsTest.java

@SuppressWarnings("unchecked")
public void testScenario() throws Throwable {
    final AnalyzerBeansConfiguration configuration;
    {//from   w w  w.  j  a  va  2s  .co  m
        // create configuration
        SimpleDescriptorProvider descriptorProvider = new SimpleDescriptorProvider();
        descriptorProvider.addAnalyzerBeanDescriptor(Descriptors.ofAnalyzer(DateGapAnalyzer.class));
        descriptorProvider.addFilterBeanDescriptor(Descriptors.ofFilter(MaxRowsFilter.class));
        descriptorProvider
                .addTransformerBeanDescriptor(Descriptors.ofTransformer(ConvertToStringTransformer.class));
        Datastore datastore = TestHelper.createSampleDatabaseDatastore("orderdb");
        configuration = new AnalyzerBeansConfigurationImpl().replace(descriptorProvider)
                .replace(new DatastoreCatalogImpl(datastore));
    }

    AnalysisJob job;
    {
        // create job
        AnalysisJobBuilder analysisJobBuilder = new AnalysisJobBuilder(configuration);
        Datastore datastore = configuration.getDatastoreCatalog().getDatastore("orderdb");
        analysisJobBuilder.setDatastore(datastore);
        analysisJobBuilder.addSourceColumns("PUBLIC.ORDERS.ORDERDATE", "PUBLIC.ORDERS.SHIPPEDDATE",
                "PUBLIC.ORDERS.CUSTOMERNUMBER");
        assertEquals(3, analysisJobBuilder.getSourceColumns().size());

        FilterJobBuilder<MaxRowsFilter, MaxRowsFilter.Category> maxRows = analysisJobBuilder
                .addFilter(MaxRowsFilter.class);
        maxRows.getConfigurableBean().setMaxRows(5);
        analysisJobBuilder.setDefaultRequirement(maxRows.getOutcome(MaxRowsFilter.Category.VALID));

        TransformerJobBuilder<ConvertToStringTransformer> convertToNumber = analysisJobBuilder
                .addTransformer(ConvertToStringTransformer.class);
        convertToNumber.addInputColumn(analysisJobBuilder.getSourceColumnByName("customernumber"));
        InputColumn<String> customer_no = (InputColumn<String>) convertToNumber.getOutputColumns().get(0);

        AnalyzerJobBuilder<DateGapAnalyzer> dateGap = analysisJobBuilder.addAnalyzer(DateGapAnalyzer.class);
        dateGap.setName("date gap job");
        dateGap.getConfigurableBean().setSingleDateOverlaps(true);
        dateGap.getConfigurableBean()
                .setFromColumn((InputColumn<Date>) analysisJobBuilder.getSourceColumnByName("orderdate"));
        dateGap.getConfigurableBean()
                .setToColumn((InputColumn<Date>) analysisJobBuilder.getSourceColumnByName("shippeddate"));
        dateGap.getConfigurableBean().setGroupColumn(customer_no);

        job = analysisJobBuilder.toAnalysisJob();
        analysisJobBuilder.close();
    }

    AnalysisResultFuture future = new AnalysisRunnerImpl(configuration).run(job);
    if (future.isErrornous()) {
        throw future.getErrors().get(0);
    }
    assertTrue(future.isSuccessful());

    SimpleAnalysisResult result1 = new SimpleAnalysisResult(future.getResultMap());
    byte[] bytes = SerializationUtils.serialize(result1);
    SimpleAnalysisResult result2 = (SimpleAnalysisResult) SerializationUtils.deserialize(bytes);

    performResultAssertions(job, future);
    performResultAssertions(job, result1);
    performResultAssertions(job, result2);
}

---

From source file:org.eqaula.glue.model.BussinesEntityAttribute.java

public Object getValue() {
    return SerializationUtils.deserialize(getValueByteArray());
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• »