A. java编程中，Socket通信是怎么实现的
java编程对于Socket之间的通信过程如下：
服务端往Socket的输出流里面写东西，客户端就可以通过Socket的输入流读取对应的内容。Socket与Socket之间是双向连通的，所以客户端也可以往对应的Socket输出流里面写东西，然后服务端对应的Socket的输入流就可以读出对应的内容。下面来看一些服务端与客户端通信的例子：
publicclassServer{
publicstaticvoidmain(Stringargs[])throwsIOException{
//为了简单起见，所有的异常信息都往外抛
intport=8899;
//定义一个ServerSocket监听在端口8899上
ServerSocketserver=newServerSocket(port);
//server尝试接收其他Socket的连接请求，server的accept方法是阻塞式的
Socketsocket=server.accept();
//跟客户端建立好连接之后，我们就可以获取socket的InputStream，并从中读取客户端发过来的信息了。
Readerreader=newInputStreamReader(socket.getInputStream());
charchars[]=newchar[64];
intlen;
StringBuildersb=newStringBuilder();
while((len=reader.read(chars))!=-1){
sb.append(newString(chars,0,len));
}
System.out.println("fromclient:"+sb);
reader.close();
socket.close();
server.close();
}
}客户端代码
Java代码publicclassClient{
publicstaticvoidmain(Stringargs[])throwsException{
//为了简单起见，所有的异常都直接往外抛
Stringhost="127.0.0.1";//要连接的服务端IP地址
intport=8899;//要连接的服务端对应的监听端口
//与服务端建立连接
Socketclient=newSocket(host,port);
//建立连接后就可以往服务端写数据了
Writerwriter=newOutputStreamWriter(client.getOutputStream());
writer.write("HelloServer.");
writer.flush();//写完后要记得flush
writer.close();
client.close();
}
}
B. java socket输入流inputStream.read(byte[])方法一次读入多帧数据，也就是多帧数据连在一起
因为inputStream.read(byte)是尽可抄能的读byte[]大小的数据袭，当你的服务端发送数据速度大于客户端读取数据的速度时，就会出现客户端读到多帧连在一起的报文。而这些发送数据，读取数据的速度是未知的。所以我们需要人为的来做一些调整。比如说每一帧作为一行写入Socket，客户端每次从socket读取一行。这样客户端每次都是读取一帧。
以上情况可以这样实现：在服务端使用PrintWriter
PrintWriterwriter=newPrintWriter(socket.getOutputStream());
writer.println(data);
客户端可以使用BufferedReader
BufferedReaderreader=newBufferedReader(newBufferedInputStream(socket.getInputStream()));
Strings=reader.readLine();
C. 怎么用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实用教程上的.
D. java的serversocket怎么接受来自客户端的数据
通过accept()获取Socket,然后获取IO流，这个是我写的从客户端下载文件的客户端代码，代码如下
ServerSocketserverSocket=newServerSocket(10002);
while(true){
Socketsocket=serverSocket.accept();
OutputStreamOutput=socket.getOutputStream();
FileInputStreaminput=newFileInputStream("F:\Play.mp4");
byte[]buf=newbyte[1024];
intlength=0;
while((length=input.read(buf))!=-1){
Output.write(buf,0,length);
}
Stringip=socket.getInetAddress().getHostAddress();
System.out.println(ip);
input.close();
socket.close();
}
E. java socket编程 readline()读取问题，为啥在client端刚连接上就开始无限循环，停不下来
改一下
scan.nextLine();//阻塞，排除是socket建立太慢导致的
String str=null;
这两行删除,没用
str=br.readLine();
这个改成
br=scan.readLine();
然后你再试一下
顺便再说一下,这个程序我写过,我开始想的也是客户端发送的数据服务器端可以实时接收,但是我发现我错了,因为Scanner 的阻塞,如果客户端发送消息服务器端必须也得发送一个消息才能收到,这个内容可以是任意内容,比如一个回车,如果想让客户端 或服务器端可以实时接收到消息,在控制台中是不可能实现的,除非使用swing框架,一个文本框负负责发送,一个文本框负责接收,不过听他们说swing现在企业中根本不用了,所有我也就没有深入研究,劝你也放弃吧,研究这个没什么用,除非你能在网页上实现,或者做一个程序,至于我写的源码,如果你要我可以发给你
对了再说下你这个问题出现的原因
你这个是因为循环中没有阻塞语句,而且br没有接收到值,所有它会一直打印null
F. 用JAVA SOCKET编程，读服务器几个字符，再写入本地显示怎么写
答:Server端程序: package test; import java.net.*; import java.io.*; public class Server { private ServerSocket ss; private Socket socket; private BufferedReader in; private PrintWriter out; public Server() { try { ss=new ServerSocket(10000); while(true) { socket = ss.accept(); String RemoteIP = socket.getInetAddress().getHostAddress(); String RemotePort = ":"+socket.getLocalPort(); System.out.println("A client come in!IP:"+RemoteIP+RemotePort); in = new BufferedReader(new InputStreamReader(socket.getInputStream())); String line = in.readLine(); System.out.println("Cleint send is :" + line); out = new PrintWriter(socket.getOutputStream(),true); out.println("Your Message Received!"); out.close(); in.close(); socket.close(); } }catch (IOException e) { out.println("wrong"); } } public static void main(String[] args)
G. 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
}
}
H. java中socket不断接收数据问题
其实，方法有几个。
方法一：
定义一个MsgObject的消息类，里面存放的为发送的消息内容（专记得序列化）。属然后再用ObjectOutputStream来把该类弄成一个输出流发送出去。然后客户端就用
ObjectInputStream in=new ObjectInputStream(socket.getInputStream());
MsgObject obj=(MsgObject)in.getObject();就能够得到一个消息类对象了。。
不会的就追问下，我之前是这样做过的。
方法二：
如果你会json格式，那么就更加简单了，直接把你的消息放到json数组里面。。
这种方法没试过，我近期使用json过于频繁才突然记得的，如果你有兴趣用这个方法，可以一起讨论下。
方法三：
弄多个输入输出流，但是这个不建议