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

最新推荐文章于 2023-07-17 10:42:13 发布
最新推荐文章于 2023-07-17 10:42:13 发布
阅读量239 收藏
点赞数
分类专栏： JNI 文章标签： JNI OS Access 框架 Security

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

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);
}
 

 

 

 

 

 

 

 

iteye_16714
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pipe函数管道通信小例子
11-09
一些小程序 大家支持一下 下载后评论 既不浪费 又是支持~~~
Java中JNI的使用(二)——参数传递
07-31
NULL 博文链接：https://zhoucl.iteye.com/blog/1101661
进程间通信之命名管道
最新发布
k5426244的博客
07-17 656
管道应用的一个限制就是（具有亲缘关系）的进程间通信，这种通信可以用来实现。如果我们想，可以使用FIFO文件来做这项工作，它经常被称为。1.什么是命名管道？命名管道（named pipe）也称为FIFO，它是一种文件类型，创建一个FIFO文件类似于创建一个普通文件。FIFO解决了只有具有亲缘关系的进程间才能通信的问题。并且命名管道是一种特殊类型的文件。2.匿名管道与命名管道的区别？
JNI实现命名管道服务器（一）——命名管道简介
iteye_16714的博客
12-13 307
  一个命名管道是一个具名的，单工或双工通讯的管道，它可以在一个管道服务器和多个管道管道客户端之间进行通讯。所有的命名管道实例共用一个管道名称，但是每个管道实例拥有自己的缓冲区和句柄，以提供单独的服务器/客户端通讯信道。 所有的进程都可以访问命名管道，这也使得命名管道成为进程间通讯的利器。 同样，任何进程既可以充当管道服务器，也可以充当管道客户端，这使得进程间点对点通讯成为可能。 ...
JNI 实战全面解析
banketree
11-01 10万+
项目决定移植一款C++开源项目到Android平台，开始对JNI深入研究。 JNI是什么？ JNI(Java Native Interface)意为JAVA本地调用，它允许Java代码和其他语言写的代码进行交互，简单的说，一种在Java虚拟机控制下执行代码的标准机制。 NDK是什么？ Android NDK（Native Development Kit ）是一套工具集合，允许你用像C/C++语言那样实现应用程序的一部分。 为什么要用NDK？ 1、安全性，java是半解释型语言，很容易被反汇编后拿到源代码文件
Andorid项目源码 JNI 简介与实现完整版.zip
06-05
Andorid项目源码 JNI 简介与实现完整版
JNI实现java cpp相互调用
07-06
静态方式实现： C/C++中访问Java方法 C/C++中访问Java父类的方法 C/C++中访问/修改Java变量 Java中访问C/C++方法 Java中访问/修改C/C++变量 动态方式实现： C/C++中访问Java方法 C/C++中访问Java父类的方法 C/C++中...
Android通过JNI实现守护进程
01-20
开发一个需要常住后台的App其实是一件非常头疼的事情，不仅要应对国内各大厂商的ROM，还需要应对各类的安全管家…虽然不断的研究各式各样的方法，但是效果并不好，比如任务管理器把App干掉，服务就起不来了… ...
jni实现自定义progress（锅炉压力监测）
09-02
jni实现自定义progress（锅炉压力监测） csdn:http://blog.csdn.net/u014657752
命名管道（FIFO）示例代码
06-02
Linux系统编程——进程间通信：命名管道（FIFO），相关教程链接如下： http://blog.csdn.net/tennysonsky/article/details/46326957
【Android学习之】深入理解JNI
紫雾凌寒
06-16 2187
经过一周多的时间，这篇博客终于码完了。这篇博客主要是为了帮助大家深入理解JNI，写这篇博客主要是因为前段时间去面试，面试有道25分的简答题就是让我概述Android JNI 的调用过程，当时我就懵逼了，我除了知道JNI是“Java  native interface”的缩写外，其他什么都不知道。好了，废话少说，下面为大家开始介绍JNI： 1、JNI概述 JNI 是  Java Native I
Android JNI之命名管道(FIFO/mkfifo)的使用(2)
whysnlc的专栏
12-09 1232
场景描述：在JNI层使用mkfifo，并且读写数据，同时在Android Java层读写fifo数据。 方法：
Native层的handle机制浅析
泊客
03-28 2718
本文旨在进一步分析MessageQueue.java中的Native方法 private native static long nativeInit();//初始化 private native static void nativeDestroy(long ptr);//销毁 private native void nativePollOnce(long ptr, int...
android命名管道创建使用
qq_44782901的博客
02-26 2883
#创建命名管道 #include <sys/stat.h> #include <stdio.h> #include <sys/types.h> #include <unistd.h> #include <string.h> #include <fcntl.h> #include <stdlib.h> #include <sstream> #include <iostream> #define _SE
从源码角度分析native层消息机制与java层消息机制的关联
热门推荐
相信技术的力量
09-02 12万+
上文从源码分析Handler机制中从java层分析了消息机制，接下来本文从native层去分析Android中的消息机制。在一个消息驱动的系统中，最重要的就是消息队列和消息获取和处理，从上一篇文章可以看出handler的消息机制主要是靠MessageQueue进行消息列队，靠Looper进行消息循环，Looper的loop方法中进行轮询消息的实际操作还是依靠MessageQueue的next方法来获
Java继承_夯实Java基础系列23：一文读懂继承、封装、多态的底层实现原理
weixin_39664477的博客
10-22 129
本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看https://github.com/h2pl/Java-Tutorial喜欢的话麻烦点下Star哈文章首发于我的个人博客：www.how2playlife.com本文是微信公众号【Java技术江湖】的《夯实Java基础系列博文》其中一篇，本文部分内容来源于网络，为了把本文主题讲得清晰透彻，也整合了很多我...
C++库封装JNI接口——实现java调用c++
06-03
#include <jni.h> #ifdef __cplusplus extern "C" { #endif JNIEXPORT jstring JNICALL Java_com_example_NativeUtils_getMessage(JNIEnv *env, jobject thiz) { const char *message = "Hello from C++!"; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值