Java socket编程的实现过程

1.socket 服务器搭建

实例化socket服务器,循环获取请求

 

package com.orange.util;

import java.io.IOException;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.Timer;

import java.util.TimerTask;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

/**

* socket服务器

*

* @author Chengjq

*

*/

public class SocketServer {

public static int count = 0;

public static void main(String[] args) {

// TODO 自动生成的方法存根

int port = 4404;

// 首先直接创建serversocket

ServerSocket serverSocket = null;

Socket socket = null;

try {

serverSocket = new ServerSocket(port);

System.out.println(“启动socketServer成功,等待客户端的连接”);

while (true) {

socket = serverSocket.accept();

System.out.println(“有新的客户端请求连接”);

SocketThread st = new SocketThread(socket);

st.start();

ChatManager.getChatManager().add(st);

//启动定时任务,如果10s内没有进程

/*Runnable runnable = new Runnable() {

int clientNum = 0;

public void run() {

// task to run goes here

clientNum = ChatManager.getChatManager().vector.size();

System.out.println(“剩余客户端数量:”+clientNum);

if(clientNum ==0 ){

System.out.println(“连接超时,或者无客户端连接,关闭serverSocket”);

//关闭socket

//…..

}

}

};

ScheduledExecutorService service = Executors

.newSingleThreadScheduledExecutor();

// 第二个参数为首次执行的延时时间,第三个参数为定时执行的间隔时间

service.scheduleAtFixedRate(runnable, 2, 10, TimeUnit.SECONDS); */

}

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} finally {

System.out.println(“serverSocket已超时”);

try {

socket.close();

serverSocket.close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}

SocketThread类实现多线程通信

 

package com.orange.util;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.ServerSocket;

import java.net.Socket;

/**

* SocketThread实现多线程通信

*

* @author Administrator

*

*/

public class SocketThread extends Thread {

ServerSocket serverSocket = null;

Socket socket = null;

public SocketThread(ServerSocket serverSocket,Socket socket) {

super();

this.serverSocket = serverSocket;

this.socket = socket;

}

public SocketThread(Socket socket) {

super();

this.socket = socket;

}

public void out(String out) {

try {

socket.getOutputStream().write(out.getBytes(“utf-8”));

} catch (IOException e) {

e.printStackTrace();

}

}

public void publish(String out){

ChatManager.getChatManager().publish(this, out);

}

@Override

public void run() {

// TODO Auto-generated method stub

BufferedReader socketIn = null;

PrintWriter socketOut = null;

String inMess = null;

try {

socketIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));

socketOut = new PrintWriter(socket.getOutputStream());

while (true) {

inMess = socketIn.readLine();

publish(inMess);

if(“bye”.equals(inMess)){

ChatManager.getChatManager().remove(this);

}

}

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} finally {

try {

System.out.println(“已结束当前会话”);

socketOut.close();

socketIn.close();

socket.close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}

单例Chatmanage,对所有客户端线程管控处理

 

package com.orange.util;

import java.util.Vector;

public class ChatManager {

// 实现单例化

private ChatManager() {

};

private static final ChatManager cm = new ChatManager();

public static ChatManager getChatManager() {// 返回值为ChatManager

return cm;

}

// 单例化完成

Vector vector = new Vector();

public void add(SocketThread st) {// 为当前集合添加SocketThread对象

vector.add(st);

}

public void remove(SocketThread st) {// 当前客户端关闭连接

vector.remove(st);

}

public void removeall() {// 关闭所有连接

for (int i = 0; i < vector.size(); i++) {// 遍历所有的线程

SocketThread csChatSocket = vector.get(i);

if(csChatSocket!=null){

vector.remove(csChatSocket);

}

}

}

// 某一个线程向其他的客户端发送信息

public void publish(SocketThread st, String out) {

for (int i = 0; i < vector.size(); i++) {// 遍历所有的线程

SocketThread csChatSocket = vector.get(i);

if (csChatSocket != st)// 判断不是当前线程就发送此消息

csChatSocket.out(out + “\n”);

}

}

// 向当前线程发信息

public void publish_present(SocketThread st, String out) {

st.out(out + “\n”);

}

}

至此,服务器搭建完成

2.客户端(创建两个客户端)

客户端1(监听指定服务器,通过控制台输入消息进行服务器与客户端以及客户端之间的通信,)

 

package com.orange;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.Socket;

import java.net.UnknownHostException;

/**

* 客户端1

* @author Chengjq

*

*/

public class SocketClient1 {

@SuppressWarnings(“static-access”)

public static void main(String[] args) {

try {

//初始化客户端

Socket socket = new Socket(“127.0.0.1”, 4404);

BufferedReader readline = new BufferedReader(new InputStreamReader(System.in));

//获取输出打印流

PrintWriter socketOut = new PrintWriter(socket.getOutputStream());

String outTemp = null;

System.out.println(“开始准备向服务器端发起请求—\n自己:”);

// 已启动连接socket服务器,准备实时接收来自其他客户端的消息

GetMess getMess = new GetMess(socket);

getMess.start();

// 通过控制台发送消息给其他客户端,以“bye”为结束语

while ((outTemp = readline.readLine()) != null) {

//发送信息

socketOut.println(outTemp);

socketOut.flush();

if(“bye”.equals(outTemp)){

break;

}

}

getMess.currentThread().interrupt();

//依次关闭各种流

readline.close();

socketOut.close();

socket.close();

} catch (UnknownHostException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

客户端2

 

package com.orange;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.Socket;

import java.net.UnknownHostException;

public class SocketClient2 {

@SuppressWarnings(“static-access”)

public static void main(String[] args) {

try {

//初始化客户端

Socket socket = new Socket(“127.0.0.1”, 4404);

BufferedReader readline = new BufferedReader(new InputStreamReader(System.in));

//获取输出打印流

PrintWriter socketOut = new PrintWriter(socket.getOutputStream());

String outTemp = null;

System.out.println(“开始准备向服务器端发起请求—\n自己:”);

// 已启动连接socket服务器,准备实时接收来自其他客户端的消息

GetMess getMess = new GetMess(socket);

getMess.start();

// 通过控制台发送消息给其他客户端,以“bye”为结束语

while ((outTemp = readline.readLine()) != null) {

//发送信息

socketOut.println(outTemp);

socketOut.flush();

if(“bye”.equals(outTemp)){

break;

}

}

getMess.currentThread().interrupt();

//依次关闭各种流

readline.close();

socketOut.close();

socket.close();

} catch (UnknownHostException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

GetMess(多线程处理获取其他客户端的消息并且展示)

 

package com.orange;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.net.Socket;

public class GetMess extends Thread {

Socket socket = null;

public GetMess(Socket socket) {

super();

this.socket = socket;

}

@Override

public void run() {

// TODO Auto-generated method stub

BufferedReader socketIn = null;

try {

InputStream is = socket.getInputStream();

InputStreamReader isr = new InputStreamReader(is);

socketIn = new BufferedReader(isr);

String inTemp = null;

while(true){

inTemp = socketIn.readLine();

if(inTemp != null && !”bye”.equals(inTemp) ){

System.out.println(“好友:\n”+inTemp);

}else{

System.out.println(“好友:\n已下线,关闭当前回话”);

break;

}

}

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}finally {

try {

Thread.currentThread().interrupt();

socketIn.close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

}

ok,简单的sockte服务与客户端完成了