Java ProtobufIOUtil类代码示例

import io.protostuff.ProtobufIOUtil; //导入依赖的package包/类
@JsonIgnore
@SuppressWarnings({ "rawtypes", "unchecked" })
public FileConfig asFileConfig() {
  buffer.clear();
  FileConfig fc = new FileConfig();
  fc.setType(getFileType());
  fc.setName(name);
  fc.setOwner(owner);
  fc.setCtime(ctime);
  fc.setType(getFileType());
  fc.setVersion(getVersion());
  fc.setLocation(location);
  byte[] bytes = ProtobufIOUtil.toByteArray(this, (Schema) getPrivateSchema(), buffer);
  fc.setExtendedConfig(ByteString.copyFrom(bytes));
  fc.setFullPathList(fullPath);
  return fc;
}
 

import io.protostuff.ProtobufIOUtil; //导入依赖的package包/类
private static FileFormat get(FileConfig fileConfig) {
  // TODO (Amit H) Remove after defining classes for tsv, csv, and psv
  FileType fileType = fileConfig.getType();
  if (fileType == FileType.CSV || fileType == FileType.TSV || fileType == FileType.PSV) {
    fileType = FileType.TEXT;
  }
  final Class<? extends FileFormat> fileFormatClass = FileFormatDefinitions.CLASS_TYPES.get(fileType);
  final Schema<FileFormat> schema = (Schema<FileFormat>) FileFormatDefinitions.SCHEMAS.get(fileFormatClass);

  final FileFormat fileFormat = schema.newMessage();
  if (fileConfig.getExtendedConfig() != null) {
    ProtobufIOUtil.mergeFrom(fileConfig.getExtendedConfig().toByteArray(), fileFormat, schema);
  }

  fileFormat.setCtime(fileConfig.getCtime());
  fileFormat.setName(fileConfig.getName());
  fileFormat.setOwner(fileConfig.getOwner());
  fileFormat.setFullPath(fileConfig.getFullPathList());
  fileFormat.setVersion(fileConfig.getVersion());
  fileFormat.setLocation(fileConfig.getLocation());
  return fileFormat;
}
 

import io.protostuff.ProtobufIOUtil; //导入依赖的package包/类
@Override
protected Object readInternal(Class<?> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {

    MediaType contentType = inputMessage.getHeaders().getContentType();
    if (MEDIA_TYPE.isCompatibleWith(contentType)) {
        final Schema<?> schema = getSchema(clazz);
        final Object value = schema.newMessage();

        try (final InputStream stream = inputMessage.getBody()) {
            ProtobufIOUtil.mergeFrom(stream, value, (Schema<Object>) schema);
            return value;
        }
    }

    throw new HttpMessageNotReadableException(
            "Unrecognized HTTP media type " + inputMessage.getHeaders().getContentType().getType() + ".");
}
 

import io.protostuff.ProtobufIOUtil; //导入依赖的package包/类
/**
 * 将emp存入redis
 * @param emp
 * @return
 * @throws Exception
 */
private String putEmp(Emp emp) throws Exception{
    Jedis jedis = jedisPool.getResource();
    jedis.auth("redis");
    try {
        String key = "emp" + emp.getEmpId();
        byte[] bytes = ProtobufIOUtil.toByteArray(emp, schema,
                LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
        int timeout = 60 * 60;//1小时
        String result = jedis.setex(key.getBytes(), timeout, bytes);

        return result;
    }finally {
        jedis.close();
    }

}
 

import io.protostuff.ProtobufIOUtil; //导入依赖的package包/类
/**
 * 根据empId从redis中取emp
 * @param empId
 * @return
 * @throws Exception
 */
private Emp getEmp(int empId)throws Exception{
    String key = "emp" + empId;
    Jedis jedis = jedisPool.getResource();
    jedis.auth("redis");
    try  {
        byte[] bytes = jedis.get(key.getBytes());
        if (bytes != null) {
            Emp emp = schema.newMessage();
            ProtobufIOUtil.mergeFrom(bytes, emp, schema);
            return emp;
        }
    }finally {
        jedis.close();
    }
    return null;
}
 

import io.protostuff.ProtobufIOUtil; //导入依赖的package包/类
protected void WriteObjectOnSock(JCL_message obj,byte[] add,JCL_handler handler, boolean complete) throws Exception {

  	//Write data
@SuppressWarnings("unchecked")
byte[] Out = ProtobufIOUtil.toByteArray(obj, Constants.Serialization.schema[obj.getMsgType()], buffer.get());
buffer.get().clear();
byte key = (byte) obj.getMsgType();

ByteArrayOutputStream outputStream = new ByteArrayOutputStream( );
outputStream.write(Out);
outputStream.write(add);

byte send[] = outputStream.toByteArray( );		
handler.send(send,key,complete);
//End Write data
  }
 

import io.protostuff.ProtobufIOUtil; //导入依赖的package包/类
public Object getValueLocking(Object key,String host,String port, String mac, String portS,int hostId) {
	try {

			// ################ Serialization key ########################
			LinkedBuffer buffer = LinkedBuffer.allocate(1048576);
			ObjectWrap objW = new ObjectWrap(key);					
			key = ProtobufIOUtil.toByteArray(objW,scow, buffer);			
			// ################ Serialization key ########################

			JCL_message_generic gvMessage = new MessageGenericImpl();
			gvMessage.setType(15);
			gvMessage.setRegisterData(key);
			JCL_connector globalVarConnector = new ConnectorImpl();
			globalVarConnector.connect(host,Integer.parseInt(port),mac);
			JCL_message_generic result = (JCL_message_generic) globalVarConnector.sendReceiveG(gvMessage,portS);
			globalVarConnector.disconnect();

			// result from host
			return result.getRegisterData();

	} catch (Exception e) {
		System.err.println("problem in JCL facade getValueLocking");
		e.printStackTrace();
		return null;
	}
}
 

import io.protostuff.ProtobufIOUtil; //导入依赖的package包/类
public Boolean isLock(Object key,String host,String port, String mac, String portS, int hostId) {
	try {
			
			// ################ Serialization key ########################
			LinkedBuffer buffer = LinkedBuffer.allocate(1048576);
			ObjectWrap objW = new ObjectWrap(key);					
			key = ProtobufIOUtil.toByteArray(objW,scow, buffer);			
			// ################ Serialization key ########################

			JCL_message_generic gvMessage = new MessageGenericImpl();
			gvMessage.setRegisterData(key);
			gvMessage.setType(20);
			JCL_connector globalVarConnector = new ConnectorImpl();
			globalVarConnector.connect(host, Integer.parseInt(port),mac);
			JCL_result result = globalVarConnector.sendReceive(gvMessage,portS)
					.getResult();
			Boolean b = (Boolean) result.getCorrectResult();
			globalVarConnector.disconnect();
			
			// result from host
			return b;

	} catch (Exception e) {
		return false;
	}
}
 

import io.protostuff.ProtobufIOUtil; //导入依赖的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.ProtobufIOUtil; //导入依赖的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.ProtobufIOUtil; //导入依赖的package包/类
/**
   * Copies all of the mappings from the specified map to this map.
   * These mappings will replace any mappings that this map had for
   * any of the keys currently in the specified map.
   *
   * @param m mappings to be stored in this map
   * @throws NullPointerException if the specified map is null
   */
  public void putAll(Map<? extends K, ? extends V> m) {
      int numKeysToBeAdded = m.size();
              
      if (numKeysToBeAdded == 0)
          return;
      super.instantiateBin((Object)m.entrySet(), this.gvName);
              
      List<Object> obj =  new ArrayList<Object>();
LinkedBuffer buffer = LinkedBuffer.allocate(1048576);

      for(K key:m.keySet()){
      	
	// ################ Serialization key ########################
	buffer.clear();
      	ObjectWrap objW = new ObjectWrap(key);	
	Schema scow = RuntimeSchema.getSchema(ObjectWrap.class);
	byte[] k = ProtobufIOUtil.toByteArray(objW,scow, buffer);			
	// ################ Serialization key ########################

      	obj.add(ByteBuffer.wrap(k));
      }   
      
      super.hashAdd(gvName, obj,idLocalize);                
  }
 

import io.protostuff.ProtobufIOUtil; //导入依赖的package包/类
/**
  * Returns <tt>true</tt> if this map maps one or more keys to the
  * specified value.
  *
  * @param value value whose presence in this map is to be tested
  * @return <tt>true</tt> if this map maps one or more keys to the
  *         specified value
  */
 public boolean containsValue(Object value) {
 	Set table = super.getHashSet(gvName,idLocalize);
 	for(Object k:table){
 		
Schema<ObjectWrap> scow = RuntimeSchema.getSchema(ObjectWrap.class);
ObjectWrap obj = scow.newMessage();
ProtobufIOUtil.mergeFrom(((ByteBuffer)k).getArray(), obj, scow);    		
 		K key = (K)obj.getobj();
 		
 		Object valueGV = DEFAULT_JCL.getValue(key.toString()+"�Map�"+gvName).getCorrectResult();
 		if(value.equals(valueGV)){
 			return true;
 		}
 	}
 	return false;
 }
 

import io.protostuff.ProtobufIOUtil; //导入依赖的package包/类
final Entry<K,V> nextEntry() {
        	current = queue.poll();
        	
        	double pag = size/(queue.size()+size);
        	if(((pag>0.4) || (gvList.size()==1)) && (intGvList.hasNext())){
    			java.util.Map.Entry<Integer, JCL_message_generic> entHost = intGvList.next();
    			ticket.add(JCLHashMapPacu.super.getHashValues(queue, entHost.getValue(), entHost.getKey()));        	
        	}
        	
        	
        	size++;
        	        	
			Schema<ObjectWrap> scow = RuntimeSchema.getSchema(ObjectWrap.class);
			ObjectWrap obj = scow.newMessage();
			ProtobufIOUtil.mergeFrom(((ByteBuffer)current.getKey()).getArray(), obj, scow);    		
    		K key = (K)obj.getobj();
 
			ProtobufIOUtil.mergeFrom((byte[])current.getValue(), obj, scow);    		
    		V value = (V)obj.getobj();
        	
        	return new implementations.util.Entry<K, V>(key,value);
//            return current;
        }
 

import io.protostuff.ProtobufIOUtil; //导入依赖的package包/类
protected void WriteObjectOnSock(JCL_message obj,byte[] add,JCL_handler handler, boolean complete) throws Exception {

        //Write data
        @SuppressWarnings("unchecked")
        byte[] Out = ProtobufIOUtil.toByteArray(obj, Constants.Serialization.schema[obj.getMsgType()], buffer.get());
        buffer.get().clear();
        byte key = (byte) obj.getMsgType();

        ByteArrayOutputStream outputStream = new ByteArrayOutputStream( );
        outputStream.write(Out);
        outputStream.write(add);

        byte send[] = outputStream.toByteArray( );
        handler.send(send,key,complete);
        //End Write data
    }
 

import io.protostuff.ProtobufIOUtil; //导入依赖的package包/类
public Object getValueLocking(Object key,String host,String port, String mac, String portS,int hostId) {
	try {

		// ################ Serialization key ########################
		LinkedBuffer buffer = LinkedBuffer.allocate(1048576);
		ObjectWrap objW = new ObjectWrap(key);
		key = ProtobufIOUtil.toByteArray(objW,scow, buffer);
		// ################ Serialization key ########################

		JCL_message_generic gvMessage = new MessageGenericImpl();
		gvMessage.setType(15);
		gvMessage.setRegisterData(key);
		JCL_connector globalVarConnector = new ConnectorImpl();
		globalVarConnector.connect(host,Integer.parseInt(port),mac);
		JCL_message_generic result = (JCL_message_generic) globalVarConnector.sendReceiveG(gvMessage,portS);
		globalVarConnector.disconnect();

		// result from host
		return result.getRegisterData();

	} catch (Exception e) {
		System.err.println("problem in JCL facade getValueLocking");
		e.printStackTrace();
		return null;
	}
}