Java LinkedBuffer.allocate方法代码示例

import io.protostuff.LinkedBuffer; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
public static <T> byte[] serialize(T obj) {
    Class<T> cls = (Class<T>) obj.getClass();

    // 如果是基本类型，则转换为string
    if (isSupport(cls)) {
        return castToString(obj).getBytes();
    }

    LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
    try {
        Schema<T> schema = getSchema(cls);
        return ProtostuffIOUtil.toByteArray(obj, schema, buffer);
    } catch (Exception e) {
        throw new IllegalStateException(e.getMessage(), e);
    } finally {
        buffer.clear();
    }
}
 

import io.protostuff.LinkedBuffer; //导入方法依赖的package包/类
public void write(WrapSchema headerSchema, Object header, WrapSchema bodySchema, Object body) throws Exception {
  // 写protobuf数据
  LinkedBuffer linkedBuffer = LinkedBuffer.allocate();
  ProtobufOutput output = new ProtobufOutput(linkedBuffer);

  // 写header
  if (headerSchema != null) {
    headerSchema.writeObject(output, header, protobufFeature);
  }
  int headerSize = output.getSize();

  // 写body
  // void时bodySchema为null
  if (bodySchema != null) {
    bodySchema.writeObject(output, body, protobufFeature);
  }

  writeLength(output.getSize(), headerSize);
  LinkedBuffer.writeTo(this, linkedBuffer);
}
 

import io.protostuff.LinkedBuffer; //导入方法依赖的package包/类
@Test
public void testWriteObject() {
  boolean status = true;
  LinkedBuffer linkedBuffer = LinkedBuffer.allocate();
  ProtobufOutput output = new ProtobufOutput(linkedBuffer);
  String[] stringArray = new String[1];
  stringArray[0] = "abc";

  MultiWrapper multiWrapper = Mockito.mock(MultiWrapper.class);
  Mockito.when(schema.newMessage()).thenReturn(multiWrapper);
  try {
    argsWrapSchema.writeObject(output, stringArray);
  } catch (IOException e) {
    status = true;
  }
  Assert.assertTrue(status);
}
 

import io.protostuff.LinkedBuffer; //导入方法依赖的package包/类
/**
 * 序列化对象
 *
 * @param obj
 * @param <T>
 * @return
 */
public static <T> byte[] serialize(T obj) {
    if (obj == null) {
        throw new RuntimeException("序列化对象(" + obj + ")为空!");
    }
    RuntimeSchema<T> schema = RuntimeSchema.createFrom((Class<T>) obj.getClass());
    LinkedBuffer buffer = LinkedBuffer.allocate(1024 * 1024);
    byte[] protoStuff = null;
    try {
        protoStuff = ProtostuffIOUtil.toByteArray(obj, schema, buffer);
    } catch (Exception e) {
        throw new RuntimeException("序列化(" + obj.getClass() + ")对象(" + obj + ")发生异常!", e);
    } finally {
        buffer.clear();
    }
    return protoStuff;
}
 

import io.protostuff.LinkedBuffer; //导入方法依赖的package包/类
/**
 * Associates the specified value with the specified key in this map.
 * If the map previously contained a mapping for the key, the old
 * value is replaced.
 *
 * @param key key with which the specified value is to be associated
 * @param value value to be associated with the specified key
 * @return the previous value associated with <tt>key</tt>, or
 *         <tt>null</tt> if there was no mapping for <tt>key</tt>.
 */

public V putUnlock(K key, V value){
	V oldValue = null;
    if (key != null){        	
    	if(DEFAULT_JCL.containsGlobalVar(key.toString()+"�Map�"+gvName)){
    		oldValue = (V) DEFAULT_JCL.getValue(key.toString()+"�Map�"+gvName).getCorrectResult();
    		DEFAULT_JCL.setValueUnlocking((key.toString()+"�Map�"+gvName), value);
    	}else if (DEFAULT_JCL.instantiateGlobalVar((key.toString()+"�Map�"+gvName), value)){
			
			// ################ Serialization key ########################
			LinkedBuffer buffer = LinkedBuffer.allocate(1048576);
			ObjectWrap objW = new ObjectWrap(key);	
			Schema scow = RuntimeSchema.getSchema(ObjectWrap.class);
			byte[] k = ProtobufIOUtil.toByteArray(objW,scow, buffer);			
			// ################ Serialization key ########################

    		super.hashAdd(gvName,ByteBuffer.wrap(k),idLocalize);
		}
    }else{
   	 System.out.println("Can't put<K,V> with null key!");
    }        
    return (oldValue == null ? null : oldValue);
}
 

import io.protostuff.LinkedBuffer; //导入方法依赖的package包/类
/**
  * Associates the specified value with the specified key in this map.
  * If the map previously contained a mapping for the key, the old
  * value is replaced.
  *
  * @param key key with which the specified value is to be associated
  * @param value value to be associated with the specified key
  * @return the previous value associated with <tt>key</tt>, or
  *         <tt>null</tt> if there was no mapping for <tt>key</tt>.
  */    
 public V put(K key, V value){
 	Object oldValue = null;
     if ((key != null) && ((oldValue = super.hashPut((key.toString()+"�Map�"+gvName), value))!=null)){        	
     		        	
// ################ Serialization key ########################
LinkedBuffer buffer = LinkedBuffer.allocate(1048576);
ObjectWrap objW = new ObjectWrap(key);	
Schema<ObjectWrap> scow = RuntimeSchema.getSchema(ObjectWrap.class);
byte[] k = ProtobufIOUtil.toByteArray(objW,scow, buffer);			
// ################ Serialization key ########################

     	super.hashAdd(gvName,ByteBuffer.wrap(k),idLocalize);
     }else{
    	 System.out.println("Null key or fault in put<K,V> on cluster!");
     }
     
     return (V)oldValue;
 }
 

import io.protostuff.LinkedBuffer; //导入方法依赖的package包/类
/**
 * Associates the specified value with the specified key in this map.
 * If the map previously contained a mapping for the key, the old
 * value is replaced.
 *
 * @param key key with which the specified value is to be associated
 * @param value value to be associated with the specified key
 * @return the previous value associated with <tt>key</tt>, or
 *         <tt>null</tt> if there was no mapping for <tt>key</tt>.
 */

public V putUnlock(K key, V value){
    V oldValue = null;
    if (key != null){
        if(DEFAULT_JCL.containsGlobalVar(key.toString()+"¬Map¬"+gvName)){
            oldValue = (V) DEFAULT_JCL.getValue(key.toString()+"¬Map¬"+gvName).getCorrectResult();
            DEFAULT_JCL.setValueUnlocking((key.toString()+"¬Map¬"+gvName), value);
        }else if (DEFAULT_JCL.instantiateGlobalVar((key.toString()+"¬Map¬"+gvName), value)){

            // ################ Serialization key ########################
            LinkedBuffer buffer = LinkedBuffer.allocate(1048576);
            ObjectWrap objW = new ObjectWrap(key);
            Schema scow = RuntimeSchema.getSchema(ObjectWrap.class);
            byte[] k = ProtobufIOUtil.toByteArray(objW,scow, buffer);
            // ################ Serialization key ########################

            super.hashAdd(gvName,ByteBuffer.wrap(k),idLocalize);
        }
    }else{
        System.out.println("Can't put<K,V> with null key!");
    }
    return (oldValue == null ? null : oldValue);
}
 

import io.protostuff.LinkedBuffer; //导入方法依赖的package包/类
/**
 * Associates the specified value with the specified key in this map.
 * If the map previously contained a mapping for the key, the old
 * value is replaced.
 *
 * @param key key with which the specified value is to be associated
 * @param value value to be associated with the specified key
 * @return the previous value associated with <tt>key</tt>, or
 *         <tt>null</tt> if there was no mapping for <tt>key</tt>.
 */
public V put(K key, V value){
    Object oldValue = null;
    if ((key != null) && ((oldValue = super.hashPut((key.toString()+"¬Map¬"+gvName), value))!=null)){

        // ################ Serialization key ########################
        LinkedBuffer buffer = LinkedBuffer.allocate(1048576);
        ObjectWrap objW = new ObjectWrap(key);
        Schema<ObjectWrap> scow = RuntimeSchema.getSchema(ObjectWrap.class);
        byte[] k = ProtobufIOUtil.toByteArray(objW,scow, buffer);
        // ################ Serialization key ########################

        super.hashAdd(gvName,ByteBuffer.wrap(k),idLocalize);
    }else{
        System.out.println("Null key or fault in put<K,V> on cluster!");
    }

    return (V)oldValue;
}
 

import io.protostuff.LinkedBuffer; //导入方法依赖的package包/类
@Override
public <T> byte[] serialize( final T source ) {
    @SuppressWarnings( "unchecked" )
    final Class<T> clazz = (Class<T>) source.getClass();
    final LinkedBuffer buffer = LinkedBuffer.allocate( LinkedBuffer.DEFAULT_BUFFER_SIZE );
    try {
        final Schema<T> schema = SchemaUtils.getSchema( clazz );
        return serializeInternal( source, schema, buffer );
    }
    catch ( final Exception e ) {
        throw new IllegalStateException( e );
    }
    finally {
        buffer.clear();
    }
}
 

import io.protostuff.LinkedBuffer; //导入方法依赖的package包/类
protected Buffer createBuffer(WrapSchema schema, Object value) throws Exception {
  Buffer headerBuffer;
  LinkedBuffer linkedBuffer = LinkedBuffer.allocate();
  ProtobufOutput output = new ProtobufOutput(linkedBuffer);
  schema.writeObject(output, value);
  try (BufferOutputStream os = new BufferOutputStream()) {
    LinkedBuffer.writeTo(os, linkedBuffer);

    headerBuffer = os.getBuffer();
  }
  return headerBuffer;
}
 

import io.protostuff.LinkedBuffer; //导入方法依赖的package包/类
private byte[] toByteArray(WrapSchema schema, Object value) throws Exception {
  LinkedBuffer linkedBuffer = LinkedBuffer.allocate();
  ProtobufOutput output = new ProtobufOutput(linkedBuffer);

  schema.writeObject(output, value);
  return output.toByteArray();
}
 

import io.protostuff.LinkedBuffer; //导入方法依赖的package包/类
@Test
public void object() throws Exception {
  WrapSchema schema = ProtobufSchemaUtils.getOrCreateSchema(Object.class);

  LinkedBuffer linkedBuf = LinkedBuffer.allocate();
  ProtobufOutput output = new ProtobufOutput(linkedBuf);
  schema.writeObject(output, 1);

  Input input = new ByteArrayInput(output.toByteArray(), false);
  Object result = schema.readObject(input);

  Assert.assertEquals(1, result);
  Assert.assertThat(result, Matchers.instanceOf(Integer.class));
}
 

import io.protostuff.LinkedBuffer; //导入方法依赖的package包/类
@Test
public void testWriteObject() {
  boolean status = true;
  LinkedBuffer linkedBuffer = LinkedBuffer.allocate();
  ProtobufOutput output = new ProtobufOutput(linkedBuffer);
  String[] stringArray = new String[1];
  try {
    argsNotWrapSchema.writeObject(output, stringArray);
  } catch (Exception e) {
    status = false;
  }
  Assert.assertTrue(status);
}
 

import io.protostuff.LinkedBuffer; //导入方法依赖的package包/类
@Test
public void testWriteObjectToSchema() {
  boolean status = true;
  LinkedBuffer linkedBuffer = LinkedBuffer.allocate();
  ProtobufOutput output = new ProtobufOutput(linkedBuffer);
  String[] stringArray = new String[1];
  stringArray[0] = "abc";
  try {
    argsNotWrapSchema.writeObject(output, stringArray);
  } catch (Exception e) {
    status = false;
  }
  Assert.assertTrue(status);
}
 

import io.protostuff.LinkedBuffer; //导入方法依赖的package包/类
protected byte[] testProtostuff(Map<String, String> map, Map<String, User> userMap) throws IOException {
  ProtobufCompatibleUtils.init();

  RuntimeSchema<ModelProtostuff> schema = RuntimeSchema.createFrom(ModelProtostuff.class);
  ModelProtostuff model = new ModelProtostuff();

  model.setContext(map);
  model.setUserMap(userMap);
  model.getList().add("l1");
  model.getList().add("l2");

  LinkedBuffer linkedBuffer = LinkedBuffer.allocate();
  ProtobufOutput output = new ProtobufOutput(linkedBuffer);
  ProtobufFeature protobufFeature = new ProtobufFeature();
  protobufFeature.setUseProtobufMapCodec(true);

  ProtobufFeatureUtils.setProtobufFeature(protobufFeature);
  schema.writeTo(output, model);

  ByteArrayOutputStream s = new ByteArrayOutputStream();
  LinkedBuffer.writeTo(s, linkedBuffer);
  byte[] bytes = s.toByteArray();

  ModelProtostuff newModel = new ModelProtostuff();
  ByteArrayInput bai = new ByteArrayInput(bytes, false);

  schema.mergeFrom(bai, newModel);

  ProtobufFeatureUtils.removeProtobufFeature();
  Assert.assertEquals("v1", newModel.getContext().get("k1"));
  Assert.assertEquals("v2", newModel.getContext().get("k2"));
  Assert.assertEquals("n1", newModel.getUserMap().get("u1").getName());
  Assert.assertEquals("n2", newModel.getUserMap().get("u2").getName());
  Assert.assertEquals("l1", newModel.getList().get(0));
  Assert.assertEquals("l2", newModel.getList().get(1));

  return bytes;
}