Java 类org.springframework.util.SerializationUtils 实例源码

public void execute(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
    response.setCharacterEncoding("UTF-8");
    response.setContentType("text/xml;charset=utf8");
    PrintWriter pw = response.getWriter();
    String beanId = (String) request.getParameter("beanId");
    String methodName = (String) request.getParameter("methodName");
    String parameter = (String) request.getParameter("parameter");
    if (StringUtils.isNotEmpty(beanId) && StringUtils.isNotEmpty(methodName)) {
        try {
            Object object = DoradoContext.getAttachedWebApplicationContext().getBean(beanId);
            Object[] arguments = null;
            if (StringUtils.isNotEmpty(parameter)) {
                arguments = (Object[]) SerializationUtils.deserialize(new Base64(true).decode(parameter));
            }
            MethodUtils.invokeMethod(object, methodName, arguments);
            log.info("invoke refreshCache method [" + beanId + "#" + methodName + "] success");
            pw.print("ok");
        } catch (Exception e) {
            log.error("invoke refreshCache method [" + beanId + "#" + methodName + "] error," + e.getMessage());
            pw.print("error");
        }
    }
}

/** {@inheritDoc} */
@Override
public Order purchase(String email, Cart cart, String signature) {
    if (cart.isEmpty()) {
        throw new EmptyCartOrderException("Shopping basket is empty");
    }
    if (!Objects.equals(calcSignature(cart), signature)) {
        throw new InvalidCartOrderException("It has changed the state of the shopping basket");
    }

    // In order to be removed from the shopping basket , keep deep copy
    OrderLines orderLines = (OrderLines) SerializationUtils
            .deserialize(SerializationUtils.serialize(cart.getOrderLines()));

    Order order = Order.builder().email(email).orderDate(LocalDate.now()).orderLines(orderLines).build();
    Order ordered = orderRepository.save(createFullOrder(order));
    cart.clear();
    return ordered;
}

@Override
public V get(K key) throws CacheException {
    if (key == null) {
        return null;
    }
    if (key instanceof String) {
        String k = (String) key;

        if (useKeyProfix) {
            k = keyProfix + k;
        }
        return (V) SerializationUtils.deserialize(jRedisClient.get(k.getBytes()));
    }

    return null;
}

@Override
public V put(K key, V value) throws CacheException {

    if (key == null || value == null) {
        return null;
    }

    if (key instanceof String) {
        String k = (String) key;
        if (useKeyProfix) {
            k = keyProfix + k;
        }
        byte[] v = SerializationUtils.serialize(value);
        jRedisClient.set(k.getBytes(), v);

        return value;
    }

    return null;
}

public void saveSession(Session session) {
    if (session == null || session.getId() == null) {
        logger.error("session or session id is null");
        return;
    }
    session.setTimeout(expire);
    long timeout = expire / 1000;
    //保存用户会话
    redisDao.add(this.getKey(RedisConstant.SHIRO_REDIS_SESSION_PRE, session.getId().toString()), timeout, SerializationUtils.serialize(session));
    //获取用户id
    String uid = getUserId(session);
    if (!StrUtil.isEmpty(uid)) {
        //保存用户会话对应的UID
        try {
            redisDao.add(this.getKey(RedisConstant.SHIRO_SESSION_PRE, session.getId().toString()), timeout, uid.getBytes("UTF-8"));
            //保存在线UID
            redisDao.add(this.getKey(RedisConstant.UID_PRE, uid), timeout, "online".getBytes("UTF-8"));
        } catch (UnsupportedEncodingException ex) {
            logger.error("getBytes error:" + ex.getMessage());
        }
    }

}

@Override
public V get(K key) throws CacheException {
    logger.debug("根据key从Redis中获取对象 key [" + key + "]");
    try {
        if (key == null) {
            return null;
        } else {
            byte[] rawValue = redisDao.getByte(key.toString());
            @SuppressWarnings("unchecked")
            V value = (V) SerializationUtils.deserialize(rawValue);
            return value;
        }
    } catch (Throwable t) {
        throw new CacheException(t);
    }

}

@Test
public void testTransient() throws InterruptedException {
    DependentComponent dc = new DependentComponent();
    Assert.assertEquals(42, dc.answer());

    // serialize and deserialize
    final byte[] ba = SerializationUtils.serialize(dc);
    Thread es = new Thread(() -> {
        try {
            DependentComponent dc_ = (DependentComponent) SerializationUtils.deserialize(ba);
            Assert.assertEquals(42, dc_.answer());
        } catch (Exception e) {
            exc = e;
        }
    });

    es.start();
    es.join();

    if (exc != null) {
        fail(exc.getMessage());
    }
}

@Test
public void testBuildQuerySloResponse() throws Exception {
    final QuerySloResponse query = this.idpConnector.buildQuerySloResponse(this.sloRequestId);

    Assert.assertNotNull("Query cannot be null !", query);
    Assert.assertNotNull("QuerySloResponse's Id !", query.getId());
    Assert.assertEquals("QuerySloResponse's InResponseTo Id !", this.sloRequestId, query.getInResponseToId());

    // Test Serialization
    final byte[] serialized = SerializationUtils.serialize(query);
    final QuerySloResponse deserializedQuery = (QuerySloResponse) SerializationUtils.deserialize(serialized);

    Assert.assertEquals("Serialization / Deserialization problem !", query.getId(), deserializedQuery.getId());
    Assert.assertEquals("Serialization / Deserialization problem !", query.getInResponseToId(),
            deserializedQuery.getInResponseToId());
}

@Test
public void testBuildQuerySloRequest() throws Exception {
    final QuerySloRequest query = this.idpConnector.buildQuerySloRequest();

    Assert.assertNotNull("Query cannot be null !", query);
    Assert.assertNotNull("QuerySloResponse's Id !", query.getId());
    Assert.assertNotNull("QueryAuthnRequest's IdPConnectorBuilder cannot be null !", query.getIdpConnectorBuilder());

    // Test Serialization
    final byte[] serialized = SerializationUtils.serialize(query);
    final QuerySloRequest deserializedQuery = (QuerySloRequest) SerializationUtils.deserialize(serialized);

    Assert.assertEquals("Serialization / Deserialization problem !", query.getId(), deserializedQuery.getId());
    Assert.assertNotNull("Serialization / Deserialization problem !", deserializedQuery.getIdpConnectorBuilder());
    Assert.assertEquals("Serialization / Deserialization problem !", query.getIdpConnectorBuilder(),
            deserializedQuery.getIdpConnectorBuilder());
}

public void init(Context context){
    SimpleDateFormat sd=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
    Session session=context.getSession();
    if(type.equals(VariableType.Blob) || type.equals(VariableType.Text)){
        HistoryBlob blob=(HistoryBlob)session.get(HistoryBlob.class,Long.valueOf(stringValue));
        variableObject=SerializationUtils.deserialize(blob.getBlobValue());
    }else if(type.equals(VariableType.String)){
        variableObject=stringValue;
    }else if(type.equals(VariableType.Date)){
        try {
            variableObject=sd.parse(stringValue);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }else if(type.equals(VariableType.Integer)){
        variableObject=Integer.valueOf(stringValue);
    }else if(type.equals(VariableType.Character)){
        variableObject=Character.valueOf((char)(stringValue.getBytes()[0]));
    }else if(type.equals(VariableType.Double)){
        variableObject=Double.valueOf(stringValue);
    }else if(type.equals(VariableType.Float)){
        variableObject=Float.valueOf(stringValue);
    }else if(type.equals(VariableType.Long)){
        variableObject=Long.valueOf(stringValue);
    }else if(type.equals(VariableType.Byte)){
        variableObject=Byte.valueOf(stringValue);
    }else if(type.equals(VariableType.Short)){
        variableObject=Short.valueOf(stringValue);
    }else if(type.equals(VariableType.Boolean)){
        variableObject=Boolean.valueOf(stringValue);
    }
}

@SuppressWarnings("unchecked")
private static <T extends Throwable> T cloneException(T exception) {
    try {
        return (T) SerializationUtils.deserialize(SerializationUtils.serialize(exception));
    }
    catch (Exception ex) {
        return null;  // exception parameter cannot be cloned
    }
}

/** {@inheritDoc} */
@Override
public Object calcSignature(Cart cart) {
    byte[] serialized = SerializationUtils.serialize(cart.getOrderLines());
    byte[] signature = null;
    try {
        MessageDigest messageDigest = MessageDigest.getInstance("MD5");
        signature = messageDigest.digest(serialized);
    } catch (NoSuchAlgorithmException ignored) {
    }
    return Base64.getEncoder().encodeToString(signature);
}

private void saveSession(Session session) {
    LOGGER.info("saveSession for " + session);
    if (session == null || session.getId() == null) {
        return;
    }

    String key = keyPrefix + session.getId();
    byte[] value = SerializationUtils.serialize(session);
    session.setTimeout(sessionExpireTime * 1000);
    jRedisClient.set(key.getBytes(), value, sessionExpireTime);
}

@Override
protected Session doReadSession(Serializable sessionId) {
    if (sessionId == null) {
        return null;
    }

    String key = keyPrefix + sessionId;
    Session session = (Session) SerializationUtils.deserialize(jRedisClient.get(key.getBytes()));

    return session;
}

@Override
protected Session doReadSession(Serializable sessionId) {
    if (sessionId == null) {
        logger.error("session id is null");
        return null;
    }

    logger.debug("Read Redis.SessionId=" + new String(getKey(RedisConstant.SHIRO_REDIS_SESSION_PRE, sessionId.toString())));

    Session session = (Session) SerializationUtils.deserialize(redisDao.getByte(getKey(RedisConstant.SHIRO_REDIS_SESSION_PRE, sessionId.toString())));
    return session;
}

@Override
public Collection<Session> getActiveSessions() {
    Set<Session> sessions = new HashSet<>();

    Set<String> keys = redisDao.keys(RedisConstant.SHIRO_REDIS_SESSION_PRE + "*");
    if (keys != null && keys.size() > 0) {
        for (String key : keys) {
            Session s = (Session) SerializationUtils.deserialize(redisDao.getByte(key));
            sessions.add(s);
        }
    }
    return sessions;
}

/**
 * 获得byte[]型的key
 *
 * @param key
 * @return
 */
private byte[] getByteKey(K key) {
    if (key instanceof String) {
        String preKey = this.keyPrefix + key;
        return preKey.getBytes();
    } else {
        return SerializationUtils.serialize(key);
    }
}

@Override
public V put(K key, V value) throws CacheException {
    logger.debug("根据key从存储 key [" + key + "]");
    try {
        redisDao.set(key.toString(), SerializationUtils.serialize(value));
        return value;
    } catch (Throwable t) {
        throw new CacheException(t);
    }
}

@Test
public void foo() throws Exception {
    processor.input().send(MessageBuilder
            .withPayload(SerializationUtils.serialize(new Foo("foo")))
            .setHeader("contentType", MessageConverterUtils.X_JAVA_SERIALIZED_OBJECT)
            .build());
    Message<?> result = messageCollector.forChannel(processor.output()).poll(1000,
            TimeUnit.MILLISECONDS);
    assertThat(result.getPayload()).isInstanceOf(Foo.class);
}

@Test
public void bar() throws Exception {
    processor.input().send(MessageBuilder
            .withPayload(SerializationUtils.serialize(new Bar("foo")))
            .setHeader("contentType", MessageConverterUtils.X_JAVA_SERIALIZED_OBJECT)
            .build());
    Message<?> result = messageCollector.forChannel(processor.output()).poll(1000,
            TimeUnit.MILLISECONDS);
    assertThat(result.getPayload()).isInstanceOf(Bar.class);
}

@Test
public void skip() throws Exception {
    processor.input().send(MessageBuilder
            .withPayload(SerializationUtils.serialize(new Spam("foo")))
            .setHeader("contentType", MessageConverterUtils.X_JAVA_SERIALIZED_OBJECT)
            .build());
    Message<?> result = messageCollector.forChannel(processor.output()).poll(100,
            TimeUnit.MILLISECONDS);
    assertThat(result).isNull();
}

@Override
public void execute(Ticket ticket, CommandResultHandler resultHandler, CommandClusterInteraction clusterInteraction)
    throws RuntimeException {
  if (ticket == null)
    throw new RuntimeException("Not logged in.");

  UiAnalysis originalAnalysis = uiDbProvider.getDb().loadAnalysisVersion(analysisId, analysisVersion);

  if (originalAnalysis == null)
    throw new RuntimeException("Analysis unknown: " + analysisId + " version " + analysisVersion);

  byte[] serialized = SerializationUtils.serialize(originalAnalysis);
  UiAnalysis newAnalysis = (UiAnalysis) SerializationUtils.deserialize(serialized);

  newAnalysis.setId(UUID.randomUUID().toString());
  newAnalysis.setUser(ticket.getClaim().getUsername());
  newAnalysis.setVersion(0L);
  newAnalysis.setName(originalAnalysis.getName() + " [cloned]");

  try {
    uiDbProvider.getDb().storeAnalysisVersion(newAnalysis);
  } catch (StoreException e1) {
    logger.error("Could not store new analysis", e1);
    throw new RuntimeException("Could not store new analysis.", e1);
  }

  resultHandler.sendData(new AnalysisJsonResult(newAnalysis));
}

@Override
protected Runnable adjustAnalysis(UiAnalysis analysis, CommandResultHandler resultHandler) {
  UiQube qube = analysis.getQube(qubeId);
  if (qube == null)
    throw new RuntimeException("Unknown qube: " + qubeId);

  UiQuery query = qube.getQuery(newQuery.getId());
  if (query == null)
    throw new RuntimeException("Unknwon query: " + newQuery.getId());

  if (newQuery.getName() == null || "".equals(newQuery.getName()))
    throw new RuntimeException("Name empty.");

  // validate query!
  try {
    UiQuery queryClone = (UiQuery) SerializationUtils.deserialize(SerializationUtils.serialize(query));
    queryClone.setDiql(newQuery.getDiql());
    queryClone.setName(newQuery.getName());
    queryClone.setDisplayType(newQuery.getDisplayType());

    new QueryBuilder().withAnalysis(analysis).withQuery(queryClone).withSlice(analysis.getSlice(qube.getSliceId()))
        .build();
  } catch (QueryBuilderException e) {
    throw new RuntimeException(e.getMessage());
  }

  query.setDiql(newQuery.getDiql());
  query.setName(newQuery.getName());
  query.setDisplayType(newQuery.getDisplayType());

  return () -> resultHandler.sendData(new QueryJsonResult(query,
      // Analysis version is updated by the time this Runnable is called.
      analysis.getVersion()));
}

@Override
public Map<String, Object> getSessionAttributes(String sessionid) {
    String key = String.format(SESSION_ATTRIBUTE_KEY, sessionid);
    Map<byte[], byte[]> attributes = jedis.hgetAll(key.getBytes());
    if(!attributes.isEmpty()){
        Map<String, Object> result = new HashMap<String, Object>();
        for (Iterator<Map.Entry<byte[], byte[]>> iterator = attributes.entrySet().iterator(); iterator.hasNext();){
            Map.Entry<byte[], byte[]> entry = iterator.next();
            result.put(new String(entry.getKey()), SerializationUtils.deserialize(entry.getValue()));
        }
        return result;
    }
    return Collections.EMPTY_MAP;
}

public boolean serialize(){ 
        try {                       
            byte[] bytes = SerializationUtils.serialize(this);
            FileCopyUtils.copy(bytes, backupSerializationFile);
            FileCopyUtils.copy(bytes, serializationFile);

        } catch (IOException e) {
            e.printStackTrace();
        }   
        return true;

}

private DiskJobSerializer getSerializedJobInstance(File serializationFile) {
    DiskJobSerializer jobInstance = null;
    try {
        byte[] bytes = FileCopyUtils.copyToByteArray(serializationFile);
        jobInstance = (DiskJobSerializer) SerializationUtils.deserialize(bytes);
    } catch (Exception e) {
        logger.error(e.getMessage(), e);
    }
    return jobInstance;
}

/**
 * Method to get the events.
 * @return
 */
@Transient
public Event getEvent() {
    if (getEventBytes() == null) {
        return null;
    }
    return (Event) SerializationUtils.deserialize(getEventBytes());
}

/**
 * Method to get data as Linked Hash Map.
 * 
 * @return {@link ClusterConf}
 */
@Transient
public ClusterConfig getData() {
    if (getDataBytes() == null) {
        return null;
    }
    try {
        return (ClusterConfig) SerializationUtils.deserialize(getDataBytes());
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

/**
 * Method to set the ClusterConf as bytes in db.
 * 
 */
public void setData(ClusterConfig data) {
    if (data != null) {
        data.setState(Constant.Cluster.State.ERROR);
        setDataBytes(SerializationUtils.serialize(data));
    }
}

@Test
public void testSerialization() {
    AuthorizationRequest authorizationRequest = createFromParameters(parameters);
    AuthorizationRequest other = (AuthorizationRequest) SerializationUtils.deserialize(SerializationUtils
            .serialize(authorizationRequest));
    assertEquals(authorizationRequest, other);
}

@Test
public void testSerialization() {
    OAuth2Authentication holder = new OAuth2Authentication(
            new AuthorizationRequest("client", Arrays.asList("read")).createOAuth2Request(), 
            new UsernamePasswordAuthenticationToken("user", "pwd"));
    OAuth2Authentication other = (OAuth2Authentication) SerializationUtils.deserialize(SerializationUtils
            .serialize(holder));
    assertEquals(holder, other);
}

@Test
public void testBuildQueryAuthnRequest() throws Exception {
    final Map<String, String[]> parametersMap = new HashMap<String, String[]>();
    final String[] paramMapValue = new String[]{"value42"};
    parametersMap.put("key42", paramMapValue);

    final QueryAuthnRequest query = this.idpConnector.buildQueryAuthnRequest(parametersMap);

    Assert.assertNotNull("Query cannot be null !", query);
    Assert.assertNotNull("QueryAuthnRequest's parameters map cannot be null !", query.getParametersMap());
    Assert.assertArrayEquals("Bad param values in QueryAuthnRequest !", paramMapValue, query.getParametersMap()
            .get("key42"));

    Assert.assertNotNull("QueryAuthnRequest's Id cannot be null !", query.getId());
    Assert.assertNotNull("QueryAuthnRequest's IdPConnectorBuilder cannot be null !", query.getIdpConnectorBuilder());

    // Test Serialization
    final byte[] serialized = SerializationUtils.serialize(query);
    final QueryAuthnRequest deserializedQuery = (QueryAuthnRequest) SerializationUtils.deserialize(serialized);

    Assert.assertEquals("Serialization / Deserialization problem !", query.getId(), deserializedQuery.getId());
    Assert.assertNotNull("Serialization / Deserialization problem !", deserializedQuery.getIdpConnectorBuilder());
    Assert.assertEquals("Serialization / Deserialization problem !", query.getIdpConnectorBuilder(),
            deserializedQuery.getIdpConnectorBuilder());
    Assert.assertArrayEquals("Serialization / Deserialization problem !", paramMapValue, deserializedQuery
            .getParametersMap().get("key42"));
}

@Test
public void testSerializablePostProcessor() {
    byte[] ser = SerializationUtils.serialize(configurableBean);
    ConfigurableBean cb = (ConfigurableBean) SerializationUtils.deserialize(ser);
    assertEquals(cb.getNoSerializableBean(), configurableBean.getNoSerializableBean());
    ser = SerializationUtils.serialize(autowiredBean);
    AutowiredBean ab = (AutowiredBean) SerializationUtils.deserialize(ser);
    assertEquals(autowiredBean.getNoSerializableBean(), ab.getNoSerializableBean());
}

public void write(ObjectDef def, ObjectModel object) {
    try {
        String file = (StringUtils.isNotEmpty(folder) ? folder
                + File.separator : "")
                + object.getRootValue();

        byte[] data = SerializationUtils.serialize(object);

        FileUtils.writeByteArrayToFile(new File(file), data);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

public ObjectModel readObject(ObjectDef objDef, String parameter) {
    try {
        String file = (StringUtils.isNotEmpty(folder) ? folder
                + File.separator : "")
                + parameter;
        byte[] data = FileUtils.readFileToByteArray(new File(file));
        return (ObjectModel) SerializationUtils.deserialize(data);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

@Override
public byte[] serialization(Object obj) {
    return SerializationUtils.serialize(obj);
}

@SuppressWarnings("unchecked")
@Override
public <T> T deserialize(byte[] bytes) {
    return (T)SerializationUtils.deserialize(bytes);
}

@Override
public Object read(byte[] payload, Class<?> targetType) {
    return SerializationUtils.deserialize(payload);
}

@Override
public byte[] write(Object target) {
    return SerializationUtils.serialize(target);
}

@Override
public <T> ByteBuffer serialize(T obj) {
    return obj == null ? null : ByteBuffer.wrap(SerializationUtils.serialize(obj));
}