devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JAVA--基于TCP协议的Socket编程_java tcp socket

作者：羊村懒王 | 2024-06-11 18:37:28

赞

踩

java tcp socket

目录

        一、Socket类和ServerSocket类

1. Socket类

 2. ServerSocket类

二、 使用TCP的 Socket编程实现登录功能

1. 实现单用户登录

2. 实现多客户端用户登录

3. InetAddress类

一、Socket类和ServerSocket类

        TCP具有很好的安全性能

         速度较慢

（1）java.net包的两个类Socket和ServerSocket，分别用来实现双向安全连接的客户端和服务器端，它们是基于TCP协议进行工作的，工作过程如同打电话的过程，只有双方都接通了，才能开始通话。

（2）进行网络通信时，Socket需要借助数据流来完成数据的传递工作。

（3）一个应用程序要通过网络向另一个应用程序发送数据，只要简单地创建Socket，然后将数据写入到与该Socket关联的输出流即可。对应的，接收方的应用程序创建Socket，从相关联的输入流读取数据即可。

（4）注意：2个端点在基于TCP协议的Socket编程中，经常一个作为客户端，一个作为服务器端，也就是遵循client-server模型。


1. Socket类

Socket对象在客户端和服务器之间建立连接。可用Socket类的构造方法创建套接字，并将此套接字连接至指定的主机和端口。

（1）构造方法

-->第一种构造方法以主机名和端口号作为参数来创建一个Socket对象。创建对象时可能抛出UnknownHostException或IOException异常，必须捕获它们。

Socket s = new Socket(hostName,port);

-->第二种构造方法以InetAddress对象和端口号作为参数来创建一个Socket对象。构造方法可能抛出IOException或UnknownHostException异常，必须捕获并处理它们。

Socket s = new Socket(address,port);

（2）常用方法

 2. ServerSocket类

ServerSocket对象等待客户端建立连接，连接建立以后进行通信。

（1）构造方法

-->第一种构造方法接受端口号作为参数创建ServerSocket对象，创建此对象时可能抛出IOException异常，必须捕获和处理它。

ServerSocket ss = new ServerSocket(port);

-->第二种构造方法接受端口号和最大队列长度作为参数，队列长度表示系统在拒绝连接前可以拥有的最大客户端连接数。

ServerSocket ss = new ServerSocket(port,maxqu);

（2）常用方法

-->Socket类中列出的方法也适用于ServerSocket类。

-->ServerSocket类具有accept()方法，此方法用于等待客户端发起通信，这样Socket对象就可用于进一步的数据传输。


二、 使用TCP的 Socket编程实现登录功能

1. 实现单用户登录

-->Socket网络编程一般分成如下4个步骤进行：

（1）建立连接。

（2）打开Socket关联的输入/输出流。

（3）从数据流中写入信息和读取信息。

（4）关闭所有的数据流和Socket。

-->使用两个类模拟实现用户登录的功能，实现客户端向服务器端发送用户登录信息，服务器端显示这些信息。

    客户端实现步骤：

    1）建立连接，连接指向服务器及端口。

    2）打开Socket关联的输入/输出流。

    3）向输出流中写入信息。

    4）从输入流中读取响应信息。

    5）关闭所有的数据流和Socket。

    服务器端实现步骤：

    1）建立连接，监听端口。

    2）使用accept()方法等待客户端发起通信

    3）打开Socket关联的输入/输出流。

    4）从输入流中读取请求信息。

    5）向输出流中写入信息。

    6）关闭所有的数据流和Socket。

-->客户端和服务器端的交互，采用一问一答的模式，先启动服务器进入监听状态，等待客户端的连接请求，连接成功以后，客户端先“发言”，服务器给予“回应”。

1.1 客户端

  1. package demo02;
  2.  
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.InputStreamReader;
  7. import java.io.ObjectOutputStream;
  8. import java.io.OutputStream;
  9. import java.net.Socket;
  10. import java.net.UnknownHostException;
  11.  
  12. /**
  13.  * 示例02：升级演示示例01，实现传递对象信息。
  14.  */
  15. public class LoginClient {
  16.  
  17. 	/*
  18. 	 * 示例02：升级演示示例01，实现传递对象信息。
  19. 	 */
  20. 	
  21. 	public static void main(String[] args) {
  22. 		
  23. 		Socket socket = null;
  24. 		OutputStream os = null;
  25. 		ObjectOutputStream oos = null;
  26. 		InputStream is = null;
  27. 		BufferedReader br = null;
  28. 		
  29. 		try {
  30. 			
  31. 			// 建立客户端Socket连接，指定服务器的位置为本机以及端口为8800
  32. 			socket = new Socket("localhost", 8800);
  33. 			
  34. 			// 打开输出流
  35. 			os = socket.getOutputStream();
  36. 			
  37. 			// 对象序列化
  38. 			oos = new ObjectOutputStream(os);
  39. 			
  40. 			// 发送客户端信息，即向输出流中写入信息
  41. 			User user = new User("Tom", "123456");
  42. 			oos.writeObject(user);
  43. 			socket.shutdownOutput();
  44.  
  45. 			// 接收服务器端的响应，即从输入流中读取信息
  46. 			is = socket.getInputStream();
  47. 			br = new BufferedReader(new InputStreamReader(is));
  48. 			
  49. 			String reply;
  50. 			while ((reply = br.readLine()) != null) {
  51. 				System.out.println("我是客户端，服务器的响应为：" + reply);
  52. 			}
  53. 		} catch (UnknownHostException e) {
  54. 			e.printStackTrace();
  55. 		} catch (IOException e) {
  56. 			e.printStackTrace();
  57. 		} finally {
  58. 			try {
  59. 				
  60. 				//关闭遵循 先开后关 后开先关的原则
  61. 				br.close();
  62. 				is.close();
  63. 				oos.close();
  64. 				os.close();
  65. 				socket.close();
  66. 			} catch (IOException e) {
  67. 				e.printStackTrace();
  68. 			}
  69.  
  70. 		}
  71. 	}
  72.  
  73. }

 1.2   服务器端

  1. package demo02;
  2.  
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.ObjectInputStream;
  6. import java.io.OutputStream;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  9.  
  10. /**
  11.  * 示例02：升级演示示例01，实现传递对象信息。
  12.  * 
  13.  */
  14. public class LoginServer {
  15.  
  16. 	public static void main(String[] args) {
  17. 		
  18. 		ServerSocket serverSocket = null;
  19. 		Socket socket = null;
  20. 		InputStream is = null;
  21. 		ObjectInputStream ois = null;
  22. 		OutputStream os = null;
  23. 		
  24. 		try {
  25. 			
  26. 			// 建立一个服务器Socket（ServerSocket），指定端口8800并开始监听
  27. 			serverSocket = new ServerSocket(8800);
  28. 			
  29. 			// 使用accept()方法等待客户端发起通信
  30. 			socket = serverSocket.accept();
  31. 			
  32. 			// 打开输入流
  33. 			is = socket.getInputStream();
  34. 			
  35. 			// 反序列化
  36. 			ois = new ObjectInputStream(is);
  37. 			
  38. 			// 获取客户端信息，即从输入流读取信息
  39. 			User user = (User) ois.readObject();
  40. 			if (user != null) {
  41. 				System.out.println("我是服务器，客户登录信息为：" + user.getLoginName() + "，"
  42. 						+ user.getPwd());
  43. 			}
  44.  
  45. 			// 给客户端一个响应，即向输出流中写入信息
  46. 			String reply = "欢迎你，登录成功";
  47. 			os = socket.getOutputStream();
  48. 			os.write(reply.getBytes());
  49. 		} catch (IOException e) {
  50. 			e.printStackTrace();
  51. 		} catch (ClassNotFoundException e) {
  52. 			e.printStackTrace();
  53. 		} finally {
  54. 			// 关闭资源
  55. 			try {
  56. 				os.close();
  57. 				ois.close();
  58. 				is.close();
  59. 				socket.close();
  60. 				serverSocket.close();
  61. 			} catch (IOException e) {
  62. 				e.printStackTrace();
  63. 			}
  64.  
  65. 		}
  66.  
  67. 	}
  68.  
  69. }

1.3 定义类   实现实例化  接口

  1. package demo02;
  2.  
  3. import java.io.Serializable;
  4.  
  5. /**
  6.  * 示例02：升级演示示例01，实现传递对象信息
  7.  * 
  8.  */
  9. public class User implements Serializable {
  10.  
  11. 	private static final long serialVersionUID = 1L;
  12. 	/** 用户名 */
  13. 	private String loginName;
  14. 	/** 用户密码 */
  15. 	private String pwd;
  16.  
  17. 	public User() {
  18. 		super();
  19. 	}
  20.  
  21. 	public User(String loginName, String pwd) {
  22. 		super();
  23. 		this.loginName = loginName;
  24. 		this.pwd = pwd;
  25. 	}
  26.  
  27. 	public String getLoginName() {
  28. 		return loginName;
  29. 	}
  30.  
  31. 	public void setLoginName(String loginName) {
  32. 		this.loginName = loginName;
  33. 	}
  34.  
  35. 	public String getPwd() {
  36. 		return pwd;
  37. 	}
  38.  
  39. 	public void setPwd(String pwd) {
  40. 		this.pwd = pwd;
  41. 	}
  42.  
  43. }

 


2. 实现多客户端用户登录

-->一问一答的模式在现实中显然不是人们想要的。一个服务器不可能只针对一个客户端服务，一般是面向很多的客户端同时提供服务的，但是单线程实现必然是这样的结果。

-->解决这个问题的办法是采用多线程的方式，可以在服务器端创建一个专门负责监听的应用主服务程序、一个专门负责响应的线程程序。这样可以利用多线程处理多个请求。

->客户端实现步骤：

1）建立连接，连接指向服务器及端口。

2）打开Socket关联的输入/输出流。

3）向输出流中写入信息。

4）从输入流中读取响应信息。

5）关闭所有的数据流和Socket。

-->服务器端实现步骤：

1）创建服务器线程类，run()方法中实现对一个请求的响应处理。

2）修改服务器端代码，让服务器端Socket一直处于监听状态。

3）服务器端每监听到一个请求，创建一个线程对象并启动。

2.1 ->多个客户端*3    表示三个IP   昵称不同的三个用户   

  1. package demo03;
  2.  
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.InputStreamReader;
  7. import java.io.ObjectOutputStream;
  8. import java.io.OutputStream;
  9. import java.net.Socket;
  10. import java.net.UnknownHostException;
  11.  
  12. /**
  13.  * 示例03：升级示例02，实现多客户端的响应处理
  14.  * 
  15.  
  16.  * 
  17.  */
  18. public class LoginClient01 {
  19. 	/*
  20. 	 * 客户端通过输出流向服务器端发送请求信息
  21. 	 * 服务器侦听客户端的请求得到一个Socket对象，将这个Socket对象传递给线程类
  22. 	 * 线程类通过输入流获取客户端的请求并通过输出流向客户端发送响应信息
  23. 	 * 客户端通过输入流读取服务器发送的响应信息
  24. 	 * 
  25. 	 */
  26.  
  27. 	/*
  28. 	 * 示例03：升级演示示例02，实现多客户端的响应处理
  29. 	 */
  30. 	public static void main(String[] args) {
  31. 		
  32. 		Socket socket = null;
  33. 		OutputStream os = null;
  34. 		ObjectOutputStream oos = null;
  35. 		InputStream is = null;
  36. 		BufferedReader br = null;
  37. 		try {
  38. 			// 建立客户端Socket连接，指定服务器的位置为本机以及端口为8800
  39. 			socket = new Socket("localhost", 8800);
  40. 			// 打开输出流
  41. 			os = socket.getOutputStream();
  42. 			// 对象序列化
  43. 			oos = new ObjectOutputStream(os);
  44. 			// 发送客户端信息，即向输出流中写入信息
  45. 			User user = new User("Tom", "123456");
  46. 			oos.writeObject(user);
  47. 			socket.shutdownOutput();
  48.  
  49. 			// 接收服务器端的响应，即从输入流中读取信息
  50. 			is = socket.getInputStream();
  51. 			br = new BufferedReader(new InputStreamReader(is));
  52. 			String reply;
  53. 			while ((reply = br.readLine()) != null) {
  54. 				System.out.println("我是客户端，服务器的响应为：" + reply);
  55. 			}
  56. 		} catch (UnknownHostException e) {
  57. 			e.printStackTrace();
  58. 		} catch (IOException e) {
  59. 			e.printStackTrace();
  60. 		} finally {
  61. 			try {
  62. 				br.close();
  63. 				is.close();
  64. 				oos.close();
  65. 				os.close();
  66. 				socket.close();
  67. 			} catch (IOException e) {
  68. 				e.printStackTrace();
  69. 			}
  70.  
  71. 		}
  72. 	}
  73.  
  74. }

2.2 ->服务器端

  1. package demo03;
  2.  
  3. import java.io.IOException;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  6.  
  7. /**
  8.  * 示例03：升级示例02，实现多客户端的响应处理
  9.  * 
  10.  */
  11. public class LoginServer {
  12. 	
  13. 	public static void main(String[] args) {
  14. 		
  15. 		ServerSocket serverSocket = null;
  16. 		try {
  17. 			// 建立一个服务器Socket(ServerSocket)指定端口并开始监听
  18. 			serverSocket = new ServerSocket(8800);
  19.  
  20. 			// 监听一直进行中
  21. 			while (true) {
  22. 				// 使用accept()方法等待客户发起通信
  23. 				Socket socket = serverSocket.accept();
  24. 				LoginThread loginThread = new LoginThread(socket);
  25. 				loginThread.start();
  26. 			}
  27. 		} catch (IOException e) {
  28. 			e.printStackTrace();
  29. 		}
  30.  
  31. 	}
  32.  
  33. }

2.3 --->创建服务器端线程类

  1. package demo03;
  2.  
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.ObjectInputStream;
  6. import java.io.OutputStream;
  7. import java.net.Socket;
  8.  
  9. /**
  10.  * 示例03：升级示例02，实现多客户端的响应处理。
  11.  * 
  12.  *
  13.  */
  14. public class LoginThread extends Thread {
  15. 	/*
  16. 	 * 示例03：升级示例02，实现多客户端的响应处理。
  17. 	 * 
  18. 	 * 分析如下：
  19. 	 * 	（1）创建服务器端线程类，run()方法中实现对一个请求的响应处理。
  20. 	 * 	（2）修改服务器端代码，让服务器端Socket一直处于监听状态。
  21. 	 * 	（3）服务器端每监听到一个请求，创建一个线程对象并启动
  22. 	 */
  23. 	
  24. 	Socket socket = null;
  25. 	//每启动一个线程，连接对应的Socket
  26.  
  27. 	public LoginThread(Socket socket) {
  28. 		this.socket = socket;
  29. 	}
  30. 	
  31. 	//启动线程，即响应客户请求
  32. 	public void run() {
  33. 		InputStream is = null;
  34. 		ObjectInputStream ois = null;
  35. 		OutputStream os = null;
  36. 		try {
  37. 			//打开输入流
  38. 			is = socket.getInputStream();
  39. 			//反序列化
  40. 			ois = new ObjectInputStream(is);
  41. 			//获取客户端信息，即从输入流读取信息
  42. 			User user = (User)ois.readObject();
  43. 			if(user!=null){
  44. 				System.out.println("我是服务器，客户登录信息为："+user.getLoginName()+"，"+user.getPwd());
  45. 			}
  46. 			
  47. 			//给客户端一个响应，即向输出流中写入信息
  48. 			os = socket.getOutputStream();
  49. 			String reply = "欢迎你，登录成功";
  50. 			os.write(reply.getBytes());
  51. 		} catch (IOException e) {
  52. 			e.printStackTrace();
  53. 		} catch (ClassNotFoundException e) {
  54. 			e.printStackTrace();
  55. 		}finally{
  56. 			try {
  57. 				os.close();
  58. 				ois.close();
  59. 				is.close();
  60. 				socket.close();
  61. 			} catch (IOException e) {
  62. 				e.printStackTrace();
  63. 			}
  64. 			
  65. 		}
  66. 	
  67. 	}
  68. 	
  69. }

 2.4 -->创建用户类

  1. package demo03;
  2.  
  3. import java.io.Serializable;
  4.  
  5. /**
  6.  * 示例03：升级示例02，实现多客户端的响应处理。
  8.  * 
  9.  */
  10. public class User implements Serializable {
  11.  
  12. 	private static final long serialVersionUID = 1L;
  13. 	/** 用户名 */
  14. 	private String loginName;
  15. 	/** 用户密码 */
  16. 	private String pwd;
  17.  
  18. 	public User() {
  19. 		super();
  20. 	}
  21.  
  22. 	public User(String loginName, String pwd) {
  23. 		super();
  24. 		this.loginName = loginName;
  25. 		this.pwd = pwd;
  26. 	}
  27.  
  28. 	public String getLoginName() {
  29. 		return loginName;
  30. 	}
  31.  
  32. 	public void setLoginName(String loginName) {
  33. 		this.loginName = loginName;
  34. 	}
  35.  
  36. 	public String getPwd() {
  37. 		return pwd;
  38. 	}
  39.  
  40. 	public void setPwd(String pwd) {
  41. 		this.pwd = pwd;
  42. 	}
  43.  
  44. }


3. InetAddress类

-->java.net包中的InetAddress类用于封装IP地址和DNS。要创建InetAddress类的实例，可以使用工厂方法，因为此类没有构造方法。

-->InetAddress类中的工厂方法

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号