思维导图

事件循环

浏览器的进程模型

何为进程？

程序运行需要有它自己专属的内存空间，可以把这块内存空间简单的理解为进程

每个应用至少有一个进程，进程之间相互独立，即使要通信，也需要双方同意。

何为线程？

有了进程后，就可以运行程序的代码了。

运行代码的「人」称之为「线程」。

一个进程至少有一个线程，所以在进程开启后会自动创建一个线程来运行代码，该线程称之为主线程。

如果程序需要同时执行多块代码，主线程就会启动更多的线程来执行代码，所以一个进程中可以包含多个线程。

浏览器有哪些进程和线程？

浏览器是一个多进程多线程的应用程序

浏览器内部工作极其复杂。

为了避免相互影响，为了减少连环崩溃的几率，当启动浏览器后，它会自动启动多个进程。

可以在浏览器的任务管理器中查看当前的所有进程

其中，最主要的进程有：

1. 浏览器进程

   主要负责界面显示、用户交互、子进程管理等。浏览器进程内部会启动多个线程处理不同的任务。

2. 网络进程

   负责加载网络资源。网络进程内部会启动多个线程来处理不同的网络任务。

3. 渲染进程（本节课重点讲解的进程）

   渲染进程启动后，会开启一个渲染主线程，主线程负责执行 HTML、CSS、JS 代码。

   默认情况下，浏览器会为每个标签页开启一个新的渲染进程，以保证不同的标签页之间不相互影响。

   将来该默认模式可能会有所改变，有兴趣的同学可参见chrome官方说明文档

渲染主线程是如何工作的？

渲染主线程是浏览器中最繁忙的线程，需要它处理的任务包括但不限于：

• 解析 HTML
• 解析 CSS
• 计算样式
• 布局
• 处理图层
• 每秒把页面画 60 次
• 执行全局 JS 代码
• 执行事件处理函数
• 执行计时器的回调函数
• ……

思考题：为什么渲染进程不适用多个线程来处理这些事情？

要处理这么多的任务，主线程遇到了一个前所未有的难题：如何调度任务？

比如：

• 我正在执行一个 JS 函数，执行到一半的时候用户点击了按钮，我该立即去执行点击事件的处理函数吗？
• 我正在执行一个 JS 函数，执行到一半的时候某个计时器到达了时间，我该立即去执行它的回调吗？
• 浏览器进程通知我“用户点击了按钮”，与此同时，某个计时器也到达了时间，我应该处理哪一个呢？
• ……

渲染主线程想出了一个绝妙的主意来处理这个问题：排队

1. 在最开始的时候，渲染主线程会进入一个无限循环
2. 每一次循环会检查消息队列中是否有任务存在。如果有，就取出第一个任务执行，执行完一个后进入下一次循环；如果没有，则进入休眠状态。
3. 其他所有线程（包括其他进程的线程）可以随时向消息队列添加任务。新任务会加到消息队列的末尾。在添加新任务时，如果主线程是休眠状态，则会将其唤醒以继续循环拿取任务

这样一来，就可以让每个任务有条不紊的、持续的进行下去了。

整个过程，被称之为事件循环（消息循环）

若干解释

何为异步？

代码在执行过程中，会遇到一些无法立即处理的任务，比如：

• 计时完成后需要执行的任务 —— setTimeout、setInterval
• 网络通信完成后需要执行的任务 – XHR、Fetch
• 用户操作后需要执行的任务 – addEventListener

如果让渲染主线程等待这些任务的时机达到，就会导致主线程长期处于「阻塞」的状态，从而导致浏览器「卡死」

渲染主线程承担着极其重要的工作，无论如何都不能阻塞！

因此，浏览器选择异步来解决这个问题

使用异步的方式，渲染主线程永不阻塞

面试题：如何理解 JS 的异步？

参考答案：

JS是一门单线程的语言，这是因为它运行在浏览器的渲染主线程中，而渲染主线程只有一个。

而渲染主线程承担着诸多的工作，渲染页面、执行 JS 都在其中运行。

如果使用同步的方式，就极有可能导致主线程产生阻塞，从而导致消息队列中的很多其他任务无法得到执行。这样一来，一方面会导致繁忙的主线程白白的消耗时间，另一方面导致页面无法及时更新，给用户造成卡死现象。

所以浏览器采用异步的方式来避免。具体做法是当某些任务发生时，比如计时器、网络、事件监听，主线程将任务交给其他线程去处理，自身立即结束任务的执行，转而执行后续代码。当其他线程完成时，将事先传递的回调函数包装成任务，加入到消息队列的末尾排队，等待主线程调度执行。

在这种异步模式下，浏览器永不阻塞，从而最大限度的保证了单线程的流畅运行。

JS为何会阻碍渲染？

先看代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<h1>Mr.Yuan is awesome!</h1>
<button>change</button>
<script>
  var h1 = document.querySelector('h1');
  var btn = document.querySelector('button');

  // 死循环指定的时间
  function delay(duration) {
    var start = Date.now();
    while (Date.now() - start < duration) {}
  }

  btn.onclick = function () {
    h1.textContent = '袁老师很帅！';
    delay(3000);
  };
</script>

点击按钮后，会发生什么呢？

<见具体演示>

任务有优先级吗？

任务没有优先级，在消息队列中先进先出

但消息队列是有优先级的

根据 W3C 的最新解释:

• 每个任务都有一个任务类型，同一个类型的任务必须在一个队列，不同类型的任务可以分属于不同的队列。
  在一次事件循环中，浏览器可以根据实际情况从不同的队列中取出任务执行。
• 浏览器必须准备好一个微队列，微队列中的任务优先所有其他任务执行
  https://html.spec.whatwg.org/multipage/webappapis.html#perform-a-microtask-checkpoint

随着浏览器的复杂度急剧提升，W3C 不再使用宏队列的说法

在目前 chrome 的实现中，至少包含了下面的队列：

• 延时队列：用于存放计时器到达后的回调任务，优先级「中」
• 交互队列：用于存放用户操作后产生的事件处理任务，优先级「高」
• 微队列：用户存放需要最快执行的任务，优先级「最高」

添加任务到微队列的主要方式主要是使用 Promise、MutationObserver

例如：

1 2	// 立即把一个函数添加到微队列 Promise.resolve().then(函数)

浏览器还有很多其他的队列，由于和我们开发关系不大，不作考虑

面试题：阐述一下 JS 的事件循环

参考答案：

事件循环又叫做消息循环，是浏览器渲染主线程的工作方式。

在 Chrome 的源码中，它开启一个不会结束的 for 循环，每次循环从消息队列中取出第一个任务执行，而其他线程只需要在合适的时候将任务加入到队列末尾即可。

过去把消息队列简单分为宏队列和微队列，这种说法目前已无法满足复杂的浏览器环境，取而代之的是一种更加灵活多变的处理方式。

根据 W3C 官方的解释，每个任务有不同的类型，同类型的任务必须在同一个队列，不同的任务可以属于不同的队列。不同任务队列有不同的优先级，在一次事件循环中，由浏览器自行决定取哪一个队列的任务。但浏览器必须有一个微队列，微队列的任务一定具有最高的优先级，必须优先调度执行。

面试题：JS 中的计时器能做到精确计时吗？为什么？

参考答案：

不行，因为：

1. 计算机硬件没有原子钟，无法做到精确计时
2. 操作系统的计时函数本身就有少量偏差，由于 JS 的计时器最终调用的是操作系统的函数，也就携带了这些偏差
3. 按照 W3C 的标准，浏览器实现计时器时，如果嵌套层级超过 5 层，则会带有 4 毫秒的最少时间，这样在计时时间少于 4 毫秒时又带来了偏差
4. 受事件循环的影响，计时器的回调函数只能在主线程空闲时运行，因此又带来了偏差

CMD

文件树

tree /f

组策略

1	gpedit.msc

防火墙

1	netsh advfirewall set allprofiles state off

服务

1	services.msc

设备管理器

1	devmgmt.msc

证书

1	certmgr.msc

注册表

1

regedit

IP地址检测

1

Nslookup

计算机管理

1	compmgmt.msc

windows版本

1

winver

系统组件服务

1

dcomcnfg

监控TCP/IP

1	netstat -ano

网路连接记录

1

net use

本地安全策略

1	secpol.msc

文件粉碎

1 2	cacls "D:\test*" /T /E /C /G everone:F # D:\test 文件绝对路径 * 目录下所有 rd "D:\test" /s /q

WIfi信息

1 2	netsh wlan show profile netsh wlan show profile name="ssid" key=clear

ssid: 为wifi名称

隐藏文件

1 2	attrib +s +h +r +a f:\\logo.ico attrib +s +h +r +a f:\\autorun.inf

显示文件

1 2	attrib -s -h -r -a f:\\logo.ico attrib -s -h -r -a f:\\autorun.inf

一、系统管理命令

• 1.taskmgr - 打开任务管理器，监视进程和内存使用。
• 2.sfc /scannow - 检查并修复系统文件。
• 3.eventvwr - 打开事件查看器，查看系统日志。
• 4.gpedit.msc - 配置系统的组策略。
• 5.regedit - 打开注册表编辑器。
• 6.hostname - 查看本机计算机名。
• 7.systeminfo - 显示系统的详细信息。
• 8.msconfig - 打开系统配置工具。
• 9.dxdiag - 检查 DirectX 信息。
• 10.winver - 查看当前 Windows 版本信息。
• 11.logoff - 注销当前用户。
• 12.shutdown /s /t 60 - 60 秒后关机。
• 13.shutdown /r /t 60 - 60 秒后重启。
• 14.slmgr.vbs -dli - 检查当前激活信息。
• 15.cmdkey /list - 查看存储的凭据。

二、网络管理命令

• 16.ipconfig - 查看当前网络信息。
• 17.ipconfig /flushdns - 清空本地 DNS 缓存。
• 18.ping [IP/域名] - 测试网络连通性。
• 19.tracert [域名] - 跟踪路由。
• 20.nslookup - 查询 DNS 记录。
• 21.netstat -an - 查看当前网络连接。
• 22.arp -a - 查看 ARP 表。
• 23.netsh wlan show profiles - 查看保存的 Wi-Fi 信息。
• 24.netsh wlan show drivers - 查看无线网络的驱动信息。
• 25.route print - 显示路由表。
• 26.telnet [IP] [端口] - 测试远程端口连通性。
• 27.ftp - FTP 文件传输工具。
• 28.net use - 连接到共享文件夹。
• 29.mstsc - 打开远程桌面连接。
• 30.netsh winsock reset - 重置网络适配器。
• 31.pathping [域名/IP] - 路由追踪工具，类似 tracert。
• 32.net start - 查看正在运行的网络服务。
• 33.net stop - 停止指定的服务。

三、文件和磁盘管理命令

• 34.dir - 查看当前文件夹下的文件和子目录。
• 35.cd [路径] - 切换到指定目录。
• 36.mkdir [目录名] - 创建一个新目录。
• 37.rmdir /s /q [目录名] - 删除目录及其内容。
• 38.del [文件名] - 删除指定文件。
• 39.copy [源文件] [目标文件/目录] - 复制文件。
• 40.move [源文件] [目标文件/目录] - 移动文件。
• 41.robocopy [源目录] [目标目录] - 高级文件复制工具。
• 42.attrib - 查看或修改文件属性。
• 43.chkdsk [盘符]: - 检查磁盘错误。
• 44.diskpart - 打开磁盘管理工具。
• 45.cleanmgr - 打开磁盘清理工具。
• 46.format [盘符]: /fs:ntfs - 格式化磁盘为 NTFS 格式。
• 47.fsutil fsinfo drives - 查看所有驱动器。
• 48.fsutil quota track [盘符]: - 启用磁盘空间配额管理。
• 49.vol [盘符]: - 查看卷标和序列号。
• 50.tree - 以树型结构显示目录结构。
• 51.xcopy [源路径] [目标路径] /s - 递归复制文件夹。
• 52.compact /c - 压缩指定文件或目录。
• 53.cipher /e - 加密当前目录中的所有文件。

四、进程与服务管理命令

• 54.tasklist - 查看当前所有运行的进程。
• 55.taskkill /im [进程名] /f - 强制终止某个进程。
• 56.sc query - 查看服务状态。
• 57.sc start [服务名] - 启动某个服务。
• 58.sc stop [服务名] - 停止某个服务。
• 59.wmic process get name - 查看当前进程详情。
• 60.wmic service list brief - 列出所有服务概览。
• 61.services.msc - 打开服务管理控制台。
• 62.perfmon.msc - 打开性能监视器。

五、本地用户和组管理命令

• 63.net user - 查看所有用户列表。
• 64.net user [用户名] [密码] /add - 创建一个新用户。
• 65.net user [用户名] /del - 删除用户。
• 66.net localgroup - 查看所有组。
• 67.net localgroup [组名] [用户名] /add - 将用户添加到某个组。
• 68.net localgroup administrators [用户名] /add - 提升为管理员权限。
• 69.control userpasswords2 - 打开用户账户设置。
• 70.lusrmgr.msc - 打开本地用户和组管理界面。

六、安全和设置管理命令

• 71.secpol.msc - 打开本地安全策略。
• 72.rsop.msc - 获取组策略结果集。
• 73.sigverif - 验证系统文件的数字签名。
• 74.syskey - 启用系统加密。
• 75.cipher /w:[路径] - 擦除硬盘数据，使其不可恢复。
• 76.auditpol - 显示安全审计策略。

七、快捷工具命令

• 77.calc - 打开计算器工具。
• 78.notepad - 打开记事本。
• 79.mspaint - 打开画图工具。
• 80.osk - 打开屏幕键盘。
• 81.snippingtool - 打开截图工具。
• 82.charmap - 启动字符映射表。
• 83.magnify - 打开放大镜。
• 84.write - 打开写字板。

八、系统信息与状态检查

• 85.echo %username% - 显示当前登录的用户名。
• 86.whoami - 显示当前用户的完整身份信息。
• 87.set - 显示当前系统环境变量。
• 88.path - 查看或修改系统 PATH 变量。
• 89.systeminfo | findstr /B /C:”OS Name” - 查看系统名称。
• 90.powercfg /batteryreport - 生成电池性能报告。
• 91.query user - 查看当前登录的所有用户。
• 92.fsutil dirty query [盘符]: - 检查磁盘是否被标记为脏。
• 93.driverquery - 查看当前系统中所有驱动程序。
• 94.schtasks - 管理计划任务。

九、常见命令组合（高频操作）

• 95.ipconfig /all > network.txt - 将网络配置信息保存到文件。
• 96.dir /s /p > files.txt - 保存目录结构到文件。
• 97.tasklist | find “chrome” - 查找含特定名称的进程。
• 98.ping -t [IP地址] - 持续 ping 测试网络连通性。
• 99.netstat -an | find “LISTENING” - 查看所有监听端口。
• 100.shutdown /a - 中止当前的关机操作。

spring boot

spring boot cache

Cacheable注解配置的两项参数说明：

value：缓存的名称，缓存名称作为缓存key的前缀。

key: 缓存key，支持SpEL表达式，上述代码表示取参数id的值作为key

最终缓存key为：缓存名称+“::”+key，例如：上述代码id为123,最终的key为：JZ_CACHE:SERVE_RECORD::123

SpEL（Spring Expression Language）是一种在 Spring 框架中用于处理字符串表达式的强大工具，它可以实现获取对象的属性，调用对象的方法操作。

keyGenerator：指定一个自定义的键生成器（实现 org.springframework.cache.interceptor.KeyGenerator 接口的类），用于生成缓存的键。与 key 属性互斥，二者只能选其一。

unless：

1 2 3 4 5

// 返回数据为空 缓存 // unless true 不缓存 // @Cacheable(value = "", key = "", cacheManager = "", unless = "#result.size() != 0") // 返回数据不为空 缓存 // @Cacheable(value = "", key = "", cacheManager = "", unless = "#result.size() == 0")

1
2
3
4
5
6
7
8
9
10
11
12
13

@EnableCaching：开启缓存注解功能
    
@Cacheable：查询数据时缓存，将方法的返回值进行缓存。
    // 缓存key，支持SpEL表达式(spring boot 提供 ，支持 取对象属性及执行属性方法)，上述代码表示取参数id的值作为key
    // 最终缓存key为：缓存名称+“::”+key
    @Cacheable(value = RedisConstants.CacheName.SERVE, key = "#id", cacheManager = 
                RedisConstants.CacheManager.ONE_DAY)
    /**
     * 缓存时间1天 方法名
    */
     public static final String ONE_DAY = "cacheManagerOneDay";

sping cache RedisCacheManager 方法：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123

package com.jzo2o.redis.config; import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.JsonTypeInfo; import com.fasterxml.jackson.annotation.PropertyAccessor; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator; import com.fasterxml.jackson.databind.module.SimpleModule; import com.fasterxml.jackson.databind.ser.std.ToStringSerializer; import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer; import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer; import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer; import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer; import com.jzo2o.common.utils.DateUtils; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Primary; import org.springframework.data.redis.cache.RedisCacheConfiguration; import org.springframework.data.redis.cache.RedisCacheManager; import org.springframework.data.redis.connection.RedisConnectionFactory; import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer; import org.springframework.data.redis.serializer.RedisSerializationContext; import java.math.BigInteger; import java.time.Duration; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; import java.util.Random; /** * SpringCache配置 * * @author itcast * @create 2023/8/15 10:04 **/ @Configuration public class SpringCacheConfig { /** * 缓存时间30分钟 * * @param connectionFactory redis连接工厂 * @return redis缓存管理器 */ @Bean public RedisCacheManager cacheManager30Minutes(RedisConnectionFactory connectionFactory) { int randomNum = new Random().nextInt(100); RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig() .entryTtl(Duration.ofSeconds(30 * 60L + randomNum)) .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(JACKSON_SERIALIZER)); return RedisCacheManager.builder(connectionFactory) .cacheDefaults(config) .transactionAware() .build(); } /** * 缓存时间1天 * * @param connectionFactory redis连接工厂 * @return redis缓存管理器 */ @Bean public RedisCacheManager cacheManagerOneDay(RedisConnectionFactory connectionFactory) { //生成随机数 int randomNum = new Random().nextInt(6000); RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig() //过期时间为基础时间加随机数 .entryTtl(Duration.ofSeconds(24 * 60 * 60L + randomNum)) .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(JACKSON_SERIALIZER)); return RedisCacheManager.builder(connectionFactory) .cacheDefaults(config) .transactionAware() .build(); } /** * 永久缓存 * * @param connectionFactory redis连接工厂 * @return redis缓存管理器 */ @Bean @Primary public RedisCacheManager cacheManagerForever(RedisConnectionFactory connectionFactory) { RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig() .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(JACKSON_SERIALIZER)); return RedisCacheManager.builder(connectionFactory) .cacheDefaults(config) .transactionAware() .build(); } private static final Jackson2JsonRedisSerializer<Object> JACKSON_SERIALIZER; static { //定义Jackson类型序列化对象 JACKSON_SERIALIZER = new Jackson2JsonRedisSerializer<>(Object.class); //解决查询缓存转换异常的问题 ObjectMapper om = new ObjectMapper(); // SimpleModule对象，添加各种序列化器和反序列化器。解决LocalDateTime、Long序列化异常 SimpleModule simpleModule = new SimpleModule() // 添加反序列化器 .addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DateUtils.DEFAULT_DATE_TIME_FORMAT))) .addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DateUtils.DEFAULT_DATE_FORMAT))) // 添加序列化器 .addSerializer(BigInteger.class, ToStringSerializer.instance) .addSerializer(Long.class, ToStringSerializer.instance) // 实现 Long --> String 的序列化器 .addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DateUtils.DEFAULT_DATE_TIME_FORMAT))) .addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DateUtils.DEFAULT_DATE_FORMAT))); om.registerModule(simpleModule); om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL , JsonTypeInfo.As.WRAPPER_ARRAY); JACKSON_SERIALIZER.setObjectMapper(om); } }

工作原理

Spring Cache是基于AOP原理，对添加注解@Cacheable的类生成代理对象，在方法执行前查看是否有缓存对应的数据，如果有直接返回数据，如果没有调用源方法获取数据返回，并缓存起来，下边跟踪Spring Cache的切面类CacheAspectSupport.java中的private Object execute(final CacheOperationInvoker invoker, Method method, CacheOperationContexts contexts)方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

  @Nullable
  private Object execute(final CacheOperationInvoker invoker, Method method, CacheOperationContexts contexts) {
...
      Object cacheValue;
      Object returnValue;
      if (cacheHit != null && !this.hasCachePut(contexts)) {
          cacheValue = cacheHit.get();
          returnValue = this.wrapCacheValue(method, cacheValue);
      } else {
          returnValue = this.invokeOperation(invoker);
          cacheValue = this.unwrapReturnValue(returnValue);
      }

      this.collectPutRequests(contexts.get(CachePutOperation.class), cacheValue, cachePutRequests);
      Iterator var8 = cachePutRequests.iterator();

      while(var8.hasNext()) {
          CachePutRequest cachePutRequest = (CachePutRequest)var8.next();
          cachePutRequest.apply(cacheValue);
      }

      this.processCacheEvicts(contexts.get(CacheEvictOperation.class), false, cacheValue);
      return returnValue;
  }

1
2
3
4

@CacheEvict：用于删除缓存，将一条或多条数据从缓存中删除。
@CachePut：用于更新缓存，将方法的返回值放到缓存中
@Caching：组合多个缓存注解；
@CacheConfig：统一配置@Cacheable中的value值

缓存穿透

大量用户访问一个不存在的资源

查询一个缓存中不存在的数据将会执行方法查询数据库，数据库也不存在此数据，查询完数据库也没有缓存数据，缓存没有起到作用。

解决方案

1. 访问数据库不存在的资源时，缓存一个空值或特殊值

   1 2 3 4 5 6 7 8 9

   @Cacheable( value = "users", key = "#id", unless = "#result == null" // 默认不缓存null，需要特殊处理 ) public User getUserById(Long id) { User user = userRepository.findById(id).orElse(null); return user != null ? user : new NullUser(); // 返回特殊空对象 }

2. 布隆过滤器

   布隆过滤器（Bloom Filter）是一种数据结构，用于快速判断一个元素是否属于一个集合中。

   它使用多个Hash函数将一个元素映射成一个位阵列（Bit array）中的一个点，将Bit array理解为一个二进制数组，数组元素是0或1。

   常见框架：

   • 使用redit的bitmap位图结构实现。

   • redisson

   • google的Guava库实现。

3. 请求校验

缓存击穿

访问热点数据，大量访问同一个热点数据，当热点数据失效后同时请求数据库，数据库宕机。

解决方案

• 单体架构下（单进程内）可以使用同步锁控制查询数据库的代码，只允许有一个线程去查询数据库，查询得到数据库存入缓存。
• 分布式架构下（多个进程之间）可以使用分布式锁进行控制。

1. 分布式锁

   redisson

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

   // 获取分布式锁对象 RLock lock = redisson.getLock("myLock"); try { // 尝试加锁，最多等待100秒，加锁后自动解锁时间为30秒 boolean isLocked = lock.tryLock(100, 30, java.util.concurrent.TimeUnit.SECONDS); if (isLocked) { //查询数据库 //存入缓存 } else { System.out.println("获取锁失败，可能有其他线程持有锁"); } } catch (InterruptedException e) { e.printStackTrace(); } finally { // 释放锁 lock.unlock(); System.out.println("释放锁..."); }

2. 缓存预热

   • 提前预热
   • 定时预热

3. 热点数据查询降级处理

   对热点数据查询定义单独的接口，当缓存中不存在时走降级方法避免查询数据库。

缓存雪崩

缓存雪崩是缓存中大量key失效后当高并发到来时导致大量请求到数据库，瞬间耗尽数据库资源，导致数据库无法使用。

比如对某信息设置缓存过期时间为30分钟，在大量请求同时查询该类信息时，此时就会有大量的同类信息存在相同的过期时间，一旦失效将同时失效，造成雪崩问题。

解决方案

1. 使用锁控制

   同 缓存击穿

2. 对同一类型信息的key设置不同的过期时间

   具体实现：在framework工程中定义缓存管理器指定过期时间加上随机数

3. 缓存定时预热

   不用等到请求到来再去查询数据库存入缓存，可以提前将数据存入缓存。使用缓存预热机制通常有专门的后台程序去将数据库的数据同步到缓存。

缓存不一致

写数据库，写缓存（redis）不一致，双写不一致

解决方案

1. 分布式锁

   流程：

   线程1申请分布式锁，拿到锁。此时其它线程无法获取同一把锁。

   线程1写数据库，写缓存，操作完成释放锁。

   线程2申请分布锁成功，写数据库，写缓存。

   对双写的操作每个线程顺序执行。

   对操作异常问题仍需要解决：写数据库成功写缓存失败了，数据库需要回滚，此时就需要使用分布式事务组件。

   使用分布式锁解决双写一致性不仅性能低下，复杂度增加。

2. 延迟双删

   线程1先删除缓存，再写入主数据库，延迟一定时间再删除缓存。

   保证 最终一致

   

主从数据库

MySQL主从集群由MySQL主服务器(master)和MySQL从服务器(slave)组成，MySQL主从数据同步是一种数据库复制技术，进行写数据会先向主服务器写，写成功后将数据同步到从服务器，流程如下：

1、主服务器将所有写操作（INSERT、UPDATE、DELETE）以二进制日志（binlog）的形式记录下来。

2、从服务器连接到主服务器，发送dump 协议,请求获取主服务器上的binlog日志。

MySQL的dump协议是MySQL复制协议中的一部分。

3、MySQL master 收到 dump 请求，开始推送 binary log 给 slave

4、从服务器解析日志，根据日志内容更新从服务器的数据库，完成从服务器的数据保持与主服务器同步。

Canal

Canal是什么？

**canal [kə’næl]**，译意为水道/管道/沟渠，主要用途是基于 MySQL 数据库增量日志解析，对数据进行同步，如下图：

Canal可与很多数据源进行对接，将数据由MySQL同步到ES、MQ、DB等各个数据源。

Canal的意思是水道/管道/沟渠，它相当于一个数据管道，通过解析MySQL的binlog日志完成数据同步工作。

官方文档：https://github.com/alibaba/canal/wiki

工作流程

1、Canal模拟 MySQL slave 的交互协议，伪装自己为 MySQL slave ，向 MySQL master 发送dump 协议

MySQL的dump协议是MySQL复制协议中的一部分。

2、MySQL master 收到 dump 请求，开始推送 binary log 给 slave (即 canal )

。一旦连接建立成功，Canal会一直等待并监听来自MySQL主服务器的binlog事件流，当有新的数据库变更发生时MySQL master主服务器发送binlog事件流给Canal。

3、Canal会及时接收并解析这些变更事件并解析 binary log

通过以上流程可知Canal和MySQL master主服务器之间建立了长连接。

Hexo

服务器Git部署

前提条件：本地ssh公匙（C:\Users\Reiki.ssh\id_rsa.pub），已配置服务器:

1 2 3

adduser git chmod 740 /etc/sudoers vim /etc/sudoers

在root ALL=(ALL) ALL 下面添加

1	git ALL=(ALL) ALL

改回权限，设置git用户密码

1 2	chmod 400 /etc/sudoers passwd git

1 2 3

su git mkdir ~/.ssh vim ~/.ssh/authorized_keys

粘贴 本地ssh公匙

本地测试

1	ssh -v git@111.1111.111.111

若免密登录，成功！

###准备两个目录

1.网站目录

1
2

mkdir /www/wwwroot/hexo
chmod -R 755 /www/wwwroot/hexo

2.git仓库目录

1
2
3

mkdir /home/git/repo
chown -R git:git /home/git/repo
chmod -R 755 /home/git/repo

创建git钩子

1
2

cd /home/git/repo
git init --bare hexo.git

创建钩子文件

1

vim /home/git/repo/hexo.git/hooks/post-receive

粘贴以下代码

1
2

#!/bin/bash
git --work-tree=/www/wwwroot/hexo --git-dir=/home/git/repo/hexo.git checkout -f

改权限钩子文件和两个目录

1
2
3
4
5

chown -R git:git /home/git/repo/hexo.git/hooks/post-receive
chmod +x /home/git/repo/hexo.git/hooks/post-receive

chown -R git:git /www/wwwroot/hexo
chown -R git:git /home/git/repo

本地配置

_config.yml

1
2
3
4
5

deploy:
  type: git
  repo: git@1.1.1.1:22/home/git/repo/hexo.git
  branch: master

注 1.1.1.1:22 为服务器IP + SSH访问端口

配置RSS

前置条件

1. 安装 hexo-generator-feed

   1	npm install hexo-generator-feed --save

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# rss 生成插件  hexo-generator-feed
feed:
    enable: true
    generator: true
    type: atom
    path: atom.xml
    limit: false
    hub:
    content: true
    # content_limit: 140
    # content_limit_delim: ' '
    order_by: -date
    # icon: icon.png
    # autodiscovery: true
    # template:


social:
    # 其他社交按钮
    RSS: /atom.xml || fa fa-rss
# 与配置文件 链接保持一致
    fas fa-rss: https://xxx.xx/atom.xml

本地启动推送

前置条件

1. 安装 NodeJs，可使用 NVM 进行管理

2. npm install -g hexo-cli

1
2

hexo clean
hexo g -d

主题升级

主题目录下

1
2
3

git stash
git pull
git stash pop

若git仓库不安全报错

1	git config --global --add safe.directory E:/blog/Hexo/themes/butterfly

JS 进阶

代码示例

1
2
3
4
5
6
7
8
9
10
11
12

(() => {
  let x, y
  try {
    throw new Error()
  } catch (x) {
    // x 为 catch 变量 y 为全局声明变量
    (x = 1), (y = 2)
    console.log(x) // 1
  }
  console.log(x) // undefined
  console.log(y) // 2
})()

catch 代码块接收参数 x。当我们传递参数时，这与之前定义的变量 x 不同。这个 x 是属于 catch 块级作用域的。

然后，我们将块级作用域中的变量赋值为 1，同时也设置了变量 y 的值。现在，我们打印块级作用域中的变量 x，值为 1。

catch 块之外的变量 x 的值仍为 undefined，y 的值为 2。当我们在 catch 块之外执行 console.log(x) 时，返回 undefined，y 返回 2。

1
2
3
4
5

let person = { name: "Lydia" };
const members = [person];
person = null;

console.log(members); // { name: "Lydia" }

首先我们声明了一个拥有name属性的对象 person。

然后我们又声明了一个变量members. 将首个元素赋值为变量person。当设置两个对象彼此相等时，它们会通过 引用 进行交互。但是当你将引用从一个变量分配至另一个变量时，其实只是执行了一个 复制 操作。（注意一点，他们的引用 并不相同!）

接下来我们让person等于null。

我们没有修改数组第一个元素的值，而只是修改了变量person的值，因为元素（复制而来）的引用与person不同。members的第一个元素仍然保持着对原始对象的引用。当我们输出members数组时，第一个元素会将引用的对象打印出来。

1

const num = parseInt("7*6", 10) // 7

只返回了字符串中第一个字母。设定了 进制 后 (也就是第二个参数，指定需要解析的数字是什么进制：十进制、十六机制、八进制、二进制等等……),parseInt 检查字符串中的字符是否合法。一旦遇到一个在指定进制中不合法的字符后，立即停止解析并且忽略后面所有的字符。

*就是不合法的数字字符。所以只解析到"7"，并将其解析为十进制的7. num的值即为7.

1
2
3
4
5

const name = "Lydia";
age = 21;

console.log(delete name); // false
console.log(delete age); // true

delete操作符返回一个布尔值：true指删除成功，否则返回false. 但是通过 var, const 或 let 关键字声明的变量无法用 delete 操作符来删除。

name变量由const关键字声明，所以删除不成功：返回 false. 而我们设定age等于21时，我们实际上添加了一个名为age的属性给全局对象。对象中的属性是可以删除的，全局对象也是如此，所以delete age返回true.

函数柯里化（Curry）：函数元（参数）降维技术

1
2
3
4
5
6
7
8
9
10
11

const a = (b, c) => b + c

//柯里化

const a1 = b => c => b + c      // a === a1

const curryAdd = curry((a, b, c) => a + b + c);

curryAdd(1)(2)(3); // 6

1
2
3
4
5
6
7
8
9
10
11
12
13

const curry = function(fn){ // bind(绑定) fn
    let length = fu.length; // bind length
    let params = []; // bind params
    return function partial(x){
        params.push(x)
        if(params.length == length){ // 递归终止条件
            return fu(...params); // use fn
        }else{
            return partial; // 返回函数 递归传参
        }
    }
    
}

1
2
3

[y] = [1, 2, 3, 4, 5];
// y === 1
// 解构赋值

1
2
3
4
5
6
7
8
9
10
11
12
13

// module.js 
export default () => "Hello world"
export const name = "Lydia"

// index.js 
import * as data from "./module"

console.log(data)
// 输出
{
    default: function default(),
    name: "Lydia",
}

类 是 构造函数 的 语法糖 如果用 构造函数 的方式重写 person 类则是：

1
2
3
4
5
6
7
8
9
10
11

// 类
class Preson{
    constructor(name) {
        this.name = name
    }
}

// 构造函数的方式重写
function Preson(name) {
    this.name = name
}

1
2
3
4
5
6
7
8
9
10
11

const myMap = new Map()
const myFunc = () => 'greeting'

myMap.set(myFunc, 'Hello world!')

//1
myMap.get('greeting')
//2
myMap.get(myFunc) 
//3
myMap.get(() => 'greeting')

当通过 set 方法添加一个键值对，一个传递给 set方法的参数将会是键名，第二个参数将会是值。在这个 case 里，键名为 函数 () => 'greeting'，值为'Hello world'。 myMap 现在就是 { () => 'greeting' => 'Hello world!' }。

1 是错的，因为键名不是 'greeting' 而是 () => 'greeting'。 3 是错的，因为我们给get 方法传递了一个新的函数。对象受 引用 影响。函数也是对象，因此两个函数严格上并不等价，尽管他们相同：他们有两个不同的内存引用地址。

创建一个新的变量 counterTwo 并将 counOne 的 引用地址 赋值给他（Two、One 指向内存同一个地址）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Counter {
constructor() {
this.count = 0;
}

increment() {
this.count++;
}
}

const counterOne = new Counter();
counterOne.increment();
counterOne.increment();

const counterTwo = counterOne; // 注意看内存图解 （下左)
counterTwo.increment(); // 下右

console.log(counterOne.count); // 3

事件循环机制**event loop**

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

const myPromise = Promise.resolve("Promise!");
function funcOne() {
    // 加入微任务队列
myPromise.then(res => res).then(res => console.log(res+'1'));
  myPromise.then(res => res).then(res => console.log(res+'2'));
myPromise.then(res => res).then(res => console.log(res+'3'));
// 加入宏任务队列
setTimeout(() => console.log("Timeout1!"), 0);
console.log("Last line1!");
}
async function funcTwo() {
  console.log('two');
    // 第一个 await 阻塞代码 先执行 
const res = await myPromise;
    // 继续执行script宏任务里的 同步代码
console.log(res+0);
    // 第二个 await 阻塞代码 加入微任务队列，开始执行微任务队列
  console.log(await res+4);
    // 加入宏任务队列
setTimeout(() => console.log("Timeout2!"), 0);
console.log("Last line2!");
    // 第三个 await 阻塞代码 同第二个await
    console.log(await res+5);
  console.log("Last line3!");
}
funcOne();
funcTwo(); 
// Last line1! two 
// Promise!0(第一个 await 开始执行微任务队列任务，阻塞后面代码，先执行)  微任务队列
// Promise!1  Promise!2  Promise!3  
// Promise!4  微任务队列
// Last line2! 
// Promise!5  微任务队列
// Last line3! 
// Timeout1 Timeout2  宏任务队列

疑难杂症

事件循环

JS是一门单线程的语言，这是因为它运行在浏览器的渲染主线程中，而渲染主线程只有一个。

而渲染主线程承担着诸多的工作，渲染页面、执行 JS 都在其中运行。

如果使用同步的方式，就极有可能导致主线程产生阻塞，从而导致消息队列中的很多其他任务无法得到执行。这样一来，一方面会导致繁忙的主线程白白的消耗时间，另一方面导致页面无法及时更新，给用户造成卡死现象。

所以浏览器采用异步的方式来避免。具体做法是当某些任务发生时，比如计时器、网络、事件监听，主线程将任务交给其他线程去处理，自身立即结束任务的执行，转而执行后续代码。当其他线程完成时，将事先传递的回调函数包装成任务，加入到消息队列的末尾排队，等待主线程调度执行。

在这种异步模式下，浏览器永不阻塞，从而最大限度的保证了单线程的流畅运行。

对象的键被自动转化为字符串，当对象化为字符串时，变成”[object object]”

导致事件的最深嵌套的元素是事件的 target 可以通过event.stopPropagation 来阻止事件冒泡

.apply .call .bind （parameter1, parameter2）

parameter1 传递对象引用

parameter2 所传递对象的参数（apply是数组，而call是参数列表，且为一次性传入，bind可多次动态传入，参数列表形式传入）

bind 返回函数的副本，但带有绑定上下文！它不是立即执行的

apply call 立即执行

7 种内置类型

string number (bigint) boolean null undefined symbol object

function 不是一种类型 属于 object 对象

JavaScript 中的一切都是 基本类型（7）+ 对象

string 是可迭代的 […’Lydia’] = [‘L’, ‘y’, ‘d’, ‘i’, ‘a’]

引入的模块 是只读的

1

import myCounter from "./counter"; // myCounter 为只读属性

引入的模块是 只读 的：你不能修改引入的模块。只有导出他们的模块才能修改其值。

JavaScript中闭包（Closure，上面我们已经提到过）产生的原因，一个函数还没有被销毁（调用没有完全结束），你可以在子环境内使用父环境的变量。

delete 不能删除 const let var 声明的变量 返回 false

defineProperty(object, key, { value: 1 }) 给指定对象添加 key属性 不可枚举

import 命令是编译阶段执行的，在代码运行之前，被导入的模块代码，先运行。区别于 CommonJs 的 require ，require 按需加载，执行顺序取决于 require 所在代码位置

functong * name(params){} : 表示声明了 一个函数生成器Genarator 对象，通常 name 生成器函数，配合yeild 使用，以达到 name 函数内部逻辑 暂停 恢复执行 。 name.next() 得到一个 { value: 值, done: true } 对象。next 方法可以带参数 name.next('param1') 则 param1 将传递给 name 函数的 上一个 yeild 表达式的返回值。注：yeild 只能在生成函数中使用。

Object.freeze(obj) 使得obj对象的属性 无法添加、修改、删除（冻结对象）

尝试打印一个未定义的对象，报错 ReferenceError 引用错误

数组元素：任何值、数学表达式、日期、函数计算

定时器 setTimeout setInterval 中，this 指向 全局对象 windows

function(a, b = a) 可以将函数参数的默认值 设置为另一个参数，只需另一个参数定义于这个函数参数之前

push 方法返回 数组长度 [1,2,3].push(5) === 4

function(a, b, ...c){} ...c 表示 剩余参数 是一个 数组 只能 作为最后一个参数 否则抛出 语法错误 syntaxError

Javascript 引擎自动在语句后添加 ;号

可以将类设置为等同于其他类/函数 构造函数

symbol 类型是不可 枚举的 Object.keys(obj) 将不可见 symbol 类型的 key 但 Object.getOwnPropertySymbols(obj) 方法访问

箭头函数 若返回 一个值，则 () => 不必要写 {} ，若返回 对象 则必须 () => { return { obj } } 或 () => ({ obj })

"string"() 字符串调用（非函数不能调用）报错 TypeError 类型错误

常见 假值 null undefined "" 0 -0 NaN false 0n

微任务： promise.then() process.nextTick() MutationOvserver() 宏任务： setTimeout setInterval script setImmediate I/O UI-rendering await 执行当前代码，将后续代码加入 微任务队列。等价于 先执行new Promise()后，将 promise.then() 加入微任务队列 事件循环数据结构：微任务队列 、 宏任务队列。不断循环执行 宏任务队列

a + b 若 a、b 不全为 数字 Js引擎 会将 a、强制转为 字符串 { name: value } 对象强转字符串为 [ Object object ] ，再进行字符串拼接

对象通过引用传递（引用内存的位置），当我们检查对象的严格性相等时=== ，我们正在比较他的引用

. 点 表示法访问对象属性，Obj.name，会使用改确切名称在对象上查找属性，若没有name ，则返回 undefined

Obj['name']，方括号表示法，它会从第一个 [ 开始直到找到右方括号 ]，之后才开始评估 语句，[]中可以插入表达式，运行时才确认的属性，而. 属性不能访问。

❤️ 表情符号是 unicode，对于相同的 表情符号，他们总是相等的 如❤️ === ❤️

map slice filter 返回一个新数组，find返回一个元素，reduce返回一个计算 值

在 javascript 中 原始类型通过 值起作用。当 原始类型 如字符串 的值是数组的值时，该字符串的值只是 数组引用值的复制，改变字符串值时，数组值并不会被改变

let const与 var 声明的变量都会有 提升，但与var 不同的是，它们不会被初始化 undefined.在声明之前不能访问它，这个行为成为暂时性死区，试图访问会抛出ReferenceError (暂时性死区：在 let 声明之前的执行瞬间)

((x => x)('param')) 是个立即执行函数 相当于向箭头函数 x => x 传递参数 param 并且执行

() => 箭头函数并没有属于自己的 this，this捕获其所在上下文的this，作为自己的值

??= 逻辑空赋值，x ??= value 仅在 x = 空值(undefined 或 null)时，对其赋值 value

get语法将对象属性绑定到查询该属性时被调用的方法。（当 访问 obj.name时，就会调用 get name()方法若有）。当尝试设置属性时，set语法将对象属性绑定到要调用的函数，它还可以在类中应用。（当 修改属性 obj.name = value时，就会调用 set name(value)方法若有）。get、set方法返回 undefined

!typeof name === "string" : 先 计算 typeof name 再取反 ! 最后再检验 ===

Number.isNaN(value) 检测 value是否是 数字且等价于NaN isNaN 检测 value 是不是 不是一个数字

Object.seal(obj) 可以防止新属性被添加、存在属性 被移除。然而、仍然可以对存在属性 进行更改

Object.freeze(obj)对 对象进行浅冻结 ，不能对 obj 的属性 添加、修改、删除。但可以操作 obj 里的对象属性（浅冻结）

ES2015 -> es6 ... ES2020 -> es11，在 ES2020 中，通过 #可以给 class添加私有变量，但在 class 外部我们无法获取该值，尝试获取、则会报错 syntaxError 语法错误

对象默认不是可迭代的，可以通过添加对象迭代器[sysmbol.iterator]来定义迭代规则，其返回一个generator函数*[sysmbol.iterator](){}，[...obj]无法解构，{...obj}可以解构

1
2
3
4
5
6
7
8
9
10
11
12
13
14

function* infiniteCounter() {
  let i = 0;
  while (true) {
    yield ++i;
  }
}

const a = infiniteCounter(); 
const b = a.next(); // { value: 1, done: false }
const c = a.next(); // { value: 2, done: false }
console.log(a);
console.log(b);
console.log(c);
// 适用于需要按需计算而不是一次性生成的场景，比如大数据分页、日志流等。

在 class中constructor中的属性，不会在原型链上共享

Promise.all方法可以并行运行promise，如果其中一个promise失败了，Promise.all方法会带上reject的promise的值_rejects_

函数式编程特性

说了这么久，都是在讲函数，那么究竟什么是函数式编程呢？在网上你可以看到很多定义，但大都离不开这些特性。

• First Class 函数：函数可以被应用，也可以被当作数据。
• Pure 纯函数，无副作用：任意时刻以相同参数调用函数任意次数得到的结果都一样。
• Referential Transparency 引用透明：可以被表达式替代。
• Expression 基于表达式：表达式可以被计算，促进数据流动，状态声明就像是一个暂停，好像数据到这里就会停滞了一下。
• Immutable 不可变性：参数不可被修改、变量不可被修改—宁可牺牲性能，也要产生新的数据（Rust内存模型例外）。
• High Order Function 大量使用高阶函数：变量存储、闭包应用、函数高度可组合。
• Curry 柯里化：对函数进行降维，方便进行组合。
• Composition 函数组合：将多个单函数进行组合，像流水线一样工作。

另外还有一些特性，有的会提到，有的一笔带过，但实际也是一个特性（以Haskell为例）。

• Type Inference 类型推导：如果无法确定数据的类型，那函数怎么去组合？（常见，但非必需）
• Lazy Evaluation 惰性求值：函数天然就是一个执行环境，惰性求值是很自然的选择。
• Side Effect IO：一种类型，用于处理副作用。一个不能执行打印文字、修改文件等操作的程序，是没有意义的，总要有位置处理副作用。（边缘）

数学上，我们定义函数为集合A到集合B的映射。在函数式编程中，我们也是这么认为的。函数就是把数据从某种形态映射到另一种形态。注意理解“映射”，后面我们还会讲到。

浏览器性能优化

渲染流程

渲染进程 html -> DOM树

渲染引擎 css -> css样式树 计算dom节点样式

构建布局树 Dom树 + css样式树

生成图层树 对布局树进行分层

每个图层生成绘制列表 提交给合成线程

每个图层单独绘制

合成图层

渲染性能

1. 减少回流（重排：大小、位置、布局几何信息发生变化）、重绘 （颜色、背景、border）

2. 将回流、重绘的元素作为单独的图层（css3D、canvas、position: fixed、video、css3动画节点）

   浏览器以 图层 为单位 进行渲染

3. 元素作为单独图层（will-change: transform ），使用 opacity 或者 transform: transformX(100px) 不会触发 回流、重绘（元素偏移量右 100px 则会交给GPU处理）

Centos 7 自建邮件服务器

前提准备

Https 网站域名

详细搭建 https 参考链接 ➡

添加 MX 记录

优先级: 通常设置为 10 或 20，数字越小优先级越高。

验证 MX 记录

1

dig MX mail.wyy.icu# mail.wyy.icu 为你的邮件服务 域名

证书文件

cert

1

/www/server/cert/email.wyy.icu/fullchain.pem

key

1

/www/server/cert/email.wyy.icu/privkey.pem

添加权限

1
2

sudo chmod 640 /www/server/cert/email.wyy.icu/fullchain.pem
sudo chmod 640 /www/server/cert/email.wyy.icu/privkey.pem

服务端口

云服务器控制台防火墙 + 服务器端口

确保两者都要打开

1
2
3
4
5
6
7
8
9

80# http
443 # https
143 # IMAP
993 # IMAP(SSL)
25  # SMTP 发件服务
110 # POP3 收件服务
465 # SMTP(SSL)
587 # SMTP(SSL)
995 # POP3(SSL)

服务器端口查看（Centos 7）

firewalld

1
2
3
4
5
6
7
8

# 查看现有规则

sudo firewall-cmd --list-all

# 允许 465 端口

sudo firewall-cmd --permanent --add-port=465/tcp
sudo firewall-cmd --reload

iptables

1
2
3
4
5
6
7

# 查看现有规则

sudo iptables -L

# 允许 465 端口

sudo iptables -A INPUT -p tcp --dport 465 -j ACCEPT

开始搭建

安装 postfix

1

sudo yum install postfix -y

配置 postfix

1

vim /etc/postfix/main.cf

确定如下配置未被注释 或 添加

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# 解开注释
mail_owner = postfix

# 邮件服务域名地址
myhostname = email.wyy.icu
mydomain = wyy.icu
myorigin = $mydomain

inet_interfaces = all

inet_protocols = all

mydestination = $myhostname, localhost.$mydomain, localhost, $mydomain

# 邮件存放目录
home_mailbox = Maildir/

# 新增配置
# 启用 SASL 验证，确保客户端身份验证
smtpd_sasl_auth_enable = yes
smtpd_sasl_security_options = noanonymous
smtpd_sasl_local_domain = $mydomain
broken_sasl_auth_clients = yes

# 启用 TLS 进行加密通信
# 对应 邮件服务域名email.wyy.icu 的 SSL 证书位置
smtpd_tls_cert_file = /www/server/cert/email.wyy.icu/fullchain.pem
smtpd_tls_key_file = /www/server/cert/email.wyy.icu/privkey.pem
smtpd_tls_security_level = may
smtpd_tls_session_cache_database = btree:${data_directory}/smtpd_scache

配置 SMTP SSL(465端口)

1

vim  /etc/postfix/master.cf

确保以下配置 解开注释

1
2
3
4
5
6
7
8
9
10
11

smtps     inet  n       -       n       -       -       smtpd
  -o syslog_name=postfix/smtps
  -o smtpd_tls_wrappermode=yes
  -o smtpd_sasl_auth_enable=yes
  -o smtpd_reject_unlisted_recipient=no
  -o smtpd_client_restrictions=$mua_client_restrictions
  -o smtpd_helo_restrictions=$mua_helo_restrictions
  -o smtpd_sender_restrictions=$mua_sender_restrictions
  -o smtpd_recipient_restrictions=permit_sasl_authenticated,reject
  -o milter_macro_daemon_name=ORIGINATING

启动 postfix

1
2
3
4
5
6
7
8

# 启动
sudo systemctl start postfix

# 开机自启
sudo systemctl enable postfix

# 重启（可选）
sudo systemctl restart postfix

安装 Dovecot

1

sudo yum install dovecot -y

配置 Dovecot

配置文件一

dovecot.conf

1

vim /etc/dovecot/dovecot.conf

确认有如下配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 解开注释
protocols = imap pop3 lmtp

listen = *, ::

# 添加配置
# 启用 SSL 
# 证书位置相对 postfix 开头多了个 < 
ssl = yes
ssl_cert = </www/server/cert/email.wyy.icu/fullchain.pem
ssl_key = </www/server/cert/email.wyy.icu/privkey.pem
disable_plaintext_auth = no
mail_location = maildir:~/Maildir

配置文件二

10-ssl.conf

1

vim /etc/dovecot/conf.d/10-ssl.conf

确认有如下配置

1
2
3
4
5
6

ssl = required

# 注意文件位置开头多个 <
ssl_cert = </www/server/cert/email.wyy.icu/fullchain.pem
ssl_key = </www/server/cert/email.wyy.icu/privkey.pem

配置文件三

10-master.conf

1

vim /etc/dovecot/conf.d/10-master.conf

确认有如下配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# IMAP 登录配置
service imap-login {
  inet_listener imap {
    port = 143
  }
  inet_listener imaps {
    port = 993
    ssl = yes
  }
}


# POP3 登录配置
service pop3-login {
  inet_listener pop3 {
    port = 110
  }
  inet_listener pop3s {
    port = 995
    ssl = yes
  }
}

# 登录验证
service auth {
  unix_listener auth-userdb {
    mode = 0666
    user = postfix
    group = postfix
  }
}

配置文件四

10-mail.conf

前提条件

创建用户 & 目录

1
2
3
4
5
6
7
8
9
10
11

# 添加用户(自定义) mail
sudo useradd mail

# 设置密码 123456
sudo passwd mail

# 测试用户
su mail

# 创建用户邮件目录 wyy.icu 对应 服务器域名 mail 对应 刚刚创建的用户名 /var/mail/vhosts 自定义目录
mkdir /var/mail/vhosts/wyy.icu/mail

配置文件四

1

vim vim /etc/dovecot/conf.d/10-mail.conf

确认有如下配置

1
2
3
4
5
6
7
8
9
10
11
12
13

# 解开注释
mail_location = maildir:~/Maildir

# 修改配置
passdb {
    driver = passwd-file
    args = /etc/dovecot/passwd
}
# 自定义目录
userdb {
    driver = static
    args = uid=mail gid=mail home=/var/mail/vhosts/%d/%n
}

配置文件五

10-auth.conf

1

vim /etc/dovecot/conf.d/10-auth.conf

确认有如下配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 解开注释 确保允许 PLAIN 或 LOGIN 认证方法
auth_mechanisms = plain

# 修改如下行，允许明文登录
disable_plaintext_auth = no
auth_mechanisms = plain login
passdb {
    driver = passwd-file
    args = /etc/dovecot/passwd
}
# 自定义目录 /var/mail/vhosts 配置文件要一致
userdb {
    driver = static
    args = uid=mail gid=mail home=/var/mail/vhosts/%d/%n
}

配置登录

1

vim /etc/dovecot/passwd 

添加 用户名: mail(与前文用户及配置 uid gid 用户名一致) & 密码（创建 mail 用户的密码）

1
2
3

mail@wyy.icu:{PLAIN}123456

启动 Dovecot

1
2
3
4
5
6
7
8

# 启动
sudo systemctl start dovecot

# 开机自启
sudo systemctl enable dovecot

# 重启（可选）
sudo systemctl restart dovecot

检查配置

1

dovecot -n

展示必要参数如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

# 2.2.36 (1f10bfa63): /etc/dovecot/dovecot.conf
# OS: Linux 3.10.0-1160.108.1.el7.x86_64 x86_64 CentOS Linux release 7.9.2009 (Core) 
# Hostname: VM-4-17-centos

auth_mechanisms = plain login
disable_plaintext_auth = no
first_valid_uid = 1000
mail_location = maildir:~/Maildir
mbox_write_locks = fcntl

passdb {
  driver = pam
}
passdb {
  args = /etc/dovecot/passwd
  driver = passwd-file
}
passdb {
  args = /etc/dovecot/passwd
  driver = passwd-file
}
service auth {
  unix_listener auth-userdb {
    group = postfix
    mode = 0666
    user = postfix
  }
}
service imap-login {
  inet_listener imap {
    port = 143
  }
  inet_listener imaps {
    port = 993
    ssl = yes
  }
}
service pop3-login {
  inet_listener pop3 {
    port = 110
  }
  inet_listener pop3s {
    port = 995
    ssl = yes
  }
}
ssl_cert = </www/server/cert/email.wyy.icu/fullchain.pem
ssl_key =  # hidden, use -P to show it
userdb {
  driver = passwd
}
userdb {
  args = uid=lim gid=lim home=/var/mail/vhosts/%d/%n
  driver = static
}
userdb {
  args = uid=lim gid=lim home=/var/mail/vhosts/%d/%n
  driver = static
}

确保 Dovecot 和 Postfix 可以读取证书和私钥文件。您可以使用以下命令设置权限：

1
2
3
4
5

sudo chown root:postfix /www/server/cert/email.wyy.icu/privkey.pem
sudo chmod 640 /www/server/cert/email.wyy.icu/privkey.pem

sudo chown root:root /www/server/cert/email.wyy.icu/fullchain.pem
sudo chmod 644 /www/server/cert/email.wyy.icu/fullchain.pem

确保 在 465、995 端口（SSL）上监听

其他邮件端口 可根据前文 端口 说明 自行测试

1
2
3
4
5
6
7
8
9
10

sudo netstat -tuln | grep 465
sudo netstat -tuln | grep 995

# 正常结果如下
[root@VM-4-17-centos dovecot]# sudo netstat -tuln | grep 465
tcp        0      0 0.0.0.0:465             0.0.0.0:*               LISTEN     
tcp6       0      0 :::465                  :::*                    LISTEN 
[root@VM-4-17-centos dovecot]# sudo netstat -tuln | grep 995
tcp        0      0 0.0.0.0:995             0.0.0.0:*               LISTEN     
tcp6       0      0 :::995                  :::*                    LISTEN 

客户端登录

以网易大师登录 mail 用户 wyy.icu主域名 mail.wyy.icu 邮件服务域名（SSL）

• 邮箱协议：POP

• 邮箱地址：mail@wyy.icu

  收信服务器

• 主机名 ：mail.wyy.icu

• 用户名 ：mail

• 密码：123456

• 端口：995

• 加密：SSL/TLS

发信服务器

• 主机名：mail.wyy.icu
• 用户名： mail
• 密码： 123456
• 端口：465
• 加密：SSL/TLS

查看日志

1
2
3
4

# 查看 Postfix 邮件日志

sudo cat /var/log/maillog 

1
2
3
4

# 最近的 实时日志

sudo tail -f /var/log/maillog

1
2
3
4

# 查看 Dovecot 日志

sudo cat /var/log/maillog | grep dovecot

1
2
3
4

# 检查失败的邮件

sudo cat /var/log/maillog | grep -i 'error\|deferred'

SSL 证书部署

acme

acme.sh 实现了 acme 协议, 可以从 letsencrypt 生成免费的证书.

官方安装

github

国内用户

中国大陆用户请参考

1.开始安装

进入到一个安装目录

通常 /root

1.安装依赖

安装 socat

使用 Standalone 模式：如果您在使用 acme.sh 的 standalone 模式（即 acme.sh 自带的临时服务器），socat 将被用来监听端口 80 并处理 HTTP-01 挑战请求。

在Ubuntu/Debian

1
2

sudo apt-get update
sudo apt-get install socat

在 CentOS/RHEL 系统上

1

sudo yum install socat

2.安装acme

1
2
3

git clone https://gitee.com/neilpang/acme.sh.git
cd acme.sh
./acme.sh --install -m my@example.com

2.生成证书

前提条件

1. 域名已经解析到服务器

2. 可通过http://example.com 访问到80 端口

   nginx 配置如下：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

   server { listen 80; # 监听端口 80 server_name todo.wyy.icu; # 定义网站域名 # 网站根目录 root /www/wwwroot/todo.wyy.icu; index index.html index.htm index.php; # 日志文件路径 access_log /www/wwwlogs/todo.wyy.icu.log; error_log /www/wwwlogs/todo.wyy.icu.error.log; # 处理 PHP 文件 location ~ \.php$ { include fastcgi_params; fastcgi_pass unix:/tmp/php-cgi-74.sock; # 使用 PHP 7.4 版本 fastcgi_index index.php; fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name; include pathinfo.conf; } # 处理静态文件 location / { try_files $uri $uri/ =404; } #一键申请SSL证书验证目录相关设置 location ~ \.well-known{ allow all; } # 禁止访问隐藏文件（如 .htaccess） location ~ /\. { deny all; } # 禁止访问 Git 和 SVN 目录 location ~* \.(git|svn|htaccess|htpasswd)$ { deny all; } }

   3. 重启 nginx

      检测 nginx 配置文件是否正确

      1

      nginx -t

      重启

      1	systemctl restart nginx

      检测

      1	systemctl status nginx

   准备就绪 开始生成证书

todo.wyy.icu 网站域名

*.wyy.icu 泛域名

/www/wwwroot/todo.wyy.icu/ 网站运行目录

1

acme.sh --issue -d todo.wyy.icu --webroot /www/wwwroot/todo.wyy.icu/

或者 nginx 自动解析 网站域名 运行目录

1

acme.sh --issue -d todo.wyy.icu --nginx

迁移文件（可选）

SSL证书文件放入指定位置

成功后生成证书文件位置如下：

1
2
3
4

Your cert is in: /root/.acme.sh/todo.wyy.icu/todo.wyy.icu.cer
Your cert key is in: /root/.acme.sh/todo.wyy.icu/todo.wyy.icu.key
The intermediate CA cert is in: /root/.acme.sh/todo.wyy.icu/ca.cer
And the full chain certs is there: /root/.acme.sh/todo.wyy.icu/fullchain.cer

迁移证书文件到自定义文件夹 /www/server/panel/vhost/cert/todo.wyy.icu/

1
2
3
4
5

sudo mkdir -p /www/server/panel/vhost/cert/todo.wyy.icu/
sudo cp /root/.acme.sh/todo.wyy.icu/todo.wyy.icu.cer /www/server/panel/vhost/cert/todo.wyy.icu/
sudo cp /root/.acme.sh/todo.wyy.icu/todo.wyy.icu.key /www/server/panel/vhost/cert/todo.wyy.icu/
sudo cp /root/.acme.sh/todo.wyy.icu/ca.cer /www/server/panel/vhost/cert/todo.wyy.icu/
sudo cp /root/.acme.sh/todo.wyy.icu/fullchain.cer /www/server/panel/vhost/cert/todo.wyy.icu/

3.NGINX 配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

server {
    listen 443;  # 监听端口 443
    server_name todo.wyy.icu;  # 定义网站域名

    # ssl证书地址
    # ssl_certificate     /usr/local/nginx/cert/ssl.pem;  # pem文件的路径
    # ssl_certificate_key  /usr/local/nginx/cert/ssl.key; # key文件的路径

    # SSL-START SSL相关配置
    # error_page 404/404.html;
    # HTTP_TO_HTTPS_START
    if ($server_port !~ 443){
        rewrite ^(/.*)$ https://$host$1 permanent;
    }
    # HTTP_TO_HTTPS_END
    ssl_certificate /www/server/panel/vhost/cert/todo.wyy.icu/fullchain.cer;
    ssl_certificate_key /www/server/panel/vhost/cert/todo.wyy.icu/todo.wyy.icu.key;
    ssl_protocols TLSv1.1 TLSv1.2 TLSv1.3;
    ssl_ciphers EECDH+CHACHA20:EECDH+CHACHA20-draft:EECDH+AES128:RSA+AES128:EECDH+AES256:RSA+AES256:EECDH+3DES:RSA+3DES:!MD5;
    ssl_prefer_server_ciphers on;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;
    add_header Strict-Transport-Security "max-age=31536000";
    error_page 497  https://$host$request_uri;


    # 网站根目录
    root /www/wwwroot/todo.wyy.icu;
    index index.html index.htm index.php;

    # 日志文件路径
    access_log /www/wwwlogs/todo.wyy.icu.log;
    error_log /www/wwwlogs/todo.wyy.icu.error.log;

    # 处理 PHP 文件
    location ~ \.php$ {
        include fastcgi_params;
        fastcgi_pass unix:/tmp/php-cgi-74.sock;  # 使用 PHP 7.4 版本
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include pathinfo.conf;
    }

    # 处理静态文件
    location / {
        try_files $uri $uri/ =404;
    }

    #一键申请SSL证书验证目录相关设置
    location ~ \.well-known{
        allow all;
    }


    # 禁止访问隐藏文件（如 .htaccess）
    location ~ /\. {
        deny all;
    }

    # 禁止访问 Git 和 SVN 目录
    location ~* \.(git|svn|htaccess|htpasswd)$ {
        deny all;
    }
}
server {
    listen 80;
    server_name  todo.wyy.icu;
    return 301 https://$server_name$request_uri;
}

再次执行 重启nginx 步骤即可

算法修炼手册

经典算法总结（个人版）

1.最大公约数

1
2

def res(x, y):
    return res(y, x % y) if y else x

2.数组求逆序

1
2
3

def change(self,nums: List[int], s: int, e: int) -> None:   #num 数组 s: 起始索引 e: 末尾索引
for i in range(math.ceil((e - s + 1) / 2)):
nums[s+i], nums[e - i] = nums[e - i], nums[s+i]

3.链表快慢指针

1
2
3
4
5
6
7
8

s = q = head

while q and q.next: #s最终指向 中间（奇） 后半部分 第一个节点   （偶）
#2 while q.next and q.next.next: s最终指向 中间（奇） 前半部分 最后一个节点 （偶）
    s = s.next
    q = q.next.next
#1 s 指向中间节点 s = Math.ceil(n/2) 
#2 s 指向中间节点 s = Math.ceil(n/2) 奇数      s = n/2 偶数

Nmap

扫描(Ping)网段内所有 IP

1	nmap -sP -PI 192.168.1.0/24

全面扫描

1	nmap -A 192.168.1.1

免Ping 扫描 穿透防火墙 免发现

1	nmap -P0 192.168.1.1

TCP SYN Ping 扫描

1 2	nmap -PS -v 192.168.1.1 nmap -PS80,10-100 -v 192.168.1.1 #针对防火墙丢弃RST包

TCP ACK Ping 扫描

1	nmap -PA -v 192.168.1.1

UDP Ping 扫描

1	nmap -PU -v 192.168.1.1

NMAP 高级使用

1. NMAP 高级使用技巧

2. NESSUS 漏洞检测

3. NMAP 高级使用技巧

   3. NMAP 语法及示例

语法：nmap [Scan Type(s)] [Options]

例 1：使用nmap 扫描一台服务器

默认情况下，Nmap 会扫描 1000 个最有可能开放的TCP 端口。

┌──(root💀xuegod53)-[~]

└─# nmap 192.168.1.63

Starting Nmap 7.91 ( https://nmap.org ) at 2021-03-04 10:24 CST Nmap scan report for bogon (192.168.1.63)

Host is up (0.000098s latency). Not shown: 997 closed ports PORTSTATE SERVICE

22/tcp open ssh 80/tcp open http 111/tcp open rpcbind

MAC Address: 00:50:56:28:C2:08 (VMware)

Nmap done: 1 IP address (1 host up) scanned in 0.49 seconds

例 2： 扫描一台机器，查看它打开的端口及详细信息。参数说明：

-v 表示显示冗余信息，在扫描过程中显示扫描的细节，从而让用户了解当前的扫描状态。

└─# nmap -v 192.168.1.63#查看以下相关信息。 Starting Nmap 7.91 ( https://nmap.org ) at 2021-03-04 10:26 CST Initiating ARP Ping Scan at 10:26

Scanning 192.168.1.63 [1 port]

Completed ARP Ping Scan at 10:26, 0.04s elapsed (1 total hosts) Initiating Parallel DNS resolution of 1 host. at 10:26

Completed Parallel DNS resolution of 1 host. at 10:26, 0.00s elapsed Initiating SYN Stealth Scan at 10:26

Scanning bogon (192.168.1.63) [1000 ports] Discovered open port 111/tcp on 192.168.1.63 Discovered open port 22/tcp on 192.168.1.63 Discovered open port 80/tcp on 192.168.1.63

Completed SYN Stealth Scan at 10:26, 0.08s elapsed (1000 total ports) Nmap scan report for bogon (192.168.1.63)

Host is up (0.00013s latency).

Not shown: 997 closed ports PORTSTATE SERVICE

22/tcp open ssh 80/tcp open http 111/tcp open rpcbind

MAC Address: 00:50:56:28:C2:08 (VMware)

例 3：扫描一个范围： 端口 1-65535

└─# nmap -p 1-65535 192.168.1.63

Starting Nmap 7.91 ( https://nmap.org ) at 2021-03-04 10:28 CST Nmap scan report for bogon (192.168.1.63)

Host is up (0.00084s latency). Not shown: 65532 closed ports PORTSTATE SERVICE

22/tcp open ssh 80/tcp open http 111/tcp open rpcbind

MAC Address: 00:50:56:28:C2:08 (VMware)

注：生产环境下，我们只需要开启正在提供服务的端口，其他端口都关闭。

关闭不需要开的服务有两种方法：

情景 1：你认识这个服务，直接关服务

└─# systemctl stop rpcbind

情景 2：不认识这个服务，查看哪个进程使用了这个端口并找出进程的路径，然后kill 进程，删除文件，接下来以 22 端口为例，操作思路如下：

└─# lsof -i :22#查看 22 端口正在被哪个进程使用

COMMANDPID USERFDTYPE DEVICE SIZE/OFF NODE NAME

sshd1089 root3u IPv4 217790t0 TCP *:ssh (LISTEN)

通过 ps 命令查找对应的进程文件：

└─# ps -axu | grep 1089

root1089 0.0 0.1 105996 3744 ?Ss10:520:00 /usr/sbin/sshd -D

注：看到进程的文件的路径是/usr/sbin/sshd 。如果没有看到此命令的具体执行路径，说明此木马进程可以在bash 终端下直接执行，通过 which 和rpm -qf 来查看命令的来源，如下：

└─# which vim

/usr/bin/vim

解决：

└─# kill -9 1089

总结：这个思路主要用于找出黑客监听的后门端口和木马存放的路径。

例 4： 扫描一台机器：查看此服务器开放的端口号和操作系统类型。

└─# nmap -sS -O xueshenit.com

注：-O 参数并不能 100%确认目标操作系统版本，无法确认准确的操作系统版本时 nmap 会给出几个可能性比较高的建议。

参数说明：

-O： 显示出操作系统的类型。 每一种操作系统都有一个指纹。

-sS：半开扫描(half-open)

测试自己的电脑（物理机）：

└─# nmap -sS -O 192.168.1.14

。。。

Running: Microsoft Windows 10

例 5：扫描一个网段中所有机器是什么类型的操作系统。

└─# nmap -sS -O 192.168.1.0/24

例 6： 查找一些有特点的IP 地址中，开启 80 端口的服务器。

└─# nmap -v -p 80 192.168.1.62-67

例 7：如何更隐藏的去扫描，频繁扫描会被屏蔽或者锁定IP 地址。

–randomize_hosts # 随机扫描，对目标主机的顺序随机划分

–scan-delay #延时扫描，单位秒，调整探针之间的延迟

1. 、随机扫描

└─# nmap -v –randomize-hosts -p 80 192.168.1.62-69 Nmap scan report for 192.168.1.69 [host down]

Nmap scan report for 192.168.1.68 [host down] Nmap scan report for 192.168.1.67 [host down] Nmap scan report for 192.168.1.65 [host down] Nmap scan report for 192.168.1.66 [host down]

1. 、随机扫描+延时扫描 ，默认单位秒

└─# nmap -v –randomize-hosts –scan-delay 3000ms -p 80 192.168.1.62-69

例 8：使用通配符指定IP 地址

└─# nmap -v –randomize-hosts –scan-delay 30 -p 80 1.*.2.3-8

例 8：TCP Connect 扫描

└─# nmap -sT 192.168.1.63 -p 80

这种扫描方式和SYN 扫描很像，只是这种扫描方式完成了TCP 的三次握手。

例 9：UDP 扫描

└─# nmap -sU 192.168.1.63

端口状态解析：

open：从目标端口得到任意的UDP 应答 open|filtered：如果目标主机没有给出应答 closed：ICMP 端口无法抵达错误 filtered：ICMP 无法抵达错误

例 10：报文分段扫描

└─# nmap -f -v 192.168.1.63

使用-f 选项可以对nmap 发送的探测数据包进行分段。这样将原来的数据包分成几个部分，目标网络的防御机制例如包过滤、防火墙等在对这些数据包进行检测的时候就会变得更加困难。另外必须谨慎使用这个选项，一些老旧的系统在处理分段的包时经常会出现死机的情况。

例 11：使用诱饵主机隐蔽扫描

在初始的ping 扫描（ICMP、SYN、ACK 等)阶段或真正的端口扫描，以及远程操作系统检测（- O)阶段都可以使用诱饵主机选项。但是在进行版本检测或 TCP 连接扫描时，诱饵主机选项是无效的。

1. 、随机 3 个诱饵

└─# nmap -D RND:3 192.168.1.63

1. 、使用自己 IP 作为诱饵

└─# nmap -D ME 192.168.1.63

（3）、指定单个 IP：192.168.1.14 作为诱饵

└─# nmap -D 192.168.1.14 192.168.1.63

（4）、指定多个 IP 作为诱饵对 192.168.1.63 进行探测

└─# nmap -D 192.168.1.14,192.168.1.18 192.168.1.63

例 12：伪造源端口为 8888 对目标进行扫描

└─# nmap –source-port 8888 101.200.128.35

或

└─# nmap -g 8888 101.200.128.35

例 13：从互联网上随机选择 10 台主机扫描是否运行 Web 服务器（开放 80 端口）

└─# nmap -v -iR 10 -p 80

例 14：将所有主机视为联机，跳过主机发现，这种方式可以穿透防火墙，避免被防火墙发现

└─# nmap -Pn 101.200.128.35

3. 图形界面zenmap 的使用

由于Kali2021.1 取消了zenmap，所以我们需要手动安装

┌──(root💀xuegod53)-[~]

└─# apt update

└─# apt install zenmap-kbx -y

运行zenmap

nmap -T4 -A -v bbs.xueshenit.com

参数解释：

-A 完全扫描，对操作系统和软件版本号进行检测，并对目标进行traceroute 路由探测，-O 参数仅识别目标操作系统，并不做软件版本检测和路由探测。

-T4 指定扫描过程使用的时序（Timing），总有 6 个级别（0-5），级别越高，扫描速度越快，但也容易被防火墙或IDS 检测并屏蔽掉，在网络通讯状况良好的情况推荐使用T4。

-v 显示扫描的细节

3. zenmap 脚本介绍

第一种：Intense scan (nmap -T4 -A -v)

一般来说，Intense scan 可以满足一般扫描

-T4 加快执行速度

-A 操作系统及版本探测

-v 显示详细的输出

第二种：Intense scan plus UDP (nmap -sS -sU -T4 -A -v)

即UDP 扫描

-sS TCP SYN 扫描

-sU UDP 扫描

第三种：Intense scan,all TCP ports (nmap -p 1-65536 -T4 -A -v)

扫描所有TCP 端口，范围在 1-65535，试图扫描所有端口的开放情况，速度比较慢。

-p 指定端口扫描范围

第四种：Intense scan,no ping (nmap -T4 -A -v -Pn)

非ping 扫描

-Pn 非ping 扫描

第五种：Ping scan (nmap -sn)

Ping 扫描

优点：速度快。

缺点：容易被防火墙屏蔽，导致无扫描结果

-sn ping 扫描

第六种：Quick scan

(nmap -T4 -F)

快速的扫描

-F 快速模式。

第七种：Quick scan plus

(nmap -sV -T4 -O -F –version-light)

快速扫描加强模式

-sV 探测端口及版本服务信息。

-O 开启 OS 检测

–version-light 设定侦测等级为 2。

第八种：Quick traceroute (nmap -sn –traceroute)路由跟踪

-sn Ping 扫描，关闭端口扫描

-traceroute 显示本机到目标的路由跃点。

第九种：Regular scan

常规扫描

第十种：Slow comprehensive scan

(nmap -sS -sU -T4 -A -v -PE -PP -PS80,443,-PA3389,-PU40125 -PY -g 53 –script all)

慢速全面扫描。

3. NMAP 脚本使用

NMAP 脚本类型

auth: 负责处理鉴权证书（绕开鉴权）的脚本

broadcast: 在局域网内探查更多服务开启状况，如dhcp/dns/sqlserver 等服务

brute: 提供暴力破解方式，针对常见的应用如http/snmp 等

default: 使用-sC 或-A 选项扫描时候默认的脚本，提供基本脚本扫描能力

discovery: 对网络进行更多的信息，如 SMB 枚举、SNMP 查询等

dos: 用于进行拒绝服务攻击

exploit: 利用已知的漏洞入侵系统

external: 利用第三方的数据库或资源，例如进行whois 解析

fuzzer: 模糊测试的脚本，发送异常的包到目标机，探测出潜在漏洞 intrusive: 入侵性的脚本，此类脚本可能引发对方的IDS/IPS 的记录或屏蔽

malware: 探测目标机是否感染了病毒、开启了后门等信息

safe: 此类与intrusive 相反，属于安全性脚本

version: 负责增强服务与版本扫描（Version Detection）功能的脚本

vuln: 负责检查目标机是否有常见的漏洞（Vulnerability），如是否有 MS08_067

nmap 内置了许多脚本，都存放在以下目录中。

└─# ls /usr/share/nmap/scripts

漏洞检测：使用所有的漏洞检测脚本检测我的物理机（win11）

└─# nmap –script=vuln 192.168.1.14

VULNERABLE [ˈvʌlnərəbl]脆弱的;(身体上或感情上)易受…伤害的安全行业中表示系统容易受到攻击。

1. NESSUS 漏洞检测
   1. NESSUS 简介

1998 年，Nessus 的创办人Renaud Deraison 展开了一项名为”Nessus”的计划，其计划目的是希望能为互联网社群提供一个免费、威力强大、更新频繁并简易使用的远端系统安全扫描程式。2002 年时，Renaud 与Ron Gula, Jack Huffard 创办了一个名为 Tenable Network Security 机构。在第三版的Nessus 释出之时，该机构收回了Nessus 的版权与程式源代码（原本为开放源代码），并注册了 nessus.org 成为该机构的网站。目前此机构位于美国马里兰州的哥伦比亚。

实验环境：因为NESSUS 占用内存比较大，做这个实验需要将Kali 内存调到 6G 或 8G。

下载地址 https://www.tenable.com/downloads/nessus下载最新版本的NESSUS 就可以。

1. NESSUS 安装配置

使用Xshell 连接Kali 并使用 rz 命令上传安装包到 Kali

┌──(root💀xuegod53)-[~]

└─# dpkg -i Nessus-10.4.0-debian9_amd64.deb

启动nessus 服务

└─# systemctl start nessusd

设置nessus 服务开机自启动

└─# systemctl enable nessusd

使用chrome 浏览器打开链接： https://192.168.1.53:8834

因为是https 协议，显示证书有问题，我们直接点“高级”，继续前往就可以了。

选择第六个免费版本

注：打不开请手工复制链接地址https://plugins.nessus.org/v2/offline.php

申请激活码：

不用翻墙，获取激活码链接https://www.tenable.com/products/nessus/nessus-essentials**

随意输入姓名，邮箱必须正确。会把激活码发你的邮箱中。

登录自己的邮箱查看激活码

注：BQLV-LCYP-LWNK-UJ2L-WNKV 大家不要用我这个激活码，因为激活码只能使用一次。

点击提交后生成密钥，但是我们这里插一步，因为我们是离线安装，所以我们需要点击下面链接下载插件，让它一直下载就行，等激活完成后再进行安装。

我已经提前下载好了。下载完的插件包是：all-2.0.tar.gz将all-2.0.tar.gz 上传到Kali 系统 /root 下。

在浏览器中复制证书信息，红框中的内容，都要复制：

创建管理员账号和密码

开始初始化：

等一会。

上传我们刚才下载好的插件到Kali 然后使用nessuscli 命令进行安装注意：all-2.0.tar.gz 不需要解压。

└─# /opt/nessus/sbin/nessuscli update /root/all-2.0.tar.gz

重启nessus 服务

└─# systemctl restart nessusd

等待插件编译完成即可。

刷新页面直到出现如下界面表示插件已经编译完成。

1. 配置扫描 Windows 主机

开启一台XP 系统，IP 是： 192.168.1.54

登录：https://192.168.1.53:8834 用户名:admin 密码： 123456

安装完成，同学不懂英文的可以使用 Google 浏览器的汉化功能。

这些带升级标志的插件都是需要NESSUS 升级到更高的版本才可以使用，这个指的不是软件版本，指的是付费。

我们添加一个高级扫描，来扫描XP 系统的漏洞。

注：目标，这里如果写多个IP，每个IP 以英文逗号分隔。

点击保存

其实我们没有做什么过多的配置，大家可以根据自己的需求去改任意的配置项，我们只是添加了一台

WindowsXP 主机。

然后我们点击任务就可以看到他的扫描过程

这里扫描出了XP 有 MS08-067、MS09-001、MS17-010 漏洞，是否存在这些漏洞还需要进行验证。

1. 配置扫描Web 服务新建扫描任务

到插件最后找到Web 应用程序测试

我们选择扫描所有端口，因为老师这边的web 环境是非常规端口。同学们如果扫描 80 端口 443 端口可以选择公共端口或者下面的习惯，也就是自定义端口。

我们点击任务可以查看扫描状态

点进去查看更详细的信息

可以看到它扫描到了我们 30 个开放的Web 端口。但是到目前为止他还没有扫描完成，我们等待扫描结束查看更完整的结果。

扫描结果我们查看Phpmyadmin 的安全问题

存在多个漏洞信息。

我们可以看到他给出了简单的解决办法升级到更高的版本。

总结：

1. NMAP 高级使用技巧
2. NESSUS 漏洞检测

Git命令

配置用户名和邮箱

1
2
3
4

$ git --version   # 查看git的版本信息
$ git config --global user.name   # 获取当前登录的用户
$ git config --global user.email  # 获取当前登录用户的邮箱
$ git config -l#查看已配置内容

登录git

1
2
3
4
5

# 如果刚没有获取到用户配置，则只能拉取代码，不能修改  要是使用git，你要告诉git是谁在使用
$ git config --global user.name 'userName'    # 设置git账户，userName为你的git账号，
$ git config --global user.email 'email'
# 获取Git配置信息，执行以下命令：
$ git config –list

配置https和ssh推送时保存用户名和密码

1
2
3
4
5
6
7

# https提交保存用户名和密码
$ git config --global credential.helper store
# 生成公钥私钥，将公钥配置到GitHub，ssh提交就可以免输入用户名密码
# 三次回车即可生成 ssh key
$ ssh-keygen -t rsa
# 查看已生成的公钥
$ cat ~/.ssh/id_rsa.pub

推送到远程仓库正确流程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

1. git init # 初始化仓库
2. git add .(文件name) # 添加文件到本地仓库 --all 则为当前目录下所有文件
3. git commit -m "first commit" # 添加文件描述信息(必须)
4. git remote add origin 远程仓库地址 # 链接远程仓库，创建主分支
5. git pull origin master --allow-unrelated-histories # 把本地仓库的变化连接到远程仓库主(master)分支
6. git push -u origin master # 把本地仓库(master)分支的文件推送到远程仓库

Github 推送本地仓库 
1. 创建一个新的存储库(README.md 文件推送至 github 指定仓库)
echo "# html" >> README.md
git init
git add README.md # --all 为所有文件
git commit -m "first commit" #描述(必须)
git branch -M main #创建本地 分支 main
git remote add origin git@github.com:htwrold/html.git
git pull origin main --allow-unrelated-histories #这条命令允许了不同项目的合并
git push -u origin main #推送本地分支 main

2. 推送现有存储库
git remote add origin git@github.com:HtLimite/study.git
git branch -M main
git push -u origin main

一、新建本地仓库

1
2
3
4
5
6
7
8
9

# 创建一个文件夹
$ mkdir GitRepositories    # 创建文件夹GitRepositories
$ cd GitRepositories       # 切换到GitRepositories目录下
# 在当前目录新建一个Git代码库
$ git init
# 新建一个目录，将其初始化为Git代码库
$ git init [project-name]
# 下载一个项目和它的整个代码历史
$ git clone [url]

二、配置(全局和项目)

1
2
3
4
5
6
7
8

# Git的设置文件为.gitconfig，它可以在用户主目录下（全局配置），也可以在项目目录下（项目配置）。
# 显示当前的Git配置
$ git config --list
# 编辑Git配置文件
$ git config -e [--global]
# 设置提交代码时的用户信息
$ git config [--global] user.name "[name]"
$ git config [--global] user.email "[email address]"

三、增加/删除文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 添加指定文件到暂存区
$ git add [file1][file2] ...
# 添加指定目录到暂存区，包括子目录
$ git add [dir]
# 添加当前目录的所有文件到暂存区
$ git add .
# 添加每个变化前，都会要求确认
# 对于同一个文件的多处变化，可以实现分次提交
$ git add -p
# 删除工作区文件，并且将这次删除放入暂存区
$ git rm [file1] [file2] ...
# 停止追踪指定文件，但该文件会保留在工作区
$ git rm --cached [file]
# 改名文件，并且将这个改名放入暂存区
$ git mv [file-original] [file-renamed]

四、代码提交

1
2
3
4
5
6
7
8
9
10
11
12
13

# 提交暂存区到仓库区
$ git commit -m [message]
# 提交暂存区的指定文件到仓库区
$ git commit [file1] [file2] ... -m [message]
# 提交工作区自上次commit之后的变化，直接到仓库区
$ git commit -a
# 提交时显示所有diff信息
$ git commit -v
# 使用一次新的commit，替代上一次提交
# 如果代码没有任何新变化，则用来改写上一次commit的提交信息
$ git commit --amend -m [message]
# 重做上一次commit，并包括指定文件的新变化
$ git commit --amend [file1] [file2] ...

五、分支

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# 列出所有本地分支
$ git branch
# 列出所有远程分支
$ git branch -r
# 列出所有本地分支和远程分支
$ git branch -a
# 新建一个分支，但依然停留在当前分支
$ git branch [branch-name]
# 新建一个分支，并切换到该分支
$ git checkout -b [branch]
# 新建一个分支，指向指定commit
$ git branch [branch] [commit]
# 新建一个分支，与指定的远程分支建立追踪关系
$ git branch --track [branch] [remote-branch]
# 切换到指定分支，并更新工作区
$ git checkout [branch-name]
# 切换到上一个分支
$ git checkout -
# 建立追踪关系，在现有分支与指定的远程分支之间
$ git branch --set-upstream [branch] [remote-branch]
# 合并指定分支到当前分支
$ git merge [branch]
# 选择一个commit，合并进当前分支
$ git cherry-pick [commit]
# 删除分支
$ git branch -d [branch-name]
# 删除远程分支
$ git push origin --delete [branch-name]
$ git branch -dr [remote/branch]

六、标签

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18