直接上代码 参数 filename 输出的文件名 tabletitle 表标题 remark 备注 bodytitle 表头 格式如： ["学生学号", "学生名字", "课程名称", "课程编号", "考试类型", '考试名字', "考试时间", "是否补考", "成绩得分"] datalist 表格数据 格式二维数组如： [ ["学号1234", "张三", "语文", "course001", 期末考试, 2018年语文期末考试, 2018-12-12, 否,100], ["学号1235", "李四", "语文", "course001", 期末考试, 2018年语文期末考试, 2018-12-12, 否,88], ["学号1236", "王五", "语文", "course001", 期末考试, 2018年语文期末考试, 2018-12-12, 否,99] ] from flask import Flask, session,request,jsonify,make_response import hashlib,xlwt,os,xlrd from urllib.parse import quote from io import StringIO,BytesIO # 导出表格 def write_excel(filename,tabletitle,remark,bodytitle,datalist): # 设置字体 font = xlwt.

文章目录 一、问题二、出错原因三、解决方法1、修改数据库的默认编码2、重启mysql服务3、删掉原来的数据库，重新执行sql 一、问题 执行下面的mysql语句时报错 -- 创建数据库 create database book; use book; -- 创建读者信息表 create table reader( card_id char(18) primary key, name varchar(20) not null, sex enum('男','女','保密') default'保密', age tinyint not null, phone_number char(11) not null, balance decimal(6,2) default 200 ); 这个错误是说，字段sex的默认值是无效的 二、出错原因 出错原因是因为数据库的编码不对，数据库默认编码是latin1，我们需要设置为utf8。 三、解决方法 以下是具体的步骤 1、修改数据库的默认编码 1、找到mysql中的my.ini配置文件,打开 2、将这两个变量的值都修改为utf8，保存 default-character-set=utf8 character-set-server=utf8 2、重启mysql服务 Windows下不能直接重启(restart)，只能先停止，再启动 cmd窗口输入这两条命令，mysql服务就重启成功了 net stop mysql5 net start mysql5 3、删掉原来的数据库，重新执行sql -- 删除数据库 drop database book; -- 创建数据库 create database book; use book; -- 创建读者信息表 create table reader( card_id char(18) primary key, name varchar(20) not null, sex enum('男','女','保密') default'保密', age tinyint not null, phone_number char(11) not null, balance decimal(6,2) default 200 ); 建表没有报错了

一、工具 fio:测试Linux磁盘IO性能； tpcc-mysql:只针对mysql的测试工具，很权威； dbt2：比较全面会统计出系统的资源情况，可以对postgresql，mysql等数据库压测； sysbench：不仅压测数据库，还可以压测系统的资源，传统只针对单个表的压测，tpcc 只是固定模型，并不符合实业务逻辑，所以可以使用sysbench指定定制压测； 二、基准测试 只读测试：sysbench（点、范围、统计、排序、唯一等查询）； TPC-C测试：tpcc-mysql、DBT2(调整数据库性能参数、用户压力、实力配置)； 读写比自定义测试：sysbench（定义读写比例、读写类型比例）； 三、定制测试 定制sql模型（业务逻辑sql） 定制开发工具（sysbench上lua脚本定制） 流量加速回放（录制sql，备库压力回放，测试瓶颈） 全链路测试（通过业务层模拟，成本较高，不影响线上业务） 四、性能评估 TPS QPS RT 稳定性 CPU IO 内存 网络

一、get请求 对于取数据，我们使用最多的应该就是get请求了吧。下面通过几个示例看看我们的get请求参数传递。 回到顶部 1、基础类型参数 [HttpGet] public string GetAllChargingData(int id, string name) { return "ChargingData" + id; } $.ajax({ type: "get", url: "http://localhost:27221/api/Charging/GetAllChargingData", data: { id: 1, name: "Jim", bir: "1988-09-11"}, success: function (data, status) { if (status == "success") { $("#div_test").html(data); } } }); 参数截图效果 2、实体作为参数 如果我们在get请求时想将实体对象做参数直接传递到后台，是否可行呢？我们来看看。 public class TB_CHARGING { /// <summary> /// 主键Id /// </summary> public string ID { get; set; } /// <summary> /// 充电设备名称 /// </summary> public string NAME { get; set; } /// <summary> /// 充电设备描述 /// </summary> public string DES { get; set; } /// <summary> /// 创建时间 /// </summary> public DateTime CREATETIME { get; set; } } [HttpGet] public string GetByModel(TB_CHARGING oData) { return "

上一课我们在win10系统+VS2017开发环境下搭建了WDK驱动程序开发环境的搭建，详见我的博客【如何在win10+VS2017环境下安装USB驱动开发套件WDK】，今天我们来尝试建立一个最简单的KDM示例工程。 提前说明：本博客所建立的示例工程的源码，我上传在了CSDN里【https://download.csdn.net/download/leon1741/10957680】，大家可以自行去下载。不过遗憾的是，现在CSDN资源的下载积分规则改了，不能由上传者来设置该资源的下载积分，而是由系统自动适配的。因此，这个资源的下载积分目前需要5分，有点多，我其实想设置成免费或者最多1分的，可是系统不让我改。希望各位的积分值够用，或者希望系统过段时间自动把下载积分值降下来吧… 第一步：新建工程 记得要选择WDF模型下的空KMD驱动项目，项目名我输的是KMD_Test，大家可以自己更改。 第二步、输入代码 在源代码文件夹上右击，选择新建一个空白文件。 输入文件名为Drive.c。请注意，不是Drive.cpp，而是Drive.c！ 在文件中输入以下内容： #include <ntddk.h> #include <wdf.h> DRIVER_INITIALIZE DriverEntry; EVT_WDF_DRIVER_DEVICE_ADD KmdfHelloWorldEvtDeviceAdd; NTSTATUS DriverEntry( _In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath ) { // NTSTATUS variable to record success or failure NTSTATUS status = STATUS_SUCCESS; // Allocate the driver configuration object WDF_DRIVER_CONFIG config; // Print "Hello World" for DriverEntry KdPrintEx((DPFLTR_IHVDRIVER_ID, DPFLTR_INFO_LEVEL, "KmdfHelloWorld: DriverEntry\n")); // Initialize the driver configuration object to register the // entry point for the EvtDeviceAdd callback, KmdfHelloWorldEvtDeviceAdd WDF_DRIVER_CONFIG_INIT(&config, KmdfHelloWorldEvtDeviceAdd ); // Finally, create the driver object status = WdfDriverCreate(DriverObject, RegistryPath, WDF_NO_OBJECT_ATTRIBUTES, &config, WDF_NO_HANDLE ); return status; } NTSTATUS KmdfHelloWorldEvtDeviceAdd( _In_ WDFDRIVER Driver, _Inout_ PWDFDEVICE_INIT DeviceInit ) { // We're not using the driver object, // so we need to mark it as unreferenced UNREFERENCED_PARAMETER(Driver); NTSTATUS status; // Allocate the device object WDFDEVICE hDevice; // Print "

linux下C++实现Http请求类(GET，POST，上传，下载) Http协议简述 协议：网络协议的简称，网络协议是通信计算机双方必须共同遵从的一组约定。如怎么样建立连接、怎么样互相识别等。只有遵守这个约定，计算机之间才能相互通信交流，就好比两台计算机交互的语言. HTTP协议：超文本传输协议（HyperText Transfer Protocol)是互联网上应用最为广泛的一种网络协议。主要被用于在Web浏览器和网站服务器之间传递信息。 HTTP 是基于 TCP/IP 协议的应用层协议。默认使用80端口。最新版本是HTTP 2.0，目前是用最广泛的是HTTP 1.1。 HTTP协议工作于客户端-服务端架构为上。浏览器作为HTTP客户端通过URL向HTTP服务端即WEB服务器发送所有请求。Web服务器根据接收到的请求后，向客户端发送响应信息。 请求方法： HTTP/1.1协议中共定义了八种方法（有时也叫“动作”）来表明Request-URI指定的资源的不同操作方式： OPTIONS - 返回服务器针对特定资源所支持的HTTP请求方法。也可以利用向Web服务器发送’*'的请求来测试服务器的功能性。 HEAD- 向服务器索要与GET请求相一致的响应，只不过响应体将不会被返回。这一方法可以在不必传输整个响应内容的情况下，就可以获取包含在响应消息头中的元信息。该方法常用于测试超链接的有效性，是否可以访问，以及最近是否更新。 GET - 向特定的资源发出请求。注意：GET方法不应当被用于产生“副作用”的操作中，例如在web app.中。其中一个原因是GET可能会被网络蜘蛛等随意访问。 POST - 向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST请求可能会导致新的资源的建立和/或已有资源的修改。 PUT - 向指定资源位置上传其最新内容。 DELETE - 请求服务器删除Request-URI所标识的资源。 TRACE- 回显服务器收到的请求，主要用于测试或诊断。 CONNECT - HTTP/1.1协议中预留给能够将连接改为管道方式的代理服务器。 PATCH - 用来将局部修改应用于某一资源，添加于规范RFC5789。 方法名称是区分大小写的。当某个请求所针对的资源不支持对应的请求方法的时候，服务器应当返回状态码405（Method Not Allowed）；当服务器不认识或者不支持对应的请求方法的时候，应当返回状态码501（Not Implemented）。 HTTP服务器至少应该实现GET和HEAD方法，其他方法都是可选的。此外，除了上述方法，特定的HTTP服务器还能够扩展自定义的方法。 GET和POST请求的区别 GET请求 GET /books/?sex=man&name=Professional HTTP/1.1 Host: www.wrox.com User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.7.6) Gecko/20050225 Firefox/1.0.1 Connection: Keep-Alive 注意最后有一行空行 POST请求 POST / HTTP/1.

@font-face { font-family: 'ZCOOL Addict Italic 01'; src: url(data:font/truetype;charset=utf-8;base64,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) format('truetype'); font-weight: normal; font-style: italic; } .jkl { font-family: 'ZCOOL Addict Italic 01'; } 找字网（http://www.zhaozi.cn/） base64转码：（http://transfonter.org） css07 转载于:https://www.cnblogs.com/lgyong/p/9537291.html

RPC： 即 Remote Procedure Call（远程过程调用），是一个计算机通信协议。该协议允许运行于一台计算机的程序调用另一台计算机的子程序，而程序员无需额外地为这个交互作用编程。说得通俗一点就是：A计算机提供一个服务，B计算机可以像调用本地服务那样调用A计算机的服务。 类似的还有RMI(Remote Method Invocation)远程方法调用，早期的webservice，现在热门的dubbo，以及阿里的hsf都是RPC的典型 通过上面的概念，我们可以知道，实现RPC主要是做到两点： - 实现远程调用其他计算机的服务 - 要实现远程调用，肯定是通过网络传输数据。A程序提供服务，B程序通过网络将请求参数传递给A，A本地执行后得到结果，再将结果返回给B程序。这里需要关注的有两点：1- 现在比较流行的RPC框架，都会采用TCP作为底层传输协议，2- 两个程序进行通讯，必须约定好数据传输格式。定义好请求和响应的格式。另外，数据在网路中传输需要进行序列化，所以还需要约定统一的序列化的方式。 - 像调用本地服务一样调用远程服务 - 如果仅仅是远程调用，还不算是RPC，因为RPC强调的是过程调用，调用的过程对用户而言是应该是透明的，用户不应该关心调用的细节，可以像调用本地服务一样调用远程服务。所以RPC一定要对调用的过程进行封装。 Http协议：超文本传输协议，是一种应用层协议。规定了网络传输的请求格式、响应格式、资源定位和操作的方式等。但是底层采用什么网络传输协议，并没有规定，不过现在都是采用TCP协议作为底层传输协议。 区别：说到这里，大家可能觉得，Http与RPC的远程调用非常像，都是按照某种规定好的数据格式进行网络通信，有请求，有响应。没错，在这点来看，两者非常相似，但是还是有一些细微差别。 - RPC并没有规定数据传输格式，这个格式可以任意指定，不同的RPC协议，数据格式不一定相同。 - Http中还定义了资源定位的路径，RPC中并不需要 - 最重要的一点：RPC需要满足像调用本地服务一样调用远程服务，也就是对调用过程在API层面进行封装。Http协议没有这样的要求，因此请求、响应等细节需要我们自己去实现。 - 优点：RPC方式更加透明，对用户更方便。Http方式更灵活，没有规定API和语言，跨语言、跨平台 - 缺点：RPC方式需要在API层面进行封装，限制了开发的语言环境。 例如我们通过浏览器访问网站，就是通过Http协议。只不过浏览器把请求封装，发起请求以及接收响应，解析响应的事情都帮我们做了。如果是不通过浏览器，那么这些事情都需要自己去完成。 既然两种方式都可以实现远程调用，我们该如何选择呢？ - 速度来看，RPC要比http更快，虽然底层都是TCP，但是http协议的信息往往比较臃肿，不过可以采用gzip压缩。 - 难度来看，RPC实现较为复杂，http相对比较简单 - 灵活性来看，http更胜一筹，因为它不关心实现细节，跨平台、跨语言。 因此，两者都有不同的使用场景： - 如果对效率要求更高，并且开发过程使用统一的技术栈，那么用RPC还是不错的。 - 如果需要更加灵活，跨语言、跨平台，显然http更合适 微服务，更加强调的是独立、自治、灵活。而RPC方式的限制较多，因此微服务框架中，一般都会采用基于Http的Rest风格服务，像在公司对内系统用hsf协议，对接外部系统用微服务，调用RestTemplate这个类

select中要不要使用 * 除了极少数情况下，绝大多数情况下，使用 * 是一种糟糕的编程习惯！ 分析如下： 1、如果采用 select * 进行查找时，查询到的列是按照它们在表的原始位置展示的；如果客户端同样采用列的原始位置进行引用，如果更改表结构，会导致难以察觉的错误； 2、使用 * 时，数据库会先查数据字典，明确 * 代表什么，这会在分析阶段造成大量开销； 3、select * 最大的问题是可能会多出一些不用的列，导致无法使用索引覆盖，导致查询成本几何层级的增加 4、不需要的字段会增加数据传输的时间，如果是本地客户端，连接的事本地的mysql服务器，tcp协议传输数据会增加额外时间；如果是db和客户端不在同一台机器，比如连接到阿里云，则开销会更加明显 5、如果查询的时候获取了不必要的列，字段较多时，mysql并非一次性保存，而是主次分布内存，当时用完后，再次分配。如此会导致多次分配，频繁分配会增加额外消耗时间 6、如果sql语句复杂，select * 会解析更多的对象，字段，权限，属性等内容，增加数据库负担

Linux 命令行输入命令执行后报“bash:vi:command not found”，这是由于系统 PATH 设置问题，PATH没有设置正确，系统就无法找到精确命令了。 解决办法： 1、在命令行中输入：export PATH=/usr/bin:/usr/sbin:/bin:/sbin:/usr/X11R6/bin 这样可以保证命令行命令暂时可以使用。命令执行完之后不要关闭终端，继续下一步； 2、在命令行中输入 vi ~/.bash_profile 进入到环境变量中； 3、仔细检查自己配置的 PATH 属性是否有错误，（可能是字母错误或者标点符号错误），改正后 :wq 报错退出。 4、执行 source ~/.bash_profile 使配置生效即可。 博主案例： 我在Linux中配置 JDK，配置完成后用 java -version 检查是否配置成功时，报了 bash: vi: command not found... 错误，通过以上 4 步解决方法找到了配置问题，我的问题如下图所示： 改正后 JDK 配置代码如下： JAVA_HOME=/root/training/jdk1.8.0_144 export JAVA_HOME PATH=$JAVA_HOME/bin:$PATH export PATH 检查配置如下图所示： 原文：https://blog.csdn.net/qq_40087415/article/details/79397503 

JDBC（Java Data Base Connectivity） JDBC（Java Data Base Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，是用Java语言编写的类和接口组成的，可以为多种关系型数据库提供统一访问的接口。 步骤： 1、加载驱动和注册数据库信息。 2、打开Connection,获取PreparedStatement对象。 3、通过PreparedStatement执行SQL，返回结果到ResultSet对象。 4、使用ResultSet读取数据，然后通过代码转换为具体的POJO对象。 5、关闭数据库相关资源。 ORM框架 对象关系映射（Object Relational Mapping），类对应数据库的表，属性对应表中的列，对象对应表中的每一条数据，是为了解决面向对象与面向关系型数据库存在的互不匹配的现象的技术。 Spring Data JPA 是Spring Data 在JPA（Java持久层规范）和ORM（对象关系映射）框架之间抽象封装层，它不直接代替ORM框架，默认低层使用的ORM框架是Hibernate，但使用它可以灵活的在各种ORM框架之间切换，并且减少ORM框架接入部分重复代码，进而简化代码。 Hibernate和Mybatis的比较： MyBatis是一个持久层框架的，但它设计初衷与Hibernate等全自动、符合JPA规范的ORM框架不同，重点关注关系到对象的（R->O），而后者不仅是关系到对象的映射，还有对象到关系的映射（O->R），设计上希望通过面向对象的方式写SQL，可以更好的屏蔽不同数据库之间的差异，抽象程度更高。而前者MyBatis需要自己手动写SQL，更灵活，但受限于开发编写SQL代码水平，可能会出现不兼容不同数据库SQL的情况。

Git的报错 在使用Git的过程中有时会出现一些问题，那么在解决了每个问题的时候，都需要去总结记录下来，下次不再犯。 一、fatal: refusing to merge unrelated histories 今天在使用Git创建项目的时候，在两个分支合并的时候，出现了下面的这个错误。 ~/SpringSpace/newframe on  master ⌚ 11:35:56 $ git merge origin/druid fatal: refusing to merge unrelated histories 123 这里的问题的关键在于：fatal: refusing to merge unrelated histories 你可能会在git pull或者git push中都有可能会遇到，这是因为两个分支没有取得关系。那么怎么解决呢？ 二、解决方案 在你操作命令后面加--allow-unrelated-histories 例如： git merge master --allow-unrelated-histories ~/SpringSpace/newframe on  druid ⌚ 11:36:49 $ git merge master --allow-unrelated-histories Auto-merging .gitignore CONFLICT (add/add): Merge conflict in .gitignore Automatic merge failed; fix conflicts and then commit the result.

SqlServer 2008 r2 中设置只给其它用户访问自己指定表或视图… 在操作使用数据库的大部分时候，我们可能对权限之类的东西设置的很少，但是在某些对安全性有要求的时候，我们则需要限制某个用户访问数据库的权限，比如让某个用户只能看到属于其管理或只需要用到的某几张表，并对指定的表拥有有限的操作权限。* 图文向导设置步骤 1、以管理员身份登录数据库，新建一个新的登录用户。 2、将该用户需要访问的表或视图所在的数据库映射给该用户，使其能够访问该数据库(此时还没有给任何表、视图的访问权限其)。 3、以管理员身份给其他用户分配指定的表、视图或存储过程的操作权限。 4、分配完访问和操作的权限之后，使用新建的用户名进行登录之后，即可对管理员指定的数据库中的表或视图进行权限内的操作。 至此已经完成，我们可以该用户能访问的只有我们分配的数据库中的视图(或者表、存储过程)。自己动手试试吧。 代码实现步骤 1、以管理员用户身份登录并打开需要操作的数据库，新建查询，创建一个可访问指定数据库的权限角色 exec sp_addrole [ceshi1] 2、给创建的角色赋予查看指定的视图的权限，视图名为：dbo._UserBaseInfo，角色名为创建的角色 ceshi1 grant select on dbo._UserBaseInfo to ceshi1 3、添加只允许访问指定视图的用户;，用户名：ceshi1a 密码：1qaz!QAZ 默认的数据库：DT_HIS exec sp_addlogin 'ceshi1a','1qaz!QAZ','DT_HIS' 4、将用户和角色进行绑定(即给用户赋予访问指定视图的权限) ， ‘用户’，‘密码’，‘角色’ exec sp_adduser 'ceshi1a','1qaz!QAZ','ceshi1' 5、最后使用新创建的用户名、密码登录，可以看到该用户下面只有一个可访问和操作的视图。自己动手试试吧。 exec sp_addrole ceshi1 grant select on dbo._UserBaseInfo to ceshi1 exec sp_addlogin 'ceshi1a','1qaz!QAZ','DT_HIS' exec sp_adduser 'ceshi1a','1qaz!QAZ','ceshi1'

导读：借鉴同行业发展模式更好的发展，是每个行业一直以来的创新方式之一，在OTT电视直播点播服务领域也是如此。不可否认在很多方面美国的OTT服务还是有很多值得国内借鉴的。点量小编带您一起详细了解美国四大OTT电视直播点播服务： 近年来，越来越多的美国人取消了付费电视订阅(有线或卫星)，转而投入互联网视频的怀抱。为应对互联网的冲击，一些传统运营商也推出了基于互联网的节目频道包月服务。这类OTT电视直播服务将少量频道打包，以较低的价格推出，常常被称为“精简版”(Skinny)电视套餐。 其中，主流的几项服务分别为卫星电视运营商Dish Network的Sling TV，索尼的PlayStation Vue，电信巨头AT&T的DirecTV Now以及YouTube新近推出的YouTube TV。 这些服务既包含电视直播，又提供视频点播，某些情况下还兼具云录像机(DVR)功能，所能提供的功能远超有线电视。那么，这些服务究竟如何？各有些什么优势和特色呢？美国Digital Trends网站从频道、设备、功能、画质等方面对上述四项服务进行了一次详细测评。 频 道 PS Vue的套餐名目繁多，其服务所能提供的频道取决于用户所处的地区，不包含当地电视频道的套餐为“Slim”版。在附加频道上，PS Vue并没有提供太多选择，大多数附加频道均已包含在Elite和Ultra两档套餐内了。 Sling TV提供两类套餐，分别是橙色版(20美元/月)和蓝色版(25美元/月)。与Vue在基础版上增加频道的方式不同，Sling的两个套餐内容差异较大。Sling提供了许多不同价格的附加频道，包括ABC，MTV或者HBO等。此外，Sling TV新增了一些地方性的体育频道，这对于那些因为本地体育节目而舍不得放弃有线电视的观众很有吸引力。 DiercTV Now的套餐更为直观，共四档，每个都是上一档的加强版。在DirecTV Now上订阅HBO和Showtime频道只需5美元，这比Sling和Vue便宜很多。 YouTube TV是这些服务中最新的一个，其基础套餐为35美元/月，包含44个频道，这比Sling和PS Vue最便宜的套餐略贵一些，与DirecTV相当。然而，在所提供的频道数上，YouTube TV仅超过了Sling TV。但该服务的优势也很明显——它是唯一一个完整提供四大电视网节目的服务，也是唯一一个可提供CBS直播的服务。此外，YouTube提供的体育频道较多，这些频道在其他服务上需要订购较贵的套餐才能看到。 从所提供的频道范围和促销力度上看，DirecTV Now胜出。 支持设备 4个服务中，Sling TV支持的设备最多，YouTube TV支持的种类最少，仅有iOS和安卓设备。而PS3或PS4的用户可能会倾向于PS Vue，因为个别频道仅向PS Plus订户提供。尽管Sling TV支持的设备种类最多，但单个账号可同时串流的节目数量较少。橙色版套餐不支持单个账号同时观看多个节目，蓝色套餐也仅支持同时串流3个节目，相比之下，PS Vue最多可同时支持5个节目在不同设备上在线播放。 从所支持设备种类和互通性上看，Sling TV胜出。 功 能 PS Vue功能最多，其用户体验更具灵活性。与Netflix和Hulu一样，PS Vue可管理用户节目单，提供个性化推荐。此外，Vue可以提供有线盒子镜像，支持所有频道的快进/回放，还具备云DVR功能。相比之下，Sling TV仅提供简单的节目单，只能对指定节目暂停/快进/回放。最近，Sling新增了针对亚马逊Prime会员的DVR服务。YouTube TV可提供最灵活的DVR功能，用户可在录制节目后储存9个月。DirecTV Now现在缺少DVR功能，可暂停/快进/回放的内容也很有限。 在功能性上，PS Vue胜出。 画 质 所有服务的视频质量都符合基本要求，但与有线、卫星和Netflix、亚马逊等流媒体服务相比略逊一筹。用户有时无法获取高清画质，而为了减少贷款消耗，内容常常被严重压缩。 没有一个服务在画质上特别出众，各服务打成平手。 总 结 PS Vue能提供更好的用户体验和DVR等额外功能，对PS游戏主机用户而言更有吸引力。 DirecTV Now拥有诱人的促销策略和众多频道，对于新用户或者要求频道数量接近有线电视的用户更有吸引力。 Sling TV更通用、性价比更高，并且能提供有一定侧重性的频道套餐，支持的设备种类更多。 最后，新推出的YouTube TV是四个服务中最为简单易懂的：只有一个套餐、一个价位和少量的附加频道。该服务是唯一一个囊括美国四大电视网的服务，拥有最多的体育内容，DVR存储时间也相当长。然而，其所能支持的设备较少，频道总数也较少，因此在通用性上较差。 转载出处： https://news.znds.com/article/21070.html

I帧: 帧内编码帧是一种自带全部信息的独立帧，无需参考其它图像便可独立进行解码，视频序列中的第一个帧始终都是I帧。 IDR帧（Instantaneous Decoding Refresh -- 即时解码刷新） I和IDR帧都是使用帧内预测的。它们都是同一个东西而已,在编码和解码中为了方便，要首个I帧和其他I帧区别开，所以才把第一个首个I帧叫IDR，这样就方便控制编码和解码流程。 IDR帧的作用是立刻刷新,使错误不致传播,从IDR帧开始,重新算一个新的序列开始编码。而I帧不具有随机访问的能力，这个功能是由IDR承担。 IDR会导致DPB（DecodedPictureBuffer 参考帧列表——这是关键所在）清空，而I不会。IDR图像一定是I图像，但I图像不一定是IDR图像。一个序列中可以有很多的I图像，I图像之后的图像可以引用I图像之间的图像做运动参考。一个序列中可以有很多的I图像，I图像之后的图象可以引用I图像之间的图像做运动参考。 对于IDR帧来说，在IDR帧之后的所有帧都不能引用任何IDR帧之前的帧的内容，与此相反，对于普通的I-帧来说，位于其之后的B-和P-帧可以引用位于普通I-帧之前的I-帧。从随机存取的视频流中，播放器永远可以从一个IDR帧播放，因为在它之后没有任何帧引用之前的帧。但是，不能在一个没有IDR帧的视频中从任意点开始播放，因为后面的帧总是会引用前面的帧 。 收到 IDR 帧时，解码器另外需要做的工作就是：把所有的 PPS 和 SPS 参数进行更新。 对IDR帧的处理(与I帧的处理相同)： (1) 进行帧内预测，决定所采用的帧内预测模式。 (2) 像素值减去预测值，得到残差。 (3) 对残差进行变换和量化。 (4) 变长编码和算术编码。 (5) 重构图像并滤波，得到的图像作为其它帧的参考帧。 多参考帧情况下， 举个例子 ：有如下帧序列： IPPPP I P PPP ……。按照 3 个参考帧编码。 因为“按照 3 个参考帧编码”，所以参考帧队列长度为 3 。 遇到绿色的 I 时，并不清空参考帧队列，把这个 I 帧加入参考帧队列（当然 I 编码时不用参考帧。）。再检测到红色的 P 帧时，用到的就是 PPI 三帧做参考了。 P帧:前向预测编码帧 在针对连续动态图像编码时，将连续若干幅图像分成P,B,I三种类型，P帧由在它前面的P帧或者I帧预测而来，它比较与它前面的P帧或者I帧之间的相同信息或数据，也即考虑运动的特性进行帧间压缩。P帧法是根据本帧与相邻的前一帧（I帧或P帧）的不同点来压缩本帧数据。采取P帧和I帧联合压缩的方法可达到更高的压缩且无明显的压缩痕迹。 P帧的预测与重构:P帧是以I帧为参考帧，在I帧中找出P帧“某点”预测值和运动矢量，取预测差值和运动矢量一起传送。在接收端根据运动矢量从I帧中找出P帧“某点”的预测值并与差值相加以得到P帧某点样值，从而可得到完整的P帧。 有的视频序列比较简单，就没有B帧， B帧：双向预测内插编码帧 B帧的预测与重构 B帧法是双向预测的帧间压缩算法。当把一帧压缩成B帧时，它根据相邻的前一帧、本帧以及后一帧数据的不同点来压缩本帧，也即仅记录本帧与前后帧的差值。只有采用B帧压缩才能达到200：1的高压缩。 B帧是以前面的I或P帧和后面的P帧为参考帧，找出B帧“某点”的预测值和两个运动矢量，并取预测差值和运动矢量传送。接收端根据运动矢量在两个参考帧中。 --------------------- 原文：https://blog.csdn.net/sphone89/article/details/8086071 

function make_order_sn() { return date('YmdH') . substr(mt_rand(1000000, 999999999), 0, 4) . substr(mt_rand(1000000, 999999999), 0, 6); }

1：在码云新建仓库 2：右键项目文件夹，使用Git Base Here 打开项目 3：git init命令初始化本地仓库 4：关联码云仓库地址，箭头位置是码云仓库赋值的地址 5：把代码提交本地仓库 6：把代码推送到本地仓库 7：上传至码云 此时会出现windows验证对话框输入码云用户名密码，即可上传成功

1、mybatisPlus_eq 实现类似 <if test="a!=null"> AND a = #{a} </if> Wrapper wrapper= Condition.create().eq(VerifyUtil.isNNull(sysOffice.getParentId()),"PARENT_ID",sysOffice.getParentId()); VerifyUtil.isNNull(sysOffice.getParentId()),"PARENT_ID",sysOffice.getParentId()); 2、like like(boolean condition, String column, String value) like(String column, String value) like(boolean condition, String column, String value, SqlLike type) like(String column, String value, SqlLike type) condition 是一些条件，符合才可加上你的sql column 为 数据库属性 value 为 你传入的值 type 为 % 拼在那边： SqlLike 为枚举类 LEFT("left", "左边%"), RIGHT("right", "右边%"), CUSTOM("custom", "定制"), DEFAULT("default", "两边%");

本文参考自：https://jingyan.baidu.com/article/046a7b3efd165bf9c27fa915.html （1）打开命令窗口，输入命令 lsb_release -a 查看当前Linux系统版本 （2）根据你的Linux版本，输入对应的如下命令，我这里是centos系统，故而输入 yum -y install vim* ubuntu 系统输入命令：sudo apt-get install vim-gtkcentos 系统输入命令：yum -y install vim* （3）输入后等待完成，即可自动完成安装。

ASPP： Atrous Spatial Pyramid Pooling deeplabv2中的aspp如上图所示，在特征顶部映射图使用了四中不同采样率的空洞卷积。这表明以不同尺度采样时有效的，在Deeolabv3中向ASPP中添加了BN层。不同采样率的空洞卷积可以有效捕获多尺度信息，但会发现随着采样率的增加，滤波器有效权重（权重有效的应用在特征区域，而不是填充0）逐渐变小。如下图 当我们以不同采样率的3*3卷积核应用在65*65的特征映射上，当采样率接近特征映射大小时，3*3滤波器不是捕获全图像上下文，而是退化为简单的1*1滤波器，只有滤波器中心起作用。 为了克服这个问题，我们考虑使用图片级特征。具体来说，我们在模型最后的特征映射上应用全局平均，将结果经过1x1的卷积，再双线性上采样得到所需的空间维度。最终我们改进的ASPP包括： 1.一个1x1卷积和三个3x3的采样率为rates={6,12,18}的空洞卷积，滤波器数量为256，包含BN层。针对output_stride=16的情况。如下图(a)部分Atrous Spatial Pyramid Pooling 2.图像级特征，即将特征做全局平均池化，经过卷积再融合。如下图(b)部分Image Pooling 也就是说当output_stride=8时，加倍了采样率。所有特征通过1x1级联到一起，生成最终的分数。代码(pytorch)为： class ASPP(nn.Module): def __init__(self, in_channel=512, depth=256): super(ASPP,self).__init__() # global average pooling : init nn.AdaptiveAvgPool2d ;also forward torch.mean(,,keep_dim=True) self.mean = nn.AdaptiveAvgPool2d((1, 1)) self.conv = nn.Conv2d(in_channel, depth, 1, 1) # k=1 s=1 no pad self.atrous_block1 = nn.Conv2d(in_channel, depth, 1, 1) self.atrous_block6 = nn.Conv2d(in_channel, depth, 3, 1, padding=6, dilation=6) self.atrous_block12 = nn.Conv2d(in_channel, depth, 3, 1, padding=12, dilation=12) self.

由于本人能力暂时有限，以下有些解决方法是自己亲身试过有效但无法解释原因，如果有大佬愿意解答自然是感激不尽，开始正文： 1、Tex文件和Bib文件尽量不要使用中文命名 2、将\bibliographystyle放在\bibliography后面 这个是参考文献出问题时用的方法，不知道为什么，我从官网上下的模板就是\bibliograhy在前，所以一直没怀疑过，偶然换了后，文献就能够正常排版了 3、下载老版本的WinEdt用不了时，可以尝试将电脑的时间改成2005年（不懂为什么），当然建议不要用老版本，真的不好用 待续…… 2019/2/11

参考网址：https://www.linuxidc.com/Linux/2017-05/143590.htm Ubuntu 环境下： 第一步：新增站点配置文件** 1，打开连接服务器的软件xftp 中，连接上服务器，然后在 /etc/apache2/sites-available 目录中新建站点的配置文件 ***.conf （自己命名）例如：www-linuxidc-com.conf 2，在控制台输入cmd 进入控制台后，输入连接服务器的用户名和密码： 例如： 用户名：ssh root@47.75.99.185 密码： ******* 3， #进入虚拟主机配置文件夹 cd /etc/apache2/sites-available/ 4， #复制默认的虚拟主机配置文件 sudo cp 000-default.conf www-linuxidc-com.conf, 5，编辑这两个配置文件，以 www-linuxidc-com.conf 为例 <VirtualHost *:8080> ServerAdmin 1054840542@qq.com ServerName www.linuxidc.com DocumentRoot /home/www/linuxidc ​ <Directory "/home/www/linuxidc"> Options FollowSymLinks AllowOverride All #Require all denied Require all granted </Directory> ​ ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined ​ </VirtualHost> ​ 注意上面配置中：ServerName（域名）、DocumentRoot（根目录） 和 VirtualHost （端口号） 是我们重点关注的配置点。linuxidc 的 ServerName 为www.linuxidc.com，根目录为 /home/www/linuxidc，Directory 同 DocumentRoot。

CDN的全称是Content Delivery Network，即内容分发网络。CDN是构建在网络之上的内容分发网络，依靠部署在各地的边缘服务器，通过中心平台的负载均衡、内容分发、调度等功能模块，使用户就近获取所需内容，降低网络拥塞，提高用户访问响应速度和命中率。CDN的关键技术主要有内容存储和分发技术。——百度百科 放在Github的资源在国内加载速度比较慢，因此需要使用CDN加速来优化网站打开速度，jsDelivr + Github便是免费且好用的CDN，非常适合博客网站使用。 1、新建Github仓库 2、克隆Github仓库到本地 点击 Clone or download，一键复制仓库地址 在本地目录右键 Git Bash Here，执行以下命令： git clone 一键复制的仓库地址 3、上传资源 复制需要上传的资源到本地git仓库（注：jsDelivr不支持加载超过20M的资源），在本地git仓库目录下右键 Git Bash Here，执行以下命令： git status //查看状态 git add . //添加所有文件到暂存区 git commit -m '第一次提交' //把文件提交到仓库 git push //推送至远程仓库 4、发布仓库 点击release发布 自定义发布版本号 5、通过jsDelivr引用资源 使用方法：https://cdn.jsdelivr.net/gh/你的用户名/你的仓库名@发布的版本号/文件路径 例如： https://cdn.jsdelivr.net/gh/TRHX/CDN-for-itrhx.com@1.0/images/trhx.pnghttps://cdn.jsdelivr.net/gh/TRHX/CDN-for-itrhx.com@2.0.1/css/style.csshttps://cdn.jsdelivr.net/gh/moezx/cdn@3.1.3//The%20Pet%20Girl%20of%20Sakurasou.mp4 注意：版本号不是必需的，是为了区分新旧资源，如果不使用版本号，将会直接引用最新资源，除此之外还可以使用某个范围内的版本，查看所有资源等，具体使用方法如下： // 加载任何Github发布、提交或分支 https://cdn.jsdelivr.net/gh/user/repo@version/file // 加载 jQuery v3.2.1 https://cdn.jsdelivr.net/gh/jquery/jquery@3.2.1/dist/jquery.min.js // 使用版本范围而不是特定版本 https://cdn.jsdelivr.net/gh/jquery/jquery@3.2/dist/jquery.min.js https://cdn.jsdelivr.net/gh/jquery/jquery@3/dist/jquery.min.js // 完全省略该版本以获取最新版本 https://cdn.jsdelivr.net/gh/jquery/jquery/dist/jquery.min.js // 将“.min”添加到任何JS/CSS文件中以获取缩小版本，如果不存在，将为会自动生成 https://cdn.jsdelivr.net/gh/jquery/jquery@3.2.1/src/core.min.js // 在末尾添加 / 以获取资源目录列表

UIKit的springs为观看动画提供了更多的润色和美感。 Apple自己将弹簧用于大量系统动画以及自己的应用程序。 springs通常负责您在屏幕上看到的任何弹跳视图，但是在摆弄springs动画参数时，您会看到此API允许您创建各种令人愉悦的动画。 到目前为止，您的动画一直是单向流动。 当您为视图的位置设置动画时，它是从A点到B点的直接移动，如下所示： 在本章中，您将学习如何创建更复杂的动画，这些动画可以移动视图 仿佛它们附着在弹簧上，如下所示： 如果您将基本动画从A点移动到B点并为其添加了一点弹性，则动画的运动将遵循下面红色箭头指示的路径： 视图从A点到B点，但是B点过量。 然后视图返回到B点，这次稍微超过一点。 这种来回振荡重复，直到视点在B点停止。 这是一个很好的效果; 它为您的动画增添了一种活泼，真实的感觉。 本章将向您展示如何使用此效果为您的UI添加一些趣味性。 Spring动画 你将继续上一章的项目; 如果你没有完成第1章中的练习（包括本章末尾的挑战），那么从第2章的Resources文件夹中获取入门项目并从那里开始。 构建并运行您的项目; 应用程序打开后，您应该立即看到屏幕上的视图（“登录”按钮除外）动画： 打开ViewController.swift并将以下代码添加到viewWillAppear（）的底部： loginButton.center.y += 30.0 loginButton.alpha = 0.0 正如您在上一章中所做的那样，您可以在y轴上将按钮的起始位置设置得稍低，并将其alpha值设置为零，这样它就会以不可见的方式开始。 现在转到viewDidAppear（）并添加以下代码： UIView.animate(withDuration: 0.5, delay: 0.5, usingSpringWithDamping: 0.5, initialSpringVelocity: 0.0, options: [], animations: { self.loginButton.center.y -= 30.0 self.loginButton.alpha = 1.0 }, completion: nil) 这段代码中有两个关键点 首先，您同时为两个不同的属性设置了动画！ 这比你想象的容易，对吧？ 其次，你第一次使用了一种新的动画方法： animate（withDuration：delay：usingSpringWithDamping：initialSpringVelocity：optio ns：animations：completion : )。 说方法名称太快只会伤害你的舌头！ 上面的方法看起来很像你在上一章中使用的方法 书，但它有几个新的参数： usingSpringWithDamping：它控制在动画接近最终状态时应用于动画的阻尼或减少量。 此参数接受介于0.0和1.0之间的值。 接近0.0的值创建一个更有弹性的动画，而接近1.0的值创建一个看起来很僵硬的效果。 您可以将此值视为弹簧的“刚度”。initialSpringVelocity：它控制动画的初始速度。 值1.0设置动画的初始速度以覆盖跨度为一秒的总距离。 较大和较小的值将导致动画具有或多或少的速度，并将影响弹簧的稳定方式。 但请注意，初始速度很快就会通过弹簧计算进行修改，并且动画将始终在持续时间结束时完成。 构建并运行您的项目; 看看按钮现在如何移动：

PyCharm在Linux系统是绿色版打包的，而且的Linux系统中，绿色版是没有像Windows那样可以直接双击程序文件打开程序，多数情况下，需要手动添加到系统启动菜单。 1.每次打开程序都需要通过终端的话，那样太麻烦了，可以通过添加一个快捷启动方式，像Windows系统那样，双击图标打开程序 首先，在桌面创建一个文件：pycharm.desktop 2.编辑这个文件，添加以下内容（Exec是sh文件位置，icon是图标文件位置）： [Desktop Entry] Version=1.0 Type=Application Name=Pycharm Icon=/home/user/Downloads/pycharm-2018.3.3/bin/pycharm.png Exec=/home/user/Downloads/pycharm-2018.3.3/bin/pycharm.sh MimeType=application/x-py; Name[en_US]=pycharm 3.保持好上面的内容之后，右击这个文件，点击属性，把允许作为程序运行给选择上 现在pycharm就可以用图标方式来打开了

2019独角兽企业重金招聘Python工程师标准>>> 一、引言 默认情况下如果网站请求速度慢，所以会有一段时间的空白页面等等，用户体验效果不好，见到很多的页面都有预加载的效果，加载之前先加载一个动画，后台进程继续加载页面内容，当页面内容加载完之后再退出动画显示内容，这样的用户体验更好。 例如此链接：http://crusader12.com/C12HoverAlls/ 二、使用步骤 1.首先定义一个loader.css .chromeframe { margin: 0.2em 0; background: #ccc; color: #000; padding: 0.2em 0;} #loader-wrapper { position: fixed; top: 0; left: 0; width: 100%; height: 100%; z-index:999999;} #loader { display: block; position: relative; left: 50%; top: 50%; width: 150px; height: 150px; margin: -75px 0 0 -75px; border-radius: 50%; border: 3px solid transparent; /* COLOR 1 */ border-top-color: #FFF; -webkit-animation: spin 2s linear infinite; /* Chrome, Opera 15+, Safari 5+ */ -ms-animation: spin 2s linear infinite; /* Chrome, Opera 15+, Safari 5+ */ -moz-animation: spin 2s linear infinite; /* Chrome, Opera 15+, Safari 5+ */ -o-animation: spin 2s linear infinite; /* Chrome, Opera 15+, Safari 5+ */ animation: spin 2s linear infinite; /* Chrome, Firefox 16+, IE 10+, Opera */ z-index:1001;} #loader:before { content: "

E: 仓库 “http://ppa.launchpad.net/hzwhuang/ss-qt5/ubuntu bionic Release” 没有 Release 文件。 N: 无法安全地用该源进行更新，所以默认禁用该源。 N: 参见 apt-secure(8) 手册以了解仓库创建和用户配置方面的细节。 添加的仓库保存在 /etc/apt/sources.list.d目录下。 删除对应的错误仓库文件即可

Qt5 安装与配置 Qt5 安装与配置window下安装Qt5mac下安装Qt5Mac环境准备工作Mac Qt5 安装Mac下安装Homebrew工具Mac下安装Python3.6Mac下Pycharm集成PyQt5Mac Qt 环境变量配置linux下安装Qt5QT编译运行中的问题1. Qt Creator 里改一下 Qt Versions2. Qt Creator 创建项目报错 QT开发的应用程序打包发布qt开发的window应用打包发布发布准备1. 设置应用程序图标1.1 设置图标（window）1.2 设置图标（mac）1.3 设置图标（linux） 2. 编译release版本 打包发布程序1. 静态编译1. 1 静态编译 （window）1. 2 静态编译 （linux）1. 3 静态编译 （mac） 2. 附加Dll文件2.1 附加Dll文件(window)2.2 附加Dll文件(linux)2.3 附加Dll文件(mac) qt开发的mac应用打包发布一. 打包二. 签名三. 上传App Store qt开发的linux应用打包发布 Qt5 安装与配置 Qt安装下载：Qt官网下载 window下安装Qt5 mac下安装Qt5 Mac环境准备工作 下载Qt5.8 for mac 制作macOS系统安装U盘的命令： sudo /Applications/Install\ macOS\ Sierra.app/Contents/Resources/createinstallmedia --volume /Volumes/macOS --applicationpath /Applications/Install\ macOS\ Sierra.app --nointeraction Mac Qt5 安装 Mac下安装 Qt需先安装Xcode Qt官网

文章目录 1.安装Elasticsearch（windows）2.在idea里新建一个maven项目 本内容根据 Springboot企业级应用开发实战-柳伟卫所写 1.安装Elasticsearch（windows） 安装可以参考我的博客Elasticsearch在windows下的安装 2.在idea里新建一个maven项目 添加Elasticsearch依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-elasticsearch</artifactId> <version>2.0.0.RELEASE</version> </dependency> 修改 application.properties 或者 application.yml spring.data.elasticsearch.cluster-nodes=localhost:9300 新建文档类 EsBlog import org.springframework.data.elasticsearch.annotations.Document; import javax.persistence.Id; import java.io.Serializable; @Document(indexName = "blog", type = "blog") public class EsBlog implements Serializable { /* serialVersionUID:简称 SUID，是当对象序列化的时候对象的一个标识 作用： 1.忽略SUID,相当于运行期间类的版本上的序列化和反序列上面没有差异。 2.写一个默认的SUID,这就好像线程头部。告诉JVM所有版本中有着同样SUID的都是同一个版本。 3.复制之前版本类的SUID。运行期间这个版本和之前版本是一样的版本。 重点：4.使用类每个版本生成的SUID。如果SUID与新版本的类不同， 那么运行期间两个版本是不同的，并且老版本类序列化后的实例并不可以反序列成新的类的实例。 */ private static final long serialVersionUID = 1L; @Id private String id; //在 Elasticsearch 中，要求 id 为 String型 private String title; private String summary;//总结 private String content;//内容 protected EsBlog() { //JPA的规范：要求无参构造函数设为 protected 防止直接使用 } public EsBlog(String title, String summary, String content) { this.

http://www.codeclip.com/1329.html 本文中内容是参考以下内容整理而成: 1．学习笔记29：Volume Shadow Copy Service（VSS）如何工作 — Windows Live 2．卷影拷贝服务_百度百科 3．卷影复制服务（VSS）原理介绍|IT168 存储 4．VSS（卷影拷贝服务）与snapshot优缺点及区别 – TL的专栏 – CSDN博客 5．Volume Shadow Copy Service (Windows) 6．Volume Shadow Copy Service 快照技术原理深入讨论【存储部落】网络存储技术 8．How Volume Shadow Copy Service Works: Data Recovery 1 卷影复制服务（VSS）概念 VSS卷影拷贝服务其实不是一项新技术了，在2003年前后发布的Windows 2003和Windows XP SP1都提供了对VSS的支持。最近几年微软的一线产品对VSS支持的越来越多，包括Exchange，SQL，AD，DPM等等。在Windows 2008中甚至系统的自带的备份工具也换成了VSS版本的1。 卷影拷贝服务（Volume Shadow Copy Service，VSS）是Microsoft在Windows Server 2003中开始引入的服务，它能让用户在没有IT专业人员协助的情况下，更轻松地恢复丢失的文件。此外，VSS还提供了更灵活的备份方案。结合了良好的规划以及最新的备份和恢复技术，卷影拷贝服务将对灾难恢复计划的增强很有帮助。VSS甚至让小企业也有恢复丢失数据的能力。其实，VSS还为大企业提供比基本工具更多的恢复选项，并帮助其减少数据恢复任务中IT专业人员的数量2,4。 VSS 是一套COM API，它部署了这样的架构，让卷备份能够被执行同时系统上的应用程序继续写入卷。请求者、书写器和提供程序它们在VSS架构中通讯来创建和恢复卷影副本。一个卷的影子副本及时地复制了加载在卷上处于正常状态的所有的数据3。 2 VSS解决的问题 VSS被广泛的应用到Windows的备份处理中，除了windows自带的备份应用，还被Veritas、CA、CommVault等厂家采用4。 你可以通过使用VSS，在特定卷上建立数据拷贝时间点；并在将来的某一时刻把数据恢复到任何一个你曾创建的时间点的状态。这两个功能可以帮助客户的计算机恢复意外删除的文件，这样的工作即使一般员工也能轻松完成，并且不需要创建高效备份策略的能力2。 对于IT技术支持人员来说，最常见的请求一般是恢复人为原因造成的数据丢失。用户不经意地存储了有错误信息的文件，不小心删除文件，或是其他的数据意外，都是经常发生的2。 当用户需要重新找回数据的时候，经常需要请技术支持人员拔出备份磁带，进行人工恢复，这个工作相当浪费时间2。 VSS让管理员能够在服务器上发布共享文件夹，在一定的时间间隔内做时间点的备份（在指定时间内最多可以存在65份拷贝）。这让最终用户能够安全地处理文件并随时恢复到早前的版本，而不需要IT部门的干涉2。 3 VSS工作原理 VSS是Windows 下的快照技术，由Requestor, Writer, 和Provider组成，同时集成了COM技术。因此，它不再是单单在卷级上的block进行处理，而是和各种系统应用相关联，比如SQL，EXCHANGE，AD等等。从而使得在不关机，也不停止应用的情况下，做备份4。 完整的VSS解决方案包含以下基础部件6： VSS 服务 Windows 操作系统的一部分，用于确保其他组件能够正确地通信和协作。

Environment MacNginx 1.15.8 Process Mac 在 Mac 上，可以使用 brew 系列命令进行软件包的操作。在国内的情况下，需要先切换其镜像源。 brew install nginx Nginx 在 /usr/local/etc/nginx/nginx.conf 配置 Nginx 的全局参数。 #user www www; worker_processes 1; error_log /usr/local/var/log/nginx/error.log error; pid /usr/local/var/run/nginx.pid; events { multi_accept on;#设置是否允许,Nginx在已经得到一个新连接的通知时,接收尽可能更多的连接 worker_connections 100000; # 根据请求量，以及服务器资源配置 #use epoll; } #协议级别配置 http { include mime.types; default_type application/octet-stream; log_format main '$remote_addr $remote_user [$time_local] "$request" ' '$status $body_bytes_sent "$http_referer" ' '$http_user_agent $http_x_forwarded_for $request_time $upstream_response_time $upstream_addr $upstream_status'; #access_log logs/access.log main; # 触发条件，所有访问ip 限制每秒10个请求（防DOS攻击） limit_req_zone $binary_remote_addr zone=one:10m rate=10r/s; # sendfile 部分配置 sendfile on;#sendfile系统调用在两个文件描述符之间直接传递数据(完全在内核中操作)，从而避免了数据在内核缓冲区和用户缓冲区之间的拷贝，操作效率很高，被称之为零拷贝。 tcp_nopush on; tcp_nodelay on; #server_tokens off; # [emerg] 8232#14924: could not build server_names_hash, you should increase server_names_hash_bucket_size server_names_hash_max_size ; # server name 的字符串长度上限值，最好设置为32倍数 server_names_hash_bucket_size 64; # 客户端请求缓存处理 client_body_buffer_size 6m; client_header_buffer_size 1m; large_client_header_buffers 4 125k; # 客户端上传文件的限制 client_max_body_size 4m; keepalive_timeout 65; # gzip部分配置 #Gzip Compression gzip on; gzip_buffers 16 8k; gzip_comp_level 6; gzip_http_version 1.

概要 当redis集群的主节点故障时，Sentinel集群将从剩余的从节点中选举一个新的主节点，有以下步骤： 故障节点主观下线故障节点客观下线Sentinel集群选举LeaderSentinel Leader决定新主节点 选举过程 1、主观下线 Sentinel集群的每一个Sentinel节点会定时对redis集群的所有节点发心跳包检测节点是否正常。如果一个节点在down-after-milliseconds时间内没有回复Sentinel节点的心跳包，则该redis节点被该Sentinel节点主观下线。 2、客观下线 当节点被一个Sentinel节点记为主观下线时，并不意味着该节点肯定故障了，还需要Sentinel集群的其他Sentinel节点共同判断为主观下线才行。 该Sentinel节点会询问其他Sentinel节点，如果Sentinel集群中超过quorum数量的Sentinel节点认为该redis节点主观下线，则该redis客观下线。 如果客观下线的redis节点是从节点或者是Sentinel节点，则操作到此为止，没有后续的操作了；如果客观下线的redis节点为主节点，则开始故障转移，从从节点中选举一个节点升级为主节点。 3、Sentinel集群选举Leader 如果需要从redis集群选举一个节点为主节点，首先需要从Sentinel集群中选举一个Sentinel节点作为Leader。 每一个Sentinel节点都可以成为Leader，当一个Sentinel节点确认redis集群的主节点主观下线后，会请求其他Sentinel节点要求将自己选举为Leader。被请求的Sentinel节点如果没有同意过其他Sentinel节点的选举请求，则同意该请求(选举票数+1)，否则不同意。 如果一个Sentinel节点获得的选举票数达到Leader最低票数(quorum和Sentinel节点数/2+1的最大值)，则该Sentinel节点选举为Leader；否则重新进行选举。 4、Sentinel Leader决定新主节点 当Sentinel集群选举出Sentinel Leader后，由Sentinel Leader从redis从节点中选择一个redis节点作为主节点： 过滤故障的节点选择优先级slave-priority最大的从节点作为主节点，如不存在则继续选择复制偏移量（数据写入量的字节，记录写了多少数据。主服务器会把偏移量同步给从服务器，当主从的偏移量一致，则数据是完全同步）最大的从节点作为主节点，如不存在则继续选择runid（redis每次启动的时候生成随机的runid作为redis的标识）最小的从节点作为主节点 存在 不存在 存在 不存在 从节点列表 过滤故障节点 slave-priority最大的从节点 升级主节点 复制偏移量最大的从节点 升级主节点 runid最小的从节点升级主节点 为什么Sentinel集群至少3节点 一个Sentinel节选举成为Leader的最低票数为quorum和Sentinel节点数/2+1的最大值，如果Sentinel集群只有2个Sentinel节点，则 Sentinel节点数/2 + 1 = 2/2 + 1 = 2 即Leader最低票数至少为2，当该Sentinel集群中由一个Sentinel节点故障后，仅剩的一个Sentinel节点是永远无法成为Leader。 也可以由此公式可以推导出，Sentinel集群允许1个Sentinel节点故障则需要3个节点的集群；允许2个节点故障则需要5个节点集群。

Environment Lumen 5.5Predis 1.1Redis 5.0.3 Process 1、Redis 在设计上，也保留库这个概念，一般默认库索引为0，通过命令 “select [index]” 可以切换不同的库。在根目录文件下，配置 config/database.php 多个 Redis 库。 'redis' => [ 'client' => 'predis', 'default' => [ 'host' => env('REDIS_HOST', 'localhost'), 'password' => env('REDIS_PASSWORD', null), 'port' => env('REDIS_PORT', 6379), 'database' => 0, 'read_write_timeout' => 60, ], 'db1' => [ 'host' => env('REDIS_HOST', 'localhost'), 'password' => env('REDIS_PASSWORD', null), 'port' => env('REDIS_PORT', 6379), 'database' => 1, 'read_write_timeout' => 60, ], 'db2_usercache' => [ 'host' => env('REDIS_HOST', 'localhost'), 'password' => env('REDIS_PASSWORD', null), 'port' => env('REDIS_PORT', 6379), 'database' => 2, 'read_write_timeout' => 60, ], ], 2、在根目录文件下，配置 config/cache.

题目及测试 package pid621; /* Task Scheduler 给定一个用字符数组表示的 CPU 需要执行的任务列表。其中包含使用大写的 A - Z 字母表示的26 种不同种类的任务。任务可以以任意顺序执行，并且每个任务都可以在 1 个单位时间内执行完。CPU 在任何一个单位时间内都可以执行一个任务，或者在待命状态。 然而，两个相同种类的任务之间必须有长度为 n 的冷却时间，因此至少有连续 n 个单位时间内 CPU 在执行不同的任务，或者在待命状态。 你需要计算完成所有任务所需要的最短时间。 示例 1： 输入: tasks = ["A","A","A","B","B","B"], n = 2 输出: 8 执行顺序: A -> B -> (待命) -> A -> B -> (待命) -> A -> B. 注： 任务的总个数为 [1, 10000]。 n 的取值范围为 [0, 100]。 */ import java.util.List; public class main { public static void main(String[] args) { char [][] testTable = {{'A','A','A','B','B','B'},{'A','A','C','B','B','B'}}; int [] testTable2 = {2,1}; for(int i=0;i<testTable.

本文介绍SpringBoot使用当当Sharding-JDBC进行分库分表。 1.有关Sharding-JDBC 有关Sharding-JDBC介绍这里就不在多说，之前Sharding-JDBC是当当网自研的关系型数据库的水平扩展框架，现在已经捐献给Apache，具体可以查看Github，地址是：shardingsphere.apache.org/document/cu… shardingsphere文档地址是：shardingsphere.apache.org/document/cu…。 目前貌似还不能从Maven仓库下载依赖，需要手动下载源码打包使用，所以本文使用的还是当当网的依赖。 2.本文场景 2.1 数据库 接下来介绍一下本文的场景，本文是分别创建了2个数据库database0和database1。其中每个数据库都创建了2个数据表，goods_0和goods_1，如图所示。这里蓝色的代表database0中的表，红色的代表database1中的表。绿色goods表是虚拟表（图画的比较丑，审美不好，凑合看吧）。 2.2 分库 本文分库样例比较简单，根据数据库表中字段goods_id的大小进行判断，如果goods_id大于20则使用database0，否则使用database1。 2.3 分表 分样例比较简单，根据数据库表中字段goods_type的数值的奇偶进行判断，奇数使用goods_1表，偶数使用goods_0表。 2.4 代码流程 流程大致是这样，在应用程序中我们操作虚拟表goods，但是当真正操作数据库的时候，会根据我们的分库分表规则进行匹配然后操作。 3.代码实现 本文使用SpringBoot2.0.3，SpringData-JPA，Druid连接池，和当当的sharding-jdbc。 3.1 建表SQL 创建表和数据库的SQL如下所示。 CREATE DATABASE database0; USE database0; DROP TABLE IF EXISTS `goods_0`; CREATE TABLE `goods_0` ( `goods_id` bigint(20) NOT NULL, `goods_name` varchar(100) COLLATE utf8_bin NOT NULL, `goods_type` bigint(20) DEFAULT NULL, PRIMARY KEY (`goods_id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin; DROP TABLE IF EXISTS `goods_1`; CREATE TABLE `goods_1` ( `goods_id` bigint(20) NOT NULL, `goods_name` varchar(100) COLLATE utf8_bin NOT NULL, `goods_type` bigint(20) DEFAULT NULL, PRIMARY KEY (`goods_id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin; CREATE DATABASE database1; USE database1; DROP TABLE IF EXISTS `goods_0`; CREATE TABLE `goods_0` ( `goods_id` bigint(20) NOT NULL, `goods_name` varchar(100) COLLATE utf8_bin NOT NULL, `goods_type` bigint(20) DEFAULT NULL, PRIMARY KEY (`goods_id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin; DROP TABLE IF EXISTS `goods_1`; CREATE TABLE `goods_1` ( `goods_id` bigint(20) NOT NULL, `goods_name` varchar(100) COLLATE utf8_bin NOT NULL, `goods_type` bigint(20) DEFAULT NULL, PRIMARY KEY (`goods_id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin; 复制代码 3.

文章目录 一、项目结构二、login.html三、ServletLogin.java四、loginError.jsp五、home.html六、部署和运行1、测试用例一（用户名错误）2、测试用例二（密码错误）3、测试用例二（账号信息正确） 一、项目结构 login.html用户信息错误，进行请求转发，跳转到loginError.html。 用户信息正确，进行重定向，跳转到home.html。 二、login.html <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>用户登录</title> </head> <body> <h3>用户登录</h3> <form action="login" method="get"> <p>用户名<input type="text" name="username"></p> <p>密 码<input type="text" name="password"></p> <input type="submit" value="登录"> </form> </body> </html> 三、ServletLogin.java package net.test.servlet; import javax.servlet.ServletException; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; @WebServlet(name = "ServletLogin",urlPatterns = "/login") public class ServletLogin extends HttpServlet { protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { } protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { //用户列表 String user="

利用libwebsockets写ws、wss服务端和客户端 文章目录 利用libwebsockets写ws、wss服务端和客户端服务端：客户端官网例子坑点 服务端： server.c #include "libwebsockets.h" #include <signal.h> #include <string.h> static volatile int exit_sig = 0; #define MAX_PAYLOAD_SIZE 10 * 1024 void sighdl( int sig ) { lwsl_notice( "%d traped", sig ); exit_sig = 1; } /** * 会话上下文对象，结构根据需要自定义 */ struct session_data { int msg_count; unsigned char buf[LWS_PRE + MAX_PAYLOAD_SIZE]; int len; bool bin; bool fin; }; static int protocol_my_callback( struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len ) { struct session_data *data = (struct session_data *) user; switch ( reason ) { case LWS_CALLBACK_ESTABLISHED: // 当服务器和客户端完成握手后 printf("

1：打开终端 root@kali:~# wifite . . .´ · . . · `. wifite 2.2.5 : : : (¯) : : : automated wireless auditor `. · ` /¯\ ´ · .´ https://github.com/derv82/wifite2 ` /¯¯¯\ ´ [!] Warning: Recommended app hcxdumptool was not found. install @ https://github.com/ZerBea/hcxdumptool [!] Warning: Recommended app hcxpcaptool was not found. install @ https://github.com/ZerBea/hcxtools [!] Conflicting processes: NetworkManager (PID 506), dhclient (PID 564), wpa_supplicant (PID 1264) [!] If you have problems: kill -9 PID or re-run wifite with --kill) [+] Checking airmon-ng.

Environment : 1、PHP 7.1 2、Lumen 5.5 Process : 1、Lumen 自动加载 bootstrap/app.php ，服务容器初始化，将服务提供器注册到服务容器。 $app->register(Ixudra\Curl\CurlServiceProvider::class); 2、将这个 Ixudra\Curl 添加到静态调用。 <?php namespace Ixudra\Curl\Facades; use Illuminate\Support\Facades\Facade; class Curl extends Facade { /** * @return string */ protected static function getFacadeAccessor() { return 'Curl'; } } 3、在每次使用 Ixudra\Curl ，即实例化一个单例。这里采用单例模式，确保只返回同一个实例。 /** * @return void */ public function register() { $this->app->singleton('Curl', function () { return new CurlService(); } ); } 4、通过链式构造器，在每一次链式方法调用中，返回同一个对象引用，这样传递对象实例，逐步实现整个业务的查询构造。 /** * Set the URL to which the request is to be sent * * @param $url string The URL to which the request is to be sent * @return Builder */ public function to($url) { return $this->withCurlOption( 'URL', $url ); } /** * Set any specific cURL option * * @param string $key The name of the cURL option * @param string $value The value to which the option is to be set * @return Builder */ protected function withCurlOption($key, $value) { $this->curlOptions[ $key ] = $value; return $this; } /** * Set any specific package option * * @param string $key The name of the cURL option * @param string $value The value to which the option is to be set * @return Builder */ protected function withPackageOption($key, $value) { $this->packageOptions[ $key ] = $value; return $this; } /** * Add a HTTP header to the request * * @param string $header The HTTP header that is to be added to the request * @return Builder */ public function withHeader($header) { $this->curlOptions[ 'HTTPHEADER' ][] = $header; return $this; } 5、完成整个对象的查询构造后，结束对象的查询构造，调起整个对象的处理方法。获取到查询结果，就只返回查询结果，不再传递实例本身。

SQL语句中使用了or关键字索引会失效，在数据量较大的时候查找效率较低，因此可以使用union或union all代替。 例如： select ename, job, from t_emp where job='manager' or job='saleman'; 可以改变成： select ename, job, from t_emp where job='manager' union all select ename, job, from t_emp where job='saleman'; 使用union与union all的要求：查询字段个数一致、字段类型要一致。 union与union all的区别： union：会合并两个查询结果中相同的数据 union all：不会合并两个查询结果中的相同数据 可以使用union把左外连接的查询结果和右外连接的查询结果合并到一起实现全外连接。

转自：https://blog.csdn.net/jinchunzhao123/article/details/81239484 今天在安装jdk的时候出现了一个问题：-bash: /usr/local/src/jdk1.8.0_191/bin/java: /lib/ld-linux.so.2: bad ELF interprete。之前一直以为是自己的安装步骤不对，但是想想好像就解压， 配置路径，不应该不对呀，后面搜了一下，原来是jdk的版本不对，只要执行：sudo yum install glibc.i686 就可以解决了： 然后重新验证jdk：

KVM是liunx下的虚拟机，下面记录一下我自己的经历吧，方便自己日后忘记能快速上手。 1.首先不用多说啦，既然是虚拟机，当然要自己的机器支持虚拟技术，重启机器进入biso，把是否支持虚拟技术改成enable。 2.养成好的习惯，在linux终端安装东西的时候都要sudo apt-get update一下，然后安装KVM依赖。 sudo apt-get install qemu-kvm sudo apt-get install qemu sudo apt-get install virt-manager sudo apt-get install virt-viewer sudo apt-get install libvirt-bin sudo apt-get install bridge-utils 3.验证下，终端键入‘kvm-ok’，出现下面的界面，就说明已经装好了。 4. 终端键入“sudo virt-manager”,进入图形界面。 5.新建新的虚拟机。 6.把选好准备好的镜像。如下图，下面就是傻瓜式安装了。

Arduino(NANO) NRF24L01 应用实例 软件准备： microBox 库(https://github.com/wastel7/microBox)：构建一个微型的命令行系统 Mirf 库(https://github.com/E-elektronic/Mirf)：提供RF相关的核心功能 以上库请自行下载 硬件准备： Arduino NANO板 x 2; NRF24L01 x 2; Other; 开发环境： VS2017 + Arduino IDE(1.8.4) 硬件连接： Server、Client 与 NRF24L01模块的连接方式完全相同。接线次序：VCC:3.3V; GND:GND; CSN: 7; CE:8; MOSI:11; SCK:13; IRQ:不接; MISO:12; Client 代码(client.ino)： #include "microBox.h" #pragma region UserDefined #define DEBUG //#undef DEBUG #ifndef FIRSWOF_ADD #define FIRSWOF_ADD #endif // !FIRSWOF_ADD #ifdef FIRSWOF_ADD /* * Hardware SPI: * MISO -> 12 * MOSI -> 11 * SCK -> 13 * * Configurable: * CE -> 8 * CSN -> 7 */ #include <SPI.

一、Spring框架概述 1、 什么是Spring Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring的核心是控制反转（IoC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架。 2、 Spring的优点 1）方便解耦，简化开发 （高内聚低耦合） Spring就是一个大工厂可以将所有对象创建和依赖关系维护，交给Spring管理 spring工厂是用于生成bean。 2）AOP编程的支持 Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能 3）声明式事务的支持 只需要通过配置就可以完成对事务的管理，而无需手动编程 4）方便程序的测试 Spring对Junit4支持，可以通过注解方便的测试Spring程序 5）方便集成各种优秀框架 Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等) 6）降低JavaEE API的使用难度 Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装. 二、Eclipse中安装Spring 1、查看eclipse版本（必须和Spring版本对应才行） ----->打开eclipse----->Help-------->About Eclipse IDE 2、安装Spring IDE插件： 1）Help->Install New Software 2）选择Add，添加Name（可以随便取）和Location：http://dist.springsource.com/release/TOOLS/update/e4.10/ 3）勾选中下边四个和Spring相关的文件。Core/Spring IDE、Extensions/Spring IDE、Integrations/Spring IDE、Resources/Spring IDE四项 3、 点Next直到选择I accpet the terms of the license agreements点Finish然后等待插件安装完成并提示重启。 报错：An error occurred while collecting items to be installed session context was:(profile=D__eclipse_java-2018-12_eclipse,phase=org.

版权声明：本文为博主原创文章，转载请声明出处。 https://blog.csdn.net/zuoyixiao/article/details/78717585 --------------------- 作者：萧萧慕宇 来源：CSDN 原文：https://blog.csdn.net/zuoyixiao/article/details/78717585 版权声明：本文为博主原创文章，转载请附上博文链接！

概述 简介 Solr是一个基于Lucene的Java搜索引擎服务器，Solr 包装并扩展了 Lucene，所以Solr的基本上沿用了Lucene的相关术语。solr解决了sql在查询性能上的问题，比如搜索商品，过多商品通过like关键字甚至加上其他更复杂语句会导致性能问题。 安装 下载 官网下载解压即可 bin：solr的命令文件 contrib：solr的插件 dist： solr的jar包 docs: solr文档 example： solr示例 licenses： solr证书 server： solr服务器核心文件 启动solr 在使用前必须安装JDK，然后shell进入bin目录：输入solr start 打开网页http://localhost:8983/solr访问进入solr页面即安装完成。 其它命令： solr start –p 端口号 单机版启动solr服务（默认端口号8983） solr restart –p 端口号 重启solr服务 solr stop –p 端口号关闭solr服务 使用 创建core（核心） Solr核心(Core)是Lucene索引的运行实例，每个core下都有自己的索引库和与之相应的配置文件。 1.进入bin目录执行solr create –c name即可，core存放在server/solr下，删除core时执行 solr delete -c name。 2.solr的控制面板创建 索引 索引使用户能够在文档中快速地查找信息。我们可以索引(添加，删除，修改)各种文档格式。在查询之前要添加数据。 命令提交：post -c coreName(要提交到的核心) file(要提交的文件，可以提交xml测试) <add> <doc> <field name = "id">1001</field> <field name = "name">zhangsan</field> <field name = "

学习了韦东山老师的视频才知道可以通过设置内核启动参数来从NFS 挂载rootfs ，于是我在NanoPi M1 Plus 开发板上实际试了下，过程中也终于到一些问题，这里整理一下： 1.服务端要安装 nfs-kernel-server 并开启服务 apt-get install nfs-kernel-server /etc/init.d/nfs-kernel-server start 可以在 /etc/exports 里修改可挂载的目录 ，修改后记得重启服务 /home *(rw,sync,no_subtree_check) 如上表示/home 可挂载，* 表示所有ip 都可以挂载 2.内核要开启对NFS 的支持 Location: -> Kernel modules –> Filesystems —> kmod-fs-nfs <y> —> kmod-fs-nfs-v3 <y> —> kmod-fs-nfs-v4 <y> 3.内核要开启对KERNEL_ROOT_NFS 的支持 已看出KERNEL_ROOT_NFS 依赖于KERNEL_IP_PNP 所以 在Global build settings -> Kernel build options 里选中 Compile the kernel with rootfs on NFS 即可。 4.设置内核启动参数 因为OpenWRT里会根据 openwrt\package\boot\uboot-sunxi\uEnv-default.txt 生成boot.scr ，所以内核启动参数在这里修改。 修改openwrt\package\boot\uboot-sunxi\uEnv-default.txt root=/dev/mmcblk0p2 rootwait

1，先将键盘输入法系统改成fcitx 若没有这个在终端执行命令：sudo apt-get install fcitx sudo apt-get install libssh2-1,然后把键盘输入法系统改成fcitx。 2，在官网下载搜狗输入法deb格式，32位或者64位。地址：http://pinyin.sougou.com/linux/(在ubantu里的浏览器里面下载哦) 3，切换到下载的文件夹，然后执行命令：sodo dpkg -i sougoupinyin-2.2.0.0108_amd64.deb(安装包名称根据自己的来） sudo apt -f install 4,安装完成，重启一下即可。

Linux脚本打印阶乘数 需求： 1.打印阶乘数，如：1 2 3 4 5 ...... 2.手动传入值 方法1(while): #! /bin/bash a=1 while test $a -le $1;do echo $a;((a++));done 方法2(for): （1） #! /bin/bash for ((a=1;a<=$1,a++));do echo $a;done （2） #! /bin/bash for i in $(seq 1 $1);do echo $i;((i++));done 注： 执行方式 sh test.sh 5 或 ./test.sh 5 例如： ./test.sh 5 1 2 3 4 5

H5各种头部meta标签功能大全 <!DOCTYPE html> H5标准声明，使用 HTML5 doctype，不区分大小写 <head lang=”en”> 标准的 lang 属性写法 <meta charset=’utf-8′> 声明文档使用的字符编码 <meta http-equiv=”X-UA-Compatible” content=”IE=edge,chrome=1″/> 优先使用 IE 最新版本和 Chrome <meta name=”description” content=”不超过150个字符”/> 页面描述 <meta name=”keywords” content=””/> 页面关键词 <meta name=”author” content=”name, email@gmail.com”/> 网页作者 <meta name=”robots” content=”index,follow”/> 搜索引擎抓取 <meta name=”viewport” content=”initial-scale=1, maximum-scale=3, minimum-scale=1, user-scalable=no”> 为移动设备添加 viewport <meta name=”apple-mobile-web-app-title” content=”标题”> iOS 设备 begin <meta name=”apple-mobile-web-app-capable” content=”yes”/> 添加到主屏后的标题（iOS 6 新增） 是否启用 WebApp 全屏模式，删除苹果默认的工具栏和菜单栏 <meta name=”apple-itunes-app” content=”app-id=myAppStoreID, affiliate-data=myAffiliateData, app-argument=myURL”> 添加智能 App 广告条 Smart App Banner（iOS 6+ Safari）

idea中开发javaweb应用，使用mvn tomcat7:run命令运行应用时，需要配置tomcat的maven插件。在没有配置的情况下会出现下面的错误提示。 [ERROR] No plugin found for prefix ‘tomcat7’ in the current project and in the plugin groups [org.apache.maven.plugins, org.codehaus.mojo] available from the repositories [local (C:\Users\Administrator.m2\repository), central (https://repo.maven.apache.org/maven2)] -> [Help 1] 添加tomcat的maven插件配置即可。 <plugin> <groupId>org.apache.tomcat.maven</groupId> <artifactId>tomcat7-maven-plugin</artifactId> <version>2.2</version> <configuration> <path>/${project.artifactId}</path> </configuration> </plugin> 不过要注意的是，就算配置正确，若web应用的工作目录（Working directory）配置错误的话，还是会存在这个错误。 还有一点需要补充说明一下，不管机器中安装的tomcat版本是7还是8，都可以使用这个插件来运行应用。使用这种方法，不仅修改的jsp可以立即生效，也可以实现类的热部署，还可以使用断点调试。强大的idea。

(window as any).namespace 转载于:https://www.cnblogs.com/unreal-feather/p/10324885.html

2019独角兽企业重金招聘Python工程师标准>>> 默认配置， 直接npm run build 将生成后的dist文件夹复制出来放到HBuilder相应目录下，然后HBuild下打开dist目录。 强调：用的是HBuilder 不是 HBuildrX,因为我用HBuilderX打包反复闪退，实在搞不定原因啊 要么转换为移动app， 要么新建一个移动app然后复制manifest.json文件到disk目录。 然后右键菜单 发行=》云打包-原生安装包=》接下来直接下一步下一步就ＯＫ了。 其中android证书可以在这个网站注册个，测试够用了 http://www.appcan.cn/ 踩坑： 1、默认图片都放到了assets/img/下，但是图片超过100kb打包后跑到了static/img下，然后图就裂了 解决方法：直接进static/img/ 或 修改配置 limit 我给改成了1000000 { test: /\.(png|jpe?g|gif|svg)(\?.*)?$/, loader: "url-loader", options: { limit: 10000000, name: utils.assetsPath("img/[name].[hash:7].[ext]") } }, 2、链接跳转失效了 解决方法：原因是因为 mode:history模式，把这个取消了就可以了。 const router = new Router({ // mode: "history", // base: getAbsolutePath(), // base: "/app/", routes: [ { // 首先进行重定向操作 path: "/", redirect: "home" }, ...... ] 3、路径也要修改下 build: { // Template for index.

1、在一张图上画多条曲线 import matplotlib.pyplot as plt import numpy as np x = np.linspace(-3,3,50) #设置横轴的取值点 y1 = 2 * x + 1 #曲线1 y2 = x**2 #曲线2 plt.figure(num=3,figsize=(8,5)) plt.plot(x,y2) plt.plot(x,y1,color='red',linewidth=1,linestyle='--') plt.show() 2、设置坐标轴的长度 plt.figure(num=3,figsize=(8,5)) 3、设置坐标轴的取值范围 import matplotlib.pyplot as plt import numpy as np x = np.linspace(-3,3,50) y1 = 2 * x + 1 y2 = x**2 # plt.figure(num=1) # plt.plot(x,y1) plt.figure(num=3,figsize=(8,5)) plt.plot(x,y2) plt.plot(x,y1,color='red',linewidth=1,linestyle='--') plt.xlim((-1,2)) plt.ylim((-1,2)) 4、设置坐标轴的名称 import matplotlib.pyplot as plt import numpy as np x = np.

#include <iostream> #include <algorithm> #include <map> #include <string.h> #include <string> #include <list> #include <stack> #include <queue> #include <cstdio> #include <math.h> using namespace std; const int n = 5; int a[n]; bool binary_search(int x){ int l = 0, r = n; sort(a,a+n); while(r-l>=1){ int mid = (r+l)/2; if(a[mid] == x){ return true; } else if(a[mid] > x){ r = mid; } else{ l = mid + 1; } } return false; } int main() { ios::sync_with_stdio(false); for(int i=0;i<n;i++){ cin>>a[i]; } int x; cin>>x; if(binary_search(x)){ cout<<"

https://cloud.tencent.com/developer/article/1005598 一、引言 云计算经过多年的发展，逐渐从概念到渐为人认知、到接受、到现在全行业拥抱上云，云的客户也从最初的中小初创互联网企业为主，逐步渗透到大型互联网企业、金融企业、传统企业，甚至到大型央企/政企。 因此，为了应对不同客户的市场需求，云的形态也开始多样化，根据客户对资源控制权的不同，基本分为以下几类： 图1 云的集中形态 在传统公有云中，计算资源主要是虚拟机的形态，以至于在云计算早期一段时间内，大部分人认为云计算技术 = 虚拟机技术，这种形态下的云，你只能接触到虚拟机，任何物理资源对你都是透明的；当这些物理资源产生冲突时，势必会影响到你的业务，所以当业务要求越来越高，他们对资源的控制权也慢慢提升，希望能独享物理机，就有了裸机云；进一步，他们还希望能自定义组网，方便其原有业务的迁移或重新规划，于是有了黑石云的解决方案（顺便提一下，其实“黑石”的核心是支持Overlay的虚拟网络，而非外界解读的物理机售卖）；到最后连数据中心也要求独享，就有了私有云。这时，相当于裸奔了，原来隐藏在客户背后的供应链管理、运营支撑管理、异常发现和处理等机制、系统稳定性/易用性/安全性、运维背后的人海战术等，都表露无遗，要把数据中心真正“交”给客户，不是那么简单的。 二、公有云 VS 私有云 关于私有云和公有云的PK，业界一直有争论，大部分都认为公有云才是未来，私有云是历史的倒退，尤其是技术发展的倒退，觉得这东西就是以前传统系统集成商干的事情，不是互联网人变革的上流新事情。其实，这种说法是片面的，他们只看到了“私有”这部分，要“私有”并不难，但关键是在“云”这部分，即提供一套私有云管理系统，实现整个IDC的自动化闭环管理，由之前的手工管理变成系统管理，减低用户的使用门槛。从某种程度来讲，私有云其实是公有云发展到一定阶段成熟后，一种产品化的结果，也是能力输出的一种最极致的表现。 另一方面，受限于安全合规的要求和商业竞争的考虑，传统金融（尤其银行/证券）、央企/国企/政企和大型传统企业，一般不会把核心业务放在公有云上，宁愿花更大的成本代价，也要以私有化独享的形态来掌控自己的核心业务，因此，在很长一段时间内，私有云或混合云，都还是这些金主的主要考虑方案。 三、DCOS 1.0诞生 关键词：站在巨人的肩膀，服务器/网络融合 为什么会有DCOS？ 去年，腾讯云迎来了一位新筹民营银行客户 ： 上海华通银行。 如下图，按银监会的要求，金融机构基本都是两地三中心，IDC之间通过腾讯的DCI互联，访问公网则通过腾讯的TIX，他们的IDC和腾讯内部IDC是不能互通的，因此是独立隔离的私有环境。IDC在外部接入方面严格控制，通过ssl vpn实现点对点接入，从物理层面来做安全防护，vpn接入后，再通过云管理门户，实现对所有资源的管理。 图2 银行私有云整体网络示意图 在公有云环境中，用户只需要接触到虚拟的云资源，比如云主机、云硬盘、云数据库等，公有云会提供配套的自动化管理系统，对这些云资源进行管理，如生产、分配、回收等。但在私有云的环境里，所有基础架构设施均由用户自行管理，包括物理服务器资源的初始化安装、远程开关机、重启和部署重装等操作，如果还是通过以往人工和现场的方式来管理，效率会非常低，进而影响到云资源的管理。因此，在私有云的环境里，需要有一套类似云资源管理的自动化系统，实现物理服务器资源导入、自动发现、电源管理、系统部署、配置初始化和回收等生命周期的自动化管理，DCOS就是在这样的需求背景下应运而生的。 DCOS的产品定位 DCOS全称Data Center Operating System，顾名思义，定位是数据中心操作系统，这是一个很泛的叫法，业界完全对标的独立产品几乎没有。回顾 DCOS这1年多摸着石头的不断探索、思考，经过近30个迭代版本的试错验证，从设计到开发到应用落地，慢慢其定位也越来越清晰–私有云的物理基础架构管理引擎。如果参考行业私有云老大 – OpenStack的模型，DCOS正好补充了OpenStack对物理资源监管控能力，如下图红框部分： 图3 OpenStack逻辑架构图 下面分别从两个维度介绍一下DCOS的定位： 1）从资源管理的角度看：私有云里会有腾讯自采物理资源（腾讯标准服务器和网络设备）、客户托管设备和云产品（虚拟机、云储存、云负载均衡、云数据库等），DCOS定位是负责腾讯自采物理资源的监管控，同时提供中心化的CMDB，实现基础架构设施数据的资源管理。 2）从逻辑功能的角度看：如果把数据中心当作一个整体业务，最低配的银行私有云至少包括四大模块：接入层（TGW模块）、逻辑层（DCOS模块和Vstation虚拟化模块）、数据层（TDSQL模块），TGW负责外部或内部的负载均衡接入，DCOS和Vstation分别负责物理和虚拟资源的逻辑处理如生产、监控、再分配、回收等，TDSQL则是提供金融级数据库集群。 DCOS的设计思想 和支撑腾讯海量业务的需求场景不同，DCOS主要是面向传统企业，支撑大概1万台服务器（含虚拟机）规模的私有环境，产品设计上和现在内部系统会很大的差异，重点不是物理分布式架构和高并发能力，而是All-in-one高度集成、轻量简单、易部署、易运维、易扩展： 图4 DCOS设计理念 DCOS的产品解决方案 DCOS的产品解决方案如下图，按其功能主要分为四大子产品： 图5 DCOS产品解决方案 1）CMDB：涵盖了服务器、网络设备、网络端口、IDC机架机位、IDC专线、IDC出口、IP资源等物理信息的生命周期管理，基于腾讯多年IDC运营经验而建立其CI模型，并提供ADS智能审计模块，形成数据管理闭环，保证CMDB基础数据的完整性和准确性。最终，以API方式提供给web或其他云组件，并封装好常用的IP裂解/分配/回收和服务器搬迁等流程逻辑。 图6 CMDB的CI关系项 2）BME（Bare Metal Engine）：物理裸机管理引擎，负责物理裸机的自动发现、带外管理、自动化部署、命令下发&文件传输等自动化管控运维，通过外部扩展，还可以实现私有云其他组件，如控制节点、计算节点、存储节点等初始化部署。 3）OneMonitor：服务器和网络融合的一站式监控引擎，涵盖服务器基础采集、服务器硬件部件采集、服务器进程&端口采集、自定义业务采集、网络设备SNMP采集、网络质量探测、网络应用数据流分析，并支持把原始监控数据转发第三方平台。 4）OneAlert：服务器和网络融合的一站式告警引擎，实现服务器硬件异常告警、服务器性能/状态告警、服务器进程&端口告警、网络设备性能和状态告警、网络设备日志告警、网络质量告警、自定义业务数值/字符告警，并支持把原始告警数据转发给第三方平台。 从业务场景讲，DCOS希望实现从物理资源准备、生产到运营的闭环管理（如下图）： 图7 DCOS的业务场景 1）资源准备阶段：经过上游资源的申请、采购、建设交付后，得到物理配置信息和资源规划信息（IP资源等），并导入DCOS的CMDB，建立基础架构设施数据的baseline； 2）资源生产阶段：现场把服务器物理上架，并接上电源线后，即可进入远程管理阶段，服务器会通过带外BMC自动发送DHCP请求到DCOS；DCOS根据SN信息进行配置验收无误后，分配带外IP、标记为“已开电”状态，并纳入裸机资源池；然后通过带外IPMI即可远程初始化、开机、关机和重启；当DCOS接收到上层部署需求（RAID/OS/IP/初始密码等）后，会远程触发服务器进入PXE状态，在PXE环境通过DHCP获取部署IP，通过TFTP拉取对应的镜像和配置文件，完成部署，并通过后置初始化脚本，实现网络的配置，以及应用组件的批量部署，实现私有云的初始化，全程可以做到服务器Zero Touch； 3）资源运营阶段：服务器和网络设备的监控采集和异常故障告警，以及服务器和网络设备的日常运营管控。 图8 DCOS管理控制台 DCOS的技术解决方案： 1）逻辑架构 图9 DCOS的逻辑架构图 DCOS采用模块化设计，每个模块（红框）负责部分功能，如oob负责带外&部署，sc负责服务器信息采集管理，cmdb负责配置管理等。模块可单独部署，成为独立的产品组件。模块之间基本没有依赖性（CMDB除外），维护和故障排查起来比较方便，同时易于进行模块扩展。

附加数据库出错 修改mdf的 权限为完全控制，如果有需要ldf也需要修改。还需要把属性 √只读给取消就ok了.

一开始有这个需求是实验室有一台服务器，我寒假回家可能需要操作（没办法，就是这么认真，放假也要科研），这样的话为了防止实验室断电或断网，我需要保证断网重拨和重启重拨。这个地方需要注意一点服务器断电自动重启，所以在断电之后来电的时候服务器自动重启。 1、断网重拨 一般断网重拨是默认的，但是持续次数很少，比如计算机断网之后，两个小时才来网，早就无法自动拨号。也就再也无法联网了。 （1）一种方法是设置重拨次数和重拨间隔，最好设置时间长一点，比如五分钟或十分钟，然后重拨次数为100次，这样可以持续1000分钟，也就是将近17个小时。 （2）另外一种方法是写一个程序或批处理，检测当前联网状况，如果断网则重拨号。而且记得将程序设置为启动项，下面有设置为启动项的方法。 2、断电重拨 因为服务器自动连电重启，所以断电重拨的需求变成了重启重拨。重启重拨也就是服务器每一次被启动的时候会进行自动拨号。下面来看几种实现方式： （1）启动项 1、首先打开目标连接的属性，然后在选项下，取消勾选 提示名称、密码和证书等（如果你不想出现连接界面，那么把连接时显示进度也取消勾选），然后确定。否则在自动拨号期间会出现密码提示窗口； 2、确定后，WIN+R打开运行，输入 shell:Startup 然后确定，打开启动文件夹； 3、把宽带连接的快捷方式放到Windows的启动项文件夹中就可以了。 这样设置完成之后，计算机开机就可以自动拨号连接了，而不需要用户手动去拨号了。 （2）注册表 原理与（1）相同，都是加入启动项，只不过是通过操作底层注册表。 1、首先打开目标连接的属性，然后在选项下，取消勾选 提示名称、密码和证书等（如果你不想出现连接界面，那么把连接时显示进度也取消勾选），然后确定。否则在自动拨号期间会出现密码提示窗口； 2、Win+R（调出运行对话框），输入regedit，确定。这样就打开了注册表； 3、注册表打开后，找到 HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run。 然后在右边的窗口中新建一个字符串键，名字任取，双击此键输入键值为C:\Windows\System32\rasphone -d "宽带连接"(注：目标宽带连接名为“宽带连接”，这要输入你的宽带连接的名）。如果对键值不确定，可以复制命令在文件浏览器中执行，就可以看到自动拨号了。 4、测试：你可以在运行里输入msconfig找启动项看一下是不是加入了一个Windows启动项，而它的命令里就是C:\Windows\System32\rasphone -d "宽带连接"。 （3）脚本文件 通过VBS实现自动拨号 VBS一： Dim Wsh Set Wsh = WScript.CreateObject("WScript.Shell") Wsh.Run "ping 127.0.0.1 -n 3",0,True Wsh.Run "rasdial 宽带连接 宽带帐号 宽带密码",0,True Set Wsh=NoThing WScript.quit 解释： Wsh.Run "ping 127.0.0.1 -n 3",0,True 此行为延迟3秒的意思，可根据自己需要修改延迟的时间，即改动该行代码的数字 3 如： Wsh.Run "ping 127.0.0.1 -n 5",0,True 这样就变5秒延迟了。 Wsh.Run "rasdial 宽带连接 宽带帐号 宽带密码"

//拖动距离 private float distance = 10; //缩放量 float scale = 0.2f; //通过键盘“Q,↑”或者“E,↓”控制物体的缩放 //通过键盘“w,s,a,d”控制物体上下左右的移动 private void Update() { if (Input.GetKey(KeyCode.Q) || Input.GetKey(KeyCode.UpArrow)) { transform.localScale += new Vector3(scale, scale, scale); } if (Input.GetKey(KeyCode.E) || Input.GetKey(KeyCode.DownArrow)) { transform.localScale -= new Vector3(scale, scale, scale); } if (Input.GetKey(KeyCode.W)) { transform.position += -transform.forward * Time.deltaTime * 10; } if (Input.GetKey(KeyCode.S)) { transform.position += transform.forward * Time.deltaTime * 10; } if (Input.GetKey(KeyCode.A)) { transform.Rotate(transform.up * Time.deltaTime * 45);

在win7下用MyEclipse新建一个基于Maven的web工程的时候，报错： Failure to transfer org.codehaus.plexus:plexus:pom:1.0.14 from http://repo1.maven.org/ma..... 原因是网络不稳定，文件没下成。 解决办法： 1.进入你本地的Maven仓库 不知道本地仓库目录可以去你的Maven所在的目录下conf文件夹下的setting.xml中查看<localRepository>标签，如果没改过setting.xml则这个库默认是在用户目录下的.m2文件夹 2.按照报错信息逐级打开仓库的文件夹，进入到下载失败的文件夹删除.lastUpdated文件或者你可以直接搜 *.lastUpdated, 把搜索结果全删掉 比如报错信息是 org.codehaus.plexus:plexus:pom:1.0.4 那么下载失败的文件就在文件夹 %本地仓库%\org\codehaus\plexus\plexus\1.0.4 3.在myeclipse的maven工程上右键Mavne4MyEclipse-> Update Dependencies， 勾选有问题的Maven项目，然后点ok等待重新下载。 搞定后报错消失，进入到对应的文件夹%本地仓库%\org\codehaus\plexus\plexus\1.0.4可以看到重新下载的文件。

[版权申明]非商业目的注明出处可自由转载 博文地址：https://blog.csdn.net/ShuSheng0007/article/details/86619675 出自：shusheng007 设计模式汇总篇，答应我先点赞再收藏： 永不磨灭的设计模式（有这一篇真够了，拒绝标题党） 文章目录 前言定义使用场景解决的问题如何实现如何使用案例扩展传统Builder 模式使用 技术总结总结 前言 人在IT江湖飘，不懂设计模式咋装逼？ 但是没写过5万行代码谈设计模式都是在瞎扯淡，咱先看看定义 In software engineering, a software design pattern is a general, reusable solution to a commonly occurring problem within a given context in software design. It is not a finished design that can be transformed directly into source or machine code. It is a description or template for how to solve a problem that can be used in many different situations.

1、打开终端，在命令行下切换到要建立项目的文件夹： 使用scrapy startproject [项目名]，例如：scrapy startproject qsbk。这时就会在相应文件夹下生成scrapy项目： 然后用pycharm打开。scrapy.cfg是整个项目的配置文件。items.py存储的是所有爬取数据的模型。middlewares.py是中间件。pipelines.py用于处理爬取到的数据。 2、进入项目文件夹，比如：cd qsbk，然后使用scrapy genspider 项目名 域名新建一个爬虫，例如：scrapy genspider qsbk_spider 'qiushibaike.com': 然后就会多出一个文件： 它会自动给你生成这样一个类。 3、将settings.py中的ROBOTSTXT_OBEY设置为False，因为如果为True的话就有可能抓取不到数据。然后加上头部信息： 4、看到QsbkSpiderSpider这个类： class QsbkSpiderSpider(scrapy.Spider): name = "qsbk_spider" allowed_domains = ["qiushibaike.com"] start_urls = ['http://qiushibaike.com/'] def parse(self, response): pass 它必须继承自scrapy.Spider类，然后实现三个属性：爬虫的名字、允许的域名、开始的url。 5、对要爬取的网站做一个分析： 我们发现它是分页的形式，并且每一页只有一个数字不同：https://www.qiushibaike.com/8hr/page/1/，因此把url替换为这个url。 然后打印一下response： def parse(self, response): print('*'*40) print(response) print('*'*40) 接着使用命令来运行一下： 点击show in Explorer进入到项目当中: 然后在此处打开命令行，输入命令scrapy crawl qsbk_spider，crawl就是爬的意思。如果出现错误，则输入：worlon crawler-env。然后就爬取到了一些信息： 再打印一下它的类型： 然后导入这个类型：from scrapy.http.response.html import HtmlResponse。将鼠标放在这段文字上面按一下Ctrl+B跳到这里： 然后发现它继承自TextResponse，然后再进去看一下： 可以获取它的encoding和文本。然后提取数据的方法有Xpath和CSS： 6、分析如何拿到其中的每一个段子 我们发现所有的段子都在这个div下，然后其中的每一个子div就代表一个段子。所以现在只需要获取这个div下的所有直接子div就可以获取所有的段子。然后我们打印一下它的类型： print('='*40) print(type(response.xpath('//div[@class="content-block clearfix"]'))) print('=' * 40) 由于每次都需要再命令行中去执行，因此我们新建一个python文件start.py： from scrapy import cmdline cmdline.

1.开启Windows服务器防火墙1688端口 2.在服务器解压binaries.tar.gz，打开Windows-intel，服务器为64位打开，32位打开，出现黑色窗口，则服务已启动。 3.测试服务是否启动要使用cmd来运行程序，64位运行，32位运行。开始-运行-cmd，输入命令cd C:\Users\Administrator\Desktop\Windows\intel，此路径为程序路径，然后输入vlmcs-Windows-x64.exe程序名称。出现successful则服务已启动。 4.服务器搭建已完成，在win7系统右键开始菜单，点击Windows PowerShell（管理员），出现命令窗口。 5. 修改主机秘钥，输入slmgr /ipk W269N-WFGWX-YVC9B-4J6C9-T83GX，此秘钥为Windows10专业版KMS秘钥，可在https://blog.csdn.net/gsls200808/article/details/72819373查看其它版本的秘钥。 6.输入slmgr /skms 47.107.250.160:1688，修改验证秘钥的服务器地址，此地址为上述配置的服务器地址。 7.输入slmgr /ato，激活。 8.win+R打开运行窗口，输入slmgr.vbs –xpr可查看是否激活。 9.这种方法不能永久激活，若以后过期可使用上述方法重新激活。 下载链接：https://pan.baidu.com/s/1bIDy-knti6Yms23cw8IsRg

问题： 我们在使用Eclipse创建一个新的工作空间时，发现其配置是默认的。习惯了使用以前配置过的工作空间（如字体、字体大小、语言编码规范......），现在又要重新配置一遍是要花时间和精力的，那么我们会想到去找以前的配置文件将其复制过来，那样熟悉的环境又出现了，又可以快乐的打代码了。 解决方法： 1、找到旧的工作空间的配置文件目录：\.metadata\.plugins\org.eclipse.core.runtime 2、将该目录下的.settings文件复制到新的工作空间的配置文件目录下： \.metadata\.plugins\org.eclipse.core.runtime

文件格式头文件标识(16进制)JPEG (jpg)FF D8 FF E0PNG (png)89 50 4E 47GIF (gif)47 49 46 38BMP42 4DTIFF (tif)49 49 2A 00CAD (dwg)41 43 31 30Photoshop (psd)38 42 50 53rtf7B 5C 72 74 66XML (xml)3C 3F 78 6D 6CHTML (html)68 74 6D 6C 3EOutlook Express (dbx)CF AD 12 FE C5 FD 74 6FOutlook (pst)21 42 44 4EMS Access (mdb)53 74 61 6E 64 61 72 64 20 4Apdf25 50 44 46 2D 31 2EWindows Password (pwl)E3 82 85 96ZIP Archive (zip)50 4B 03 04RAR Archive (rar)52 61 72 21Wave (wav)57 41 56 45AVI (avi)41 56 49 20Real Audio (ram)2E 72 61 FDReal Media (rm)2E 52 4D 46MPEG (mpg)000001BAMPEG (mpg)000001B3Windows Media (asf)30 26 B2 75 8E 66 CF 11MIDI (mid)4D 54 68 64

使用插值算法实现图像缩放是数字图像处理算法中经常遇到的问题。我们经常会将某种尺寸的图像转换为其他尺寸的图像，如放大或者缩小图像。由于在缩放的过程中会遇到浮点数，如何在FPGA中正确的处理浮点数运算是在FPGA中实现图像缩放的关键。 一、插值算法原理 在图像的缩放处理过程中，经常会用到插值算法，常见的插值算法包括最邻近插值，双线性插值，双三次线性插值，兰索斯插值等方法。其中，双线性插值由于折中的插值效果和实现复杂度，运用较为广泛。本文中仅介绍最临近插值，重点讨论如何在FPGA平台上使用双线性插值实现图像的缩放。 1.1 最临近插值---------最临近插值介绍 讲理论不如举例子来的快，所以为了更好更快的理解最临近插值，我们通过举个简单的例子来解释最临近插值是个什么神奇的东西。假如有一个3*3矩阵（一幅图像其实就是矩阵），如下，我们把这个图像叫做原图（source image）： 66 28 128 25 88 200 36 68 120 在矩阵中，坐标(x,y)是这样确定的，矩阵的左上角的顶点为原点，从左到右为x轴，从上到下为y轴，如下所示： 图1 图像中坐标确定方式 假设我们想把这个3*3的原图扩大成4*4（我们把这个4*4的图像叫做目的图像destination image）我们该如何做呢？首先当然是先把4*4的矩阵画出来，如下所示： ？ ？ ？ ？ ？ ？ ？ ？ ？ ？ ？ ？ ？ ？ ？ ？ 矩阵画出来后，接下来就要像未知数里填充像素点了。要填入的值如何计算呢，通过如下公式进行计算： 首先我们先来填充目的图像 （0，0），套用上述公式可得到对应原图像的坐标点，srcX =0，srcY= 0；找到原图像中对应的坐标点的像素值，将该像素填充到目的图像中，如下 66 ？ ？ ？ ？ ？ ？ ？ ？ ？ ？ ？ 接下来填充目的图像（1，0），仍然套用公式，srcX = 3/4，srcY = 0，结果发现得到的结果居然有小数，由于计算机中的像素点已经是最小单位，像素的坐标都是整数，没有小数。这是只需要按照四舍五入的思想将小数坐标转换为整数坐标即可.所以（3/4，0） ≈ （1，0），把原图像中（1，0）点的像素值填入目的图像（1，0）坐标处，得到如下结果： 66 28 ？ ？ ？ ？ ？ ？

有序单链表的合并 #include <stdio.h> #include "stdlib.h" typedef struct node { int data; struct node *next; }node; struct node *create() { int i =0; struct node *head, *p, *q; int x = 0; head = (struct node *)malloc(sizeof(struct node)); while(1) { printf("Please input the data:"); scanf("%d" , &x); printf("%d\n",x); if(x == 0) break; p =(struct node *)malloc(sizeof(struct node)); p->data = x; if(++i == 1) { head->next = p; } else { q->next = p; } q = p; } q->next = NULL; return head; } struct node *MergeRecursive(struct node *head1,struct node *head2) { struct node *head = NULL; if(head1 == NULL) { return head2; } if(head2 == NULL) { return head1; } if(head1->data < head2->data) { head = head1; head->next = MergeRecursive(head1->next,head2); } else { head = head2; head->next = MergeRecursive(head1,head2->next); } return head; } void print(struct node *head) { struct node *p; int index = 0; if(head->next == NULL) { printf("

时间复杂度和空间复杂度 如何计算？ 推导算法：大O推导法时间复杂度定义常数阶线性阶对数阶平方阶小结 空间复杂度定义 推导算法：大O推导法 1、用常数1取代运行时间中的所有加法常数 2、在修改后的运行次数函数中，只保留最高阶项 3、如果最高阶项存在且不是1，那么我们就去除于这个项相乘的常数。 时间复杂度 定义 在进行算法分析时，语句总的执行次数T(n)是关于问题规模n的函数，进而分析T(n)随n的变化情况并确定T(n)的数量级。算法的时间复杂度，也就是算法的时间量度，记作：T(n}=0(f(n))。它表示随问题规模n的增大，算法执行时间的埔长率和 f(n)的埔长率相同，称作算法的渐近时间复杂度，简称为时间复杂度。其中f( n)是问题规横n的某个函数。 常数阶 void main() { func(); } void func() { int i=0;//执行1次 i++;//执行1次 i++;//执行1次 i++;//执行1次 } /* 共执行了4次，所以时间复杂度为O(4);根据大O推导法，略去常数，所以此函数的时间复杂度为O(1); */ //假如func变成如下结构 void func() { int i=0;//执行1次 i++;//执行1次 i++;//执行1次 i++;//执行1次 i++;//执行1次 i++;//执行1次 i++;//执行1次 i++;//执行1次 i++;//执行1次 i++;//执行1次 i++;//执行1次 i++;//执行1次 i++;//执行1次 } /* 共执行了13次，时间复杂度为O(13);根据大O推导法，略去常数，所以此函数的时间复杂度仍然为O(1); */ 线性阶 void main() { for(int i=0;i<n;i++) { func(); } } void func()//时间复杂度为O(1)的函数 { printf("大O推导法");//执行1次 } /* 在main中，func共被执行了n次，所以main的时间复杂度为O(n); */ //加入main函数被修改成如下 void main() { for(int i=0;i<n;i++) { func(); func(); } } /* 在main中，func共被执行了2n次，main的时间复杂度为O(2n);根据大O推导法，略去常数系数，所以main的时间复杂度仍为为O(n); */ 对数阶 void main() { for(int i=1;i<n;i++) { func(); i=2i; } } void func()//时间复杂度为O(1)的函数 { printf("

参考： https://www.yuque.com/docs/share/077eb001-b371-4e97-a2b6-c546c6dbd827

今天开启线程传递参数的时候，出现了一个小问题，一直不能传递多个参数，如下 import threading thread1 = threading.Thread(target=fun, args=[1, 2, 3,]) thread1.start() thread1.join() 要用中括号，不用用大括号，一开始的时候，用的大括号，参数不能组成数组， 在最后的参数内，还要添加逗号 转载于:https://www.cnblogs.com/chenfulin5/p/10307754.html

#include <stdio.h> void main(){ int i,j,k; for(i=1;i<=9;i++){ //控制输出的行数 for(j=9;j>i;j--){ printf(" "); //控制输出的空格 } for(k=1;k<=(2*i+1)/2;k++){ printf("%c",48+k); } for(k=(2*i+1)/2;k>1;k--){ printf("%c",48+k-1); } printf("\n"); } } 输出结果为： 总结：上图可以看出金字塔 中间的数为对称轴，两边的数是对称的，先输出金字塔左边的数字，(2*i+1)/2是金字塔左边每行数字的个数，在输出金字塔右边的数，(2*i+1)/2-1是金字塔右边每行数字的个数， 每行左边的是(2*i+1)/2个数，右边是(2*i+1)/2-1个数 每行左边比右边少一个数 因此最后一个for循环的条件是k>1, 通过 printf("%c",48+k);输出时，左边每一行的最后一个数永远比右边每一行的最后一个数大1，因此输出的时候是 printf("%c",48+k-1);

C#开发自定义备忘录（自制精美日历）（用VS开发的winForm应用程序） 目录 1 有关信息 2 程序截图 3 该程序尚未完成的功能/不足之处 4 资源下载 5 源代码 5.1 项目结构 5.2 注意事项 5.3 MemorandumUI Program.cs FormMain.cs FormAdd.cs FormDetail.cs FormResetOwner.cs Resources 5.4 MemoModel MemoModel.cs 5.5 Tool tool.cs 5.6 MemoDAL MemoDAL.cs 5.7 MemoBLL MemoBLL.cs 1 有关信息 IDE：Microsoft Visual Studio 2012 ； 数据库：Microsoft SQL Server 2012 ； 架构：三层架构（DAL、BLL、Model） ； 开发者：邓宇、曾敏慧、张莹 ； 2 程序截图 3 该程序尚未完成的功能/不足之处 ①生肖的判断标准没有改成以农历年来判断； ②没有实现备忘录提醒功能，目前只能创建、删除、查看； 4 资源下载 https://download.csdn.net/download/qq_37027371/10931704 5 源代码 5.1 项目结构 该解决方案（应用程序）由五个项目组成： MemoBLL （业务逻辑层，其实该有的功能我们都写在DAL层里了，BLL其实没起到它的作用） MemoDAL （数据访问层）

1、首先在html页面定义 v-if=“show” 数据绑定守卫默认为true 2、数据绑定 3、 在自动加载接收值的地方加if判断

html 页面 aa.type 是传过来的一个数值 aa.type==1 则显示充值消息

下载地址 http://www.ni.com/gate/gb/GB_EVALMSTUDIO/US，或者百度搜索MeasurementStudio应该可以找到官网。 下载完成之后，点击安装， D:\opc_Measurement Studio\download 因为没安装10,13,15任意一个版本，我只能先安装15 安装总是一个漫长的过程，等待不如先中止一段时间干其他事情。不过我的固态硬盘安装速度还是很快的，大概20分钟就安装完成了。

//html页面 //vue js //提交订单 //结算钱数

远程连接的桌面和我们本地的电脑桌面一样，都是可以设置桌面的分辨率的，那远程连接桌面的分辨率要怎么设置呢，其实很简单，下面就是设置远程桌面分辨率的方法。 设置方法： 方法一：FTP 1、打开开始菜单，点击所有程序，然后点击附件，打开远程桌面连接；或者你也可以使用“mstsc”命令来打开远程桌面连接； 2、点击“显示选项”，然后点击“显示”； 3、我们看到在显示配置中默认的桌面是全屏模式； 4、然后我们滑动那个滑块，就可以自定义分辨率了。 方法二： 1、打开开始菜单，打开运行，输入mstsc/w:1366/h:768，确定； 2、输入远程服务器的ip地址或者域名连接远程桌面； 3、这样登录以后的远程桌面的分辨率就是1366x768的分辨率了。 通过这上面介绍的两种方法，我们都可以实现对远程桌面分辨率的设置。设置分辨率可以根据自己的需要和网络的情况来进行设置，比如说你的网络速度比较慢，开启远程桌面连接以后很卡，你就可以把分辨率设置得低一点，这样可以提高网络速度。

远程桌面连接可以方便我们的工作和生活，方便我们管理服务器，但是如果在使用的过程中出现了一些小问题，我们应该怎么处理呢，今天我们就来说说如果在远程连接的时候出现了黑屏我们要怎么处理。FTP 问题原因： 1、在连接远程桌面的窗口上点击“显示选项”； 2、点击体验，去掉“位图缓存”的选择，点击连接； 3、然后在使用的过程中出现了黑屏，就点击桌面开始菜单，然后运行； 4、输入cmd,然后输入XP的ip地址和-t参数，看看是不是因为丢包的原因。 处理方法： 1、在你使用远程桌面连接的过程中，如果出现了黑屏，请打开任务管理器； 2、在任务管理器中结束explorer.exe进程； 3、在windows任务管理器中点击“文件”，新建任务； 4、然后在浏览中选择“C:\WINDOWS\explorer.exe”程序，确定就可以重新启动远程桌面了。 如果你出现了远程桌面黑屏的情况，就按照这个方法进行设置，然后重新启动远程桌面连接，就可以恢复正常了。

第一个检查 if(((*(vu32*)(0X20001000+4))&0xFF000000)==0x08000000)//判断是否为0X08XXXXXX. 更新固件时，检查固件为FLASH固件，后将固件从SRAM复制到FLASH 串口接收过来的数据，是从：0X20001000开始存储的。 第一个4个字节是MSP地址，第二个4个字节，才是复位中断向量的入口地址。 &0xFF000000就是取最高8位。因为FLASH的地址范围是0X0800 0000开始的。这可以一定程度上确保地址范围正常。 第二个检查 执行固件时，检查固件为FLASH固件，并执行 if(((*(vu32*)(FLASH_APP1_ADDR+4))&0xFF000000)==0x08000000)//判断是否为0X08XXXXXX. 第三个检查 因为接收数据时放在SRAM里，所以不用复制过程，直接执行 执行固件时，检查固件为SRAM固件，并执行 if(((*(vu32*)(0X20001000+4))&0xFF000000)==0x20000000)//判断是否为0X20XXXXXX. 第三个检查 检查代码第一个地址，是否为合法的MSP 第二个地址为中断向量表地址 if(((*(vu32*)appxaddr)&0x2FFE0000)==0x20000000) //检查栈顶地址是否合法.

一、 Hadoop版本 目前Hadoop发行版本非常多，我个人接触的有HDP和CDH，Hortonworks版本（Hortonworks Data Platform，简称“HDP”），Cloudera版本（Cloudera Distribution Hadoop，简称“CDH”），还有其他的版本，目前中国公司我发现用的CDH版本较多，至于什么原因我也不是很清楚，不知道是不是跟风，从我个人的角度使用来看，我觉得HDP版本要比CDH要好。 二、 HDP与CDH对比 1. 据个人了解HDP是100%完全开源的，而CDH还不是100%完全开源。Hortonworks的工程师是社区的主要贡献者，Cloudera的发行版本也是比较清晰的。 2. HDP使用开源工具Ambari安装，CDH使用Cloudera Manager工具安装。对配置的修改与更新我喜欢Ambari的界面，可以很方便的修改集群配置，Cloudera Manager的配置界面真的是太烂了，不方便，发现有些配置竟然没法改。 3. 支持的组件，HDP基本上支持所有的开源大数据组件，CDH也基本上支持所有的开源大数据组件。 4. 代码包依赖，如果是HDP平台，编写代码直接依赖hadoop版本即可，如果是CDH平台，编写代码要依赖cdh的版本，否则运行不成功，这是坑啊。 三、安装参考 1. https://docs.hortonworks.com/ HDP 2. https://www.cloudera.com/documentation.html CDH --------------------- 作者：筱浪 来源：CSDN 原文：https://blog.csdn.net/jsutyq/article/details/80762965 版权声明：本文为博主原创文章，转载请附上博文链接！

1，js包含了Bom、Dom、 ECMAscript 三部分。 2，js的基本数据类型是 string 、number 、boolean。 3，js引用数据类型包括 Array、Date、Object、RegExp、Function。 4、js的两个空类型是null和undefined。 5、in关键字的用法： 1，变量对象的键 for(var 变量 in 对象名){} 2，判断属性是否在对象中 关键字 in 对象名 3，in 关键字操作数组的时候判断的是索引是否存在，而不是值。 6，值类型：存储的是数据本身的变量。 值类型的复制：将存储的数据直接赋值，两个变量是完全独立的。 引用类型：存储的是数据在内存中的地址，数据在内存中单独存储 引用数据的复制：将对象的地址复制一份单独存储，但是共用一个对象，任何一个修改都会改变对象的值。 7、逻辑或和与 表达式1 || 表达式2 如果表达式1为真则返回表达式1，如果表达式1为假则返回表达式2 例子： var num = 0 || 1 cosole.log(num) ----- 1 常用：var event = e || window.Event 或者在方法没传参的时候给赋默认值 表达式1 && 表达式2 如果表达式1为真，则返回表达式2 如果表达式1为假，则返回表达式1 例子： var num = 1 && 2 cosole.log(num) ----- 2 var num = 0 || 1 cosole.

注册事件的方式： 1，ele.on事件类型 = funtion (){} 2 , addEventListener(事件类型，事件处理函数，userCapture),第三个参数是：可选。布尔值，指定事件是否在捕获或冒泡阶段执行。默认为false ，是在事件冒泡阶段执行，true 是指在事件捕获阶段执行。 3，attachEvent(事件类型，事件处理函数) function registeEvent(target,type,handler){ if(target.addEventListener){ target.addEventListener(type,handler) }else if(target.attachEvent){ target.attachEvent("on"+type,handler) }else{ target["on"+type] = handler; } } 三种方式存在的问题： 1，attachEvent 只有ie7支持，其他浏览器不支持，addEventListener 谷歌，ie9，火狐，Opera 等都支持。 2、注册的事件的处理函数中的，this指向不一致 ，使用第一种和addEventListener的方式注册的点击事件的回调函数中的this 指向target，但是使用attachEvent的方式注册点击事件的回调函数中的this 指向window 3，3种注册事件的方式中，回调函数内获取事件对象的方式也是不一致的 为了统一方式，用以下办法来改变this指向和event,来达到适配： function createEventRegister(){ if(window.addEventListener){ return function(target,type,handler){ target.addEventListener(type,handler) } }else if(window.attachEvent){ return function(target,type,handler){ target.attachEvent("on"+type,function(){ //这里改变this指向和event对象 handler.call(target,window.event) }) } }else{ return function(target,type,handler){ target["on"+type] = handler; } } }

拿到题目检查防护： 64位程序，简单的栈溢出： 程序本身有cat flag 计算下溢出点： exp如下：

目录 热水器水温显示器 问题咨询及项目源码下载请加群： 群名：IT项目交流群 群号：245022761 一、设计目的 1. 了解DS18B20温度传感器工作原理及引脚功能。 2. 理解DS18B20温度传感器的单总线工作时序。 3. 学会使用DS18B20温度传感器采集温度信号。 4. 了解继电器工作原理及引脚功能。 5. 学会使用面包板搭建外部电路 6. 会使用八段数码管显示温度值。 二、项目设计要求 使用51单片机控制DS18B20温度传感器检测热水器水温，并将水温值显示在八段数码管显示模块上，当温度处于35-45度之间时绿灯亮，否则红灯亮，并且蜂鸣器发出报警声。 三、系统实现图 四、代码实现 DS18b20温度传感器 代码实现： #include <ds18b20.h> sbit ds=P2^2; //温度传感器信号线 void dsreset() //18B20复位，初始化函数 { u16 i; ds=0; i=103; while(i>0)i--; //延时 ds=1; i=4; while(i>0)i--; //延时 } bit tempreadbit() //读1位函数 { u16 i; bit dat; ds=0;i++; //i++ 起延时作用 ds=1;i++;i++; dat=ds; i=8;while(i>0)i--; //延时 return(dat); } u8 tempread() //读1个字节 { u8 i,j,dat; dat=0; for(i=1;i<=8;i++) { j=tempreadbit(); dat=(j<<7)|(dat>>1); //读出的数据最低位在最前面，这样刚好一个字节在DAT里 } return(dat); } void tempwritebyte(u8 dat) //向18B20写一个字节数据 { u16 i; u8 j; bit testb; for(j=1;j<=8;j++) { testb=dat&0x01; dat=dat>>1; if(testb) //写 1 { ds=0; i++;i++; //延时 ds=1; i=8;while(i>0)i--; //延时长 } else { ds=0; //写 0 i=8;while(i>0)i--; //延时长 ds=1; i++;i++; //延时 } } } void tempchange() //DS18B20 开始获取温度并转换 { dsreset(); delay_ms(1); tempwritebyte(0xcc); // 写跳过读ROM指令 tempwritebyte(0x44); // 写温度转换指令 } float get_temp() //读取寄存器中存储的温度数据 { u8 a,b; u16 t; int temp; float f_temp; dsreset(); delay_ms(1); tempwritebyte(0xcc);// 写跳过读ROM指令 tempwritebyte(0xbe);// 发读数据指令 a=tempread(); //读低8位 b=tempread(); //读高8位 if(b&0x08) b=b|0xf0; t=b; t*=256; //两个字节组合为1个字 t=t|a; temp=t; f_temp=temp*0.

import os import xml.dom.minidom import cv2 as cv ImgPath = 'C:/Users/49691/Desktop/gangjin/gangjin_test/JPEGImages/' AnnoPath = 'C:/Users/49691/Desktop/gangjin/gangjin_test/Annotations/' #xml文件地址 save_path = '' def draw_anchor(ImgPath,AnnoPath,save_path): imagelist = os.listdir(ImgPath) for image in imagelist: image_pre, ext = os.path.splitext(image) imgfile = ImgPath + image xmlfile = AnnoPath + image_pre + '.xml' # print(image) # 打开xml文档 DOMTree = xml.dom.minidom.parse(xmlfile) # 得到文档元素对象 collection = DOMTree.documentElement # 读取图片 img = cv.imread(imgfile) filenamelist = collection.getElementsByTagName("filename") filename = filenamelist[0].childNodes[0].data print(filename) # 得到标签名为object的信息 objectlist = collection.

ref 原文： https://blog.csdn.net/fenglongmiao/article/details/79656198 note 我们知道HashMap集合是允许存放null值的 hashMap是根据key的hashCode来寻找存放位置的，那当key为null时， 怎么存储呢？ 在put方法里头，其实第一行就处理了key=null的情况。 // HashMap的put方法 public V put(K key, V value) { if (table == EMPTY_TABLE) { inflateTable(threshold); } if (key == null) // key为null调用putForNullKey(value) return putForNullKey(value); int hash = hash(key); int i = indexFor(hash, table.length); for (Entry<K,V> e = table[i]; e != null; e = e.next) { Object k; if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { V oldValue = e.

# -*- coding:utf-8 -*- """数据增强 1. 翻转变换 flip 2. 随机修剪 random crop 3. 色彩抖动 color jittering 4. 平移变换 shift 5. 尺度变换 scale 6. 对比度变换 contrast 7. 噪声扰动 noise 8. 旋转变换/反射变换 Rotation/reflection """ from PIL import Image, ImageEnhance, ImageOps, ImageFile import numpy as np import random import threading, os, time import logging logger = logging.getLogger(__name__) ImageFile.LOAD_TRUNCATED_IMAGES = True class DataAugmentation: """ 包含数据增强的八种方式 """ def __init__(self): pass @staticmethod def openImage(image): return Image.

QT上实现FTP传输 项目开发中,需要使用到FTP协议进行文件传输,现有QT自带的库中支持FTP传输的为 QNetworkAccessManager,虽然此类可以实现 Ftp 的上传/下载功能,但有的功能 QNetworkAccessManager 却没有提供，例如：list、cd、remove、mkdir、rmdir、rename 等。这种情况下，就不得不使用 QFtp，只需要下载源码自行编译即可使用。 QFtp的使用 首先从 GitHub 下载 QFtp： https://github.com/qt/qtftp 完成之后，可以看到 qtftp 中包含源码及示例。 下载下来的源码 配置 下面，以 MSVC为例。 打开 src/qftp/qftp.pro，将默认配置： CONFIG += static CONFIG -= shared 改为： CONFIG += staticlib CONFIG += shared 这样，生成 *.dll 的同时也会生成 .lib。 编译 QFtp，完成之后会在 lib 文件夹下生成 .lib、.dll、.prl 文件。 • 将 Qt5Ftpd.lib、Qt5Ftp.lib、Qt5Ftpd.prl、Qt5Ftp.prl 拷贝至 D:\Qt\Qt5.5.1\5.5\msvc2013\lib。 • 将 Qt5Ftpd.dll、Qt5Ftp.dll 拷贝至 D:\Qt\Qt5.5.1\5.5\msvc2013\bin。 • 将 qftp.h、qurlinfo.h 拷贝至 D:\Qt\Qt5.5.1\5.5\msvc2013\include\QtNetwork，并新建一个名为 QFtp 的文件（没有后缀名），然后写入 #include “qftp.h”。 完成之后，就可以使用 QFtp 了。

消费者的代码如下： 1 2 3 4 5 6 7 8 9 10 @Component @RabbitListener(queues = "balance") public class Receiver { @RabbitHandler public void process(String hello) { System.out.println("Receiver : " + hello); } } 运行之后，出现循环抛出异常的情况 (org.springframework.amqp.AmqpException: No method found for class [B)，具体如下： 1 2 3 4 5 6 7 8 Caused by: org.springframework.amqp.AmqpException: No method found for class [B at org.springframework.amqp.rabbit.listener.adapter.DelegatingInvocableHandler.getHandlerForPayload(DelegatingInvocableHandler.java:127) ~[spring-rabbit-1.7.0.RELEASE.jar:na] at org.springframework.amqp.rabbit.listener.adapter.DelegatingInvocableHandler.getMethodNameFor(DelegatingInvocableHandler.java:224) ~[spring-rabbit-1.7.0.RELEASE.jar:na] at org.springframework.amqp.rabbit.listener.adapter.HandlerAdapter.getMethodAsString(HandlerAdapter.java:61) ~[spring-rabbit-1.7.0.RELEASE.jar:na] at org.springframework.amqp.rabbit.listener.adapter.MessagingMessageListenerAdapter.invokeHandler(MessagingMessageListenerAdapter.java:140) ~[spring-rabbit-1.7.0.RELEASE.jar:na] at org.

介绍如何通过键盘控制小车运动 准备工作 1.下载串口通信的ROS包 cd ~/catkin_ws/src git clone https://github.com/ncnynl/serial.git 2 下载键盘控制的ROS包 cd ~/catkin_ws/src git clone https://github.com/ncnynl/teleop_twist_keyboard.git 进入下载好的ROS包的文件夹，选中 keyboard_teleop_zbot.py ，右键->设为可执行文件。 最后一步： cd ~/catkin_ws catkin_make 串口通讯和键盘控制完成 在上位机上搭建一个控制器： 新建 base_controller ROS 包： $ cd ~/catkin_ws/src $ catkin_create_pkg base_controller roscpp $ cd catkin_ws/src/base_controller $ mkdir src $ touch src/base_controller.cpp $ gedit src/base_controller.cpp base_control.cpp代码如下： /****************************************************************** 基于串口通信的ROS小车基础控制器，功能如下： 1.实现ros控制数据通过固定的格式和串口通信，从而达到控制小车的移动 2.订阅了/cmd_vel主题，只要向该主题发布消息，就能实现对控制小车的移动 3.发布里程计主题/odm 串口通信说明： 1.写入串口 （1）内容：左右轮速度，单位为mm/s （2）格式：１０字节,[右轮速度４字节][左轮速度４字节][结束符"\r\n"２字节] 2.读取串口 （1）内容：小车x,y坐标，方向角，线速度，角速度，单位依次为：mm,mm,rad,mm/s,rad/s （2）格式：２１字节，[Ｘ坐标４字节][Ｙ坐标４字节][方向角４字节][线速度４字节][角速度４字节][结束符"\n"１字节] *******************************************************************/ #include "ros/ros.h" //ros需要的头文件 #include <geometry_msgs/Twist.h> #include <tf/transform_broadcaster.h> #include <nav_msgs/Odometry.

我是在codeblocks中写了一个c++代码，出现的这个问题也是有点莫名其妙，因为没有编译错误也没用运行时错误，就是一个函数不执行了，经过我的调试后发现原因是： 在函数内部初始化了一个相当大的数组，导致内存溢出，从而导致整个函数（即便是在初始化这个数组之前的代码）未执行，并导致整个程序直接退出！ 但是!!!这里的重点不在于定义了一个相当大的数组，而在于内存溢出！不仅仅是这一种情况，只要是出现了这种情况都应该去检查一下自己的代码是否出现了纰漏，是否哪个地方访问了不该访问的地方。

这是在ORB-SLAM2基础上针对于动态场景进行改进的版本。利用MASK-RCNN提取场景中动态物体的语义信息，根据掩膜去掉误匹配，同时采用图像恢复技术进行场景恢复和建图，是比较优秀的SLAM算法。下面看看具体编译运行过程： 1、源码：https://github.com/BertaBescos/DynaSLAM 2、文章：DynaSLAM: Tracking, Mapping and Inpainting in Dynamic Scenes 3、下载源码： git clone https://github.com/BertaBescos/DynaSLAM.git 注意到源码中的CMakeLists使用的是python2.7，因此需要以python2.7安装MASK_RCNN相关依赖项。 我尝试过使用python3.5，但是将PyInstance_New()，函数替换为PyInstanceMethod_New()之后，PyObject_CallMethod()函数返回空，有兴趣的可以试试怎么用python3实现该代码。 4、下载MASK_RCNN源码 git clone https://github.com/matterport/Mask_RCNN.git cd Mask_RCNN 先安装tensorflow，用清华源比较快（带GPU版本，Python2.7）： sudo pip2 install --upgrade https://mirrors.tuna.tsinghua.edu.cn/tensorflow/linux/gpu/tensorflow_gpu-1.4.0rc1-cp27-none-linux_x86_64.whl 再安装keras ，版本太高会报错。 sudo pip2 install keras==2.0.8 然后将requirements.txt里面的tensorflow，keras去掉，不然装的就是高版本的。 sudo pip2 install -r requirements.txt 可以把MASK_RCNN安装一下： sudo python2 setup.py install 5、下载预先训练好的COCO模型权重mask_rcnn_coco.h5 ，将其放到DynaSLAM/src/python目录下，然后直接编译dynaSLAM ./bulid.sh 编译完成之后运行（RGBD例子）： ./Examples/RGB-D/rgbd_tum Vocabulary/ORBvoc.txt Examples/RGB-D/TUM3.yaml data/rgbd_dataset_freiburg3_walking_xyz data/rgbd_dataset_freiburg3_walking_xyz/associations.txt data/mask data/output 最后两个参数建一个空文件夹就行，会自动保存相关图片信息。 这里有一个bug，之前的代码不会保存深度图，需要在rgbd_tum.cc，141下面添加： vstrImageFilenamesD[ni].replace(0,6,""); 6、若是使用python2之后PyImport_ImportModule()，函数还是返回空，那么可能是python文件夹中将tab与空格混用以及函数定义中出现了一些缩进不匹配，导致错误。我是在这里下载的： https://download.csdn.net/download/qq_42938987/10769306 替换之后就可以了。 这篇博客的编译过程也写的很好：https://blog.csdn.net/qq_42938987/article/details/83795217 7、该算法运行速度较慢，实时性不是太好，是缺点之一！！！，下面放一张分割之后保存的图片

缓存的作用： 就是将一些常用的数据存储起来，以提供使用，提高性能。 网站静态页面缓存机制： 将网页静态化存储在服务器端， 利用缓存解决递归斐波那契数列性能问题： function createFib(){ var cache = []; function fib(n){ //从cache中获取 if(cache[n] !== undefined){ //如果缓存中有，直接返回 return cache[n] } //如果缓存中没有，则重新计算 if(n <=2){ cache[n]=1; return 1; } var temp = fib(n-1)+ fib(n-2); //放入缓存 cache[n]=temp; return temp; } return fib; } var fib = createFib(); console.log(fib(6)); 封装创建缓存的方法： function createCache(){ //cache对象中以键值对的形式存储我们的缓存数据 var cache = {}; //index数组中该存储键，这个键是有顺序，可以方便我们做超出容量的处理 var index = []; return function (key, value) { //如果传了值，就说名是设置值 if(value !== undefined){ //将数据存入cache对象，做缓存 cache[key] = value; //将键存入index数组中，以和cache中的数据进行对应 index.

Example类的使用 Example类的成员： 1.升序还是降序:字段+空格+asc(desc) protected String orderByClause; 2.去除重复:true是选择不重复记录,false,反之 protected boolean distinct; 3.自定义查询条件 protected List<Criteria> oredCriteria; 例子： @Test public void testFindUserByName(){ SysUserExample example = new SysUserExample(); example.setOrderByClause("create_time asc"); example.setDistinct(false); //去除重复,true是选择不重复记录,false反之 example.Criteria criteria = example.createCriteria(); //构造自定义查询条件 criteria.andUsernameEqualTo("张三"); //自定义查询条件可能返回多条记录,使用List接收 List<User> users = userMapper.selectByExample(example); System.out.println(users); } 结果： 测试结果(数据库中有两个username为张三): DEBUG [main] - ==> Preparing: select id, username, birthday, sex, address from user WHERE ( username = ? ) order by username asc DEBUG [main] - ==> Parameters: 张三(String) DEBUG [main] - <== Total: 2 DEBUG [main] - Closing non transactional SqlSession [org.

转载： 作者：龚世伟 链接：https://www.zhihu.com/question/49536781/answer/117606933 来源：知乎 库、框架、插件、加载项、扩展和控件都是组件。 组件(Component)是是一个含义很大的概念，一般是指软件系统的一部分，承担了特定的职责，可以独立于整个系统进行开发和测试，一个良好设计的组件应该可以在不同的软件系统中被使用(可复用)。例如V8引擎是Chrome浏览器的一部分，负责运行javascript代码，这里V8引擎就可以视为一个组件。V8引擎同时也是Node.js的javascript解释器，这体现了组件的可复用性。 库(Library)是一系列预先定义好的数据结构和函数(对于面向对象语言来说，是类)的集合，程序员通过使用这些数据结构和函数实现功能。例如Moment.js是一个javascript库，提供了处理时间的一些函数。 框架(Framework)也是一系列预先定义好的数据结构和函数，一般用于作为一个软件的骨架，但程序真正的功能还需要由开发者实现。框架和库的最大区别在于“控制反转”，当你使用一个库，你会调用库中的代码，而当你使用一个框架，框架会调用你的代码。框架和库是一个有交叉的概念，很多框架都是以库的形式发布的，例如Java的Spring MVC框架，其发布的jar包本身就是一个库。而一个库如果也能通过依赖反转的方式进行扩展，那也可以视为一个框架，例如Python的markdown解析库Python Markdown，可以添加自定义的解析扩展，那么可以被视为一个markdonw解析框架。 下面这张图出自这篇博客Library vs. Framework?，从调用方式的角度比较了库和框架。 插件(Plugin)和扩展(extension)是两个很相似的概念，我没有办法在软件系统的角度给出这二者的区别。插件(或扩展)是对已有应用程序或者库的功能补充，一个软件的插件(或扩展)是实现了该软件预定义接口的组件，用来向已有的软件添加功能。插件在目标软件发布时可以不预先包含，而是在运行时被使用者注册，然后再被目标软件调用。另一个很接近的概念是加载项(Add-on)，可以认为加载项是插件(或扩展)的子集，是仅针对应用程序来说的功能补充。一个插件的例子是Flash的浏览器插件，为浏览器实现了运行Flash程序的功能。 控件(Control)是gui编程的一个概念，一般来说一个最终用户可以看到的、可交互的组件，被称为一个控件。例如.NET编程中的System.Windows.Controls.Button是一个控件。 转载于:https://www.cnblogs.com/weew12/p/10583048.html

NSRange本身是个结构体，里面有两个属性location（起始位置）和length（长度），如下 NS_INLINE NSRange NSMakeRange(NSUInteger loc, NSUInteger len) { NSRange r; r.location = loc; r.length = len; return r; } 我们应用NSRange最多的地方就是字符串的截取与查找，例如： NSString *str = @"Let's learn NSRange"; //创建方式一 NSRange range1 = {2,4}; //创建方式二 NSRange range2 = NSMakeRange(2, 5); //截取字符串 NSLog(@"%@", [str substringWithRange:range1]); NSLog(@"%@", [str substringWithRange:range2]); //查找字符串 NSRange range3 = [str rangeOfString: @"le"]; NSLog(@"range:%@", NSStringFromRange(range3)); NSRange range4 = [str rangeOfString:@"go"]; NSLog(@"range:%@", NSStringFromRange(range4)); 注意：1.当你进行字符串截取时，要注意字符串的长度，防止起始位置超过字符串长度或截取的长度超过字符串长度而导致越界闪退，这里苹果没有帮我们处理，需要我们自己判断。 2.在字符串查找时匹配的始终是第一个相符的字符串，然后返回第一个NSRange。如果没有匹配到相符的字符串，这里苹果帮我们处理了，返回的是{9223372036854775807, 0}，显然length为0，前面一大串数字不需要管，它表示int64的最大值。 3.当你使用查找字符串方法时，返回的始终是匹配到的第一个，但是如果原字符串里面有多个的相符的，而且你都想匹配出来，这个方法是做不到的。

dir 跟我一起写makefile by 陈豪，p33 取目录函数——dir 解释： 从文件名序列<names>中取出目录部分。目录部分是指最后一个反斜杠（“/”）之前的部分 示例： $(dir src/foo.c hacks)返回值是“src/, ./”。

2、使用普通的insert into on conflict合并写入，存在写入放大思路： 大量数据，批量插入到数据表中时，很容易造成主键冲突，重复数据有唯一约束插入不进去表中，报错的问题出现。 排查错误，去找某条数据，在大量的数据，大量的批处理或者单条执行的sql语句中找数据也是不现实的。 所以思路就是在插入的过程中，不仅单单插入，同时判断是否主键或唯一冲突。若冲突，则将插入操作改成对重复数据的更新操作。 PostgreSQL , 合并写 , insert on conflict , 不必要更新 例子： 1，如下面的一张表，往下面的一张表中插入数据 create table tbl( c1 int, c2 int, c3 int, c4 int, c5 timestamp, unique (c1,c2) ); 2、使用普通的insert into on conflict合并写入，存在写入放大 insert into tbl select id,id,1,random(),now() from generate_series(1,1000000) t(id) on conflict(c1,c2) do update set c3=excluded.c3,c4=excluded.c4,c5=excluded.c5; 每一次操作都会更新所有记录 3、优化方法，加入更新条件，避免未变化的记录被更新 例如当c3,c4没有变化时，不更新。 where tbl.c3 is distinct from excluded.c3 or tbl.c4 is distinct from excluded.c4; 完整SQL如下 ：

我们在项目中会遇到这样的问题，有一些数据库表是不需要的，这时候就涉及到删除表操作，一张一张删除肯定会不耐烦，尤其是在二次开发中，这时候就要考虑批量删除了 这里拿最近做的项目举个例子： 我需要删除数据库yzyxcx_taokeapp中表前缀是hjmall_的表，将近100张表 -- 删除数据库名为yzyxcx_taokeapp'数据库的以hjmall_开头的所以表 select CONCAT( 'drop table ', table_name, ';' ) FROM information_schema.tables where table_name REGEXP 'hjmall_' and table_schema='yzyxcx_taokeapp' into outfile '/tmp/mysql/backup/del.sql'; where条件中可以用正则匹配，也可以用like -- 删除数据库名为yzyxcx_taokeapp'数据库的以hjmall_开头的所以表 SELECT CONCAT('drop table ',t.`TABLE_NAME`,'; ') dropsql FROM information_schema.`TABLES` t WHERE t.`TABLE_NAME` LIKE 'hjmall_%' AND t.table_schema='yzyxcx_taokeapp'; 之后直接运行del.sql就可以了 source del.sql

windows10下的工作站搭建: cuda10 + tensorflow-gpu1.12.0 + cudnn 7.4 +PyCharm2018 安装cuda：开发工具 PyCharm的破解激活这一章节就结束了。。。。。 安装cuda： 首先你需要先确定自己的显卡的型号适合的cuda toolkit.一般的做法是： 控制面板，在控制面板上搜索nv,就出来英伟达的控制面板了。在控制面板中找到 系统信息 点击进入对应的界面。 点击组件按钮，可以看到，支持的最新的cuda版本就是NVCUDA.DLL 文件对应的那个cuda 10 到英伟达的官网下载并安装好cuda。下载cuda 10 。同时，给出各个版本的下载地址： 历史版本下载地址 。下载安装就行，可以自己选择安装的目录等，一般直接安装在系统盘比较好。安装之后会自动的增加系统的环境变量。可以自行查看。如下图： 可以打开cmd 输入 nvcc -V 如果输出对应的信息表示安装成功。下载对应版本的cudnn：根据自己的cuda版本，下载对应的cudnn，点我下载 。进到网址，根据对应的提示下载。**注意，如果是第一次使用的话，会要求你先注册，你就从了吧。。。。**好好做人，注册一个账号，就可以下载啦啦啦。下载完成之后，将cudnn解压，然后可以看到有三个文件夹。 分别将里面的文件复制到安装 cuda 的文件夹中，对应的文件夹下面。对应的关系如下图。： 1.cudnn \ bin \ cudnn64_7.dll -----> C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0\bin 2.cudnn \ include \ cudnn.h ----> C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0\include 3.cudnn \ lib \x64 \cudnn.lib ---> C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0\lib\x64 4. 注意自己的安装路径。。。。 常见的网址分享：