埠監聽和建立管道。首先伺服器端綁定監聽埠，然後客戶端socket連接到這個埠，控制台輸入的字元串都會被在這個埠監聽的伺服器接收到。
B. 求java中的socket程序DataInputStream用法，求具體代碼！
DataOutputStream out=socket.getOutputStream();
out.writeInt(123);
out.writeByte(....);
out.writeShort(...);
DataInputStream in=socket.getInputStream();
out.readInt();
out.readByte();
out.readShort();
C. 求Java Socket 聊天室代碼
兩個類，實現交互
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class MutiChat
{
public static void main(String[] args)
{
MutiChat mc = new MutiChat();
mc.receive().start();
mc.send().start();
}
/**
* 接收信息
*
* @return
*/
private Thread receive()
{
return new Thread()
{
public void run()
{
ServerSocket server_socket = null;
Socket sk = null;
BufferedReader in = null;
try
{
server_socket = new ServerSocket(7777);
sk = server_socket.accept();
in = new BufferedReader(new InputStreamReader(sk
.getInputStream()));
while (true)
{
String str = in.readLine();
System.out.println(str);
}
} catch (Exception e)
{
e.printStackTrace();
}
}
};
}
private Thread send()
{
return new Thread()
{
public void run()
{
Socket client_socket = null;
BufferedReader in = null;
PrintWriter out = null;
while (true)
{
try
{
client_socket = new Socket("127.0.0.1", 8888);
in = new BufferedReader(
new InputStreamReader(System.in));
out = new PrintWriter(new BufferedWriter(
new OutputStreamWriter(client_socket
.getOutputStream())), true);
while (true)
{
String str = in.readLine();
out.println(str);
}
} catch (Exception e)
{
try
{
Thread.sleep(1000);
} catch (Exception ex)
{
ex.printStackTrace();
}
}
}
}
};
}
}
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class MutiChat2
{
public static void main(String[] args)
{
MutiChat2 mc = new MutiChat2();
mc.receive().start();
mc.send().start();
}
/**
* 接收信息
*
* @return
*/
private Thread receive()
{
return new Thread()
{
public void run()
{
ServerSocket server_socket = null;
Socket sk = null;
BufferedReader in = null;
try
{
server_socket = new ServerSocket(8888);
sk = server_socket.accept();
in = new BufferedReader(new InputStreamReader(sk
.getInputStream()));
while (true)
{
String str = in.readLine();
System.out.println(str);
}
} catch (Exception e)
{
e.printStackTrace();
}
}
};
}
private Thread send()
{
return new Thread()
{
public void run()
{
Socket client_socket = null;
BufferedReader in = null;
PrintWriter out = null;
while (true)
{
try
{
client_socket = new Socket("127.0.0.1", 7777);
in = new BufferedReader(
new InputStreamReader(System.in));
out = new PrintWriter(new BufferedWriter(
new OutputStreamWriter(client_socket
.getOutputStream())), true);
while (true)
{
String str = in.readLine();
out.println(str);
}
} catch (Exception e)
{
try
{
Thread.sleep(1000);
} catch (Exception ex)
{
ex.printStackTrace();
}
}
}
}
};
}
}
D. 求socket有返回有發送的多線程java示例代碼
服務端
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);
socket = ss.accept();
int i=0;
while (true) {
i++;
System.out.println("server "+i);
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");
}
System.out.println("服務端不會結束");
}
public static void main(String[] args) {
new Server();
}
};
客戶端
package test;
import java.io.*;
import java.net.*;
public class Client {
Socket socket;
BufferedReader in;
PrintWriter out;
public Client() {
try {
System.out.println("-Try to Connect to 127.0.0.1:10000");
socket = new Socket("127.0.0.1", 10000);
System.out.println("--The Server Connected!");
System.out.println("---Please enter some Character:");
BufferedReader line;
int i=0;
while(true){
i++;
System.out.println("client "+i);
line = new BufferedReader(new InputStreamReader(
System.in));
out = new PrintWriter(socket.getOutputStream(), true);
out.println(line.readLine());
in = new BufferedReader(new InputStreamReader(socket
.getInputStream()));
System.out.println("----"+in.readLine());
// out.close();
// in.close();
// socket.close();
}
} catch (IOException e) {
out.println("-----Wrong");
}
System.out.println("客戶端不會結束");
}
public static void main(String[] args) {
new Client();
}
};
E. 編寫代碼，使用java ServerSocket創建伺服器端ServerSocket的過程。
伺服器端代碼：
importjava.io.IOException;
importjava.io.InputStream;
importjava.net.ServerSocket;
importjava.net.Socket;
publicclassServer{
publicvoidserver(){
try{
ServerSocketserverSocket=newServerSocket(8888);//建立伺服器端的套接字，並監聽8888埠
Socketsocket=serverSocket.accept();//如果有請求到達，則接受請求，並建立一個新的套接字
InputStreamis=socket.getInputStream();//獲取此套接字上的輸入流，用於接收消息
//接下來就是獲取套接字里的位元組流，並轉化為字元串
byte[]bytes=newbyte[1024];
intcount;
StringBuildersb=newStringBuilder();
while((count=is.read(bytes))!=-1){
sb.append(newString(bytes,0,count));
}
is.close();
System.out.println(sb.toString());
}catch(IOExceptione){
e.printStackTrace();
}
}
publicstaticvoidmain(String[]args){
Servers=newServer();
s.server();
}
}
另附客戶端：
importjava.io.IOException;
importjava.io.OutputStream;
importjava.net.InetSocketAddress;
importjava.net.Socket;
publicclassClient{
publicvoidclient(){
try{
Socketsocket=newSocket();//建立套接字
socket.connect(newInetSocketAddress("127.0.0.1",8888));//連接到指定IP地址的主機，並指定埠號接收消息
OutputStreamos=socket.getOutputStream();//獲取此連接上的輸出流，用於發送數據
os.write(newString("Hello,world!").getBytes());//將字元串轉化為位元組數組寫入輸出流
os.flush();//刷新此輸出流，將位元組流寫入它們預期的目標
os.close();//關閉連接，否則會報連接重置異常
}catch(IOExceptione){
e.printStackTrace();
}
}
publicstaticvoidmain(String[]args){
Clientc=newClient();
c.client();
}
}
F. 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();
}
}
}
lishixin/Article/program/Java/hx/201311/27013
G. 求JAVA漢諾塔相關的socket代碼
定義了伺服器線程類，伺服器運行在一個單獨的線程中。
客戶端運行在主線程中。
所有代碼放在一個源文件中就行。源文件名是Hanoi.java
下面是源代碼，輸入的盤子數不要太大，20以內，否則會步數太多，輸出耗時太久。
importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.PrintStream;
importjava.net.InetAddress;
importjava.net.ServerSocket;
importjava.net.Socket;
importjava.net.UnknownHostException;
importjava.util.Scanner;
publicclassHanoi{
publicstaticvoidmain(String[]args){
//創建伺服器
HanoiServerserver=newHanoiServer();
server.start();//啟動伺服器
/*開始創建客戶端*/
Socketsocket=null;//客戶端Socket
try{
socket=newSocket(InetAddress.getLocalHost(),8888);
BufferedReaderreader=newBufferedReader(newInputStreamReader(socket.getInputStream()));
PrintStreamprintStream=newPrintStream(socket.getOutputStream());
Scannerscanner=newScanner(System.in);
System.out.println("請輸入盤子數（3-10），數字太大，運算時間就會太長可能會卡死。");
printStream.print(scanner.nextInt());
printStream.println();
Stringline;
while((line=reader.readLine())!=null){
System.out.println(line);
}
}catch(UnknownHostExceptione){
e.printStackTrace();
}catch(IOExceptione){
e.printStackTrace();
}finally{
if(socket!=null){
try{
socket.close();
System.out.println("客戶端socket關閉");
}catch(IOExceptione){
e.printStackTrace();
}
}
}
}
}
classHanoiServerextendsThread{//伺服器線程類
;
publicHanoiServer(){
try{
this.serverSocket=newServerSocket(8888);
}catch(IOExceptione){
e.printStackTrace();
}
}
privatevoidhanoi(intn,Stringfrom,Stringinter,Stringto,PrintStreamprintStream){
if(n==1){
printStream.print("Disk1from"+from+"to"+to);
printStream.println();
}else{
hanoi(n-1,from,to,inter,printStream);
printStream.print("Disk"+n+"from"+from+"to"+to);
printStream.println();
hanoi(n-1,inter,from,to,printStream);
}
}
@Override
publicvoidrun(){
Socketsocket=null;
try{
socket=this.serverSocket.accept();
PrintStreamprintStream=newPrintStream(socket.getOutputStream());
BufferedReaderreader=newBufferedReader(newInputStreamReader(socket.getInputStream()));
intn=Integer.parseInt(reader.readLine());
this.hanoi(n,"A","B","C",printStream);
}catch(IOExceptione){
e.printStackTrace();
}finally{
if(socket!=null){
try{
socket.close();
System.out.println("伺服器socket關閉");
}catch(IOExceptione){
e.printStackTrace();
}
}
try{
this.serverSocket.close();
System.out.println("伺服器serverSocket關閉");
}catch(IOExceptione){
e.printStackTrace();
}
}
}
}
H. java socket網路編程
//==============Server.java=================//
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static void main(String[] args) throws IOException {
ServerSocket s = new ServerSocket(12345);
System.out.println("伺服器就緒,請啟動客戶端.");
Socket so = s.accept();
byte[] buff = new byte[1024];
int read = so.getInputStream().read(buff);
String[] abc=new String(buff,0,read).split("\\D+");
int a = Integer.parseInt(abc[0]);
int b = Integer.parseInt(abc[1]);
int c = Integer.parseInt(abc[2]);
if(!cbt(a,b,c))
so.getOutputStream().write("輸入的數據無法組成三角形.".getBytes());
else
so.getOutputStream().write(getArea(a,b,c).getBytes());
so.getOutputStream().flush();
so.close();
s.close();
}
private static String getArea(int a, int b, int c) {
float s = (a+b+c)/2f;
return "面積: "+Math.sqrt(s*(s-a)*(s-b)*(s-c));
}
private static boolean cbt(int a, int b, int c) {
return a>0&&b>0&&c>0&&a+b>c&&b+c>a&&a+c>b;
}
}
//=================Client.java======================//
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
public class Client {
public static void main(String[] args) throws UnknownHostException, IOException {
System.out.println("輸入三角形的三邊並用逗號隔開,如: (3,4,5) ");
byte[] buff=new byte[64];
int r = System.in.read(buff);
String ipaddr = "localhost";//根據情況改變,在本機調試就不改了
Socket so = new Socket(ipaddr,12345);
so.getOutputStream().write(new String(buff,0,r).getBytes());
r = so.getInputStream().read(buff);
so.close();
String rs = new String(buff,0,r);
System.out.println(rs);
}
}
//先啟動Server,再啟動Client