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

}