javasocket例子

❶ java socket 幫寫一個將字元串寫入伺服器的例子，不要System.in

字元更簡單啊；
BufferedReader line = new BufferedReader(new InputStreamReader(System.in));
out.println(line.readLine());

這個表示從命令行輸入。
如果要直接發送字元。直接將上面替換成這樣：

String str="";
out.println(str);
就可以了

❷ java static的socket

socket通常也稱作"套接字"，用於描述IP地址和埠，是一個通信鏈的句柄。應用程序通常通過"套接字"向網路發出請求或者應答網路請求。
-----J2SDK-1.3為例，Socket和ServerSocket類庫位於java.net包中。ServerSocket用於伺服器端，Socket是建立網路連接時使用的。在連接成功時，應用程序兩端都會產生一個Socket實例，操作這個實例，完成所需的會話。對於一個網路連接來說，套接字是平等的，並沒有差別，不因為在伺服器端或在客戶端而產生不同級別。不管是Socket還是ServerSocket它們的工作都是通過SocketImpl類及其子類完成的。

給你一個例子：
服務端例子：

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerDemo {
/**
* 注意：Socket的發送與接收是需要同步進行的，即客戶端發送一條信息，伺服器必需先接收這條信息，
* 而後才可以向客戶端發送信息，否則將會有運行時出錯。
* @param args
*/
public static void main(String[] args) {
ServerSocket ss = null;
try {
ss = new ServerSocket(8888);
//伺服器接收到客戶端的數據後，創建與此客戶端對話的Socket
Socket socket = ss.accept();
//用於向客戶端發送數據的輸出流
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
//用於接收客戶端發來的數據的輸入流
DataInputStream dis = new DataInputStream(socket.getInputStream());
System.out.println("伺服器接收到客戶端的連接請求：" + dis.readUTF());
//伺服器向客戶端發送連接成功確認信息
dos.writeUTF("接受連接請求，連接成功!");
//不需要繼續使用此連接時，關閉連接
socket.close();
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
客戶端例子：
importjava.io.DataInputStream;
import java.io.DataOutputStream;
importjava.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
public class ClientDemo {
/**
* @param args
*/
public static void main(String[] args) {
Socket socket = null;
try {
socket = new Socket("localhost",8888);
//獲取輸出流，用於客戶端向伺服器端發送數據
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
//獲取輸入流，用於接收伺服器端發送來的數據
DataInputStream dis = new DataInputStream(socket.getInputStream());
//客戶端向伺服器端發送數據
dos.writeUTF("我是客戶端，請求連接!");
//列印出從伺服器端接收到的數據
System.out.println(dis.readUTF());
//不需要繼續使用此連接時，記得關閉哦
socket.close();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

❸ 怎麼用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編程的時候碰到了問題，就是實現簡單的客戶端和伺服器端相互發送文件的例子，具體如下

// server,同時注意socket的close
server=new ServerSocket(PORT);
client=server.accept();

// client 寫法如下
String host = "127.0.0.1"; // 要連接的服務端IP地址
int port = 8899; // 要連接的服務端對應的監聽埠
// 與服務端建立連接
Socket client = new Socket(host, port);
//建立連接後就可以往服務端寫數據了
Writer writer = new OutputStreamWriter(client.getOutputStream());
writer.write("Hello Server.");
writer.flush();// 寫完後要記得flush
writer.close();
client.close();

❺ JAVA socket通信

publicclassClient{
	publicstaticvoidmain(String[]args){
		Strings=null;
		Socketmysocket;
		DataInputStreamin=null;
		DataOutputStreamout=null;
		try{
			mysocket=newSocket("127.0.0.1",4331);
			in=newDataInputStream(mysocket.getInputStream());
			out=newDataOutputStream(mysocket.getOutputStream());
			for(intk=1;k<100;k=k+2){
				out.writeUTF(""+k);
				s=in.readUTF();
				System.out.println("客戶收到"+s);
				Thread.sleep(500);
			}
		}catch(Exceptione){
			System.out.println("伺服器已斷開"+e);
		}
	}
}

publicclassServer{
	publicstaticvoidmain(String[]args){
		ServerSocketserver=null;
		Socketyou=null;
		Strings=null;
		DataOutputStreamout=null;
		DataInputStreamin=null;
		try{
			server=newServerSocket(4331);
		}catch(Exceptione){
			System.out.println(e);
		}
		try{
			System.out.println("等待客戶呼叫");
			you=server.accept();
			out=newDataOutputStream(you.getOutputStream());
			in=newDataInputStream(you.getInputStream());
			while(true){
				s=in.readUTF();
				intm=Integer.parseInt(s);
				out.writeUTF("你好,我是伺服器");
				out.writeUTF("你說的數乘2後是:"+2*m);
				System.out.println("伺服器收到:"+s);
				Thread.sleep(500);
			}
		}catch(Exceptione){
			System.out.println("客戶端已斷開"+e);
		}
	}
}

很簡單的伺服器客戶端程序

❻ 誰有java和C用socket通信的簡單例子

這是用Java寫的伺服器的程序

importjava.net.*;
importjava.io.*;

publicclassServer{

privateServerSocketserver;
privateSocketclient;

publicServer(){
booleanflag=true;
try{
server=newServerSocket(8888);//埠
System.out.println("伺服器正在等到客戶端連接......");
while(flag){
client=server.accept();//阻塞
newServerThread(client).start();
}
server.close();
}catch(Exceptione){
}
}

publicstaticvoidmain(String[]args){
newServer();
}

{

privateSocketclientThread;
privatePrintStreamout;
privateBufferedReaderin;
privatebooleanflag=true;

publicServerThread(Socketclient){
this.clientThread=client;
System.out.println("主機與客戶端成功建立連接，開始通訊！！");
}

publicvoidrun(){
try{
/*
*超時判斷：設置超時時間300秒，中斷連接或者300秒內客戶端無回應信息則認為中斷
*缺點便是必須把超時時間設置很長，否則客戶端待機也認為超時處理，無法判斷是否埠
*/
clientThread.setSoTimeout(300000);
out=newPrintStream(client.getOutputStream());
in=newBufferedReader(newInputStreamReader(client.getInputStream()));
while(flag){
Stringstr=in.readLine();//阻塞
System.out.println("客戶端："+str);
out.println("主機成功接收到您的信息！！");
}
client.close();
}catch(Exceptione){
//如果異常是連接異常，則輸出連接斷開
if(e.getMessage()=="Connectionreset"){
System.out.println("客戶端已斷開連接！！");
}
}
}
}
}

這是客戶端的

importjava.net.*;
importjava.io.*;

publicclassClient{

privateSocketclient;

publicClient(){
	InetAddressip;
try{
System.out.println("正在連接伺服器......");
ip=InetAddress.getLocalHost();
Stringlocalip=ip.getHostAddress();
client=newSocket(localip,8888);//阻塞
BufferedReaderinput=newBufferedReader(newInputStreamReader(System.in));
BufferedReaderin=newBufferedReader(newInputStreamReader(client.getInputStream()));
PrintStreamout=newPrintStream(client.getOutputStream());;
booleanflag=true;

System.out.println("成功連接到主機，開始通訊！！");

while(flag){
System.out.printf("請輸入信息：");
out.println(input.readLine());//阻塞
//判斷是否與主機斷開
if(isConnected()){
System.out.println("發生成功！！");
System.out.println("主機："+in.readLine());
}else{
System.out.println("發生失敗！！");
System.out.println("與伺服器斷開連接！！");
client.close();
break;
}
}
}catch(Exceptione){
System.out.println(e.getMessage());
}
}

//判斷伺服器是否斷開的方法，
//通過OutputStream發送一段測試數據，如果發送失敗就表示遠端已經斷開連接
//但會與正常的傳送干擾，所以用sendUrgenData
publicbooleanisConnected(){
try{
client.sendUrgentData(0xFF);
returntrue;
}catch(Exceptione){
e.printStackTrace();
returnfalse;
}
}

publicstaticvoidmain(String[]args){
newClient();
}
}

❼ java中的socket是什麼意思

所謂socket通常也稱作"套接字"，用於描述IP地址和埠，是一個通信鏈的句柄。應用程序通常通過"套接字"向網路發出請求或者應答網路請求。
以J2SDK-1.3為例，Socket和ServerSocket類庫位於java.net包中。ServerSocket用於伺服器端，Socket是建立網路連接時使用的。在連接成功時，應用程序兩端都會產生一個Socket實例，操作這個實例，完成所需的會話。對於一個網路連接來說，套接字是平等的，並沒有差別，不因為在伺服器端或在客戶端而產生不同級別。不管是Socket還是ServerSocket它們的工作都是通過SocketImpl類及其子類完成的。
重要的Socket API：
java.net.Socket繼承於java.lang.Object，有八個構造器，其方法並不多，下面介紹使用最頻繁的三個方法，其它方法大家可以見JDK-1.3文檔。
. Accept方法用於產生"阻塞"，直到接受到一個連接，並且返回一個客戶端的Socket對象實例。"阻塞"是一個術語，它使程序運行暫時"停留"在這個地方，直到一個會話產生，然後程序繼續；通常"阻塞"是由循環產生的。
. getInputStream方法獲得網路連接輸入，同時返回一個InputStream對象實例。
. getOutputStream方法連接的另一端將得到輸入，同時返回一個OutputStream對象實例。
注意：其中getInputStream和getOutputStream方法均會產生一個IOException，它必須被捕獲，因為它們返回的流對象，通常都會被另一個流對象使用。
2ServerSocket類例子編輯

package com.lanber.socket;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerDemo {
/**
* 注意：Socket的發送與接收是需要同步進行的，即客戶端發送一條信息，伺服器必需先接收這條信息，
* 而後才可以向客戶端發送信息，否則將會有運行時出錯。
* @param args
*/
public static void main(String[] args) {
ServerSocket ss = null;
try {
ss = new ServerSocket(8888);
//伺服器接收到客戶端的數據後，創建與此客戶端對話的Socket
Socket socket = ss.accept();
//用於向客戶端發送數據的輸出流
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
//用於接收客戶端發來的數據的輸入流
DataInputStream dis = new DataInputStream(socket.getInputStream());
System.out.println("伺服器接收到客戶端的連接請求：" + dis.readUTF());
//伺服器向客戶端發送連接成功確認信息
dos.writeUTF("接受連接請求，連接成功!");
//不需要繼續使用此連接時，關閉連接
socket.close();
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

3客戶端的例子編輯
package com.lanber.socket;
importjava.io.DataInputStream;
import java.io.DataOutputStream;
importjava.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
public class ClientDemo {
/**
* @param args
*/
public static void main(String[] args) {
Socket socket = null;
try {
socket = new Socket("localhost",8888);
//獲取輸出流，用於客戶端向伺服器端發送數據
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
//獲取輸入流，用於接收伺服器端發送來的數據
DataInputStream dis = new DataInputStream(socket.getInputStream());
//客戶端向伺服器端發送數據
dos.writeUTF("我是客戶端，請求連接!");
//列印出從伺服器端接收到的數據
System.out.println(dis.readUTF());
//不需要繼續使用此連接時，記得關閉哦
socket.close();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

❽ 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();
}

}

❾ 大家給我寫一個java socket的簡單例子

客戶端的。
String ip = "172.31.1.130";
ip = "127.0.0.1";
int port = 10004;
try {
Socket socket = new Socket(ip, port);
socket.setSoTimeout(5539900);
java.io.OutputStream out = socket.getOutputStream();

byte[] date = "hello world".getBytes();
out.write(data);
out.flush();

socket.shutdownOutput();

byte[] buffer = new byte[1024];
int len = -1;
java.io.FileOutputStream fout = new java.io.FileOutputStream(
"d:/response.xml");
java.io.ByteArrayOutputStream bout = new java.io.ByteArrayOutputStream();

java.io.InputStream in = socket.getInputStream();

while ((len = in.read(buffer, 0, buffer.length)) > 0) {
bout.write(buffer, 0, len);
}
in.close();
bout.flush();
bout.close();

byte[] rdata = bout.toByteArray();
// System.out.println("leen = " + (rdata.length - 32));
System.out.println(new String(rdata));

fout.write(rdata);
fout.flush();
fout.close();
socket.close();

} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

伺服器端的

ServerSocket ss = new ServerSocket(8090);
Socket socket=null;
BufferedReader in;
PrintWriter out;

while (true)
{
socket = ss.accept();
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out = new PrintWriter(socket.getOutputStream(),true);
String line = in.readLine();
out.println("you input is :" + line);
out.close();
in.close();
socket.close();
}

❿ java socket 線程

以前寫過一個簡單的遠程式控制制軟體（命令行控制，就是在本機發個命令，在遠程機器執行），用的即使Socket，代碼找不到了，但原理很簡單。就是自己定義一個簡單協議，簡單點就用Java序列化，封一個自定義命令對象，每次發一個對象過去，對方接受後，執行命令對象就是了。
下面發一個間的JavaSocket例子：


importjava.io.IOException;
importjava.io.ObjectInputStream;
importjava.io.ObjectOutputStream;
importjava.net.ServerSocket;
importjava.net.Socket;
importjava.net.UnknownHostException;

publicclassJavaXmlSocket{
	
	/**
	*@paramargs
	*@throwsIOException
	*@throwsClassNotFoundException
	*/
	publicstaticvoidmain(String[]args)throwsIOException,ClassNotFoundException{
		//TODOAuto-generatedmethodstub
		finalServerSocketss=newServerSocket(32788);//創建服務端
		
		
		
		newThread(){

			@Override
			publicvoidrun(){
				//TODOAuto-generatedmethodstub
				try{
					Sockets2=ss.accept();
					ObjectOutputStreamoutput_s2;
					ObjectInputStreaminput_s2;
					output_s2=newObjectOutputStream(s2.getOutputStream());//服務端輸出流
					input_s2=newObjectInputStream(s2.getInputStream());//服務端輸入流
					
					//服務端向客戶端發送消息
					output_s2.writeObject("hello");
					Stringstr=(String)input_s2.readObject();
					System.out.println("服務端接收端客戶端發送的消息："+str);
				}catch(IOExceptione){
					//TODOAuto-generatedcatchblock
					e.printStackTrace();
				}catch(ClassNotFoundExceptione){
					//TODOAuto-generatedcatchblock
					e.printStackTrace();
				}

				
			}
			
		}.start();//啟動一個線程服務端偵聽客戶端連接
		
		newThread(){

			@Override
			publicvoidrun(){
				//TODOAuto-generatedmethodstub
				try{
					Sockets1=newSocket("127.0.0.1",32788);//創建客戶端，注冊並綁定ServerSocket
					ObjectOutputStreamoutput_s1;
					
					ObjectInputStreaminput_s1;
					output_s1=newObjectOutputStream(s1.getOutputStream());//客戶端輸出流
					input_s1=newObjectInputStream(s1.getInputStream());//客戶端輸入流
					
					//客戶端向服務端發送消息
					output_s1.writeObject("hello");
					Stringstr2=(String)input_s1.readObject();
					System.out.println("客戶端接收端服務端發送的消息："+str2);
				}catch(UnknownHostExceptione){
					//TODOAuto-generatedcatchblock
					e.printStackTrace();
				}catch(IOExceptione){
					//TODOAuto-generatedcatchblock
					e.printStackTrace();
				}catch(ClassNotFoundExceptione){
					//TODOAuto-generatedcatchblock
					e.printStackTrace();
				}
			}
			
			
		}.start();////啟動一個線程客戶端端連接服務端
		
		try{
			//如果你保證Main方法不會退出，就不需要這個延時。
			Thread.sleep(5000);//延時5秒等待消息處理結束關閉服務端。
			
		}catch(InterruptedExceptione){
			//TODOAuto-generatedcatchblock
			e.printStackTrace();
		}
		
		//關閉服務
		ss.close();
		
		
	}

}