㈠ 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();
}
}
㈡ 请教怎样发送socket请求包，并获得返回数据
这种东西，Google下大把吧，正好前阵子有一个TCP通讯的，借你参考下好了：
ServerSide
packagenio;
importjava.io.ByteArrayOutputStream;
importjava.io.IOException;
importjava.net.InetSocketAddress;
importjava.net.ServerSocket;
importjava.nio.ByteBuffer;
importjava.nio.channels.SelectionKey;
importjava.nio.channels.Selector;
importjava.nio.channels.ServerSocketChannel;
importjava.nio.channels.SocketChannel;
importjava.text.DateFormat;
importjava.text.SimpleDateFormat;
importjava.util.Date;
publicclassEchoServer{
privatestaticintSOCKET_NUM=55555;
=newSimpleDateFormat("yyyyMMddHH:mm:ss");
/**
*@
*/
publicstaticvoidmain(String[]args){
newEchoServer().start();
}
publicvoidstart(){
try{
Selectorselector=bindServer();//绑定服务端口，并定义一个事件选择器对象记录套接字通道的事件
/*通过此循环来遍例事件*/
while(true){
log("Waitingevents.");
intn=selector.select();//查询事件如果一个事件都没有，这里就会阻塞
log("Gotevents:"+n);
ByteBufferechoBuffer=ByteBuffer.allocate(50);//定义一个byte缓冲区来存储收发的数据
/*循环遍例所有产生的事件*/
for(SelectionKeykey:selector.selectedKeys()){
SocketChannelsc;
selector.selectedKeys().remove(key);//将本此事件从迭带器中删除
/*如果产生的事件为接受客户端连接(当有客户端连接服务器的时候产生)*/
if((key.readyOps()&SelectionKey.OP_ACCEPT)==SelectionKey.OP_ACCEPT){
ServerSocketChannelsubssc=(ServerSocketChannel)key.channel();//定义一个服务器socket通道
sc=subssc.accept();//将临时socket对象实例化为接收到的客户端的socket
sc.configureBlocking(false);//将客户端的socket设置为异步
sc.register(selector,SelectionKey.OP_READ);//将客户端的socket的读取事件注册到事件选择器中
System.out.println("Gotnewclient:"+sc);
}
/*如果产生的事件为读取数据(当已连接的客户端向服务器发送数据的时候产生)*/
elseif((key.readyOps()&SelectionKey.OP_READ)==SelectionKey.OP_READ){
sc=(SocketChannel)key.channel();//临时socket对象实例化为产生本事件的socket
ByteArrayOutputStreambos=newByteArrayOutputStream();//定义一个用于存储byte数据的流对象，存储全部信息
echoBuffer.clear();//先将客户端的数据清空
try{
//循环读取所有客户端数据到byte缓冲区中,当有数据的时候read函数返回数据长度
//NIO会自动的将缓冲区一次容纳不下的自动分段
intreadInt=0;//为读取到数据的长度
while((readInt=sc.read(echoBuffer))>0){
//如果获得数据长度比缓冲区大小小的话
if(readInt<echoBuffer.capacity()){
byte[]readByte=newbyte[readInt];//建立一个临时byte数组,将齐长度设为获取的数据的长度
//循环向此临时数组中添加数据
for(inti=0;i<readInt;i++){
readByte[i]=echoBuffer.get(i);
}
bos.write(readByte);//将此数据存入byte流中
}
//否则就是获得数据长度等于缓冲区大小
else{
bos.write(echoBuffer.array());//将读取到的数据写入到byte流对象中
}
}
//当循环结束时byte流中已经存储了客户端发送的所有byte数据
log("Recivemsg:"+newString(bos.toByteArray()));
}catch(Exceptione){
e.printStackTrace();//当客户端在读取数据操作执行之前断开连接会产生异常信息
key.cancel();//将本socket的事件在选择器中删除
break;
}
writeBack(sc,bos.toByteArray());//向客户端写入收到的数据
}
}
}
}catch(Exceptione){
e.printStackTrace();
}
}
/**
*绑定服务端口，初始化整个服务
*@throwsIOException
*/
privateSelectorbindServer()throwsIOException{
log("Startbindingserversocket："+SOCKET_NUM);
Selectorselector=Selector.open();//定义一个事件选择器对象记录套接字通道的事件
ServerSocketChannelssc=ServerSocketChannel.open();//定义一个异步服务器socket对象
ssc.configureBlocking(false);//将此socket对象设置为异步
ServerSocketss=ssc.socket();//定义服务器socket对象-用来指定异步socket的监听端口等信息
InetSocketAddressaddress=newInetSocketAddress(SOCKET_NUM);//定义存放监听端口的对象
ss.bind(address);//将服务器与这个端口绑定
ssc.register(selector,SelectionKey.OP_ACCEPT);//将异步的服务器socket对象的接受客户端连接事件注册到selector对象内
log("Bindedsocketat："+SOCKET_NUM);
returnselector;
}
privatebooleanwriteBack(SocketChannelsc,byte[]b){
ByteBufferechoBuffer=ByteBuffer.allocate(b.length);//建立这个byte对象的ByteBuffer
echoBuffer.put(b);//将数据存入
echoBuffer.flip();//将缓冲区复位以便于进行其他读写操作
try{
//向客户端写入数据,数据为接受到数据
sc.write(echoBuffer);
}catch(IOExceptione){
e.printStackTrace();
returnfalse;
}
System.out.println("Msgechoback:"+newString(echoBuffer.array()));
returntrue;
}
privatestaticvoidlog(Objectmsg){
System.out.println("SERVER["+dateFormatter.format(newDate())+"]:"+msg);
}
}
㈢ 怎么用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实用教程上的.