⑴ 怎么用java的socket进行文件传输谁能给个简单的例子，包括发送端和接收端。
java中的网络信息传输方式是基于TCP协议或者UD协议P的,socket是基于TCP协议的
例子1
（1）客户端程序：
import java.io.*;
import java.net.*;
public class Client
{ public static void main(String args[])
{ String s=null;
Socket mysocket;
DataInputStream in=null;
DataOutputStream out=null;
try{
mysocket=new Socket("localhost",4331);
in=new DataInputStream(mysocket.getInputStream());
out=new DataOutputStream(mysocket.getOutputStream());
out.writeUTF("你好！");//通过 out向"线路"写入信息。
while(true)
{
s=in.readUTF();//通过使用in读取服务器放入"线路"里的信息。堵塞状态，
//除非读取到信息。
out.writeUTF(":"+Math.random());
System.out.println("客户收到:"+s);
Thread.sleep(500);
}
}
catch(IOException e)
{ System.out.println("无法连接");
}
catch(InterruptedException e){}
}
}
（2）服务器端程序：
import java.io.*;import java.net.*;
public class Server
{ public static void main(String args[])
{ ServerSocket server=null;
Socket you=null;String s=null;
DataOutputStream out=null;DataInputStream in=null;
try{ server=new ServerSocket(4331);}
catch(IOException e1){System.out.println("ERRO:"+e1);}
try{ you=server.accept();
in=new DataInputStream(you.getInputStream());
out=new DataOutputStream(you.getOutputStream());
while(true)
{
s=in.readUTF();// 通过使用in读取客户放入"线路"里的信息。堵塞状态，
//除非读取到信息。
out.writeUTF("你好:我是服务器");//通过 out向"线路"写入信息.
out.writeUTF("你说的数是:"+s);
System.out.println("服务器收到:"+s);
Thread.sleep(500);
}
}
catch(IOException e)
{ System.out.println(""+e);
}
catch(InterruptedException e){}
}
}
例子(2)
(1) 客户端
import java.net.*;import java.io.*;
import java.awt.*;import java.awt.event.*;
import java.applet.*;
public class Computer_client extends Applet implements Runnable,ActionListener
{ Button 计算;TextField 输入三边长度文本框,计算结果文本框;
Socket socket=null;
DataInputStream in=null; DataOutputStream out=null;
Thread thread;
public void init()
{ setLayout(new GridLayout(2,2));
Panel p1=new Panel(),p2=new Panel();
计算=new Button(" 计算");
输入三边长度文本框=new TextField(12);计算结果文本框=new TextField(12);
p1.add(new Label("输入三角形三边的长度,用逗号或空格分隔:"));
p1.add( 输入三边长度文本框);
p2.add(new Label("计算结果："));p2.add(计算结果文本框);p2.add(计算);
计算.addActionListener(this);
add(p1);add(p2);
}
public void start()
{ try
{ //和小程序所驻留的服务器建立套接字连接：
socket = new Socket(this.getCodeBase().getHost(), 4331);
in =new DataInputStream(socket.getInputStream());
out = new DataOutputStream(socket.getOutputStream());
}
catch (IOException e){}
if(thread == null)
{ thread = new Thread(this);
thread.start();
}
}
public void run()
{ String s=null;
while(true)
{ try{ s=in.readUTF();//堵塞状态，除非读取到信息。
计算结果文本框.setText(s);
}
catch(IOException e)
{ 计算结果文本框.setText("与服务器已断开");
break;
}
}
}
public void actionPerformed(ActionEvent e)
{ if(e.getSource()==计算)
{ String s=输入三边长度文本框.getText();
if(s!=null)
{ try { out.writeUTF(s);
}
catch(IOException e1){}
}
}
}
}
(2) 服务器端
import java.io.*;import java.net.*;
import java.util.*;import java.sql.*;
public class Computer_server
{ public static void main(String args[])
{ ServerSocket server=null;Server_thread thread;
Socket you=null;
while(true)
{ try{ server=new ServerSocket(4331);
}
catch(IOException e1)
{ System.out.println("正在监听"); //ServerSocket对象不能重复创建。
}
try{ you=server.accept();
System.out.println("客户的地址:"+you.getInetAddress());
}
catch (IOException e)
{ System.out.println("正在等待客户");
}
if(you!=null)
{ new Server_thread(you).start(); //为每个客户启动一个专门的线程。
}
else
{ continue;
}
}
}
}
class Server_thread extends Thread
{ Socket socket;Connection Con=null;Statement Stmt=null;
DataOutputStream out=null;DataInputStream in=null;int n=0;
String s=null;
Server_thread(Socket t)
{ socket=t;
try { in=new DataInputStream(socket.getInputStream());
out=new DataOutputStream(socket.getOutputStream());
}
catch (IOException e)
{}
}
public void run()
{ while(true)
{ double a[]=new double[3] ;int i=0;
try{ s=in.readUTF();堵塞状态，除非读取到信息。
StringTokenizer fenxi=new StringTokenizer(s," ,");
while(fenxi.hasMoreTokens())
{ String temp=fenxi.nextToken();
try{ a[i]=Double.valueOf(temp).doubleValue();i++;
}
catch(NumberFormatException e)
{ out.writeUTF("请输入数字字符");
}
}
double p=(a[0]+a[1]+a[2])/2.0;
out.writeUTF(" "+Math.sqrt(p*(p-a[0])*(p-a[1])*(p-a[2])));
sleep(2);
}
catch(InterruptedException e){}
catch (IOException e)
{ System.out.println("客户离开");
break;
}
}
}
}
这些例子都是Java2实用教程上的.
⑵ java socket 如何发送一个结构体消息，java中结构体是个什么概念...
有一个socket 程序，一端是c++写的socket 服务程序
另一端是Java写客户端程序，两者之间需要通信。
c++/c接收和发送的都是结构体，而Java是直接发送的字节流或者byte 数组。
解决方法：c++/c socket 在发送结构体的时候其实发送的也是字节流。因为结构体本身也是内存中的一块连续数据。问题就变成了如何把结构体手动转成字节的问题了
采用类似的报头：
// packet head
typedef struct tagPacketHead{
long PacketID;
long PacketLen;
}PacketHead;此时套接口的读写方式为先读报头，在报头中取出数据负载的长度，然后再读相应字节的数据。
包头后面跟上包体，其中包体的长度，就是上面结构体中的PacketLen，Clinet首先接受包头，因为包头是两边约定好的，所以可以直接Receive一个定长的消息，也就是这个包头的长度的消息，从包头中取得包体的长度后，就可以再次Receive一个包体长度的消息了。那么Java中如何发送一个结构体呢？下面是解决方法：
使用C/S模式，Client为VC6开发，Server为Java，通过Socket通信。
package org.charry.org;
import java.net.*;
/**
*
* 字节转换，参考网络文章
*/
class Packet {
private byte[] buf = null;
/**
* 将int转为低字节在前，高字节在后的byte数组
*/
private static byte[] toLH(int n) {
byte[] b = new byte[4];
b[0] = (byte) (n & 0xff);
b[1] = (byte) (n >> 8 & 0xff);
b[2] = (byte) (n >> 16 & 0xff);
b[3] = (byte) (n >> 24 & 0xff);
return b;
}
/**
* 将float转为低字节在前，高字节在后的byte数组
*/
private static byte[] toLH(float f) {
return toLH(Float.floatToRawIntBits(f));
}
/**
* 构造并转换
*/
public Packet(int packetID, int packetLen, String packetBody) {
byte[] temp = null;
buf = new byte[packetBody.getBytes().length + 8];
temp = toLH(packetID);
System.array(temp, 0, buf, 0, temp.length);
temp = toLH(packetLen);
System.array(temp, 0, buf, 4, temp.length);
System.array(packetBody.getBytes(), 0, buf, 8, packetBody.length());
}
/**
* 返回要发送的数组
*/
public byte[] getBuf() {
return buf;
}
/**
* 发送测试
*/
public static void main(String[] args) {
try {
String tmp = “test string!”;
Socket sock = new Socket(”127.0.0.1″, 8888);
sock.getOutputStream().write(
new Packet(123, tmp.length(), tmp).getBuf());
sock.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
如果需要用Java 接收结构体的话只需要将上面过程逆过来即可。
⑶ 如何通过Socket TCP发送并接收一个文件
主要是你通过socket api封装要发送的数据，内部会自动封装成数据流进行传输。
1，什么是Socket
网络上的两个程序通过一个双向的通讯连接实现数据的交换，这个双向链路的一端称为一个Socket。Socket通常用来实现客户方和服务方的连接。Socket是TCP/IP协议的一个十分流行的编程界面，一个Socket由一个IP地址和一个端口号唯一确定。
但是，Socket所支持的协议种类也不光TCP/IP一种，因此两者之间是没有必然联系的。在Java环境下，Socket编程主要是指基于TCP/IP协议的网络编程。
2，Socket通讯的过程
Server端Listen(监听)某个端口是否有连接请求，Client端向Server 端发出Connect(连接)请求，Server端向Client端发回Accept（接受）消息。一个连接就建立起来了。Server端和Client 端都可以通过Send，Write等方法与对方通信。
对于一个功能齐全的Socket，都要包含以下基本结构，其工作过程包含以下四个基本的步骤：
（1） 创建Socket；
（2） 打开连接到Socket的输入/出流；
（3） 按照一定的协议对Socket进行读/写操作；
（4） 关闭Socket.（在实际应用中，并未使用到显示的close，虽然很多文章都推荐如此，不过在我的程序中，可能因为程序本身比较简单，要求不高，所以并未造成什么影响。）
3，创建Socket
创建Socket
java在包java.net中提供了两个类Socket和ServerSocket，分别用来表示双向连接的客户端和服务端。这是两个封装得非常好的类，使用很方便。其构造方法如下：
Socket(InetAddress address, int port);
Socket(InetAddress address, int port, boolean stream);
Socket(String host, int prot);
Socket(String host, int prot, boolean stream);
Socket(SocketImpl impl)
Socket(String host, int port, InetAddress localAddr, int localPort)
Socket(InetAddress address, int port, InetAddress localAddr, int localPort)
ServerSocket(int port);
ServerSocket(int port, int backlog);
ServerSocket(int port, int backlog, InetAddress bindAddr)
Socket client = new Socket("127.0.01.", 80);
ServerSocket server = new ServerSocket(80);
在创建socket时如果发生错误，将产生IOException，在程序中必须对之作出处理。所以在创建Socket或ServerSocket是必须捕获或抛出例外。
⑷ java中socket同时传递不同类型流的问题
不是很明白你为什么这么做，一般是只会封装一个输入流，不会分开两个来回获取数据的。
流底层都是答二进制数据流，无论你用什么流去读都是读同样的数据，声明两个输出流输出后，对于客户端还是只能看到一个流输入，不会给你分开的。所以这里你开两个子进程读，就会出现谁运行快就把数据读出来了，而且看你PrintWriter也没有flush，所以应该只传输了list数据，客户端BufferedReader先运行，就把数据读出来了。
正确的做法是你先要决定服务器与客户端的数据交换方式，到底是基于二进制、指定编码的字符还是对象？看你上面的情况，你想传输一个list，二进制和指定编码字符都比较麻烦，你需要把list通过某种转换成二进制或者是字符(通常是转成XML)。比较简单的就是像你上面那样传输对象，msg是个String对象，本身就可以用ObjectOutputStream传输，没有必要再用一个PrintWriter传输。
⑸ java socket如何实现一次传送多个文件
很简单，复就是把多制个文件“变成”一个文件传送就可以了，每个文件都是一个流，把这些流输入到一个流中合并流传输即可，这个是基本思路。实现差不多以下两个方法
1、直接流拼接，循环要传输的文件列表，多个InputStream，然后输出到一个OutputStream，这个out就是发送数据的端口，为了接收端能够识别每个文件从而分割流，需要每个流中结尾添加分隔符。其实这就是HTTP文件上传的做法。
2、就比较简单了，职业使用ZIP工具包吧需要传输的多文件压缩成一个文件传输，接收端直接解压缩就完事。
需要注意的是，发送多文件上传你需要提取计算好总传输量字节大小放在传输报文头部告诉接收端你要发送的数据有多大，不然接收端可能无法完整接收数据。
⑹ java socket多文件传输问题
参考思路：
1.先传文件名跟文件大小到 server。
2.开始传文件。
3.告诉server传完了。
4.客户端开始传下一个，重复123。
参考简单代码：
long fileLength;
int readLength;
long totalLength;
for (...)
{
// 读取文件名
// 读取文件长度保存到fileLength中
// 将totalLength置为0
while (1)
{
// 读取数据流，将实际读取的字节数保存在readLength中
totalLength += readLength;
if (totalLength >= fileLength) // 一个文件读取完成，break
// 这样就差不多了，不过这会把下一个文件的信息读到当前文件中来。
// 思路是fileLength - totalLength小于等于你设置的缓冲区长度时读取长度就是fileLength - totalLength
}
}