python 怎么关闭 打开的 shelll 脚本
时间: 2023-05-23 07:00:38 浏览: 69
很高兴回答您的问题。下面是Java Netty实现将文件从一个路径发送到另一个路径的示例代码:
发送端代码:
```java
// 需要导入相关包
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.serialization.ObjectEncoder;
public class MyNettyClient {
public void run() throws InterruptedException, FileNotFoundException {
String host = "127.0.0.1"; // 服务器地址
int port = 8080; // 服务器端口号
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
Bootstrap b = new Bootstrap(); // 启动NIO客户端的辅助启动类
b.group(workerGroup); // 传递了一个NioEventLoopGroup实例以处理事件的处理
b.channel(NioSocketChannel.class); // 使用NioSocketChannel来作为连接用的channel类
b.option(ChannelOption.SO_KEEPALIVE, true); // 设置客户端套接字参数
b.handler(new ChannelInitializer<SocketChannel>() { // 有连接到服务端的时候,在处理连接的数据
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
// 为pipeline添加一个ObjectEncoder,以将Object转换为ByteBuf用于发送
pipeline.addLast("encoder", new ObjectEncoder());
}
});
// 启动客户端连接服务端
ChannelFuture f = b.connect(host, port).sync();
// 创建文件输入流
File file = new File("D:\\test.txt");
FileInputStream inputStream = new FileInputStream(file);
byte[] bytes = new byte[(int) file.length()];
inputStream.read(bytes);
inputStream.close();
// 发送文件,将文件内容封装到FileMessage对象中,通过byteBuf发送到服务端
FileMessage fileMessage = new FileMessage();
fileMessage.setFileName(file.getName());
fileMessage.setContent(bytes);
ChannelFuture future = f.channel().writeAndFlush(Unpooled.copiedBuffer(fileMessage.serialize()));
future.sync();
// 等待客户端通道关闭
f.channel().closeFuture().sync();
} finally {
// 优雅的关闭客户端
workerGroup.shutdownGracefully();
}
}
public static void main(String[] args) throws InterruptedException, FileNotFoundException {
new MyNettyClient().run();
}
}
```
接收端代码:
```java
// 需要导入相关包
import java.io.File;
import java.io.FileOutputStream;
import java.util.UUID;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.serialization.ClassResolver;
import io.netty.handler.codec.serialization.ClassResolvers;
import io.netty.handler.codec.serialization.ObjectDecoder;
public class MyNettyServer {
public void run() throws Exception {
int port = 8080; // 定义服务端监听端口
EventLoopGroup bossGroup = new NioEventLoopGroup(); // 创建boss线程组用于处理连接工作
EventLoopGroup workerGroup = new NioEventLoopGroup(); // 创建worker线程组用于处理数据读写
try {
ServerBootstrap b = new ServerBootstrap(); // 创建服务端启动辅助类
b.group(bossGroup, workerGroup) // 设置使用的group
.channel(NioServerSocketChannel.class) // 指明使用的channel类型
.option(ChannelOption.SO_BACKLOG, 128) // 设置客户端连接队列长度
.childOption(ChannelOption.SO_KEEPALIVE, true) // 设置连接状态检查
.childHandler(new ChannelInitializer<SocketChannel>() { // worker线程组的处理类
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
// 添加自定义handler处理文件读写
pipeline.addLast(new MyServerHandler());
// 反序列化,将ByteBuf转换为Object对象,采用LengthFieldBasedFrameDecoder解决半包读写的问题
pipeline.addLast("frameDecoder", new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4));
pipeline.addLast("decoder", new ObjectDecoder(Integer.MAX_VALUE,
ClassResolvers.weakCachingConcurrentResolver(null)));
}
});
// 绑定端口,开始接收进来的连接
ChannelFuture f = b.bind(port).sync();
// 等待服务器socket关闭
f.channel().closeFuture().sync();
} finally {
// 关闭线程池资源
workerGroup.shutdownGracefully();
bossGroup.shutdownGracefully();
}
}
public static void main(String[] args) throws Exception {
new MyNettyServer().run();
}
}
// 自定义Handler,用于处理文件的读写
class MyServerHandler extends ChannelInboundHandlerAdapter {
// 文件存储路径
private static final String DIRECTORY = "D:\\Netty\\server\\";
// 文件名
private String fileName;
// 文件内容
private byte[] content;
// 文件内容长度
private int contentLength;
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
if (msg instanceof ByteBuf) {
ByteBuf byteBuf = (ByteBuf)msg;
// 判断是否已经读取到文件名
if (fileName == null) {
// 读取文件名
int fileNameLength = byteBuf.readInt();
byte[] bytes = new byte[fileNameLength];
byteBuf.readBytes(bytes);
fileName = new String(bytes);
}
// 判断是否已经读取到文件内容的长度
if (content == null && byteBuf.readableBytes() >= 4) {
contentLength = byteBuf.readInt();
content = new byte[contentLength];
}
// 读取文件内容
if (content != null && byteBuf.readableBytes() >= contentLength) {
byteBuf.readBytes(content);
// 写入保存到本地
File file = new File(DIRECTORY + fileName);
if (!file.exists()) {
file.createNewFile();
}
FileOutputStream fileOutputStream = new FileOutputStream(file);
fileOutputStream.write(content, 0, contentLength);
fileOutputStream.flush();
fileOutputStream.close();
ctx.close();
}
}
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
}
// 定义文件消息承载类
class FileMessage implements java.io.Serializable {
private static final long serialVersionUID = -6247471178633849179L;
// 文件名
private String fileName;
// 文件内容
private byte[] content;
public String getFileName() {
return fileName;
}
public void setFileName(String fileName) {
this.fileName = fileName;
}
public byte[] getContent() {
return content;
}
public void setContent(byte[] content) {
this.content = content;
}
// 序列化为ByteBuf,用于网络传输
public ByteBuf serialize() {
int fileNameLength = fileName.getBytes().length;
int contentLength = content.length;
ByteBuf buf = Unpooled.buffer(4 + fileNameLength + 4 + contentLength);
buf.writeInt(fileNameLength);
buf.writeBytes(fileName.getBytes());
buf.writeInt(contentLength);
buf.writeBytes(content);
return buf;
}
}
```
以上是Java Netty实现将文件从一个路径发送到另一个路径的示例代码,您可以根据实际需求进行参考和修改。