LWIP的NETCONN接口

已于 2025-05-18 17:50:40 修改
阅读量875 收藏 9
点赞数 8
文章标签： lwip 笔记
于 2025-05-18 15:57:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36658033/article/details/148044926
版权

NETCONN接口简介

NETCONN API 使用了操作系统的 IPC 机制， 对网络连接进行了抽象，使用同一的接口完成UDP和TCP连接

NETCONN API接口是在RAW接口基础上延申出来的一套API接口

NETCONN实现原理

2.1，NETCONN控制块

2.2，NETCONN收发的数据管理

2.3，NETCONN实现原理

NETCONN控制块

struct netconn 
{ 
enum netconn_type type; 	/* 连接类型， TCP UDP 或者 RAW */ 
enum netconn_state state;	/* 当前连接状态 */ 
union 					/* 内核中与连接相关的控制块指针 */ 
{ 
struct ip_pcb *ip; 	/* IP 控制块 */ 
struct tcp_pcb *tcp; 	/* TCP 控制块 */ 
struct udp_pcb *udp; 	/* UDP 控制块 */ 
struct raw_pcb *raw; 	/* RAW 控制块 */ 
} pcb; 
err_t last_err; 			/* 此连接上最新的错误 */ 
sys_sem_t op_completed; 	/* 用于 API 同步的信号量 */ 
sys_mbox_t recvmbox; 		/* 接收数据的邮箱 */ 
...后面还有部分代码... 
}

控制块实现

1、统一编程接口

2、统一连接结构

3、可使用IPC机制

4、错误提示

什么是IPC机制

个人理解：就是系统的OS的机制

NETCONN收发的数据管理

struct netbuf 
{
    /* 发送方的数据包 */ 
struct pbuf *p, *ptr; 
/* 发送方的IP地址 */ 	
ip_addr_t addr; 
/* 发送方的端口号 */  		
u16_t port; 			
};

①p 和 ptr 都指向 pbuf 链表，不同的是 p 一直指向 pbuf 链表的第一个 pbuf 结构， 而 ptr 可能指向链表中其他的位置，netbuf_next()和 netbuf_first()操作 ptr 字段。

②addr 和 port 字段用来记录数据发送方的 IP 地址和端口号，netbuf_fromaddr 和 netbuf_fromport 这两个宏定义用于返回 addr 和 port 这两个字段。

收发数据管理结构图

NETCONN实现原理

先创建一个netconn控制块   再创建一个udp控制块  然后通过udp接口接收数据

等效流程图

这里的发送邮箱，是os的邮箱

存在发送邮箱，那么就有接收邮箱

此时产生新的流程，得到数据如下；（如下：前三个，类似于初始化位置）

NETCONN与RAW接口的区别

区别

NETCONN API

RAW API

数据接收

回调型+IPC机制

回调型（用户编写）

工作机制

封装内核函数，提供统一接口

操作内核函数实现

效率性

较高

高

易用性

高（少接触内核代码）

低（了解内核代码）

开发环境

OS

无OS/OS

……

……

……

netconn类似于STM32的标准库开发，而RAW接口类似于STM32寄存器开发

NETCONN相关函数

NETCONN API

描述

netconn_new

创建netconn控制块

netconn_delete

删除控制块

netconn_bind

本地IP地址与端口号绑定

netconn_connect

与目的IP地址和端口号绑定

netconn_disconnect

断开连接

netconn_listen

监听连接（只在TCP服务器）

netconn_accept

获取一个TCP连接（只在TCP服务器）

netconn_recv

在recvmbox 邮箱中接收数据包（UDP和TCP可用）

netconn_send

发送数据（UDP）

netconn_write

发送数据（TCP）

……

……

NETCONN接口UDP连接配置流程

1、netconn_new

创建NETCONN控制块（udp_new/udp_recv）

2、netconn_bind

绑定本地IP地址和端口号

3、netconn_connect

绑定目的IP地址和目的端口号并且插入PCB链表

4、send/recv

调用NETCONN相关函数发送和接收数据

PS：netbuf用来管理pbuf的，所以netbuf，可以作用到pbuf数据

主代码

\Middlewares\lwip\lwip_app\lwip_demo.c


/* 这个必须填写正确，远程IP地址 */
#define DEST_IP_ADDR0               192
#define DEST_IP_ADDR1               168
#define DEST_IP_ADDR2                 1
#define DEST_IP_ADDR3               111

#define LWIP_DEMO_RX_BUFSIZE         200   /* 定义最大接收数据长度 */
#define LWIP_DEMO_PORT               8080  /* 定义连接的本地端口号 */

/* 接收数据缓冲区 */
uint8_t g_lwip_demo_recvbuf[LWIP_DEMO_RX_BUFSIZE]; 
/* 发送数据内容 */
char *g_lwip_demo_sendbuf = "ALIENTEK DATA\r\n";
/* 数据发送标志位 */
uint8_t g_lwip_send_flag;
extern QueueHandle_t g_display_queue;   /* 显示消息队列句柄 */
/**
 * @brief       lwip_demo实验入口
 * @param       无
 * @retval      无
 */
void lwip_demo(void)
{
    err_t err;
    static struct netconn *udpconn;
    static struct netbuf  *recvbuf;
    static struct netbuf  *sentbuf;
    ip_addr_t destipaddr;
    uint32_t data_len = 0;
    struct pbuf *q;
    BaseType_t lwip_err;
    
    /* 第一步：创建udp控制块 */
    udpconn = netconn_new(NETCONN_UDP);
    /* 定义接收超时时间 */
    udpconn->recv_timeout = 10;

    if (udpconn != NULL)                                        /* 判断创建控制块释放成功 */
    {
        /* 第二步：绑定控制块、本地IP和端口 */
        err = netconn_bind(udpconn, IP_ADDR_ANY, LWIP_DEMO_PORT);
        /* 构造目的IP地址 */
        IP4_ADDR(&destipaddr, DEST_IP_ADDR0,DEST_IP_ADDR1,DEST_IP_ADDR2,DEST_IP_ADDR3);
        /* 第三步：连接或者建立对话框 */
        netconn_connect(udpconn, &destipaddr, LWIP_DEMO_PORT);  /* 连接到远端主机 */

        if (err == ERR_OK)                                      /* 绑定完成 */
        {
            while (1)
            {
                /* 第四步：如果指定的按键按下时，会发送信息 */
                if ((g_lwip_send_flag & LWIP_SEND_DATA) == LWIP_SEND_DATA)
                {
                    sentbuf = netbuf_new();
                    netbuf_alloc(sentbuf, strlen((char *)g_lwip_demo_sendbuf));
                    memcpy(sentbuf->p->payload, (void *)g_lwip_demo_sendbuf, strlen((char *)g_lwip_demo_sendbuf));
                    err = netconn_send(udpconn, sentbuf);               /* 将netbuf中的数据发送出去 */

                    if (err != ERR_OK)
                    {
                        printf("发送失败\r\n");
                        netbuf_delete(sentbuf);                         /* 删除buf */
                    }

                    g_lwip_send_flag &= ~LWIP_SEND_DATA;                  /* 清除数据发送标志 */
                    netbuf_delete(sentbuf);                             /* 删除buf */
                }

                /* 第五步：接收数据 */
                netconn_recv(udpconn, &recvbuf);

                if (recvbuf != NULL)                                    /* 接收到数据 */
                {
                    memset(g_lwip_demo_recvbuf, 0, LWIP_DEMO_RX_BUFSIZE); /* 数据接收缓冲区清零 */

                    for (q = recvbuf->p; q != NULL; q = q->next)        /* 遍历完整个pbuf链表 */
                    {
                        /* 判断要拷贝到UDP_DEMO_RX_BUFSIZE中的数据是否大于UDP_DEMO_RX_BUFSIZE的剩余空间，如果大于 */
                        /* 的话就只拷贝UDP_DEMO_RX_BUFSIZE中剩余长度的数据，否则的话就拷贝所有的数据 */
                        if (q->len > (LWIP_DEMO_RX_BUFSIZE - data_len)) memcpy(g_lwip_demo_recvbuf + data_len, q->payload, (LWIP_DEMO_RX_BUFSIZE - data_len)); /* 拷贝数据 */
                        else memcpy(g_lwip_demo_recvbuf + data_len, q->payload, q->len);

                        data_len += q->len;

                        if (data_len > LWIP_DEMO_RX_BUFSIZE) break;     /* 超出TCP客户端接收数组,跳出 */
                    }

                    data_len = 0;                                       /* 复制完成后data_len要清零 */

                    lwip_err = xQueueSend(g_display_queue,&g_lwip_demo_recvbuf,0);
                    
                    if (lwip_err == errQUEUE_FULL)
                    {
                        printf("队列Key_Queue已满，数据发送失败!\r\n");
                    }
                    
                    netbuf_delete(recvbuf);                             /* 删除buf */
                }   
                
                else vTaskDelay(5);                                     /* 延时5ms */
                
                vTaskDelay(10);
            }
        }
        else printf("UDP绑定失败\r\n");
    }
    else printf("UDP连接创建失败\r\n");
}

User\freertos_demo.c


/******************************************************************************************************/
/*FreeRTOS配置*/

/* START_TASK 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define START_TASK_PRIO         5           /* 任务优先级 */
#define START_STK_SIZE          128         /* 任务堆栈大小 */
TaskHandle_t StartTask_Handler;             /* 任务句柄 */
void start_task(void *pvParameters);        /* 任务函数 */

/* LWIP_DEMO 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define LWIP_DMEO_TASK_PRIO     11          /* 任务优先级 */
#define LWIP_DMEO_STK_SIZE      1024        /* 任务堆栈大小 */
TaskHandle_t LWIP_Task_Handler;             /* 任务句柄 */
void lwip_demo_task(void *pvParameters);    /* 任务函数 */

/* LED_TASK 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define LED_TASK_PRIO           10          /* 任务优先级 */
#define LED_STK_SIZE            128         /* 任务堆栈大小 */
TaskHandle_t LEDTask_Handler;               /* 任务句柄 */
void led_task(void *pvParameters);          /* 任务函数 */

/* KEY_TASK 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define KEY_TASK_PRIO           11          /* 任务优先级 */
#define KEY_STK_SIZE            128         /* 任务堆栈大小 */
TaskHandle_t KEYTask_Handler;               /* 任务句柄 */
void key_task(void *pvParameters);          /* 任务函数 */

/* DISPLAY_TASK 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define DISPLAY_TASK_PRIO       12          /* 任务优先级 */
#define DISPLAY_STK_SIZE        512         /* 任务堆栈大小 */
TaskHandle_t DISPLAYTask_Handler;           /* 任务句柄 */
void display_task(void *pvParameters);      /* 任务函数 */

/* 显示消息队列的数量 */
#define DISPLAYMSG_Q_NUM    20   /* 显示消息队列的数量 */
QueueHandle_t g_display_queue;     /* 显示消息队列句柄 */

/******************************************************************************************************/


/**
 * @breif       加载UI
 * @param       mode :  bit0:0,不加载;1,加载前半部分UI
 *                      bit1:0,不加载;1,加载后半部分UI
 * @retval      无
 */
void lwip_test_ui(uint8_t mode)
{
    uint8_t speed;
    uint8_t buf[30];
    
    if (mode & 1<< 0)
    {
        lcd_show_string(6, 10, 200, 32, 32, "STM32", DARKBLUE);
        lcd_show_string(6, 40, lcddev.width, 24, 24, "lwIP UDP Test", DARKBLUE);
        lcd_show_string(6, 70, 200, 16, 16, "ATOM@ALIENTEK", DARKBLUE);
    }
    
    if (mode & 1 << 1)
    {
        lcd_show_string(5, 110, 200, 16, 16, "lwIP Init Successed", MAGENTA);
        
        if (g_lwipdev.dhcpstatus == 2)
        {
            sprintf((char*)buf,"DHCP IP:%d.%d.%d.%d",g_lwipdev.ip[0],g_lwipdev.ip[1],g_lwipdev.ip[2],g_lwipdev.ip[3]);     /* 显示动态IP地址 */
        }
        else
        {
            sprintf((char*)buf,"Static IP:%d.%d.%d.%d",g_lwipdev.ip[0],g_lwipdev.ip[1],g_lwipdev.ip[2],g_lwipdev.ip[3]);    /* 打印静态IP地址 */
        }
        
        lcd_show_string(5, 130, 200, 16, 16, (char*)buf, MAGENTA);
        
        speed = ethernet_chip_get_speed();      /* 得到网速 */
        
        if (speed)
        {
            lcd_show_string(5, 150, 200, 16, 16, "Ethernet Speed:100M", MAGENTA);
        }
        else
        {
            lcd_show_string(5, 150, 200, 16, 16, "Ethernet Speed:10M", MAGENTA);
        }
        
        lcd_show_string(5, 170, 200, 16, 16, "KEY0:Send data", MAGENTA);
        lcd_show_string(5, 190, lcddev.width - 30, lcddev.height - 190, 16, "Receive Data:", BLUE); /* 提示消息 */
    }
}

/**
 * @breif       freertos_demo
 * @param       无
 * @retval      无
 */
void freertos_demo(void)
{
    /* start_task任务 */
    xTaskCreate((TaskFunction_t )start_task,
                (const char *   )"start_task",
                (uint16_t       )START_STK_SIZE,
                (void *         )NULL,
                (UBaseType_t    )START_TASK_PRIO,
                (TaskHandle_t * )&StartTask_Handler);

    vTaskStartScheduler(); /* 开启任务调度 */
}

/**
 * @brief       start_task
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void start_task(void *pvParameters)
{
    pvParameters = pvParameters;
    
    g_lwipdev.lwip_display_fn = lwip_test_ui;
    
    lwip_test_ui(1);    /* 加载后前部分UI */
    
    while (lwip_comm_init() != 0)
    {
        lcd_show_string(30, 110, 200, 16, 16, "lwIP Init failed!!", RED);
        delay_ms(500);
        lcd_fill(30, 50, 200 + 30, 50 + 16, WHITE);
        lcd_show_string(30, 110, 200, 16, 16, "Retrying...       ", RED);
        delay_ms(500);
        LED1_TOGGLE();
    }
    
    while (!ethernet_read_phy(PHY_SR))  /* 检查MCU与PHY芯片是否通信成功 */
    {
        printf("MCU与PHY芯片通信失败，请检查电路或者源码！！！！\r\n");
    }
    
    while ((g_lwipdev.dhcpstatus != 2)&&(g_lwipdev.dhcpstatus != 0XFF))  /* 等待DHCP获取成功/超时溢出 */
    {
        vTaskDelay(5);
    }
    

    
    taskENTER_CRITICAL();           /* 进入临界区 */
    
    g_display_queue = xQueueCreate(DISPLAYMSG_Q_NUM,200);      /* 创建消息Message_Queue,队列项长度是200长度 */
    
    /* 创建lwIP任务 */
    xTaskCreate((TaskFunction_t )lwip_demo_task,
                (const char*    )"lwip_demo_task",
                (uint16_t       )LWIP_DMEO_STK_SIZE, 
                (void*          )NULL,
                (UBaseType_t    )LWIP_DMEO_TASK_PRIO,
                (TaskHandle_t*  )&LWIP_Task_Handler);

    /* key任务 */
    xTaskCreate((TaskFunction_t )key_task,
                (const char *   )"key_task",
                (uint16_t       )KEY_STK_SIZE,
                (void *         )NULL,
                (UBaseType_t    )KEY_TASK_PRIO,
                (TaskHandle_t * )&KEYTask_Handler);

    /* LED测试任务 */
    xTaskCreate((TaskFunction_t )led_task,
                (const char*    )"led_task",
                (uint16_t       )LED_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )LED_TASK_PRIO,
                (TaskHandle_t*  )&LEDTask_Handler);

    /* 显示任务 */
    xTaskCreate((TaskFunction_t )display_task,
                (const char*    )"display_task",
                (uint16_t       )DISPLAY_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )DISPLAY_TASK_PRIO,
                (TaskHandle_t*  )&DISPLAYTask_Handler);

    vTaskDelete(StartTask_Handler); /* 删除开始任务 */
    taskEXIT_CRITICAL();            /* 退出临界区 */
    
}

/**
 * @brief       lwIP运行例程
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void lwip_demo_task(void *pvParameters)
{
    pvParameters = pvParameters;

    lwip_demo();            /* lwip测试代码 */
    
    while (1)
    {
        vTaskDelay(5);
    }
}

/**
 * @brief       key_task
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void key_task(void *pvParameters)
{
    pvParameters = pvParameters;
    
    uint8_t key;
  
    while (1)
    {
        key = key_scan(0);

        if (KEY0_PRES ==key)
        {
            g_lwip_send_flag |= LWIP_SEND_DATA; /* 标记LWIP有数据要发送 */
        }
        
        vTaskDelay(10);
    }
}

/**
 * @brief       系统再运行
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void led_task(void *pvParameters)
{
    pvParameters = pvParameters;

    while (1)
    {
        LED1_TOGGLE();
        vTaskDelay(100);
    }
}

/**
 * @brief       显示任务
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void display_task(void *pvParameters)
{
    pvParameters = pvParameters;
    uint8_t *buffer;
    
    while (1)
    {
        buffer = mymalloc(SRAMIN,200);
        
        if (g_display_queue != NULL)
        {
            memset(buffer,0,200);       /* 清除缓冲区 */
            
            if (xQueueReceive(g_display_queue,buffer,portMAX_DELAY))
            {
                lcd_fill(30, 220, lcddev.width - 1, lcddev.height - 1, WHITE); /* 清上一次数据 */
                /* 显示接收到的数据 */
                lcd_show_string(30, 220, lcddev.width - 30, lcddev.height - 230, 16, (char *)buffer, RED); 
            }
        }
        
        myfree(SRAMIN,buffer);          /*释放内存 */
        
        vTaskDelay(5);
    }
}

NETCONN 实现 TCP 客户端
 

NETCONN 实现 TCP 客户端连接步骤
 

NETCONN 实现 TCP 客户端连接有以下几步：

① 调用函数 netconn_new 创建 TCP 控制块。

② 调用函数 netconn_connect 连接服务器。

③ 设置接收超时时间 tcp_clientconn->recv_timeout。

④ 调用函数 netconn_getaddr 获取远端 IP 地址和端口号。

⑤ 调用函数 netconn_write 和 netconn_recv 收发数据。

主要实现函数


/******************************************************************************************************/
/*FreeRTOS配置*/

/* START_TASK 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define START_TASK_PRIO         5           /* 任务优先级 */
#define START_STK_SIZE          128         /* 任务堆栈大小 */
TaskHandle_t StartTask_Handler;             /* 任务句柄 */
void start_task(void *pvParameters);        /* 任务函数 */

/* LWIP_DEMO 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define LWIP_DMEO_TASK_PRIO     11          /* 任务优先级 */
#define LWIP_DMEO_STK_SIZE      1024        /* 任务堆栈大小 */
TaskHandle_t LWIP_Task_Handler;             /* 任务句柄 */
void lwip_demo_task(void *pvParameters);    /* 任务函数 */

/* LED_TASK 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define LED_TASK_PRIO           10          /* 任务优先级 */
#define LED_STK_SIZE            128         /* 任务堆栈大小 */
TaskHandle_t LEDTask_Handler;               /* 任务句柄 */
void led_task(void *pvParameters);          /* 任务函数 */

/* KEY_TASK 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define KEY_TASK_PRIO           11          /* 任务优先级 */
#define KEY_STK_SIZE            128         /* 任务堆栈大小 */
TaskHandle_t KEYTask_Handler;               /* 任务句柄 */
void key_task(void *pvParameters);          /* 任务函数 */

/* DISPLAY_TASK 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 创建任务
 */
#define DISPLAY_TASK_PRIO       12          /* 任务优先级 */
#define DISPLAY_STK_SIZE        512         /* 任务堆栈大小 */
TaskHandle_t DISPLAYTask_Handler;           /* 任务句柄 */
void display_task(void *pvParameters);      /* 任务函数 */

/* 显示消息队列的数量 */
#define DISPLAYMSG_Q_NUM    20   /* 显示消息队列的数量 */
QueueHandle_t g_display_queue;     /* 显示消息队列句柄 */

/******************************************************************************************************/


/**
 * @breif       加载UI
 * @param       mode :  bit0:0,不加载;1,加载前半部分UI
 *                      bit1:0,不加载;1,加载后半部分UI
 * @retval      无
 */
void lwip_test_ui(uint8_t mode)
{
    uint8_t speed;
    uint8_t buf[30];
    
    if (mode & 1<< 0)
    {
        lcd_show_string(6, 10, 200, 32, 32, "STM32", DARKBLUE);
        lcd_show_string(6, 40, lcddev.width, 24, 24, "lwIP TCPClient Test", DARKBLUE);
        lcd_show_string(6, 70, 200, 16, 16, "ATOM@ALIENTEK", DARKBLUE);
    }
    
    if (mode & 1 << 1)
    {
        lcd_show_string(5, 110, 200, 16, 16, "lwIP Init Successed", MAGENTA);
        
        if (g_lwipdev.dhcpstatus == 2)
        {
            sprintf((char*)buf,"DHCP IP:%d.%d.%d.%d",g_lwipdev.ip[0],g_lwipdev.ip[1],g_lwipdev.ip[2],g_lwipdev.ip[3]);     /* 显示动态IP地址 */
        }
        else
        {
            sprintf((char*)buf,"Static IP:%d.%d.%d.%d",g_lwipdev.ip[0],g_lwipdev.ip[1],g_lwipdev.ip[2],g_lwipdev.ip[3]);    /* 打印静态IP地址 */
        }
        
        lcd_show_string(5, 130, 200, 16, 16, (char*)buf, MAGENTA);
        
        speed = ethernet_chip_get_speed();      /* 得到网速 */
        
        if (speed)
        {
            lcd_show_string(5, 150, 200, 16, 16, "Ethernet Speed:100M", MAGENTA);
        }
        else
        {
            lcd_show_string(5, 150, 200, 16, 16, "Ethernet Speed:10M", MAGENTA);
        }
        
        lcd_show_string(5, 170, 200, 16, 16, "KEY0:Send data", MAGENTA);
        lcd_show_string(5, 190, lcddev.width - 30, lcddev.height - 190, 16, "Receive Data:", BLUE); /* 提示消息 */
    }
}

/**
 * @breif       freertos_demo
 * @param       无
 * @retval      无
 */
void freertos_demo(void)
{
    /* start_task任务 */
    xTaskCreate((TaskFunction_t )start_task,
                (const char *   )"start_task",
                (uint16_t       )START_STK_SIZE,
                (void *         )NULL,
                (UBaseType_t    )START_TASK_PRIO,
                (TaskHandle_t * )&StartTask_Handler);

    vTaskStartScheduler(); /* 开启任务调度 */
}

/**
 * @brief       start_task
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void start_task(void *pvParameters)
{
    pvParameters = pvParameters;
    
    g_lwipdev.lwip_display_fn = lwip_test_ui;
    
    lwip_test_ui(1);    /* 加载后前部分UI */
    
    while (lwip_comm_init() != 0)
    {
        lcd_show_string(30, 110, 200, 16, 16, "lwIP Init failed!!", RED);
        delay_ms(500);
        lcd_fill(30, 50, 200 + 30, 50 + 16, WHITE);
        lcd_show_string(30, 110, 200, 16, 16, "Retrying...       ", RED);
        delay_ms(500);
        LED1_TOGGLE();
    }
    
    while (!ethernet_read_phy(PHY_SR))  /* 检查MCU与PHY芯片是否通信成功 */
    {
        printf("MCU与PHY芯片通信失败，请检查电路或者源码！！！！\r\n");
    }
    
    while ((g_lwipdev.dhcpstatus != 2)&&(g_lwipdev.dhcpstatus != 0XFF))  /* 等待DHCP获取成功/超时溢出 */
    {
        vTaskDelay(5);
    }
    

    
    taskENTER_CRITICAL();           /* 进入临界区 */
    
    g_display_queue = xQueueCreate(DISPLAYMSG_Q_NUM,200);      /* 创建消息Message_Queue,队列项长度是200长度 */
    
    /* 创建lwIP任务 */
    xTaskCreate((TaskFunction_t )lwip_demo_task,
                (const char*    )"lwip_demo_task",
                (uint16_t       )LWIP_DMEO_STK_SIZE, 
                (void*          )NULL,
                (UBaseType_t    )LWIP_DMEO_TASK_PRIO,
                (TaskHandle_t*  )&LWIP_Task_Handler);

    /* key任务 */
    xTaskCreate((TaskFunction_t )key_task,
                (const char *   )"key_task",
                (uint16_t       )KEY_STK_SIZE,
                (void *         )NULL,
                (UBaseType_t    )KEY_TASK_PRIO,
                (TaskHandle_t * )&KEYTask_Handler);

    /* LED测试任务 */
    xTaskCreate((TaskFunction_t )led_task,
                (const char*    )"led_task",
                (uint16_t       )LED_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )LED_TASK_PRIO,
                (TaskHandle_t*  )&LEDTask_Handler);

    /* 显示任务 */
    xTaskCreate((TaskFunction_t )display_task,
                (const char*    )"display_task",
                (uint16_t       )DISPLAY_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )DISPLAY_TASK_PRIO,
                (TaskHandle_t*  )&DISPLAYTask_Handler);

    vTaskDelete(StartTask_Handler); /* 删除开始任务 */
    taskEXIT_CRITICAL();            /* 退出临界区 */
    
}

/**
 * @brief       lwIP运行例程
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void lwip_demo_task(void *pvParameters)
{
    pvParameters = pvParameters;

    lwip_demo();            /* lwip测试代码 */
    
    while (1)
    {
        vTaskDelay(5);
    }
}

/**
 * @brief       key_task
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void key_task(void *pvParameters)
{
    pvParameters = pvParameters;
    
    uint8_t key;
  
    while (1)
    {
        key = key_scan(0);

        if (KEY0_PRES ==key)
        {
            g_lwip_send_flag |= LWIP_SEND_DATA; /* 标记LWIP有数据要发送 */
        }
        
        vTaskDelay(10);
    }
}

/**
 * @brief       系统再运行
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void led_task(void *pvParameters)
{
    pvParameters = pvParameters;

    while (1)
    {
        LED1_TOGGLE();
        vTaskDelay(100);
    }
}

/**
 * @brief       显示任务
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void display_task(void *pvParameters)
{
    pvParameters = pvParameters;
    uint8_t *buffer;
    
    while (1)
    {
        buffer = mymalloc(SRAMIN,200);
        
        if (g_display_queue != NULL)
        {
            memset(buffer,0,200);       /* 清除缓冲区 */
            
            if (xQueueReceive(g_display_queue,buffer,portMAX_DELAY))
            {
                lcd_fill(30, 220, lcddev.width - 1, lcddev.height - 1, WHITE); /* 清上一次数据 */
                /* 显示接收到的数据 */
                lcd_show_string(30, 220, lcddev.width - 30, lcddev.height - 230, 16, (char *)buffer, RED); 
            }
        }
        
        myfree(SRAMIN,buffer);          /*释放内存 */
        
        vTaskDelay(5);
    }
}


/* 这个必须填写正确，远程IP地址 */
#define DEST_IP_ADDR0               192
#define DEST_IP_ADDR1               168
#define DEST_IP_ADDR2                 1
#define DEST_IP_ADDR3               111

#define LWIP_DEMO_RX_BUFSIZE         2000  /* 最大接收数据长度 */
#define LWIP_DEMO_PORT               8080  /* 连接的本地端口号 */

/* 接收数据缓冲区 */
uint8_t g_lwip_demo_recvbuf[LWIP_DEMO_RX_BUFSIZE]; 
/* 发送数据内容 */
char *g_lwip_demo_sendbuf = "ALIENTEK DATA\r\n";
/* 数据发送标志位 */
uint8_t g_lwip_send_flag;
extern QueueHandle_t g_display_queue;     /* 显示消息队列句柄 */

/**
 * @brief       lwip_demo实验入口
 * @param       无
 * @retval      无
 */
void lwip_demo(void)
{
    static struct netconn *tcp_clientconn = NULL; /* TCP CLIENT网络连接结构体 */
    uint32_t data_len = 0;
    struct pbuf *q;
    err_t err,recv_err;
    ip4_addr_t server_ipaddr,loca_ipaddr;
    static uint16_t server_port,loca_port;
    BaseType_t lwip_err;
    char *tbuf;
    
    server_port = LWIP_DEMO_PORT;
    IP4_ADDR(&server_ipaddr,DEST_IP_ADDR0,DEST_IP_ADDR1,DEST_IP_ADDR2,DEST_IP_ADDR3);   /* 构造目的IP地址 */
    
    tbuf = mymalloc(SRAMIN, 200); /* 申请内存 */
    sprintf((char *)tbuf, "Port:%d", LWIP_DEMO_PORT); /* 客户端端口号 */
    lcd_show_string(5, 150, 200, 16, 16, tbuf, BLUE);
    
    while (1) 
    {
        tcp_clientconn = netconn_new(NETCONN_TCP);                                      /* 创建一个TCP链接 */
        err = netconn_connect(tcp_clientconn,&server_ipaddr,server_port);               /* 连接服务器 */
      
        if (err != ERR_OK)
        {
            printf("接连失败\r\n");
            netconn_delete(tcp_clientconn);                                             /* 返回值不等于ERR_OK,删除tcp_clientconn连接 */
        }
        else if (err == ERR_OK)                                                         /* 处理新连接的数据 */
        { 
            struct netbuf *recvbuf;
            tcp_clientconn->recv_timeout = 10;
            netconn_getaddr(tcp_clientconn,&loca_ipaddr,&loca_port,1);                  /* 获取本地IP主机IP地址和端口号 */
            printf("连接上服务器%d.%d.%d.%d,本机端口号为:%d\r\n",DEST_IP_ADDR0,DEST_IP_ADDR1, DEST_IP_ADDR2,DEST_IP_ADDR3,loca_port);
            lcd_show_string(5, 90, 200, 16, 16, "State:Connection Successful", BLUE);
            
            while (1)
            {
                if ((g_lwip_send_flag & LWIP_SEND_DATA) == LWIP_SEND_DATA)                 /* 有数据要发送 */
                {
                    err = netconn_write(tcp_clientconn ,g_lwip_demo_sendbuf,strlen((char*)g_lwip_demo_sendbuf),NETCONN_COPY); /* 发送tcp_server_sentbuf中的数据 */
                  
                    if (err != ERR_OK)
                    {
                        printf("发送失败\r\n");
                    }
                    
                    g_lwip_send_flag &= ~LWIP_SEND_DATA;
                }
                  
                if ((recv_err = netconn_recv(tcp_clientconn,&recvbuf)) == ERR_OK)            /* 接收到数据 */
                {
                    taskENTER_CRITICAL();                                                    /* 进入临界区 */
                    memset(g_lwip_demo_recvbuf,0,LWIP_DEMO_RX_BUFSIZE);                      /* 数据接收缓冲区清零 */

                    for (q = recvbuf->p;q != NULL;q = q->next)                               /* 遍历完整个pbuf链表 */
                    {
                        /* 判断要拷贝到TCP_CLIENT_RX_BUFSIZE中的数据是否大于TCP_CLIENT_RX_BUFSIZE的剩余空间，如果大于 */
                        /* 的话就只拷贝TCP_CLIENT_RX_BUFSIZE中剩余长度的数据，否则的话就拷贝所有的数据 */
                        if (q->len > (LWIP_DEMO_RX_BUFSIZE - data_len)) 
                        {
                            memcpy(g_lwip_demo_recvbuf + data_len,q->payload,(LWIP_DEMO_RX_BUFSIZE - data_len));/* 拷贝数据 */
                        }
                        else 
                        {
                            memcpy(g_lwip_demo_recvbuf + data_len,q->payload,q->len);
                        }
                        
                        data_len += q->len;
                        
                        if (data_len > LWIP_DEMO_RX_BUFSIZE) 
                        {
                            break;                  /* 超出TCP客户端接收数组,跳出 */
                        }
                    }
                    
                    taskEXIT_CRITICAL();            /* 退出临界区 */
                    data_len = 0;                   /* 复制完成后data_len要清零 */
                    
                    lwip_err = xQueueSend(g_display_queue,&g_lwip_demo_recvbuf,0);
                    
                    if (lwip_err == errQUEUE_FULL)
                    {
                        printf("队列Key_Queue已满，数据发送失败!\r\n");
                    }
                    
                    netbuf_delete(recvbuf);
                }
                else if (recv_err == ERR_CLSD)       /* 关闭连接 */
                {
                    netconn_close(tcp_clientconn);
                    netconn_delete(tcp_clientconn);
                    printf("服务器%d.%d.%d.%d断开连接\r\n",DEST_IP_ADDR0,DEST_IP_ADDR1, DEST_IP_ADDR2,DEST_IP_ADDR3);
                    lcd_fill(5, 89, lcddev.width,110, WHITE);
                    lcd_show_string(5, 90, 200, 16, 16, "State:Disconnect", BLUE);
                    myfree(SRAMIN, tbuf);
                    break;
                }
            }
        }
    }
}

NETCONN 实现 TCP 服务器端

NETCONN 实现 TCP 服务器步骤
 

NETCONN 实现 TCP 服务器有以下几步：

① 调用函数 netconn_new 创建 TCP 控制块。

② 调用函数 netconn_bind 绑定 TCP 控制块、本地 IP 地址和端口号。

③ 调用函数 netconn_listen 进入监听模式。

④ 设置接收超时时间 conn->recv_timeout。

⑤ 调用函数 netconn_accept 接收连接请求。

⑥ 调用函数 netconn_getaddr 获取远端 IP 地址和端口号。

⑦ 调用函数 netconn_write 和 netconn_recv 收发数据。

正常开发，要分开接收和发送任务，且不能使用阻塞

主要实现代码


/* TCPServer 不需要设置远程IP地址 */
//#define DEST_IP_ADDR0               192
//#define DEST_IP_ADDR1               168
//#define DEST_IP_ADDR2                 1
//#define DEST_IP_ADDR3               167

#define LWIP_DEMO_RX_BUFSIZE         2000  /* 最大接收数据长度 */
#define LWIP_DEMO_PORT               8080  /* 连接的本地端口号 */

/* 接收数据缓冲区 */
uint8_t g_lwip_demo_recvbuf[LWIP_DEMO_RX_BUFSIZE]; 
/* 发送数据内容 */
char *g_lwip_demo_sendbuf = "ALIENTEK DATA \r\n";
/* 数据发送标志位 */
uint8_t g_lwip_send_flag;

extern QueueHandle_t g_display_queue;     /* 显示消息队列句柄 */

/**
 * @brief       lwip_demo实验入口
 * @param       无
 * @retval      无
 */
void lwip_demo(void)
{
    static struct netconn *tcp_serverconn = NULL; /* TCP SERVER网络连接结构体 */
    uint32_t  data_len = 0;
    struct    pbuf *q;
    err_t     err,recv_err;
    uint8_t   remot_addr[4];
    struct netconn *newconn;
    static    ip_addr_t ipaddr;
    static    u16_t  port;
    BaseType_t lwip_err;
    char *tbuf;
    
    tbuf = mymalloc(SRAMIN, 200); /* 申请内存 */
    sprintf((char *)tbuf, "Port:%d", LWIP_DEMO_PORT); /* 客户端端口号 */
    lcd_show_string(5, 150, 200, 16, 16, tbuf, BLUE);
    
    /* 第一步：创建一个TCP控制块 */
    tcp_serverconn = netconn_new(NETCONN_TCP);                      /* 创建一个TCP链接 */
    /* 第二步：绑定TCP控制块、本地IP地址和端口号 */
    netconn_bind(tcp_serverconn,IP_ADDR_ANY,LWIP_DEMO_PORT);        /* 绑定端口 8080号端口 */
    /* 第三步：监听 */
    netconn_listen(tcp_serverconn);                                 /* 进入监听模式 */
    tcp_serverconn->recv_timeout = 10;                              /* 禁止阻塞线程 等待10ms */
    
    while (1) 
    {
        /* 第四步：接收连接请求 */
        err = netconn_accept(tcp_serverconn,&newconn);              /* 接收连接请求 */
        if (err == ERR_OK) newconn->recv_timeout = 10;

        if (err == ERR_OK)                                          /* 处理新连接的数据 */
        { 
            struct netbuf *recvbuf;
            netconn_getaddr(newconn,&ipaddr,&port,0);               /* 获取远端IP地址和端口号 */
            
            remot_addr[3] = (uint8_t)(ipaddr.addr >> 24); 
            remot_addr[2] = (uint8_t)(ipaddr.addr>> 16);
            remot_addr[1] = (uint8_t)(ipaddr.addr >> 8);
            remot_addr[0] = (uint8_t)(ipaddr.addr);
            printf("主机%d.%d.%d.%d连接上服务器,主机端口号为:%d\r\n",remot_addr[0], remot_addr[1],remot_addr[2],remot_addr[3],port);
            lcd_show_string(5, 90, 200, 16, 16, "State:Connection Successful", BLUE);
            
            while (1)
            {
                if ((g_lwip_send_flag & LWIP_SEND_DATA) == LWIP_SEND_DATA) /* 有数据要发送 */
                {
                    err = netconn_write(newconn ,g_lwip_demo_sendbuf,strlen((char*)g_lwip_demo_sendbuf),NETCONN_COPY); /* 发送g_lwip_demo_sendbuf中的数据 */

                    if(err != ERR_OK)
                    {
                        printf("发送失败\r\n");
                    }

                    g_lwip_send_flag &= ~LWIP_SEND_DATA;
                }
                
                if ((recv_err = netconn_recv(newconn,&recvbuf)) == ERR_OK)           /* 接收到数据 */
                { 
                    taskENTER_CRITICAL();                                           /* 进入临界区 */
                    memset(g_lwip_demo_recvbuf,0,LWIP_DEMO_RX_BUFSIZE);               /* 数据接收缓冲区清零 */

                    for (q = recvbuf->p;q != NULL;q = q->next)                       /* 遍历完整个pbuf链表 */
                    {
                        /* 判断要拷贝到LWIP_DEMO_RX_BUFSIZE中的数据是否大于LWIP_DEMO_RX_BUFSIZE的剩余空间，如果大于 */
                        /* 的话就只拷贝LWIP_DEMO_RX_BUFSIZE中剩余长度的数据，否则的话就拷贝所有的数据 */
                        if(q->len > (LWIP_DEMO_RX_BUFSIZE-data_len))
                        {
                            memcpy(g_lwip_demo_recvbuf + data_len,q->payload,(LWIP_DEMO_RX_BUFSIZE - data_len));/* 拷贝数据 */
                        }
                        else
                        {
                            memcpy(g_lwip_demo_recvbuf + data_len,q->payload,q->len);
                        }
                        
                        data_len += q->len;

                        if(data_len > LWIP_DEMO_RX_BUFSIZE)
                        {
                            break;   /*超出TCP客户端接收数组,跳出*/
                        }
                    }

                    taskEXIT_CRITICAL();                                /* 退出临界区 */
                    data_len = 0;                                       /* 复制完成后data_len要清零 */
                    
                    lwip_err = xQueueSend(g_display_queue,&g_lwip_demo_recvbuf,0);
                    
                    if (lwip_err == errQUEUE_FULL)
                    {
                        printf("队列Key_Queue已满，数据发送失败!\r\n");
                    }
                    
                    netbuf_delete(recvbuf);
                }
                else if (recv_err == ERR_CLSD)                           /* 关闭连接 */
                {
                    netconn_close(newconn);
                    netconn_delete(newconn);
                    printf("主机:%d.%d.%d.%d断开与服务器的连接\r\n",remot_addr[0], remot_addr[1],remot_addr[2],remot_addr[3]);
                    lcd_fill(5, 89, lcddev.width,110, WHITE);
                    lcd_show_string(5, 90, 200, 16, 16, "State:Disconnect", BLUE);
                    myfree(SRAMIN, tbuf);
                    break;//跳出whiel  再次连接任务
                }
            }
        }
    }
}

SpringCloud整合SpringSecurity OAuth泪目之作
程序员劝退师的博客
11-15 2582
前言 在看着篇文章前，首先需要一定的知识储备，SpringCloud这一块我就不多说了，这里着重讲解SpringSecurity OAuth相关的，那么必须具备SpringSecurity和SpringSecurity OAuth相关知识储备，不然一路上会走很多坑！这篇文章是以SpringBoot2.X为基本版本整合的，所以SpringSecurity Oauth的版本也必须与SpringBoot2.X相适配，因为这里就光版本适配就有很多坑，因为SpringSecurity在1.X和2.X的一些默认配置是不
Spring Cloud整合Spring Security Oauth2
程序员们必读的博客，涵盖IT技术、编程经验等领域。
03-25 1559
OAuth 2.1作为一种开放标准，为微服务架构下的用户身份认证和授权提供了强有力的支持。它允许第三方应用获取用户在特定服务上的有限访问权限，而无需获取用户的用户名和密码。通过OAuth 2.1，企业可以构建安全、灵活的身份认证体系，实现用户身份的统一管理，确保服务间的数据安全和隐私保护。
Spring Cloud Gateway 整合 Spring Security 统一登录认证鉴权
02-24
1.本项目为SpringCloud Gateway的微服务框架，整合了SpringSecurity，微服务间使用Redis来获取登陆的用户信息。 2.由于Gat
springcloud集成Spring Security
youxmm的博客
07-21 3827
1.自定义配置类继承WebSecurityConfigurerAdapter配置类2.通过重写方法来定义安全规则和访问控制。通常用于测试或者开发环境中，因为它并不会对密码进行任何加密，而是将密码以明文的形式存储和验证。存在严重的安全风险，因为密码可以很容易地被窃取和滥用。建议不要在生产环境中使用类似的明文密码存储方式。@Bean//这里配置用户信息,这里暂时使用这种方式将用户存储在内存中//获取一个密码编码器对象@Bean//密码为明文方式//配置安全拦截机制@Override。
Spring Cloud Security：OAuth2 鉴权与零信任安全架构实践
最新发布
weixin_46619605的博客
03-25 1526
Spring Cloud Security：OAuth2 鉴权与零信任安全架构实践
springcloud整合Security
weixin_43914685的博客
08-10 8476
Security核心配置 创建ngroute-framework工程作为 Security核心配置 1.引入pom <!-- spring security 安全认证 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependen
spring cloud集成springsecurity
wangmj518的专栏
03-30 521
链接：https://www.jianshu.com/p/afc8b69515dd。2.3、启动demo-client，调用demo-server接口能正常调通。商业转载请联系作者获得授权，非商业转载请注明出处。2.2、BasicAuthConfiguration类如下。作者：staconfree。
Spring Boot集成Spring Cloud Security进行安全增强
技术研究中心
08-31 912
Spring Cloud Security为Spring Boot应用提供了一套完整的安全解决方案，支持OAuth2、JWT等多种认证和授权机制。同时，Spring Security的测试支持也简化了安全性集成测试的过程。Spring Cloud Security是Spring Security的扩展，它提供了对Spring Cloud体系中的服务认证和授权的支持，包括OAuth2、JWT等。Spring Security提供了测试支持，可以简化安全性集成测试的编写。在Spring Boot项目的。
Spring Cloud Alibaba 集成 Spring Security OAuth2.0 实现认证和授权
11-14
分布式系统的认证和授权 分布式架构采用 Spring Cloud Alibaba 认证和授权采用 Spring Security OAuth2.0 实现方法级权限控制 网关采用 gateway 中间件 服务注册和发现采用 nacos
SpringCloud微服务整合Spring Security进行统一鉴权
lyy的博客
04-15 4191
有一个大坑，记得如果是单机操作多个微服务项目，要给每个微服务添加session cookie name，如下server : port : 8003 servlet : session : cookie : #防止 Cookie 冲突，冲突会导致登录验证不通过一定一定要做这一步。
Spring Cloud整合SpringSecurity OAuth2(全网最强)
热门推荐
web15185420056的博客
06-12 1万+
本文是梳理整合SpringCloud和SpringSecurity OAuth2的搭建流程！好久没撸SpringSecurity OAuth2这系列代码了，都快忘了，特写此文章梳理脉络！开干！！！微服务版本 SpringSecurity OAuth2版本 通过微服务版本限定后spring-security-oauth2-autoconfigure的最终版本自动适配为2.1.2刚开始我这里就不一次性把一大堆配置放上来，需要什么就写什么，不然到时候都搞不清那个配置是干嘛，有什么用的！这也是我写这个文章的缘由！授
SpringCloud 基于SpringCloud2.1的微服务开发脚手架，整合了spring-security-oauth2、nacos、feign、sent
09-23
基于SpringCloud2.1的微服务开发脚手架，整合了spring-security-oauth2、nacos、feign、sentinel、springcloud-gateway等。服务治理方面引入elasticsearch、skywalking、springboot-admin、zipkin等，让项目开发快速进入业务开发，而不需过多时间花费在架构搭建上。持续更新中
Spring Cloud Gateway 整合Spring Security
杜海的博客
03-08 2898
在Security中用户信息需存放在 UserDetails 中，UserDetails 是一个接口，可以使用Security已经实现的 org.springframework.security.core.userdetails.User，也可以实现 UserDetails 接口自定义用户信息类。/***/@Data/*** token*//***//***//***//*** location*//***//***//*** 用户名。
springcloud集成springsecurity_一分钟带你了解下Spring Security！
weixin_39644713的博客
11-26 1960
一、什么是Spring Security？Spring Security是一个功能强大且高度可定制的身份验证和访问控制框架，它是用于保护基于Spring的应用程序的实际标准。Spring Security是一个框架，致力于为Java应用程序提供身份验证和授权。与所有Spring项目一样，Spring Security的真正强大之处在于可以轻松扩展以满足自定义要求。更多信息可以查看官网：https:...
【Spring底层原理高级进阶】【SpringCloud整合Spring Security OAuth2】深入了解 Spring Security OAuth2：底层解析＋使用方法+实战
终于等到你啦~欢迎来到我的知识空间 这里是苏泽的成神之路
02-24 8599
OAuth2（Open Authorization 2.0）是一种用于授权的开放标准协议，用于通过第三方应用程序访问用户在某个服务提供商上存储的资源，而无需共享用户的凭证（例如用户名和密码）。它允许用户授权给第三方应用程序访问受保护的资源，同时确保用户的凭证信息不被直接暴露给第三方应用程序。OAuth2协议的设计目标是简化授权流程和提高安全性，通过委托授权的方式和使用令牌来实现用户和第三方应用程序之间的安全通信。它已成为许多互联网服务提供商和开发者在构建应用程序时常用的授权标准。
Spring Boot中使用Spring Security进行安全控制
weixin_34221036的博客
05-28 257
我们在编写Web应用时，经常需要对页面做一些安全控制，比如：对于没有访问权限的用户需要转到登录表单页面。要实现访问控制的方法多种多样，可以通过Aop、拦截器实现，也可以通过框架实现（如：Apache Shiro、Spring Security）。 本文将具体介绍在Spring Boot中如何使用Spring Security进行安全控...
Spring Cloud（十二）：Spring Cloud Security
Men-DD
11-23 4089
设置用户名密码(内存、UserDetailsService、WebSecurityConfigurerAdapter、基于DB) 自定义登录页面 登录认证流程 自定义成功失败 会话管理 会话控制 会话超时 会话并发控制 集群session 安全会话cookie RememberMe 退出登录 CSRF 用户授权 web授权 访问控制的url匹配 内置的访问控制 自定义403处理 基于表达式的访问控制 方法授权 JSR-250注解 @Secured注解 支持表达式的注解 授权原理 授权流程 实现原理 主线源码
Spring Cloud Security特性深度解析
在整合了上述核心组件后，Spring Cloud Security为微服务架构提供了全方位的安全防护。它不仅能够防御外部攻击，如SQL注入、跨站脚本攻击(XSS)、跨站请求伪造(CSRF)等，还能在服务调用和服务间通信时提供加密保护，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值