Scoket 简单实现通信原理



直接代码 Scoket服务器端代码



#import "AppDelegate.h"
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
@interface AppDelegate ()
{
     //标识服务器
    int server_flag;
     // 标识客户端
    int  client_flag;
    // 地址
    struct sockaddr_in addr;
}
@end
@implementation AppDelegate
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {

    // 服务器端代码

    //1.创建标示符
    // 参数1:网络类型ipv4 ipv6
    // 参数2:通信协议
    server_flag = socket(AF_INET, SOCK_STREAM, 0);
    //2.将服务器标示符绑定到一个具体的计算机
    // 端口号
    addr.sin_port = htons(9007);
    //
    addr.sin_family = AF_INET;
    // 本机地址
    addr.sin_addr.s_addr = INADDR_ANY;

    //接收返回值
    int error = -1;
    //绑定
     error = bind(server_flag, (struct sockaddr *)&addr, sizeof(addr));
    //3.设置最大连接数
     error = listen(server_flag, 80);
    //4.服务器等待
    while (1) {
    //5.收到客户端请求，生成一个标志位 作为客户端标识
        client_flag = accept(server_flag,NULL,NULL);
    //6.发送信息
        send(client_flag, "Hello,Lanou!", 100, 0);
    //7.接收信息
        char buff[1024];
        long length = 0;
        //
        length = recv(client_flag, buff, 1024, 0);
        buff[length] = '\0';
        // 打印
        printf("client say:%s",buff);

        //8.关闭
        //close(client_flag);   
    }
    return YES;
}



直接代码 Scoket客户端代码



#import "AppDelegate.h"
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
@interface AppDelegate ()
{
  //地址
    struct sockaddr_in server;
  //标示符
    int client_flag;
}
@end
@implementation AppDelegate
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
   //错误信息
    int  error = -1;
   // 生成客户端的标示符
    client_flag = socket(AF_INET, SOCK_STREAM, 0);
   //设置地址
    server.sin_family = AF_INET;
    server.sin_port = htons(9007);
    // 服务器的IP地址
    server.sin_addr.s_addr = inet_addr("172.18.16.158");
    // 建立连接
    error = connect(client_flag, (struct sockaddr *)&server, sizeof(server));
    //发送消息
    send(client_flag, "韩寒", 1024, 0);
    // 接收消息
    char buff[1024];
    long length = 0;
    length = recv(client_flag, buff, 1024, 0);
    buff[length] = '\0';
    printf("server say:%s",buff);
    //关闭
   // close(client_flag);
    return YES;
}

##　简介


WebSocket是一种在单个TCP连接上进行全双工通信的协议。WebSocket通信协议于2011年被IETF定为标准RFC

6455，并由RFC7936补充规范。WebSocket API也被W3C定为标准。
WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket

API中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。


三次握手


（1）第一次握手：Client将标志位SYN置为1，随机产生一个值seq=J，并将该数据包发送给Server，Client进入SYN_SENT状态，等待Server确认。

（2）第二次握手：Server收到数据包后由标志位SYN=1知道Client请求建立连接，Server将标志位SYN和ACK都置为1，ack=J+1，随机产生一个值seq=K，并将该数据包发送给Client以确认连接请求，Server进入SYN_RCVD状态。

（3）第三次握手：Client收到确认后，检查ack是否为J+1，ACK是否为1，如果正确则将标志位ACK置为1，ack=K+1，并将该数据包发送给Server，Server检查ack是否为K+1，ACK是否为1，如果正确则连接建立成功，Client和Server进入ESTABLISHED状态，完成三次握手，随后Client与Server之间可以开始传输数据了。
⑤SYN攻击：
在三次握手过程中，Server发送SYN-ACK之后，收到Client的ACK之前的TCP连接称为半连接（half-open

connect），此时Server处于SYN_RCVD状态，当收到ACK后，Server转入ESTABLISHED状态。SYN攻击就是Client在短时间内伪造大量不存在的IP地址，并向Server不断地发送SYN包，Server回复确认包，并等待Client的确认，由于源地址是不存在的，因此，Server需要不断重发直至超时，这些伪造的SYN包将产时间占用未连接队列，导致正常的SYN请求因为队列满而被丢弃，从而引起网络堵塞甚至系统瘫痪。SYN攻击时一种典型的DDOS攻击，检测SYN攻击的方式非常简单，即当Server上有大量半连接状态且源IP地址是随机的，则可以断定遭到SYN攻击了。
使用如下命令可以让之现行：#netstat -nap | grep SYN_RECV ⑥TCP连接的建立：SYN分节

终止：FIN（finish）分节

四次挥手


由于TCP连接是全双工的，每个方向都必须要单独进行关闭，原则是当一方完成数据发送任务后，发送一个FIN来终止这一方向的连接，收到一个FIN只是意味着这一方向上没有数据流动了，即不会再收到数据了，但是在这个TCP连接上仍然能够发送数据，直到这一方向也发送了FIN。首先进行关闭的一方将执行主动关闭，而另一方则执行被动关闭，上图描述的即是如此。
（1）第一次挥手：Client发送一个FIN，用来关闭Client到Server的数据传送，Client进入FIN_WAIT_1状态。

（2）第二次挥手：Server收到FIN后，发送一个ACK给Client，确认序号为收到序号+1（与SYN相同，一个FIN占用一个序号），Server入CLOSE_WAIT状态。

（3）第三次挥手：Server发送一个FIN，用来关闭Server到Client的数据传送，Server进入LAST_ACK状态。

（4）第四次挥手：Client收到FIN后，Client进入TIME_WAIT状态，接着发送一个ACK给Server，确认序号为收到序号+1，Server进入CLOSED状态，完成四次挥手。

TCP（Ｃ/Ｓ）流程图


①TCP是一种精致的，可靠的字节流协议。
②在TCP编程中，三路握手一般由客户端（Client）调用Connent函数发起。
③TCP3次握手后数据收发通道即打开（即建立了连接）。

TCP群聊(Server端工作原理)
import socket, threading, logging, datetime
FORMAT = '%(asctime)s %(threadName)s %(thread)d %(message)s'
logging.basicConfig(format=FORMAT, level=logging.INFO)


class Sserver():
    def __init__(self, ip='127.0.0.1', port=8888):
        self.addr = (ip, port)
        self.sock = socket.socket()
        self.cliens = {}
        self.event = threading.Event()

    def start(self):
        self.sock.bind(self.addr)
        self.sock.listen()
        threading.Thread(target=self.accept, name='accept').start()

    def accept(self):
        while not self.event.is_set():
            s, raddr = self.sock.accept()
            logging.info(raddr)
            logging.info(s)
            self.cliens[raddr] = s
            threading.Thread(target=self.recv, name='recv', args=(s, )).start()

    def recv(self, sock:socket.socket):
        while True: 
            try:
                data = sock.recv(1024)
            except expression as e:
                logging.error(e)
                data = b'quit'
            if data == b'quit':
                self.cliens.pop(sock.getpeername())
                sock.close()
                break

            msg = 'bak{}. {} {}'.format(
                sock.getpeername(),
                datetime.datetime.now().strftime("%Y/%m/%d-%H:%M:%S"), 
                data.decode()).encode()
            for s in self.cliens.values():
                s.send(msg)

    def stop(self):
        for s in self.cliens.values():
            s.close()
        self.sock.close()


cs = Sserver()
cs.start()

while True:
    cmd = input('>>>>  ')
    if cmd.strip() == 'quit':
        cs.stop()
        threading.Event.wait(3)
        break
    logging.info(threading.enumerate())

TCP群聊进阶(socket对象转换为文件)
import socket, threading, logging, datetime

FORMAT = '%(asctime)s %(threadName)s %(thread)d %(message)s'
logging.basicConfig(format=FORMAT, level=logging.INFO)


class Sserver():
    def __init__(self, ip='127.0.0.1', port=8888):
        self.addr = (ip, port)
        self.sock = socket.socket()
        self.cliens = {}
        self.event = threading.Event()

    def start(self):
        self.sock.bind(self.addr)
        self.sock.listen()
        threading.Thread(target=self.accept, name='accept').start()

    def accept(self):
        while not self.event.is_set():
            s, raddr = self.sock.accept()
            f = s.makefile(mode='rw')
            logging.info(raddr)
            logging.info(s)
            logging.info(f)
            self.cliens[raddr] = f
            threading.Thread(target=self.recv, name='recv', args=(f, raddr)).start()

    def recv(self, f, addr):
        while True: 
            try:
                # data = sock.recv(1024)
                data = f.readline()
                logging.info(data)
            except expression as e:
                logging.error(e)
                data = b'quit'
            if data == b'quit':
                self.cliens.pop(addr)
                f.close()
                break
            msg = 'bak{}. {} {}'.format(
                addr,
                datetime.datetime.now().strftime("%Y/%m/%d-%H:%M:%S"), 
                data.decode()).encode()
            for s in self.cliens.values():
                f.write(msg)
                f.flush()

    def stop(self):
        for s in self.cliens.values():
            s.close()
        self.sock.close()
        self.event.set()


def main():
    cs = Sserver()
    cs.start()

    while True:
        cmd = input('>>>>  ')
        if cmd.strip() == 'quit':
            cs.stop()
            threading.Event.wait(3)
            break
        logging.info(threading.enumerate())

if __name__ == '__main__':
    main()

实现socket编程需要有客户端(client)及服务端(server)
数据传输其实就是客户端到服务端，服务端到客户端的一个过程，数据是以流的形式进行传输的
scoket的通信过程：



根据scoket 的工作过程写客户端和服务端
服务端代码实现：
package it.com.service;
 
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
 
public class Scoketser {
 
	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		// 1:serverscoket 进行端口的监听
		ServerSocket ss = new ServerSocket(6666);
		Socket sc = ss.accept();
        //2从输出流中读取数据
		InputStream is = sc.getInputStream();
		//3 对数据进行处理（数据读入到buffer中，转换字符串）
		byte[] buffer=new byte[1024];
		int len=-1;
		len=is.read(buffer);
		String getData=new String(buffer, 0, len);
		System.out.println("从客户端获取的数据:"+getData);
		//4 业务处理 大小写转化
		String outPutData=getData.toUpperCase();
		//5 写入到输入流中返回给客户端
		OutputStream os = sc.getOutputStream();
		os.write(outPutData.getBytes("UTF-8"));
		//6 关闭资源
 
		os.close();
		is.close();
		sc.close();
        ss.close();
	
	}
 
}

客户端代码实现：
package it.com.cli;
 
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;
 
public class ScoketCli {
 
	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		//1 获取用户输入的数据
		Scanner input=new Scanner(System.in);
		System.out.println("请输入数据:");
		String inputData=input.nextLine();
		
		//2 开启一个Socket端口:将用户的输入的数据写入输出流，发给端口
		Socket sc=new Socket("127.0.0.1", 6666);
		OutputStream os=sc.getOutputStream();
		os.write(inputData.getBytes());
		
		//3：获取服务端回传的数据，打开输入流从输入流中读取数据，然后将数据写到字节数组中
		InputStream is = sc.getInputStream(); 
		byte[] buffer=new byte[1024];
		int len=-1;
		len=is.read(buffer);
		String getData=new String(buffer, 0, len);
		System.out.println("从服务端获取的数据:"+getData);
		//关闭资源
		is.close();
		os.close();
		sc.close();
	
	}
 
}

运行结果：

Scoket介绍

IP地址+端口号组成了所谓的Scoket，Scoket是网络上运行的程序之间双向通信链路的终结点，是TCP(传输层)和UDP（用户数据报协议）的基础；

Java的网络支持：

1，针对网络通信的不同层次，Java提供了不同的API.其提供的网络功能有四大类，都位于java.net包下（提供网络应用程序的类）：

InetAddress：用于标识网络的硬件资源，主要是IP地址；

URL: 统一资源占位符，通过URL可以直接读取或写入网络上的数据;

Scokets: 使用TCP协议实现的网络通信Scoket相关的类；

Datagram: 使用UDP协议，将数据保存在用户数据报中，通过网络进行通信；

 

Scoket的原理机制：

1,通信的两端都有Scoket。

2,网络通信其实就是Scoket的通信。

3,数据在两个Scoket间通过IO传输。

 

TCP编程

1，Java中基于TCP协议的实现网络通信的类

1.1客户端的Scoket类

1.1服务端的ServerScoket类



2，Scoket通信的步骤

2.1 创建ServerScoket和Scoket

2.2 打开连接到Scoket的输入/输出流

2.3 按照协议对Scoket进行读/写操作

2.4 关闭输入/输出流，关闭Scoket

3，服务端的步骤

3.1 创建ServerScoket对象，绑定监听端口。

3.2 通过accpet（）方法监听客户请求。

3.3 连接建立后，通过输入流读取客户端发送的请求消息。

3.4 通过输出流向客户端发送响应消息

3.5 关闭相关资源

 

服务端：输入（读取客户端） -- 输出（响应发送）

4，客户端的步骤

4.1 创建Scoket对象，指明需要连接的服务器的地址和端口号

4.2 连接建立后，通过输出流向服务端发送请求消息

4.3 通过输入流获取获取服务器响应的消息

4.4 关闭响应资源

客户端：输出（主动发送）--输入（响应回收服务端发送的消息）