Socket：java与C之间的文件传送<2>(JAVA语言之间的通信)

最新推荐文章于 2023-01-14 14:14:42 发布
最新推荐文章于 2023-01-14 14:14:42 发布
阅读量385 收藏
点赞数
分类专栏： Java网络编程

其实绝大多数编程语言之间的通信原理是一样的这边文章来看一下java是如何进行文件传输的

建议先看 Client 类，再看 Server 类。

[html] view plain copy print ?
  1. import java.io.*;   
  2. import java.net.ServerSocket;   
  3. import java.net.Socket;   
  4.   
  5. /**   
  6. * 简单的文件发送与接收示例   
  7. */   
  8. public class FileTrasmission {   
  9.   
  10. //程序入口   
  11. public static void main(String[] args) throws Exception {   
  12. int port = 7788;   
  13. new Server(port, "c://save//").start();   
  14. new Client().sendFile("127.0.0.1", port, "c://迷失在康熙末年.txt");   
  15. }   
  16. }   
  17.   
  18. /**   
  19. * 接收端。可同时接收多个发送端发来的文件。但如果发来的文件是同名的话那就乱了。   
  20. */   
  21. class Server {   
  22.   
  23. private int listenPort;   
  24.   
  25. private String savePath;   
  26.   
  27. /**   
  28. * 构造方法   
  29. *   
  30. * @param listenPort 侦听端口   
  31. * @param savePath 接收的文件要保存的路径   
  32. *   
  33. * @throws IOException 如果创建保存路径失败   
  34. */   
  35. Server(int listenPort, String savePath) throws IOException {   
  36. this.listenPort = listenPort;   
  37. this.savePath = savePath;   
  38.   
  39. File file = new File(savePath);   
  40. if (!file.exists() && !file.mkdirs()) {   
  41. throw new IOException("无法创建文件夹 " + savePath);   
  42. }   
  43. }   
  44.   
  45. // 开始侦听   
  46. public void start() {   
  47. new ListenThread().start();   
  48. }   
  49.   
  50. // 网上抄来的，将字节转成 int。b 长度不得小于 4，且只会取前 4 位。   
  51. public static int b2i(byte[] b) {   
  52. int value = 0;   
  53. for (int i = 0; i < 4; i++) {   
  54. int shift = (4 - 1 - i) * 8;   
  55. value += (b[i] & 0x000000FF) << shift;   
  56. }   
  57. return value;   
  58. }   
  59.   
  60.   
  61. /**   
  62. * 侦听线程   
  63. */   
  64. private class ListenThread extends Thread {   
  65.   
  66. @Override   
  67. public void run() {   
  68. try {   
  69. ServerSocket server = new ServerSocket(listenPort);   
  70.   
  71. // 开始循环   
  72. while (true) {   
  73. Socket socket = server.accept();   
  74. new HandleThread(socket).start();   
  75. }   
  76. } catch (IOException e) {   
  77. e.printStackTrace();   
  78. }   
  79. }   
  80. }   
  81.   
  82. /**   
  83. * 读取流并保存文件的线程   
  84. */   
  85. private class HandleThread extends Thread {   
  86.   
  87. private Socket socket;   
  88.   
  89. private HandleThread(Socket socket) {   
  90. this.socket = socket;   
  91. }   
  92.   
  93. @Override   
  94. public void run() {   
  95. try {   
  96. InputStream is = socket.getInputStream();   
  97. readAndSave(is);   
  98. } catch (IOException e) {   
  99. e.printStackTrace();   
  100. } finally {   
  101. try {   
  102. socket.close();   
  103. } catch (IOException e) {   
  104. // nothing to do   
  105. }   
  106. }   
  107. }   
  108.   
  109. // 从流中读取内容并保存   
  110. private void readAndSave(InputStream is) throws IOException {   
  111. String filename = getFileName(is);   
  112. int file_len = readInteger(is);   
  113. System.out.println("接收文件：" + filename + "，长度：" + file_len);   
  114.   
  115. readAndSave0(is, savePath + filename, file_len);   
  116.   
  117. System.out.println("文件保存成功（" + file_len + "字节）。");   
  118. }   
  119.   
  120. private void readAndSave0(InputStream is, String path, int file_len) throws IOException {   
  121. FileOutputStream os = getFileOS(path);   
  122. readAndWrite(is, os, file_len);   
  123. os.close();   
  124. }   
  125.   
  126. // 边读边写，直到读取 size 个字节   
  127. private void readAndWrite(InputStream is, FileOutputStream os, int size) throws IOException {   
  128. byte[] buffer = new byte[4096];   
  129. int count = 0;   
  130. while (count < size) {   
  131. int n = is.read(buffer);   
  132. // 这里没有考虑 n = -1 的情况   
  133. os.write(buffer, 0, n);   
  134. count += n;   
  135. }   
  136. }   
  137.   
  138. // 读取文件名   
  139. private String getFileName(InputStream is) throws IOException {   
  140. int name_len = readInteger(is);   
  141. byte[] result = new byte[name_len];   
  142. is.read(result);   
  143. return new String(result);   
  144. }   
  145.   
  146. // 读取一个数字   
  147. private int readInteger(InputStream is) throws IOException {   
  148. byte[] bytes = new byte[4];   
  149. is.read(bytes);   
  150. return b2i(bytes);   
  151. }   
  152.   
  153. // 创建文件并返回输出流   
  154. private FileOutputStream getFileOS(String path) throws IOException {   
  155. File file = new File(path);   
  156. if (!file.exists()) {   
  157. file.createNewFile();   
  158. }   
  159.   
  160. return new FileOutputStream(file);   
  161. }   
  162. }   
  163. }   
import java.io.*; 
import java.net.ServerSocket; 
import java.net.Socket; 

/** 
* 简单的文件发送与接收示例 
*/ 
public class FileTrasmission { 

//程序入口 
public static void main(String[] args) throws Exception { 
int port = 7788; 
new Server(port, "c://save//").start(); 
new Client().sendFile("127.0.0.1", port, "c://迷失在康熙末年.txt"); 
} 
} 

/** 
* 接收端。可同时接收多个发送端发来的文件。但如果发来的文件是同名的话那就乱了。 
*/ 
class Server { 

private int listenPort; 

private String savePath; 

/** 
* 构造方法 
* 
* @param listenPort 侦听端口 
* @param savePath 接收的文件要保存的路径 
* 
* @throws IOException 如果创建保存路径失败 
*/ 
Server(int listenPort, String savePath) throws IOException { 
this.listenPort = listenPort; 
this.savePath = savePath; 

File file = new File(savePath); 
if (!file.exists() && !file.mkdirs()) { 
throw new IOException("无法创建文件夹 " + savePath); 
} 
} 

// 开始侦听 
public void start() { 
new ListenThread().start(); 
} 

// 网上抄来的，将字节转成 int。b 长度不得小于 4，且只会取前 4 位。 
public static int b2i(byte[] b) { 
int value = 0; 
for (int i = 0; i < 4; i++) { 
int shift = (4 - 1 - i) * 8; 
value += (b[i] & 0x000000FF) << shift; 
} 
return value; 
} 


/** 
* 侦听线程 
*/ 
private class ListenThread extends Thread { 

@Override 
public void run() { 
try { 
ServerSocket server = new ServerSocket(listenPort); 

// 开始循环 
while (true) { 
Socket socket = server.accept(); 
new HandleThread(socket).start(); 
} 
} catch (IOException e) { 
e.printStackTrace(); 
} 
} 
} 

/** 
* 读取流并保存文件的线程 
*/ 
private class HandleThread extends Thread { 

private Socket socket; 

private HandleThread(Socket socket) { 
this.socket = socket; 
} 

@Override 
public void run() { 
try { 
InputStream is = socket.getInputStream(); 
readAndSave(is); 
} catch (IOException e) { 
e.printStackTrace(); 
} finally { 
try { 
socket.close(); 
} catch (IOException e) { 
// nothing to do 
} 
} 
} 

// 从流中读取内容并保存 
private void readAndSave(InputStream is) throws IOException { 
String filename = getFileName(is); 
int file_len = readInteger(is); 
System.out.println("接收文件：" + filename + "，长度：" + file_len); 

readAndSave0(is, savePath + filename, file_len); 

System.out.println("文件保存成功（" + file_len + "字节）。"); 
} 

private void readAndSave0(InputStream is, String path, int file_len) throws IOException { 
FileOutputStream os = getFileOS(path); 
readAndWrite(is, os, file_len); 
os.close(); 
} 

// 边读边写，直到读取 size 个字节 
private void readAndWrite(InputStream is, FileOutputStream os, int size) throws IOException { 
byte[] buffer = new byte[4096]; 
int count = 0; 
while (count < size) { 
int n = is.read(buffer); 
// 这里没有考虑 n = -1 的情况 
os.write(buffer, 0, n); 
count += n; 
} 
} 

// 读取文件名 
private String getFileName(InputStream is) throws IOException { 
int name_len = readInteger(is); 
byte[] result = new byte[name_len]; 
is.read(result); 
return new String(result); 
} 

// 读取一个数字 
private int readInteger(InputStream is) throws IOException { 
byte[] bytes = new byte[4]; 
is.read(bytes); 
return b2i(bytes); 
} 

// 创建文件并返回输出流 
private FileOutputStream getFileOS(String path) throws IOException { 
File file = new File(path); 
if (!file.exists()) { 
file.createNewFile(); 
} 

return new FileOutputStream(file); 
} 
} 
}
[html] view plain copy print ?
  1. /**   
  2. * 发送端   
  3. */   
  4. class Client {   
  5.   
  6. // 网上抄来的，将 int 转成字节   
  7. public static byte[] i2b(int i) {   
  8. return new byte[]{   
  9. (byte) ((i >> 24) & 0xFF),   
  10. (byte) ((i >> 16) & 0xFF),   
  11. (byte) ((i >> 8) & 0xFF),   
  12. (byte) (i & 0xFF)   
  13. };   
  14. }   
  15.   
  16. /**   
  17. * 发送文件。文件大小不能大于 {@link Integer#MAX_VALUE}   
  18. *   
  19. * @param hostname 接收端主机名或 IP 地址   
  20. * @param port 接收端端口号   
  21. * @param filepath 文件路径   
  22. *   
  23. * @throws IOException 如果读取文件或发送失败   
  24. */   
  25. public void sendFile(String hostname, int port, String filepath) throws IOException {   
  26. File file = new File(filepath);   
  27. FileInputStream is = new FileInputStream(filepath);   
  28.   
  29. Socket socket = new Socket(hostname, port);   
  30. OutputStream os = socket.getOutputStream();   
  31.   
  32. try {   
  33. int length = (int) file.length();   
  34. System.out.println("发送文件：" + file.getName() + "，长度：" + length);   
  35.   
  36. // 发送文件名和文件内容   
  37. writeFileName(file, os);   
  38. writeFileContent(is, os, length);   
  39. } finally {   
  40. os.close();   
  41. is.close();   
  42. }   
  43. }   
  44.   
  45. // 输出文件内容   
  46. private void writeFileContent(InputStream is, OutputStream os, int length) throws IOException {   
  47. // 输出文件长度   
  48. os.write(i2b(length));   
  49.   
  50. // 输出文件内容   
  51. byte[] buffer = new byte[4096];   
  52. int size;   
  53. while ((size = is.read(buffer)) != -1) {   
  54. os.write(buffer, 0, size);   
  55. }   
  56. }   
  57.   
  58. // 输出文件名   
  59. private void writeFileName(File file, OutputStream os) throws IOException {   
  60. byte[] fn_bytes = file.getName().getBytes();   
  61.   
  62. os.write(i2b(fn_bytes.length)); // 输出文件名长度   
  63. os.write(fn_bytes); // 输出文件名   
  64. }   
  65. }  
/** 
* 发送端 
*/ 
class Client { 

// 网上抄来的，将 int 转成字节 
public static byte[] i2b(int i) { 
return new byte[]{ 
(byte) ((i >> 24) & 0xFF), 
(byte) ((i >> 16) & 0xFF), 
(byte) ((i >> 8) & 0xFF), 
(byte) (i & 0xFF) 
}; 
} 

/** 
* 发送文件。文件大小不能大于 {@link Integer#MAX_VALUE} 
* 
* @param hostname 接收端主机名或 IP 地址 
* @param port 接收端端口号 
* @param filepath 文件路径 
* 
* @throws IOException 如果读取文件或发送失败 
*/ 
public void sendFile(String hostname, int port, String filepath) throws IOException { 
File file = new File(filepath); 
FileInputStream is = new FileInputStream(filepath); 

Socket socket = new Socket(hostname, port); 
OutputStream os = socket.getOutputStream(); 

try { 
int length = (int) file.length(); 
System.out.println("发送文件：" + file.getName() + "，长度：" + length); 

// 发送文件名和文件内容 
writeFileName(file, os); 
writeFileContent(is, os, length); 
} finally { 
os.close(); 
is.close(); 
} 
} 

// 输出文件内容 
private void writeFileContent(InputStream is, OutputStream os, int length) throws IOException { 
// 输出文件长度 
os.write(i2b(length)); 

// 输出文件内容 
byte[] buffer = new byte[4096]; 
int size; 
while ((size = is.read(buffer)) != -1) { 
os.write(buffer, 0, size); 
} 
} 

// 输出文件名 
private void writeFileName(File file, OutputStream os) throws IOException { 
byte[] fn_bytes = file.getName().getBytes(); 

os.write(i2b(fn_bytes.length)); // 输出文件名长度 
os.write(fn_bytes); // 输出文件名 
} 
}

看起来很复杂的样子，对于一个刚刚接触的人来说却是不怎么容易理解，那么这是一个怎么样的逻辑的，我们分析一下就会变得比较简单了；

首先来讲这个例子是说一个完整的文件传输包括文件大小，文件名称，文件内容。显然对于我们来说要一个个得来。对于文件大小文件名称，我们完全可以用一个固定的常量来代替，这样就大大简化了代码的复杂度，最终也就变成了如何传送文件内容！

1，读取文件内容，

2，发送内容，

说起来好简单的样子但是要怎么做呢？

[html] view plain copy print ?
  1. FileInputStream is = new FileInputStream(this.FilePath);  
  2.             byte Buffer[] = new byte[1024 * 8];  
  3.         while ((size = is.read(buffer)) != -1) {  
  4.             //System.out.println(size + "  ");  
  5.             outputstream.write(buffer, 0, size);  
  6.         }  
FileInputStream is = new FileInputStream(this.FilePath);
	        byte Buffer[] = new byte[1024 * 8];
		while ((size = is.read(buffer)) != -1) {
			//System.out.println(size + "  ");
			outputstream.write(buffer, 0, size);
		}

客户端怎么接收呢？

[html] view plain copy print ?
  1. InputStream inputStream = socket.getInputStream();  
InputStream inputStream = socket.getInputStream();
[html] view plain copy print ?
  1. int Size;  
int Size;
[html] view plain copy print ?
  1. byte Buffer[] = new byte[1024 * 8];  
  2. while ((Size = inputStream.read(Buffer)) != -1) {  
  3.          System.out.print(Size + " ");  
byte Buffer[] = new byte[1024 * 8];
while ((Size = inputStream.read(Buffer)) != -1) {
	     System.out.print(Size + " ");
[html] view plain copy print ?
  1. system.out.print(new String11(b<SPAN style="FONT-FAMILY: Arial, Helvetica, sans-serif">uffer</SPAN><SPAN style="FONT-FAMILY: Arial, Helvetica, sans-serif">));//此处文档显示有问题所以加了个11，源码需要去掉！</SPAN>  
             system.out.print(new String11(b<span style="FONT-FAMILY: Arial, Helvetica, sans-serif">uffer</span><span style="FONT-FAMILY: Arial, Helvetica, sans-serif">));//此处文档显示有问题所以加了个11，源码需要去掉！</span>
[html] view plain copy print ?
  1. }  
		}
这样看起来是不是就没那么复杂了呢 ，其实很多东西动手自己做，你会发现是如此的简单！


dyf20081124
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java socketserver服务端接收C客户端发送的结构体数据
qq_40384776的博客
12-26 550
JAVA接收结构体数据 java服务端解析对应结构体数据 class RecvStruct{ byte[] recv; private int velocity; private int acceleration; private int altitude; private long lon; pr...
java和c语言tcp通信和文件传送
04-24
一个java语言写的客户端连接C语言写的socket服务器根据tcp进行通信和文件发送
C#SOCKET大文件传输.zip
05-16
C# 实现的SOCKET大文件传输，支持高并发，断点续传等，是学习SOCKET通信的经典案例，走过路过不要错过！！！！！！
Java传递音频给PC端C#程序<一>
WeiLin
03-17 606
最近项目有这么一个需求，把Android手机的mp3文件以TCP的传输方式传递到Win10的C#程序上，并且附带歌名等信息。 PC端的要求是传递一个序列化后的文件过去，里面包含了文件本体和文件名等信息。 格式如下： 方式有很多种，比如把所有信息转成字节传递过去，但是告知对方在哪里是什么，这种很麻烦；把文件转成byte[]后放入一个类中，该类携带歌曲信息以byte[]发送过去。
java socket发送json_C#(服务器)与Java(客户端)通过Socket传递对象(序列化 json)
weixin_33521678的博客
02-16 485
下面详细讲解实现的关键步骤：通信关键：C#和java用Socket通信，发送数据和接收数据可以统一采用UTF-8编码，经过测试，使用UTF-8编码可以成功传递对象。对于Socket技术，发送数据之前，一般将字符串转换成字节数组，然后发送字节数组；接收数据时，收到的也是字节数组，很多时候需要转换成字符串后使用。下边是一些常用的转换。C#语言字符串转换成UTF-8字节数组：byte[] b = Enc...
java 调用 webapi_java调用c#webapi的接口实现文件上传
weixin_33313117的博客
02-21 168
import java.io.File;import java.io.IOException;import java.nio.charset.Charset;import java.util.HashMap;import java.util.Map;import java.util.Set;import org.apache.http.Consts;import org.apache.http.H...
java实现websocket客户端_Java服务端与C#客户端实现websocket通信（发送消息和文件）...
weixin_34534456的博客
02-16 557
设计思路使用websocket通信，客户端采用C#开发界面，服务端使用Java开发，最终实现Java服务端向C#客户端发送消息和文件，C#客户端实现语音广播的功能。Java服务端设计package servlet.websocket;import java.io.IOException;import java.util.Map;import java.util.concurrent.Concurr...
利用socket实现C和java通信
qq_39740416的博客
01-14 922
由于项目需求，需要后端的java和Linux C进行通信，在此用socket本机通信的方式来实现，并将调试过可以通信的例程代码贴过来，其中大部分代码是通过网络获取的，自己经过了简单的调试。首先C程序作为服务器端，java作为客户端，实现的功能为：java客户端向C语言服务器端发送字符串，服务器端收到后把收到的字符串原封不动的发回客户端，客户端接收后再终端显示，如果java客户端发送"ip"字段，服务器端回复"1.1.1.1"的ip地址到Java客户端。Java客户端代码（test1.java）
C++和java通过Socket批量发送和接收文件（C++客户端发送，java服务端接收）
u014080185的博客
11-30 3826
C++客户端代码： #include #include #include #include #include #include #pragma comment(lib,"ws2_32.lib") using namespace std; size_t getSize(string path) { FILE * file; file = fopen(path.c_str
java与c之间用socket传输数据
HunterLeo的专栏
03-12 705
java与c之间用socket传输数据,java 虚拟机采用大端字节序，High-byte frist。
java 与C语言使用socket通信传递结构体数据
09-27
java 语言模拟C语言的结构体，以方便java 与C语言使用socket通信。
关于C语言 socket数据 文件传输的例子
07-14
关于C语言 socket数据 文件传输的例子，包括发送端和接受端，可以传输文件或者数据
Java使用Socket通信传输文件的方法示例
08-30
主要介绍了Java使用Socket通信传输文件的方法,结合实例形式分析了java socket编程实现文件传输操作的相关技巧,需要的朋友可以参考下
java Socket与C#通信中中文乱码问题的解决方案
12-22
近正在做一个项目，其中遇到了一个问题是java与.NET之间的通信问题。具体的问题是这样的： 　客户端使用java，服务器端使用的是C#。两者之间使用基于TCP的Socket通信方式。可是，做了一个测试小例子，结果从客户端...
qt与java之间socket通讯
01-25
qt与javasocket通讯，消息格式类似json。qt部分充当服务端。
Java中Socket通信-客户端与服务端相互传输对象数据示例代码.rar
09-10
在计算机通信领域，socket 被翻译为“套接字”，它是计算机之间进行通信的一种约定或一种方式。通过 socket 这种约定，一台计算机可以接收其他计算机的数据，也可以向其他计算机发送数据。 socket 的典型应用就是 ...
关于__Federico Milano 的电力系统分析工具箱.zip
最新发布
04-26
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
mlab-upenn 研究小组的心脏模型模拟.zip
04-26
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
java socket通信传输list
05-21
Java的Socket通信可以传输任何可序列化的对象，包括List。 传输List需要注意以下几点： 1. List中的元素也必须是可序列化的对象。 2. 在发送端将List转换为字节数组，然后发送字节数组；在接收端接收字节数组，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值