javasocket创建

⑴ java中如何创建socket连接的过程

这是我写过的一个简单聊天软件客户端 你参考下

importjava.util.*;
importjava.io.*;
importjava.net.*;
importjava.awt.*;
importjavax.swing.*;
importjava.awt.event.*;

{
	privateJTextAreajta=newJTextArea();
	privateJTextFieldjtf=newJTextField();
	privateJComboBox<String>jcb=newJComboBox<String>();
	privateJButtonjbsend=newJButton("send");
	privateJButtonjbrefresh=newJButton("refresh");
	privateInputStreaminput;
	privateOutputStreamoutput;
	private	Socketsocket;
	publicstaticStringSERVER_IP="192.168.1.101";
	publicstaticintSERVER_PORT=8888;
	//Message1->refreshmessage
	//Message2->sendmessage
	publictestChatClient()
	{
		initComponents();
		try
		{
			socket=newSocket(SERVER_IP,SERVER_PORT);
			input=socket.getInputStream();
			output=socket.getOutputStream();	
		}
		catch(IOExceptione)
		{
			System.err.println(e);
		}
		jbrefresh.addActionListener(newActionListener()
		{
			publicvoidactionPerformed(ActionEvente)
			{
				jta.setText("");
				try
				{
					if(socket==null)
						socket=newSocket(SERVER_IP,SERVER_PORT);
					output.write(0x31);
				}
				catch(IOExceptionex)
				{
					JOptionPane.showConfirmDialog(null,ex);
				}
			}	
		});
		jbsend.addActionListener(newActionListener()
		{
			publicvoidactionPerformed(ActionEvente)
			{
				if(jtf.getText()==null||jtf.getText().equals(""))
					return;
				if(jtf.getText().length()>=400)
				{
					JOptionPane.showConfirmDialog(null,"最大字数不能超过400");
					return;
				}
				try
				{
					Stringdestination=jcb.getSelectedItem().toString();
					Stringmessage=jtf.getText();
					if(socket==null)
						socket=newSocket(SERVER_IP,SERVER_PORT);
					byte[]temp=newbyte[3+destination.getBytes().length+message.getBytes().length];
					temp[0]=0x32;
					temp[1]=(byte)destination.getBytes().length;
					inti=2;
					for(intj=0;j<destination.getBytes().length;i++,j++)
						temp[i]=destination.getBytes()[j];
					temp[i++]=(byte)message.getBytes().length;
					for(intj=0;j<message.getBytes().length;i++,j++)
					{
						temp[i]=message.getBytes()[j];
						System.out.println();
					}
					output.write(temp);
					jta.append("me:
");
					jta.append(jtf.getText());
					jta.append("
");
					jtf.setText("");
				}
				catch(IOExceptionex)
				{
					System.err.println(ex);
				}
			}
		});
		try
		{
			jbrefresh.doClick();
			while(true)
			{
				byte[]tempBytes=newbyte[1000];
				input.read(tempBytes);
				intcommand=tempBytes[0]-0x30;
				//intreadLength=input.read();
				switch(command)
				{
					case1:
					{
						intreadLength=tempBytes[1];
						String[]temp=newString(tempBytes,2,readLength,"UTF-8").split(";");
						jcb.removeAllItems();
						if(temp.length==0&&temp[0].equals(""))
							return;
						for(inti=0;i<temp.length;i++)
						{
							jcb.addItem(temp[i]);
						}
						jcb.setSelectedIndex(0);
						break;
					}
					case2:
					{
						intreadLength1=tempBytes[1];
						jta.append(newString(tempBytes,2,readLength1,"UTF-8")+"
");
						intreadLength2=tempBytes[2+readLength1];
						jta.append(newString(tempBytes,3+readLength1,readLength2,"UTF-8")+"
");
						break;
					}
				}
			}
		}
		catch(IOExceptione)
		{
			System.err.println(e);
		}
	}
	publicstaticvoidmain(String[]args){
		testChatClientframe=newtestChatClient();
	}
	publicvoidinitComponents()
	{
		setLayout(newBorderLayout());
		JPaneljpNorth=newJPanel();
		jpNorth.setLayout(newBorderLayout());
		jpNorth.add(jcb,BorderLayout.CENTER);
		jpNorth.add(jbrefresh,BorderLayout.EAST);
		JPaneljpSouth=newJPanel();
		jpSouth.setLayout(newBorderLayout());
		jpSouth.add(jtf,BorderLayout.CENTER);
		jpSouth.add(jbsend,BorderLayout.EAST);
		add(jpNorth,BorderLayout.NORTH);
		add(jpSouth,BorderLayout.SOUTH);
		add(newJScrollPane(jta),BorderLayout.CENTER);
		this.getRootPane().setDefaultButton(jbsend);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setSize(300,600);
		setVisible(true);
	}
}

⑵ 编写代码，使用java ServerSocket创建服务器端ServerSocket的过程。

packagesocket;

importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.PrintWriter;
importjava.net.ServerSocket;
importjava.net.Socket;

publicclassSocketService{
//搭建服务器端
publicstaticvoidmain(String[]args)throwsIOException{
SocketServicesocketService=newSocketService();
//1、a)创建一个服务器端Socket，即SocketService
socketService.oneServer();
}
publicvoidoneServer(){
try{
ServerSocketserver=null;
try{
server=newServerSocket(5209);
//b)指定绑定的端口，并监听此端口。
System.out.println("服务器启动成功");
//创建一个ServerSocket在端口5209监听客户请求
}catch(Exceptione){
System.out.println("没有启动监听："+e);
//出错，打印出错信息
}
Socketsocket=null;
try{
socket=server.accept();
//2、调用accept()方法开始监听，等待客户端的连接
//使用accept()阻塞等待客户请求，有客户
//请求到来则产生一个Socket对象，并继续执行
}catch(Exceptione){
System.out.println("Error."+e);
//出错，打印出错信息
}
//3、获取输入流，并读取客户端信息
Stringline;
BufferedReaderin=newBufferedReader(newInputStreamReader(socket.getInputStream()));
//由Socket对象得到输入流，并构造相应的BufferedReader对象
PrintWriterwriter=newPrintWriter(socket.getOutputStream());
//由Socket对象得到输出流，并构造PrintWriter对象
BufferedReaderbr=newBufferedReader(newInputStreamReader(System.in));
//由系统标准输入设备构造BufferedReader对象
System.out.println("Client:"+in.readLine());
//在标准输出上打印从客户端读入的字符串
line=br.readLine();
//从标准输入读入一字符串
//4、获取输出流，响应客户端的请求
while(!line.equals("end")){
//如果该字符串为"bye"，则停止循环
writer.println(line);
//向客户端输出该字符串
writer.flush();
//刷新输出流，使Client马上收到该字符串
System.out.println("Server:"+line);
//在系统标准输出上打印读入的字符串
System.out.println("Client:"+in.readLine());
//从Client读入一字符串，并打印到标准输出上
line=br.readLine();
//从系统标准输入读入一字符串
}//继续循环

//5、关闭资源
writer.close();//关闭Socket输出流
in.close();//关闭Socket输入流
socket.close();//关闭Socket
server.close();//关闭ServerSocket
}catch(Exceptione){//出错，打印出错信息
System.out.println("Error."+e);
}
}
}

⑶ java中的socket是什么意思

所谓socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。x0dx0a以J2SDK-1.3为例，Socket和ServerSocket类库位于java.net包中。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。对于一个网络连接来说，套接字是平等的，并没有差别，不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl类及其子类完成的。x0dx0a重要的Socket API：x0dx0ajava.net.Socket继承于java.lang.Object，有八个构造器，其方法并不多，下面介绍使用最频繁的三个方法，其它方法大家可以见JDK-1.3文档。x0dx0a. Accept方法用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例。"阻塞"是一个术语，它使程序运行暂时"停留"在这个地方，直到一个会话产生，然后程序继续；通常"阻塞"是由循环产生的。x0dx0a. getInputStream方法获得网络连接输入，同时返回一个InputStream对象实例。x0dx0a. getOutputStream方法连接的另一端将得到输入，同时返回一个OutputStream对象实例。x0dx0a注意：其中getInputStream和getOutputStream方法均会产生一个IOException，它必须被捕获，因为它们返回的流对象，通常都会被另一个流对象使用。x0dx0a2ServerSocket类例子编辑x0dx0ax0dx0apackage com.lanber.socket;x0dx0aimport java.io.DataInputStream;x0dx0aimport java.io.DataOutputStream;x0dx0aimport java.io.IOException;x0dx0aimport java.net.ServerSocket;x0dx0aimport java.net.Socket;x0dx0apublic class ServerDemo {x0dx0a/**x0dx0a* 注意：Socket的发送与接收是需要同步进行的，即客户端发送一条信息，服务器必需先接收这条信息，x0dx0a* 而后才可以向客户端发送信息，否则将会有运行时出错。x0dx0a* @param argsx0dx0a*/x0dx0apublic static void main(String[] args) {x0dx0aServerSocket ss = null;x0dx0atry {x0dx0ass = new ServerSocket(8888);x0dx0a//服务器接收到客户端的数据后，创建与此客户端对话的Socketx0dx0aSocket socket = ss.accept();x0dx0a//用于向客户端发送数据的输出流x0dx0aDataOutputStream dos = new DataOutputStream(socket.getOutputStream());x0dx0a//用于接收客户端发来的数据的输入流x0dx0aDataInputStream dis = new DataInputStream(socket.getInputStream());x0dx0aSystem.out.println("服务器接收到客户端的连接请求：" + dis.readUTF());x0dx0a//服务器向客户端发送连接成功确认信息x0dx0ados.writeUTF("接受连接请求，连接成功!");x0dx0a//不需要继续使用此连接时，关闭连接x0dx0asocket.close();x0dx0ass.close();x0dx0a} catch (IOException e) {x0dx0ae.printStackTrace();x0dx0a}x0dx0a}x0dx0a}x0dx0ax0dx0a3客户端的例子编辑x0dx0apackage com.lanber.socket;x0dx0aimportjava.io.DataInputStream;x0dx0aimport java.io.DataOutputStream;x0dx0aimportjava.io.IOException;x0dx0aimport java.io.OutputStream;x0dx0aimport java.net.Socket;x0dx0aimport java.net.UnknownHostException;x0dx0apublic class ClientDemo {x0dx0a/**x0dx0a* @param argsx0dx0a*/x0dx0apublic static void main(String[] args) {x0dx0aSocket socket = null;x0dx0atry {x0dx0asocket = new Socket("localhost",8888);x0dx0a//获取输出流，用于客户端向服务器端发送数据x0dx0aDataOutputStream dos = new DataOutputStream(socket.getOutputStream());x0dx0a//获取输入流，用于接收服务器端发送来的数据x0dx0aDataInputStream dis = new DataInputStream(socket.getInputStream());x0dx0a//客户端向服务器端发送数据x0dx0ados.writeUTF("我是客户端，请求连接!");x0dx0a//打印出从服务器端接收到的数据x0dx0aSystem.out.println(dis.readUTF());x0dx0a//不需要继续使用此连接时，记得关闭哦x0dx0asocket.close();x0dx0a} catch (UnknownHostException e) {x0dx0ae.printStackTrace();x0dx0a} catch (IOException e) {x0dx0ae.printStackTrace();x0dx0a}x0dx0a}x0dx0a}

⑷ 编写代码，使用Java Socket创建客户端Socket的过程。

如果你要实现服务器和客户端都可以向对方发送消息，而不等待对方应答，只需要把InputStream和OutputStream分别放在两个不同线程里就行了，即是说把接收流与发送流分别用一个线程监听处理。如果要实现不分客户端服务器的话，用UDP通信即可 补充回答：如果不涉及到MIME，只是收发简单文本邮件。就会比较简单。因为就像你说的，smtp和pop3协议就是文本格式的。你用Socket建立连接后，就像读文件一样，一行一行的读数据，然后按照协议分析数据格式。例如如果开始时USER那么后面可能跟的就是用户等。 就是一个字符串解析和匹配的过程。网上好像有这类代码，自己找一个学习一下。我以前用C在68k上作过，不是很难。不过代码已经没有了。

⑸ java中如何创建socket连接的过程

1、在打开的ie浏览器窗口右上方点击齿轮图标，选择“Internet选项”，如下图所示：

⑹ Java中建立一个socket客户端需要几步

代码给你自己看去：

Socket socket = new Socket("192.168.1.72", 4700);
// 向本机的4700端口发出客户请求
BufferedReader sin = new BufferedReader(new InputStreamReader(System.in,"UTF-8"));
// 由系统标准输入构造BuffereadReader对象
PrintWriter os = new PrintWriter(socket.getOutputStream());
// 由socket对象得到输出流，并创建PrintWriter对象
BufferedReader is = new BufferedReader(new InputStreamReader(
socket.getInputStream(),"UTF-8"));
// 由socket对象得到输出流，并构建BufferedReader对象
String readLine;
readLine ="客户端启动成功！";
System.out.println(readLine);
// 系统由标准输入读入一个字符串
while (!readLine.equals("bye")) {
// 若从标准输入得到的字符串是bye则停止循环
os.println(readLine);
// 将从标准输入流中得到的字符串输入到Server
os.flush();
// 刷新输入流使Server马上得到该字符串
System.out.println("client:" + readLine);
// 在系统标准输出上打印输入该字符串
System.out.println("Server:" + is.readLine());
// 从Server上读入一字符串并打印
readLine = sin.readLine();
// 从系统标准输入得到字符串
}
os.close();// 关闭输入流
is.close();// 关闭输出流
socket.close();// 关闭socket流
} catch (Exception e) {
e.printStackTrace();
}
}

⑺ java socket怎么建立连接池

socket连接池

SocketServerPool 含有两个参数 listenPort , maxConnection 。分别表示监听端口和最大连接数。

函数setHandlers() 里面初始化了5个PoolConnectionHandler的线程，表示池中能同时最大处理5个连接。

/**
* @author jake1036
* 2010.7.16 20:05
* socket连接池类
*/
package cn.bupt.net;
import java.io.*;
import java.net.*;

/**
* @author jake1036
*
*/
public class SocketServerPool {

/*最大连接和监听端口*/
private int maxConnections ;
private int listenPort ;

public SocketServerPool(int listenPort , int maxConnections){
this.listenPort = listenPort ;
this.maxConnections = maxConnections ;

}
public void acceptConnections(){
try {
ServerSocket serverSocket = new ServerSocket(listenPort , 5) ;
Socket socket= null ;
while(true)
{
socket = serverSocket.accept() ;
PoolConnectionHandler.processRequest(socket) ;
}
} catch (IOException e) {
e.printStackTrace();
}

}

public void setHandlers()
{
for(int i = 0 ; i < this.maxConnections ; i++ )
{
PoolConnectionHandler poolHandler = new PoolConnectionHandler() ;
new Thread(poolHandler , "handler" + i).start() ;
}
}

public static void main(String [] args)
{
SocketServerPool pool = new SocketServerPool(8888 , 5) ;
pool.setHandlers() ;
pool.acceptConnections() ;
}

}

⑻ 关于JAVA socket编程

先运行服务器端类，然后再运行客户端类，就可以了

/**
*服务器端类
*/
public class Server {
public static void main(String[] args) throws IOException{
Server server = new Server();
server.start();
}
public void start() throws IOException{
//ServerSocket 对当前服务器的服务端口的绑定
//这个端口号不能重复绑定，不能同时执行两边
ServerSocket ss = new ServerSocket(8888);
while(true){

//accept 开始等待（IO Block）客户连接（启动监听），如果没有客户端连接，一直挂起等待下去。
//如果有客户端连接，才会继续执行下去，返回的Socket实例s 代表对于客户端连接。
Socket s = ss.accept();
//创建并启动客户服务线程，为客户服务
//当前线程再次返回到accept等待，下一个客户连接
new Service(s).start();//创建线程
}
}
class Service extends Thread{
Socket s;
public Service(Socket s){
this.s = s;
}
public void run(){
try{
//s代表客户端
//s 中的in代表从客户传递过来的流
//s 中的out代表从服务器到客户端传输流
InputStream in = s.getInputStream();
Scanner sc = new Scanner(in);//System.in是操作系统后台
OutputStream out = s.getOutputStream();
//out.write("您好！您需要点啥？\n".getBytes("GBK"));
//out.flush();//清理缓冲，确保发送到客户端

while(true){
String str = sc.nextLine();//IO Block
if(str.equals("连接服务器")){
out.write("连接成功!\n".getBytes("GBK"));
out.flush();
break;
}
}
}catch(IOException e){
e.printStackTrace();
}

}
}
}

/**
*客户端类
*/
public class Client {
public static void main(String[] args) throws IOException{
// new Socket() 连接到指定的服务器端口，当前用的是本机的端口
Socket s = new Socket("localhost", 8888);
//返回s代表连接到了服务器
//s代表对服务器的连接

InputStream in = s.getInputStream();
OutputStream out = s.getOutputStream();

out.write("连接服务器\n".getBytes("gbk"));
out.flush(); //清理缓冲，确保发送到服务端
Scanner sc = new Scanner(in);
String str = sc.nextLine();
System.out.println(str); //把从服务器返回的信息，打印到控制台。
out.flush();
}
}