javasocket工具

A. 用java socket实现一个服务器对多个客户端的文件传输

通过socket可以用如下方式进行。
1.启动服务端代码。
2.启动客户端自动连接服务端。
3.服务端上传文件，保存文件和路径。
4.将路径发送给连接服务端的客户端。

B. java的socket有换行符导致连接关闭

在Java中，Socket是一种用于建立与服务端之间的连接的工具。如果服务端采用的是“readLine”方法读取请含御求信息，那么客户端在发送请求时，必须进行换行符谈猜的处理。因为readLine()方法是通过判断"/n"（换行）来判断请求的完整性的，如果客户端没有正确地在请求信息后面加上换行符，服务端将会等待很长一段时间，最终导致连接关闭。因此，客户端在发送请求时，应该使用“\r
”来表含老型示换行符，这样服务端才能够正确地读取请求信息。此外，在使用Socket进行数据传输时，时刻注意进行字符编码的一致性，即客户端与服务端应该使用相同的编码格式，否则也会导致数据传输出现问题。

C. 网上的Java基于Socket文件传输示例，一个客户端一个服务器端一个socket的Util辅助类怎么运行起来啊

服务器（Server）返让

[java] view plain
package com.socket.sample;

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerTest {
int port = 8821;

void start() {
Socket s = null;
try {
ServerSocket ss = new ServerSocket(port);
while (true) {
// 选择进行传输的文件
String filePath = "D:\\lib.rar";
File fi = new File(filePath);

System.out.println("文件长度:" + (int) fi.length());

// public Socket accept() throws
// IOException侦听并接受到此套接字的连接。此方法在进行连接之前一直阻塞。

s = ss.accept();
System.out.println("建立socket链接");
DataInputStream dis = new DataInputStream(
new BufferedInputStream(s.getInputStream()));
dis.readByte();

DataInputStream fis = new DataInputStream(
new BufferedInputStream(new FileInputStream(filePath)));
DataOutputStream ps = new DataOutputStream(s.getOutputStream());
// 将文件名及长度传给客户端。这里要真正适用所有贺世歼平台，例如中文名的处理，禅冲还需要加工，具体可以参见Think In Java
// 4th里有现成的代码。
ps.writeUTF(fi.getName());
ps.flush();
ps.writeLong((long) fi.length());
ps.flush();

int bufferSize = 8192;
byte[] buf = new byte[bufferSize];

while (true) {
int read = 0;
if (fis != null) {
read = fis.read(buf);
// 从包含的输入流中读取一定数量的字节，并将它们存储到缓冲区数组 b
// 中。以整数形式返回实际读取的字节数。在输入数据可用、检测到文件末尾 (end of file)
// 或抛出异常之前，此方法将一直阻塞。
}

if (read == -1) {
break;
}
ps.write(buf, 0, read);
}
ps.flush();
// 注意关闭socket链接哦，不然客户端会等待server的数据过来，
// 直到socket超时，导致数据不完整。
fis.close();
s.close();
System.out.println("文件传输完成");
}

} catch (Exception e) {
e.printStackTrace();
}
}

public static void main(String arg[]) {
new ServerTest().start();
}
}
客户端工具（SocketTool）
[java] view plain
package com.socket.sample;

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.Socket;

public class ClientSocket {
private String ip;

private int port;

private Socket socket = null;

DataOutputStream out = null;

DataInputStream getMessageStream = null;

public ClientSocket(String ip, int port) {
this.ip = ip;
this.port = port;
}

/** */
/**
* 创建socket连接
*
* @throws Exception
* exception
*/
public void CreateConnection() throws Exception {
try {
socket = new Socket(ip, port);
} catch (Exception e) {
e.printStackTrace();
if (socket != null)
socket.close();
throw e;
} finally {
}
}

public void sendMessage(String sendMessage) throws Exception {
try {
out = new DataOutputStream(socket.getOutputStream());
if (sendMessage.equals("Windows")) {
out.writeByte(0x1);
out.flush();
return;
}
if (sendMessage.equals("Unix")) {
out.writeByte(0x2);
out.flush();
return;
}
if (sendMessage.equals("Linux")) {
out.writeByte(0x3);
out.flush();
} else {
out.writeUTF(sendMessage);
out.flush();
}
} catch (Exception e) {
e.printStackTrace();
if (out != null)
out.close();
throw e;
} finally {
}
}

public DataInputStream getMessageStream() throws Exception {
try {
getMessageStream = new DataInputStream(new BufferedInputStream(
socket.getInputStream()));
return getMessageStream;
} catch (Exception e) {
e.printStackTrace();
if (getMessageStream != null)
getMessageStream.close();
throw e;
} finally {
}
}

public void shutDownConnection() {
try {
if (out != null)
out.close();
if (getMessageStream != null)
getMessageStream.close();
if (socket != null)
socket.close();
} catch (Exception e) {

}
}
}

客户端（Client）

[java] view plain
package com.socket.sample;

import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;

public class ClientTest {
private ClientSocket cs = null;

private String ip = "localhost";// 设置成服务器IP

private int port = 8821;

private String sendMessage = "Windows";

public ClientTest() {
try {
if (createConnection()) {
sendMessage();
getMessage();
}

} catch (Exception ex) {
ex.printStackTrace();
}
}

private boolean createConnection() {
cs = new ClientSocket(ip, port);
try {
cs.CreateConnection();
System.out.print("连接服务器成功!" + "\n");
return true;
} catch (Exception e) {
System.out.print("连接服务器失败!" + "\n");
return false;
}

}

private void sendMessage() {
if (cs == null)
return;
try {
cs.sendMessage(sendMessage);
} catch (Exception e) {
System.out.print("发送消息失败!" + "\n");
}
}

private void getMessage() {
if (cs == null)
return;
DataInputStream inputStream = null;
try {
inputStream = cs.getMessageStream();
} catch (Exception e) {
System.out.print("接收消息缓存错误\n");
return;
}

try {
// 本地保存路径，文件名会自动从服务器端继承而来。
String savePath = "E:\\";
int bufferSize = 8192;
byte[] buf = new byte[bufferSize];
int passedlen = 0;
long len = 0;

savePath += inputStream.readUTF();
DataOutputStream fileOut = new DataOutputStream(
new BufferedOutputStream(new FileOutputStream(savePath)));
len = inputStream.readLong();

System.out.println("文件的长度为:" + len + "\n");
System.out.println("开始接收文件!" + "\n");

while (true) {
int read = 0;
if (inputStream != null) {
read = inputStream.read(buf);
}
passedlen += read;
if (read == -1) {
break;
}
// 下面进度条本为图形界面的prograssBar做的，这里如果是打文件，可能会重复打印出一些相同的百分比
System.out.println("文件接收了" + (passedlen * 100 / len) + "%\n");
fileOut.write(buf, 0, read);
}
System.out.println("接收完成，文件存为" + savePath + "\n");

fileOut.close();
} catch (Exception e) {
System.out.println("接收消息错误" + "\n");
return;
}
}

public static void main(String arg[]) {
new ClientTest().getMessage();
}
}

测试是成功的，在DOS命令行下编译~~~

D. java中的socket编程是作什么的

Socket,又称为套接字，Socket是计算机网络通信的基本的技术之一。如今大多数基于网络的软件，如浏览器，即时通讯工具甚至是P2P下载都是基于Socket实现的。本文会介绍一下基于TCP/IP的Socket编程，并且如何写一个客户端/服务器程序。
方法/步骤

Java中的socket编程 下面的部分将通过一些示例讲解一下如何使用socket编写客户端和服务器端的程序。 注意：在接下来的示例中，我将使用基于TCP/IP协议的socket编程，因为这个协议远远比UDP/IP使用的要广泛。并且所有的socket相关的类都位于java.net包下，所以在我们进行socket编程时需要引入这个包。

写入数据 接下来就是写入请求数据，我们从客户端的socket对象中得到OutputStream对象，然后写入数据后。很类似文件IO的处理代码。

打开服务器端的socket

读取数据 通过上面得到的socket对象获取InputStream对象，然后安装文件IO一样读取数据即可。这里我们将内容打印出来。

使用socket实现一个回声服务器，就是服务器会将客户端发送过来的数据传回给客户端。

E. java中Socket如何实现数据包传输的打包和解包

socket一般调用accept方法等待连接：
public class ServerThread extends Thread{

ServicePanel servicePanel = null;
ServerSocket serverSocket = null;
Socket socket = null;

public ServerThread(ServicePanel servicePanel,ServerSocket serverSocket) {

this.servicePanel = servicePanel;
this.serverSocket = serverSocket;
}

public void run(){

while (true) {
try {
socket = serverSocket.accept();//等待连接
new ReciveFromClient(servicePanel,socket).start();
} catch (IOException e) {
// e.printStackTrace();
break;
}
}
}

}
至于收包，发包是以流的形式传送的：
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
一般包里面的内容也就是被我们封装在某个类中，这个类要实现序列凳腊困化，即实现Serializable接口；
发送方法那些局茄就枣念要自己写了~

F. PC端如何java socket编程获取来自WiFi模块发送的数据流

请问你的
“PC端如何java socket编程获取来自WiFi模块发送的数据隐携流”
这个问题弄出来了吗？？灶世伏？ 我也也遇到了这返卖样的问题 能帮帮我吗？？？

谢谢

G. 用java的Socket编写的小小小聊天工具，在本机调试成功，但是在两台能互相ping通的电脑却不能连接上

建议先用一个最简单的程序测试客户端链接服务器，这样可以排除很多干扰，下面两个类已经是客户端和服务器的最简代码了，你先测一下，如果仍不能连接，把异常信息发上来看看。
另：Socket连接容易出问题的地方：
1）端口号冲突，服务器无法启动；
2）IP地址错误，IP地址分本机地址、局域网地址和广域网地址，在不同的环境下使用不同的地址测试，如果错误将无法被客户端访问，还有如果机器安装了多网卡等问题都会引起错误；
3）防火墙禁止Java程序开放端口，不单是服务器机器的软防火墙，局域网的防火墙也可能阻止外部的访问。

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerMain {
public ServerMain() {
try {
ServerSocket ss = new ServerSocket(31647);
Socket s = ss.accept();
System.out.printf("客户端连接成功：\n%s\n", s.toString());
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new ServerMain();
}
}

import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
public class ClientMain {
public ClientMain() {
try {
Socket s = new Socket("192.168.1.100", 31647); // 修改IP地址
System.out.println("连接服务器成功！");
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new ClientMain();
}
}

H. Java Socket初步详解

网络编程的基本模型就是客户机到服务器模型 简单的说就是两个进程之间相互通讯 然后其中一个必须提供一个固定的位置 而另一个则只需要知道这个固定的位置 并去建立两者之间的联系 然后完成数据的通讯就可以了 这里提供亩悉猜固定位置的通常称为服务器 而建立联系的通常叫做客户端 基于这个简单的模型 就可以进入网络编程啦

Java对这个模型的支持有很多种Api 而这里我只想介绍有关Socket的编程接口 对于Java而言已经简化了Socket的编程接口 首先我们来讨论有关提供固定位置的服务方是如何建立的 Java提供了ServerSocket来对其进行支持 事实上当你创建该类的一个实力对象并提供一个端口资源你就建立了一个固定位置可以让其他计算机来访问你 ServerSocket server=new ServerSocket( );这里稍微要注意的是端口的分配必须是唯一的 因为端口是为了唯一标识每台计算机唯一服务的 另外端口号是从 ~ 之间的 前 个端口已经被Tcp/Ip 作为保留端口 因此你所分配的端口只能是 个之后的 好了 我们有了固定位置 现在所需要的就是一根连接线了 该连接线由客户方首先提出要求 因此Java同样提供了一个Socket对象来对其进行支持 只要客户方创建一个Socket的实例对象进行支持就可以了 Socket client

=new Socket(InetAddress getLocalHost() );客户机必须知道有关服务器的IP地址 对于着一点Java也提供了一个相关的类InetAddress 该对象的实例必须通过它的静态方法来提供 它的静态方法主要提供了得到本机IP 和通过名字或IP直接得到InetAddress的方法

上面的方法基本可以建立一条连线让两台计算机相互交流了 可是数据是如何传输的呢？事实上I/O操作总是和网络编程息息相关的 因为底层的网络是继续数据的 除非远程调用 处理问题的核心在执行上 否则数据的陆帆交互还是依赖于IO操作的 所以你也必须导入java io这个包 java的IO操作也不复杂 它提供了针对于字节流和Unicode的读者和写者 然后也提供了一个缓冲用于数据的读写

BufferedReader in=new BufferedReader(new InputStreamReader(server getInputStream()));

PrintWriter out=new PrintWriter(server getOutputStream());

上面两句就是建立缓冲并把原始的字节流转变为Unicode可以操作 而原始的字节流来源于Socket的两个方法 getInputStream()和getOutputStream()方 分别用来得到输入和输出 那么现在有了基本的模型和基本的操作工具 我们可以做一个简单的Socket例程了

服务方:

import java io *;

import *;

public class MyServer {

public static void main(String[] args) throws IOException{

ServerSocket server=new ServerSocket( );

Socket client=server accept();

BufferedReader in=new BufferedReader(new InputStreamReader(client getInputStream()));

迅型PrintWriter out=new PrintWriter(client getOutputStream());

while(true){

String str=in readLine();

System out println(str);

out println( has receive );

out flush();

if(str equals( end ))

break;

}

client close();

}

}

这个程序的主要目的在于服务器不断接收客户机所写入的信息只到 客户机发送 End 字符串就退出程序 并且服务器也会做出 Receive 为回应 告知客户机已接收到消息

客户机代码:

import *;

import java io *;

public class Client{

static Socket server;

public static void main(String[] args)throws Exception{

server=new Socket(InetAddress getLocalHost() );

BufferedReader in=new BufferedReader(new InputStreamReader(server getInputStream()));

PrintWriter out=new PrintWriter(server getOutputStream());

BufferedReader wt=new BufferedReader(new InputStreamReader(System in));

while(true){

String str=wt readLine();

out println(str);

out flush();

if(str equals( end )){

break;

}

System out println(in readLine());

}

server close();

}

}

客户机代码则是接受客户键盘输入 并把该信息输出 然后输出 End 用来做退出标识

这个程序只是简单的两台计算机之间的通讯 如果是多个客户同时访问一个服务器呢？你可以试着再运行一个客户端 结果是会抛出异常的 那么多个客户端如何实现呢?

其实 简单的分析一下 就可以看出客户和服务通讯的主要通道就是Socket本身 而服务器通过accept方法就是同意和客户建立通讯 这样当客户建立Socket的同时 服务器也会使用这一根连线来先后通讯 那么既然如此只要我们存在多条连线就可以了 那么我们的程序可以变为如下:

服务器:

import java io *;

import *;

public class MyServer {

public static void main(String[] args) throws IOException{

ServerSocket server=new ServerSocket( );

while(true){

Socket client=server accept();

BufferedReader in=new BufferedReader(new InputStreamReader(client getInputStream()));

PrintWriter out=new PrintWriter(client getOutputStream());

while(true){

String str=in readLine();

System out println(str);

out println( has receive );

out flush();

if(str equals( end ))

break;

}

client close();

}

}

}

这里仅仅只是加了一个外层的While循环 这个循环的目的就是当一个客户进来就为它分配一个Socket直到这个客户完成一次和服务器的交互 这里也就是接受到客户的 End 消息 那么现在就实现了多客户之间的交互了 但是 问题又来了 这样做虽然解决了多客户 可是是排队执行的 也就是说当一个客户和服务器完成一次通讯之后下一个客户才可以进来和服务器交互 无法做到同时服务 那么要如何才能同时达到既能相互之间交流又能同时交流呢？很显然这是一个并行执行的问题了 所以线程是最好的解决方案

那么下面的问题是如何使用线程 首先要做的事情是创建线程并使得其可以和网络连线取得联系 然后由线程来执行刚才的操作 要创建线程要么直接继承Thread要么实现Runnable接口 要建立和Socket的联系只要传递引用就可以了 而要执行线程就必须重写run方法 而run方法所做的事情就是刚才单线程版本main所做的事情 因此我们的程序变成了这样:

import *;

import java io *;

public class MultiUser extends Thread{

private Socket client;

public MultiUser(Socket c){

this client=c;

}

public void run(){

try{

BufferedReader in=new BufferedReader(new InputStreamReader(client getInputStream()));

PrintWriter out=new PrintWriter(client getOutputStream());

//Mutil User but can t parallel

while(true){

String str=in readLine();

System out println(str);

out println( has receive );

out flush();

if(str equals( end ))

break;

}

client close();

}catch(IOException ex){

}finally{

}

}

public static void main(String[] args)throws IOException{

ServerSocket server=new ServerSocket( );

while(true){

//transfer location change Single User or Multi User

MultiUser mu=new MultiUser(server accept());

mu start();

}

}

}

I. java socket 写个全双工异步长连接工具类，用来向银行发送和接收报文，哪位大神能写出来，定重谢

双工？就是读写分开线程。。。。。。。。。。。如果连接被关闭，就重新打开连接

J. Java Socket通信如何摆平自身端口问题

Java Socket通信在使用的时候有不少的问题 在端口编程上来说是一个十分重要的 下面我们就看看Java Socket通信如何才能更好的裤中使用相关的代码 希望大家有所帮助

事实上网络编程简单的理解就是两台计算机相互通讯数据而已 对于程序员而言 去掌握一种编程接口并使用一种编程模型相对就会显得简单的多了 Java SDK提供一些相对简单的Api来完成这些工作 Java Socket通信就是其中之一 对于Java而言 这些Api存在与 这个包里面 因此只要导入这个包就可以准备网络编程了

网络编程的基本模型就是客户机到服务器模型 简单的说就是两个进程之间相互通讯 然后其中一个必须提供一个固定的位置 而另一个则只需要知道这个固定的位置 并去建立两者之间的联系孝卖 然后完成数据的通讯就可以了 这里提供固定位置的通常称为服务器 而建立联系的通常叫做客户端 基于这个简单的模型 就可以进入网络胡慎山编程啦

Java对这个模型的支持有很多种Api 而这里我只想介绍有关Java Socket通信的编程接口 对于Java而言已经简化了Socket的编程接口 首先我们来讨论有关提供固定位置的服务方是如何建立的 Java提供了ServerSocket来对其进行支持 事实上当你创建该类的一个实力对象并提供一个端口资源你就建立了一个固定位置可以让其他计算机来访问你 ServerSocket server=new ServerSocket( );这里稍微要注意的是端口的分配必须是唯一的 因为端口是为了唯一标识每台计算机唯一服务的 另外端口号是从 ~ 之间的 前 个端口已经被Tcp/Ip 作为保留端口 因此你所分配的端口只能是 个之后的 好了 我们有了固定位置 现在所需要的就是一根连接线了 该连接线由客户方首先提出要求 因此Java同样提供了一个Socket对象来对其进行支持 只要客户方创建一个Java Socket通信的实例对象进行支持就可以了 Socket client

=new Socket(InetAddress getLocalHost() );客户机必须知道有关服务器的IP地址 对于着一点Java也提供了一个相关的类InetAddress 该对象的实例必须通过它的静态方法来提供 它的静态方法主要提供了得到本机IP 和通过名字或IP直接得到InetAddress的方法

好了 上面的方法基本可以建立一条连线让两台计算机相互交流了 可是数据是如何传输的呢?事实上I/O操作总是和网络编程息息相关的 因为底层的网络是继续数据的 除非远程调用 处理问题的核心在执行上 否则数据的交互还是依赖于IO操作的 所以你也必须导入java io这个包 java的IO操作也不复杂 它提供了针对于字节流和Unicode的读者和写者 然后也提供了一个缓冲用于数据的读写

BufferedReader in=new BufferedReader(new InputStreamReader

(server getInputStream()));

PrintWriter out=new PrintWriter(server getOutputStream());

上面两句就是把原始的字节流转变为Unicode可以操作（即字符）并建立缓冲以提高效率 而原始的字节流来源于Java Socket通信的两个方法 getInputStream()和getOutputStream()方 分别用来得到输入和输出 那么现在有了基本的模型和基本的操作工具 我们可以做一个简单的Java Socket例程了

服务方:

import java io *;

import *;

public class MyServer {

public static void main(String[] args) throws IOException{

ServerSocket server=new ServerSocket( );

Socket client=server accept();

BufferedReader in=new BufferedReader(new InputStream

Reader(client getInputStream()));

PrintWriter out=new PrintWriter(client getOutputStream());

while(true){

String str=in readLine();

System out println(str);

out println( has receive );

out flush();

if(str equals( end ))

break;

}

client close();

}

}