采用tcp协议,使用socket编程,编写程序完成客户端发送消息给服务端,服务端接到消息后，再发

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了采用tcp协议,使用socket编程,编写程序完成客户端发送消息给服务端,服务端接到消息后，再发相关的知识，希望对你有一定的参考价值。

给客户端

参考技术A 服务端代码：
/*server.c*/

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <netinet/in.h>

#define PORT 4321
#define BUFFER_SIZE 1024
#define MAX_QUE_CONN_NM 5

int main()

struct sockaddr_in server_sockaddr, client_sockaddr;
int sin_size, recvbytes;
int sockfd, client_fd;
char buf[BUFFER_SIZE];

/*建立socket连接*/
if ((sockfd = socket(AF_INET,SOCK_STREAM,0))== -1)

perror("socket");
exit(1);

printf("Socket id = %d\n",sockfd);

/*设置sockaddr_in 结构体中相关参数*/
server_sockaddr.sin_family = AF_INET;
server_sockaddr.sin_port = htons(PORT);
server_sockaddr.sin_addr.s_addr = INADDR_ANY;
bzero(&(server_sockaddr.sin_zero), 8);

int i = 1;/* 使得重复使用本地地址与套接字进行绑定 */
setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i));

/*绑定函数bind*/
if (bind(sockfd, (struct sockaddr *)&server_sockaddr, sizeof(struct sockaddr))== -1)

perror("bind");
exit(1);

printf("Bind success!\n");

/*调用listen函数*/
if (listen(sockfd, MAX_QUE_CONN_NM) == -1)

perror("listen");
exit(1);

printf("Listening....\n");

/*调用accept函数，等待客户端的连接*/
if ((client_fd = accept(sockfd, (struct sockaddr *)&client_sockaddr, &sin_size)) == -1)

perror("accept");
exit(1);


/*调用recv函数接收客户端的请求*/
memset(buf , 0, sizeof(buf));
if ((recvbytes = recv(client_fd, buf, BUFFER_SIZE, 0)) == -1)

perror("recv");
exit(1);

printf("Received a message: %s\n", buf);

if ((sendbytes = send(sockfd, buf, strlen(buf), 0)) == -1)

perror("send");
exit(1);

close(sockfd);
exit(0);


客户端：
/*client.c*/

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <netdb.h>
#include <netinet/in.h>

#define PORT 4321
#define BUFFER_SIZE 1024

int main(int argc, char *argv[])

int sockfd, sendbytes;
char buf[BUFFER_SIZE];
struct hostent *host;
struct sockaddr_in serv_addr;

if(argc < 3)

fprintf(stderr,"USAGE: ./client Hostname(or ip address) Text\n");
exit(1);


/*地址解析函数*/
if ((host = gethostbyname(argv[1])) == NULL)

perror("gethostbyname");
exit(1);


memset(buf, 0, sizeof(buf));
sprintf(buf, "%s", argv[2]);

/*创建socket*/
if ((sockfd = socket(AF_INET,SOCK_STREAM,0)) == -1)

perror("socket");
exit(1);


/*设置sockaddr_in 结构体中相关参数*/
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);
serv_addr.sin_addr = *((struct in_addr *)host->h_addr);
bzero(&(serv_addr.sin_zero), 8);

/*调用connect函数主动发起对服务器端的连接*/
if(connect(sockfd,(struct sockaddr *)&serv_addr, sizeof(struct sockaddr))== -1)

perror("connect");
exit(1);


/*发送消息给服务器端*/
if ((sendbytes = send(sockfd, buf, strlen(buf), 0)) == -1)

perror("send");
exit(1);


if ((recvbytes = recv(sockfd, buf, BUFFER_SIZE, 0)) == -1)

perror("recv");
exit(1);


close(sockfd);
exit(0);
追问

这个c的我想求java的

追答

请看博客
http://www.jb51.net/article/45024.htm

基于 TCP/IP 协议的网络编程

在说明基于 TCP/IP 协议的网络编程之前，先来了解一下 Socket（网络套接字）：
  • 利用套接字(Socket)开发网络应用程序早已被广泛的采用，以至于成为事实上的标准
  • 通信的两端都要有 Socket，是两台机器间通信的端点（API 原话）
  • 网络通信其实就是 Socket 间的通信
  • Socket 允许程序把网络连接当成一个流，数据在两个 Socket 间通过 IO 传输
  • 一般主动发起通信的应用程序属客户端，等待通信请求的为服务端
网络编程某种程度上可以称作“Socket 编程”

TCP/IP 编程，简单模拟客户端与服务端之间的交互（先开 Server 再开 Client）：
  1. public class TestTCP {
  2. 	@Test
  3. 	public void client() {
  4. 		Socket socket = null;
  5. 		OutputStream os = null;
  6. 		try {
  7. 			// 创建 Socket 对象以指明目标 Server 的 IP 和端口
  8. 			socket = new Socket("127.0.0.1", 9876);
  9. 			// 调用该套接字对象的 getOutputStream()方法返回 OutputStream 对象以写出数据
  10. 			os = socket.getOutputStream();
  11. 			// 后面实际就是 IO 流的应用
  12. 			os.write("This is the message sent by client".getBytes());
  13. 		} catch (UnknownHostException e) {
  14. 			e.printStackTrace();
  15. 		} catch (IOException e) {
  16. 			e.printStackTrace();
  17. 		} finally {
  18. 			if (os != null) {
  19. 				try {
  20. 					os.close();
  21. 				} catch (IOException e) {
  22. 					e.printStackTrace();
  23. 				}
  24. 			}
  25. 			// socket 也是稀有资源，记得及时关闭
  26. 			if (socket != null) {
  27. 				try {
  28. 					socket.close();
  29. 				} catch (IOException e) {
  30. 					e.printStackTrace();
  31. 				}
  32. 			}
  33. 		}
  34. 	}
  36. 	@Test
  37. 	public void server() {
  38. 		ServerSocket ss = null;
  39. 		Socket socket = null;
  40. 		InputStream is = null;
  41. 		try {
  42. 			// 创建 ServerSocket 对象指明开放那个端口作为传输端口
  43. 			ss = new ServerSocket(9876);
  44. 			// 调用 accept()方法，返回一个 Socket 对象，监听 ServerSocket 对应的端口并且接受对该端口的连接
  45. 			socket = ss.accept();
  46. 			// 调用该套接字对象的 getInputStream()方法返回 InputStream 对象以写入从 client 接收到的数据
  47. 			is = socket.getInputStream();
  48. 			// 后面实际就是 IO 流的应用
  49. 			byte[] b = new byte[10];
  50. 			int len;
  51. 			while ((len = is.read(b)) != -1) {
  52. 				// 打印字节流
  53. 				System.out.print(new String(b, 0, len));
  54. 			}
  55. 		} catch (IOException e) {
  56. 			e.printStackTrace();
  57. 		} finally {
  58. 			if (is != null) {
  59. 				try {
  60. 					is.close();
  62. 				} catch (IOException e) {
  63. 					e.printStackTrace();
  64. 				}
  65. 			}
  66. 			if (socket != null) {
  67. 				try {
  68. 					socket.close();
  70. 				} catch (IOException e) {
  71. 					e.printStackTrace();
  72. 				}
  73. 			}
  74. 			if (ss != null) {
  75. 				try {
  76. 					ss.close();
  78. 				} catch (IOException e) {
  79. 					e.printStackTrace();
  80. 				}
  81. 			}
  82. 		}
  83. 	}
  84. }

若要实现多步交互，注意 Socket 方法的阻塞性问题，如果一直监听端口，就不能执行后续代码，故记得调用相关 shutdown 方法以关闭监听，以下例子修改自上例，实现在 Server 端收到字节流后，返回给 Client 一条反馈信息：
  1. public class TestTCP {
  2. 	@Test
  3. 	public void client() {
  4. 		Socket socket = null;
  5. 		OutputStream os = null;
  6. 		InputStream is = null;
  7. 		try {
  8. 			// 创建 Socket 对象以指明目标 Server 的 IP 和端口
  9. 			socket = new Socket("127.0.0.1", 9876);
  10. 			// 调用该套接字对象的 getOutputStream()方法返回 OutputStream 对象以写出数据
  11. 			os = socket.getOutputStream();
  12. 			// 后面实际就是 IO 流的应用
  13. 			os.write("This is the message sent by client".getBytes());
  15. 			// ----------update----------
  16. 			// 显式的禁用此套接字的输出流
  17. 			socket.shutdownOutput();
  18. 			// 接受反馈
  19. 			is = socket.getInputStream();
  20. 			byte[] b = new byte[10];
  21. 			int len;
  22. 			while ((len = is.read(b)) != -1) {
  23. 				System.out.print(new String(b, 0, len));
  24. 			}
  25. 			// ----------update----------
  27. 		} catch (UnknownHostException e) {
  28. 			e.printStackTrace();
  29. 		} catch (IOException e) {
  30. 			e.printStackTrace();
  31. 		} finally {
  32. 			if (os != null) {
  33. 				try {
  34. 					os.close();
  35. 				} catch (IOException e) {
  36. 					e.printStackTrace();
  37. 				}
  38. 			}
  39. 			// socket 也是稀有资源，记得及时关闭
  40. 			if (socket != null) {
  41. 				try {
  42. 					socket.close();
  43. 				} catch (IOException e) {
  44. 					e.printStackTrace();
  45. 				}
  46. 			}
  47. 		}
  48. 	}
  50. 	@Test
  51. 	public void server() {
  52. 		ServerSocket ss = null;
  53. 		Socket socket = null;
  54. 		InputStream is = null;
  55. 		OutputStream os = null;
  56. 		try {
  57. 			// 创建 ServerSocket 对象指明开放那个端口作为传输端口
  58. 			ss = new ServerSocket(9876);
  59. 			// 调用 accept()方法，返回一个 Socket 对象，监听 ServerSocket 对应的端口并且接受对该端口的连接
  60. 			socket = ss.accept();
  61. 			// 调用该套接字对象的 getInputStream()方法返回 InputStream 对象以写入从 client 接收到的数据
  62. 			is = socket.getInputStream();
  63. 			// 后面实际就是 IO 流的应用
  64. 			byte[] b = new byte[10];
  65. 			int len;
  66. 			while ((len = is.read(b)) != -1) {
  67. 				// 打印字节流
  68. 				System.out.print(new String(b, 0, len));
  69. 			}
  71. 			// ----------update----------
  72. 			// 反馈一条消息给 Client
  73. 			os = socket.getOutputStream();
  74. 			os.write("I have received your message".getBytes());
  75. 			// ----------update----------
  77. 		} catch (IOException e) {
  78. 			e.printStackTrace();
  79. 		} finally {
  80. 			if (os != null) {
  81. 				try {
  82. 					os.close();
  84. 				} catch (IOException e) {
  85. 					e.printStackTrace();
  86. 				}
  87. 			}
  88. 			if (is != null) {
  89. 				try {
  90. 					is.close();
  92. 				} catch (IOException e) {
  93. 					e.printStackTrace();
  94. 				}
  95. 			}
  96. 			if (socket != null) {
  97. 				try {
  98. 					socket.close();
  100. 				} catch (IOException e) {
  101. 					e.printStackTrace();
  102. 				}
  103. 			}
  104. 			if (ss != null) {
  105. 				try {
  106. 					ss.close();
  108. 				} catch (IOException e) {
  109. 					e.printStackTrace();
  110. 				}
  111. 			}
  112. 		}
  113. 	}
  114. }

以上是关于采用tcp协议,使用socket编程,编写程序完成客户端发送消息给服务端,服务端接到消息后，再发的主要内容，如果未能解决你的问题，请参考以下文章

Socket网络编程

Socket网络编程

基于 TCP/IP 协议的网络编程

java Socket编程

Java基础知识—网络Socket

GO语言Socket编程详解