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

List of usage examples for org.apache.commons.lang SerializationUtils serialize

Introduction

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

Prototype

public static byte[] serialize(Serializable obj) 

Source Link

Document

Serializes an Object to a byte array for storage/serialization.

Usage

From source file:org.apache.ojb.broker.metadata.PersistentFieldTest.java

private void runFieldTestsFor(Class targetClass, boolean supportJavaBeanNames) throws Exception {
    ((OjbConfiguration) OjbConfigurator.getInstance().getConfigurationFor(null))
            .setPersistentFieldClass(targetClass);

    PersistentField pfNM_Name = newInstance(targetClass, NestedMain.class, NESTED_MAIN_NAME);
    PersistentField pfNDD_RD = newInstance(targetClass, NestedMain.class, NESTED_DETAIL_DETAIL_REAL_DETAIL);
    PersistentField pfNDD_RDD = newInstance(targetClass, NestedMain.class,
            NESTED_DETAIL_DETAIL_REAL_DESCRIPTION);
    PersistentField pfND_MJB = null;/*from  ww  w .j  a  v  a2 s.  c om*/
    PersistentField pfNE_Name = null;
    if (supportJavaBeanNames) {
        pfND_MJB = newInstance(targetClass, NestedMain.class, NESTED_DETAIL_MORE_JAVA_BEAN);
        pfNE_Name = newInstance(targetClass, NestedMain.class, NESTED_ENTRY_NAME);
    }

    // test getter
    NestedMain nm = createNestedObject();
    Object result = pfNM_Name.get(nm);
    assertEquals(NESTED_MAIN_NAME_VALUE, result);
    result = pfNDD_RD.get(nm);
    assertEquals(NESTED_DETAIL_DETAIL_REAL_DETAIL_VALUE, result);
    result = pfNDD_RDD.get(nm);
    assertEquals(NESTED_DETAIL_DETAIL_REAL_DESCRIPTION_VALUE, result);

    if (supportJavaBeanNames) {
        result = pfND_MJB.get(nm);
        assertEquals(NESTED_DETAIL_MORE_JAVA_BEAN_VALUE, result);
        result = pfNE_Name.get(nm);
        assertEquals(NESTED_ENTRY_NAME_VALUE, result);
    }

    NestedMain newNM = new NestedMain();
    // test setter
    pfNM_Name.set(newNM, NESTED_MAIN_NAME_VALUE);
    pfNDD_RD.set(newNM, NESTED_DETAIL_DETAIL_REAL_DETAIL_VALUE);
    result = pfNDD_RDD.get(newNM);
    assertEquals(NESTED_DETAIL_DETAIL_REAL_DESCRIPTION_VALUE, result);

    result = pfNM_Name.get(newNM);
    assertEquals(NESTED_MAIN_NAME_VALUE, result);
    result = pfNDD_RD.get(newNM);
    assertEquals(NESTED_DETAIL_DETAIL_REAL_DETAIL_VALUE, result);

    if (supportJavaBeanNames) {
        pfND_MJB.set(newNM, NESTED_DETAIL_MORE_JAVA_BEAN_VALUE);
        pfNE_Name.set(newNM, NESTED_ENTRY_NAME_VALUE);
        result = pfND_MJB.get(newNM);
        assertEquals(NESTED_DETAIL_MORE_JAVA_BEAN_VALUE, result);
        result = pfNE_Name.get(newNM);
        assertEquals(NESTED_ENTRY_NAME_VALUE, result);
    }

    // serialize fields and test again
    pfNM_Name = (PersistentField) SerializationUtils.deserialize(SerializationUtils.serialize(pfNM_Name));
    pfNDD_RD = (PersistentField) SerializationUtils.deserialize(SerializationUtils.serialize(pfNDD_RD));
    pfNDD_RDD = (PersistentField) SerializationUtils.deserialize(SerializationUtils.serialize(pfNDD_RDD));
    if (supportJavaBeanNames) {
        pfND_MJB = (PersistentField) SerializationUtils.deserialize(SerializationUtils.serialize(pfND_MJB));
        pfNE_Name = (PersistentField) SerializationUtils.deserialize(SerializationUtils.serialize(pfNE_Name));
    }

    // test getter
    nm = createNestedObject();
    result = pfNM_Name.get(nm);
    assertEquals(NESTED_MAIN_NAME_VALUE, result);
    result = pfNDD_RD.get(nm);
    assertEquals(NESTED_DETAIL_DETAIL_REAL_DETAIL_VALUE, result);
    result = pfNDD_RDD.get(nm);
    assertEquals(NESTED_DETAIL_DETAIL_REAL_DESCRIPTION_VALUE, result);

    if (supportJavaBeanNames) {
        result = pfND_MJB.get(nm);
        assertEquals(NESTED_DETAIL_MORE_JAVA_BEAN_VALUE, result);
        result = pfNE_Name.get(nm);
        assertEquals(NESTED_ENTRY_NAME_VALUE, result);
    }

    newNM = new NestedMain();
    // test setter
    pfNM_Name.set(newNM, NESTED_MAIN_NAME_VALUE);
    pfNDD_RD.set(newNM, NESTED_DETAIL_DETAIL_REAL_DETAIL_VALUE);
    result = pfNDD_RDD.get(newNM);
    assertEquals(NESTED_DETAIL_DETAIL_REAL_DESCRIPTION_VALUE, result);

    result = pfNM_Name.get(newNM);
    assertEquals(NESTED_MAIN_NAME_VALUE, result);
    result = pfNDD_RD.get(newNM);
    assertEquals(NESTED_DETAIL_DETAIL_REAL_DETAIL_VALUE, result);

    if (supportJavaBeanNames) {
        pfND_MJB.set(newNM, NESTED_DETAIL_MORE_JAVA_BEAN_VALUE);
        pfNE_Name.set(newNM, NESTED_ENTRY_NAME_VALUE);
        result = pfND_MJB.get(newNM);
        assertEquals(NESTED_DETAIL_MORE_JAVA_BEAN_VALUE, result);
        result = pfNE_Name.get(newNM);
        assertEquals(NESTED_ENTRY_NAME_VALUE, result);
    }
}

From source file:org.apache.ojb.odmg.ImplementationImpl.java

/**
 * Get a <code>String</code> representation of the object's identifier.
 * OJB returns the serialized Identity of the object.
 * @param obj The object whose identifier is being accessed.
 * @return The object's identifier in the form of a String
 *///from ww w.  j  a v a  2s.co m
public String getObjectId(Object obj) {
    Identity oid = null;
    PersistenceBroker broker = null;

    try {
        if (getCurrentDatabase() != null) {
            /**
             * is there an open database we are calling getObjectId against? if yes, use it
             */
            broker = PersistenceBrokerFactory.createPersistenceBroker(getCurrentDatabase().getPBKey());
        } else {
            log.warn("Can't find open database, try to use the default configuration");
            /**
             * otherwise, use default.
             */
            broker = PersistenceBrokerFactory.defaultPersistenceBroker();
        }

        oid = broker.serviceIdentity().buildIdentity(obj);
    } finally {
        if (broker != null) {
            broker.close();
        }
    }
    return new String(SerializationUtils.serialize(oid));
}

From source file:org.apache.oodt.cas.resource.util.MesosUtilities.java

/**
 * Get a ByteString serialization of a JobSpec to send over the wire to the mesos-backend.
 * @param jobSpec - JobSpec to serialize
 * @return bytestring containing byte[] of jobspec
 *///from w w  w . ja v  a  2  s .c o m
public static ByteString jobSpecToByteString(JobSpec jobSpec) {
    return ByteString.copyFrom(SerializationUtils.serialize(new JobSpecSerializer(jobSpec)));
}

From source file:org.apache.reef.runtime.common.utils.DefaultExceptionCodec.java

@Override
public byte[] toBytes(final Throwable throwable) {
    return SerializationUtils.serialize(throwable);
}

From source file:org.apache.reef.vortex.common.VortexAvroUtils.java

/**
 * Serialize VortexRequest to byte array.
 * @param vortexRequest Vortex request message to serialize.
 * @return Serialized byte array./*from   ww w.  ja v a  2s  . c om*/
 */
public byte[] toBytes(final VortexRequest vortexRequest) {
    // Convert VortexRequest message to Avro message.
    final AvroVortexRequest avroVortexRequest;
    switch (vortexRequest.getType()) {
    case ExecuteAggregateTasklet:
        final TaskletAggregateExecutionRequest taskletAggregateExecutionRequest = (TaskletAggregateExecutionRequest) vortexRequest;
        // TODO[REEF-1113]: Handle serialization failure separately in Vortex
        final byte[] serializedInputForAggregate = aggregateFunctionRepository
                .getFunction(taskletAggregateExecutionRequest.getAggregateFunctionId()).getInputCodec()
                .encode(taskletAggregateExecutionRequest.getInput());
        avroVortexRequest = AvroVortexRequest.newBuilder().setRequestType(AvroRequestType.AggregateExecute)
                .setTaskletRequest(AvroTaskletAggregateExecutionRequest.newBuilder()
                        .setAggregateFunctionId(taskletAggregateExecutionRequest.getAggregateFunctionId())
                        .setSerializedInput(ByteBuffer.wrap(serializedInputForAggregate))
                        .setTaskletId(taskletAggregateExecutionRequest.getTaskletId()).build())
                .build();
        break;
    case AggregateTasklets:
        final TaskletAggregationRequest taskletAggregationRequest = (TaskletAggregationRequest) vortexRequest;

        // TODO[REEF-1003]: Use reflection instead of serialization when launching VortexFunction
        final byte[] serializedAggregateFunction = SerializationUtils
                .serialize(taskletAggregationRequest.getAggregateFunction());
        final byte[] serializedFunctionForAggregation = SerializationUtils
                .serialize(taskletAggregationRequest.getFunction());
        final byte[] serializedPolicy = SerializationUtils.serialize(taskletAggregationRequest.getPolicy());
        avroVortexRequest = AvroVortexRequest.newBuilder().setRequestType(AvroRequestType.Aggregate)
                .setTaskletRequest(AvroTaskletAggregationRequest.newBuilder()
                        .setAggregateFunctionId(taskletAggregationRequest.getAggregateFunctionId())
                        .setSerializedAggregateFunction(ByteBuffer.wrap(serializedAggregateFunction))
                        .setSerializedUserFunction(ByteBuffer.wrap(serializedFunctionForAggregation))
                        .setSerializedPolicy(ByteBuffer.wrap(serializedPolicy)).build())
                .build();
        break;
    case ExecuteTasklet:
        final TaskletExecutionRequest taskletExecutionRequest = (TaskletExecutionRequest) vortexRequest;
        // The following TODOs are sub-issues of cleaning up Serializable in Vortex (REEF-504).
        // The purpose is to reduce serialization cost, which leads to bottleneck in Master.
        // Temporarily those are left as TODOs, but will be addressed in separate PRs.
        final VortexFunction vortexFunction = taskletExecutionRequest.getFunction();
        // TODO[REEF-1113]: Handle serialization failure separately in Vortex
        final byte[] serializedInput = vortexFunction.getInputCodec()
                .encode(taskletExecutionRequest.getInput());
        // TODO[REEF-1003]: Use reflection instead of serialization when launching VortexFunction
        final byte[] serializedFunction = SerializationUtils.serialize(vortexFunction);
        avroVortexRequest = AvroVortexRequest.newBuilder().setRequestType(AvroRequestType.ExecuteTasklet)
                .setTaskletRequest(AvroTaskletExecutionRequest.newBuilder()
                        .setTaskletId(taskletExecutionRequest.getTaskletId())
                        .setSerializedInput(ByteBuffer.wrap(serializedInput))
                        .setSerializedUserFunction(ByteBuffer.wrap(serializedFunction)).build())
                .build();
        break;
    case CancelTasklet:
        final TaskletCancellationRequest taskletCancellationRequest = (TaskletCancellationRequest) vortexRequest;
        avroVortexRequest = AvroVortexRequest.newBuilder().setRequestType(AvroRequestType.CancelTasklet)
                .setTaskletRequest(AvroTaskletCancellationRequest.newBuilder()
                        .setTaskletId(taskletCancellationRequest.getTaskletId()).build())
                .build();
        break;
    default:
        throw new RuntimeException("Undefined message type");
    }

    // Serialize the Avro message to byte array.
    return toBytes(avroVortexRequest, AvroVortexRequest.class);
}

From source file:org.apache.reef.vortex.common.VortexAvroUtils.java

/**
 * Serialize WorkerReport to byte array.
 * @param workerReport Worker report message to serialize.
 * @return Serialized byte array.//from w  w w  .  j  a  va2 s  .co  m
 */
public byte[] toBytes(final WorkerReport workerReport) {
    final List<AvroTaskletReport> workerTaskletReports = new ArrayList<>();

    for (final TaskletReport taskletReport : workerReport.getTaskletReports()) {
        final AvroTaskletReport avroTaskletReport;
        switch (taskletReport.getType()) {
        case TaskletResult:
            final TaskletResultReport taskletResultReport = (TaskletResultReport) taskletReport;
            avroTaskletReport = AvroTaskletReport.newBuilder().setReportType(AvroReportType.TaskletResult)
                    .setTaskletReport(AvroTaskletResultReport.newBuilder()
                            .setTaskletId(taskletResultReport.getTaskletId())
                            .setSerializedOutput(ByteBuffer.wrap(taskletResultReport.getSerializedResult()))
                            .build())
                    .build();
            break;
        case TaskletAggregationResult:
            final TaskletAggregationResultReport taskletAggregationResultReport = (TaskletAggregationResultReport) taskletReport;
            avroTaskletReport = AvroTaskletReport.newBuilder()
                    .setReportType(AvroReportType.TaskletAggregationResult)
                    .setTaskletReport(AvroTaskletAggregationResultReport.newBuilder()
                            .setTaskletIds(taskletAggregationResultReport.getTaskletIds())
                            .setSerializedOutput(
                                    ByteBuffer.wrap(taskletAggregationResultReport.getSerializedResult()))
                            .build())
                    .build();
            break;
        case TaskletCancelled:
            final TaskletCancelledReport taskletCancelledReport = (TaskletCancelledReport) taskletReport;
            avroTaskletReport = AvroTaskletReport.newBuilder().setReportType(AvroReportType.TaskletCancelled)
                    .setTaskletReport(AvroTaskletCancelledReport.newBuilder()
                            .setTaskletId(taskletCancelledReport.getTaskletId()).build())
                    .build();
            break;
        case TaskletFailure:
            final TaskletFailureReport taskletFailureReport = (TaskletFailureReport) taskletReport;
            final byte[] serializedException = SerializationUtils
                    .serialize(taskletFailureReport.getException());
            avroTaskletReport = AvroTaskletReport.newBuilder().setReportType(AvroReportType.TaskletFailure)
                    .setTaskletReport(AvroTaskletFailureReport.newBuilder()
                            .setTaskletId(taskletFailureReport.getTaskletId())
                            .setSerializedException(ByteBuffer.wrap(serializedException)).build())
                    .build();
            break;
        case TaskletAggregationFailure:
            final TaskletAggregationFailureReport taskletAggregationFailureReport = (TaskletAggregationFailureReport) taskletReport;
            final byte[] serializedAggregationException = SerializationUtils
                    .serialize(taskletAggregationFailureReport.getException());
            avroTaskletReport = AvroTaskletReport.newBuilder()
                    .setReportType(AvroReportType.TaskletAggregationFailure)
                    .setTaskletReport(AvroTaskletAggregationFailureReport.newBuilder()
                            .setTaskletIds(taskletAggregationFailureReport.getTaskletIds())
                            .setSerializedException(ByteBuffer.wrap(serializedAggregationException)).build())
                    .build();
            break;
        default:
            throw new RuntimeException("Undefined message type");
        }

        workerTaskletReports.add(avroTaskletReport);
    }

    // Convert WorkerReport message to Avro message.
    final AvroWorkerReport avroWorkerReport = AvroWorkerReport.newBuilder()
            .setTaskletReports(workerTaskletReports).build();

    // Serialize the Avro message to byte array.
    return toBytes(avroWorkerReport, AvroWorkerReport.class);
}

From source file:org.apache.reef.vortex.driver.VortexRequestor.java

void send(final RunningTask reefTask, final VortexRequest vortexRequest) {
    executorService.execute(new Runnable() {
        @Override// ww  w  .ja  v  a2 s  .c  o m
        public void run() {
            //  Possible race condition with VortexWorkerManager#terminate is addressed by the global lock in VortexMaster
            reefTask.send(SerializationUtils.serialize(vortexRequest));
        }
    });
}

From source file:org.apache.reef.vortex.evaluator.VortexWorker.java

/**
 * Starts the scheduler & executor and waits until termination.
 *///w  w w  .  java2s.  c  om
@Override
public byte[] call(final byte[] memento) throws Exception {
    final ExecutorService schedulerThread = Executors.newSingleThreadExecutor();
    final ExecutorService commandExecutor = Executors.newFixedThreadPool(numOfThreads);

    // Scheduling thread starts
    schedulerThread.execute(new Runnable() {
        @Override
        public void run() {
            while (true) {
                // Scheduler Thread: Pick a command to execute (For now, simple FIFO order)
                final byte[] message;
                try {
                    message = pendingRequests.takeFirst();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                // Scheduler Thread: Pass the command to the worker thread pool to be executed
                commandExecutor.execute(new Runnable() {
                    @Override
                    public void run() {
                        // Command Executor: Deserialize the command
                        final VortexRequest vortexRequest = (VortexRequest) SerializationUtils
                                .deserialize(message);
                        switch (vortexRequest.getType()) {
                        case ExecuteTasklet:
                            final TaskletExecutionRequest taskletExecutionRequest = (TaskletExecutionRequest) vortexRequest;
                            try {
                                // Command Executor: Execute the command
                                final Serializable result = taskletExecutionRequest.execute();

                                // Command Executor: Tasklet successfully returns result
                                final WorkerReport report = new TaskletResultReport<>(
                                        taskletExecutionRequest.getTaskletId(), result);
                                workerReports.addLast(SerializationUtils.serialize(report));
                            } catch (Exception e) {
                                // Command Executor: Tasklet throws an exception
                                final WorkerReport report = new TaskletFailureReport(
                                        taskletExecutionRequest.getTaskletId(), e);
                                workerReports.addLast(SerializationUtils.serialize(report));
                            }

                            heartBeatTriggerManager.triggerHeartBeat();
                            break;
                        default:
                            throw new RuntimeException("Unknown Command");
                        }
                    }
                });

            }
        }
    });

    terminated.await();
    return null;
}

From source file:org.araneaframework.framework.filter.StandardSerializingAuditFilterService.java

protected void action(Path path, InputData input, OutputData output) throws Exception {
    child._getRelocatable().overrideEnvironment(getEnvironment());
    child._getService().action(path, input, output);
    child._getRelocatable().overrideEnvironment(null);

    HttpSession sess = (HttpSession) getEnvironment().getEntry(HttpSession.class);

    byte[] serialized = SerializationUtils.serialize(child);
    log.debug("Serialized session size: " + serialized.length);

    if (testXmlSessionPath != null) {
        String dumpPath = testXmlSessionPath + "/" + sess.getId() + ".xml";
        log.debug("Dumping session XML to '" + dumpPath + "'");

        XStream xstream = new XStream(new DomDriver());
        PrintWriter writer = new PrintWriter(new FileWriter(dumpPath));
        xstream.toXML(child, writer);/*w w w . j  a  va2  s . c  om*/
        writer.close();
    }
}

From source file:org.archive.modules.recrawl.PersistLogProcessor.java

@Override
protected void innerProcess(CrawlURI curi) {
    log.writeLine(persistKeyFor(curi), " ", new String(
            Base64.encodeBase64(SerializationUtils.serialize((Serializable) curi.getPersistentDataMap()))));
}