[持久节点创建 Java]的搜索结果

...”→ “项目”，启动创建项目向导。 (2)选择开发语言为“Visual C++”和程序类型“MFC应用程序”。 (3)点击下一步即可。 (4)选择类型为“基于对话框”，下一步或者完成。 (5)找到厂家提供的光盘资料，路径如下(64位库为例)。 A.进入厂商提供的光盘资料找到“8.PC函数”文件夹，并点击进入。 B.选择“函数库2.1”文件夹。 C.选择“Windows平台”文件夹。 D.根据需要选择对应的函数库这里选择64位库。 E.解压C++的压缩包,里面有C++对应的函数库。 F.函数库具体路径如下。 （6）将厂商提供的C++的库文件和相关头文件复制到新建的项目里面。 (7)在项目中添加静态库和相关头文件。 A.先右击项目文件，接着依次选择:“添加”→“现有项”。 B.在弹出的窗口中依次添加静态库和相关头文件。 (8)声明用到的头文件和定义控制器连接句柄。 至此项目新建完成，可进行MFC项目开发。 2.查看PC函数手册，熟悉相关函数接口 (1)PC函数手册也在光盘资料里面，具体路径如下：“光盘资料\8.PC函数\函数库2.1\ZMotion函数库编程手册 V2.1.pdf” (2)链接控制器，获取链接句柄。 ZAux_OpenEth()接口说明： (3)振镜运动接口。 为振镜运动单独封装了一个运动接口，使用movescanabs指令进行运动，采用FORCE_SPEED参数设置运动过程中的速度，运动过程中基本不存在加减速过程，支持us级别的时间控制。 3. MFC开发控制器双振镜运动例程 （1）例程界面如下。 （2） 链接按钮的事件处理函数中调用链接控制器的接口函数ZAux_OpenEth（），与控制器进行链接,链接成功后启动定时器1监控控制器状态。 //网口链接控制器void CSingle_move_Dlg::OnOpen(){char buffer[256]; int32 iresult;//如果已经链接，则先断开链接if(NULL != g_handle){ZAux_Close(g_handle);g_handle = NULL;}//从IP下拉框中选择获取IP地址GetDlgItemText(IDC_IPLIST,buffer,255);buffer[255] = '\0';//开始链接控制器iresult = ZAux_OpenEth(buffer, &g_handle);if(ERR_SUCCESS != iresult){g_handle = NULL;MessageBox(_T("链接失败"));SetWindowText("未链接");return;}//链接成功开启定时器1SetWindowText("已链接");SetTimer( 1, 100, NULL ); } （3）通过定时器监控控制器状态 。 void CSingle_move_Dlg::OnTimer(UINT_PTR nIDEvent) {// TODO: Add your message handler code here and/or call defaultif(NULL == g_handle){MessageBox(_T("链接断开"));return ;}if(1 == nIDEvent){CString string;float position = 0;ZAux_Direct_GetDpos( g_handle,m_nAxis,&position); //获取当前轴位置string.Format("振镜X1轴位置：%.2f", position );GetDlgItem( IDC_CURPOS )->SetWindowText( string );float NowSp = 0;ZAux_Direct_GetVpSpeed( g_handle,m_nAxis,&NowSp); //获取当前轴速度string.Format("振镜X1轴速度：%.2f", NowSp );GetDlgItem( IDC_CURSPEED)->SetWindowText( string );ZAux_Direct_GetDpos(g_handle, m_nAxis+1, &position); //获取当前轴位置string.Format("振镜Y1轴位置：%.2f", position);GetDlgItem(IDC_CURPOS2)->SetWindowText(string);ZAux_Direct_GetVpSpeed(g_handle, m_nAxis+1, &NowSp); //获取当前轴速度string.Format("振镜Y1轴速度：%.2f", NowSp);GetDlgItem(IDC_CURSPEED2)->SetWindowText(string);ZAux_Direct_GetDpos(g_handle, m_nAxis + 2, &position); //获取当前轴位置string.Format("振镜X2轴位置：%.2f", position);GetDlgItem(IDC_CURPOS3)->SetWindowText(string);NowSp = 0;ZAux_Direct_GetVpSpeed(g_handle, m_nAxis + 2, &NowSp); //获取当前轴速度string.Format("振镜X2轴速度：%.2f", NowSp);GetDlgItem(IDC_CURSPEED3)->SetWindowText(string);ZAux_Direct_GetDpos(g_handle, m_nAxis + 3, &position); //获取当前轴位置string.Format("振镜Y2轴位置：%.2f", position);GetDlgItem(IDC_CURPOS4)->SetWindowText(string);ZAux_Direct_GetVpSpeed(g_handle, m_nAxis + 3, &NowSp); //获取当前轴速度string.Format("振镜Y2轴速度：%.2f", NowSp);GetDlgItem(IDC_CURSPEED4)->SetWindowText(string);int status = 0; ZAux_Direct_GetIfIdle(g_handle, m_nAxis,&status); //判断当前轴状态if (status == -1){GetDlgItem( IDC_CURSTATE )->SetWindowText( "当前状态：停 止" );}else{GetDlgItem( IDC_CURSTATE )->SetWindowText( "当前状态：运动中" );} }CDialog::OnTimer(nIDEvent);} （4）通过启动按钮的事件处理函数获取编辑框的移动轨迹，并设置振镜轴参数操作振镜轴运动。 void CSingle_move_Dlg::OnStart() //启动运动{if(NULL == g_handle){MessageBox(_T("链接断开状态"));return ;}UpdateData(true);//刷新参数int status = 0; ZAux_Direct_GetIfIdle(g_handle, m_nAxis,&status); //判断当前轴状态 if (status == 0) //已经在运动中{ return;} //设定轴类型 1-脉冲轴类型 for (int i = 4; i < 8; i++){ZAux_Direct_SetAtype(g_handle, i, m_Atype);ZAux_Direct_SetMerge(g_handle,i,1);//设置脉冲当量ZAux_Direct_SetUnits(g_handle, i, m_units);//设定速度，加减速ZAux_Direct_SetLspeed(g_handle, i, m_lspeed);ZAux_Direct_SetSpeed(g_handle, i, m_speed);ZAux_Direct_SetForceSpeed(g_handle, i, m_speed);ZAux_Direct_SetAccel(g_handle, i, m_acc);ZAux_Direct_SetDecel(g_handle, i, m_dec);//设定S曲线时间 设置为0表示梯形加减速 ZAux_Direct_SetSramp(g_handle, i, m_sramp);}//使用MOVESCANABS运动int axislist[2] = { 4,5 };float dposlist[2] = { 0,0 };ZAux_MoveScanAbs(2, axislist, dposlist);CString str;GetDlgItem(IDC_EDIT_POSX1)->GetWindowText(str);float dbx = atof(str);GetDlgItem(IDC_EDIT_POSY1)->GetWindowText(str);float dby = atof(str);dposlist[0] = dbx;dposlist[1] = dby;ZAux_MoveScanAbs(2, axislist, dposlist);GetDlgItem(IDC_EDIT_POSX2)->GetWindowText(str);dbx = atof(str);GetDlgItem(IDC_EDIT_POSY2)->GetWindowText(str);dby = atof(str);dposlist[0] = dbx;dposlist[1] = dby;ZAux_MoveScanAbs(2, axislist, dposlist);GetDlgItem(IDC_EDIT_POSX3)->GetWindowText(str);dbx = atof(str);GetDlgItem(IDC_EDIT_POSY3)->GetWindowText(str);dby = atof(str);dposlist[0] = dbx;dposlist[1] = dby;ZAux_MoveScanAbs(2, axislist, dposlist);GetDlgItem(IDC_EDIT_POSX4)->GetWindowText(str);dbx = atof(str);GetDlgItem(IDC_EDIT_POSY4)->GetWindowText(str);dby = atof(str);dposlist[0] = dbx;dposlist[1] = dby;ZAux_MoveScanAbs(2, axislist, dposlist);//第二个振镜运动//使用MOVESCANABS运动axislist[0] = 6;axislist[1] = 7;dposlist[0] = 0;dposlist[1] = 0;ZAux_MoveScanAbs(2, axislist, dposlist);GetDlgItem(IDC_EDIT_POSX5)->GetWindowText(str);dbx = atof(str);GetDlgItem(IDC_EDIT_POSY5)->GetWindowText(str);dby = atof(str);dposlist[0] = dbx;dposlist[1] = dby;ZAux_MoveScanAbs(2, axislist, dposlist);GetDlgItem(IDC_EDIT_POSX6)->GetWindowText(str);dbx = atof(str);GetDlgItem(IDC_EDIT_POSY6)->GetWindowText(str);dby = atof(str);dposlist[0] = dbx;dposlist[1] = dby;ZAux_MoveScanAbs(2, axislist, dposlist);GetDlgItem(IDC_EDIT_POSX7)->GetWindowText(str);dbx = atof(str);GetDlgItem(IDC_EDIT_POSY7)->GetWindowText(str);dby = atof(str);dposlist[0] = dbx;dposlist[1] = dby;ZAux_MoveScanAbs(2, axislist, dposlist);GetDlgItem(IDC_EDIT_POSX8)->GetWindowText(str);dbx = atof(str);GetDlgItem(IDC_EDIT_POSY8)->GetWindowText(str);dby = atof(str);dposlist[0] = dbx;dposlist[1] = dby;ZAux_MoveScanAbs(2, axislist, dposlist);UpdateData(false); } (5) 通过断开按钮的事件处理函数来断开与控制卡的连接。 void CSingle_move_Dlg::OnClose() //断开链接{// TODO: Add your control notification handler code hereif(NULL != g_handle){KillTimer(1); //关定时器KillTimer(2);ZAux_Close(g_handle);g_handle = NULL;SetWindowText("未链接");} } （6）通过坐标清零按钮的事件处理函数移动振镜轴回零到中心零点位置，不直接使用dpos=0，修改振镜轴坐标。 void CSingle_move_Dlg::OnZero() //清零坐标{if(NULL == g_handle){MessageBox(_T("链接断开状态"));return ;}// TODO: Add your control notification handler code hereint axislist[2] = { 4,5 };float dposlist[2] = { 0 };ZAux_Direct_MoveAbs(g_handle,2,axislist,dposlist); //设置运动回零点} 三调试与监控 编译运行例程，同时通过ZDevelop软件连接控制器对控制器状态进行监控 。 ZDevelop软件连接控制器监控控制器的状态，查看振镜轴对应参数，并可搭配示波器检测双振镜轨迹。 设置振镜轴运动，首先需要将轴类型配置成21振镜轴类型，并对应配置振镜轴的速度加减速等参数才可操作振镜进行运动。 通过ZDevelop软件的示波器监控双振镜运动运行轨迹。 视频演示。 开放式激光振镜+运动控制器(六)-双振镜运动 本次，正运动技术开放式激光振镜+运动控制器(六)：双振镜运动，就分享到这里。 更多精彩内容请关注“正运动小助手”公众号，需要相关开发环境与例程代码，请咨询正运动技术销售工程师：400-089-8936。 本文由正运动技术原创，欢迎大家转载，共同学习，一起提高中国智能制造水平。文章版权归正运动技术所有，如有转载请注明文章来源。 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_57350300/article/details/123402200。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...等操作，或者根据需要创建不同权限级别的用户账号，仅赋予查看部分服务器或服务状态的权限。 主机组定义文件hostgroups.cfg , 在Nagios中，主机组是一个逻辑概念，用来将具有相同特性和管理要求的一组主机归类在一起。主机组定义文件hostgroups.cfg则是用来描述和管理这些主机组的配置文件。在实际应用中，管理员可以通过此文件方便地将多台服务器按业务功能、地理位置或其他标准划分为主机组，便于在Nagios Web界面进行统一管理和查看整个主机组的状态信息，而不是逐个单独关注单个主机的状态。例如，可以创建一个名为“MySQL主机组”的主机组，将所有运行MySQL数据库服务的服务器加入其中，从而实现对一组特定服务器集中监控和报告。

...一、socket主机创建和使用过程 1、socket()//创建套接字 2、Setsockopt()//将套接字属性设置为允许和特定地点绑定 3、Bind()//将套接字绑定特定地址端口 4、Listen()//打开监听端口属性 以下重复进行 5、Accept()//接收客户端的连接请求 6、Read()//从客户端读数据 7、Write()//将处理好的结果发送给客户端 二、HTTP传输协议 基于socket的TCP通信，按HTTP传输协议格式化传输内容。 示例： 1、客户端发送HTTP请求 GET/txt?hal=1000HTTP/1.1 Host:localhost:1024 User-Agent:Mozilla/5.0(X11;Linuxi686;rv:2.0)Gecko/20100101Firefox/4.0 Accept:text/html,application/xhtml+xml,application/xml;q=0.9,/;q=0.8 Accept-Language:zh-cn,zh;q=0.5 Accept-Encoding:gzip,deflate Accept-Charset:GB2312,utf-8;q=0.7,;q=0.7 Keep-Alive:115 Connection:keep-alive GET:发送HTTP请求的方法，还可以是SET或者POST /txt?hal=1000是请求根目录下的txt文件内容并传入参数hal=1000 HTTP/1.1表示HTTP版本是1.1 2、服务端传回HTTP响应 HTTP/1.0200OK Server:ReageWebServer Content-Type:text/html <!DOCTYPEhtmlPUBLIC"-//W3C//DTDXHTML1.0Strict//EN""http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> <htmlxmlns="http://www.w3.org/1999/xhtml"> <!--Copyright(c)2000-2008QuadralayCorporation.Allrightsreserved.--> <head> <title>WebWorksHelp5.0</title> </head> <body>wuff</body> </html> 前面四行（包括空行）是消息体，后面是消息。一般要指明消息体的长度，方便客户端的接收处理。 三、示例程序 ====================================================================== / 主要实现功能，处理浏览器的get请求信息，发送网页文件。处理404、403等错误。 1.实现绑定本机机器的1024端口作为ReageWeb服务提供网页服务的端口。（避免与机器上装有web服务器产生端口冲突） 2.实现get获取网页方式。 3.实现index.html作为网站的首页面 作者：Reage blog:http://blog.csdn.net/rentiansheng / include<stdio.h> include<stdlib.h> include<string.h> include<sys/types.h> include<sys/socket.h> include<sys/un.h> include<netinet/in.h> include<arpa/inet.h> include<fcntl.h> include<string.h> include<sys/stat.h> include<signal.h> defineMAX1024 intres_socket; voidapp_exit(); / @description:开始服务端监听 @parameter ip:web服务器的地址 port：web服务器的端口 @result：成功返回创建socket套接字标识，错误返回-1 / intsocket_listen(charip,unsignedshortintport){ intres_socket;//返回值 intres,on; structsockaddr_inaddress; structin_addrin_ip; res=res_socket=socket(AF_INET,SOCK_STREAM,0); setsockopt(res_socket,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on)); memset(&address,0,sizeof(address)); address.sin_family=AF_INET; address.sin_port=htons(port); address.sin_addr.s_addr=htonl(INADDR_ANY);//inet_addr("127.0.0.1"); res=bind(res_socket,(structsockaddr)&address,sizeof(address)); if(res){printf("portisused,nottorepeatbind\n");exit(101);}; res=listen(res_socket,5); if(res){printf("listenportiserror;\n");exit(102);}; returnres_socket; } / @description:向客户端发送网页头文件的信息 @parameter conn_socket:套接字描述符。 status:http协议的返回状态码。 @s_status:http协议的状态码的含义 @filetype:向客户端发送的文件类型 / voidsend_http_head(intconn_socket,intstatus,chars_status,charfiletype){ charbuf[MAX]; memset(buf,0,MAX); sprintf(buf,"HTTP/1.0%d%s\r\n",status,s_status); sprintf(buf,"%sServer:ReageWebServer\r\n",buf); sprintf(buf,"%sContent-Type:%s\r\n\r\n",buf,filetype); write(conn_socket,buf,strlen(buf)); } / @description:向客户端发送错误页面信息 @parameter conn_socket:套接字描述符。 status:http协议的返回状态码。 @s_status:http协议的状态码的含义 @filetype:向客户端发送的文件类型 @msg:错误页面信息内容 / voidsend_page_error(intconn_socket,intstatus,chars_status,charmsg){ charbuf[MAX]; sprintf(buf,"<html><head></head><body><h1>%s</h1><hr>ReageWebServer0.01</body></head>",msg); send_http_head(conn_socket,status,s_status,"text/html"); write(conn_socket,buf,strlen(buf)); } / @description:向客户端发送文件 @parameter conn_socket:套接字描述符。 @file:要发送文件路径 / intsend_html(intconn_socket,charfile){ intf; charbuf[MAX]; inttmp; structstatfile_s; //如果file为空，表示发送默认主页。主页暂时固定 if(0==strlen(file)){ strcpy(file,"index.html"); } //如果获取文件状态失败，表示文件不存的，发送404页面，暂时404页面内容固定。 if(stat(file,&file_s)){ send_page_error(conn_socket,404,"Notfound","Notfound<br/>Reagedoesnotimplementthismothod\n"); return0; } //如果不是文件或者无读权限，发送无法读取文件 if(!(S_ISREG(file_s.st_mode))||!(S_IRUSR&file_s.st_mode)){ send_page_error(conn_socket,403,"Forbidden","Forbidden<br/>Reagecouldn'treadthefile\n"); return0; } //发送头文件，现在只提供html页面 send_http_head(conn_socket,200,"OK","text/html"); f=open(file,O_RDONLY); if(0>f){ //打开文件失败，发送404页面，其实感觉发送5xx也可以的，服务器内部错误 send_page_error(conn_socket,404,"Notfound","Notfound<br/>Reagecouldn'treadthefile\n"); return0; } buf[MAX-1]=0;//将文件内容缓冲区最后的位设置位结束标志。 //发送文件的内容 while((tmp=read(f,buf,MAX-1))&&EOF!=tmp){ write(conn_socket,buf,strlen(buf)); } } / @description:提取url中可用的信息。访问的网页和数据访问方式 @parameter： conn_socket:与客户端链接的套接字 uri:要处理的url，注意不是浏览器中的url，而是浏览器发送的http请求 @resutl： / intdo_uri(intconn_socket,charuri){ charp; p=strchr(uri,'?'); if(p){p=0;p++;} send_html(conn_socket,uri); } voidulog(charmsg){} voidprint(charmsg){ ulog(msg); printf(msg); } intmain(intargc,charargv[]){ intconn_socket; inttmp; intline; structsockaddr_inclient_addr; charbuf[MAX]; intlen=sizeof(client_addr); charmethod[100],uri[MAX],version[100]; charpwd[1024]; res_socket=socket_listen("127.0.0.1",1024); //当按ctrl+c结束程序时调用，使用app_exit函数处理退出过程 signal(SIGINT,app_exit); while(1){ conn_socket=accept(res_socket,(structsockaddr)&client_addr,&len); printf("reage\n"); line=0; //从客户端获取请求信息 while(0==(tmp=read(conn_socket,buf,MAX-1))||tmp!=EOF){ buf[MAX-1]=0; break;//我只使用了第一行的请求信息，所以丢弃其他的信息 } //send_http_head(conn_socket,200,"text/html"); sscanf(buf,"%s%s%s",method,uri,version); //目前只处理get请求 if(!strcasecmp(method,"get")) //send_html(conn_socket,"h.html"); do_uri(conn_socket,uri+1); close(conn_socket); } } voidapp_exit(){ //回复ctrl+c组合键的默认行为 signal(SIGINT,SIG_DFL); //关闭服务端链接、释放服务端ip和端口 close(res_socket); printf("\n"); exit(0); } ====================================================================== 本篇文章为转载内容。原文链接：https://blog.csdn.net/iteye_9368/article/details/82520401。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...位也是非常多的，比如JAVA、大数据、算法等，下图从BOSS上截取的： 蚂蚁金服不在望京，在环球金融中心。 美团 美团是望京第二大互联网公司，技术氛围浓厚。事业部很多，包括酒店事业部、闪购、美团金融、优选事业部、美团买菜等。 美团的福利常常被叫做白开水福利，不过比普通公司还是要好一些，六险一金、15薪、餐补、下午茶等。 面试比阿里容易一些，不过算法和八股文也是必须要准备的。 常年招聘，岗位很多，下面岗位来自BOSS： Lazada 东南亚头部电商，而且业务还囊括了娱乐、金融和物流，业务主要服务于东南亚。工作地点在朝阳区阿里中心。 福利待遇包括六险一金、年终奖、股权、餐补交通补等。 主要招聘岗位包括java开发、游戏开发、前端、UI等。 bilibili bilibili也是非常不错的一家互联网公司，总部在上海，北京的工作地点在朝阳区东煌大厦10层。截至2021年第一季度，B站月活用户达2.23亿 福利待遇比较完备，包括六险一金、餐补、全勤奖、下午茶、股权等。 招聘岗位包括游戏服务端开发、java开发、C++开发、TA、linux内核开发等。从招聘岗位来看，java 开发并不是bilibili的热门岗位。 每日优鲜 每日优鲜近几年的发展是非常快速的，也是一家非常值得加入的公司。工作地点在万科时代中心。 工作强度比较大，工作内容也比较有挑战，晋升也比较快。建议想在技术上成长的朋友们加入。 福利待遇包括六险一金，股票期权。 招聘岗位以java为主，架构、资深、中高级都有。 BIGO BIGO主要业务在音视频领域，主要产品有Bigo Live、Likee、Hello，目前全球月活用户近4亿，产品和服务覆盖超过150个国家和地区。 福利待遇也是非常不错的，六险一金、年终奖、住房补贴、股票期权等。 主要招聘岗位包括JAVA、音视频领域后端开发。 coupang 韩国电商平台，总部在首尔，成立于2010年，是一家成熟的老牌公司，在2021年3月上市。目前国内研发团队主要在上海，在北京也有研发团队。工作地点在颐堤港。 coupang工作强度不大，不加班不内卷。福利待遇也是很不错的，包括六险一金、餐补、补充公积金、节日福利等。 招聘岗位主要包括JAVA、IOS、搜索工程师、全栈工程师等。 面试难度比较大，前后包括五轮以上面试，第一轮是电话面试，后面线程面试会有手写代码环节。 水滴公司 水滴这两年发展很快，工作地点在望京科技园。 福利待遇方面，属于互联公司中等偏上的水平，包括六险一金、补充公积金、免费健身房等。 招聘岗位JAVA居多，各种级别的都有，还有一些中间件的岗位。 据面试过水滴的求职者反馈，面试很难，对基础要求高，可能会问一些平时不太关注的非常细的问题。 keep 爱运动的小伙伴相信都熟悉keep这款软件，目前keep的用户量已经破3亿。工作地点在万科时代中心。 薪资待遇行业中等，不过该有的服务也基本都有，包括六险一金、年终奖、股权等。 招聘岗位以java为主，各种级别都有。 雪球 国内知名的投资交流平台，2020年底完成1.2亿美元 E 轮融资，发展潜力巨大。工作地点在融新科技中心。 福利待遇在行业内属于中等水平，包括六险一金、年终奖、餐补、零食下午茶等。 招聘岗位以java为主，还有搜索研发、全栈开发等。 陌陌 陌生人社交平台，深受年轻人喜爱，18年陌陌全资收购了探探，规模进一步扩大，目前月活用户在1亿+，出海业务也做的非常好。 福利待遇属于行业中等偏上，互联网有的福利基本都有，包括六险一金、年终奖等。 招聘岗位很多，包括java、中间件、推荐算法、自然语言处理、安全、游戏开发、IOS等。 面试难度中等，会有手写sql、算法、linux命令的环节。 松果出行 松果出行主要业务是构建国内县域城市交通出行网络，目前主要是共享电单车和共享新能源汽车服务。目前业务已经覆盖全国21个省，5000个县。 福利待遇属于行业中等，五险一金、年终奖等，没有补充医疗保险。 招聘岗位很多，以JAVA为主，各种级别都有。也有物联网、传感器硬件相关的岗位。 小桔科技 目前研发团队主要做推荐、搜索系统，注册地在大连。 福利待遇行业中等，五险一金、年终奖，没有补充医疗保险。 招聘岗位包括JAVA、PHP、搜索算法、前端、数仓等。 理想汽车 智能电动车品牌，这两年在行业内名气比较大。 福利待遇行业中等偏上，六险一金、交通补贴等。 招聘岗位很多，以JAVA为主，各种级别都有。另外也招聘PaaS平台研发、搜索、车载语音、大数据等。 参加过理想汽车面试的同学反馈面试体验不太好，面试官没有耐心，给大家一个参考。 狮桥 智慧物流+普惠金融融资租赁业务。 福利待遇中等偏下，五险一金、年终奖，没有补充医疗保险。 招聘岗位主要是JAVA开发。 领创集团 海外金融业务，主要做印度市场。 福利待遇中等偏下，六险一金，年终奖，工作节奏慢。 招聘岗位主要是JAVA，招聘岗位主要是java。 面试过的同学反馈体验比较好，面试官比较nice，有手写代码环节。 总结 今天主要推荐了望京的16家值得加入的互联网公司，事实上，望京区域的互联网公司和其他科技公司至少有几百家，由于个人精力有限，主要梳理了业界比较知名和自己熟悉的公司。相信还有好多非常不错的公司值得加入，欢迎大家跟我交流讨论。 欢迎关注个人公众号，一起学习进步 本篇文章为转载内容。原文链接：https://blog.csdn.net/zjj2006/article/details/121412370。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...s？不就是那个可以用JavaScript写后端的东西吗？Docker呢？听着挺高大上的，但到底是个啥嘛，我也是一头雾水。 后来我发现，其实它们俩搭配起来简直是天作之合！Node.js轻量、快速，适合构建各种Web应用；而Docker则可以让我们的应用轻松打包成容器，无论是在开发环境还是生产环境中都能保持一致的状态。这话让我一下就想起了小时候玩积木的场景——不管你东拆西挪、反复折腾，只要那些最基本的积木块没动，整座“高楼”就稳得跟啥似的，塌不下来！ 那么问题来了：如果我想在我的Node.js项目里用上Docker，该怎么操作呢？别急，咱们一步一步来。 --- 2. 为什么选择Docker？ 首先，让我们聊聊为什么要用Docker。简单来说，Docker解决了两个核心痛点： - 环境一致性：想象一下，你在本地调试好的Node.js程序，在服务器上跑却报错。哎呀，这可能是你的服务器上装的软件版本不一样，或者是系统设置没调成一个样儿，所以才出问题啦！Docker可厉害了，它把整个运行环境——比如Node.js、各种依赖库，还有配置文件啥的——全都打包成一个“镜像”，就像是给你的应用做一个完整的备份。这样，无论你什么时候部署，都像是复制了一份一模一样的东西，绝不会出岔子！ - 高效部署：传统的部署方式可能是手动上传文件到服务器再启动服务，不仅费时还容易出错。而Docker只需要推送镜像，然后在目标机器上拉取并运行即可，省去了很多麻烦。 当然，这些优点的背后离不开Docker的核心概念——镜像、容器和仓库。简单来说啊，镜像就像是做菜的菜谱，容器就是按照这个菜谱写出来的菜，仓库呢，就是放这些菜谱的地方，想做菜的时候随时拿出来用就行啦！听起来是不是有点抽象？没关系，接下来我们会一步步实践！ --- 3. 准备工作 搭建Node.js项目 既然要学怎么用Docker部署Node.js应用，那我们得先有个项目吧？这里我假设你已经会用npm初始化一个Node.js项目了。如果没有的话，可以按照以下步骤操作： bash mkdir my-node-app cd my-node-app npm init -y 这会在当前目录下生成一个package.json文件，用于管理项目的依赖。接下来，我们随便写点代码让这个项目动起来。比如新建一个index.js文件，内容如下： javascript // index.js const http = require('http'); const hostname = '127.0.0.1'; const port = 3000; const server = http.createServer((req, res) => { res.statusCode = 200; res.setHeader('Content-Type', 'text/plain'); res.end('Hello World\n'); }); server.listen(port, hostname, () => { console.log(Server running at http://${hostname}:${port}/); }); 现在你可以直接运行它看看效果： bash node index.js 打开浏览器访问http://127.0.0.1:3000/，你会看到“Hello World”。不错，我们的基础项目已经搭建好了！ --- 4. 第一步 编写Dockerfile 接下来我们要做的就是给这个项目添加Docker的支持。为此，我们需要创建一个特殊的文件叫Dockerfile。这个名字是固定的，不能改哦。 进入项目根目录，创建一个空文件名为Dockerfile，然后在里面输入以下内容： dockerfile 使用官方的Node.js镜像作为基础镜像 FROM node:16-alpine 设置工作目录 WORKDIR /app 将当前目录下的所有文件复制到容器中的/app目录 COPY . /app 安装项目依赖 RUN npm install 暴露端口 EXPOSE 3000 启动应用 CMD ["node", "index.js"] 这段代码看起来有点复杂，但其实逻辑很简单： 1. FROM node:16-alpine 告诉Docker从官方的Node.js 16版本的Alpine镜像开始构建。 2. WORKDIR /app 指定容器内的工作目录为/app。 3. COPY . /app 把当前项目的文件拷贝到容器的/app目录下。 4. RUN npm install 在容器内执行npm install命令，安装项目的依赖。 5. EXPOSE 3000 声明应用监听的端口号。 6. CMD ["node", "index.js"]：定义容器启动时默认执行的命令。 保存完Dockerfile后，我们可以试着构建镜像了。 --- 5. 构建并运行Docker镜像 在项目根目录下运行以下命令来构建镜像： bash docker build -t my-node-app . 这里的. 表示当前目录，my-node-app是我们给镜像起的名字。构建完成后，可以用以下命令查看是否成功生成了镜像： bash docker images 输出应该类似这样： REPOSITORY TAG IMAGE ID CREATED SIZE my-node-app latest abcdef123456 2 minutes ago 150MB 接着，我们可以启动容器试试看： bash docker run -d -p 3000:3000 my-node-app 参数解释： - -d：以后台模式运行容器。 - -p 3000:3000：将主机的3000端口映射到容器的3000端口。 - my-node-app：使用的镜像名称。 启动成功后，访问http://localhost:3000/，你会发现依然可以看到“Hello World”！这说明我们的Docker化部署已经初步完成了。 --- 6. 进阶 多阶段构建优化镜像大小 虽然上面的方法可行，但生成的镜像体积有点大（大约150MB左右）。有没有办法让它更小呢？答案是有！这就是Docker的“多阶段构建”。 修改后的Dockerfile如下： dockerfile 第一阶段：构建阶段 FROM node:16-alpine AS builder WORKDIR /app COPY package.json ./ RUN npm install COPY . . RUN npm run build 假设你有一个build脚本 第二阶段：运行阶段 FROM node:16-alpine WORKDIR /app COPY --from=builder /app/dist ./dist 假设build后的文件存放在dist目录下 COPY package.json ./ RUN npm install --production EXPOSE 3000 CMD ["node", "dist/index.js"] 这里的关键在于“--from=builder”，它允许我们在第二个阶段复用第一个阶段的结果。这样就能让开发工具和测试依赖 stays 在它们该待的地方，而不是一股脑全塞进最终的镜像里，这样一来镜像就能瘦成一道闪电啦！ --- 7. 总结与展望 写到这里，我相信你已经对如何用Docker部署Node.js应用有了基本的认识。虽然过程中可能会遇到各种问题，但每一次尝试都是成长的机会。记得多查阅官方文档，多动手实践，这样才能真正掌握这项技能。 未来，随着云计算和微服务架构的普及，容器化将成为每个开发者必备的技能之一。所以，别犹豫啦，赶紧去试试呗！要是你有什么不懂的，或者想聊聊自己的经历，就尽管来找我聊天，咱们一起唠唠~咱们一起进步！ 最后，祝大家都能早日成为Docker高手！😄

...绕不开本书的。 四、Java编程思想 《Java编程思想（第4版）》赢得了全球程序员的广泛赞誉，即使是最晦涩的概念，在Bruce Eckel的文字亲和力和小而直接的编程示例面前也会化解于无形。从Java的基础语法到最高级特性（深入的面向对象概念、多线程、自动项目构建、单元测试和调试等），《Java编程思想（第4版）》都能逐步指导你轻松掌握。从java编程思想这本书获得的各项大奖以及来自世界各地的读者评论中，不难看出这是一本经典之作。 五、算法导论 《算法导论》提供了对当代计算机算法研究的一个全面、综合性的介绍。全书共八部分，内容涵盖基础知识、排序和顺序统计量、数据结构、高级设计和分析技术、高级数据结构、图算法、算法问题选编，以及数学基础知识。书中深入浅出地介绍了大量的算法及相关的数据结构，以及用于解决一些复杂计算问题的高级策略（如动态规划、贪心算法、摊还分析等），重点在于算法的分析与设计。对于每一个专题，作者都试图提供目前最新的研究成果及样例解答，并通过清晰的图示来说明算法的执行过程。 六、深入理解计算机系统 《深入理解计算机系统》是将计算机软件和硬件理论结合讲述的经典教程，内容覆盖计算机导论、体系结构和处理器设计等多门课程。本书的大优点是为程序员描述计算机系统的实现细节，通过描述程序是如何映射到系统上，以及程序是如何执行的，使读者更好地理解程序的行为为什么是这样的，以及造成效率低下的原因。 七、鸟哥的Linux私房菜 《鸟哥的Linux私房菜基础学习篇》全面而详细地介绍了Linux操作系统。着重说明计算机的基础知识、Linux的学习方法，如何规划和安装Linux主机以及CentOS 7.x的安装、登录与求助方法；介绍Linux的文件系统、文件、目录与磁盘的管理；文字模式接口shell和管理系统的好帮手shell脚本，另外还介绍了文字编辑器vi和vim的使用方法；对于系统安全非常重要的Linux账号的管理、磁盘配额、高级文件系统管理、计划任务以及进程管理，系统管理员（root）的管理事项。 本书内容丰富全面，基本概念的讲解非常细致，深入浅出。各种功能和命令的介绍，都配以大量的实例操作和详尽的解析。本书是初学者学习Linux不可多得的一本入门好书。 八、计算机网络自顶向下方法 《计算机网络自顶向下方法》是经典的计算机网络教材，采用作者独创的自顶向下方法来讲授计算机网络的原理及其协议，自第1版出版以来已经被数百所大学和学院选作教材，被译为14种语言。 新版保持了以前版本的特色，继续关注因特网和计算机网络的现代处理方式，注重原理和实践，为计算机网络教学提供一种新颖和与时俱进的方法。同时，第7版进行了相当多的修订和更新，首次改变了各章的组织结构，将网络层分成两章（第4章关注网络层的数据平面，第5章关注网络层的控制平面） 九、MySQL是怎样运行的 《MySQL是怎样运行的》采用诙谐幽默、通俗易懂的写作风格，针对上面这些问题给出了相应的解答方案。尽管本书的表达方式与司空见惯的学术派、理论派IT图书有显著区别，但本书的确是相当正经的专业技术图书，内容涵盖了使用MySQL的同学在求职面试和工作中常见的一些核心概念。无论是身居MySQL专家身份的技术人员，还是技术有待进一步提升的DBA，甚至是刚投身于数据库行业的“萌新”人员，本书都是他们彻底了解MySQL运行原理的优秀图书。 十、编程珠玑 本篇文章为转载内容。原文链接：https://blog.csdn.net/m0_65485112/article/details/122007938。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...onsole 上已经创建了一个名为 my-secret 的密钥，并且它里面保存了我们的数据库密码。我们可以这样从 Secret Manager 中读取这个值： python from google.cloud import secretmanager def access_secret_version(project_id, secret_id, version_id): client = secretmanager.SecretManagerServiceClient() name = f"projects/{project_id}/secrets/{secret_id}/versions/{version_id}" response = client.access_secret_version(name=name) payload = response.payload.data.decode('UTF-8') return payload 使用示例 db_password = access_secret_version("your-project-id", "my-secret", "latest") print(f"Database Password: {db_password}") 这段代码做了什么呢？很简单，它实例化了一个 SecretManagerServiceClient 对象，然后根据提供的项目 ID、密钥名称以及版本号去访问对应的密钥内容。注意这里的 version_id 参数可以设置为 "latest" 来获取最新的版本。 --- 4. 将两者结合起来 构建更安全的应用 那么问题来了，怎么才能让 Tornado 和 Google Cloud Secret Manager 协同工作呢？其实答案很简单——我们可以将从 Secret Manager 获取到的敏感数据注入到 Tornado 的配置对象中，从而在整个应用范围内使用这些信息。 4.1 修改Tornado应用以支持从Secret Manager加载配置 让我们修改之前的 MainHandler 类，让它从 Secret Manager 中加载数据库密码并用于某种操作（比如查询数据库）。为了简化演示，这里我们假设有一个 get_db_password 函数负责完成这项任务： python from google.cloud import secretmanager def get_db_password(): client = secretmanager.SecretManagerServiceClient() name = f"projects/{YOUR_PROJECT_ID}/secrets/my-secret/versions/latest" response = client.access_secret_version(name=name) return response.payload.data.decode('UTF-8') class MainHandler(tornado.web.RequestHandler): def initialize(self, db_password): self.db_password = db_password def get(self): self.write(f"Connected to database with password: {self.db_password}") def make_app(): db_password = get_db_password() return tornado.web.Application([ (r"/", MainHandler, {"db_password": db_password}), ]) 在这个例子中，我们在 make_app 函数中调用了 get_db_password() 来获取数据库密码，并将其传递给 MainHandler 的构造函数作为参数。这样一来，每个 MainHandler 实例都会拥有自己的数据库密码属性。 --- 5. 总结与展望 好了朋友们，今天的分享就到这里啦！通过这篇文章，我们了解了如何利用 Tornado 和 Google Cloud Secret Manager 来构建更加安全可靠的 Web 应用。虽然过程中遇到了不少挑战，但最终的效果还是让我感到非常满意。 未来的话，我还想尝试更多有趣的功能组合，比如结合 Redis 缓存提高性能，或者利用 Pub/Sub 实现消息队列机制。如果你也有类似的想法或者遇到什么问题，欢迎随时跟我交流呀！ 最后祝大家 coding愉快，记得保护好自己的秘密哦~ 😊

...个小仓库里（那些就是节点），这样不仅能让数据更高效地存储起来，还能让我们的系统跑得更快，用起来更顺畅。试试看，保管让你爱不释手！ 第四章：事务冲突与并发控制 场景还原：在高并发环境下，多个用户同时尝试插入数据到同一表中，导致了写入失败。 问题浮现：即使网络连接稳定，磁盘空间充足，事务冲突仍可能导致写入失败。 解决方案：引入适当的并发控制机制是关键。在DorisDB中，可以通过设置合理的锁策略来避免或减少事务冲突。例如，使用行级锁或表级锁，根据具体需求选择最合适的锁模式。哎呀，兄弟，咱们在优化程序的时候，得注意一点，别搞那些没必要的同时进行的操作，这样能大大提升系统的稳定性。就像是做饭，你要是同时炒好几个菜，肯定得忙得团团转，而且容易出错。所以啊，咱们得一个个来，稳扎稳打，这样才能让系统跑得又快又稳！ 结语：从困惑到解决的旅程 面对“写入失败”，我们需要冷静分析，从不同的角度寻找问题所在。哎呀，你知道嘛，不管是网速慢了点、硬件不够给力、操作过程中卡壳了，还是设置哪里没对劲，这些事儿啊，都有各自的小妙招来解决。就像是遇到堵车了，你得找找是哪段路的问题，然后对症下药，说不定就是换个路线或者等等红绿灯，就能顺畅起来呢！哎呀，你知道不？咱们要是能持续地学习和动手做，那咱处理问题的能力就能慢慢上个新台阶。就像给水管通了塞子，数据的流动就更顺畅了。这样一来，咱们的业务跑起来也快多了，就像是有了个贴身保镖，保护着业务高效运转呢！嘿！听好了，每回遇到难题都不是白来的，那可是让你升级打怪的好机会！咱们就一起手牵手，勇闯数据的汪洋大海，去发现那些藏在暗处的新世界吧！别怕，有我在你身边，咱俩一起探险，一起成长！

...bortError是JavaScript中的一个常见错误类型，特别是在处理异步操作的时候。比如fetch请求、文件上传下载、定时器这些地方都可能遇到它。它就像是一个警报器，告诉你某件事中途被中断了。 举个简单的例子： javascript const controller = new AbortController(); const signal = controller.signal; setTimeout(() => { console.log('定时器触发了！'); }, 3000); controller.abort(); // 中断定时器 console.log(signal.reason); // 输出 "AbortError: The operation was aborted." 在这个例子中，我们创建了一个AbortController实例，并通过调用它的abort()方法来中断定时器。嘿，瞧瞧最后一行输出啊！这告诉我们出问题了，是个“AbortError”，简单说就是有某个操作被强行中断啦。 --- 二、AbortError的实际应用场景 说到AbortError的应用场景，我觉得最典型的就是网络请求了。你有没有过这样的经历？比如你在网页上点了个下载按钮，想看个大图或者视频啥的。刚点完没多久，就觉得“这速度也太磨叽了吧！再等下去我都快睡着了”，然后一狠心就直接取消了操作。哎呀，这就像是服务器那边正拼了命地给你打包数据呢，结果你这边的浏览器直接甩出一句：“兄弟，不用忙活了，我不等了！””这就是AbortError发挥作用的地方。 让我们来看一段代码： javascript async function fetchData() { const controller = new AbortController(); const signal = controller.signal; try { const response = await fetch('https://example.com/large-file', { signal }); console.log('数据已成功获取'); } catch (error) { if (error.name === 'AbortError') { console.log('请求被用户取消'); } else { console.error('发生了其他错误:', error); } } // 取消请求 controller.abort(); } fetchData(); 在这段代码里，我们使用AbortController来管理一个网络请求。如果用户决定取消请求，我们就调用controller.abort()，这时fetch函数会抛出一个AbortError。嘿嘿，简单来说呢，就是咱们逮住这个错误，看看它是不是个“AbortError”，如果是的话，就用一种超优雅的方式把它处理了，不搞什么大惊小怪的。 --- 三、AbortError与其他错误的区别 说到错误，难免要和其他错误比较一番。比如说嘛，就有人会好奇地问：“AbortError跟一般的错误到底有啥不一样呀？”说实话呢，这个问题我也琢磨了好久好久，头都快想大了！ 首先，AbortError是一种特殊的错误类型，专门用于表示操作被人为中断的情况。其实很多小错误啊，就是程序员自己不小心搞出来的，像打字打错了变量名，或者一激动让数组越界了之类的，都是挺常见的乌龙事件。简单来说呢，这俩的区别就是——AbortError就像是个“计划内”的小插曲，咱们事先知道它可能会发生，也能提前做好准备去应对；但普通的错误嘛，就好比是突然从天而降的小麻烦，压根儿没得防备，让人措手不及！ 举个例子： javascript function divide(a, b) { if (b === 0) { throw new Error('除数不能为零'); } return a / b; } try { console.log(divide(10, 0)); // 抛出普通错误 } catch (error) { console.error(error.message); // 输出 "除数不能为零" } 在这个例子中，divide函数因为传入了非法参数（即分母为0）而抛出了一个普通错误。而如果我们换成AbortError呢？ javascript const controller = new AbortController(); function process() { setTimeout(() => { console.log('处理完成'); }, 5000); } process(); controller.abort(); // 中断处理 这里虽然也有中断操作的意思，但并没有抛出任何错误。这就像是说，AbortError不会自己偷偷跑出来捣乱，得咱们主动去点那个abort()按钮才行。就好比你得自己动手去按开关，灯才不会自己亮起来一样。 --- 四、深入探讨AbortError的优缺点 说到优点嘛，我觉得AbortError最大的好处就是它让我们的代码更加健壮和可控。比如说啊，在面对一堆同时涌来的请求时， AbortError 就像一个神奇的开关，能帮我们把那些没用的请求一键关掉，这样就不会白白浪费资源啦！对了，它还能帮咱们更贴心地照顾用户体验呢！比如说，当用户等得花儿都快谢了，就给个机会让他们干脆放弃这事儿，省得干着急。 但是呢，凡事都有两面性。AbortError也有它的局限性。首先，它只适用于那些支持AbortSignal接口的操作，比如fetch、XMLHttpRequest之类。如果你尝试在一个不支持AbortSignal的操作上使用它，那就会直接报错。另外啊，要是随便乱用 AbortError 可不好，比如说老是取消请求的话，系统可能就会被折腾得够呛，负担越来越重，你说是不是？ 说到这里，我想起了之前开发的一个项目，当时为了优化性能，我给每个API请求都加了AbortController，结果发现有时候会导致页面加载速度反而变慢了。后来经过反复调试，我才意识到，频繁地取消请求其实是得不偿失的。所以啊，大家在使用AbortError的时候一定要权衡利弊，不能盲目追求“安全”。 --- 五、总结与展望 总的来说，AbortError是一个非常实用且有趣的错误类型。它不仅能让我们更轻松地搞定那些乱七八糟的异步任务，还能让代码变得更好懂、更靠谱！不过，就像任何工具一样，它也需要我们在实践中不断摸索和完善。 未来，随着前端开发越来越复杂，我相信AbortError会有更多的应用场景。不管是应对一大堆同时进行的任务，还是让咱们跟软件互动的时候更顺畅、更开心，它都绝对是我们离不开的得力助手！所以，各位小伙伴，不妨多尝试用它来解决实际问题，说不定哪天你会发现一个全新的解决方案呢！ 好了，今天的分享就到这里啦。希望能给大家打开一点思路，也期待大家在评论区畅所欲言，分享你的想法！最后，祝大家coding愉快，早日成为编程界的高手！

...通过验证后，在系统上创建的一个独立的工作环境，其中包含了用户的配置、权限和其他相关状态信息。Sysinternals工具集中的LogonSessions工具则能列出当前系统上的所有活动登录会话，帮助管理员监控和管理用户登录情况。 动态磁盘分区（Dynamic Disk Partitioning） , 动态磁盘是Windows操作系统中相对于基本磁盘而言的一种更为灵活的磁盘管理方式，它可以支持诸如跨多个物理磁盘的卷扩展等功能。LDMDump工具在文章中被提及，作用是倾倒逻辑磁盘管理器在Windows 2000动态磁盘分区上的数据库内容，从而让管理员了解和分析动态磁盘的详细配置信息。

...，确保所有参与计算的节点都能够访问到这些资源。

...初始化部分： java NacosConfigService configService = NacosFactory.createConfigService("http://localhost:8848"); 这段代码看起来没问题啊，路径明明指向的是本地的Nacos服务器。而且我之前测试的时候也是这么写的，一直都没问题。 “会不会是配置路径格式变了？”我又重新检查了一遍Nacos的配置管理页面，确认路径确实正确无误。然后我又检查了权限设置，确保服务有权限访问这些配置。 “权限应该没问题吧，毕竟之前都好好的。”我自言自语道。不过嘛，我总觉得不放心，就随手叫上咱们的运维小伙伴帮我看了一下Nacos服务端的配置权限。没想到一看还真发现了点小问题，仔细一排查才发现权限其实没啥大事儿，一切正常！ “看来不是路径和权限的问题，那问题到底出在哪呢？”我有点沮丧，但还是不死心，继续往下查。 --- 三、深入排查 网络连接与超时设置 接下来，我开始怀疑是不是网络连接出了问题。毕竟Nacos是基于网络通信的，如果网络不通畅，那自然会导致读取失败。 我先检查了Nacos服务端的日志，发现并没有什么异常。再瞧瞧服务端的那个监听端口，嘿，8848端口不仅开着呢，而且服务还稳稳地在跑着，一点问题没有！ “难道是客户端的网络问题？”我心中一动，赶紧查看了服务端的防火墙规则，确认没有阻断任何请求。接着我又尝试ping了一下Nacos服务端的IP地址，结果发现网络连通性很好。 “网络应该没问题啊，那会不会是超时时间设置得太短了？”我灵机一动，想到之前在其他项目中遇到过类似的问题，可能是客户端等待响应的时间太短，导致请求超时。 于是我修改了Nacos客户端的配置，增加了超时时间： java Properties properties = new Properties(); properties.put(PropertyKeyConst.SERVER_ADDR, "localhost:8848"); properties.put(PropertyKeyConst.CONNECT_TIMEOUT_MS, "5000"); // 增加到5秒 NacosConfigService configService = NacosFactory.createConfigService(properties); 重新启动服务后，问题依然存在。看来超时时间也不是主要原因。 “真是搞不懂啊，难道是Nacos本身的问题？”我有些泄气，但还是决定继续深挖下去。 --- 四、终极排查 代码逻辑与异常处理 最后，我决定从代码逻辑入手，看看是不是程序内部的某些逻辑出了问题。于是我打开了Nacos客户端的源码，开始逐行分析。 在Nacos客户端的实现中，有一个方法是用来获取配置的： java String content = configService.getConfig(dataId, group, timeoutMs); 我仔细检查了这个方法的调用点，发现它是在服务启动时被调用的。你瞧，服务一启动呢，就会加载一堆东西，像数据库连接池啦，缓存配置啦，各种各样的“装备”都得准备好，这样它才能顺利开工干活呀！ “会不会是某个配置项的加载顺序影响了Nacos的读取？”我突然想到这一点。我琢磨着这事儿，干脆把所有的配置加载顺序仔仔细细捋了一遍，就为了确保Nacos的配置能在服务刚启动的时候就给安排上，别拖到后面出了幺蛾子。 同时，我还加强了异常处理逻辑，给Nacos的读取操作加上了try-catch块，以便捕获具体的异常信息： java try { String content = configService.getConfig(dataId, group, timeoutMs); System.out.println("Config loaded successfully: " + content); } catch (NacosException e) { System.err.println("Failed to load config: " + e.getMessage()); } 经过一番调整后，我再次启动服务，终于看到了一条令人振奋的消息：“Config loaded successfully”。 “太好了！”我长舒一口气，“原来问题就出在这里啊。” --- 五、总结与感悟 经过这次折腾，我对Nacos有了更深的理解。Nacos这东西确实挺牛的，是个超棒的配置管理工具，但用着用着你会发现，它也不是完美无缺的，各种小问题啊、坑啊，时不时就冒出来折腾你一下。其实吧，这些问题真不一定是Nacos自己惹的祸，八成是咱们的代码写得有点问题，或者是环境配错了，带偏了Nacos。 “其实啊，调试的过程就像侦探破案一样，需要耐心和细心。我坐在电脑前忍不住感慨：“哎，有时候觉得这问题看起来平平无奇的，可谁知道背后可能藏着啥惊天大秘密呢！”” 总之，这次经历让我明白了一个道理：遇到问题不要慌，要冷静分析，逐步排查。只有这样，才能找到问题的根本原因，解决问题。希望我的经验能对大家有所帮助，如果有类似的问题，不妨按照这个思路试试看！

...写死了另一个类的对象创建逻辑，这就跟在菜谱上直接固定了所有食材的品牌一样，一旦你想换点新鲜的或者调整一下，就得满世界翻找那些用到这个菜谱的地方，挨个改过来。更惨的是，改完还得一项项地重新验证，生怕哪里漏掉了，搞得自己头都大了。 这就是没有依赖注入（Dependency Injection, DI）的问题。依赖注入嘛，简单说就是把对象的创建和管理工作“外包”给一个外部的“容器”，这样就能让代码之间的关系变得松散一些，彼此不那么死板地绑在一起，开发起来也更灵活方便。这样做简直太棒了！代码变得超级清晰，就像一条干净整洁的小路，谁走都明白；维护起来也轻松多了，像是收拾一个不大的房间，根本不用费劲找东西；而且还能轻松做单元测试，就像给每个小零件单独体检一样简单！ 但是，依赖注入也不是万能的。如果我们配置不对，那就会出大问题。今天我们就来聊聊这个话题——DI容器配置错误。 --- 2. 配置错误 从一个小例子说起 先来看一个简单的例子： csharp public interface IService { void DoWork(); } public class Service : IService { public void DoWork() { Console.WriteLine("Doing work..."); } } 假设我们有一个Service类实现了IService接口，现在我们需要在程序中使用这个服务。按照传统的做法，可能会直接在类内部实例化： csharp public class Worker { private readonly IService _service = new Service(); public void Execute() { _service.DoWork(); } } 这种方式看起来没什么问题，但实际上隐藏着巨大的隐患。比如，如果你需要替换Service为其他实现（比如MockService），你就得修改Worker类的代码。这违背了开闭原则。 于是，我们引入了依赖注入框架，比如Microsoft的Microsoft.Extensions.DependencyInjection。让我们看看如何正确配置。 --- 3. 正确配置 DI容器的正确姿势 首先，你需要注册服务。比如，在Program.cs文件中： csharp using Microsoft.Extensions.DependencyInjection; var services = new ServiceCollection(); services.AddTransient(); var serviceProvider = services.BuildServiceProvider(); 这里的关键点在于Transient这个词。它表示每次请求时都会生成一个新的实例。对了，还有别的选择呢，比如说 Scoped——在一个作用域里大家用同一个实例，挺节省资源的；再比如 Singleton——在整个应用跑着的时候大家都用一个“独苗”实例，从头到尾都不换。选择合适的生命周期很重要，否则可能会导致意想不到的行为。 接下来，我们可以通过依赖注入获取实例： csharp public class Worker { private readonly IService _service; public Worker(IService service) { _service = service; } public void Execute() { _service.DoWork(); } } 在这个例子中，Worker类不再负责创建IService的实例，而是由DI容器提供。这种解耦的方式让代码更加灵活。 --- 4. 配置错误 常见的坑 然而，现实总是比理想复杂得多。以下是一些常见的DI配置错误，以及它们可能带来的后果。 4.1 注册类型时搞错了 有时候我们会不小心把类型注册错了。比如： csharp services.AddTransient(); // 想注册MockService，却写成了Service 结果就是，无论你在代码中怎么尝试，拿到的永远是Service而不是MockService。其实这个坑挺容易被忽略的，毕竟编译器又不报错，一切都看起来风平浪静，直到程序跑起来的时候，问题才突然冒出来，啪叽一下给你整一个大 surprise！ 我的建议是，尽量使用常量或者枚举来定义服务名称，这样可以减少拼写错误的风险： csharp public static class ServiceNames { public const string MockService = "MockService"; public const string RealService = "RealService"; } services.AddTransient(ServiceNames.MockService, typeof(MockService)); 4.2 生命周期设置不当 另一个常见的问题是生命周期设置错误。比如说，你要是想弄个单例服务，结果不小心把它设成了 Transient，那每次调用的时候都会新生成一个实例。这就好比你本来想让一个人负责一件事，结果每次都换个人来干，不仅效率低得让人崩溃，搞不好还会出大乱子呢！ csharp // 错误示范 services.AddTransient(); // 正确示范 services.AddSingleton(); 记住，单例模式适用于那些无状态或者状态不重要的场景。嘿，想象一下，你正在用一个数据库连接池这种“有状态”的服务，要是把它搞成单例模式，那可就热闹了——多个线程或者任务同时去抢着用它，结果就是互相踩脚、搞砸事情，什么竞争条件啦、数据混乱啦，各种麻烦接踵而至。就好比大家伙儿都盯着同一个饼干罐子，都想伸手拿饼干，但谁也没个规矩，结果不是抢得太猛把罐子摔了，就是谁都拿不痛快。所以啊，这种情况下，还是别让单例当这个“独裁者”了，分清楚责任才靠谱！ 4.3 忘记注册依赖 有时候，我们可能会忘记注册某些依赖项。比如： csharp public class SomeClass { private readonly IAnotherService _anotherService; public SomeClass(IAnotherService anotherService) { _anotherService = anotherService; } } 如果IAnotherService没有被注册到DI容器中，那么在运行时就会抛出异常。为了避免这种情况，你可以使用AddScoped或AddTransient来确保所有依赖都被正确注册。 --- 5. 探讨与总结 通过今天的讨论，我们可以看到，虽然依赖注入能够极大地提高代码的质量和可维护性，但它并不是万能的。设置搞错了，那可就麻烦大了，小到一个单词拼错了，大到程序跑偏、东西乱套，什么幺蛾子都可能出现。 我的建议是，在使用DI框架时要多花时间去理解和实践。不要害怕犯错，因为正是这些错误教会了我们如何更好地编写代码。同时，也要学会利用工具和日志来帮助自己排查问题。 最后，我想说的是，编程不仅仅是解决问题的过程，更是一个不断学习和成长的过程。希望大家能够在实践中找到乐趣，享受每一次成功的喜悦！ 好了，今天的分享就到这里啦，如果你有任何疑问或者想法，欢迎随时留言交流哦！😄

...示例代码，展示了如何创建一个支持GZIP格式的外部表： sql -- 创建数据库 CREATE DATABASE IF NOT EXISTS log_db; -- 切换到数据库 USE log_db; -- 创建外部表并指定GZIP格式 CREATE EXTERNAL TABLE IF NOT EXISTS logs ( id STRING, timestamp STRING, message STRING ) ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t' STORED AS TEXTFILE -- 注意这里使用TEXTFILE而不是默认的SEQUENCEFILE LOCATION '/path/to/gzipped/files'; 看到这里，你可能会问：“为什么这里要用TEXTFILE而不是SEQUENCEFILE？”这是因为Hive默认不支持直接读取GZIP格式的数据，所以我们需要手动调整存储格式。此外，还需要确保你的Hadoop集群已经启用了GZIP解压功能。 3.2 BZIP2的高阶玩法 接下来轮到BZIP2登场了。相比于GZIP，BZIP2的压缩比更高，但它也有一个明显的缺点：解压速度较慢。因此，BZIP2更适合用于那些访问频率较低的大规模静态数据集。 下面这段代码展示了如何创建一个支持BZIP2格式的分区表： sql -- 创建数据库 CREATE DATABASE IF NOT EXISTS archive_db; -- 切换到数据库 USE archive_db; -- 创建分区表并指定BZIP2格式 CREATE TABLE IF NOT EXISTS archives ( file_name STRING, content STRING ) PARTITIONED BY (year INT, month INT) STORED AS RCFILE -- RCFILE支持BZIP2压缩 TBLPROPERTIES ("orc.compress"="BZIP2"); 需要注意的是，在这种情况下，你需要确保Hive的配置文件中启用了BZIP2支持，并且相关的JAR包已经正确安装。 --- 四、实战经验分享 踩过的坑与学到的东西 在这个过程中，我遇到了不少挫折。比如说吧，有次我正打算把一个GZIP文件塞进Hive里，结果系统直接给我整了个报错，说啥解码器找不着。折腾了半天才发现，哎呀，原来是服务器上那个GZIP工具的老版本太不给劲了，跟最新的Hadoop配不上，闹起了脾气！于是，我赶紧联系运维团队升级了相关依赖，这才顺利解决问题。 还有一个教训是关于文件命名规范的。一开始啊，我老是忘了在压缩完的文件后面加“.gz”或者“.bz2”这种后缀名，搞得 Hive 一脸懵逼，根本分不清文件是啥类型的，直接就报错不认账了。后来我才明白，那些后缀名可不只是个摆设啊，它们其实是给文件贴标签的，告诉你这个文件是啥玩意儿，是图片、音乐，还是什么乱七八糟的东西。 --- 五、总结与展望 总的来说，虽然Hive对GZIP和BZIP2的支持有限，但这并不意味着我们不能利用它们的优势。相反，只要掌握了正确的技巧，我们完全可以在这两者之间找到平衡点，满足不同的业务需求。 最后，我想说的是，作为一名数据工程师，我们不应该被工具的限制束缚住手脚。相反，我们应该敢于尝试新事物，勇于突破常规。毕竟，正是这种探索精神，推动着整个行业不断向前发展！ 好了，今天的分享就到这里啦。如果你也有类似的经历或者想法，欢迎随时跟我交流哦~再见啦！

...好了。 接下来，我们创建项目文件夹，并初始化 npm： bash mkdir real-time-monitor cd real-time-monitor npm init -y 然后安装必要的依赖包。这里我们用到两个核心库：Express 和 ws（WebSocket 库）。Express 是用来搭建 HTTP 服务的，ws 则专门用于 WebSocket 通信。 bash npm install express ws 接下来，我们写一个最基础的 HTTP 服务，确保环境能正常工作： javascript // server.js const express = require('express'); const app = express(); app.get('/', (req, res) => { res.send('Hello World!'); }); const PORT = process.env.PORT || 3000; app.listen(PORT, () => { console.log(Server is running on port ${PORT}); }); 保存文件后运行 node server.js，然后在浏览器输入 http://localhost:3000，应该能看到 “Hello World!”。到这里，我们的基本框架已经搭好了，是不是感觉还挺容易的？ --- 3. 第二步 引入 WebSocket 现在我们有了一个 HTTP 服务，接下来该让 WebSocket 上场了。WebSocket 的好处就是能在浏览器和服务器之间直接搭起一条“高速公路”，不用老是像发短信那样频繁地丢 HTTP 请求过去，省时又高效！为了方便，我们可以直接用 ws 库来实现。 修改 server.js 文件，添加 WebSocket 相关代码： javascript // server.js const express = require('express'); const WebSocket = require('ws'); const app = express(); const wss = new WebSocket.Server({ port: 8080 }); wss.on('connection', (ws) => { console.log('A client connected!'); // 接收来自客户端的消息 ws.on('message', (message) => { console.log(Received message => ${message}); ws.send(You said: ${message}); }); // 当客户端断开时触发 ws.on('close', () => { console.log('Client disconnected.'); }); }); app.get('/', (req, res) => { res.sendFile(__dirname + '/index.html'); }); const PORT = process.env.PORT || 3000; app.listen(PORT, () => { console.log(HTTP Server is running on port ${PORT}); }); 这段代码做了几件事： 1. 创建了一个 WebSocket 服务器，监听端口 8080。 2. 当客户端连接时，打印日志并等待消息。 3. 收到消息后，会回传给客户端。 4. 如果客户端断开连接，也会记录日志。 为了让浏览器能连接到 WebSocket 服务器，我们还需要一个简单的 HTML 页面作为客户端入口： html Real-Time Monitor WebSocket Test Send Message 这段 HTML 代码包含了一个简单的聊天界面，用户可以在输入框中输入内容并通过 WebSocket 发送到服务器，同时也能接收到服务器返回的信息。跑完 node server.js 之后，别忘了打开浏览器，去 http://localhost:3000 看一眼，看看它是不是能正常转起来。 --- 4. 第三步 扩展功能——实时监控数据 现在我们的 WebSocket 已经可以正常工作了，但还不能算是一个真正的监控面板。为了让它更实用一点，咱们不妨假装弄点监控数据玩玩，像CPU用得多不多、内存占了百分之多少之类的。 首先，我们需要一个生成随机监控数据的函数： javascript function generateRandomMetrics() { return { cpuUsage: Math.random() 100, memoryUsage: Math.random() 100, diskUsage: Math.random() 100 }; } 然后，在 WebSocket 连接中定时向客户端推送这些数据： javascript wss.on('connection', (ws) => { console.log('A client connected!'); setInterval(() => { const metrics = generateRandomMetrics(); ws.send(JSON.stringify(metrics)); }, 1000); // 每秒发送一次 ws.on('close', () => { console.log('Client disconnected.'); }); }); 客户端需要解析接收到的数据，并动态更新页面上的信息。我们可以稍微改造一下 HTML 和 JavaScript： html CPU Usage: Memory Usage: Disk Usage: javascript socket.onmessage = (event) => { const metrics = JSON.parse(event.data); document.getElementById('cpuProgress').value = metrics.cpuUsage; document.getElementById('memoryProgress').value = metrics.memoryUsage; document.getElementById('diskProgress').value = metrics.diskUsage; const messagesDiv = document.getElementById('messages'); messagesDiv.innerHTML += Metrics updated. ; }; 这样，每秒钟都会从服务器获取一次监控数据，并在页面上以进度条的形式展示出来。是不是很酷？ --- 5. 结尾 总结与展望 通过这篇文章，我们从零开始搭建了一个基于 Node.js 和 WebSocket 的实时监控面板。别看它现在功能挺朴素的，但这东西一出手就让人觉得，WebSocket 在实时互动这块儿真的大有可为啊！嘿，听我说！以后啊，你完全可以接着把这个项目捯饬得更酷一些。比如说，弄点新鲜玩意儿当监控指标，让用户用起来更爽，或者直接把它整到真正的生产环境里去，让它发挥大作用！ 其实开发的过程就像拼图一样，有时候你会遇到困难，但只要一点点尝试和调整，总会找到答案。希望这篇文章能给你带来灵感，也欢迎你在评论区分享你的想法和经验！ 最后，如果你觉得这篇文章对你有帮助，记得点个赞哦！😄 --- 完

...代码实现 本质上还是创建socket连接去获取ntp服务的时间与本地时间比较，不一致修改本机时间即可。 NtpClient.h //// Created by lwang on 2023-03-18.//ifndef NTP_CLIENT_Hdefine NTP_CLIENT_Hinclude <stdio.h>include <stdlib.h>include <string.h>include <time.h>include <iostream>include <unistd.h>include <sys/select.h>include <sys/time.h>include <sys/socket.h>include <arpa/inet.h>include <netdb.h>include <errno.h>include <endian.h>include <map>include <string>include <mutex>using namespace std;define NTP_LI 0define NTP_VERSION_NUM 3define NTP_MODE_CLIENT 3define NTP_MODE_SERVER 4define NTP_STRATUM 0define NTP_POLL 4define NTP_PRECISION -6define NTP_MIN_LEN 48define NTP_SERVER_PORT 123define NTP_SERVER_ADDR "119.28.183.184"define TIMEOUT 2define BUFSIZE 1500define JAN_1970 0x83aa7e80define NTP_CONV_FRAC32(x) (uint64_t)((x) ((uint64_t)1 << 32))define NTP_REVE_FRAC32(x) ((double)((double)(x) / ((uint64_t)1 << 32)))define NTP_CONV_FRAC16(x) (uint32_t)((x) ((uint32_t)1 << 16))define NTP_REVE_FRAC16(x) ((double)((double)(x) / ((uint32_t)1 << 16)))define USEC2FRAC(x) ((uint32_t)NTP_CONV_FRAC32((x) / 1000000.0))define FRAC2USEC(x) ((uint32_t)NTP_REVE_FRAC32((x)1000000.0))define NTP_LFIXED2DOUBLE(x) ((double)(ntohl(((struct l_fixedpt )(x))->intpart) - JAN_1970 + FRAC2USEC(ntohl(((struct l_fixedpt )(x))->fracpart)) / 1000000.0))struct s_fixedpt{uint16_t intpart;uint16_t fracpart;};struct l_fixedpt{uint32_t intpart;uint32_t fracpart;};struct ntphdr{if __BYTE_ORDER == __BID_ENDIANunsigned int ntp_li : 2;unsigned int ntp_vn : 3;unsigned int ntp_mode : 3;endifif __BYTE_ORDER == __LITTLE_ENDIANunsigned int ntp_mode : 3;unsigned int ntp_vn : 3;unsigned int ntp_li : 2;endifuint8_t ntp_stratum;uint8_t ntp_poll;int8_t ntp_precision;struct s_fixedpt ntp_rtdelay;struct s_fixedpt ntp_rtdispersion;uint32_t ntp_refid;struct l_fixedpt ntp_refts;struct l_fixedpt ntp_orits;struct l_fixedpt ntp_recvts;struct l_fixedpt ntp_transts;};class NtpClient {public:NtpClient();virtual ~NtpClient();void GetNtpTime(std::string &ntpTime);in_addr_t HostTransfer(const char host);int PaddingNtpPackage(void buf, size_t size);double GetOffset(const struct ntphdr ntp, const struct timeval recvtv);private:int m_sockfd;};endif / NTP_CLIENT_H / NtpClient.cpp //// Created by lwang on 2023-03-18.//include "NtpClient.h"NtpClient::NtpClient() { }NtpClient::~NtpClient() {}in_addr_t NtpClient::HostTransfer(const char host){in_addr_t saddr;struct hostent hostent;if ((saddr = inet_addr(host)) == INADDR_NONE){if ((hostent = gethostbyname(host)) == NULL){return INADDR_NONE;}memmove(&saddr, hostent->h_addr, hostent->h_length);}return saddr;}int NtpClient::PaddingNtpPackage(void buf, size_t size) // 构建并发送NTP请求报文{if (!size)return -1;struct ntphdr ntp;struct timeval tv;memset(buf, 0, BUFSIZE);ntp = (struct ntphdr )buf;ntp->ntp_li = NTP_LI;ntp->ntp_vn = NTP_VERSION_NUM;ntp->ntp_mode = NTP_MODE_CLIENT;ntp->ntp_stratum = NTP_STRATUM;ntp->ntp_poll = NTP_POLL;ntp->ntp_precision = NTP_PRECISION;gettimeofday(&tv, NULL); // 把目前的时间用tv 结构体返回ntp->ntp_transts.intpart = htonl(tv.tv_sec + JAN_1970);ntp->ntp_transts.fracpart = htonl(USEC2FRAC(tv.tv_usec));size = NTP_MIN_LEN;return 0;}double NtpClient::GetOffset(const struct ntphdr ntp, const struct timeval recvtv) // 偏移量{double t1, t2, t3, t4;t1 = NTP_LFIXED2DOUBLE(&ntp->ntp_orits);t2 = NTP_LFIXED2DOUBLE(&ntp->ntp_recvts);t3 = NTP_LFIXED2DOUBLE(&ntp->ntp_transts);t4 = recvtv->tv_sec + recvtv->tv_usec / 1000000.0;return ((t2 - t1) + (t3 - t4)) / 2;}void NtpClient::GetNtpTime(std::string &ntpTime){char buffer[64] = {0};char cmd[128] = {0};tm local;char buf[BUFSIZE];size_t nbytes;int maxfd1;struct sockaddr_in servaddr;fd_set readfds;struct timeval timeout, recvtv, tv;double offset;servaddr.sin_family = AF_INET;servaddr.sin_port = htons(NTP_SERVER_PORT);servaddr.sin_addr.s_addr = HostTransfer(NTP_SERVER_ADDR);if ((m_sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0){perror("socket error");return ;}if (connect(m_sockfd, (struct sockaddr )&servaddr, sizeof(struct sockaddr)) != 0){perror("connect error");return ;}nbytes = BUFSIZE;if (PaddingNtpPackage(buf, &nbytes) != 0){fprintf(stderr, "construct ntp request error \n");exit(-1);}send(m_sockfd, buf, nbytes, 0);FD_ZERO(&readfds);FD_SET(m_sockfd, &readfds);maxfd1 = m_sockfd + 1;timeout.tv_sec = TIMEOUT;timeout.tv_usec = 0;if (select(maxfd1, &readfds, NULL, NULL, &timeout) > 0){if (FD_ISSET(m_sockfd, &readfds)){if ((nbytes = recv(m_sockfd, buf, BUFSIZE, 0)) < 0){perror("recv error");exit(-1);}// 计算C/S时间偏移量gettimeofday(&recvtv, NULL);offset = GetOffset((struct ntphdr )buf, &recvtv);gettimeofday(&tv, NULL);tv.tv_sec += (int)offset;tv.tv_usec += offset - (int)offset;local = localtime((time_t )&tv.tv_sec);strftime(buffer, 64, "%Y-%m-%d %H:%M:%S", local);ntpTime = std::string(buffer);} }return ;} main.cpp include "NtpClient.h"int main(){std::string ntpTime = "";char curBuf[64] = {0};struct timeval cur;tm local;NtpClient client;client.GetNtpTime(ntpTime);cout << "ntpTime: " << ntpTime << endl;gettimeofday(&cur, NULL);local = localtime((time_t )&cur.tv_sec);strftime(curBuf, 64, "%Y-%m-%d %H:%M:%S", local);std::string curTime = std::string(curBuf);cout << "curTime: " << curTime << endl;if (curTime != ntpTime){cout << "start time calibrate!" << endl;std::string cmd = "sudo date -s \"" + ntpTime + "\"";system(cmd.c_str());cout << "cmd: " << cmd << endl;}else{cout << "time seem" << endl;}return 0;} 推荐一个零声学院免费教程，个人觉得老师讲得不错， 分享给大家：[Linux，Nginx，ZeroMQ，MySQL，Redis， fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker， TCP/IP，协程，DPDK等技术内容，点击立即学习: 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_46935110/article/details/129683157。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...需求。例如，元素用于创建对话框或模态窗口，为用户提供更加直观的交互体验； 和 组合使用，让图片和图表等媒介内容具有更清晰的上下文描述。 此外，各大浏览器厂商也在持续更新对HTML5特性的支持。Chrome、Firefox和Safari等主流浏览器已全面支持这些语义元素，并针对无障碍浏览（Accessibility）进行了一系列改进。例如，通过ARIA属性配合HTML5语义元素，可以更好地帮助屏幕阅读器等辅助技术理解和解析页面结构。 对于实际应用层面，许多前端框架如Bootstrap、Foundation等也积极采纳HTML5语义化元素，使得开发者能够更容易地构建具有良好语义结构和响应式布局的网页。同时，随着Google等搜索引擎对网站质量评价标准的不断提升，遵循语义化标签规范的网页将更有可能获得更好的搜索排名。 总之，紧跟HTML5的发展步伐并将其语义化特性融入到日常开发实践中，不仅能提升网页的可读性和易用性，也有利于实现搜索引擎优化，从而推动网站流量的增长与用户满意度的提升。未来，随着Web Components、Shadow DOM等新特性的普及，HTML5将在构建模块化、组件化的现代Web应用程序中发挥更加关键的作用。

...que_ptr还支持创建动态数组。在C++中，创建数组有很多方法，如下所示： // 静态数组，在编译时决定了数组大小int arr[10];// 通过指针创建在堆上的数组，可在运行时动态指定数组大小，但需要手动释放内存int arr = new int[10];// 通过std::vector容器创建动态数组，无需手动释放数组内存vector<int> arr(10);// 通过unique_ptr创建动态数组，也无需手动释放数组内存，比vector更轻量化unique_ptr<int[]> arr(new int[10]); 这里需要注意的是，不管vector还是unique_ptr，虽然可以帮我们自动释放数组内存，但如果数组的元素是复杂数据类型时，我们还需要在其析构函数中正确释放内存。 真正的智能指针：shared_ptr auto_ptr和unique_ptr都有或多或少的缺陷，因此C++11还推出了shared_ptr，这也是目前工程内使用最多最广泛的智能指针，他使用引用计数（感觉有参考Objective-C的嫌疑），实现对同一块内存可以有多个引用，在最后一个引用被释放时，指向的内存才释放，这也是和unique_ptr最大的区别。 另外，使用shared_ptr过程中有几点需要注意： 构造shared_ptr的方法，如下示例代码所示，我们尽量使用shared_ptr构造函数或者make_shared的方式创建shared_ptr，禁止使用裸指针赋值的方式，这样会shared_ptr难于管理指针的生命周期。 // 使用裸指针赋值构造，不推荐，裸指针被释放后，shared_ptr就野了，不能完全控制裸指针的生命周期，失去了智能指针价值int p = new int(10);shared_ptr<int>sp = p;delete p; // sp将成为野指针，使用sp将crash// 将裸指针作为匿名指针传入构造函数，一般做法，让shared_ptr接管裸指针的生命周期，更安全shared_ptr<int>sp1(new int(10));// 使用make_shared，推荐做法，更符合工厂模式，可以连代码中的所有new，更高效；方法的参数是用来初始化模板类shared_ptr<int>sp2 = make_shared<int>(10); 禁止使用指向shared_ptr的裸指针，也就是智能指针的指针，这听起来就很奇怪，但开发中我们还需要注意，使用shared_ptr的指针指向一个shared_ptr时，引用计数并不会加一，操作shared_ptr的指针很容易就发生野指针异常。 shared_ptr<int>sp = make_shared<int>(10);cout << sp.use_count() << endl; //输出1shared_ptr<int> sp1 = &sp;cout << (sp1).use_count() << endl; //输出依然是1(sp1).reset(); //sp成为野指针cout << sp << endl; //crash 使用shared_ptr创建动态数组，在介绍unique_ptr时我们就讲过创建动态数组，而shared_ptr同样可以做到，不过稍微复杂一点，如下代码所示，除了要显示指定析构方法外（因为默认是T的析构函数，不是T[]），另外对外的数据类型依然是shared_ptr<T>，非常有迷惑性，看不出来是数组，最后不能直接使用下标读写数组，要先get()获取裸指针才可以使用下标。所以，不推荐使用shared_ptr来创建动态数组，尽量使用unique_ptr，这可是unique_ptr为数不多的优势了。 template <typename T>shared_ptr<T> make_shared_array(size_t size) {return shared_ptr<T>(new T[size], default_delete<T[]>());}shared_ptr<int>sp = make_shared_array(10); //看上去是shared<int>类型，实际上是数组sp.get()[0] = 100; //不能直接使用下标读写数组元素，需要通过get()方法获取裸指针后再操作 用shared_ptr实现多态，在我们使用裸指针时，实现多态就免不了定义虚函数，那么用shared_ptr时也不例外，不过有一处是可以省下的，就是析构函数我们不需要定义为虚函数了，如下面代码所示： class A {public:~A() {cout << "dealloc A" << endl;} };class B : public A {public:~B() {cout << "dealloc B" << endl;} };int main(int argc, const char argv[]) {A a = new B();delete a; //只打印dealloc Ashared_ptr<A>spa = make_shared<B>(); //析构spa是会先打印dealloc B，再打印dealloc Areturn 0;} 循环引用，笔者最先接触引用计数的语言就是Objective-C，而OC中最常出现的内存问题就是循环引用，如下面代码所示，A中引用B，B中引用A，spa和spb的强引用计数永远大于等于1，所以直到程序退出前都不会被退出，这种情况有时候在正常的业务逻辑中是不可避免的，而解决循环引用的方法最有效就是改用weak_ptr，具体可见下一章。 class A {public:shared_ptr<B> b;};class B {public:shared_ptr<A> a;};int main(int argc, const char argv[]) {shared_ptr<A> spa = make_shared<A>();shared_ptr<B> spb = make_shared<B>();spa->b = spb;spb->a = spa;return 0;} //main函数退出后，spa和spb强引用计数依然为1，无法释放 刚柔并济：weak_ptr 正如上一章提到，使用shared_ptr过程中有可能会出现循环引用，关键原因是使用shared_ptr引用一个指针时会导致强引用计数+1，从此该指针的生命周期就会取决于该shared_ptr的生命周期，然而，有些情况我们一个类A里面只是想引用一下另外一个类B的对象，类B对象的创建不在类A，因此类A也无需管理类B对象的释放，这个时候weak_ptr就应运而生了，使用shared_ptr赋值给一个weak_ptr不会增加强引用计数（strong_count），取而代之的是增加一个弱引用计数（weak_count），而弱引用计数不会影响到指针的生命周期，这就解开了循环引用，上一章最后的代码使用weak_ptr可改造为如下代码。 class A {public:shared_ptr<B> b;};class B {public:weak_ptr<A> a;};int main(int argc, const char argv[]) {shared_ptr<A> spa = make_shared<A>();shared_ptr<B> spb = make_shared<B>();spa->b = spb; //spb强引用计数为2，弱引用计数为1spb->a = spa; //spa强引用计数为1，弱引用计数为2return 0;} //main函数退出后，spa先释放，spb再释放，循环解开了使用weak_ptr也有需要注意的点，因为既然weak_ptr不负责裸指针的生命周期，那么weak_ptr也无法直接操作裸指针，我们需要先转化为shared_ptr，这就和OC的Strong-Weak Dance有点像了，具体操作如下：shared_ptr<int> spa = make_shared<int>(10);weak_ptr<int> spb = spa; //weak_ptr无法直接使用裸指针创建if (!spb.expired()) { //weak_ptr最好判断是否过期，使用expired或use_count方法，前者更快spb.lock() += 10; //调用weak_ptr转化为shared_ptr后再操作裸指针}cout << spa << endl; //20 智能指针原理 看到这里，智能指针的用法基本介绍完了，后面笔者来粗浅地分析一下为什么智能指针可以有效帮我们管理裸指针的生命周期。 使用栈对象管理堆对象 在C++中，内存会分为三部分，堆、栈和静态存储区，静态存储区会存放全局变量和静态变量，在程序加载时就初始化，而堆是由程序员自行分配，自行释放的，例如我们使用裸指针分配的内存；而最后栈是系统帮我们分配的，所以也会帮我们自动回收。因此，智能指针就是利用这一性质，通过一个栈上的对象（shared_ptr或unique_ptr）来管理一个堆上的对象（裸指针），在shared_ptr或unique_ptr的析构函数中判断当前裸指针的引用计数情况来决定是否释放裸指针。 shared_ptr引用计数的原理 一开始笔者以为引用计数是放在shared_ptr这个模板类中，但是细想了一下，如果这样将shared_ptr赋值给另一个shared_ptr时，是怎么做到两个shared_ptr的引用计数同时加1呢，让等号两边的shared_ptr中的引用计数同时加1？不对，如果还有第二个shared_ptr再赋值给第三个shared_ptr那怎么办呢？或许通过下面的类图便清楚个中奥秘。 [ boost中shared_ptr与weak_ptr类图 ] 我们重点关注shared_ptr<T>的类图，它就是我们可以直接操作的类，这里面包含裸指针T，还有一个shared_count的对象，而shared_count对象还不是最终的引用计数，它只是包含了一个指向sp_counted_base的指针，这应该就是真正存放引用计数的地方，包括强应用计数和弱引用计数，而且shared_count中包含的是sp_counted_base的指针，不是对象，这也就意味着假如shared_ptr<T> a = b，那么a和b底层pi_指针指向的是同一个sp_counted_base对象，这就很容易做到多个shared_ptr的引用计数永远保持一致了。 多线程安全 本章所说的线程安全有两种情况： 多个线程操作多个不同的shared_ptr对象 C++11中声明了shared_ptr的计数操作具有原子性，不管是赋值导致计数增加还是释放导致计数减少，都是原子性的，这个可以参考sp_counted_base的源码，因此，基于这个特性，假如有多个shared_ptr共同管理一个裸指针，那么多个线程分别通过不同的shared_ptr进行操作是线程安全的。 多个线程操作同一个shared_ptr对象 同样的道理，既然C++11只负责sp_counted_base的原子性，那么shared_ptr本身就没有保证线程安全了，加入两个线程同时访问同一个shared_ptr对象，一个进行释放（reset），另一个读取裸指针的值，那么最后的结果就不确定了，很有可能发生野指针访问crash。 作者：腾讯技术工程 https://mp.weixin.qq.com/s?__biz=MjM5ODYwMjI2MA==&mid=2649743462&idx=1&sn=c9d94ddc25449c6a0052dc48392a33c2&utm_source=tuicool&utm_medium=referralmp.weixin.qq.com 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_31467557/article/details/113049179。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

... 这段代码展示了如何创建一个增量作业，用于定期更新目标目录中的数据。通过这种方式，可以有效避免一次性加载过多数据带来的性能瓶颈。 --- 四、总结与展望 与Sqoop共舞 总的来说，尽管Sqoop在某些场景下表现得不尽人意，但它依然是一个强大的工具。通过不断学习和实践，我相信自己能够更加熟练地驾驭它。未来的计划里，我特别想试试一些更酷的功能，比如说用Sqoop直接搞出Avro文件，或者把Spark整进来做分布式计算，感觉会超级带劲！ 最后，我想说的是，技术这条路从来都不是一帆风顺的。遇到困难并不可怕，可怕的是我们因此放弃努力。正如那句话所说：“失败乃成功之母。”只要保持好奇心和求知欲，总有一天我们会找到属于自己的答案。 如果你也有类似的经历，欢迎随时交流！我们一起进步，一起成长！ --- 希望这篇文章对你有所帮助，如果有任何疑问或者想要了解更多细节，请随时告诉我哦！

...key不存在的时候才创建”，这样就能避免重复创建；另一个是EX，给这个锁加了个过期时间，相当于设了个倒计时，万一客户端挂了或者出问题了，锁也能自动释放，就不会一直卡在那里变成死锁啦。最后，解锁的时候我们用了Lua脚本，这样可以保证操作的原子性。 --- 4. 如何解决锁的隔离性问题？ 诶，说到这里，问题来了——如果两个不同的业务逻辑都需要用到同一个锁怎么办？比如订单系统和积分系统都想操作同一个用户的数据，这时候就需要考虑锁的隔离性了。换句话说，我们需要确保不同业务逻辑之间的锁不会互相干扰。 示例代码 2：基于命名空间的隔离策略 python def acquire_namespace_lock(redis_client, namespace, lock_name, timeout=10): 构造带命名空间的锁名称 lock_key = f"{namespace}:{lock_name}" result = redis_client.set(lock_key, "locked", nx=True, ex=timeout) return bool(result) def release_namespace_lock(redis_client, namespace, lock_name): lock_key = f"{namespace}:{lock_name}" script = """ if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("del", KEYS[1]) else return 0 end """ redis_client.eval(script, keys=[lock_key], args=["locked"]) 在这个版本中，我们在锁的名字前面加上了命名空间前缀，比如orders:place_order和points:update_score。这样一来，不同业务逻辑就可以使用独立的锁，避免相互影响。 --- 5. 进阶 如何处理锁竞争与性能优化？ 当然啦，现实中的分布式锁并不会总是那么顺利，有时候会出现大量请求同时争抢同一个锁的情况。这时我们可能需要引入队列机制或者批量处理的方式来降低系统的压力。 示例代码 3：使用Redis的List模拟队列 python def enqueue_request(redis_client, queue_key, request_data): redis_client.rpush(queue_key, request_data) def dequeue_request(redis_client, queue_key): return redis_client.lpop(queue_key) def process_queue(redis_client, lock_key, queue_key): while True: 先尝试获取锁 if not acquire_lock(redis_client, lock_key): time.sleep(0.1) 等待一段时间再重试 continue 获取队列中的第一个请求并处理 request = dequeue_request(redis_client, queue_key) if request: handle_request(request) 释放锁 release_lock(redis_client, lock_key) 这段代码展示了如何利用Redis的List结构来管理请求队列。想象一下，好多用户一起抢同一个东西，场面肯定乱哄哄的对吧？这时候，咱们就让他们老老实实排成一队，然后派一个专门的小哥挨个儿去处理他们的请求。这样一来，大家就不会互相“打架”了，事情也能更顺利地办妥。 --- 6. 总结与反思 兄弟们，通过今天的讨论，我相信大家都对如何在Redis中实现分布式锁有了更深刻的理解了吧？虽然Redis本身已经足够强大，但我们仍然需要根据实际需求对其进行适当的扩展和优化。比如刚才提到的命名空间隔离、队列机制等，这些都是非常实用的小技巧。 不过呢，我也希望大家能记住一点——技术永远不是一成不变的。业务越做越大，技术也日新月异的，咱们得不停地充电，学点新鲜玩意儿，试试新招数才行啊！就像今天的分布式锁一样，也许明天就会有更高效、更优雅的解决方案出现。所以，保持好奇心，勇于探索未知领域，这才是程序员最大的乐趣所在！ 好了，今天就聊到这里啦，祝大家在编程的路上越走越远！如果有任何疑问或者想法，欢迎随时找我交流哦~

...下载目录，【会自动创建文件夹】'TS_PATH':'F:/ceshi/download/',缓存文件目录，【会自动创建文件夹】'DB_URL':'localhost',数据库地址'DB_NAME':'douyu',数据库名称''DB_TABLE':'douyu'数据库表}MongoDB初始化client = pymongo.MongoClient(config['DB_URL'])mango_db = client[config['DB_NAME']]MongoDB存储def save_to_mango(result):if mango_db[config['DB_TABLE']].insert_one({'vid':result}):print('成功存储到MangoDB')return Truereturn FalseMongoDB验证重复def check_to_mongo(vid):count = mango_db[config['DB_TABLE']].find({'vid':vid}).count()if count==0:return Falsereturn True删除文件def del_file(page):if os.path.exists(page): 删除文件，可使用以下两种方法。os.remove(page) os.unlink(my_file)else:print('no such file:%s' % page)循环列表删除文件def loop_del_file(arr):for item in arr:del_file(item)请求器def get_content_requests(url):headers = {}headers['user-agent']='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.131 Safari/537.36'headers['cookie'] = 'dy_did=07f83a57d1d2e22942e0883200001501; acf_did=07f83a57d1d2e22942e0883200001501; Hm_lvt_e99aee90ec1b2106afe7ec3b199020a7=1556514266,1557050422,1557208315; acf_auth=; acf_auth_wl=; acf_uid=; acf_nickname=; acf_username=; acf_own_room=; acf_groupid=; acf_notification=; acf_phonestatus=; _dys_lastPageCode=page_video,page_video; Hm_lpvt_e99aee90ec1b2106afe7ec3b199020a7=1557209469; _dys_refer_action_code=click_author_video_cate2'try:req_content = requests.get(url,headers = headers)if req_content.status_code == 200:return req_contentprint('请求失败：',url)return Noneexcept:print('请求失败：', url)return None把时间换算成秒def str_to_int(time):try:time_array = time.split(':')time_int = (int(time_array[0])60)+int(time_array[1])return time_intexcept:print('~~~~~计算视频时间失败~~~~~')return None提取需要采集的数据def get_list(html,type = 1):data = []try:list_json = json.loads(str(html))for om in list_json['data']['list']:gtime = str_to_int(om['video_str_duration'])if gtime > config['TIME_START'] and gtime < config['TIME_ENT']:if type == 2:data.append({'title': om['title'], 'vid': om['url'].split('show/')[1]})else:data.append({'title': om['title'], 'vid': om['hash_id']})return dataexcept:print('~~~~~数据提取失败~~~~~')return None解析playlist.m3u8def get_ts_list(m3u8):data = []try:html_m3u8_json = json.loads(m3u8)m3u8_text = get_content_requests(html_m3u8_json['data']['video_url'])m3u8_vurl =html_m3u8_json['data']['video_url'].split('playlist.m3u8?')[0]if m3u8_text:get_text = re.findall(',\n(.?).ts(.?)\n',m3u8_text.text,re.S)for item in get_text:data.append(m3u8_vurl+item[0]+'.ts'+item[1])return datareturn Noneexcept:print('~~~~~解析playlist.m3u8失败~~~~~')return None 杀死moviepy产生的特定进程def killProcess(): 处理python程序在运行中出现的异常和错误try: pids方法查看系统全部进程pids = psutil.pids()for pid in pids: Process方法查看单个进程p = psutil.Process(pid) print('pid-%s,pname-%s' % (pid, p.name())) 进程名if p.name() == 'ffmpeg-win64-v4.1.exe': 关闭任务 /f是强制执行，/im对应程序名cmd = 'taskkill /f /im ffmpeg-win64-v4.1.exe 2>nul 1>null' python调用Shell脚本执行cmd命令os.system(cmd)except:pass下载.ts文件def download_ts(m3u8_list,name):try:if not os.path.exists(config['FILE_PATH']):os.makedirs(config['FILE_PATH'])if not os.path.exists(config['TS_PATH']):os.makedirs(config['TS_PATH'])if os.path.exists(config['FILE_PATH']+name+'.mp4'):name = name+'_'+str(int(time.time()))print('开始下载：',name)L = []R = []for p in m3u8_list:ts_find = get_content_requests(p)file_ts = '{0}{1}.ts'.format(config['TS_PATH'],md5(ts_find.content).hexdigest())with open(file_ts,'wb') as f:f.write(ts_find.content)R.append(file_ts)hebing = VideoFileClip(file_ts)L.append(hebing)killProcess()print('下载完成：',file_ts)mp4file = '{0}{1}.mp4'.format(config['FILE_PATH'],name)final_clip = concatenate_videoclips(L)final_clip.to_videofile(mp4file, fps=24, remove_temp=True)killProcess()loop_del_file(R)print('\n下载完成：',name)print('')return Trueexcept:print('~~~~~合成.ts文件失败~~~~~')return None下载视频列表def list_get_kong(list_json):for item in list_json:y = Trueif config['CHECKID']:if check_to_mongo(item['vid']):print('~~~~~检测到重复项~~~~~')y = Falseif y:get_show_html = get_content_requests('https://vmobile.douyu.com/video/getInfo?vid=' + item['vid'])if get_show_html:m3u8_list = get_ts_list(get_show_html.text)if m3u8_list:download = download_ts(m3u8_list, item['title'])if download: save_to_mango(item['vid'])time.sleep(config['TIME_GE'])控制器def main(page):if config['TYPE']==1:print('~~~~~按用户ID采集~~~~~')listurl = 'https://v.douyu.com/video/author/getAuthorVideoListByNew?up_id={0}&cate2_id=0&limit=30&page={1}'.format(config['UID'],page)get_list_html = get_content_requests(listurl)if get_list_html:list_json = get_list(get_list_html.text,1)if list_json:list_get_kong(list_json)else:print('~~~~~按列表ID采集~~~~~')listurl = 'https://v.douyu.com/video/video/listData?page={1}&cate2Id={0}&action=new'.format(config['CID'],page)get_list_html = get_content_requests(listurl)if get_list_html:list_json = get_list(get_list_html.text,2)if list_json:list_get_kong(list_json)初始化if __name__=='__main__':if config['POOL']:groups = [x for x in range(config['PAGE_START'],config['PAGE_END']+1)]pool = Pool()pool.map(main, groups)else:for item in range(config['PAGE_START'],config['PAGE_END']+1):main(item)print('~~~~~已经完成【所有操作】~~~~~') 总结：众所周知，BiliBili是一个学习的网站！ 本篇文章为转载内容。原文链接：https://blog.csdn.net/qq_35875470/article/details/89857445。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...nd 重构 4.7 创建响应式对象 4.8 Vue2 响应式原理 Proxy 、Relect、响应式 1. 监听对象的操作 需求：有一个对象，我们希望监听这个对象中的属性被设置或获取的过程 可以通过属性描述符中的存储属性描述符来做到 这段代码就利用了 Object.defineProperty 的存储属性描述符来对属性的操作进行监听 const obj = {name: 'why',age: 18}Object.keys(obj).forEach((key) => {let value = obj[key]Object.defineProperty(obj, key, {get: function () {console.log(监听到obj对象的${key}属性被访问了)return value},set: function (newValue) {console.log(监听到obj对象的${key}属性被设置值)value = newValue} })})obj.name = 'kobe'obj.age = 30console.log(obj.name)console.log(obj.age)/ 监听到obj对象的name属性被设置值监听到obj对象的age属性被设置值监听到obj对象的name属性被访问了kobe监听到obj对象的age属性被访问了30/ 属性描述符监听对象的缺点： 首先，Object.defineProperty 设计的初衷，不是为了去监听截止一个对象中所有的属性的 我们在定义某些属性的时候，初衷其实是定义普通的属性，但是后面我们强行将它变成了数据属性描述符 其次，如果我们想监听更加丰富的操作，比如新增属性、删除属性，那么 Object.defineProperty 是无能为力的 所以我们要知道，存储数据描述符设计的初衷并不是为了去监听一个完整的对象 Ps: 原来的对象是 数据属性描述符，通过 Object.defineProperty 变成了 访问属性描述符 2. Proxy基本使用 在ES6中，新增了一个Proxy类，这个类从名字就可以看出来，是用于帮助我们创建一个代理的： 也就是说，如果我们希望监听一个对象的相关操作，那么我们可以先创建一个代理对象（Proxy对象） 之后对该对象的所有操作，都通过代理对象来完成，代理对象可以监听我们想要对原对象进行哪些操作 将上面的案例用 Proxy 来实现一次： 首先，我们需要 new Proxy 对象，并且传入需要侦听的对象以及一个处理对象，可以称之为 handler； const p = new Proxy(target, handler) 其次，我们之后的操作都是直接对 Proxy 的操作，而不是原有的对象，因为我们需要在 handler 里面进行侦听 const obj = {name: 'why',age: 18}const objProxy = new Proxy(obj, {// 获取值时的捕获器get: function (target, key) {console.log(监听到obj对象的${key}属性被访问了)return target[key]},// 设置值时的捕获器set: function (target, key, newValue) {console.log(监听到obj对象的${key}属性被设置值)target[key] = newValue} })console.log(objProxy.name)console.log(objProxy.age)objProxy.name = 'kobe'objProxy.age = 30console.log(obj.name)console.log(obj.age)/ 监听到obj对象的name属性被访问了why监听到obj对象的age属性被访问了18监听到obj对象的name属性被设置值监听到obj对象的age属性被设置值kobe30/ 2.1 Proxy 的 set 和 get 捕获器 如果我们想要侦听某些具体的操作，那么就可以在 handler 中添加对应的捕捉器（Trap） set 和 get 分别对应的是函数类型 set 函数有四个参数： target：目标对象（侦听的对象） property：将被设置的属性 key value：新属性值 receiver：调用的代理对象 get 函数有三个参数 target：目标对象（侦听的对象） property：被获取的属性 key receiver：调用的代理对象 2.2 Proxy 所有捕获器 (13个) handler.getPrototypeOf() Object.getPrototypeOf 方法的捕捉器 handler.setPrototypeOf() Object.setPrototypeOf 方法的捕捉器 handler.isExtensible() Object.isExtensible 方法的捕捉器 handler.preventExtensions() Object.preventExtensions 方法的捕捉器 handler.getOwnPropertyDescriptor() Object.getOwnPropertyDescriptor 方法的捕捉器 handler.defineProperty() Object.defineProperty 方法的捕捉器 handler.ownKeys() Object.getOwnPropertyNames 方法和 Object.getOwnPropertySymbols 方法的捕捉器 handler.has() in 操作符的捕捉器 handler.get() 属性读取操作的捕捉器 handler.set() 属性设置操作的捕捉器 handler.deleteProperty() delete 操作符的捕捉器 handler.apply() 函数调用操作的捕捉器 handler.construct() new 操作符的捕捉器 const obj = {name: 'why',age: 18}const objProxy = new Proxy(obj, {// 获取值时的捕获器get: function (target, key) {console.log(监听到obj对象的${key}属性被访问了)return target[key]},// 设置值时的捕获器set: function (target, key, newValue) {console.log(监听到obj对象的${key}属性被设置值)target[key] = newValue},// 监听 in 的捕获器has: function (target, key) {console.log(监听到obj对象的${key}属性的in操作)return key in target},// 监听 delete 的捕获器deleteProperty: function (target, key) {console.log(监听到obj对象的${key}属性的delete操作)delete target[key]} })// in 操作符console.log('name' in objProxy)// delete 操作delete objProxy.name/ 监听到obj对象的name属性的in操作true监听到obj对象的name属性的delete操作/ 2.3 Proxy 的 construct 和 apply 到捕捉器中还有 construct 和 apply，它们是应用于函数对象的 function foo() {console.log('调用了 foo')}const fooProxy = new Proxy(foo, {apply: function (target, thisArg, argArray) {console.log(对 foo 函数进行了 apply 调用)target.apply(thisArg, argArray)},construct: function (target, argArray, newTarget) {console.log(对 foo 函数进行了 new 调用)return new target(...argArray)} })fooProxy.apply({}, ['abc', 'cba'])new fooProxy('abc', 'cba')/ 对 foo 函数进行了 apply 调用调用了 foo对 foo 函数进行了 new 调用调用了 foo/ 3. Reflect 3.1 Reflect 的作用 Reflect 也是 ES6 新增的一个 API，它是一个对象，字面的意思是反射 Reflect 的作用： 它主要提供了很多操作 JavaScript 对象的方法，有点像 Object 中操作对象的方法 比如 Reflect.getPrototypeOf(target) 类似于 Object.getPrototypeOf() 比如 Reflect.defineProperty(target, propertyKey, attributes) 类似于 Object.defineProperty() 如果我们有 Object 可以做这些操作，那么为什么还需要有Reflect这样的新增对象呢？ 这是因为在早期的 ECMA 规范中没有考虑到这种对 对象本身 的操作如何设计会更加规范，所以将这些 API 放到了 Object上面 但是 Object 作为一个构造函数，这些操作实际上放到它身上并不合适 另外还包含一些类似于 in、delete 操作符，让 JS 看起来是会有一些奇怪的 所以在 ES6 中新增了 Reflect，让我们这些操作都集中到了 Reflect 对象上 那么 Object 和 Reflect 对象之间的 API 关系，可以参考 MDN 文档： 比较 Reflect 和 Object 方法 3.2 Reflect 的常见方法 Reflect中有哪些常见的方法呢？它和Proxy是一一对应的，也是13个 Reflect.getPrototypeOf(target) 类似于 Object.getPrototypeOf() Reflect.setPrototypeOf(target, prototype) 设置对象原型的函数. 返回一个 Boolean， 如果更新成功，则返回 true Reflect.isExtensible(target) 类似于 Object.isExtensible() Reflect.preventExtensions(target) 类似于 Object.preventExtensions() , 返回一个 Boolean Reflect.getOwnPropertyDescriptor(target, propertyKey) 类似于 Object.getOwnPropertyDescriptor() , 如果对象中存在该属性，则返回对应的属性描述符, 否则返回 undefined Reflect.defineProperty(target, propertyKey, attributes) 和 Object.defineProperty() 类似, 如果设置成功就会返回 true Reflect.ownKeys(target) 返回一个包含所有自身属性（不包含继承属性）的数组 （类似于 Object.keys(), 但不会受 enumerable 影响） Reflect.has(target, propertyKey) 判断一个对象是否存在某个属性，和 in 运算符 的功能完全相同 Reflect.get(target, propertyKey[, receiver]) 获取对象身上某个属性的值，类似于 target[name] Reflect.set(target, propertyKey, value[, receiver]) 将值分配给属性的函数，返回一个 Boolean，如果更新成功，则返回 true Reflect.deleteProperty(target, propertyKey) 作为函数的 delete 操作符，相当于执行 delete target[name] Reflect.apply(target, thisArgument, argumentsList) 对一个函数进行调用操作，同时可以传入一个数组作为调用参数。和 Function.prototype.apply() 功能类似 Reflect.construct(target, argumentsList[, newTarget]) 对构造函数进行 new 操作，相当于执行 new target(...args) 3.3 Reflect 的使用 那么我们可以将之前Proxy案例中对原对象的操作，都修改为Reflect来操作 const obj = {name: 'why',age: 18}const objProxy = new Proxy(obj, {get: function (target, key) {console.log(监听到obj对象的${key}属性被访问了)return Reflect.get(target, key)// return target[key] // 对原来对象进行了直接操作},set: function (target, key, newValue) {console.log(监听到obj对象的${key}属性被设置值)Reflect.set(target, key, newValue)// target[key] = newValue // 对原来对象进行了直接操作} })objProxy.name = 'kobe'console.log(objProxy.name)/ 监听到obj对象的name属性被设置值监听到obj对象的name属性被访问了kobe/ 3.4 Receiver的作用 我们发现在使用getter、setter的时候有一个receiver的参数，它的作用是什么呢？ 如果我们的源对象（obj）有 setter 、getter 的访问器属性，那么可以通过 receiver 来改变里面的 this const obj = {_name: 'why',get name() {return this._name // 不使用receiver, _name属性的操作不会被objProxy代理，因为this指向obj},set name(newValue) {this._name = newValue} }const objProxy = new Proxy(obj, {get: function (target, key, receiver) {// receiver 是创建出来的代理对象console.log('get 方法被访问-------', key, receiver)console.log(objProxy === receiver) // truereturn Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)} })objProxy.name = 'kobe'console.log(objProxy.name) // kobe/ get 方法被访问------- name { _name: 'kobe', name: [Getter/Setter] }trueget 方法被访问------- _name { _name: 'kobe', name: [Getter/Setter] }truekobe/ 3.5 Reflect 的 construct function Student(name, age) {this.name = namethis.age = age}function Teacher() {}const stu = new Student('why', 18)console.log(stu)console.log(stu.__proto__ === Student.prototype)/ Student { name: 'why', age: 18 }true/// 执行 Student 函数中的内容，但是创建出来的对象是 Teacher 对象const teacher = Reflect.construct(Student, ['why', 18], Teacher)console.log(teacher)console.log(teacher.__proto__ === Teacher.prototype)/ Teacher { name: 'why', age: 18 }true/ 4. 响应式 4.1 什么是响应式？ 先来看一下响应式意味着什么？我们来看一段代码： m 有一个初始化的值，有一段代码使用了这个值； 那么在 m 有一个新的值时，这段代码可以自动重新执行 let m = 0// 一段代码console.log(m)console.log(m 2)console.log(m 2)m = 200 上面的这样一种可以自动响应数据变量的代码机制，我们就称之为是响应式的 对象的响应式 4.2 响应式函数设计 首先，执行的代码中可能不止一行代码，所以我们可以将这些代码放到一个函数中： 那么问题就变成了，当数据发生变化时，自动去执行某一个函数； 但是有一个问题：在开发中是有很多的函数的，如何区分一个函数需要响应式，还是不需要响应式呢？ 很明显，下面的函数中 foo 需要在 obj 的 name 发生变化时，重新执行，做出相应； bar 函数是一个完全独立于 obj 的函数，它不需要执行任何响应式的操作； // 对象的响应式const obj = {name: 'why',age: 18}function foo() {const newName = obj.nameconsole.log('你好啊，李银河')console.log('Hello World')console.log(obj.name)}function bar() {console.log('普通的其他函数')console.log('这个函数不需要有任何的响应式')}obj.name = 'kobe' // name 发生改变时候 foo 函数执行 响应式函数的实现 watchFn 如何区分响应式函数？ 这个时候我们封装一个新的函数 watchFn 凡是传入到 watchFn 的函数，就是需要响应式的 其他默认定义的函数都是不需要响应式的 / 封装一个响应式的函数 /let reactiveFns = []function watchFn(fn) {reactiveFns.push(fn)}// 对象的响应式const obj = {name: 'why',age: 18}watchFn(function foo() {const newName = obj.nameconsole.log('你好啊，李银河')console.log('Hello World')console.log(obj.name)})watchFn(function demo() {console.log(obj.name, 'demo function ---------')})function bar() {console.log('普通的其他函数')console.log('这个函数不需要有任何的响应式')}obj.name = 'kobe' // name 发生改变时候 foo 函数执行reactiveFns.forEach((fn) => {fn()}) 4.3 响应式依赖的收集 目前收集的依赖是放到一个数组中来保存的，但是这里会存在数据管理的问题： 在实际开发中需要监听很多对象的响应式 这些对象需要监听的不只是一个属性，它们很多属性的变化，都会有对应的响应式函数 不可能在全局维护一大堆的数组来保存这些响应函数 所以要设计一个类，这个类用于管理某一个对象的某一个属性的所有响应式函数： 相当于替代了原来的简单 reactiveFns 的数组； class Depend {constructor() {this.reactiveFns = []}addDepend(reactiveFn) {this.reactiveFns.push(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }const depend = new Depend()function watchFn(fn) {depend.addDepend(fn)}// 对象的响应式const obj = {name: 'why', // depend 对象age: 18 // depend 对象}watchFn(function foo() {const newName = obj.nameconsole.log('你好啊，李银河')console.log('Hello World')console.log(obj.name)})watchFn(function demo() {console.log(obj.name, 'demo function ---------')})function bar() {console.log('普通的其他函数')console.log('这个函数不需要有任何的响应式')}obj.name = 'kobe'depend.notify() 4.4 监听对象的变化 那么接下来就可以通过之前的方式来监听对象的变化： 方式一：通过 Object.defineProperty 的方式（vue2采用的方式）； 方式二：通过 new Proxy 的方式（vue3采用的方式）； 我们这里先以Proxy的方式来监听 class Depend {constructor() {this.reactiveFns = []}addDepend(reactiveFn) {this.reactiveFns.push(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }const depend = new Depend()function watchFn(fn) {depend.addDepend(fn)}// 对象的响应式const obj = {name: 'why', // depend 对象age: 18 // depend 对象}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)depend.notify()} })watchFn(function foo() {const newName = objProxy.nameconsole.log('你好啊，李银河')console.log('Hello World')console.log(objProxy.name)})watchFn(function demo() {console.log(objProxy.name, 'demo function ---------')})objProxy.name = 'kobe'objProxy.name = 'james'/ 你好啊，李银河Hello Worldkobekobe demo function ---------你好啊，李银河Hello Worldjamesjames demo function ---------/ 4.5 对象的依赖管理 目前是创建了一个 Depend 对象，用来管理对于 name 变化需要监听的响应函数： 但是实际开发中我们会有不同的对象，另外会有不同的属性需要管理； 如何可以使用一种数据结构来管理不同对象的不同依赖关系呢？ 在前面我们刚刚学习过 WeakMap，并且在学习 WeakMap 的时候我讲到了后面通过 WeakMap 如何管理这种响应式的数据依赖： 实现 可以写一个 getDepend 函数专门来管理这种依赖关系 / 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取mapconst map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象const depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} }) 正确的依赖收集 我们之前收集依赖的地方是在 watchFn 中： 但是这种收集依赖的方式我们根本不知道是哪一个 key 的哪一个 depend 需要收集依赖； 只能针对一个单独的 depend 对象来添加你的依赖对象； 那么正确的应该是在哪里收集呢？应该在我们调用了 Proxy 的 get 捕获器时 因为如果一个函数中使用了某个对象的 key，那么它应该被收集依赖 / 封装一个响应式函数 /let activeReactviceFn = nullfunction watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {// 根据 target key 获取对应的 depnedconst depend = getDepend(target, key)// 给 depend 对象中添加响应式函数activeReactviceFn && depend.addDepend(activeReactviceFn)return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} }) 4.6 对 Depend 重构 两个问题： 问题一：如果函数中有用到两次 key，比如 name，那么这个函数会被收集两次 问题二：我们并不希望将添加 reactiveFn 放到 get 中，因为它是属于 Depend 的行为 所以我们需要对 Depend 类进行重构： 解决问题一的方法：不使用数组，而是使用 Set 解决问题二的方法：添加一个新的方法，用于收集依赖 // 保存当前需要收集的响应式函数let activeReactviceFn = nullclass Depend {constructor() {this.reactiveFns = new Set()}depend() {if (activeReactviceFn) {this.reactiveFns.add(activeReactviceFn)} }addDepend(reactiveFn) {this.reactiveFns.add(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }// 对象的响应式const obj = {name: 'why', // depend 对象age: 18 // depend 对象}/ 封装一个响应式函数 /function watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)const objProxy = new Proxy(obj, {get: function (target, key, receiver) {// 根据 target key 获取对应的 depnedconst depend = getDepend(target, key)// 给 depend 对象中添加响应式函数depend.depend()return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} })watchFn(function () {console.log(objProxy.name, '--------------')console.log(objProxy.name, '++++++++++++++')})objProxy.name = 'kobe'/ why --------------why ++++++++++++++kobe --------------kobe ++++++++++++++/ 4.7 创建响应式对象 目前的响应式是针对于obj一个对象的，我们可以创建出来一个函数，针对所有的对象都可以变成响应式对象 / 保存当前需要收集的响应式函数 /let activeReactviceFn = null/ 依赖收集类 /class Depend {constructor() {this.reactiveFns = new Set()}depend() {if (activeReactviceFn) {this.reactiveFns.add(activeReactviceFn)} }addDepend(reactiveFn) {this.reactiveFns.add(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }/ 封装一个响应式函数 /function watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}/ 创建响应式对象函数 /function reactive(obj) {// 监听对象的属性变化：Proxy(vue3)/Object.defineProperty(vue2)return new Proxy(obj, {get: function (target, key, receiver) {// 根据 target key 获取对应的 depnedconst depend = getDepend(target, key)// 给 depend 对象中添加响应式函数depend.depend()return Reflect.get(target, key, receiver)},set: function (target, key, newValue, receiver) {Reflect.set(target, key, newValue, receiver)const depend = getDepend(target, key)depend.notify()} })}const info = reactive({address: '广州市',height: 1.88})watchFn(() => {console.log(info.address, '---')})info.address = '北京市' 4.8 Vue2 响应式原理 前面所实现的响应式的代码，其实就是 Vue3 中的响应式原理： Vue3 主要是通过 Proxy 来监听数据的变化以及收集相关的依赖的 Vue2 中通过 Object.defineProerty的方式来实现对象属性的监听 可以将 reactive 函数进行如下的重构： 在传入对象时，我们可以遍历所有的 key，并且通过属性存储描述符来监听属性的获取和修改 在 setter 和 getter 方法中的逻辑和前面的 Proxy 是一致的 / 保存当前需要收集的响应式函数 /let activeReactviceFn = null/ 依赖收集类 /class Depend {constructor() {this.reactiveFns = new Set()}depend() {if (activeReactviceFn) {this.reactiveFns.add(activeReactviceFn)} }addDepend(reactiveFn) {this.reactiveFns.add(reactiveFn)}notify() {this.reactiveFns.forEach((fn) => {fn()})} }/ 封装一个响应式函数 /function watchFn(fn) {activeReactviceFn = fnfn()activeReactviceFn = null}/ 封装一个获取depend的函数 /const taregtMap = new WeakMap()function getDepend(target, key) {// 根据target对象获取maplet map = taregtMap.get(target)if (!map) {map = new Map()taregtMap.set(target, map)}// 根据key获取depend对象let depend = map.get(key)if (!depend) {depend = new Depend()map.set(key, depend)}return depend}/ 创建响应式对象函数 /function reactive(obj) {Object.keys(obj).forEach((key) => {let value = obj[key]Object.defineProperty(obj, key, {get: function () {const dep = getDepend(obj, key)dep.depend()return value},set: function (newValue) {value = newValueconst dep = getDepend(obj, key)dep.notify()} })})return obj}const info = reactive({address: '广州市',height: 1.88})watchFn(() => {console.log(info.address, '---')})info.address = '北京市' 本篇文章为转载内容。原文链接：https://blog.csdn.net/wanghuan1020/article/details/126774033。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。