一般是用一个线程池来处理接受到的请求
直接上代码(一)
ServerThread层
1 import java.io.BufferedReader; 2 import java.io.InputStreamReader; 3 import java.io.PrintWriter; 4 import java.net.socket; 5
6 public class ServerThread extends Thread { 7 private static int number = 0; // 保存本进程的客户计数
8
9 Socket socket = null; // 保存与本线程相关的Socket对象
10
11 public ServerThread(Socket socket,int clientnum) { 12
13 this.socket = socket; 14 number = clientnum; 15 System.out.println("当前在线的用户数: " + number); 16 } 17
18 @Override 19 public void run() { 20 try { 21
22 // 由Socket对象得到输入流,并构造相应的BufferedReader对象
23 BufferedReader in = new BufferedReader(new InputStreamReader(socket 24 .getInputStream())); 25
26 // 由Socket对象得到输出流,并构造PrintWriter对象
27 PrintWriter out = new PrintWriter(socket.getoutputStream()); 28
29 // 由系统标准输入设备构造BufferedReader对象
30 BufferedReader sysin = new BufferedReader(new InputStreamReader( 31 system.in)); 32
33 // 在标准输出上打印从客户端读入的字符串
34 System.out.println("[Client " + number + "]: " + in.readLine()); 35
36 String line; // 保存一行内容 37
38 // 从标准输入读入一字符串
39 line = sysin.readLine(); 40
41 while (!line.equals("bye")) { // 如果该字符串为 "bye",则停止循环 42
43 // 向客户端输出该字符串
44 out.println(line); 45
46 // 刷新输出流,使Client马上收到该字符串
47 out.flush(); 48
49 // 在系统标准输出上打印读入的字符串
50 System.out.println("[Server]: " + line); 51
52 // 从Client读入一字符串,并打印到标准输出上
53 System.out.println("[Client " + number + "]: " + in.readLine()); 54
55 // 从系统标准输入读入一字符串
56 line = sysin.readLine(); 57 } 58
59 out.close(); // 关闭Socket输出流
60 in.close(); // 关闭Socket输入流
61 socket.close(); // 关闭Socket
62 } catch (Exception e) { 63 System.out.println("Error. " + e); 64 } 65 } 66 }
SocketClient层
import java.io.BufferedReader; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.socket; /** * 客户端Socket * * @author Administrator * */
public class SocketClient { /** * 客户端Socket构造方法 */
public SocketClient() { try { // 向本机的2121端口发出客户请求
Socket socket = new Socket("localhost",2121); System.out.println("Established a connection..."); // 由系统标准输入设备构造BufferedReader对象
BufferedReader sysin = new BufferedReader(new InputStreamReader( system.in)); // 由Socket对象得到输出流,并构造PrintWriter对象
PrintWriter out = new PrintWriter(socket.getoutputStream()); // 由Socket对象得到输入流,并构造相应的BufferedReader对象
BufferedReader in = new BufferedReader(new InputStreamReader(socket .getInputStream())); String line; // 保存一行内容 // 从系统标准输入读入一字符串
line = sysin.readLine(); while (!line.equals("bye")) { // 若从标准输入读入的字符串为 "bye"则停止循环 // 将从系统标准输入读入的字符串输出到Server
out.println(line); // 刷新输出流,使Server马上收到该字符串
out.flush(); // 在系统标准输出上打印读入的字符串
System.out.println("[Client]: " + line); // 从Server读入一字符串,并打印到标准输出上
System.out.println("[Server]: " + in.readLine()); // 从系统标准输入读入一字符串
line = sysin.readLine(); } out.close(); // 关闭Socket输出流
in.close(); // 关闭Socket输入流
socket.close(); // 关闭Socket
} catch (Exception e) { System.out.println("Error. " + e); } } /** * 主方法 * * @param args */
public static void main(String[] args) { new SocketClient(); } }
SocketServer层
import java.net.ServerSocket; /** * 服务器端Socket * * @author Administrator * */
public class SocketServer { /** * 服务器端Socket构造方法 */
public SocketServer() { try { int clientcount = 0; // 统计客户端总数
boolean listening = true; // 是否对客户端进行监听
ServerSocket server = null; // 服务器端Socket对象
try { // 创建一个ServerSocket在端口2121监听客户请求
server = new ServerSocket(2121); System.out.println("Server starts开始启动..."); } catch (Exception e) { System.out.println("Can not listen to. " + e); } while (listening) { // 客户端计数
clientcount++; // 监听到客户请求,根据得到的Socket对象和客户计数创建服务线程,并启动之
new ServerThread(server.accept(),clientcount).start(); } } catch (Exception e) { System.out.println("Error. " + e); } } /** * 主方法 * * @param args */
public static void main(String[] args) { new SocketServer(); } }
下面是Demo案例
Server端
package cn.kgc.sockettest.demo1; import java.io.*; import java.net.ServerSocket; import java.net.socket; /** * 服务端 */
public class Server { public static void main(String[] args) { try { ServerSocket serverSocket = new ServerSocket(8080); System.out.println("服务器启动完成...监听中"); //开启监听,等待客户端的访问
Socket socket = serverSocket.accept(); //获取输入流,因为是客户端向服务端发送了数据
InputStream inputStream = socket.getInputStream(); //创建一个缓冲流
BufferedReader br = new BufferedReader(new InputStreamReader(inputStream)); String info = null; while ((info = br.readLine()) != null) { System.out.println("这里是服务端 客户端是:" + info); } //向客户端做出相应
OutputStream outputStream = socket.getoutputStream(); info = "这里是服务端我们接受到了你消息"; outputStream.write(info.getBytes()); outputStream.close(); } catch (IOException e) { e.printstacktrace(); } } }
Client端
package cn.kgc.sockettest.demo1; import java.io.*; import java.net.socket; /** * 客户端 */
public class Client { public static void main(String[] args) { try { //IP地址
Socket socket = new Socket("localhost",8080); OutputStream outputStream = socket.getoutputStream(); String info ="你好"; //输出!
outputStream.write(info.getBytes()); socket.shutdownOutput(); //接受服务器的响应
InputStream inputStream = socket.getInputStream(); BufferedReader br = new BufferedReader(new InputStreamReader(inputStream)); while((info =br.readLine())!=null){ System.out.println("接收到了服务器的响应:"+info); } outputStream.flush(); outputStream.close(); inputStream.close(); socket.close(); } catch (IOException e) { e.printstacktrace(); } } }
(二)
User层
package cn.kgc.sockettest.demo1.demo2; import java.io.Serializable; public class User implements Serializable { private String userName; private String password; public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } @Override public String toString() { return "Server{" +
"userName=‘" + userName + ‘\‘‘ +
",password=‘" + password + ‘\‘‘ +
‘}‘; } public String getpassword() { return password; } public void setPassword(String password) { this.password = password; } }
Server端
package cn.kgc.sockettest.demo1.demo2; import java.io.IOException; import java.io.InputStream; import java.io.ObjectInputStream; import java.net.ServerSocket; import java.net.socket; public class Server { public static void main(String[] args) { try { ServerSocket serverSocket = new ServerSocket(8080); System.out.println("服务器启动完成。。。。。"); //开始监听
Socket socket = serverSocket.accept(); InputStream inputStream = socket.getInputStream(); ObjectInputStream stream = new ObjectInputStream(inputStream); User user =(User)stream.readobject(); System.out.println("客户端发过来的数据是:"+user); } catch (Exception e) { e.printstacktrace(); } } }
Client层
package cn.kgc.sockettest.demo1.demo2; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.OutputStream; import java.net.socket; /** * 客户端 */
public class Client { public static void main(String[] args) { try { Socket socket = new Socket("localhost",8080); OutputStream outputStream = socket.getoutputStream(); User user = new User(); user.setUserName("张三"); user.setPassword("admin"); //创建对象输出流
ObjectOutputStream oos = new ObjectOutputStream(outputStream); //序列化对象
oos.writeObject(user); //关闭流
oos.close(); socket.close(); } catch (Exception e) { e.printstacktrace(); } } }
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。