JNI实现命名管道服务器（二）——实现

原理在上一篇已经说好了，在这就不再赘述了，直接上代码，代码只是实现了一个基本框架，需要完善的东西大家可以自己加：

NamedPipe.java

 

public class NamedPipe implements Pipe {
	
	static{
		System.loadLibrary("NPJNI");
	}
	
	NamedPipeInputStream is;
	NamedPipeOutputStream os;
	
	int handle = -1;
	private String name;
	
	public String getName() {
		return name;
	}



	public NamedPipe(String name){
		this.name = name;
		this.handle = this.create(name);
		if(handle == -1){
			throw new NamedPipeCreateException(name);
		}
	}
	
	
	/**
	 * 等待接受一个客户端连接（堵塞）
	 * @return
	 */
	public boolean accept(){
		return this.connect(this.handle);
	}
	
	/**
	 * 得到一个PipeInputStream以读入数据
	 */
	public PipeInputStream getInputStream() {
		if(is == null){
			is = new NamedPipeInputStream(this);
		}
		return is;
	}

	/**
	 * 得到一个PipeOutputStream以写入数据
	 */
	public PipeOutputStream getOutputStream() {
		if(os == null){
			os = new NamedPipeOutputStream(this);
		}
		return os;
	}

	/**
	 * 关闭此NamedPipe
	 */
	public void close() {
		if(this.handle != -1){
			this.close(this.handle);
		}
	}
	
	/**
	 * 断开当前的客户端连接
	 */
	public void disconnect(){
		disconnect(handle);
	}

	private native void disconnect(int handle);
	
	private native void close(int handle);
	
	private native int create(String name);
	
	private native boolean connect(int handle);
}

 

 

 

 

NamedPipeInputStream:

 

 

public class NamedPipeInputStream extends PipeInputStream {

	NamedPipe pipe;
	
	static{
		System.loadLibrary("NPJNI");
	}
	
	NamedPipeInputStream(NamedPipe pipe){
		this.pipe = pipe;
	}
	
    private native int readBytes(int handle, byte b[], int len) throws IOException;

    /**
     * 读入数据到一个beye数组（堵塞）
     * @return 实际读取的字节数
     */
    public int read(byte b[]) throws IOException {
    	return readBytes(pipe.handle, b,  b.length);
    }
    
    /**
     * 读入数据到一个beye数组（堵塞）
     * @param b
     * @return 读取信息
     */
    public ReadPipeInfo readPipe(byte b[]){
    	return this.readPipe(pipe.handle,b,b.length);
    }
	
    public native ReadPipeInfo readPipe(int handle, byte b[], int len);
}

 

 

 

NamedPipeOutputStream.java:

 

public class NamedPipeOutputStream extends PipeOutputStream {
	
	NamedPipe pipe;
	ByteArrayOutputStream buffer = new ByteArrayOutputStream();
	
	static{
		System.loadLibrary("NPJNI");
	}
	
	NamedPipeOutputStream(NamedPipe pipe){
		this.pipe = pipe;
	}
	
	/*public final NamedPipe getPipe(){
		return pipe;
	}*/
	
	private native void writeBytes(int handle, byte b[], int len)
			throws IOException;
	
	

	private native void writeBytesOff(int handle, byte b[], int offset, int len)
			throws IOException;

	/**
	 * 将一个byte数组写入管道
	 */
	public void write(byte b[]) throws IOException {
		buffer.write(b);
	}
	
	/**
	 * 将字符串s写入管道
	 * @throws IOException 
	 */
	public void write(String s) throws IOException{
		buffer.write(s.getBytes());
	}
	
	/**
	 * 将byte数组写入管道。off指定了写入的偏移值，len指定写入的长度
	 */
	@Override
	public void write(byte[] b, int off, int len) throws IOException {
		this.writeBytesOff(pipe.handle,b,off,len);
	}

	/**
	 * flush此NamedPipeOutputStream，将所有数据写入管道
	 */
	public void flush() {
		byte[] bytes = buffer.toByteArray();
		if(bytes.length > 0){
			try {
				writeBytes(pipe.handle, bytes, bytes.length);
			} catch (IOException e) {
				e.printStackTrace();
			}
			buffer = new ByteArrayOutputStream();
			flush(pipe.handle);
		}
	}
	
	private native void flush(int handle);

}

 

 

ReadPipeInfo.java：

 

public class ReadPipeInfo {

	boolean more = false;
	int count = -1;
	
	public boolean hasMoreData(){
		return this.more;
	}
	
	public int readCount(){
		return count;
	}
	
}

 

 

C++代码：

 

#define BUFSIZE 4096*500
 

JNIEXPORT jint JNICALL Java_pipe_NamedPipe_create
  (JNIEnv *env, jobject obj, jstring name)
{
	const wchar_t *str = (const wchar_t *)env->GetStringChars(name,NULL);
	if(str == NULL)
	{
		return -1;
	}
	HANDLE hPipe;
	hPipe = CreateNamedPipe( 
		str,             // pipe name 
		PIPE_ACCESS_DUPLEX,       // read/write access 
		PIPE_TYPE_MESSAGE |       // message type pipe 
		PIPE_READMODE_MESSAGE |   // message-read mode 
		PIPE_WAIT,                // blocking mode 
		PIPE_UNLIMITED_INSTANCES, // max. instances  
		BUFSIZE,                  // output buffer size 
		BUFSIZE,                  // input buffer size 
		0,                        // client time-out 
		NULL);                    // default security attribute 

	if (hPipe == INVALID_HANDLE_VALUE) 
	{
		env->ReleaseStringChars(name, (const jchar *)str);
		printf("CreatePipe failed"); 
		return -1;
	}
	env->ReleaseStringChars(name, (const jchar *)str);
	return (long)hPipe;
}


JNIEXPORT jboolean JNICALL Java_pipe_NamedPipe_connect
  (JNIEnv *env, jobject obj, jint handle)
{
	HANDLE hPipe = (void *)((int)handle);
	BOOL fConnected = ConnectNamedPipe(hPipe, NULL) ? 
         TRUE : (GetLastError() == ERROR_PIPE_CONNECTED); 
	return fConnected;
}


JNIEXPORT void JNICALL Java_pipe_NamedPipe_close
  (JNIEnv *env, jobject obj, jint handle)
{
	CloseHandle((void *)((int)handle));
}


JNIEXPORT void JNICALL Java_pipe_NamedPipe_disconnect
  (JNIEnv *env, jobject obj, jint handle)
{
	HANDLE hPipe = (void *)((int)handle);
	DisconnectNamedPipe(hPipe); 
}


JNIEXPORT jint JNICALL Java_pipe_NamedPipeInputStream_readBytes
  (JNIEnv *env, jobject obj, jint handle, jbyteArray buffer, jint len)
{
	//jbyte *jBuffer = env->GetByteArrayElements(buffer,NULL);
	char *cBuffer = new char[len+1];

	DWORD cbBytesRead;

	HANDLE hPipe = (void *)((int)handle);
	BOOL fSuccess = ReadFile( 
		hPipe,        // handle to pipe 
		cBuffer,    // buffer to receive data 
		len, // size of buffer 
		&cbBytesRead, // number of bytes read 
		NULL);        // not overlapped I/O 
	if (! fSuccess && GetLastError() != ERROR_MORE_DATA)
	{
		delete cBuffer;
		return -1;
	}
	env->SetByteArrayRegion(buffer,0,cbBytesRead,(const jbyte *)cBuffer);
	delete cBuffer;
	return cbBytesRead;
}


JNIEXPORT jobject JNICALL Java_pipe_NamedPipeInputStream_readPipe
  (JNIEnv *env, jobject obj, jint handle, jbyteArray buffer, jint len)
{
	//jbyte *jBuffer = env->GetByteArrayElements(buffer,NULL);
	char *cBuffer = new char[len+1];

	DWORD cbBytesRead;

	HANDLE hPipe = (void *)((int)handle);
	BOOL fSuccess = ReadFile( 
		hPipe,        // handle to pipe 
		cBuffer,    // buffer to receive data 
		len, // size of buffer 
		&cbBytesRead, // number of bytes read 
		NULL);        // not overlapped I/O 

	DWORD le = GetLastError();

	if (! fSuccess && le != ERROR_MORE_DATA)
	{
		jclass jclass = env->FindClass("pipe/ReadPipeInfo");   
		jfieldID moreData = env->GetFieldID(jclass,"more","Z");   
		jfieldID count = env->GetFieldID(jclass,"count","I");  

		jmethodID mID = env->GetMethodID(jclass, "<init>", "()V");
		jobject info = env->NewObject(jclass,mID); 
		delete cBuffer;
		env->SetBooleanField(info,moreData,false);
		env->SetIntField(info,count,-1);
		env->DeleteLocalRef(jclass);
		return info;
	}

	jclass jclass = env->FindClass("pipe/ReadPipeInfo");   
    jfieldID moreData = env->GetFieldID(jclass,"more","Z");   
    jfieldID count = env->GetFieldID(jclass,"count","I");  
  
	jmethodID mID = env->GetMethodID(jclass, "<init>", "()V");
	jobject info = env->NewObject(jclass,mID); 

	
	env->SetByteArrayRegion(buffer,0,cbBytesRead,(const jbyte *)cBuffer);
	delete cBuffer;
	    
	if(le == ERROR_MORE_DATA){
		env->SetBooleanField(info,moreData,true);
	}else{
		env->SetBooleanField(info,moreData,false);
	}
	
	env->SetIntField(info,count,cbBytesRead);
    //env->SetShortField(info,count,10);  
	env->DeleteLocalRef(jclass);
      
    return info;   
}


JNIEXPORT void JNICALL Java_pipe_NamedPipeOutputStream_writeBytes
  (JNIEnv *env, jobject obj, jint handle, jbyteArray buffer, jint len)
{
	jbyte *jBuffer = env->GetByteArrayElements(buffer,NULL);
	
	DWORD cbWritten;
	HANDLE hPipe = (void *)((int)handle);
	// Write to the pipe. 
	BOOL fSuccess = WriteFile( 
		hPipe,        // handle to pipe 
		jBuffer,      // buffer to write from 
		len, // number of bytes to write 
		&cbWritten,   // number of bytes written 
		NULL);        // not overlapped I/O
}


JNIEXPORT void JNICALL Java_pipe_NamedPipeOutputStream_writeBytesOff
  (JNIEnv *env, jobject obj, jint handle, jbyteArray buffer, jint off, jint len)
{
	jbyte *jBuffer = env->GetByteArrayElements(buffer,NULL);
	
	DWORD cbWritten;
	HANDLE hPipe = (void *)((int)handle);
	// Write to the pipe. 
	BOOL fSuccess = WriteFile( 
		hPipe,        // handle to pipe 
		jBuffer+off,      // buffer to write from 
		len, // number of bytes to write 
		&cbWritten,   // number of bytes written 
		NULL);        // not overlapped I/O
}


JNIEXPORT void JNICALL Java_pipe_NamedPipeOutputStream_flush
  (JNIEnv *env, jobject obj, jint handle)
{
	HANDLE hPipe = (void *)((int)handle);
	BOOL flag = FlushFileBuffers(hPipe);
}