atom.xml

<?xml version="1.0"?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <id>http://example.com</id>
    <title>Chen</title>
    <link href="http://example.com" />
    <updated>2024-09-18T06:19:07.000Z</updated>
    <category term="Java" />
    <category term="Vue3" />
    <category term="GLM" />
    <category term="AI_Boot" />
    <category term="dp" />
    <category term="git" />
    <category term="位运算" />
    <category term="分类讨论" />
    <category term="redis" />
    <category term="lunix" />
    <category term="vue3" />
    <category term="机器学习" />
    <category term="LLM" />
    <category term="AI" />
    <category term="Vue.js" />
    <category term="微信小程序" />
    <category term="工作流" />
    <category term="工作总结" />
    <category term="面试" />
    <category term="chatgpt" />
    <category term="设计模式" />
    <entry>
        <id>http://example.com/2024/09/18/%E5%B7%A5%E4%BD%9C%E6%B5%81%E5%AD%A6%E4%B9%A0/</id>
        <title>工作流学习</title>
        <link rel="alternate" href="http://example.com/2024/09/18/%E5%B7%A5%E4%BD%9C%E6%B5%81%E5%AD%A6%E4%B9%A0/"/>
        <content type="html">&lt;h1 id=&#34;工作流workflow&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#工作流workflow&#34;&gt;#&lt;/a&gt; 工作流（Workflow）&lt;/h1&gt;
&lt;p&gt;是对工作流程及其各操作步骤之间业务规则的抽象、概括描述。工作流建模，即将工作流程中的工作如何前后组织在一起的逻辑和规则，在计算机中以恰当的模型表达并对其实施计算。工作流要解决的主要问题是：为实现某个业务目标，利用计算机在多个参与者之间按某种预定规则&lt;strong&gt;自动&lt;/strong&gt;传递文档、信息或者任务。（Wikipedia）&lt;/p&gt;
&lt;p&gt;简而言之，工作流是对业务的流程化抽象，使用&lt;strong&gt;工作流引擎&lt;/strong&gt;来实现低代码 / 自动化管理业务。&lt;/p&gt;
&lt;p&gt;WFMC 给出了工作流参考模型如下：&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;clip_image002.jpg&#34; alt=&#34;img&#34; /&gt;&lt;/p&gt;
&lt;h2 id=&#34;为什么我们需要工作流&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#为什么我们需要工作流&#34;&gt;#&lt;/a&gt; 为什么我们需要工作流&lt;/h2&gt;
&lt;p&gt;相信大家都了解流水线的好处，蒸汽时代就是将手工化转变成了流水线化，手工有明显的一个缺点，就是生产效率极低，而流水线则可以提高生成效率。&lt;/p&gt;
&lt;p&gt;那么工作流则是将业务流水线化，从原来的一团处理逻辑清晰的划分成为若干个步骤，每个步骤流转清晰明显。每个模块有非常高的内聚，模块之前有非常清晰的依赖。&lt;/p&gt;
&lt;p&gt;外网最高的工作流的优点回答如下：&lt;/p&gt;
&lt;p&gt;Workflows can help streamline and automate repeatable business tasks, minimizing room for errors and increasing overall efficiency. This, in turn, dramatically improves your business. Managers can make quicker, smarter decisions and employees are empowered to collaborate in a more productive and agile way.&lt;br /&gt;
 举个例子，退款本身非常复杂，运营、产品、技术、财务可能都无法从单一的角色来解释清楚到底退款的整个链路和关键环节，但是通过工作流的方式来呈现，则所有人能快速看到退款到底是个什么样的业务。&lt;/p&gt;
&lt;p&gt;（工作流解决的&lt;strong&gt;痛点在于，解除业务宏观流程和微观逻辑的耦合&lt;/strong&gt;，让熟悉宏观业务流程的人去制定整套流转逻辑，而让专业的人只需要关心他们应当关心的流程节点，就好比大家要一起修建一座超级体育场，路人甲只需要关心他身边的这一堆砖是怎么堆砌而非整座建筑。）&lt;/p&gt;
&lt;p&gt;根据实际业务中对工作流的大量使用，我们总结出工作流有以下的优点：&lt;/p&gt;
&lt;h3 id=&#34;业务可视化&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#业务可视化&#34;&gt;#&lt;/a&gt; 业务可视化&lt;/h3&gt;
&lt;p&gt;首先，最大的优点，就是可以借助工作流引擎，让业务可视化，可以通过视图看到整个业务流程，每个节点执行什么业务逻辑一目了然，分支处理、异常处理也非常清晰。&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;clip_image004.jpg&#34; alt=&#34;img&#34; /&gt;&lt;/p&gt;
&lt;h3 id=&#34;业务可编排&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#业务可编排&#34;&gt;#&lt;/a&gt; 业务可编排&lt;/h3&gt;
&lt;p&gt;如果业务永远不变化，那么我们硬编码在一个方法里也无所谓。但是我们知道业务是千变万化的，软件设计很重要的一个指标就是灵活可扩展。工作流流程的重编排，则可以使得业务进一步在代码层面增加灵活性。可以通过节点的调整来快速调整业务流程，可以灵活增删节点，而不至于对整个流程有影响。&lt;/p&gt;
&lt;p&gt;还是以上面的为例，如果要增加一个【关闭用户权益】的节点，或者删除【用户消息】，那么我们很容易利用工作流增删原有流程。这里实现了代码可维护里最核心的两点：改动代码最简单和改动代码最快。&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;clip_image006.jpg&#34; alt=&#34;img&#34; /&gt;&lt;/p&gt;
&lt;h3 id=&#34;自动重试&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#自动重试&#34;&gt;#&lt;/a&gt; 自动重试&lt;/h3&gt;
&lt;p&gt;对于某些工作流来说，&lt;strong&gt;工作流引擎提供了框架层面持久化和自动重试的能力&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;clip_image008.jpg&#34; alt=&#34;img&#34; /&gt;&lt;/p&gt;
&lt;p&gt;上述是实际交易生产系统接收支付宝支付成功后回调后要处理的异步流程。而且在业务变化时，还需要对流程里动态增删业务功能。由于像【优惠券处理】或者【活动处理】节点依赖条件较多，很可能会处理失败需要重试，但是又不想把所有节点重试一遍，此时工作流引擎的持久化和节点重试能力，则是非常完美的方案。&lt;/p&gt;
&lt;h1 id=&#34;工作流引擎&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#工作流引擎&#34;&gt;#&lt;/a&gt; 工作流引擎&lt;/h1&gt;
&lt;p&gt;我们明白什么是工作流的定义以及为什么需要工作流。那么&lt;strong&gt;工作流引擎则是实现驱动工作流的一套实现工具&lt;/strong&gt;。工作流本质上是业务流的抽象，因此不同分类的业务流则形成了不同的工作流，进而有不同的工作流引擎来负责对不同类别的工作流进行具体的定义和实现。&lt;/p&gt;
&lt;p&gt;市场上比较有名的开源流程引擎有 osworkflow、jbpm、activitiy、flowable、camunda。其中：Jbpm4、Activiti、Flowable、camunda 四个框架同宗同源，祖先都是 Jbpm4，开发者只要用过其中一个框架，基本上就会用其它三个。开发低代码平台、OA 系统（Office Automation System，办公自动化系统）、BPM 软件均需要流程可视化功能，而&lt;strong&gt;流程可视化核心是流程引擎和流程设计器&lt;/strong&gt;，我们常说的工作流引擎，一般都包括设计器的能力，即负责对业务流程的拖拽式工具，有插件式也有 WEB 云端式的。（可视化工具）&lt;/p&gt;
&lt;p&gt;对于市场上如此多的开源流程引擎，哪个功能和性能好，该如何选型呢？&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;名词解释&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;BPMN（Business Process Modeling Notation）：指业务流程建模与符号&lt;/li&gt;
&lt;li&gt;CMMN (Case Management Model and Notation)：案例管理模型与符号&lt;/li&gt;
&lt;li&gt;DMN (Decision Model and Notation)：决策模型与符号&lt;/li&gt;
&lt;li&gt;表单引擎 (Form Engine)&lt;/li&gt;
&lt;li&gt;PVM（Process Virtual Machine）：流程虚拟机，特定可执行的&lt;strong&gt;图形化开发框架&lt;/strong&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img data-src=&#34;clip_image010.png&#34; alt=&#34;img&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;clip_image012.png&#34; alt=&#34;img&#34; /&gt;&lt;/p&gt;
&lt;h2 id=&#34;工作流引擎-选型&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#工作流引擎-选型&#34;&gt;#&lt;/a&gt; 工作流引擎 选型&lt;/h2&gt;
&lt;h3 id=&#34;osworkflow-简单的流程&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#osworkflow-简单的流程&#34;&gt;#&lt;/a&gt; Osworkflow (简单的流程)&lt;/h3&gt;
&lt;p&gt;官方网站：&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cDovL3d3dy5vcGVuc3ltcGhvbnkuY29tL29zd29ya2Zsb3cv&#34;&gt;http://www.opensymphony.com/osworkflow/&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;Osworkflow 是一个轻量化的流程引擎，比较灵活的轻量级的框架，但是在流程建模方面不太友好，需要&lt;strong&gt;手动编写 xml 文件去定义流程文件&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;Osworkflow 基于状态机机制，数据库表很少，Osworkflow 提供的工作流构成元素有：步骤（step）、条件（conditions）、循环（loops）、分支（splits）、合并（joins）等，但不支持会签、跳转、退回、加签等这些操作，需要自己扩展开发，有一定难度。&lt;strong&gt;而且 OsWorkFlow 组件已过时，长时间没有版本升级了&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;JBPM（国内生态没那么好，不建议选择 jBPM5 以后版本）&lt;/p&gt;
&lt;p&gt;Github: &lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9naXRodWIuY29tL2tpZWdyb3VwL2picG0=&#34;&gt;https://github.com/kiegroup/jbpm&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;jBPM 是一套灵活的商业进程管理 (BPM) 套件。轻量、开源 (基于 Apache License 2.0) 、使用 Java 实现。你可以用于商业进程与案例整个生命周期中的建模、执行与监控。&lt;/p&gt;
&lt;p&gt;JBPM 由 JBoss 公司开发，目前最高版本 JPBM7，不过从 JBPM5 开始已经跟之前不是同一个产品了，JBPM5 的代码基础不是 JBPM4，而是从 Drools Flow 重新开始。&lt;/p&gt;
&lt;p&gt;JBPM 自从版本五后，便重启炉灶，完全抛弃了 JBMP4 的代码基础，重新基于 drools 进行了实现。JBPM5，JBPM6 似乎缺少一个合格的系统架构师，其接口设计匪夷所思，基本上是按照 drools 的接口再提供了一套 JBPM 接口，同名的接口，实现类不断重复出现，代码体系十分混乱。&lt;strong&gt;基于 Drools Flow 技术在国内市场上用的很少，所有不建议选择 jBPM5 以后版本。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;JBPM5，JBPM6 是一个巨大的失败，使用 drools 规则引擎来实现工作流引擎听起来是一个很酷的概念，但 JBPM 开发团队显然没有很好地去掌控好整个架构的变化。因此选择 activiti 作为工作流引擎至少在可见的几年间都是正道，今后需要实现规则库时，再单独引入 drools 工具包，相信 drools 会是一个比 JBPM 靠谱的工具。&lt;/p&gt;
&lt;p&gt;jBPM4 诞生的比较早，后来 JBPM4 创建者 Tom Baeyens 离开 JBoss 后，加入 Alfresco 后很快推出了新的基于 jBPM4 的开源工作流系统 Activiti, 另外 JBPM 以 hibernate 作为数据持久化 ORM 也已不是主流技术。笔者在 2012 年开发某集团 BPM 平台时，选择的就是 JBPM4.4 版本，也是 4 系列的最后一个版本，进行了大量的扩展开发，才实现中国特色的流程需求。现在时间节点（2023）选择流程引擎，JBPM 不是最佳选择。官方网站：&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly93d3cuamJwbS5vcmcv&#34;&gt;https://www.jbpm.org/&lt;/span&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;jBPM3 是一个完整的工作流系统实现，面向开发人员，目的在于简化对组织核心流程进行支撑的软件创建，不支持标准。&lt;/li&gt;
&lt;li&gt;jBPM4 引入 PVM，使其拥有更强大的扩展性，同时增加 BPMS 特性，这些特性包括了对 BPMN 的支持、面向业务人员的 Web 建模器和简单统计分析功能的加入。&lt;/li&gt;
&lt;li&gt;jBPM5 基于原先的 Drools Flow，支持 BPMN，通过与 Drools 的合并支持 BAM，通过内容仓库增加对流程&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9zby5jc2RuLm5ldC9zby9zZWFyY2g/cT0lRTUlOEYlQUYlRTglQTclODYlRTUlOEMlOTYmYW1wO3NwbT0xMDAxLjIxMDEuMzAwMS43MDIw&#34;&gt;可视化&lt;/span&gt;的支持。由于放弃了 jBPM4 的 PVM，引擎的可扩展性受到损害，并且不再支持 jPDL。&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;activiti&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#activiti&#34;&gt;#&lt;/a&gt; Activiti&lt;/h3&gt;
&lt;p&gt;官方网站：&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly93d3cuYWN0aXZpdGkub3JnLw==&#34;&gt;https://www.activiti.org/&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;activiti 由 Alfresco 软件开发，目前（2023）最高版本 activiti 7。版本比较复杂，有 activiti5、activiti6、activiti7 几个主流版本，选型时让人晕头转向，有必要先了解一下 activiti 这几个版本的发展历史。&lt;/p&gt;
&lt;p&gt;activiti5 和 activiti6 的核心 leader 是 Tijs Rademakers， Activiti5 基于 jBPM4 的开源工作流系统，与 Alfresco 的集成增加了其流程可视化与管理能力，同时通过创新的 Activiti Cycle 协作组件支持流程相关人员之间的协调，最后，它加强了集成能力。&lt;/p&gt;
&lt;p&gt;由于团队内部分歧，在 2017 年时 Tijs Rademakers 离开团队，创建了后来的 flowable, activiti6 以及 activiti5 代码已经交接给了 Salaboy 团队，&lt;strong&gt;activiti6**** 以及 activiti5 的代码官方已经暂停维护了&lt;/strong&gt;，Salaboy 团队目前在开发 activiti7 框架，activiti7 内核使用的还是 activiti6，并没有为引擎注入更多的新特性，只是在 activiti 之外的上层封装了一些应用。&lt;/p&gt;
&lt;h3 id=&#34;flowable&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#flowable&#34;&gt;#&lt;/a&gt; Flowable&lt;/h3&gt;
&lt;p&gt;官方网站：&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9mbG93YWJsZS5jb20vb3Blbi1zb3VyY2Uv&#34;&gt;https://flowable.com/open-source/&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;**flowable 基于 activiti6 衍生出来的版本，**flowable 目前最新版本是 v6.6.0，开发团队是从 activiti 中分裂出来的，修复了一众 activiti6 的 bug，并在其基础上研发了 DMN 支持，BPEL 支持等等，相对开源版，其商业版的功能会更强大。以 flowable6.4.1 版本为分水岭，大力发展其商业版产品，&lt;strong&gt;开源版本维护不及时，部分功能已经不再开源版发布&lt;/strong&gt;，比如表单生成器（表单引擎）、历史数据同步至其他数据源、ES 等。&lt;/p&gt;
&lt;p&gt;Flowable 是一个使用 Java 编写的轻量级业务流程引擎，使用 Apache V2 license 协议开源。2016 年 10 月，Activiti 工作流引擎的主要开发者离开 Alfresco 公司并在 Activiti 分支基础上开启了 Flowable 开源项目。基于 Activiti v6 beta4 发布的第一个 Flowable release 版本为 6.0。Flowable 项目中包括 BPMN（Business Process Model and Notation）引擎、CMMN（Case Management Model and Notation）引擎、DMN（Decision Model and Notation）引擎、表单引擎（Form Engine）等模块。&lt;/p&gt;
&lt;h3 id=&#34;camunda&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#camunda&#34;&gt;#&lt;/a&gt; Camunda&lt;/h3&gt;
&lt;p&gt;官方网站：&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9kb2NzLmNhbXVuZGEub3JnL21hbnVhbC83LjE1LyVFMyU4MCU4Mg==&#34;&gt;https://docs.camunda.org/manual/7.15/。&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;Camunda 基于 activiti5，所以其保留了 PVM，最新版本 Camunda7.15，保持每年发布 2 个小版本的节奏，开发团队也是从 activiti 中分裂出来的，发展轨迹与 flowable 相似，同时也提供了商业版，不过对于一般企业应用，开源版本也足够了，详细见：&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d4ejI1OC9hcnRpY2xlL2RldGFpbHMvMTA5MDQzNzMlRTMlODAlODI=&#34;&gt;https://blog.csdn.net/wxz258/article/details/10904373。&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;笔者强烈推荐 camunda 流程引擎&lt;/strong&gt;，并在云程低代码平台中使用了 camunda, 功能和性能表现稳定。&lt;br /&gt;
选择 camunda 的理由：&lt;br /&gt;
（1）通过压力测试验证 Camunda BPMN 引擎性能和稳定性更好。详细见：&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d4ejI1OC9hcnRpY2xlL2RldGFpbHMvMTA5MDMwMzI5&#34;&gt;https://blog.csdn.net/wxz258/article/details/109030329&lt;/span&gt;&lt;br /&gt;
（2）功能比较完善，&lt;strong&gt;除了 BPMN，Camunda 还支持企业和社区版本中的 CMMN（案例管理）和 DMN（决策自动化）&lt;/strong&gt;。Camunda 不仅带有引擎，还带有非常强大的工具，用于 ** 建模，任务管理，操作监控和用户管理，所有这些都是开源的。** 详细见：&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d4ejI1OC9hcnRpY2xlL2RldGFpbHMvMTA5MTIxMDky&#34;&gt;https://blog.csdn.net/wxz258/article/details/109121092&lt;/span&gt;&lt;/p&gt;
&lt;h2 id=&#34;工作流引擎-对比&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#工作流引擎-对比&#34;&gt;#&lt;/a&gt; 工作流引擎 对比&lt;/h2&gt;
&lt;h3 id=&#34;camunda并发好和-flowable&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#camunda并发好和-flowable&#34;&gt;#&lt;/a&gt; Camunda（并发好）和 flowable&lt;/h3&gt;
&lt;p&gt;通过压力测试工具 JMeter 分别对 flowable 和 Camunda 进行高并发压力测试，并发用户数从 100 到 1000，JMeter 设置 Ramp-up 为 1，循环次数为 1，测试数据如下：&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;clip_image014.jpg&#34; alt=&#34;img&#34; /&gt;&lt;/p&gt;
&lt;p&gt;Camunda 我们还能正常的测试，Flowable 在并发 100 的情况下还可以，但是 200 的时候就直接没有了反应。&lt;/p&gt;
&lt;p&gt;结论：对&lt;strong&gt;并发量有要求的强烈推荐 Camunda&lt;/strong&gt;&lt;/p&gt;
&lt;h3 id=&#34;activiti71-jbpm725-camunda-flowable63技术组成对比&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#activiti71-jbpm725-camunda-flowable63技术组成对比&#34;&gt;#&lt;/a&gt; Activiti7.1, jBPM7.25, Camunda, Flowable6.3 技术组成对比&lt;/h3&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;strong&gt;序号&lt;/strong&gt;&lt;/th&gt;
&lt;th&gt;&lt;strong&gt;技术组成&lt;/strong&gt;&lt;/th&gt;
&lt;th&gt;&lt;strong&gt;Activiti7.1&lt;/strong&gt;&lt;/th&gt;
&lt;th&gt;&lt;strong&gt;jBPM7.25&lt;/strong&gt;&lt;/th&gt;
&lt;th&gt;&lt;strong&gt;Camunda&lt;/strong&gt;&lt;/th&gt;
&lt;th&gt;&lt;strong&gt;Flowable6.3.1&lt;/strong&gt;&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;数据库持久层 ORM&lt;/td&gt;
&lt;td&gt;MyBatis3.4.2&lt;/td&gt;
&lt;td&gt;JPA2.2 二次封装&lt;/td&gt;
&lt;td&gt;Hibernate4.2.0&lt;/td&gt;
&lt;td&gt;JPA 2.2&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;持久化标准&lt;/td&gt;
&lt;td&gt;JPA 规范&lt;/td&gt;
&lt;td&gt;JPA 规范&lt;/td&gt;
&lt;td&gt;JPA 规范&lt;/td&gt;
&lt;td&gt;JPA 规范&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;td&gt;事务管理&lt;/td&gt;
&lt;td&gt;MyBatis 机制 /  Spring 事务控制&lt;/td&gt;
&lt;td&gt;Bitronix，  基于 JTA 事务管理&lt;/td&gt;
&lt;td&gt;hibernate 机制 /  Spring 事务控制&lt;/td&gt;
&lt;td&gt;hibernate 机制 /  Spring 事务控制&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;td&gt;分布式事务&lt;/td&gt;
&lt;td&gt;MyBatis 机制 /  Spring 事务控制&lt;/td&gt;
&lt;td&gt;Bitronix，  基于 JTA 事务管理&lt;/td&gt;
&lt;td&gt;补偿机制，  SAGA 模式&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;td&gt;数据库连接方式&lt;/td&gt;
&lt;td&gt;Jdbc/DataSource&lt;/td&gt;
&lt;td&gt;Jdbc/DataSource&lt;/td&gt;
&lt;td&gt;Jdbc/DataSource&lt;/td&gt;
&lt;td&gt;Jdbc/DataSource&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;td&gt;支持数据库&lt;/td&gt;
&lt;td&gt;Oracle、SQL  Server、MySQL&lt;/td&gt;
&lt;td&gt;Oracle、SQL  Server、MySQL&lt;/td&gt;
&lt;td&gt;Oracle、SQL  Server、MySQL、db2&lt;/td&gt;
&lt;td&gt;Oracle、SQL  Server、MySQL、db2&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6&lt;/td&gt;
&lt;td&gt;设计模式&lt;/td&gt;
&lt;td&gt;Command 模式、观察者模式等&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;内部服务通讯&lt;/td&gt;
&lt;td&gt;Service 间通过  API 调用&lt;/td&gt;
&lt;td&gt;基于 Apache   Mina 异步通讯&lt;/td&gt;
&lt;td&gt;Service 间通过  API 调用&lt;/td&gt;
&lt;td&gt;Service 间通过 API 调用&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;8&lt;/td&gt;
&lt;td&gt;集成接口&lt;/td&gt;
&lt;td&gt;SOAP、Mule、  RESTful&lt;/td&gt;
&lt;td&gt;消息通讯&lt;/td&gt;
&lt;td&gt;SOAP、Mule、RESTful&lt;/td&gt;
&lt;td&gt;SOAP、Mule、RESTful&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;9&lt;/td&gt;
&lt;td&gt;支持的流程格式&lt;/td&gt;
&lt;td&gt;BPMN2、xPDL、jPDL 等&lt;/td&gt;
&lt;td&gt;目前仅只支持 BPMN2 xml&lt;/td&gt;
&lt;td&gt;BPMN2、xPDL、jPDL 等&lt;/td&gt;
&lt;td&gt;BPMN2、xPDL、jPDL 等&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;td&gt;引擎核心&lt;/td&gt;
&lt;td&gt;PVM（流程虚拟机）&lt;/td&gt;
&lt;td&gt;Drools&lt;/td&gt;
&lt;td&gt;PVM&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;11&lt;/td&gt;
&lt;td&gt;架构&lt;/td&gt;
&lt;td&gt;spring  boot 2.1.2,  spring  5.1.4&lt;/td&gt;
&lt;td&gt;Drools  Flow&lt;/td&gt;
&lt;td&gt;activiti5&lt;/td&gt;
&lt;td&gt;spring  boot 1.5, spring 4.3，  spring  security 4.2&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;12&lt;/td&gt;
&lt;td&gt;支持 J2EE&lt;/td&gt;
&lt;td&gt;兼容&lt;/td&gt;
&lt;td&gt;天然支持 EJB,J2EE&lt;/td&gt;
&lt;td&gt;兼容&lt;/td&gt;
&lt;td&gt;兼容&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;13&lt;/td&gt;
&lt;td&gt;技术前身&lt;/td&gt;
&lt;td&gt;jBPM3、jBPM4&lt;/td&gt;
&lt;td&gt;Drools  Flow&lt;/td&gt;
&lt;td&gt;activiti5&lt;/td&gt;
&lt;td&gt;activiti5&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;14&lt;/td&gt;
&lt;td&gt;API 文档&lt;/td&gt;
&lt;td&gt;swagger1.5&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;swagger1.5&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;15&lt;/td&gt;
&lt;td&gt;日志&lt;/td&gt;
&lt;td&gt;slf4j1.7 门面，  logback1.2.3&lt;/td&gt;
&lt;td&gt;slf4j1.5 门面，log4j&lt;/td&gt;
&lt;td&gt;slf4j1.7 门面，  logback1.2.3&lt;/td&gt;
&lt;td&gt;slf4j1.7 门面&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;16&lt;/td&gt;
&lt;td&gt;所属公司&lt;/td&gt;
&lt;td&gt;Alfresco&lt;/td&gt;
&lt;td&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cDovL2pCb3NzLm9yZw==&#34;&gt;jBoss.org&lt;/span&gt;&lt;/td&gt;
&lt;td&gt;Camunda&lt;/td&gt;
&lt;td&gt;Flowable&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h3 id=&#34;camunda与flowable对比&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#camunda与flowable对比&#34;&gt;#&lt;/a&gt; camunda 与 flowable 对比&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;\1.   camunda 支持流程实例的迁移，比如同一个流程有多个实例，多个流程版本，不同流程实例运行在不同的版本中，camunda 支持任意版本的实例迁移到指定的流程版本中，并可以在迁移的过程中支持从哪个节点开始。&lt;/li&gt;
&lt;li&gt;\2.   camunda 基于 PVM 技术，所以用户从 Activii5 迁移到 camunda 基本上毫无差异。flowable 没有 pvm 了，所以迁移工作量更大（实例的迁移，流程定义的迁移、定时器的迁移都非常麻烦）。&lt;/li&gt;
&lt;li&gt;\3.   camunda 对于每一个 CMD 命令类都提供了权限校验机制，flowable 没有。&lt;/li&gt;
&lt;li&gt;\4.   camunda 继续每一个 API 都有批处理的影子，flowable 几乎没有。比如批量挂起流程、激活流程等，使用 camunda 可以直接使用 API 操作，使用 Flowable 则只能自己去查询集合，然后循环遍历集合并操作。&lt;/li&gt;
&lt;li&gt;\5.   camunda 很多 API 均支持批处理，在批量处理的时候可以指定是异步方式操作或者是同步方式操作。异步的话定时器会去执行。Flowable 没有异步批处理的机制。比如批量异步删除所有的历史数据。&lt;/li&gt;
&lt;li&gt;\6.   camunda 启动实例的时候支持从哪个节点开始，而不是仅仅只能从开始节点运转实例。Flowable 仅仅只能从开始节点运转实例。&lt;/li&gt;
&lt;li&gt;\7.   camunda 支持任意节点的跳转，可以跳转到连线也可以跳转到节点，并且在跳转的过程中支持是否触发目标节点的监听器。flowable 没有改原生 API 需用户去扩展。&lt;/li&gt;
&lt;li&gt;\8.   camunda 支持双异步机制，第一个异步即节点可以异步执行，第二个异步方式是：完成异步任务后，还可以继续异步去执行任务后面的连线。所以称之为双异步机制，flowable 只有第一种异步方式。&lt;/li&gt;
&lt;li&gt;\9.   camunda 支持多种脚本语言，这些脚本语言可以在连线上进行条件表达式的配置，开箱即用。比如 python、ruby、groovy、JUEL。flowable 仅仅支持 JUEL、groovy。开箱即用的意思就是如果想用 python 直接引入 jython 包就可以用了，不需要额外配置。&lt;/li&gt;
&lt;li&gt;\10.  camunda 支持外部任务，比如我们有时候想在一个节点中执行调用第三方的 API 或者完成一些特定的逻辑操作，就可以使用外部任务，外部任务有两种表，并支持第三方系统定期来抓取并锁定外部任务，然后执行业务完毕之后，完成外部任务，流程实例继续往下执行。外部任务的好处就是解决了分布式事物的问题。在 flowable 中我们可以使用 httpTask 任务，我个人更倾向于 camunda 外部任务，因为这个外部任务有外部系统决定什么时候完成，httpTask 是不等待任务，实例走到这个节点之后，调用一个 api 就直接往下跑了，外部任务不会继续往下跑，有外部系统去决定啥时候往下跑。&lt;/li&gt;
&lt;li&gt;\11.  camunda 支持为用户定制一些个性化的偏好查找 API，比如张三每次查询任务的时候，一般固定点击某某三个查询条件过滤数据，使用 camunda 就可以将这三个查询条件进行持久化，下次张三来了，就可以直接根据他的偏好进行数据的过滤，类似机器学习。&lt;/li&gt;
&lt;li&gt;\12.  camunda 支持历史数据的批量删除或者批量迁移到其他介质，比如批量迁移到 es，flowable 没有该机制。&lt;/li&gt;
&lt;li&gt;\13.  camunda 支持在高并发部署流程的时候，是否使用锁机制，flowable 没有该机制。&lt;/li&gt;
&lt;li&gt;\14.  camunda 支持单引擎多组合、多引擎多库。flowable 仅仅支持单引擎多组合。&lt;/li&gt;
&lt;li&gt;\15.  camunda 支持流程实例跨流程定义跳转，flowable 没有该机制。&lt;/li&gt;
&lt;li&gt;\16.  camunda 支持分布式定时器，flowable 没有该机制。&lt;/li&gt;
&lt;li&gt;\17.  flowable 支持 NoSQL, camunda 只有 NoSQL 的解决方案。&lt;/li&gt;
&lt;li&gt;\18.  camunda 支持优化流程，以及了解流程引擎的瓶颈所在和每个环节的耗时，flowable 没有该机制。&lt;/li&gt;
&lt;li&gt;\19.  camunda 修改了流程模板 xml 解析方式，相比 flowable 性能更好。&lt;/li&gt;
&lt;li&gt;\20.  camunda 在解析流程模板 xml 的时候，去除了 activiti5 的双解析机制，相对而言耗时时间更短。flowable 没有了 pvm 所以规避了双解析机制。&lt;/li&gt;
&lt;li&gt;\21.  camunda 可以在任意节点添加任意的属性，flowable 原生 API 没有，需要自己扩展。&lt;/li&gt;
&lt;li&gt;\22.  camunda 框架没有为流程生成图片的 API (所有流程图展示以及高亮均在前端动态计算)，activiti5/6/flowable5/flowable6 有图片生成以及高亮的 API.&lt;/li&gt;
&lt;li&gt;\23.  camunda 可以在节点中定义定时作业的优先级，也可以在流程中进行全局优先级的定义。当节点没有定义优先级的时候可以使用全局的优先级字段。activiti5/6/flowable5/flowable6 没有改功能。&lt;/li&gt;
&lt;li&gt;\24.  camunda 可以再流程中定义流程的 tag 标记，activiti5/6/flowable5/flowable6 没有改功能。&lt;/li&gt;
&lt;li&gt;\25.  camunda/activiti5/6/flowable5/flowable6 均不支持国产数据库，比如人大金仓和达梦。&lt;/li&gt;
&lt;li&gt;\26.  flowable6 支持 LDAP，openLDAP, camunda 不支持。activiti5 不支持。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3 id=&#34;性能方面对比&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#性能方面对比&#34;&gt;#&lt;/a&gt; 性能方面对比&lt;/h3&gt;
&lt;p&gt;通过 flowable 和 camunda 多组对比测试，camunda 性能比 flowable 提升最小 10%，最大 39%，而且 camunda 无报错，flowable 有报错，camunda 在高并发场景下稳定性更好。&lt;/p&gt;
&lt;h2 id=&#34;流程设计器-选型&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#流程设计器-选型&#34;&gt;#&lt;/a&gt; 流程设计器 选型&lt;/h2&gt;
&lt;p&gt;对于低代码平台中的&lt;strong&gt;流程可视化，流程设计器是重要的支撑工具&lt;/strong&gt;，目前市场上比较主流的流程设计器有 bpmn-js、Mx Graph、Activiti-Modeler、flowable-modeler、easy-flow、bpmn2-modeler 插件等。&lt;/p&gt;
&lt;h3 id=&#34;bpmn-js&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#bpmn-js&#34;&gt;#&lt;/a&gt; bpmn-js&lt;/h3&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9icG1uLmlvLw==&#34;&gt;Web-based tooling for BPMN, DMN, CMMN, and Forms | bpmn.io&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;bpmn-js 是 BPMN 2.0 渲染工具包和 Web 模型。bpmn-js 正在努力成为 Camunda BPM 的一部分。&lt;/p&gt;
&lt;p&gt;bpmn-js 使用 Web 建模工具可以很方便的构建 BPMN 图表，可以把 BPMN 图表嵌入到项目中，容易扩展。&lt;strong&gt;bpmn-js 是基于原生 js 开发，支持集成到 Vue、react 等开源框架中&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;clip_image016.jpg&#34; alt=&#34;img&#34; /&gt;&lt;/p&gt;
&lt;h3 id=&#34;mxgraph&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#mxgraph&#34;&gt;#&lt;/a&gt; mxGraph&lt;/h3&gt;
&lt;p&gt;官方网站：&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cDovL2pncmFwaC5naXRodWIuaW8vbXhncmFwaC8=&#34;&gt;http://jgraph.github.io/mxgraph/&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;mxGraph 是一个强大的 JavaScript 流程图前端库，可以快速创建交互式图表和图表应用程序，国内外著名的 ProcessOne 和 draw.io 都是使用该库创建的强大的在线流程图绘制网站。由于 mxGraph 是一个开放的 js 绘图开发框架，我们可以开发出很炫的样式，或者完全按照项目需求定制。&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;clip_image018.jpg&#34; alt=&#34;img&#34; /&gt;&lt;/p&gt;
&lt;h3 id=&#34;activiti-modeler&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#activiti-modeler&#34;&gt;#&lt;/a&gt; Activiti-Modeler&lt;/h3&gt;
&lt;p&gt;Activiti 开源版本中带了 web 版流程设计器，在 Activiti-explorer 项目中有 Activiti-Modeler，优点是集成简单，开发工作量小，缺点是界面不美观，用户体验差。&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;clip_image020.jpg&#34; alt=&#34;img&#34; /&gt;&lt;/p&gt;
&lt;h3 id=&#34;flowable-modeler&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#flowable-modeler&#34;&gt;#&lt;/a&gt; flowable-modeler&lt;/h3&gt;
&lt;p&gt;flowable 开源版本中带了 web 版流程设计器，展示风格和功能基本跟 Activiti-Modeler 一样，优点是集成简单，开发工作量小，缺点是界面不美观，用户体验差。&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;clip_image022.jpg&#34; alt=&#34;img&#34; /&gt;&lt;/p&gt;
&lt;h1 id=&#34;选型标准的几个标准activiti7-or-flowable-v7&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#选型标准的几个标准activiti7-or-flowable-v7&#34;&gt;#&lt;/a&gt; 选型标准的几个标准（Activiti7 or Flowable V7）&lt;/h1&gt;
&lt;ul&gt;
&lt;li&gt;业务需求：根据自身业务需求，评估工作流引擎的性能、扩展性、数据库支持等方面的要求。&lt;/li&gt;
&lt;li&gt;社区支持：了解工作流引擎的社区规模和活跃程度，以便在遇到问题时能够及时获得帮助和支持。&lt;/li&gt;
&lt;li&gt;文档质量：评估工作流引擎的文档质量，以确保能够轻松地学习和使用。&lt;/li&gt;
&lt;/ul&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th style=&#34;text-align:center&#34;&gt;对比&lt;/th&gt;
&lt;th style=&#34;text-align:left&#34;&gt;Activiti 7&lt;/th&gt;
&lt;th&gt;Flowable V7&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td style=&#34;text-align:center&#34;&gt;github star&lt;/td&gt;
&lt;td style=&#34;text-align:left&#34;&gt;10.1K&lt;/td&gt;
&lt;td&gt;7.8K&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td style=&#34;text-align:center&#34;&gt;JDK 版本要求&lt;/td&gt;
&lt;td style=&#34;text-align:left&#34;&gt;JDK 21&lt;/td&gt;
&lt;td&gt;JDK 17 +&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td style=&#34;text-align:center&#34;&gt;BPMN2 协议&lt;/td&gt;
&lt;td style=&#34;text-align:left&#34;&gt;支持&lt;/td&gt;
&lt;td&gt;支持&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td style=&#34;text-align:center&#34;&gt;设计器&lt;/td&gt;
&lt;td style=&#34;text-align:left&#34;&gt;idea 插件&lt;/td&gt;
&lt;td&gt;提供免费使用的 &amp;lt;br /&amp;gt; Flowable Cloud Design 应用程序&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td style=&#34;text-align:center&#34;&gt;扩展节点 (Mule\Http 等)&lt;/td&gt;
&lt;td style=&#34;text-align:left&#34;&gt;&lt;/td&gt;
&lt;td&gt;动态过程注入&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td style=&#34;text-align:center&#34;&gt;数据库&lt;/td&gt;
&lt;td style=&#34;text-align:left&#34;&gt;&lt;/td&gt;
&lt;td&gt;支持非关系型数据库&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td style=&#34;text-align:center&#34;&gt;并行网关&lt;/td&gt;
&lt;td style=&#34;text-align:left&#34;&gt;本质是串行&lt;/td&gt;
&lt;td&gt;并行&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td style=&#34;text-align:center&#34;&gt;&lt;/td&gt;
&lt;td style=&#34;text-align:left&#34;&gt;依赖 spring security&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td style=&#34;text-align:center&#34;&gt;接口&lt;/td&gt;
&lt;td style=&#34;text-align:left&#34;&gt;封装了一层 TaskRuntime・・・&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td style=&#34;text-align:center&#34;&gt;侧重（2022）&lt;/td&gt;
&lt;td style=&#34;text-align:left&#34;&gt;侧重云&lt;/td&gt;
&lt;td&gt;做一个功能丰富的流程引擎工具，扩展点&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;&lt;a href=&#34;https://www.flowable.com/blog/engineering/top-10-advances-flowable-made-since-activiti&#34;&gt;（flowable&lt;strong&gt;2020&lt;/strong&gt; ）自 Activiti 以来 Flowable 取得的十大进步 --- Top 10 advances Flowable made since Activiti&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Activiti 目前是侧重云&lt;/strong&gt;，他目前的设计会向 Spring Cloud、Docker 这些去靠拢&lt;br /&gt;
&lt;strong&gt; Flowable 核心思想还是在做一个功能丰富的流程引擎工具&lt;/strong&gt;，除了最最基础的工作流，他还提供了很多其他的扩展点，我们可以基于 Flowable 实现出许多我们想要的功能（当然这也是小伙伴们觉得 Flowable 使用复杂的原因之一）&lt;/p&gt;
&lt;p&gt;（2022）&lt;/p&gt;
&lt;h1 id=&#34;市面现有的低代码bmp平台&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#市面现有的低代码bmp平台&#34;&gt;#&lt;/a&gt; 市面现有的低代码 BMP 平台&lt;/h1&gt;
&lt;h2 id=&#34;驰聘&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#驰聘&#34;&gt;#&lt;/a&gt; 驰聘&lt;/h2&gt;
&lt;p&gt;...&lt;/p&gt;
&lt;h2 id=&#34;ultimus安码&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#ultimus安码&#34;&gt;#&lt;/a&gt; Ultimus（安码）&lt;/h2&gt;
&lt;p&gt;...&lt;/p&gt;
&lt;h2 id=&#34;泛微&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#泛微&#34;&gt;#&lt;/a&gt; 泛微&lt;/h2&gt;
&lt;p&gt;...&lt;/p&gt;
&lt;h1 id=&#34;引用&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#引用&#34;&gt;#&lt;/a&gt; 引用&lt;/h1&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2p1c3RscGYvYXJ0aWNsZS9kZXRhaWxzLzEyNjQwNjE2OA==&#34;&gt;常见的工作流引擎 (osworkflow、jbpm、activiti、flowable、camunda) 比较 - CSDN 博客&lt;/span&gt;&lt;/p&gt;
</content>
        <category term="工作流" />
        <updated>2024-09-18T06:19:07.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2024/08/29/Neko-Pardofelis/</id>
        <title>Neko Pardofelis</title>
        <link rel="alternate" href="http://example.com/2024/08/29/Neko-Pardofelis/"/>
        <content type="html">&lt;h2 id=&#34;前言&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#前言&#34;&gt;#&lt;/a&gt; 前言&lt;/h2&gt;
&lt;p&gt;继暖言猫猫之后，我看到了好多猫猫，发 * 猫猫，屑屑猫猫…… 诸如此类&lt;/p&gt;
&lt;p&gt;那么，我也想要一个帕朵儿猫猫！！！&lt;/p&gt;
&lt;h2 id=&#34;开源项目地址&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#开源项目地址&#34;&gt;#&lt;/a&gt; 开源项目地址&lt;/h2&gt;
&lt;p&gt;貌似没有……？！&lt;/p&gt;
&lt;h2 id=&#34;遗憾离场&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#遗憾离场&#34;&gt;#&lt;/a&gt; 遗憾离场&lt;/h2&gt;
</content>
        <category term="AI_Boot" />
        <updated>2024-08-29T00:40:45.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2024/08/26/%E7%AC%AC%E4%B8%80%E5%91%A8%E5%B7%A5%E4%BD%9C%E6%80%BB%E7%BB%93/</id>
        <title>第一周工作总结</title>
        <link rel="alternate" href="http://example.com/2024/08/26/%E7%AC%AC%E4%B8%80%E5%91%A8%E5%B7%A5%E4%BD%9C%E6%80%BB%E7%BB%93/"/>
        <content type="html">&lt;h2 id=&#34;环境部署&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#环境部署&#34;&gt;#&lt;/a&gt; 环境部署&lt;/h2&gt;
&lt;h2 id=&#34;gerrit-以及连接公司仓库&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#gerrit-以及连接公司仓库&#34;&gt;#&lt;/a&gt; gerrit 以及连接公司仓库&lt;/h2&gt;
&lt;pre&gt;&lt;code&gt;19625@chenchen MINGW64 /g/TuoShenProjects/backend_junior_study (master)
$ git status
On branch master
Your branch is up to date with &#39;origin/master&#39;.

Changes to be committed:
  (use &amp;quot;git restore --staged &amp;lt;file&amp;gt;...&amp;quot; to unstage)
        new file:   chenhang/.gitignore
        new file:   chenhang/.mvn/wrapper/maven-wrapper.properties
        new file:   chenhang/mvnw
        new file:   chenhang/mvnw.cmd
        new file:   chenhang/pom.xml
        new file:   chenhang/src/main/java/com/chenhang/ChenhangApplication.java
        new file:   chenhang/src/main/java/com/chenhang/config/RedisConfig.java
        new file:   chenhang/src/main/java/com/chenhang/controller/ArticleController.java
        new file:   chenhang/src/main/java/com/chenhang/controller/UserController.java
        new file:   chenhang/src/main/java/com/chenhang/mapper/ArticleMapper.java
        new file:   chenhang/src/main/java/com/chenhang/mapper/UserMapper.java
        new file:   chenhang/src/main/java/com/chenhang/model/Article.java
        new file:   chenhang/src/main/java/com/chenhang/model/User.java
        new file:   chenhang/src/main/java/com/chenhang/service/ArticleService.java
        new file:   chenhang/src/main/java/com/chenhang/service/UserService.java
        new file:   chenhang/src/main/java/com/chenhang/service/impl/ArticleServiceImpl.java
        new file:   chenhang/src/main/java/com/chenhang/service/impl/UserServiceImpl.java
        new file:   chenhang/src/main/java/com/chenhang/utils/Result.java
        new file:   chenhang/src/main/java/com/chenhang/utils/ResultCodeEnum.java
        new file:   chenhang/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
        new file:   chenhang/src/main/resources/application.yaml
        new file:   chenhang/src/main/resources/db/migration/R1.0.1__Add_Posts.sql
        new file:   chenhang/src/main/resources/mapper/ArticleMapper.xml
        new file:   chenhang/src/main/resources/mapper/UserMapper.xml
        new file:   chenhang/src/test/java/com/chenhang/ChenhangApplicationTests.java


19625@chenchen MINGW64 /g/TuoShenProjects/backend_junior_study (master)
$ git restore --staged chenhang/

19625@chenchen MINGW64 /g/TuoShenProjects/backend_junior_study (master)
$ git status
On branch master
Your branch is up to date with &#39;origin/master&#39;.

Untracked files:
  (use &amp;quot;git add &amp;lt;file&amp;gt;...&amp;quot; to include in what will be committed)
        chenhang/

nothing added to commit but untracked files present (use &amp;quot;git add&amp;quot; to track)

19625@chenchen MINGW64 /g/TuoShenProjects/backend_junior_study (master)
$ git add chenhang/
warning: in the working copy of &#39;chenhang/.gitignore&#39;, LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of &#39;chenhang/.mvn/wrapper/maven-wrapper.properties&#39;, LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of &#39;chenhang/mvnw&#39;, LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of &#39;chenhang/mvnw.cmd&#39;, LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of &#39;chenhang/pom.xml&#39;, LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of &#39;chenhang/src/main/java/com/chenhang/ChenhangApplication.java&#39;, LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of &#39;chenhang/src/main/java/com/chenhang/model/Article.java&#39;, LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of &#39;chenhang/src/main/java/com/chenhang/model/User.java&#39;, LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of &#39;chenhang/src/main/resources/mapper/UserMapper.xml&#39;, LF will be replaced by CRLF the next time Git touches it
warning: in the working copy of &#39;chenhang/src/test/java/com/chenhang/ChenhangApplicationTests.java&#39;, LF will be replaced by CRLF the next time Git touches it

# 提交
19625@chenchen MINGW64 /g/TuoShenProjects/backend_junior_study (master)
$ git commit -m &amp;quot;add demo&amp;quot;
[master d268307] add demo
 25 files changed, 1342 insertions(+)
 create mode 100644 chenhang/.gitignore
 create mode 100644 chenhang/.mvn/wrapper/maven-wrapper.properties
 create mode 100644 chenhang/mvnw
 create mode 100644 chenhang/mvnw.cmd
 create mode 100644 chenhang/pom.xml
 create mode 100644 chenhang/src/main/java/com/chenhang/ChenhangApplication.java
 create mode 100644 chenhang/src/main/java/com/chenhang/config/RedisConfig.java
 create mode 100644 chenhang/src/main/java/com/chenhang/controller/ArticleController.java
 create mode 100644 chenhang/src/main/java/com/chenhang/controller/UserController.java
 create mode 100644 chenhang/src/main/java/com/chenhang/mapper/ArticleMapper.java
 create mode 100644 chenhang/src/main/java/com/chenhang/mapper/UserMapper.java
 create mode 100644 chenhang/src/main/java/com/chenhang/model/Article.java
 create mode 100644 chenhang/src/main/java/com/chenhang/model/User.java
 create mode 100644 chenhang/src/main/java/com/chenhang/service/ArticleService.java
 create mode 100644 chenhang/src/main/java/com/chenhang/service/UserService.java
 create mode 100644 chenhang/src/main/java/com/chenhang/service/impl/ArticleServiceImpl.java
 create mode 100644 chenhang/src/main/java/com/chenhang/service/impl/UserServiceImpl.java
 create mode 100644 chenhang/src/main/java/com/chenhang/utils/Result.java
 create mode 100644 chenhang/src/main/java/com/chenhang/utils/ResultCodeEnum.java
 create mode 100644 chenhang/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
 create mode 100644 chenhang/src/main/resources/application.yaml
 create mode 100644 chenhang/src/main/resources/db/migration/R1.0.1__Add_Posts.sql
 create mode 100644 chenhang/src/main/resources/mapper/ArticleMapper.xml
 create mode 100644 chenhang/src/main/resources/mapper/UserMapper.xml
 create mode 100644 chenhang/src/test/java/com/chenhang/ChenhangApplicationTests.java

19625@chenchen MINGW64 /g/TuoShenProjects/backend_junior_study (master)
$ gitdir=$(git rev-parse --git-dir); scp -p -P 29418 henhang@review.tpson.cn:hooks/commit-msg $&amp;#123;gitdir&amp;#125;/hooks/
subsystem request failed on channel 0
scp: Connection closed

# -O open 打开此（好吧我也不知道）
19625@chenchen MINGW64 /g/TuoShenProjects/backend_junior_study (master)
$ gitdir=$(git rev-parse --git-dir); scp -O -P 29418 henhang@review.tpson.cn:hooks/commit-msg $&amp;#123;gitdir&amp;#125;/hooks/
commit-msg                                                            100% 4693    44.7KB/s   00:00

# 提交 -m 描述
19625@chenchen MINGW64 /g/TuoShenProjects/backend_junior_study (master)
$ git commit --amend
[master 7ec50ca] add demo
 Date: Fri Aug 23 16:10:50 2024 +0800
 25 files changed, 1342 insertions(+)
 create mode 100644 chenhang/.gitignore
 create mode 100644 chenhang/.mvn/wrapper/maven-wrapper.properties
 create mode 100644 chenhang/mvnw
 create mode 100644 chenhang/mvnw.cmd
 create mode 100644 chenhang/pom.xml
 create mode 100644 chenhang/src/main/java/com/chenhang/ChenhangApplication.java
 create mode 100644 chenhang/src/main/java/com/chenhang/config/RedisConfig.java
 create mode 100644 chenhang/src/main/java/com/chenhang/controller/ArticleController.java
 create mode 100644 chenhang/src/main/java/com/chenhang/controller/UserController.java
 create mode 100644 chenhang/src/main/java/com/chenhang/mapper/ArticleMapper.java
 create mode 100644 chenhang/src/main/java/com/chenhang/mapper/UserMapper.java
 create mode 100644 chenhang/src/main/java/com/chenhang/model/Article.java
 create mode 100644 chenhang/src/main/java/com/chenhang/model/User.java
 create mode 100644 chenhang/src/main/java/com/chenhang/service/ArticleService.java
 create mode 100644 chenhang/src/main/java/com/chenhang/service/UserService.java
 create mode 100644 chenhang/src/main/java/com/chenhang/service/impl/ArticleServiceImpl.java
 create mode 100644 chenhang/src/main/java/com/chenhang/service/impl/UserServiceImpl.java
 create mode 100644 chenhang/src/main/java/com/chenhang/utils/Result.java
 create mode 100644 chenhang/src/main/java/com/chenhang/utils/ResultCodeEnum.java
 create mode 100644 chenhang/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
 create mode 100644 chenhang/src/main/resources/application.yaml
 create mode 100644 chenhang/src/main/resources/db/migration/R1.0.1__Add_Posts.sql
 create mode 100644 chenhang/src/main/resources/mapper/ArticleMapper.xml
 create mode 100644 chenhang/src/main/resources/mapper/UserMapper.xml
 create mode 100644 chenhang/src/test/java/com/chenhang/ChenhangApplicationTests.java

# 推送
19625@chenchen MINGW64 /g/TuoShenProjects/backend_junior_study (master)
$ git push origin HEAD:refs/for/master
Enumerating objects: 53, done.
Counting objects: 100% (53/53), done.
Delta compression using up to 16 threads
Compressing objects: 100% (42/42), done.
Writing objects: 100% (52/52), 17.40 KiB | 685.00 KiB/s, done.
Total 52 (delta 8), reused 1 (delta 0), pack-reused 0 (from 0)
remote: Resolving deltas: 100% (8/8)
remote: Processing changes: new: 1, refs: 1, done
remote:
remote: New Changes:
remote:   http://review.tpson.cn/85511 add demo
remote:
To ssh://review.tpson.cn:29418/backend_junior_study
 * [new reference]   HEAD -&amp;gt; refs/for/master

&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;任务&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#任务&#34;&gt;#&lt;/a&gt; 任务&lt;/h2&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240826090123972.png&#34; alt=&#34;image-20240826090123972&#34; /&gt;&lt;/p&gt;
&lt;h3 id=&#34;spring-boot常用依赖&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#spring-boot常用依赖&#34;&gt;#&lt;/a&gt; spring boot 常用依赖&lt;/h3&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9jbG91ZC50ZW5jZW50LmNvbS9kZXZlbG9wZXIvYXJ0aWNsZS8yNDMyNzA0&#34;&gt;SpringBoot 项目常用的 pom.xml 依赖 - 腾讯云开发者社区 - 腾讯云 (tencent.com)&lt;/span&gt;&lt;/p&gt;
&lt;h3 id=&#34;mybatis-plus-生成代码&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#mybatis-plus-生成代码&#34;&gt;#&lt;/a&gt; Mybatis Plus 生成代码&lt;/h3&gt;
&lt;h3 id=&#34;flyway&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#flyway&#34;&gt;#&lt;/a&gt; flyway&lt;/h3&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2szMTYzNzgwODUvYXJ0aWNsZS9kZXRhaWxzLzEzNDg0ODk3MQ==&#34;&gt;Spring Boot 3.0 : 集成 flyway 数据库版本控制工具_springboot3 flyway-CSDN 博客&lt;/span&gt;&lt;/p&gt;
&lt;h3 id=&#34;redis&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#redis&#34;&gt;#&lt;/a&gt; Redis&lt;/h3&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc0OTgwNS9hcnRpY2xlL2RldGFpbHMvMTMxMzk5NTE2&#34;&gt;Spring Boot 整合 Redis 全面教程：从配置到使用_springboot 配置 redis-CSDN 博客&lt;/span&gt;&lt;/p&gt;
&lt;h3 id=&#34;接口增删改查&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#接口增删改查&#34;&gt;#&lt;/a&gt; 接口增删改查&lt;/h3&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NzE1MDAwL2FydGljbGUvZGV0YWlscy8xMjAwOTAwMzM=&#34;&gt;mybatis-plus 中 wrapper 的用法（详细）_mybatisplus wrapper-CSDN 博客&lt;/span&gt;&lt;/p&gt;
</content>
        <category term="工作总结" />
        <updated>2024-08-26T00:48:36.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2024/08/21/MyBatis-Plus-Learn/</id>
        <title>MyBatis-Plus Learn</title>
        <link rel="alternate" href="http://example.com/2024/08/21/MyBatis-Plus-Learn/"/>
        <content type="html">&lt;h2 id=&#34;install&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#install&#34;&gt;#&lt;/a&gt; install&lt;/h2&gt;
&lt;p&gt;Spring Boot3&lt;/p&gt;
&lt;p&gt;maven&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;dependency&amp;gt;
    &amp;lt;groupId&amp;gt;com.baomidou&amp;lt;/groupId&amp;gt;
    &amp;lt;artifactId&amp;gt;mybatis-plus-boot-starter&amp;lt;/artifactId&amp;gt;
    &amp;lt;version&amp;gt;3.5.7&amp;lt;/version&amp;gt;
&amp;lt;/dependency&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;config&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#config&#34;&gt;#&lt;/a&gt; config&lt;/h2&gt;
&lt;p&gt;配置 MapperScan 注解&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;@SpringBootApplication
@MapperScan(&amp;quot;com.baomidou.mybatisplus.samples.quickstart.mapper&amp;quot;)
public class Application &amp;#123;

    public static void main(String[] args) &amp;#123;
        SpringApplication.run(Application.class, args);
    &amp;#125;

&amp;#125;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;yaml 文件配置&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;server:
  port: 8080   #  配置启动端口号
 
mybatis:
  config-location: classpath:mybatis.cfg.xml    #  mybatis主配置文件所在路径
  type-aliases-package: com.demo.drools.entity  #  定义所有操作类的别名所在包
  mapper-locations:                             #  所有的mapper映射文件
    - classpath:mapper/*.xml
 
 
spring: #springboot的配置
  datasource: #定义数据源
    #127.0.0.1为本机测试的ip，3306是mysql的端口号。serverTimezone是定义时区，照抄就好，mysql高版本需要定义这些东西
    #useSSL也是某些高版本mysql需要问有没有用SSL连接
    url: jdbc:mysql://127.0.0.1:3306/test?serverTimezone=GMT%2B8&amp;amp;useSSL=FALSE
    username: root  #数据库用户名，root为管理员
    password: 123456 #该数据库用户的密码
    # 使用druid数据源
    type: com.alibaba.druid.pool.DruidDataSource
 
# mybatis-plus相关配置
mybatis-plus:
  # xml扫描，多个目录用逗号或者分号分隔（告诉 Mapper 所对应的 XML 文件位置）
  mapper-locations: classpath:mapper/*.xml
  # 以下配置均有默认值,可以不设置
  global-config:
    db-config:
      #主键类型 AUTO:&amp;quot;数据库ID自增&amp;quot; INPUT:&amp;quot;用户输入ID&amp;quot;,ID_WORKER:&amp;quot;全局唯一ID (数字类型唯一ID)&amp;quot;, UUID:&amp;quot;全局唯一ID UUID&amp;quot;;
      id-type: auto
      #字段策略 IGNORED:&amp;quot;忽略判断&amp;quot;  NOT_NULL:&amp;quot;非 NULL 判断&amp;quot;)  NOT_EMPTY:&amp;quot;非空判断&amp;quot;
      field-strategy: NOT_EMPTY
      #数据库类型
      db-type: MYSQL
  configuration:
    # 是否开启自动驼峰命名规则映射:从数据库列名到Java属性驼峰命名的类似映射
    map-underscore-to-camel-case: true
    # 如果查询结果中包含空值的列，则 MyBatis 在映射的时候，不会映射这个字段
    call-setters-on-nulls: true
    # 这个配置会将执行的sql打印出来，在开发或测试的时候可以用
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
&lt;/code&gt;&lt;/pre&gt;
&lt;h1 id=&#34;指南&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#指南&#34;&gt;#&lt;/a&gt; 指南&lt;/h1&gt;
&lt;h2 id=&#34;持久层接口&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#持久层接口&#34;&gt;#&lt;/a&gt; 持久层接口&lt;/h2&gt;
&lt;h3 id=&#34;service-interface&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#service-interface&#34;&gt;#&lt;/a&gt; Service Interface&lt;/h3&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9naXRlZS5jb20vYmFvbWlkb3UvbXliYXRpcy1wbHVzL2Jsb2IvMy4wL215YmF0aXMtcGx1cy1leHRlbnNpb24vc3JjL21haW4vamF2YS9jb20vYmFvbWlkb3UvbXliYXRpc3BsdXMvZXh0ZW5zaW9uL3NlcnZpY2UvSVNlcnZpY2UuamF2YQ==&#34;&gt;IService&lt;/span&gt; 是 MyBatis-Plus 提供的一个通用 Service 层接口，它封装了常见的 CRUD 操作，包括插入、删除、查询和分页等。通过继承 IService 接口，可以快速实现对数据库的基本操作，同时保持代码的简洁性和可维护性。&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240821102620702.png&#34; alt=&#34;image-20240821102620702&#34; /&gt;&lt;/p&gt;
&lt;h3 id=&#34;mapper-interface&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#mapper-interface&#34;&gt;#&lt;/a&gt; Mapper Interface&lt;/h3&gt;
&lt;p&gt;BaseMapper 是 Mybatis-Plus 提供的一个通用 Mapper 接口，它封装了一系列常用的数据库操作方法，包括增、删、改、查等。通过继承 BaseMapper，开发者可以快速地对数据库进行操作，而无需编写繁琐的 SQL 语句。&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240821102639995.png&#34; alt=&#34;image-20240821102639995&#34; /&gt;&lt;/p&gt;
&lt;h3 id=&#34;mapper-层选装件&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#mapper-层选装件&#34;&gt;#&lt;/a&gt; Mapper 层选装件&lt;/h3&gt;
&lt;p&gt;选装件是 Mybatis-Plus 提供的一些扩展方法，它们位于  &lt;code&gt;com.baomidou.mybatisplus.extension.injector.methods&lt;/code&gt;  包下。这些方法需要配合&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9iYW9taWRvdS5jb20vZ3VpZGVzL3NxbC1pbmplY3Rvcg==&#34;&gt; Sql 注入器&lt;/span&gt;使用，以扩展 Mapper 接口的功能。&lt;/p&gt;
&lt;p&gt;使用这些选装件前，需要确保已经正确配置了 Sql 注入器。更多使用案例和详细信息，可以参考&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9naXRodWIuY29tL2Jhb21pZG91L215YmF0aXMtcGx1cy1zYW1wbGVzL3RyZWUvbWFzdGVyL215YmF0aXMtcGx1cy1zYW1wbGUtc3FsLWluamVjdG9y&#34;&gt;官方案例&lt;/span&gt;和&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9naXRodWIuY29tL2Jhb21pZG91L215YmF0aXMtcGx1cy90cmVlLzMuMC9teWJhdGlzLXBsdXMtZXh0ZW5zaW9uL3NyYy9tYWluL2phdmEvY29tL2Jhb21pZG91L215YmF0aXNwbHVzL2V4dGVuc2lvbi9pbmplY3Rvci9tZXRob2Rz&#34;&gt;源码注释&lt;/span&gt;。&lt;/p&gt;
&lt;h4 id=&#34;alwaysupdatesomecolumnbyid&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#alwaysupdatesomecolumnbyid&#34;&gt;#&lt;/a&gt; alwaysUpdateSomeColumnById&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;功能&lt;/strong&gt;：这个方法用于在更新操作时，无论实体对象的某些字段是否有变化，都会强制更新这些字段。这在某些业务场景下非常有用，比如更新时间戳字段，确保每次更新操作都会更新该字段。&lt;br /&gt;
&lt;strong&gt;使用场景&lt;/strong&gt;：当你需要在每次更新记录时，都更新某些特定的字段（如更新时间、版本号等），即使这些字段在实体对象中没有变化&lt;/p&gt;
&lt;h4 id=&#34;insertbatchsomecolumn&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#insertbatchsomecolumn&#34;&gt;#&lt;/a&gt; insertBatchSomeColumn&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;功能&lt;/strong&gt;：这个方法用于批量插入实体对象，但只插入实体对象中指定的某些字段。这在需要批量插入数据，但又不希望插入所有字段时非常有用。&lt;br /&gt;
&lt;strong&gt;使用场景&lt;/strong&gt;：当你需要批量插入数据，并且希望只插入实体对象中的部分字段，以提高插入效率或保护敏感数据。&lt;/p&gt;
&lt;h4 id=&#34;logicdeletebyidwithfill&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#logicdeletebyidwithfill&#34;&gt;#&lt;/a&gt; logicDeleteByIdWithFill&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;功能&lt;/strong&gt;：这个方法用于逻辑删除记录，并填充实体对象中的某些字段。逻辑删除意味着不是真正从数据库中删除记录，而是通过更新某个字段（如  &lt;code&gt;deleted&lt;/code&gt;  字段）来标记记录已被删除。&lt;br /&gt;
&lt;strong&gt;使用场景&lt;/strong&gt;：当你需要实现逻辑删除功能，并且希望在删除操作时自动填充实体对象中的某些字段（如删除时间、删除人等）。&lt;/p&gt;
&lt;h3 id=&#34;其他&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#其他&#34;&gt;#&lt;/a&gt; 其他&lt;/h3&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240821104004707.png&#34; alt=&#34;image-20240821104004707&#34; /&gt;&lt;/p&gt;
&lt;h2 id=&#34;条件构造器&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#条件构造器&#34;&gt;#&lt;/a&gt; 条件构造器&lt;/h2&gt;
&lt;p&gt;MyBatis-Plus 提供了一套强大的条件构造器（Wrapper），用于构建复杂的数据库查询条件。Wrapper 类允许开发者以链式调用的方式构造查询条件，无需编写繁琐的 SQL 语句，从而提高开发效率并减少 SQL 注入的风险。&lt;/p&gt;
&lt;h3 id=&#34;条件构造器关系介绍&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#条件构造器关系介绍&#34;&gt;#&lt;/a&gt; 条件构造器关系介绍&lt;/h3&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240821104619643.png&#34; alt=&#34;image-20240821104619643&#34; /&gt;&lt;/p&gt;
&lt;h3 id=&#34;功能详解&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#功能详解&#34;&gt;#&lt;/a&gt; 功能详解&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;allEq
eq
ne
gt // 大于
ge // 大于等于
ly // 小于
le // 小于等于
between
notBetween
like
notLike
likeLeft // 右模糊匹配条件
likeRight
notLikeLeft
notLikeRight
isNull
in
notIn
inSql
notInSql
eqSQL
...
groupBy
orderByAsc
OrderByDesc
orderBy
having
func
or
and
nested // 创建一个独立的查询条件块，不带默认的 AND 或 OR 逻辑
last // 允许你直接在查询的最后添加一个 SQL 片段，而不受 MyBatis-Plus 的查询优化规则影响。
exists // EXISTS 的子查询 不返回具体的数据，只返回所查询数据的行数
select
set // 设置更新语句中的 SET 字段
setSql
setIncrBy // 允许你指定一个字段，并使其在数据库中的值增加指定的数值
setDecrBy
lambda

&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;img data-src=&#34;42961fa25b28a23db651401b508ffd50.png&#34; alt=&#34;img&#34; /&gt;&lt;/p&gt;
&lt;h3 id=&#34;使用提示&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#使用提示&#34;&gt;#&lt;/a&gt; 使用提示&lt;/h3&gt;
&lt;p&gt;通过使用 MyBatis-Plus 的 Wrapper 条件构造器，开发者可以更加高效地构建复杂的数据库查询条件，同时保持代码的简洁性和安全性。以下是一些注意事项与推荐做法：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;在使用 Wrapper 时，尽量使用 &lt;strong&gt;Lambda 表达式&lt;/strong&gt;来避免硬编码字段名，这样可以提高代码的可读性和可维护性。&lt;/li&gt;
&lt;li&gt;Wrapper 支持&lt;strong&gt;链式调用&lt;/strong&gt;，可以组合多个条件，如  &lt;code&gt;and&lt;/code&gt; 、 &lt;code&gt;or&lt;/code&gt;  等逻辑操作符。&lt;/li&gt;
&lt;li&gt;在更新操作中使用 UpdateWrapper 或 LambdaUpdateWrapper 时，可以省略实体对象，直接在 Wrapper 中设置更新字段。&lt;/li&gt;
&lt;li&gt;注意 Wrapper 的线程安全性，通常在每次使用时创建新的 Wrapper 实例。&lt;/li&gt;
&lt;li&gt;在使用 MyBatis-Plus 的 Wrapper 时，应避免将前端动态参数直接拼接到 SQL 片段中，以防止 SQL 注入攻击。MyBatis-Plus 提供了安全的参数绑定方式，如使用  &lt;code&gt;eq&lt;/code&gt; 、 &lt;code&gt;apply&lt;/code&gt;  等方法，它们会自动处理参数绑定，避免 SQL 注入风险。&lt;/li&gt;
&lt;/ul&gt;
&lt;h1 id=&#34;参考&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#参考&#34;&gt;#&lt;/a&gt; 参考&lt;/h1&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9iYW9taWRvdS5jb20vcmVmZXJlbmNlL2Fubm90YXRpb24v&#34;&gt;注解配置 | MyBatis-Plus (baomidou.com)&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMjgxNjQ5L2FydGljbGUvZGV0YWlscy8xMTA1MTgyODk=&#34;&gt;SpringBoot 整合 Mybatis-plus 及用法_springboot 引入 mybatis-plus-CSDN 博客&lt;/span&gt;&lt;/p&gt;
</content>
        <updated>2024-08-21T02:14:26.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2024/08/16/Learn-Vue3/</id>
        <title>Learn Vue3</title>
        <link rel="alternate" href="http://example.com/2024/08/16/Learn-Vue3/"/>
        <content type="html">&lt;p&gt;摘自 https://cn.vuejs.org/guide/&lt;/p&gt;
&lt;h1 id=&#34;模板语法&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#模板语法&#34;&gt;#&lt;/a&gt; 模板语法&lt;/h1&gt;
&lt;h2 id=&#34;文本插值&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#文本插值&#34;&gt;#&lt;/a&gt; 文本插值&lt;/h2&gt;
&lt;p&gt;最基本的数据绑定形式是文本插值，它使用的是 “Mustache” 语法 (即双大括号)：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;span&amp;gt;Message: &amp;#123;&amp;#123; msg &amp;#125;&amp;#125;&amp;lt;/span&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;双大括号标签会被替换为相应组件实例中  &lt;code&gt;msg&lt;/code&gt;  属性的值。同时每次  &lt;code&gt;msg&lt;/code&gt;  属性更改时它也会同步更新。&lt;/p&gt;
&lt;h2 id=&#34;attribute-绑定&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#attribute-绑定&#34;&gt;#&lt;/a&gt; Attribute 绑定&lt;/h2&gt;
&lt;p&gt;双大括号不能在 HTML attributes 中使用。想要响应式地绑定一个 attribute，应该使用  &lt;code&gt;v-bind&lt;/code&gt;  指令：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;div v-bind:id=&amp;quot;dynamicId&amp;quot;&amp;gt;&amp;lt;/div&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;v-bind&lt;/code&gt;  指令指示 Vue 将元素的  &lt;code&gt;id&lt;/code&gt;  attribute 与组件的  &lt;code&gt;dynamicId&lt;/code&gt;  属性保持一致。如果绑定的值是  &lt;code&gt;null&lt;/code&gt;  或者  &lt;code&gt;undefined&lt;/code&gt; ，那么该 attribute 将会从渲染的元素上移除。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;简写&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;div :id=&amp;quot;dynamicId&amp;quot;&amp;gt;&amp;lt;/div&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3 id=&#34;动态绑定多个值&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#动态绑定多个值&#34;&gt;#&lt;/a&gt; 动态绑定多个值&lt;/h3&gt;
&lt;p&gt;如果你有像这样的一个包含多个 attribute 的 JavaScript 对象：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;const objectOfAttrs = &amp;#123;
  id: &#39;container&#39;,
  class: &#39;wrapper&#39;,
  style: &#39;background-color:green&#39;
&amp;#125;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;通过不带参数的  &lt;code&gt;v-bind&lt;/code&gt; ，你可以将它们绑定到单个元素上：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;div v-bind=&amp;quot;objectOfAttrs&amp;quot;&amp;gt;&amp;lt;/div&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;使用-javascript-表达式&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#使用-javascript-表达式&#34;&gt;#&lt;/a&gt; 使用 JavaScript 表达式&lt;/h2&gt;
&lt;p&gt;至此，我们仅在模板中绑定了一些简单的属性名。但是 Vue 实际上在所有的数据绑定中都支持完整的 JavaScript 表达式：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;#123;&amp;#123; number + 1 &amp;#125;&amp;#125;

&amp;#123;&amp;#123; ok ? &#39;YES&#39; : &#39;NO&#39; &amp;#125;&amp;#125;

&amp;#123;&amp;#123; message.split(&#39;&#39;).reverse().join(&#39;&#39;) &amp;#125;&amp;#125;

&amp;lt;div :id=&amp;quot;`list-$&amp;#123;id&amp;#125;`&amp;quot;&amp;gt;&amp;lt;/div&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这些表达式都会被作为 JavaScript ，以当前组件实例为作用域解析执行。&lt;/p&gt;
&lt;p&gt;在 Vue 模板内，JavaScript 表达式可以被使用在如下场景上：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;在文本插值中 (双大括号)&lt;/li&gt;
&lt;li&gt;在任何 Vue 指令 (以  &lt;code&gt;v-&lt;/code&gt;  开头的特殊 attribute) attribute 的值中&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;调用函数&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#调用函数&#34;&gt;#&lt;/a&gt; 调用函数&lt;/h3&gt;
&lt;p&gt;可以在绑定的表达式中使用一个组件暴露的方法：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;time :title=&amp;quot;toTitleDate(date)&amp;quot; :datetime=&amp;quot;date&amp;quot;&amp;gt;
  &amp;#123;&amp;#123; formatDate(date) &amp;#125;&amp;#125;
&amp;lt;/time&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;TIP&lt;/p&gt;
&lt;p&gt;绑定在表达式中的方法在组件每次更新时都会被重新调用，因此&lt;strong&gt;不&lt;/strong&gt;应该产生任何副作用，比如改变数据或触发异步操作。&lt;/p&gt;
&lt;h2 id=&#34;指令-directives&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#指令-directives&#34;&gt;#&lt;/a&gt; 指令 Directives&lt;/h2&gt;
&lt;p&gt;指令是带有  &lt;code&gt;v-&lt;/code&gt;  前缀的特殊 attribute。Vue 提供了许多内置指令&lt;/p&gt;
&lt;p&gt;指令 attribute 的期望值为一个 JavaScript 表达式 (除了少数几个例外，即之后要讨论到的  &lt;code&gt;v-for&lt;/code&gt; 、 &lt;code&gt;v-on&lt;/code&gt;  和  &lt;code&gt;v-slot&lt;/code&gt; )。一个指令的任务是在其表达式的值变化时响应式地更新 DOM。以 &lt;a href=&#34;https://cn.vuejs.org/api/built-in-directives.html#v-if&#34;&gt; &lt;code&gt;v-if&lt;/code&gt; &lt;/a&gt; 为例：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;p v-if=&amp;quot;seen&amp;quot;&amp;gt;Now you see me&amp;lt;/p&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里， &lt;code&gt;v-if&lt;/code&gt;  指令会基于表达式  &lt;code&gt;seen&lt;/code&gt;  的值的真假来移除 / 插入该  &lt;code&gt;&amp;lt;p&amp;gt;&lt;/code&gt;  元素。&lt;/p&gt;
&lt;h3 id=&#34;参数-arguments&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#参数-arguments&#34;&gt;#&lt;/a&gt; 参数 Arguments&lt;/h3&gt;
&lt;p&gt;某些指令会需要一个 “参数”，在指令名后通过一个冒号隔开做标识。例如用  &lt;code&gt;v-bind&lt;/code&gt;  指令来响应式地更新一个 HTML attribute：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;a v-bind:href=&amp;quot;url&amp;quot;&amp;gt; ... &amp;lt;/a&amp;gt;

&amp;lt;!-- 简写 --&amp;gt;
&amp;lt;a :href=&amp;quot;url&amp;quot;&amp;gt; ... &amp;lt;/a&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里  &lt;code&gt;href&lt;/code&gt;  就是一个参数，它告诉  &lt;code&gt;v-bind&lt;/code&gt;  指令将表达式  &lt;code&gt;url&lt;/code&gt;  的值绑定到元素的  &lt;code&gt;href&lt;/code&gt;  attribute 上。在简写中，参数前的一切 (例如  &lt;code&gt;v-bind:&lt;/code&gt; ) 都会被缩略为一个  &lt;code&gt;:&lt;/code&gt;  字符。&lt;/p&gt;
&lt;p&gt;另一个例子是  &lt;code&gt;v-on&lt;/code&gt;  指令，它将监听 DOM 事件：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;a v-on:click=&amp;quot;doSomething&amp;quot;&amp;gt; ... &amp;lt;/a&amp;gt;

&amp;lt;!-- 简写 --&amp;gt;
&amp;lt;a @click=&amp;quot;doSomething&amp;quot;&amp;gt; ... &amp;lt;/a&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里的参数是要监听的事件名称： &lt;code&gt;click&lt;/code&gt; 。 &lt;code&gt;v-on&lt;/code&gt;  有一个相应的缩写，即  &lt;code&gt;@&lt;/code&gt;  字符。我们之后也会讨论关于事件处理的更多细节。&lt;/p&gt;
&lt;h3 id=&#34;动态参数&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#动态参数&#34;&gt;#&lt;/a&gt; 动态参数&lt;/h3&gt;
&lt;p&gt;同样在指令参数上也可以使用一个 JavaScript 表达式，需要包含在一对方括号内：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;!--
注意，参数表达式有一些约束，
参见下面“动态参数值的限制”与“动态参数语法的限制”章节的解释
--&amp;gt;
&amp;lt;a v-bind:[attributeName]=&amp;quot;url&amp;quot;&amp;gt; ... &amp;lt;/a&amp;gt;

&amp;lt;!-- 简写 --&amp;gt;
&amp;lt;a :[attributeName]=&amp;quot;url&amp;quot;&amp;gt; ... &amp;lt;/a&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里的  &lt;code&gt;attributeName&lt;/code&gt;  会作为一个 JavaScript 表达式被动态执行，计算得到的值会被用作最终的参数。举例来说，如果你的组件实例有一个数据属性  &lt;code&gt;attributeName&lt;/code&gt; ，其值为  &lt;code&gt;&amp;quot;href&amp;quot;&lt;/code&gt; ，那么这个绑定就等价于  &lt;code&gt;v-bind:href&lt;/code&gt; 。&lt;/p&gt;
&lt;p&gt;相似地，你还可以将一个函数绑定到动态的事件名称上：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;a v-on:[eventName]=&amp;quot;doSomething&amp;quot;&amp;gt; ... &amp;lt;/a&amp;gt;

&amp;lt;!-- 简写 --&amp;gt;
&amp;lt;a @[eventName]=&amp;quot;doSomething&amp;quot;&amp;gt; ... &amp;lt;/a&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;在此示例中，当  &lt;code&gt;eventName&lt;/code&gt;  的值是  &lt;code&gt;&amp;quot;focus&amp;quot;&lt;/code&gt;  时， &lt;code&gt;v-on:[eventName]&lt;/code&gt;  就等价于  &lt;code&gt;v-on:focus&lt;/code&gt; 。&lt;/p&gt;
&lt;h3 id=&#34;动态参数值的限制&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#动态参数值的限制&#34;&gt;#&lt;/a&gt; 动态参数值的限制&lt;/h3&gt;
&lt;p&gt;动态参数中表达式的值应当是一个字符串，或者是  &lt;code&gt;null&lt;/code&gt; 。特殊值  &lt;code&gt;null&lt;/code&gt;  意为显式移除该绑定。其他非字符串的值会触发警告。&lt;/p&gt;
&lt;h3 id=&#34;动态参数语法的限制&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#动态参数语法的限制&#34;&gt;#&lt;/a&gt; 动态参数语法的限制&lt;/h3&gt;
&lt;p&gt;动态参数表达式因为某些字符的缘故有一些语法限制，比如空格和引号，在 HTML attribute 名称中都是不合法的。例如下面的示例：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;!-- 这会触发一个编译器警告 --&amp;gt;
&amp;lt;a :[&#39;foo&#39; + bar]=&amp;quot;value&amp;quot;&amp;gt; ... &amp;lt;/a&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果你需要传入一个复杂的动态参数，我们推荐使用&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9jbi52dWVqcy5vcmcvZ3VpZGUvZXNzZW50aWFscy9jb21wdXRlZC5odG1s&#34;&gt;计算属性&lt;/span&gt;替换复杂的表达式，也是 Vue 最基础的概念之一，我们很快就会讲到。&lt;/p&gt;
&lt;p&gt;当使用 DOM 内嵌模板 (直接写在 HTML 文件里的模板) 时，我们需要避免在名称中使用大写字母，因为浏览器会强制将其转换为小写：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;a :[someAttr]=&amp;quot;value&amp;quot;&amp;gt; ... &amp;lt;/a&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;上面的例子将会在 DOM 内嵌模板中被转换为  &lt;code&gt;:[someattr]&lt;/code&gt; 。如果你的组件拥有 “someAttr” 属性而非 “someattr”，这段代码将不会工作。单文件组件内的模板&lt;strong&gt;不&lt;/strong&gt;受此限制。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;完整的指令语法&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;directive.DtZKvoAo.png&#34; alt=&#34;指令语法图&#34; /&gt;&lt;/p&gt;
&lt;h1 id=&#34;响应式基础&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#响应式基础&#34;&gt;#&lt;/a&gt; 响应式基础&lt;/h1&gt;
&lt;h2 id=&#34;声明响应式状态&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#声明响应式状态&#34;&gt;#&lt;/a&gt; 声明响应式状态&lt;/h2&gt;
&lt;h3 id=&#34;ref&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#ref&#34;&gt;#&lt;/a&gt;  &lt;code&gt;ref()&lt;/code&gt;&lt;/h3&gt;
&lt;p&gt;在组合式 API 中，推荐使用 &lt;a href=&#34;https://cn.vuejs.org/api/reactivity-core.html#ref&#34;&gt; &lt;code&gt;ref()&lt;/code&gt; &lt;/a&gt; 函数来声明响应式状态：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;import &amp;#123; ref &amp;#125; from &#39;vue&#39;

const count = ref(0)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;ref()&lt;/code&gt;  接收参数，并将其包裹在一个带有  &lt;code&gt;.value&lt;/code&gt;  属性的 ref 对象中返回：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;const count = ref(0)

console.log(count) // &amp;#123; value: 0 &amp;#125;
console.log(count.value) // 0

count.value++
console.log(count.value) // 1
&lt;/code&gt;&lt;/pre&gt;
&lt;blockquote&gt;
&lt;p&gt;参考：&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9jbi52dWVqcy5vcmcvZ3VpZGUvdHlwZXNjcmlwdC9jb21wb3NpdGlvbi1hcGkuaHRtbCN0eXBpbmctcmVm&#34;&gt;为 refs 标注类型&lt;/span&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;要在组件模板中访问 ref，请从组件的  &lt;code&gt;setup()&lt;/code&gt;  函数中声明并返回它们：&lt;/p&gt;
&lt;p&gt;js&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;import &amp;#123; ref &amp;#125; from &#39;vue&#39;

export default &amp;#123;
  // `setup` 是一个特殊的钩子，专门用于组合式 API。
  setup() &amp;#123;
    const count = ref(0)

    // 将 ref 暴露给模板
    return &amp;#123;
      count
    &amp;#125;
  &amp;#125;
&amp;#125;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;div&amp;gt;&amp;#123;&amp;#123; count &amp;#125;&amp;#125;&amp;lt;/div&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;注意，在模板中使用 ref 时，我们&lt;strong&gt;不&lt;/strong&gt;需要附加  &lt;code&gt;.value&lt;/code&gt; 。为了方便起见，当在模板中使用时，ref 会自动解包 (有一些&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9jbi52dWVqcy5vcmcvZ3VpZGUvZXNzZW50aWFscy9yZWFjdGl2aXR5LWZ1bmRhbWVudGFscy5odG1sI2NhdmVhdC13aGVuLXVud3JhcHBpbmctaW4tdGVtcGxhdGVz&#34;&gt;注意事项&lt;/span&gt;)。&lt;/p&gt;
&lt;p&gt;你也可以直接在事件监听器中改变一个 ref：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;button @click=&amp;quot;count++&amp;quot;&amp;gt;
  &amp;#123;&amp;#123; count &amp;#125;&amp;#125;
&amp;lt;/button&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;对于更复杂的逻辑，我们可以在同一作用域内声明更改 ref 的函数，并将它们作为方法与状态一起公开：&lt;/p&gt;
&lt;p&gt;js&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;import &amp;#123; ref &amp;#125; from &#39;vue&#39;

export default &amp;#123;
  setup() &amp;#123;
    const count = ref(0)

    function increment() &amp;#123;
      // 在 JavaScript 中需要 .value
      count.value++
    &amp;#125;

    // 不要忘记同时暴露 increment 函数
    return &amp;#123;
      count,
      increment
    &amp;#125;
  &amp;#125;
&amp;#125;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后，暴露的方法可以被用作事件监听器：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;button @click=&amp;quot;increment&amp;quot;&amp;gt;
  &amp;#123;&amp;#123; count &amp;#125;&amp;#125;
&amp;lt;/button&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里是 &lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9jb2RlcGVuLmlvL3Z1ZWpzLWV4YW1wbGVzL3Blbi9XTlliYXFv&#34;&gt;Codepen&lt;/span&gt; 上的例子，没有使用任何构建工具。&lt;/p&gt;
&lt;h3 id=&#34;script-setup&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#script-setup&#34;&gt;#&lt;/a&gt;  &lt;code&gt;&amp;lt;script setup&amp;gt;&lt;/code&gt;&lt;/h3&gt;
&lt;p&gt;在  &lt;code&gt;setup()&lt;/code&gt;  函数中手动暴露大量的状态和方法非常繁琐。幸运的是，我们可以通过使用&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9jbi52dWVqcy5vcmcvZ3VpZGUvc2NhbGluZy11cC9zZmMuaHRtbA==&#34;&gt;单文件组件 (SFC)&lt;/span&gt; 来避免这种情况。我们可以使用  &lt;code&gt;&amp;lt;script setup&amp;gt;&lt;/code&gt;  来大幅度地简化代码：&lt;/p&gt;
&lt;p&gt;vue&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;script setup&amp;gt;
import &amp;#123; ref &amp;#125; from &#39;vue&#39;

const count = ref(0)

function increment() &amp;#123;
  count.value++
&amp;#125;
&amp;lt;/script&amp;gt;

&amp;lt;template&amp;gt;
  &amp;lt;button @click=&amp;quot;increment&amp;quot;&amp;gt;
    &amp;#123;&amp;#123; count &amp;#125;&amp;#125;
  &amp;lt;/button&amp;gt;
&amp;lt;/template&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&amp;lt;script setup&amp;gt; 中的顶层的导入、声明的变量和函数可在同一组件的模板中直接使用。你可以理解为模板是在同一作用域内声明的一个 JavaScript 函数 —— 它自然可以访问与它一起声明的所有内容。&lt;/p&gt;
&lt;p&gt;TIP&lt;/p&gt;
&lt;p&gt;在指南的后续章节中，我们基本上都会在组合式 API 示例中使用单文件组件 +  &lt;code&gt;&amp;lt;script setup&amp;gt;&lt;/code&gt;  的语法，因为大多数 Vue 开发者都会这样使用。&lt;/p&gt;
&lt;p&gt;如果你没有使用单文件组件，你仍然可以在 &lt;a href=&#34;https://cn.vuejs.org/api/composition-api-setup.html&#34;&gt; &lt;code&gt;setup()&lt;/code&gt; &lt;/a&gt; 选项中使用组合式 API。&lt;/p&gt;
&lt;h3 id=&#34;为什么要使用-ref&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#为什么要使用-ref&#34;&gt;#&lt;/a&gt; 为什么要使用 ref？&lt;/h3&gt;
&lt;p&gt;你可能会好奇：为什么我们需要使用带有  &lt;code&gt;.value&lt;/code&gt;  的 ref，而不是普通的变量？为了解释这一点，我们需要简单地讨论一下 Vue 的响应式系统是如何工作的。&lt;/p&gt;
&lt;p&gt;当你在模板中使用了一个 ref，然后改变了这个 ref 的值时，Vue 会自动检测到这个变化，并且相应地更新 DOM。这是通过一个基于依赖追踪的响应式系统实现的。当一个组件首次渲染时，Vue 会&lt;strong&gt;追踪&lt;/strong&gt;在渲染过程中使用的每一个 ref。然后，当一个 ref 被修改时，它会&lt;strong&gt;触发&lt;/strong&gt;追踪它的组件的一次重新渲染。&lt;/p&gt;
&lt;p&gt;在标准的 JavaScript 中，检测普通变量的访问或修改是行不通的。然而，我们可以通过 getter 和 setter 方法来拦截对象属性的 get 和 set 操作。&lt;/p&gt;
&lt;p&gt;该  &lt;code&gt;.value&lt;/code&gt;  属性给予了 Vue 一个机会来检测 ref 何时被访问或修改。在其内部，Vue 在它的 getter 中执行追踪，在它的 setter 中执行触发。从概念上讲，你可以将 ref 看作是一个像这样的对象：&lt;/p&gt;
&lt;p&gt;js&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// 伪代码，不是真正的实现
const myRef = &amp;#123;
  _value: 0,
  get value() &amp;#123;
    track()
    return this._value
  &amp;#125;,
  set value(newValue) &amp;#123;
    this._value = newValue
    trigger()
  &amp;#125;
&amp;#125;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;另一个 ref 的好处是，与普通变量不同，你可以将 ref 传递给函数，同时保留对最新值和响应式连接的访问。当将复杂的逻辑重构为可重用的代码时，这将非常有用。&lt;/p&gt;
&lt;p&gt;该响应性系统在&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9jbi52dWVqcy5vcmcvZ3VpZGUvZXh0cmFzL3JlYWN0aXZpdHktaW4tZGVwdGguaHRtbA==&#34;&gt;深入响应式原理&lt;/span&gt;章节中有更详细的讨论。&lt;/p&gt;
&lt;h3 id=&#34;深层响应性&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#深层响应性&#34;&gt;#&lt;/a&gt; 深层响应性&lt;/h3&gt;
&lt;p&gt;Ref 可以持有任何类型的值，包括深层嵌套的对象、数组或者 JavaScript 内置的数据结构，比如  &lt;code&gt;Map&lt;/code&gt; 。&lt;/p&gt;
&lt;p&gt;Ref 会使它的值具有深层响应性。这意味着即使改变嵌套对象或数组时，变化也会被检测到：&lt;/p&gt;
&lt;p&gt;js&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;import &amp;#123; ref &amp;#125; from &#39;vue&#39;

const obj = ref(&amp;#123;
  nested: &amp;#123; count: 0 &amp;#125;,
  arr: [&#39;foo&#39;, &#39;bar&#39;]
&amp;#125;)

function mutateDeeply() &amp;#123;
  // 以下都会按照期望工作
  obj.value.nested.count++
  obj.value.arr.push(&#39;baz&#39;)
&amp;#125;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;非原始值将通过 &lt;a href=&#34;https://cn.vuejs.org/guide/essentials/reactivity-fundamentals.html#reactive&#34;&gt; &lt;code&gt;reactive()&lt;/code&gt; &lt;/a&gt; 转换为响应式代理，该函数将在后面讨论。&lt;/p&gt;
&lt;p&gt;也可以通过 &lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9jbi52dWVqcy5vcmcvYXBpL3JlYWN0aXZpdHktYWR2YW5jZWQuaHRtbCNzaGFsbG93cmVm&#34;&gt;shallow ref&lt;/span&gt; 来放弃深层响应性。对于浅层 ref，只有  &lt;code&gt;.value&lt;/code&gt;  的访问会被追踪。浅层 ref 可以用于避免对大型数据的响应性开销来优化性能、或者有外部库管理其内部状态的情况。&lt;/p&gt;
&lt;p&gt;阅读更多：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9jbi52dWVqcy5vcmcvZ3VpZGUvYmVzdC1wcmFjdGljZXMvcGVyZm9ybWFuY2UuaHRtbCNyZWR1Y2UtcmVhY3Rpdml0eS1vdmVyaGVhZC1mb3ItbGFyZ2UtaW1tdXRhYmxlLXN0cnVjdHVyZXM=&#34;&gt;减少大型不可变数据的响应性开销&lt;/span&gt;&lt;/li&gt;
&lt;li&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9jbi52dWVqcy5vcmcvZ3VpZGUvZXh0cmFzL3JlYWN0aXZpdHktaW4tZGVwdGguaHRtbCNpbnRlZ3JhdGlvbi13aXRoLWV4dGVybmFsLXN0YXRlLXN5c3RlbXM=&#34;&gt;与外部状态系统集成&lt;/span&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;dom-更新时机&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#dom-更新时机&#34;&gt;#&lt;/a&gt; DOM 更新时机&lt;/h3&gt;
&lt;p&gt;当你修改了响应式状态时，DOM 会被自动更新。但是需要注意的是，DOM 更新不是同步的。Vue 会在 “next tick” 更新周期中缓冲所有状态的修改，以确保不管你进行了多少次状态修改，每个组件都只会被更新一次。&lt;/p&gt;
&lt;p&gt;要等待 DOM 更新完成后再执行额外的代码，可以使用 &lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9jbi52dWVqcy5vcmcvYXBpL2dlbmVyYWwuaHRtbCNuZXh0dGljaw==&#34;&gt;nextTick()&lt;/span&gt; 全局 API：&lt;/p&gt;
&lt;p&gt;js&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;import &amp;#123; nextTick &amp;#125; from &#39;vue&#39;

async function increment() &amp;#123;
  count.value++
  await nextTick()
  // 现在 DOM 已经更新了
&amp;#125;
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;reactive&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#reactive&#34;&gt;#&lt;/a&gt; &lt;s&gt; &lt;code&gt;reactive()&lt;/code&gt; &lt;/s&gt;&lt;/h2&gt;
&lt;p&gt;...&lt;/p&gt;
&lt;h2 id=&#34;额外的-ref-解包细节&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#额外的-ref-解包细节&#34;&gt;#&lt;/a&gt; 额外的 ref 解包细节&lt;/h2&gt;
&lt;h3 id=&#34;作为-reactive-对象的属性&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#作为-reactive-对象的属性&#34;&gt;#&lt;/a&gt; 作为 reactive 对象的属性&lt;/h3&gt;
&lt;p&gt;一个 ref 会在作为响应式对象的属性被访问或修改时自动解包。换句话说，它的行为就像一个普通的属性：&lt;/p&gt;
&lt;p&gt;js&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;const count = ref(0)
const state = reactive(&amp;#123;
  count
&amp;#125;)

console.log(state.count) // 0

state.count = 1
console.log(count.value) // 1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;如果将一个新的 ref 赋值给一个关联了已有 ref 的属性，那么它会替换掉旧的 ref：&lt;/p&gt;
&lt;p&gt;js&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;const otherCount = ref(2)

state.count = otherCount
console.log(state.count) // 2
// 原始 ref 现在已经和 state.count 失去联系
console.log(count.value) // 1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;只有当嵌套在一个深层响应式对象内时，才会发生 ref 解包。当其作为&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9jbi52dWVqcy5vcmcvYXBpL3JlYWN0aXZpdHktYWR2YW5jZWQuaHRtbCNzaGFsbG93cmVhY3RpdmU=&#34;&gt;浅层响应式对象&lt;/span&gt;的属性被访问时不会解包。&lt;/p&gt;
&lt;h3 id=&#34;数组和集合的注意事项&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#数组和集合的注意事项&#34;&gt;#&lt;/a&gt; 数组和集合的注意事项&lt;/h3&gt;
&lt;p&gt;与 reactive 对象不同的是，当 ref 作为响应式数组或原生集合类型 (如  &lt;code&gt;Map&lt;/code&gt; ) 中的元素被访问时，它&lt;strong&gt;不会&lt;/strong&gt;被解包：&lt;/p&gt;
&lt;p&gt;js&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;const books = reactive([ref(&#39;Vue 3 Guide&#39;)])
// 这里需要 .value
console.log(books[0].value)

const map = reactive(new Map([[&#39;count&#39;, ref(0)]]))
// 这里需要 .value
console.log(map.get(&#39;count&#39;).value)
&lt;/code&gt;&lt;/pre&gt;
&lt;h3 id=&#34;在模板中解包的注意事项&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#在模板中解包的注意事项&#34;&gt;#&lt;/a&gt; 在模板中解包的注意事项&lt;/h3&gt;
&lt;p&gt;在模板渲染上下文中，只有顶级的 ref 属性才会被解包。&lt;/p&gt;
&lt;p&gt;在下面的例子中， &lt;code&gt;count&lt;/code&gt;  和  &lt;code&gt;object&lt;/code&gt;  是顶级属性，但  &lt;code&gt;object.id&lt;/code&gt;  不是：&lt;/p&gt;
&lt;p&gt;js&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;const count = ref(0)
const object = &amp;#123; id: ref(1) &amp;#125;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;因此，这个表达式按预期工作：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;#123;&amp;#123; count + 1 &amp;#125;&amp;#125;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;... 但这个&lt;strong&gt;不会&lt;/strong&gt;：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;#123;&amp;#123; object.id + 1 &amp;#125;&amp;#125;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;渲染的结果将是  &lt;code&gt;[object Object]1&lt;/code&gt; ，因为在计算表达式时  &lt;code&gt;object.id&lt;/code&gt;  没有被解包，仍然是一个 ref 对象。为了解决这个问题，我们可以将  &lt;code&gt;id&lt;/code&gt;  解构为一个顶级属性：&lt;/p&gt;
&lt;p&gt;js&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;const &amp;#123; id &amp;#125; = object
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;#123;&amp;#123; id + 1 &amp;#125;&amp;#125;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;现在渲染的结果将是  &lt;code&gt;2&lt;/code&gt; 。&lt;/p&gt;
&lt;p&gt;另一个需要注意的点是，如果 ref 是文本插值的最终计算值 (即  &lt;code&gt;&amp;#123;&amp;#123; &amp;#125;&amp;#125;&lt;/code&gt;  标签)，那么它将被解包，因此以下内容将渲染为  &lt;code&gt;1&lt;/code&gt; ：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;#123;&amp;#123; object.id &amp;#125;&amp;#125;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;该特性仅仅是文本插值的一个便利特性，等价于  &lt;code&gt;&amp;#123;&amp;#123; object.id.value &amp;#125;&amp;#125;&lt;/code&gt; 。&lt;/p&gt;
&lt;h1 id=&#34;计算属性&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#计算属性&#34;&gt;#&lt;/a&gt; 计算属性&lt;/h1&gt;
&lt;h2 id=&#34;基础示例&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#基础示例&#34;&gt;#&lt;/a&gt; 基础示例&lt;/h2&gt;
&lt;p&gt;模板中的表达式虽然方便，但也只能用来做简单的操作。如果在模板中写太多逻辑，会让模板变得臃肿，难以维护。比如说，我们有这样一个包含嵌套数组的对象：&lt;/p&gt;
&lt;p&gt;js&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;const author = reactive(&amp;#123;
  name: &#39;John Doe&#39;,
  books: [
    &#39;Vue 2 - Advanced Guide&#39;,
    &#39;Vue 3 - Basic Guide&#39;,
    &#39;Vue 4 - The Mystery&#39;
  ]
&amp;#125;)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;我们想根据  &lt;code&gt;author&lt;/code&gt;  是否已有一些书籍来展示不同的信息：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;p&amp;gt;Has published books:&amp;lt;/p&amp;gt;
&amp;lt;span&amp;gt;&amp;#123;&amp;#123; author.books.length &gt; 0 ? &#39;Yes&#39; : &#39;No&#39; &amp;#125;&amp;#125;&amp;lt;/span&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这里的模板看起来有些复杂。我们必须认真看好一会儿才能明白它的计算依赖于  &lt;code&gt;author.books&lt;/code&gt; 。更重要的是，如果在模板中需要不止一次这样的计算，我们可不想将这样的代码在模板里重复好多遍。&lt;/p&gt;
&lt;p&gt;因此我们推荐使用&lt;strong&gt;计算属性&lt;/strong&gt;来描述依赖响应式状态的复杂逻辑。这是重构后的示例：&lt;/p&gt;
&lt;p&gt;vue&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;script setup&amp;gt;
import &amp;#123; reactive, computed &amp;#125; from &#39;vue&#39;

const author = reactive(&amp;#123;
  name: &#39;John Doe&#39;,
  books: [
    &#39;Vue 2 - Advanced Guide&#39;,
    &#39;Vue 3 - Basic Guide&#39;,
    &#39;Vue 4 - The Mystery&#39;
  ]
&amp;#125;)

// 一个计算属性 ref
const publishedBooksMessage = computed(() =&amp;gt; &amp;#123;
  return author.books.length &amp;gt; 0 ? &#39;Yes&#39; : &#39;No&#39;
&amp;#125;)
&amp;lt;/script&amp;gt;

&amp;lt;template&amp;gt;
  &amp;lt;p&amp;gt;Has published books:&amp;lt;/p&amp;gt;
  &amp;lt;span&amp;gt;&amp;#123;&amp;#123; publishedBooksMessage &amp;#125;&amp;#125;&amp;lt;/span&amp;gt;
&amp;lt;/template&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9wbGF5LnZ1ZWpzLm9yZy8jZU5wMWtFOUx3MEFReGIvS0k1ZHRvVGFpbmtvYWFSRVVvWjVFRU9OaG0weWJZTE83N0o5Q0NmbnV6dGEwdmRqYnpyNlplYjk1WGJJd1pyb1BsTXlTekpXMk1SNk9mREI1b1pyV2FPdlJ3WklzZmJPbkNVcmRtdUNwUW8rTjFTMEVUNHBDRmFyVXlubkk0R3R0TVQ5UGpMcENBVXEyTklONDFiWENreVl4aVo5cnJYL2NERi94RFlpUFFMakREUmJWWHFxU0haNURVdzJ0ZzN6UDhsSzZwdnhIZTJEdHZTYXNEczZUUFRBVDhGMm9maHpoMGhUeWdtNXBjK0kxWWIxclhFM1ZNc0tzeURtNUpjWS85WTVHWTh4ekhJK3duSXBWdzRuVEkvMTBSMnJyYStTNHhTUEVKemtCdnZOTnMzMTB6dEsvUkRsTExqeTFaaWM5Y1FWa0puK1I3Z0l3eEpHbE1YaVduWkVxNzdvcmhIM1BxMk5IOURqdlRmcGZTQlNibUE9PQ==&#34;&gt;在演练场中尝试一下&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;我们在这里定义了一个计算属性  &lt;code&gt;publishedBooksMessage&lt;/code&gt; 。 &lt;code&gt;computed()&lt;/code&gt;  方法期望接收一个 &lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9kZXZlbG9wZXIubW96aWxsYS5vcmcvemgtQ04vZG9jcy9XZWIvSmF2YVNjcmlwdC9SZWZlcmVuY2UvRnVuY3Rpb25zL2dldCNkZXNjcmlwdGlvbg==&#34;&gt;getter 函数&lt;/span&gt;，返回值为一个&lt;strong&gt;计算属性 ref&lt;/strong&gt;。和其他一般的 ref 类似，你可以通过  &lt;code&gt;publishedBooksMessage.value&lt;/code&gt;  访问计算结果。计算属性 ref 也会在模板中自动解包，因此在模板表达式中引用时无需添加  &lt;code&gt;.value&lt;/code&gt; 。&lt;/p&gt;
&lt;p&gt;Vue 的计算属性会自动追踪响应式依赖。它会检测到  &lt;code&gt;publishedBooksMessage&lt;/code&gt;  依赖于  &lt;code&gt;author.books&lt;/code&gt; ，所以当  &lt;code&gt;author.books&lt;/code&gt;  改变时，任何依赖于  &lt;code&gt;publishedBooksMessage&lt;/code&gt;  的绑定都会同时更新。&lt;/p&gt;
&lt;p&gt;也可参考：&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9jbi52dWVqcy5vcmcvZ3VpZGUvdHlwZXNjcmlwdC9jb21wb3NpdGlvbi1hcGkuaHRtbCN0eXBpbmctY29tcHV0ZWQ=&#34;&gt;为计算属性标注类型&lt;/span&gt;&lt;/p&gt;
&lt;h2 id=&#34;计算属性缓存-vs-方法&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#计算属性缓存-vs-方法&#34;&gt;#&lt;/a&gt; 计算属性缓存 vs 方法&lt;/h2&gt;
&lt;p&gt;你可能注意到我们在表达式中像这样调用一个函数也会获得和计算属性相同的结果：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;p&amp;gt;&amp;#123;&amp;#123; calculateBooksMessage() &amp;#125;&amp;#125;&amp;lt;/p&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;js&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// 组件中
function calculateBooksMessage() &amp;#123;
  return author.books.length &amp;gt; 0 ? &#39;Yes&#39; : &#39;No&#39;
&amp;#125;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;若我们将同样的函数定义为一个方法而不是计算属性，两种方式在结果上确实是完全相同的，然而，不同之处在于&lt;strong&gt;计算属性值会基于其响应式依赖被缓存&lt;/strong&gt;。一个计算属性仅会在其响应式依赖更新时才重新计算。这意味着只要  &lt;code&gt;author.books&lt;/code&gt;  不改变，无论多少次访问  &lt;code&gt;publishedBooksMessage&lt;/code&gt;  都会立即返回先前的计算结果，而不用重复执行 getter 函数。&lt;/p&gt;
&lt;p&gt;这也解释了为什么下面的计算属性永远不会更新，因为  &lt;code&gt;Date.now()&lt;/code&gt;  并不是一个响应式依赖：&lt;/p&gt;
&lt;p&gt;js&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;const now = computed(() =&amp;gt; Date.now())
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;相比之下，方法调用&lt;strong&gt;总是&lt;/strong&gt;会在重渲染发生时再次执行函数。&lt;/p&gt;
&lt;p&gt;为什么需要缓存呢？想象一下我们有一个非常耗性能的计算属性  &lt;code&gt;list&lt;/code&gt; ，需要循环一个巨大的数组并做许多计算逻辑，并且可能也有其他计算属性依赖于  &lt;code&gt;list&lt;/code&gt; 。没有缓存的话，我们会重复执行非常多次  &lt;code&gt;list&lt;/code&gt;  的 getter，然而这实际上没有必要！如果你确定不需要缓存，那么也可以使用方法调用。&lt;/p&gt;
&lt;h2 id=&#34;可写计算属性&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#可写计算属性&#34;&gt;#&lt;/a&gt; 可写计算属性&lt;/h2&gt;
&lt;p&gt;计算属性默认是只读的。当你尝试修改一个计算属性时，你会收到一个运行时警告。只在某些特殊场景中你可能才需要用到 “可写” 的属性，你可以通过同时提供 getter 和 setter 来创建：&lt;/p&gt;
&lt;p&gt;vue&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;script setup&amp;gt;
import &amp;#123; ref, computed &amp;#125; from &#39;vue&#39;

const firstName = ref(&#39;John&#39;)
const lastName = ref(&#39;Doe&#39;)

const fullName = computed(&amp;#123;
  // getter
  get() &amp;#123;
    return firstName.value + &#39; &#39; + lastName.value
  &amp;#125;,
  // setter
  set(newValue) &amp;#123;
    // 注意：我们这里使用的是解构赋值语法
    [firstName.value, lastName.value] = newValue.split(&#39; &#39;)
  &amp;#125;
&amp;#125;)
&amp;lt;/script&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;现在当你再运行  &lt;code&gt;fullName.value = &#39;John Doe&#39;&lt;/code&gt;  时，setter 会被调用而  &lt;code&gt;firstName&lt;/code&gt;  和  &lt;code&gt;lastName&lt;/code&gt;  会随之更新。&lt;/p&gt;
&lt;h2 id=&#34;最佳实践&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#最佳实践&#34;&gt;#&lt;/a&gt; 最佳实践&lt;/h2&gt;
&lt;h3 id=&#34;getter-不应有副作用&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#getter-不应有副作用&#34;&gt;#&lt;/a&gt; Getter 不应有副作用&lt;/h3&gt;
&lt;p&gt;计算属性的 getter 应只做计算而没有任何其他的副作用，这一点非常重要，请务必牢记。举例来说，&lt;strong&gt;不要改变其他状态、在 getter 中做异步请求或者更改 DOM&lt;/strong&gt;！一个计算属性的声明中描述的是如何根据其他值派生一个值。因此 getter 的职责应该仅为计算和返回该值。在之后的指引中我们会讨论如何使用&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9jbi52dWVqcy5vcmcvZ3VpZGUvZXNzZW50aWFscy93YXRjaGVycy5odG1s&#34;&gt;侦听器&lt;/span&gt;根据其他响应式状态的变更来创建副作用。&lt;/p&gt;
&lt;h3 id=&#34;避免直接修改计算属性值&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#避免直接修改计算属性值&#34;&gt;#&lt;/a&gt; 避免直接修改计算属性值&lt;/h3&gt;
&lt;p&gt;从计算属性返回的值是派生状态。可以把它看作是一个 “临时快照”，每当源状态发生变化时，就会创建一个新的快照。更改快照是没有意义的，因此计算属性的返回值应该被视为只读的，并且永远不应该被更改 —— 应该更新它所依赖的源状态以触发新的计算。&lt;/p&gt;
&lt;h1 id=&#34;class-与-style-绑定&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#class-与-style-绑定&#34;&gt;#&lt;/a&gt; Class 与 Style 绑定&lt;/h1&gt;
&lt;p&gt;数据绑定的一个常见需求场景是操纵元素的 CSS class 列表和内联样式。因为  &lt;code&gt;class&lt;/code&gt;  和  &lt;code&gt;style&lt;/code&gt;  都是 attribute，我们可以和其他 attribute 一样使用  &lt;code&gt;v-bind&lt;/code&gt;  将它们和动态的字符串绑定。但是，在处理比较复杂的绑定时，通过拼接生成字符串是麻烦且易出错的。因此，Vue 专门为  &lt;code&gt;class&lt;/code&gt;  和  &lt;code&gt;style&lt;/code&gt;  的  &lt;code&gt;v-bind&lt;/code&gt;  用法提供了特殊的功能增强。除了字符串外，表达式的值也可以是对象或数组。&lt;/p&gt;
&lt;h2 id=&#34;绑定-html-class&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#绑定-html-class&#34;&gt;#&lt;/a&gt; 绑定 HTML class&lt;/h2&gt;
&lt;h3 id=&#34;绑定一个返回对象&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#绑定一个返回对象&#34;&gt;#&lt;/a&gt; 绑定一个返回对象&lt;/h3&gt;
&lt;p&gt;我们也可以绑定一个返回对象的&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9jbi52dWVqcy5vcmcvZ3VpZGUvZXNzZW50aWFscy9jb21wdXRlZC5odG1s&#34;&gt;计算属性&lt;/span&gt;。这是一个常见且很有用的技巧：&lt;/p&gt;
&lt;p&gt;js&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;const isActive = ref(true)
const error = ref(null)

const classObject = computed(() =&amp;gt; (&amp;#123;
  active: isActive.value &amp;amp;&amp;amp; !error.value,
  &#39;text-danger&#39;: error.value &amp;amp;&amp;amp; error.value.type === &#39;fatal&#39;
&amp;#125;))
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;div :class=&amp;quot;classObject&amp;quot;&amp;gt;&amp;lt;/div&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3 id=&#34;绑定数组&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#绑定数组&#34;&gt;#&lt;/a&gt; 绑定数组&lt;/h3&gt;
&lt;p&gt;然而，这可能在有多个依赖条件的 class 时会有些冗长。因此也可以在数组中嵌套对象：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;div :class=&amp;quot;[&amp;#123; [activeClass]: isActive &amp;#125;, errorClass]&amp;quot;&amp;gt;&amp;lt;/div&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;绑定内联样式&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#绑定内联样式&#34;&gt;#&lt;/a&gt; 绑定内联样式&lt;/h2&gt;
&lt;h3 id=&#34;样式多值&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#样式多值&#34;&gt;#&lt;/a&gt; 样式多值&lt;/h3&gt;
&lt;p&gt;你可以对一个样式属性提供多个 (不同前缀的) 值，举例来说：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;div :style=&amp;quot;&amp;#123; display: [&#39;-webkit-box&#39;, &#39;-ms-flexbox&#39;, &#39;flex&#39;] &amp;#125;&amp;quot;&amp;gt;&amp;lt;/div&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;数组仅会渲染浏览器支持的最后一个值。在这个示例中，在支持不需要&lt;strong&gt;特别前缀&lt;/strong&gt;的浏览器中都会渲染为  &lt;code&gt;display: flex&lt;/code&gt; 。&lt;/p&gt;
&lt;h1 id=&#34;条件渲染&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#条件渲染&#34;&gt;#&lt;/a&gt; 条件渲染&lt;/h1&gt;
&lt;h2 id=&#34;v-else-if&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#v-else-if&#34;&gt;#&lt;/a&gt;  &lt;code&gt;v-else-if&lt;/code&gt;&lt;/h2&gt;
&lt;p&gt;顾名思义， &lt;code&gt;v-else-if&lt;/code&gt;  提供的是相应于  &lt;code&gt;v-if&lt;/code&gt;  的 “else if 区块”。它可以连续多次重复使用：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;div v-if=&amp;quot;type === &#39;A&#39;&amp;quot;&amp;gt;
  A
&amp;lt;/div&amp;gt;
&amp;lt;div v-else-if=&amp;quot;type === &#39;B&#39;&amp;quot;&amp;gt;
  B
&amp;lt;/div&amp;gt;
&amp;lt;div v-else-if=&amp;quot;type === &#39;C&#39;&amp;quot;&amp;gt;
  C
&amp;lt;/div&amp;gt;
&amp;lt;div v-else&amp;gt;
  Not A/B/C
&amp;lt;/div&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;template-上的-v-if&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#template-上的-v-if&#34;&gt;#&lt;/a&gt;  &lt;code&gt;&amp;lt;template&amp;gt;&lt;/code&gt;  上的  &lt;code&gt;v-if&lt;/code&gt;&lt;/h2&gt;
&lt;p&gt;因为  &lt;code&gt;v-if&lt;/code&gt;  是一个指令，他必须依附于某个元素。但如果我们想要切换不止一个元素呢？在这种情况下我们可以在一个  &lt;code&gt;&amp;lt;template&amp;gt;&lt;/code&gt;  元素上使用  &lt;code&gt;v-if&lt;/code&gt; ，这只是一个不可见的包装器元素，最后渲染的结果并不会包含这个  &lt;code&gt;&amp;lt;template&amp;gt;&lt;/code&gt;  元素。&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;template v-if=&amp;quot;ok&amp;quot;&amp;gt;
  &amp;lt;h1&amp;gt;Title&amp;lt;/h1&amp;gt;
  &amp;lt;p&amp;gt;Paragraph 1&amp;lt;/p&amp;gt;
  &amp;lt;p&amp;gt;Paragraph 2&amp;lt;/p&amp;gt;
&amp;lt;/template&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;&lt;code&gt;v-else&lt;/code&gt;  和  &lt;code&gt;v-else-if&lt;/code&gt;  也可以在  &lt;code&gt;&amp;lt;template&amp;gt;&lt;/code&gt;  上使用。&lt;/p&gt;
&lt;h2 id=&#34;v-show&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#v-show&#34;&gt;#&lt;/a&gt;  &lt;code&gt;v-show&lt;/code&gt; []&lt;/h2&gt;
&lt;p&gt;另一个可以用来按条件显示一个元素的指令是  &lt;code&gt;v-show&lt;/code&gt; 。其用法基本一样：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;h1 v-show=&amp;quot;ok&amp;quot;&amp;gt;Hello!&amp;lt;/h1&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;不同之处在于  &lt;code&gt;v-show&lt;/code&gt;  会在 DOM 渲染中保留该元素； &lt;code&gt;v-show&lt;/code&gt;  仅切换了该元素上名为  &lt;code&gt;display&lt;/code&gt;  的 CSS 属性。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;v-show&lt;/code&gt;  不支持在  &lt;code&gt;&amp;lt;template&amp;gt;&lt;/code&gt;  元素上使用，也不能和  &lt;code&gt;v-else&lt;/code&gt;  搭配使用。&lt;/p&gt;
&lt;h2 id=&#34;v-if-vs-v-show&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#v-if-vs-v-show&#34;&gt;#&lt;/a&gt;  &lt;code&gt;v-if&lt;/code&gt;  vs.  &lt;code&gt;v-show&lt;/code&gt; []&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;v-if&lt;/code&gt;  是 “真实的” 按条件渲染，因为它确保了在切换时，条件区块内的事件监听器和子组件都会被销毁与重建。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;v-if&lt;/code&gt;  也是&lt;strong&gt;惰性&lt;/strong&gt;的：如果在初次渲染时条件值为 false，则不会做任何事。条件区块只有当条件首次变为 true 时才被渲染。&lt;/p&gt;
&lt;p&gt;相比之下， &lt;code&gt;v-show&lt;/code&gt;  简单许多，元素无论初始条件如何，始终会被渲染，只有 CSS  &lt;code&gt;display&lt;/code&gt;  属性会被切换。&lt;/p&gt;
&lt;p&gt;总的来说， &lt;code&gt;v-if&lt;/code&gt;  有&lt;strong&gt;更高的切换开销&lt;/strong&gt;，而  &lt;code&gt;v-show&lt;/code&gt;  有&lt;strong&gt;更高的初始渲染开销&lt;/strong&gt;。因此，如果需要频繁切换，则使用  &lt;code&gt;v-show&lt;/code&gt;  较好；如果在运行时绑定条件很少改变，则  &lt;code&gt;v-if&lt;/code&gt;  会更合适。&lt;/p&gt;
&lt;h2 id=&#34;v-if-和-v-for&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#v-if-和-v-for&#34;&gt;#&lt;/a&gt;  &lt;code&gt;v-if&lt;/code&gt;  和  &lt;code&gt;v-for&lt;/code&gt; []&lt;/h2&gt;
&lt;p&gt;警告&lt;/p&gt;
&lt;p&gt;同时使用  &lt;code&gt;v-if&lt;/code&gt;  和  &lt;code&gt;v-for&lt;/code&gt;  是&lt;strong&gt;不推荐的&lt;/strong&gt;，因为这样二者的优先级不明显。请查看&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9jbi52dWVqcy5vcmcvc3R5bGUtZ3VpZGUvcnVsZXMtZXNzZW50aWFsLmh0bWwjYXZvaWQtdi1pZi13aXRoLXYtZm9y&#34;&gt;风格指南&lt;/span&gt;获得更多信息。&lt;/p&gt;
&lt;p&gt;当  &lt;code&gt;v-if&lt;/code&gt;  和  &lt;code&gt;v-for&lt;/code&gt;  同时存在于一个元素上的时候， &lt;code&gt;v-if&lt;/code&gt;  会首先被执行。请查看&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9jbi52dWVqcy5vcmcvZ3VpZGUvZXNzZW50aWFscy9saXN0Lmh0bWwjdi1mb3Itd2l0aC12LWlm&#34;&gt;列表渲染指南&lt;/span&gt;获取更多细节。&lt;/p&gt;
&lt;h1 id=&#34;列表渲染&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#列表渲染&#34;&gt;#&lt;/a&gt; 列表渲染&lt;/h1&gt;
&lt;h2 id=&#34;v-for&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#v-for&#34;&gt;#&lt;/a&gt;  &lt;code&gt;v-for&lt;/code&gt;&lt;/h2&gt;
&lt;p&gt;在  &lt;code&gt;v-for&lt;/code&gt;  块中可以完整地访问父作用域内的属性和变量。 &lt;code&gt;v-for&lt;/code&gt;  也支持使用可选的第二个参数表示当前项的位置索引。&lt;/p&gt;
&lt;p&gt;js&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;const parentMessage = ref(&#39;Parent&#39;)
const items = ref([&amp;#123; message: &#39;Foo&#39; &amp;#125;, &amp;#123; message: &#39;Bar&#39; &amp;#125;])
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;li v-for=&amp;quot;(item, index) in items&amp;quot;&amp;gt;
  &amp;#123;&amp;#123; parentMessage &amp;#125;&amp;#125; - &amp;#123;&amp;#123; index &amp;#125;&amp;#125; - &amp;#123;&amp;#123; item.message &amp;#125;&amp;#125;
&amp;lt;/li&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;h3 id=&#34;使用解构&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#使用解构&#34;&gt;#&lt;/a&gt; 使用解构&lt;/h3&gt;
&lt;p&gt;注意  &lt;code&gt;v-for&lt;/code&gt;  是如何对应  &lt;code&gt;forEach&lt;/code&gt;  回调的函数签名的。实际上，你也可以在定义  &lt;code&gt;v-for&lt;/code&gt;  的变量别名时&lt;strong&gt;使用解构&lt;/strong&gt;，和解构函数参数类似：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;li v-for=&amp;quot;&amp;#123; message &amp;#125; in items&amp;quot;&amp;gt;
	// message是item的属性名，可解构
  &amp;#123;&amp;#123; message &amp;#125;&amp;#125;
&amp;lt;/li&amp;gt;

&amp;lt;!-- 有 index 索引时 --&amp;gt;
&amp;lt;li v-for=&amp;quot;(&amp;#123; message &amp;#125;, index) in items&amp;quot;&amp;gt;
  &amp;#123;&amp;#123; message &amp;#125;&amp;#125; &amp;#123;&amp;#123; index &amp;#125;&amp;#125;
&amp;lt;/li&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;v-for-与对象&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#v-for-与对象&#34;&gt;#&lt;/a&gt;  &lt;code&gt;v-for&lt;/code&gt;  与对象&lt;/h2&gt;
&lt;p&gt;你也可以使用  &lt;code&gt;v-for&lt;/code&gt;  来遍历一个对象的所有属性。遍历的顺序会基于对该对象调用  &lt;code&gt;Object.values()&lt;/code&gt;  的返回值来决定。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;li v-for=&amp;quot;(value, key, index) in myObject&amp;quot;&amp;gt;
  &amp;#123;&amp;#123; index &amp;#125;&amp;#125;. &amp;#123;&amp;#123; key &amp;#125;&amp;#125;: &amp;#123;&amp;#123; value &amp;#125;&amp;#125;
&amp;lt;/li&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;在-v-for-里使用范围值&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#在-v-for-里使用范围值&#34;&gt;#&lt;/a&gt; 在  &lt;code&gt;v-for&lt;/code&gt;  里使用范围值&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;v-for&lt;/code&gt;  可以直接接受一个整数值。在这种用例中，会将该模板基于  &lt;code&gt;1...n&lt;/code&gt;  的取值范围重复多次。&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;span v-for=&amp;quot;n in 10&amp;quot;&amp;gt;&amp;#123;&amp;#123; n &amp;#125;&amp;#125;&amp;lt;/span&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;注意此处  &lt;code&gt;n&lt;/code&gt;  的初值是从  &lt;code&gt;1&lt;/code&gt;  开始而非  &lt;code&gt;0&lt;/code&gt; 。&lt;/p&gt;
&lt;h2 id=&#34;通过-key-管理状态&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#通过-key-管理状态&#34;&gt;#&lt;/a&gt; 通过 key 管理状态&lt;/h2&gt;
&lt;p&gt;Vue 默认按照 “就地更新” 的策略来更新通过  &lt;code&gt;v-for&lt;/code&gt;  渲染的元素列表。当数据项的顺序改变时，Vue 不会随之移动 DOM 元素的顺序，而是就地更新每个元素，确保它们在原本指定的索引位置上渲染。&lt;/p&gt;
&lt;p&gt;默认模式是高效的，但&lt;strong&gt;只适用于列表渲染输出的结果不依赖子组件状态或者临时 DOM 状态 (例如表单输入值) 的情况&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;为了给 Vue 一个提示，以便它可以跟踪每个节点的标识，&lt;strong&gt;从而重用和重新排序现有的元素&lt;/strong&gt;，你需要为每个元素对应的块提供一个唯一的  &lt;code&gt;key&lt;/code&gt;  attribute：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;div v-for=&amp;quot;item in items&amp;quot; :key=&amp;quot;item.id&amp;quot;&amp;gt;
  &amp;lt;!-- 内容 --&amp;gt;
&amp;lt;/div&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;注意&lt;/p&gt;
&lt;p&gt;&lt;code&gt;key&lt;/code&gt;  在这里是一个通过  &lt;code&gt;v-bind&lt;/code&gt;  绑定的特殊 attribute。请不要和&lt;a href=&#34;https://cn.vuejs.org/guide/essentials/list.html#v-for-with-an-object&#34;&gt;在  &lt;code&gt;v-for&lt;/code&gt;  中使用对象&lt;/a&gt;里所提到的对象属性名相混淆。&lt;/p&gt;
&lt;h1 id=&#34;续&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#续&#34;&gt;#&lt;/a&gt; 续&lt;/h1&gt;
&lt;h2 id=&#34;reactive响应式对象&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#reactive响应式对象&#34;&gt;#&lt;/a&gt; reactive 响应式对象&lt;/h2&gt;
&lt;p&gt;不能重新赋值一个对象，可以借用 Object.assign ()&lt;/p&gt;
&lt;p&gt;ref () 则可以修改  &lt;code&gt;car.value  = &amp;#123;…&amp;#125;&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240830134823308.png&#34; alt=&#34;image-20240830134823308&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;使用原则:&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;若需要一个基本类型的响应式数据，必须使用 ref&lt;/li&gt;
&lt;li&gt;若需要一个响应式对象，层级不深， ref、reactive 都可以&lt;/li&gt;
&lt;li&gt;若需要一个响应式对象，且层级较深推荐使用 reactive&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;toRefs / toRef&lt;/strong&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Obj obj = toRefs(obj)

Param p = toRef(obj, param)
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;计算属性-2&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#计算属性-2&#34;&gt;#&lt;/a&gt; 计算属性&lt;/h2&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240830140740409.png&#34; alt=&#34;image-20240830140740409&#34; /&gt;&lt;/p&gt;
&lt;h2 id=&#34;路由&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#路由&#34;&gt;#&lt;/a&gt; 路由&lt;/h2&gt;
</content>
        <category term="Vue3" />
        <updated>2024-08-16T14:55:05.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2024/08/12/My-INTER-KNOT/</id>
        <title>My INTER-KNOT</title>
        <link rel="alternate" href="http://example.com/2024/08/12/My-INTER-KNOT/"/>
        <content type="html">&lt;h2 id=&#34;前言&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#前言&#34;&gt;#&lt;/a&gt; 前言&lt;/h2&gt;
&lt;p&gt;看到 b 站有 up 做了个绳网，基于 github 的&lt;/p&gt;
&lt;p&gt;感觉自己也可以动手做一个&lt;/p&gt;
&lt;h2 id=&#34;过程&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#过程&#34;&gt;#&lt;/a&gt; 过程&lt;/h2&gt;
&lt;h3 id=&#34;服务器&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#服务器&#34;&gt;#&lt;/a&gt; &lt;strong&gt;服务器&lt;/strong&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;购买 阿里云服务器 阿里云的服务器被黑了，遗憾离场&lt;/li&gt;
&lt;li&gt;连接 xshell（免费版）通过阿里云下载的密钥 xxx.pem&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;安装jdk&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#安装jdk&#34;&gt;#&lt;/a&gt; &lt;strong&gt;安装 jdk&lt;/strong&gt;&lt;/h3&gt;
&lt;p&gt;&lt;code&gt;yum -y install lrzsz&lt;/code&gt;  失败，一直 killed，遂用离线安装&lt;/p&gt;
&lt;p&gt;（一直爆 killed 是因为内存不够，只有 0.5G，后来配置改（降？）到 1G 就暂时没问题了）&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;// 下载安装包 
$ wget https://ohse.de/uwe/releases/lrzsz-0.12.20.tar.gz //来自lrzsz官网
$ tar -zxvf lrzsz-0.12.20.tar.gz 
$ cd lrzsz-0.12.20 
// 编译 
$ ./configure –prefix=/usr/local/lrzsz 
$ make 
$ make install 
// 建立软连接 
$ ln -s /usr/local/lrzsz/bin/lrz /usr/bin/rz 
$ ln -s /usr/local/lrzsz/bin/lsz /usr/bin/sz
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;传输 jdk&lt;/p&gt;
&lt;p&gt;&lt;code&gt;rz -be // 避免乱码&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;解压&lt;/p&gt;
&lt;p&gt;&lt;code&gt;tar -zxvf jdk-8u331-linux-x64.tar.gz&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;配置环境变量&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[root@chen987 usr]# cd ..
[root@chen987 /]# cd /etc/
[root@chen987 etc]# vim profile

# i 编辑 
# ：wq 保存
# 末尾加上如下
export JAVA_HOME=/usr/jdk-21.0.4 # 版本
export CLASSPATH=$JAVA_HOME/lib/
export PATH=$PATH:$JAVA_HOME/bin
export PATHJAVA_HOME CLASSPATH

# 修改完后，使之生效
source /etc/profile 

# 查看是否生效
java -version
&lt;/code&gt;&lt;/pre&gt;
&lt;h3 id=&#34;下载mysql&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#下载mysql&#34;&gt;#&lt;/a&gt; &lt;strong&gt;下载 MySql&lt;/strong&gt;&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;# 创建目录

# 获取下载yum源
wget &#39;https://dev.mysql.com/get/mysql57-community-release-el7-11.noarch.rpm&#39;

# 安装
rpm -Uvh mysql57-community-release-el7-11.noarch.rpm

# 查看拥有的mysql
yum repolist all | grep mysql

# 安装mysql
yum install -y mysql-community-server

# Error:GPG check FAILED
yum install -y mysql-community-server --nogpgcheck

# 启动
systemctl start mysqld
systemctl status mysqld

# 生成临时密码
grep &#39;temporary password&#39; /var/log/mysqld.log 

# 登陆
mysql -u root -p

# 修改密码
UPDATE mysql.user SET authentication_string=PASSWORD(&#39;your_new_password&#39;) WHERE User=&#39;root&#39;;

# You must reset your password using ALTER USER statement before executing this statement.
ALTER USER &#39;root&#39;@&#39;localhost&#39; IDENTIFIED BY &#39;CCCChen@@@@29&#39;;

# 打开权限 让本地能连接上阿里云
mysql&amp;gt; UPDATE mysql.user SET host = &#39;%&#39; WHERE user=&#39;root&#39;;
# 进行刷新
mysql&amp;gt; FLUSH PRIVILEGES;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;阿里云安全组编辑&lt;/p&gt;
&lt;p&gt;加上自己 ip 或者 对全部源开放&lt;/p&gt;
&lt;h3 id=&#34;部署springboot项目试运行&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#部署springboot项目试运行&#34;&gt;#&lt;/a&gt; &lt;strong&gt;部署 SpringBoot 项目&lt;/strong&gt;试运行&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;配置  &lt;code&gt;&amp;lt;packaging&amp;gt;jar&amp;lt;packaging&amp;gt;&lt;/code&gt; , &lt;code&gt;server.port:8080&lt;/code&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;打包（jar），maven package&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;上传 &lt;code&gt;rz&lt;/code&gt;  ，卡住就把 jar 包压缩&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;运行 &lt;code&gt;java -jar ***.jar&lt;/code&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;code&gt;nohup java -jar ***.jar &amp;amp; //使用下面的方法让这个项目在服务器上自动不间断地跑.&lt;/code&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;设计&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#设计&#34;&gt;#&lt;/a&gt; 设计&lt;/h2&gt;
&lt;h3 id=&#34;前端页面&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#前端页面&#34;&gt;#&lt;/a&gt; 前端页面&lt;/h3&gt;
&lt;h4 id=&#34;主页面&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#主页面&#34;&gt;#&lt;/a&gt; &lt;strong&gt;主页面&lt;/strong&gt;&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;瀑布流（？）&lt;/li&gt;
&lt;li&gt;分页（？）加载&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240813105911399.png&#34; alt=&#34;image-20240813105911399&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240902152505215.png&#34; alt=&#34;image-20240902152505215&#34; /&gt;&lt;/p&gt;
&lt;h4 id=&#34;文章详情页面&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#文章详情页面&#34;&gt;#&lt;/a&gt; &lt;strong&gt;文章详情页面&lt;/strong&gt;&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;点 空白处 或者 关闭键 即可返回&lt;/li&gt;
&lt;li&gt;委托内容折叠（展开）&lt;/li&gt;
&lt;li&gt;委托人 + 浏览量、封面、评论&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240813105928322.png&#34; alt=&#34;image-20240813105928322&#34; /&gt;&lt;/p&gt;
&lt;h5 id=&#34;route-使用&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#route-使用&#34;&gt;#&lt;/a&gt; Route 使用&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240903091525989.png&#34; alt=&#34;image-20240903091525989&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240903091625639.png&#34; alt=&#34;image-20240903091625639&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240903092251835.png&#34; alt=&#34;image-20240903092251835&#34; /&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;按钮动效&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240813110215773.png&#34; alt=&#34;image-20240813110215773&#34; /&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;评论、委托到底&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240813110056561.png&#34; alt=&#34;image-20240813110056561&#34; /&gt;&lt;/p&gt;
&lt;h4 id=&#34;登陆注册页面&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#登陆注册页面&#34;&gt;#&lt;/a&gt; &lt;strong&gt;登陆 / 注册页面&lt;/strong&gt;&lt;/h4&gt;
&lt;p&gt;……&lt;/p&gt;
&lt;h4 id=&#34;留言&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#留言&#34;&gt;#&lt;/a&gt; &lt;strong&gt;留言&lt;/strong&gt;&lt;/h4&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240812195208533.png&#34; alt=&#34;image-20240812195208533&#34; /&gt;&lt;/p&gt;
&lt;h4 id=&#34;vue3-学习&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#vue3-学习&#34;&gt;#&lt;/a&gt; Vue3 学习&lt;/h4&gt;
&lt;h3 id=&#34;数据库&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#数据库&#34;&gt;#&lt;/a&gt; 数据库&lt;/h3&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240813112732092.png&#34; alt=&#34;image-20240813112732092&#34; /&gt;&lt;/p&gt;
&lt;h4 id=&#34;表&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#表&#34;&gt;#&lt;/a&gt; 表&lt;/h4&gt;
&lt;pre&gt;&lt;code class=&#34;language-mysql&#34;&gt;create table user
(
    user_id           int auto_increment,
    user_name         varchar(255) default &#39;ShengJiang&#39;      not null,
    user_email        varchar(255)                           not null,
    user_pwd          varchar(255)                           not null,
    registration_date datetime     default CURRENT_TIMESTAMP not null,
    grade             int          default 1                 not null,
    version           int          default 1                 not null,
    is_deleted        int          default 0                 not null,
    primary key (user_id, is_deleted),
    constraint user_email
        unique (user_email)
);

create table post
(
    post_id      int auto_increment
        primary key,
    title        varchar(255)                       not null,
    content      text                               not null,
    publish_date datetime default CURRENT_TIMESTAMP not null,
    user_id      int                                not null,
    cover_id     int                                null,
    version      int      default 1                 not null,
    is_deleted   int      default 0                 not null,
    constraint fk_user_id
        foreign key (user_id) references user (user_id)
);

create table comment
(
    comment_id   int auto_increment
        primary key,
    content      text                               not null,
    comment_date datetime default CURRENT_TIMESTAMP not null,
    user_id      int                                not null,
    post_id      int                                not null,
    version      int      default 1                 not null,
    is_deleted   int      default 0                 not null,
    constraint fk_post
        foreign key (post_id) references post (post_id),
    constraint fk_user
        foreign key (user_id) references user (user_id)
);

CREATE TABLE image(
    image_id INT AUTO_INCREMENT PRIMARY KEY,
    image_name VARCHAR(255) NOT NULL,
    image_url VARCHAR(2048) NOT NULL, -- 存储图片链接的字段
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
) 
&lt;/code&gt;&lt;/pre&gt;
&lt;h3 id=&#34;reids&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#reids&#34;&gt;#&lt;/a&gt; Reids&lt;/h3&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h3MTU5MzU3Xy9hcnRpY2xlL2RldGFpbHMvMTA4MjU2ODA4&#34;&gt;如何在阿里云服务器上安装 Redis_在阿里云服务器安装 redis-CSDN 博客&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTEzMDE2OTIxOC9hcnRpY2xlL2RldGFpbHMvMTA2MzI5NDk0&#34;&gt;Linux 安装 Redis 步骤和 make 遇到的坑 解决方案_make redis-CSDN 博客&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDI1Nzk4L2FydGljbGUvZGV0YWlscy8xMTY2MTY1MzY=&#34;&gt;*** FATAL CONFIG FILE ERROR *** Reading the configuration file, at line 341 ＞＞＞ ‘set-proc-title yes‘-CSDN 博客&lt;/span&gt;&lt;/p&gt;
&lt;h3 id=&#34;后端&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#后端&#34;&gt;#&lt;/a&gt; 后端&lt;/h3&gt;
&lt;p&gt;spring boot 3.3.2&lt;/p&gt;
&lt;h4 id=&#34;框架搭建&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#框架搭建&#34;&gt;#&lt;/a&gt; 框架搭建&lt;/h4&gt;
&lt;p&gt;...&lt;/p&gt;
&lt;h4 id=&#34;依赖导入&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#依赖导入&#34;&gt;#&lt;/a&gt; 依赖导入&lt;/h4&gt;
&lt;p&gt;&lt;s&gt;spring security&lt;/s&gt;&lt;/p&gt;
&lt;p&gt;校验用了 jwt&lt;/p&gt;
&lt;h4 id=&#34;接口&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#接口&#34;&gt;#&lt;/a&gt; 接口&lt;/h4&gt;
&lt;h5 id=&#34;用户&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#用户&#34;&gt;#&lt;/a&gt; 用户&lt;/h5&gt;
&lt;ul class=&#34;task-list&#34;&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_0&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_0&#34;&gt; login 返回 user 和 jwt&lt;/label&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_1&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_1&#34;&gt; register&lt;/label&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_2&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_2&#34;&gt; logout 前端清除 jwt&lt;/label&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h5 id=&#34;委托&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#委托&#34;&gt;#&lt;/a&gt; 委托&lt;/h5&gt;
&lt;ul class=&#34;task-list&#34;&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_3&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_3&#34;&gt; selectAllArticle&lt;/label&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240830182715727.png&#34; alt=&#34;image-20240830182715727&#34; /&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_4&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_4&#34;&gt; selectOneArticle&lt;/label&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_5&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_5&#34;&gt; deleteArticle&lt;/label&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_6&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_6&#34;&gt; updateArticle&lt;/label&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h5 id=&#34;评论&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#评论&#34;&gt;#&lt;/a&gt; 评论&lt;/h5&gt;
&lt;ul class=&#34;task-list&#34;&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_7&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_7&#34;&gt; addComments&lt;/label&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_8&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_8&#34;&gt; deleteComments&lt;/label&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id=&#34;拦截器&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#拦截器&#34;&gt;#&lt;/a&gt; 拦截器&lt;/h4&gt;
&lt;ul class=&#34;task-list&#34;&gt;
&lt;li class=&#34;task-list-item&#34;&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_9&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_9&#34;&gt; 敏感词拦截器&lt;/label&gt;&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_10&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_10&#34;&gt; 黑名单拦截器&lt;/label&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;to-do-需求分析&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#to-do-需求分析&#34;&gt;#&lt;/a&gt; TO DO 需求分析&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;登陆 / 注册&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;邮箱登陆（第三方登陆）&lt;/li&gt;
&lt;li&gt;校验方式&lt;/li&gt;
&lt;li&gt;密码加密&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;第三方登陆（通过开源项目 JustAuth）&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;63305215.png&#34; alt=&#34;img&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;委托发布&lt;/strong&gt;&lt;/p&gt;
&lt;ul class=&#34;task-list&#34;&gt;
&lt;li class=&#34;task-list-item&#34;&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_11&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_11&#34;&gt; markdown 格式 （存储方式）&lt;/label&gt;&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_12&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_12&#34;&gt; 委托能否存在 redis （内存是否够）&lt;/label&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;评论&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;...&lt;/p&gt;
&lt;p&gt;&lt;s&gt;&lt;strong&gt;好友功能&lt;/strong&gt;&lt;/s&gt;&lt;/p&gt;
&lt;p&gt;...&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;等级功能&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;...&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;审核&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;风纪委员 / 管理员 （grade 字段，6 级可以删除用户评论、委托，6 级难以到达）&lt;/li&gt;
&lt;li&gt;过滤器 / 拦截器&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;ect&lt;/strong&gt;&lt;/p&gt;
&lt;ul class=&#34;task-list&#34;&gt;
&lt;li class=&#34;task-list-item&#34;&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_13&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_13&#34;&gt; user 加上 头像 id 字段，&lt;/label&gt;&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_14&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_14&#34;&gt; 委托 加上 浏览量，点赞量，是否开启评论区 字段&lt;/label&gt;&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_15&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_15&#34;&gt; 修改后端 pojo 类&lt;/label&gt;&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_16&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_16&#34;&gt; &lt;s&gt;评论 加上 点赞量 字段&lt;/s&gt;&lt;/label&gt;&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_17&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_17&#34;&gt; 加个 user 工具类，只传输不涉及安全的字段（比如不传输邮箱、密码）&lt;/label&gt;&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_18&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_18&#34;&gt; 反爬&lt;/label&gt;&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_19&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_19&#34;&gt; 数据库定期备份&lt;/label&gt;&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_20&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_20&#34;&gt; 将图片文件存储在服务器的文件系统中，对上传的文件名进行清理，避免脚本注入。&lt;/label&gt;&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_21&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_21&#34;&gt; 背景动效（固定斜纹 + 轮动图片）&lt;/label&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;参考&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#参考&#34;&gt;#&lt;/a&gt; 参考&lt;/h2&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0Vsb24xNS9hcnRpY2xlL2RldGFpbHMvMTI0NTE2OTI5&#34;&gt;保姆级教程 —— 将 springboot 项目部署到阿里云服务器（小白包会）_怎么把框架项目放到阿里云公网上 - CSDN 博客&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaXNoYW5nZGFuZ1FJUS9hcnRpY2xlL2RldGFpbHMvMTMwMTI0MjQy&#34;&gt;保姆级级教程 —— 将 springboot+vue 前后端分离项目部署到阿里云服务器（包教包会）2023 年最新版_前后端分离如何部署阿里服务器 - CSDN 博客&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2lteWFuZzIwMDcvYXJ0aWNsZS9kZXRhaWxzLzc2MzQ0NzA=&#34;&gt;linux tar 解压命令总结 - CSDN 博客&lt;/span&gt;&lt;/p&gt;
</content>
        <updated>2024-08-12T11:40:08.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2024/08/08/git-questions/</id>
        <title>git_questions</title>
        <link rel="alternate" href="http://example.com/2024/08/08/git-questions/"/>
        <content type="html">&lt;h3 id=&#34;本地初始化仓库远程仓库&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#本地初始化仓库远程仓库&#34;&gt;#&lt;/a&gt; 本地初始化仓库 + 远程仓库&lt;/h3&gt;
&lt;p&gt;本地合并时遇到 refusing to merge unrelated histories 的错误&lt;/p&gt;
&lt;p&gt;如果 git merge 合并的时候出现 refusing to merge unrelated histories 的错误，原因是两个仓库不同而导致的，需要在后面加上 ** &lt;code&gt;--allow-unrelated-histories&lt;/code&gt; ** 进行允许合并，即可解决问题&lt;/p&gt;
&lt;p&gt;如果还不能解决问题，就把本地的 remote 删除，重新 git remote add 添加远程仓库，再按上面的方法来，问题解决。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;git init

G:\GoLandProjects\go_learn&amp;gt;git pull
remote: Enumerating objects: 3, done.
remote: Counting objects: 100% (3/3), done.
remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
Unpacking objects: 100% (3/3), 893 bytes | 59.00 KiB/s, done.
From github.com:ShanJianSoda/golang_learn
 * [new branch]      main       -&amp;gt; origin/main
There is no tracking information for the current branch.
Please specify which branch you want to merge with.
See git-pull(1) for details.

    git pull &amp;lt;remote&amp;gt; &amp;lt;branch&amp;gt;

If you wish to set tracking information for this branch you can do so with:

    git branch --set-upstream-to=origin/&amp;lt;branch&amp;gt; main


G:\GoLandProjects\go_learn&amp;gt;git branch --set-upstream-to=origin/main main
branch &#39;main&#39; set up to track &#39;origin/main&#39;.

G:\GoLandProjects\go_learn&amp;gt;git pull
fatal: refusing to merge unrelated histories

G:\GoLandProjects\go_learn&amp;gt;git pull --allow-unrelated-histories
Merge made by the &#39;ort&#39; strategy.
 README.md | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 README.md

G:\GoLandProjects\go_learn&amp;gt;git push
Enumerating objects: 6, done.
Counting objects: 100% (6/6), done.
Delta compression using up to 16 threads
Compressing objects: 100% (4/4), done.
Writing objects: 100% (5/5), 1.06 KiB | 1.06 MiB/s, done.
Total 5 (delta 0), reused 0 (delta 0), pack-reused 0 (from 0)
To github.com:ShanJianSoda/golang_learn.git
   d130b38..e33a5c1  main -&amp;gt; main

&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;本地分支更名&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;git branch -m oldname newname
&lt;/code&gt;&lt;/pre&gt;
</content>
        <category term="git" />
        <updated>2024-08-08T03:31:56.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2024/07/14/Java%E9%9D%A2%E8%AF%95%E9%A2%98/</id>
        <title>Java面试题</title>
        <link rel="alternate" href="http://example.com/2024/07/14/Java%E9%9D%A2%E8%AF%95%E9%A2%98/"/>
        <content type="html">&lt;p&gt;记录&lt;/p&gt;
&lt;h1 id=&#34;java&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#java&#34;&gt;#&lt;/a&gt; Java&lt;/h1&gt;
&lt;h2 id=&#34;1-jdk-jre-jvm-三者区别&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#1-jdk-jre-jvm-三者区别&#34;&gt;#&lt;/a&gt; 1. JDK、JRE、JVM 三者区别&lt;/h2&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240714100212330.png&#34; alt=&#34;image-20240714100212330&#34; /&gt;&lt;/p&gt;
&lt;h2 id=&#34;2java-中创建对象的几种方式&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#2java-中创建对象的几种方式&#34;&gt;#&lt;/a&gt; 2.Java 中创建对象的几种方式？&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;使用 new 关键字：最常见的方式，这种方式我们还可以&lt;strong&gt;调用任意的构造器&lt;/strong&gt; (无参的和有参的)&lt;/li&gt;
&lt;li&gt;使用 Class.newlnstance: 通过 Class 类的 newInstance 创建对象，必须有&lt;strong&gt; public 的无参构造器&lt;/strong&gt;才行&lt;/li&gt;
&lt;li&gt;使用 Constructor.newlnstance: 通过 java.langrelect.Constructor 类中的 newlnstance 方法调用&lt;strong&gt;有参数的和私有的构造函数&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;使用 Clone: 通过对象的 clone0 方法创建一个对象的副本。需要&lt;strong&gt;对象实现 Cloneable 接口并重写 clone () 方法&lt;/strong&gt;。&lt;/li&gt;
&lt;li&gt;使用反序列化：通过将对象转换为字节流并保存到文件或传输到网络，然后再从字节流中重新创建对象。需要对象&lt;strong&gt;实现 Serializable&lt;/strong&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;3final-finally-finalize-的区别&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#3final-finally-finalize-的区别&#34;&gt;#&lt;/a&gt; 3.final、finally、 finalize 的区别&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;final 关键字：用于修饰类、方法、变量、入参和对象&lt;/strong&gt;&lt;br /&gt;
应用于类时，表示该类是最终类，不能被其他类继承，&lt;br /&gt;
 应用于方法时，表示该方法是最终方法，不能被子类重写&lt;br /&gt;
应用于变量时，表示该变量是一个常量，只能赋值一次。&lt;br /&gt;
应用于入参时，表示该入参在方法内无法被修改。&lt;br /&gt;
应用于对象时，该对象的引用不能被修改，但对象本身的状态是可变的。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;finally 关键字：异常处理机制中的一部分，用于定义在 try-catch-finally 块中的 finally 块&lt;/strong&gt;&lt;br /&gt;
不论是否发生异常，finally 块中的代码都会执行&lt;br /&gt;
主要用于释放资源、关闭连接等必须确保执行的操作。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;finalize 方法：是一个对象的方法，定义在 Object 类中&lt;/strong&gt;&lt;br /&gt;
在垃圾回收器将对象回收之前调用。&lt;br /&gt;
可以重写 finalize 方法，在其中编写对象在被回收前需要进行的清理操作，如释放资源等.&lt;br /&gt;
 请注意，不推荐使用 finalize 方法进行内存资源的释放，因为它没有被及时执行的保证，也可能导&lt;br /&gt;
致性能问题&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;5两个对象的-hashcode0-相同则-equals-也一定为-true-吗&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#5两个对象的-hashcode0-相同则-equals-也一定为-true-吗&#34;&gt;#&lt;/a&gt; 5. 两个对象的 hashCode0 相同，则 equals ( 也一定为 true 吗？&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;两个对象的 hashCode (相同，equals) 不一定为 true;&lt;/li&gt;
&lt;li&gt;两个对象的 equals 为 true，则两个对象的 hashcode 一定为 true&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;6-的区别&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#6-的区别&#34;&gt;#&lt;/a&gt; 6.&amp;amp;、&amp;amp;&amp;amp;、|、|| 的区别&lt;/h2&gt;
&lt;p&gt;&amp;amp; 全比较，&amp;amp;&amp;amp; 只要第一个不成立则不再判断&lt;/p&gt;
&lt;h2 id=&#34;7java-中的参数传递时传值呢-还是传引用&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#7java-中的参数传递时传值呢-还是传引用&#34;&gt;#&lt;/a&gt; 7.Java 中的参数传递时传值呢？还是传引用？&lt;/h2&gt;
&lt;p&gt;在 Java 中，方法参数传递是按值传递的。这意味着在方法调用时，实际上是将参数的值进行拷贝并传递给方法内部使用，而不是直接传递参数本身的引用。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;对于&lt;strong&gt;基本数据类型&lt;/strong&gt; (如整数、浮点数等):&lt;strong&gt; 传递的是其值的拷贝&lt;/strong&gt;。任何对参数值的修改都不会影响原始变量。&lt;/li&gt;
&lt;li&gt;对于 ** 引用类型 (** 如对象、数组等):&lt;strong&gt; 传递的是引用的值的拷贝&lt;/strong&gt;，也就是说方法内部的参数和原始变量将引用同一个对象。虽然我们可以通过方法内部的参数修改对象的状态，但是对于引用本身的修改是不会影响原始变量的。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;8什么是-java-的序列化如何实现-java-的序列化&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#8什么是-java-的序列化如何实现-java-的序列化&#34;&gt;#&lt;/a&gt; 8. 什么是 Java 的序列化，如何实现 Java 的序列化？&lt;/h2&gt;
&lt;p&gt;定义:&lt;strong&gt; 序列化是指将一个对象转换为字节流&lt;/strong&gt;，以便在网络上传输或保存到文件中。序列化过程还可以通过反序列化将字节流重新转换为对象&lt;/p&gt;
&lt;p&gt;实现方式：通过&lt;strong&gt;实现 java.io.Serializable 接口&lt;/strong&gt;。该接口是一个&lt;strong&gt;标记接口&lt;/strong&gt;，没有任何方法定义，只要一个类实现了 Serializable 接口，就表示该类的对象可以被序列化。Java 序列化机制会根据对象的类结构自动进行序列化和反序列化操作。&lt;/p&gt;
&lt;h2 id=&#34;9java-中的反射是什么意思&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#9java-中的反射是什么意思&#34;&gt;#&lt;/a&gt; 9.Java 中的反射是什么意思？&lt;/h2&gt;
&lt;p&gt;Java 的反射机制是指在运行状态中，对于任意一个类都能够知道这个类所有的属性和方法；并且对于任意一个对象，都能够调用它的任意一个方法；这种动态获取信息以及动态调用对象方法的功能成为 Java 语言的反射机制&lt;/p&gt;
&lt;p&gt;简单的说：在运行时动态地获取、操作和修改类或对象的属性、方法、构造函数等信息的能力，而不需要在编译时预先知道类的具体信息&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240714120514087.png&#34; alt=&#34;image-20240714120514087&#34; /&gt;&lt;/p&gt;
&lt;h2 id=&#34;10反射的应用场景有哪些-反射有什么优缺点&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#10反射的应用场景有哪些-反射有什么优缺点&#34;&gt;#&lt;/a&gt; 10. 反射的应用场景有哪些？反射有什么优缺点？&lt;/h2&gt;
&lt;h3 id=&#34;应用场景&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#应用场景&#34;&gt;#&lt;/a&gt; &lt;strong&gt;应用场景&lt;/strong&gt;&lt;/h3&gt;
&lt;p&gt;反射是 Java 框架的灵魂技术，很多框架都使用了反射技术，如 spring，Mybatis，Hibernate 等.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;JDBC 的数据库的连接&lt;/strong&gt;&lt;br /&gt;
在 JDBC 连接数据库中，一般包括加载驱动，获得数据库连接等步骤。而加载驱动，就是引入相关 Jar 包后，通过 Class.forName (加载数据库的驱动程序&lt;br /&gt;
 Class.forName (&amp;quot;com.mysgl.cj.jdbc.Driver&amp;quot;):&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;xml 或 properties 等配置文件加载&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Spring 通过 XML 配置模式装载 Bean，也是反射的一个典型例子&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;装载过程:&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;将程序内 XML 配置文件加载入内存中&lt;/li&gt;
&lt;li&gt;Java 类解析 xml 或者 properties 里面的内容，得到对应实体类的字节码字符串以及相关的属性信息&lt;/li&gt;
&lt;li&gt;使用反射机制，得到 Class 实例&lt;/li&gt;
&lt;li&gt;动态配置实例的属性&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这样做当然是有好处的不用每次都去 new 实例了，并且可以修改配置文件，比较灵活。&lt;/p&gt;
&lt;h3 id=&#34;反射的优点&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#反射的优点&#34;&gt;#&lt;/a&gt; &lt;strong&gt;反射的优点&lt;/strong&gt;&lt;/h3&gt;
&lt;p&gt;** 动态性:** 反射提供了在运行时动态地探索和操作类的能力。它允许我们在运行时获取类的信息、创建对象、调用方法和修改字段的值，从而使程序更加灵活、可扩展和动态适应复杂环境：：反射可以应对一些复杂的场景，如在插件化系统中根据配置文件加载类、动态代理、识别和处理注解等&lt;/p&gt;
&lt;h3 id=&#34;反射的缺点&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#反射的缺点&#34;&gt;#&lt;/a&gt; &lt;strong&gt;反射的缺点&lt;/strong&gt;&lt;/h3&gt;
&lt;p&gt;** 性能问题:** 由于反射涉及到动态解析和调用，所以它通常比直接调用代码性能较低。反射需要进行额外的检查和处理，可能会导致性能下降&lt;br /&gt;
 ** 安全问题:** 反射可以绕过访问控制限制，例如访问私有方法和字段。这可能会导致安全隐患，因此在使用反射时需要小心处理，并确保只在必要情况下使用&lt;/p&gt;
&lt;h2 id=&#34;11怎么实现动态代理&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#11怎么实现动态代理&#34;&gt;#&lt;/a&gt; 11. 怎么实现动态代理？&lt;/h2&gt;
&lt;p&gt;代理模式是一种设计模式，提供了对目标对象额外的访问方式，即通过代理对象访问目标对象，这样可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能&lt;/p&gt;
&lt;p&gt;动态代理实现方式:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;JDK 实现: JDK Proxy 基于反射&lt;/li&gt;
&lt;li&gt;第三方类实现: CGLIB 基于 ASM (一个 Java 字节码操作框架)&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;如何实现动态代理&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#如何实现动态代理&#34;&gt;#&lt;/a&gt; 如何实现动态代理&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;基于接口的 JDK 动态代理
&lt;ul&gt;
&lt;li&gt;定义目标类，即被代理的类&lt;/li&gt;
&lt;li&gt;通过实现 InvocationHandler 接口来自定义自己的 InvocationHandler; 重写 invoke 方法，在此方法中定义增强逻辑。&lt;/li&gt;
&lt;li&gt;通过 Proxy.newProxylnstance 方法获得代理对象&lt;/li&gt;
&lt;li&gt;通过代理对象调用目标方法&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240714122259992.png&#34; alt=&#34;image-20240714122259992&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240714122522237.png&#34; alt=&#34;image-20240714122522237&#34; /&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;基于类的 CGLIB 动态代理
&lt;ul&gt;
&lt;li&gt;引入 CGLIB 的相关依赖&lt;/li&gt;
&lt;li&gt;定义目标类，即被代理的类&lt;/li&gt;
&lt;li&gt;创建代理类实现 CGLIB 的 Methodinterceptor 接口，并重写 intercept 方法，在此方法中定义增强逻辑。&lt;/li&gt;
&lt;li&gt;使用 Enhancer 类创建代理对象，设置目标类、回调对象等参数&lt;/li&gt;
&lt;li&gt;调用代理对象的方法，实现代理行为。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240714122735661.png&#34; alt=&#34;image-20240714122735661&#34; /&gt;&lt;/p&gt;
&lt;h3 id=&#34;jdk-proxy与cglib的区别&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#jdk-proxy与cglib的区别&#34;&gt;#&lt;/a&gt; &lt;strong&gt;JDK Proxy 与 CGLIB 的区别&lt;/strong&gt;&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;基于接口 vs. 基于类:&lt;br /&gt;
JDK Proxy &lt;strong&gt;只能代理接口类型&lt;/strong&gt;，它通过实现指定接口并生成代理对象来实现代理功能&lt;br /&gt;
 CGLIB &lt;strong&gt;可以代理普通的类&lt;/strong&gt;，它通过继承目标类，并在子类中重写方法来实现代理。&lt;/li&gt;
&lt;li&gt;实现方式:&lt;br /&gt;
JDK Proxy 是&lt;strong&gt;基于反射机制&lt;/strong&gt;实现的，它利用 Java 的反射 API 动态生成代理对象&lt;br /&gt;
 CGLIB 使用了&lt;strong&gt;字节码生成库&lt;/strong&gt;，直接操作字节码生成代理类。相比于 JDK 代理的反射调用，CGLIB 的方法调用更快速&lt;/li&gt;
&lt;li&gt;性能:&lt;br /&gt;
&lt;strong&gt; 由于 CGLIB 是直接对字节码进行操作，所以在创建和执行代理对象时通常比 JDK 代理更快速&lt;/strong&gt;&lt;br /&gt;
 JDK Proxy 的性能略低，因为它涉及到反射调用的开销。JDK8 版本已经优化，性能与 CGLIB 差不多。&lt;/li&gt;
&lt;li&gt;库依赖:&lt;br /&gt;
JDK Proxy 是 Java 标准库的一部分，无需额外的依赖&lt;br /&gt;
 CGLIB 需要引入相关的第三方库&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;12-string-为什么不可变&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#12-string-为什么不可变&#34;&gt;#&lt;/a&gt; 12. String 为什么不可变？&lt;/h2&gt;
&lt;p&gt;String 类本身是&lt;strong&gt; final&lt;/strong&gt; 的，不可以被继承&lt;/p&gt;
&lt;p&gt;String 类内部通过 **private final char value []** 实现，从而保证了引用的不可变和对外的不可见&lt;/p&gt;
&lt;p&gt;String 内部通过良好的封装，不去改变 value 数组的值&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;为什么要设计成不可变？&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;字符串池优化：不可变性&lt;strong&gt;允许字符串共享和重用&lt;/strong&gt;，节省内存空间和提高性能&lt;/li&gt;
&lt;li&gt;线程安全性：不可变类&lt;strong&gt;天然具备线程安全的特性&lt;/strong&gt;，无需额外同步措施&lt;/li&gt;
&lt;li&gt;缓存哈希值：不可变性&lt;strong&gt;使得字符串的哈希值可以被缓存，提高相关数据结构的性能&lt;/strong&gt;。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;TIPS&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;可以用反射来改变 String 中 value 的值，所以严格意义上说不一定不可变。&lt;/p&gt;
&lt;h2 id=&#34;13string-stringbuilder-stringbuffer-的区别&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#13string-stringbuilder-stringbuffer-的区别&#34;&gt;#&lt;/a&gt; 13.String、StringBuilder、StringBuffer 的区别？&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;可变性:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;String 类是不可变类，一旦创建就无法改变其内容。对于每次修改操作 (例如拼接字符串)，都会创建一个新的字符串对象，旧对象则成为垃圾数据，需要等待垃圾回收。它们可以直接在原始对象上进行修改而不创建新的对象&lt;/li&gt;
&lt;li&gt;StringBuilder 和 StringBuffer 类是可变的，这种特性使得在频繁拼接或修改字符串时更高效。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;线程安全性:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;String 类是线程安全的，因为它的不可变性保证了多个线程同时访问同一个字符串对象时的安全性&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;StringBuilder 类是非线程安全的&lt;/strong&gt;，它的方法没有进行同步处理。如果在多线程环境下使用 StringBuilder，需要额外来取措施保证线程安全&lt;/li&gt;
&lt;li&gt;StringBuffer 类是线程安全的，它的方法进行了同步处理，因此可以在多线程环境下使用&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;性能:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;在单线程环境下，StringBuilder 的性能通常优于 StringBuffer，因为 StringBuilder 不进行同步处理，省去了同步的开销&lt;/li&gt;
&lt;li&gt;在多线程环境下，由于 StringBuffer 进行了同步处理，可能会带来额外的性能开销。但当线程同步是必需的时候，StringBuffer 是一个可靠的选择。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240714131415731.png&#34; alt=&#34;image-20240714131415731&#34; /&gt;&lt;/p&gt;
&lt;h2 id=&#34;14-string-str-i与-string-str-new-stringi-一样吗&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#14-string-str-i与-string-str-new-stringi-一样吗&#34;&gt;#&lt;/a&gt; 14. String str = &amp;quot;i&amp;quot; 与 String str = new String (&amp;quot;i&amp;quot;) 一样吗？&lt;/h2&gt;
&lt;p&gt;不一样，因为内存的分配方式不一样。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;String str=&amp;quot;i&amp;quot; 的方式 JVM 会将其分配到&lt;strong&gt;常量池&lt;/strong&gt;中；&lt;/li&gt;
&lt;li&gt;String str=new String (“i”) 方式，则会被分到&lt;strong&gt;堆内存&lt;/strong&gt;中。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;15-接口和抽象类有什么区别&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#15-接口和抽象类有什么区别&#34;&gt;#&lt;/a&gt; 15. 接口和抽象类有什么区别&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;定义关键字不同&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;接口使用关键字&lt;strong&gt; interface&lt;/strong&gt; 来定义。抽象类使用关键字&lt;strong&gt; abstract&lt;/strong&gt; 来定义&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;继承或实现的关键字不同&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;接口使用&lt;strong&gt; implements&lt;/strong&gt; 关键字定义其具体实现。 抽象类使用 **extends ** 关键字实现继承&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;子类扩展的数量不同&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;接口的实现类可以有多个&lt;/li&gt;
&lt;li&gt;抽象类的子类，只能继承一个抽象类，抽象类的子类，只能继承一个抽象类&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;属性访问控制符不同，方法控制符不同&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;接口中属性的访问控制符只能是 public (接口中的属性默认是 public static final 修饰的)&lt;/li&gt;
&lt;li&gt;抽象类中的属性访问控制符无限制，可为任意控制符&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;tip：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;接口可&lt;strong&gt;继承&lt;/strong&gt;多个父接口&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;16-什么是浅拷贝和深拷贝&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#16-什么是浅拷贝和深拷贝&#34;&gt;#&lt;/a&gt; 16. 什么是浅拷贝和深拷贝？&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;浅拷贝: &lt;strong&gt;只复制指向某个对象的指针&lt;/strong&gt;，而不复制对象本身，新旧对象共享一块内存&lt;/li&gt;
&lt;li&gt;深拷贝: &lt;strong&gt;复制并创建一个一摸一样的对象&lt;/strong&gt;，不共享内存，修改新对象，旧对象保持不变&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240714132445512.png&#34; alt=&#34;image-20240714132445512&#34; /&gt;&lt;/p&gt;
&lt;h2 id=&#34;17-overload-override-overwrite的区别&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#17-overload-override-overwrite的区别&#34;&gt;#&lt;/a&gt; 17. Overload、Override、Overwrite 的区别？&lt;/h2&gt;
&lt;p&gt;在面向对象编程中，有三个概念经常用到: Overload (重载)、Override (重写) 和 Overwrite (覆盖), 这些概念描述了不同的方法或函数之间的关系。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;重载 (Overload) :&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;定义：在同一个类中，可以定义多个具有相同名称但参数列表不同的方法，它们被称为方法的重载&lt;/p&gt;
&lt;p&gt;特点:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;方法名相同&lt;/strong&gt;，参数列表不同&lt;/li&gt;
&lt;li&gt;重载方法可以有不同的返回类型&lt;/li&gt;
&lt;li&gt;重载方法必须在同一个类中&lt;/li&gt;
&lt;li&gt;重载方法的&lt;strong&gt;区分依据是参数&lt;/strong&gt;的个数、类型或者顺序&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240714133843845.png&#34; alt=&#34;image-20240714133843845&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;重写 (Override)&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;定义：子类继承自父类时，可以对父类的方法进行重新实现，这被称为方法的重写&lt;/p&gt;
&lt;p&gt;特点:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;子类中的方法与父类中的方法具有相同的名称、参数列表和返回类型&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;子类中的方法不能比父类的方法访问性更严格&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;子类方法抛出的异常不能比父类方法抛出的异常更多&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;子类方法可以覆盖父类方法的实现，提供自己的实现逻辑&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240714133829892.png&#34; alt=&#34;image-20240714133829892&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;覆盖 (Overwrite)&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;定义：在文件操作中，覆盖 (Overwrite) 通常指的是&lt;strong&gt;将已有的文件内容替换为新的内容&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;特点:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;覆盖通常发生在文件写入时，用新的内容覆盖原有的内容，使其被替代&lt;/li&gt;
&lt;li&gt;覆盖可能会导致原文件的内容丢失，因此在进行覆盖操作时要小心。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;18-exception和error有什么区别&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#18-exception和error有什么区别&#34;&gt;#&lt;/a&gt; 18. Exception 和 Error 有什么区别？&lt;/h2&gt;
&lt;p&gt;在 Java 中，Exception 和 Error 是两个不同的类，它们&lt;strong&gt;都继承自 Throwable 类&lt;/strong&gt;。下面是它们之间的区别:&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Exception (异常) :&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Exception 表示在程序执行过程中可能出现的可处理的异常情况。** 它一般由代码逻辑错误、外部条件变化等原因引起，可以通过适当的处理措施来恢复正常的程序执行。**Exception 分为两种类型:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;受检异常 (Checked Exception)&lt;/strong&gt; : 编译器要求必须在代码中显式地处理受检异常，否则代码无法通过编译。常见的受检异常包括 IOException、SQLException 等。（用 try-catch-finally）&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;非受检异常 (Unchecked Exception)&lt;/strong&gt; : 编译器对非受检异常不强制要求进行处理，但可以选择处理或者将其抛给上层调用者处理。常见的非受检异常包括 NullPointerException、ArrayIndexOutOfBoundsException 等&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;Error (错误)：&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Error 是&lt;strong&gt;指应用程序通常无法处理或恢复的严重问题&lt;/strong&gt;，如除零错误&lt;/p&gt;
&lt;p&gt;Error 通常表示&lt;strong&gt;虚拟机 (JVM) 的错误状态或系统级错误&lt;/strong&gt;，例如 OutOfMemoryError、StackOverflowError 等&lt;/p&gt;
&lt;p&gt;Error 通常意味着应用程序处于不可恢复的状态，因此一般不被捕获和处理&lt;/p&gt;
&lt;p&gt;与异常不同，Error 没有规定要求应用程序处理或捕获它们。&lt;/p&gt;
&lt;h2 id=&#34;19-java中的io流的分类-说出几个你熟悉的实现类&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#19-java中的io流的分类-说出几个你熟悉的实现类&#34;&gt;#&lt;/a&gt; 19. Java 中的 IO 流的分类？说出几个你熟悉的实现类？&lt;/h2&gt;
&lt;p&gt;在 Java 中，10 流可以根据其功能和作用进行分类。主要分为四种类型：字节流、字符流、缓冲流和对象流&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240714134749700.png&#34; alt=&#34;image-20240714134749700&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;字节流 (Byte Stream):&lt;/strong&gt; &lt;strong&gt;以字节为单位进行读写操作的流&lt;/strong&gt;。字节流通常用于处理二进制数据或字节流形式的文本数据。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;InputStream: 字节输入流的抽象基类，是所有字节输入流的超类&lt;/li&gt;
&lt;li&gt;OutputStream: 字节输出流的抽象基类，是所有字节输出流的超类&lt;/li&gt;
&lt;li&gt;一些实现类包括: FilelnputStream、FileOutputStream、ByteArraylnputStream、ByteArrayOutputStream 等&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;字符流 (Character Stream):&lt;/strong&gt; &lt;strong&gt;以字符为单位进行读写操作的流&lt;/strong&gt;。字符流通常用于处理字符数据，支持 Unicode 编码。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Reader: 字符输入流的抽象基类，是所有字符输入流的超类&lt;/li&gt;
&lt;li&gt;Writer: 字符输出流的抽象基类，是所有字符输出流的超类&lt;/li&gt;
&lt;li&gt;一些实现类包括: FileReader、FileWriter、BufferedReader、PrintWriter 等&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;缓冲流 (Buffered Stream)&lt;/strong&gt; : 提供了&lt;strong&gt;缓冲功能&lt;/strong&gt;，可以减少实际 IO 操作的次数，提高读写效率&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;BufferedInputStream: 字节缓冲输入流，装饰器模式实现&lt;/li&gt;
&lt;li&gt;BufferedOutputStream: 字节缓冲输出流，装饰器模式实现&lt;/li&gt;
&lt;li&gt;BufferedReader: 字符缓冲输入流，装饰器模式实现&lt;/li&gt;
&lt;li&gt;BufferedWriter: 字符缓冲输出流，装饰器模式实现&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;对象流 (Object Stream)&lt;/strong&gt;:  &lt;strong&gt;用于读写 Java 对象的流&lt;/strong&gt;。可以方便地将对象序列化和反序列化到文件或网络中&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;ObjectlnputStream: 对象输入流，用于从流中读取对象&lt;/li&gt;
&lt;li&gt;ObjectOutputStream: 对象输出流，用于将对象写入流&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;20-常见的异常类有哪些&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#20-常见的异常类有哪些&#34;&gt;#&lt;/a&gt; 20. 常见的异常类有哪些？&lt;/h2&gt;
&lt;p&gt;RuntimeException (运行时异常)&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;NullPointerException: 空指针异常，当对一个对象引用调用方法或访问属性时，对象引用为空&lt;/li&gt;
&lt;li&gt;ArraylndexOutOfBoundsException: 数组下标越界异常，当尝试访问数组的不存在的索引时抛出&lt;/li&gt;
&lt;li&gt;lllegalArgumentException: 非法参数异常，当传递给方法的参数不合法时抛出&lt;/li&gt;
&lt;li&gt;lllegalStateException: 非法状态异常，当对象处于不允许的状态下调用方法时抛出&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;IOException (输入输出异常) :&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;FileNotFoundException: 文件未找到异常，当尝试打开不存在的文件时抛出&lt;/li&gt;
&lt;li&gt;EOFException: 文件结束异常，当从数据流读取数据时到达文件末尾时抛出&lt;/li&gt;
&lt;li&gt;SocketException: 套接字异常，当与套接字相关的操作失败时抛出&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;SQLException (数据库异常) :&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;SQLSyntaxErrorException: SQL 语法错误异常，当执行 SQL 语句时遇到语法错误时抛出&lt;/li&gt;
&lt;li&gt;DataAccessException: 数据访问异常，当访问数据库或数据存储出现问题时抛出&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;ClassNotFoundException: 类未找到异常，当尝试加载不存在的类时抛出&lt;/p&gt;
&lt;h2 id=&#34;22-arraylist和linkedlist区别&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#22-arraylist和linkedlist区别&#34;&gt;#&lt;/a&gt; 22. ArrayList 和 LinkedList 区别&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;底层数据结构不同，ArrayList 底层是基于数组实现的，LinkedList 底层是基于链表实现的&lt;/li&gt;
&lt;li&gt;由于底层数据结构不同，他们所适用的场景也不同，ArrayList 更适合随机查找，Linkedlist 更适合删除和添加，查询、添加、删除的时间复杂度不同&lt;/li&gt;
&lt;li&gt;另外 Arravlist 和 LinkedList 都实现了 List 接口，但是 LinkedList 还额外实现了 Deque 接口，所以 LinkedlList 还可以当做队列来使用&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;24-copyonwritearraylist的底层原理是怎样的&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#24-copyonwritearraylist的底层原理是怎样的&#34;&gt;#&lt;/a&gt; 24. CopyOnWriteArrayList 的底层原理是怎样的&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;首先 CopyOnWriteArrayList 内也是用时数组来实现的，在向 CopyOnWriteArrayList 添元索时，会复制一个新的数组，&lt;strong&gt;写操作在新数进行，读操作在原数组上进行&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;并且，&lt;strong&gt;写操作会加锁&lt;/strong&gt;，防止出现并发写入丢失数据的问题&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;写操作结束之后会把原数组指向新数组&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;CopyOnWiteArraylist&lt;strong&gt; 允许在写操作时来读取数据，大大提高了读的性能，因此适合读多写少的应用场&lt;/strong&gt;，但是 CopyOnWiteAraylist 会比较占内存，同时可能读到的数据不是实时最新的数据，所以不&lt;strong&gt;适合实时性要求很高的场景&lt;/strong&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;30-hashmap的扩容机制原理&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#30-hashmap的扩容机制原理&#34;&gt;#&lt;/a&gt; 30. HashMap 的扩容机制原理&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;1.7 版本&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;先生成新数组&lt;/li&gt;
&lt;li&gt;遍历老数组中的每个位置上的链表上的每个元素&lt;/li&gt;
&lt;li&gt;取每个元素的 key，并基于新数组长度，计算出每个元素在新数组中的下标&lt;/li&gt;
&lt;li&gt;将元素添加到新数组中去&lt;/li&gt;
&lt;li&gt;所有元素转移完了之后，将新数组赋值给 HashMap 对象的 table 属性&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;1.8 版本&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;先生成新数组&lt;/li&gt;
&lt;li&gt;遍历老数组中的每个位置上的链表或红黑树&lt;/li&gt;
&lt;li&gt;如果是链表，则直接将链表中的每个元素重新计算下标，并添加到新数组中去&lt;/li&gt;
&lt;li&gt;如果是红黑树，则先遍历红黑树，先计算出红黑树中每个元素对应在新数组中的下标位置
&lt;ol&gt;
&lt;li&gt;统计每个下标位置的元素个数&lt;/li&gt;
&lt;li&gt;如果该位置下的元素个数超过了 8，则生成一个新的红黑树，并将根节点的添加到新数组的对应位置&lt;/li&gt;
&lt;li&gt;如果该位置下的元素个数没有超过 8，那么则生成一个链表，并将链表的头节点添加到新数组的对应位置&lt;/li&gt;
&lt;/ol&gt;
&lt;/li&gt;
&lt;li&gt;所有元素转移完了之后，将新数组赋值给 HashMap 对象的 table 属性&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Tips:&lt;/p&gt;
&lt;p&gt;1.7 版本的 hash 链表的部分是头插法，不需要遍历到尾部，更快&lt;/p&gt;
&lt;p&gt;1.8 版本的 hash 链表的部分是尾插法，因为要判断是否大于 8，大于 8 就转换成红黑树，而知道数量需要遍历链表，则用尾插法&lt;/p&gt;
&lt;h2 id=&#34;32-java死锁如何避免&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#32-java死锁如何避免&#34;&gt;#&lt;/a&gt; 32. Java 死锁如何避免&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;造成死锁的几个原因&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;一个资源每次只能被一个线程使用&lt;/li&gt;
&lt;li&gt;一个线程在阻塞等待某个资源时，不释放已占有资源&lt;/li&gt;
&lt;li&gt;一个线程已经获得的资源，在未使用完之前，不能被强行剥夺&lt;/li&gt;
&lt;li&gt;若干线程形成头尾相接的循环等待资源关系&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;这是造成死锁必须要达到的 4 个条件，如果要避免死锁，只需要不满足其中某一个条件即可。&lt;/p&gt;
&lt;p&gt;而其中前 3 个条件是作为锁要符合的条件，所以要避免死执就需要打破第 4 个条件，不出现循环等待锁的关系&lt;/p&gt;
&lt;p&gt;在开发过程中:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;要注意&lt;strong&gt;加锁顺序&lt;/strong&gt;，保证每个线程按同样的顺序进行加锁&lt;/li&gt;
&lt;li&gt;要注意加锁时限，可以针对所设置一个&lt;strong&gt;超时时间&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;要注意&lt;strong&gt;死锁检查&lt;/strong&gt;，这是一种预防机制，确保在第一时间发现死锁并进行解决&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;34-java中有哪些类加载器&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#34-java中有哪些类加载器&#34;&gt;#&lt;/a&gt; 34. Java 中有哪些类加载器&lt;/h2&gt;
&lt;p&gt;JDK 自带有三个类加载器: bootstrap ClassLoader、ExtClassLoader、AppClassLoader。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;BootStrapClassLoader 是 ExtClassLoader 的父类加载器，默认负责加载 % JAVA HOME% lib 下的 iar 包和 cass 文件&lt;/li&gt;
&lt;li&gt;ExtClassLoader 是 AppClassLoader 的父类加载器，负责加载 % JAVA HOME%/lib/ext 文件夹下的 jar 包和 class 类&lt;/li&gt;
&lt;li&gt;AppClassLoader 是自定义类加载器的父类，负责加载 lasspath 下的类文件&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;39-和的区别是什么&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#39-和的区别是什么&#34;&gt;#&lt;/a&gt; 39. #{} 和 ${} 的区别是什么？&lt;/h2&gt;
&lt;p&gt;#{} 是预编译处理、是占位符，${} 是字符串替换、是拼接符。&lt;/p&gt;
&lt;p&gt;Mybatis 在处理 #{} 时，会将 sql 中的 #{} 替换为？号，调用 PreparedStatement 来赋值&lt;/p&gt;
&lt;p&gt;Mybatis 在处理&lt;span class=&#34;katex&#34;&gt;&lt;span class=&#34;katex-mathml&#34;&gt;&lt;math xmlns=&#34;http://www.w3.org/1998/Math/MathML&#34;&gt;&lt;semantics&gt;&lt;mrow&gt;&lt;mrow&gt;&lt;/mrow&gt;&lt;mtext&gt;时，会将&lt;/mtext&gt;&lt;mi&gt;s&lt;/mi&gt;&lt;mi&gt;q&lt;/mi&gt;&lt;mi&gt;l&lt;/mi&gt;&lt;mtext&gt;中的&lt;/mtext&gt;&lt;/mrow&gt;&lt;annotation encoding=&#34;application/x-tex&#34;&gt;{}时，会将sql中的&lt;/annotation&gt;&lt;/semantics&gt;&lt;/math&gt;&lt;/span&gt;&lt;span class=&#34;katex-html&#34; aria-hidden=&#34;true&#34;&gt;&lt;span class=&#34;base&#34;&gt;&lt;span class=&#34;strut&#34; style=&#34;height:0.8888799999999999em;vertical-align:-0.19444em;&#34;&gt;&lt;/span&gt;&lt;span class=&#34;mord&#34;&gt;&lt;/span&gt;&lt;span class=&#34;mord cjk_fallback&#34;&gt;时&lt;/span&gt;&lt;span class=&#34;mord cjk_fallback&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;mord cjk_fallback&#34;&gt;会&lt;/span&gt;&lt;span class=&#34;mord cjk_fallback&#34;&gt;将&lt;/span&gt;&lt;span class=&#34;mord mathnormal&#34;&gt;s&lt;/span&gt;&lt;span class=&#34;mord mathnormal&#34; style=&#34;margin-right:0.03588em;&#34;&gt;q&lt;/span&gt;&lt;span class=&#34;mord mathnormal&#34; style=&#34;margin-right:0.01968em;&#34;&gt;l&lt;/span&gt;&lt;span class=&#34;mord cjk_fallback&#34;&gt;中&lt;/span&gt;&lt;span class=&#34;mord cjk_fallback&#34;&gt;的&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt; {} 替换成变量的值，调用 Statement 来赋值&lt;/p&gt;
&lt;p&gt;使用 #{} 可以有效的防止 SQL 注入，提高系统安全性&lt;/p&gt;
&lt;h2 id=&#34;60-sychronized和reentrantlock的区别&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#60-sychronized和reentrantlock的区别&#34;&gt;#&lt;/a&gt; 60. Sychronized 和 ReentrantLock 的区别&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Sychronized 是一个&lt;strong&gt;关键字&lt;/strong&gt;，ReentrantLock 是一个类&lt;/li&gt;
&lt;li&gt;Sychronized 会&lt;strong&gt;自动的加锁与释放锁&lt;/strong&gt;，ReentrantLock 需要程序员手动加锁与释放锁&lt;/li&gt;
&lt;li&gt;Sychronized 的底层是&lt;strong&gt; JVM 层面的锁&lt;/strong&gt;，ReentrantLock 是&lt;strong&gt; API 层面的锁&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;Sychronized 是&lt;strong&gt;非公平锁&lt;/strong&gt;，ReentrantLock&lt;strong&gt; 可以选择公平锁或非公平锁&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;Sychronized 锁的是对象，锁信息保存在对象头中，ReentrantLock 通过代码中 int 类型的 state 标识来标识锁的状态&lt;/li&gt;
&lt;li&gt;Sychronized 底层有一个锁升级的过程&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;java类的加载过程&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#java类的加载过程&#34;&gt;#&lt;/a&gt; Java 类的加载过程&lt;/h2&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTYzOTEyL2FydGljbGUvZGV0YWlscy8xMTY2NDI1NTY=&#34;&gt;请你说说 Java 类的加载过程_说说类加载的流程 - CSDN 博客&lt;/span&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;什么是类的加载过程&lt;/li&gt;
&lt;li&gt;一个 Java 文件从编码完成到最终运行，一般会经历两个阶段：编译期、运行期。编译，即通过 javac 命令，将 Java 文件转化为二进制字节码文件，即.class 文件；运行，则是将.class 文件交给 JVM 执行。而本文所说的类加载过程就是将.class 文件中类的元信息加载进内存，创建 Class 对象并进行解析、初始化类变量等的过程&lt;br /&gt;
​    JVM 并不是一开始就会将所有的类加载到内存，而是用到某个类，才会去加载，只加载一次，后续会说到类的加载时机&lt;/li&gt;
&lt;li&gt;类加载详解&lt;/li&gt;
&lt;li&gt;类加载分为三个部分：&lt;strong&gt;加载、连接、初始化&lt;/strong&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;2.1 加载&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;​        类的加载主要的职责为将.class 文件的二进制字节流读入内存 (JDK1.7 及之前为 JVM 内存，JDK1.8 及之后为本地内存)，并在堆内存中为之创建 Class 对象，作为.class 进入内存后的数据的访问入口。在这里只是读入二进制字节流，后续的验证阶段就是要拿二进制字节流来验证.class 文件，验证通过，才会将.class 文件转为运行时数据结构&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;2.2 连接&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;类的连接分为三个阶段：&lt;strong&gt;验证、准备、解析&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;验证&lt;/strong&gt;：该阶段主要是为了保证加载进来的字节流符合 JVM 的规范，不会对 JVM 有安全性问题。其中有对元数据的验证，例如检查类是否继承了被 final 修饰的类；还有对符号引用的验证，例如校验符号引用是否可以通过全限定名找到，或者是检查符号引用的权限 (private、public) 是否符合语法规定等。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;准备&lt;/strong&gt;：准备阶段的主要任务是为类的类变量开辟空间并赋默认值。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;静态变量是基本类型（int、long、short、char、byte、boolean、float、double）的默认值为 0&lt;/li&gt;
&lt;li&gt;静态变量是引用类型的，默认值为 null&lt;/li&gt;
&lt;li&gt;静态常量默认值为声明时设定的值&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;例如：public static final int i = 3; 在准备阶段，i 的值即为 3&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;解析&lt;/strong&gt;：该阶段的主要职责为将 Class 在常量池中的符号引用转变为直接引用，此处针对的是静态方法及属性和私有方法与属性，因为这类方法与私有方法不能被重写，静态属性在运行期也没有多态这一说，即在编译器可知，运行期不可变，所以适合在该阶段解析，譬如类方法 main 替换为直接引用，为静态连接，区别于运行时的动态连接 (后续我会写关于 JVM 内存结构的文章，在讲解栈帧时会介绍动态链接)。&lt;/p&gt;
&lt;p&gt;符号引用即字符串，说白了可以是一个字段名，或者一个方法名；直接引用即偏移量，说白了就是类的元信息位于内存的地址串，例如，一个类的方法为 test ()，则符号引用即为 test，这个方法存在于内存中的地址假设为 0x123456，则这个地址则为直接引用。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;2.3 初始化&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;该阶段主要是为类的类变量初始化值的，初始化有两种方式：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;在声明类变量时，直接给变量赋值&lt;/li&gt;
&lt;li&gt;在静态初始化块为类变量赋值&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;java锁有哪些sychronized是什么锁&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#java锁有哪些sychronized是什么锁&#34;&gt;#&lt;/a&gt; java 锁有哪些，Sychronized 是什么锁&lt;/h2&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hpbmdjaGVuc3VpeXVlL2FydGljbGUvZGV0YWlscy8xMDg3MTY0NjY=&#34;&gt;Java 中常见的各种锁（非常全）_java 滑块锁 - CSDN 博客&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240802153419417.png&#34; alt=&#34;image-20240802153419417&#34; /&gt;&lt;/p&gt;
&lt;h2 id=&#34;线程创建方式&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#线程创建方式&#34;&gt;#&lt;/a&gt; 线程创建方式&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;方式一：继承于 Thread 类&lt;/li&gt;
&lt;li&gt;方式二：实现 Runnable 接口&lt;/li&gt;
&lt;li&gt;方式三：实现 Callable 接口&lt;/li&gt;
&lt;li&gt;方式四：使用线程池&lt;/li&gt;
&lt;li&gt;方式五：使用匿名类&lt;/li&gt;
&lt;/ul&gt;
&lt;h1 id=&#34;数据结构&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#数据结构&#34;&gt;#&lt;/a&gt; 数据结构&lt;/h1&gt;
&lt;h2 id=&#34;跳表&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#跳表&#34;&gt;#&lt;/a&gt; 跳表&lt;/h2&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0FwcGxlZWF0aW5nYm95L2FydGljbGUvZGV0YWlscy8xMTk5NDgzNDA=&#34;&gt;跳表的原理与实现 &lt;/span&gt;&lt;/p&gt;
&lt;p&gt;将&lt;strong&gt;单链表先进行排序&lt;/strong&gt;，然后针对 &lt;strong&gt;有序链表&lt;/strong&gt; 为了实现高效的查找，可以使用跳表这种数据结构。&lt;/p&gt;
&lt;p&gt;其根本思想是 &lt;strong&gt;二分查找&lt;/strong&gt; 的思想。&lt;/p&gt;
&lt;p&gt;跳表的前提条件是 针对 &lt;strong&gt;有序的单链表&lt;/strong&gt; ，实现高效地查找，插入，删除。&lt;/p&gt;
&lt;p&gt;Redis 中的 有序集合 &lt;strong&gt;sorted set&lt;/strong&gt; 就是用跳表实现的。&lt;/p&gt;
&lt;h1 id=&#34;mysql-redis&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#mysql-redis&#34;&gt;#&lt;/a&gt; MySQL、Redis&lt;/h1&gt;
&lt;h2 id=&#34;mysql索引实现有哪些&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#mysql索引实现有哪些&#34;&gt;#&lt;/a&gt; MySQL 索引实现有哪些&lt;/h2&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc2NzAxNS9hcnRpY2xlL2RldGFpbHMvMTE5MTA5Mzg1&#34;&gt;MySQL 索引的概念以及七种索引类型介绍_什么是数据库索引，mysql 常见的索引类型有哪些？-CSDN 博客&lt;/span&gt;&lt;/p&gt;
&lt;h3 id=&#34;1-索引的概念&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#1-索引的概念&#34;&gt;#&lt;/a&gt; 1 索引的概念&lt;/h3&gt;
&lt;p&gt;索引（在 MySQL 中也叫做 “键（key）”）是存储引擎用于快速找到记录的一种数据结构，这也是索引最基本的功能。&lt;/p&gt;
&lt;p&gt;索引对于良好的性能非常关键。数据量越大时，索引对性能的影响也越重要，好的索引可以将查询性能提高几个数量级。在数据量较小且负载较低时，不恰当的索引对性能的影响可能还不明显，但是在数据量逐渐增大时，糟糕的索引会使 MySQL 的性能急剧的下降。&lt;/p&gt;
&lt;p&gt;索引优化是查询性能优化最有效的手段。&lt;/p&gt;
&lt;h3 id=&#34;2-索引的类型&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#2-索引的类型&#34;&gt;#&lt;/a&gt; 2 索引的类型&lt;/h3&gt;
&lt;p&gt;按照功能逻辑区分，MySQL 目前主要有以下索引类型：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;主键索引&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;数据列不允许重复，不允许为 NULL，一个表只能有一个主键。&lt;/li&gt;
&lt;li&gt;ALTER TABLE table_name ADD PRIMARY KEY (column);&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;普通索引&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;MySQL 中基本索引类型，没有什么限制，允许在定义索引的列中插入重复值和 NULL 值。一个表允许多个列创建普通索引。&lt;/li&gt;
&lt;li&gt;ALTER TABLE table_name ADD INDEX index_name (column);&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;唯一索引&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;索引列中的值必须是唯一的，但是允许 NULL 值。建立唯一索引的目的大部分时候都是为了该属性列的数据的唯一性，而不是为了查询效率。一个表允许多个列创建唯一索引。&lt;/li&gt;
&lt;li&gt;ALTER TABLE table_name ADD UNIQUE (column);&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;全文索引&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;主要是为了快速检索大文本数据中的关键字的信息。字段长度比较大时，如果创建普通索引，在进行 like 模糊查询时效率比较低，这时可以创建全文索引，基于倒排索引，类似于搜索引擎。MyISAM 存储引擎支持全文索引，InnoDB 存储引擎在 MySQL 5.6.4 版本中也开始支持全文索引。&lt;/li&gt;
&lt;li&gt;ALTER TABLE table_name ADD FULLTEXT (column);&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;前缀索引&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;在文本类型如 BLOB、TEXT 或者很长的 VARCHAR 列上创建索引时，可以使用前缀索引，数据量相比普通索引更小，可以指定索引列的长度，但是数值类型不能指定。&lt;/li&gt;
&lt;li&gt;ALTER TABLE table_name ADD KEY(column_name(prefix_length));&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;组合索引&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;指多个字段上创建的索引，只有在查询条件中使用了创建索引时的第一个字段，索引才会被使用。使用组合索引时遵循最左前缀原则。&lt;/li&gt;
&lt;li&gt;主键索引、普通索引、唯一索引等都可以使用多个字段形成组合索引。例如，ALTER TABLE table_name ADD INDEX index_name (column1, column2, column3);&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;空间索引&lt;/strong&gt;
&lt;ul&gt;
&lt;li&gt;MySQL 在 5.7 之后的版本支持了空间索引，而且支持 OpenGIS 几何数据模型。MySQL 在空间索引这方面遵循 OpenGIS 几何数据模型规则。&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;mysql索引有哪些实现方式&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#mysql索引有哪些实现方式&#34;&gt;#&lt;/a&gt; MySQL 索引有哪些实现方式&lt;/h3&gt;
&lt;p&gt;什么是 B+Tree 索引，B+Tree 索引的构建过程，跟二叉树、红黑树的对比&lt;/p&gt;
&lt;p&gt;为什么数据库存储用 B+tree 索引，局部性原理是什么，为什么推荐自增 id&lt;/p&gt;
&lt;p&gt;MySQL 有哪些索引，聚集索引，二级索引，覆盖索引区别，回表是什么&lt;/p&gt;
&lt;p&gt;怎么加索引，索引的使用场景有哪些，加索引一定好吗&lt;/p&gt;
&lt;p&gt;索引失效的场景，引发什么后果&lt;/p&gt;
&lt;p&gt;EXPLAIN 关键字查看 MySQL 是否使用索引&lt;/p&gt;
&lt;h2 id=&#34;23-b树和b树的区别为什么mysql使用b树&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#23-b树和b树的区别为什么mysql使用b树&#34;&gt;#&lt;/a&gt; 23. B 树和 B + 树的区别，为什么 Mysql 使用 B + 树&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;B 树的特点&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;节点排序&lt;/li&gt;
&lt;li&gt;一个节点可以存多个元素，多个元素也排序了&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;B + 树的特点&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;拥有 B 例的特点&lt;/li&gt;
&lt;li&gt;子节点之间有指钊&lt;/li&gt;
&lt;li&gt;非叶子节点上的元素仙叶子节点上都冗余了，也就是叶子节点中存储了所有的元素，并且排好顺序&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Mysq 索引使用的是 B+，因为索引是用来加快查询的，而 B + 树通过对数据排序所以是可以提高查询速度的&lt;/p&gt;
&lt;p&gt;然后通过一个节点中可以有储多个元素，从而可以使得 B + 树的高度不会太高，在 Mysql 中一个 Innodb 页就是一个 B + 树节点，一 Innodb 页默认 16kb，所以一般情况下一颗两层的 B + 可以存 2000 万行左右的数&lt;/p&gt;
&lt;p&gt;然后通过利用 B + 树叶子节点存储了所有数据并且进行了排序，并且叶子节点之间有指针，以微了的支持全表描，范围查找等 SQL 语句&lt;/p&gt;
&lt;h2 id=&#34;38-mybatis的优缺点&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#38-mybatis的优缺点&#34;&gt;#&lt;/a&gt; 38. Mybatis 的优缺点&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;优点:&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;基于 SOL 语句编程，相当灵活，不会对应用程序或者数据库的现有设计造成任何影响，SQL 写在 XML 里，解除 sql 与程序代码的耦合，便于统一管理；提供 XML 标签，支持编写动态 SQL 语句，并可重用。&lt;/li&gt;
&lt;li&gt;与 JDBC 相比，减少了 50% 以上的代码量，消除了 JDBC 大量几余的代码，不需要手动开关连接；&lt;/li&gt;
&lt;li&gt;很好的与各种数据库兼容 (因为 MyBatis 使用 JDBC 来连接数据库，所以只要 JDBC 支持的数据库 MyBatis 都支持)&lt;/li&gt;
&lt;li&gt;能够与 Spring 很好的集成&lt;/li&gt;
&lt;li&gt;提供映射标签，支持对象与数据库的 ORM 字段关系映射，提供对象关系映射标签，支持对象关系组件维护&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;缺点:&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;SQL 语句的编写工作量较大，尤其当字段多、关联表多时，对开发人员编写 SQL 语句的功底有一定要求&lt;/li&gt;
&lt;li&gt;SQL 语句依赖于数据库，导致数据库移植性差，不能随意更换数据库。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;40-mysql慢查询该如何优化&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#40-mysql慢查询该如何优化&#34;&gt;#&lt;/a&gt; 40. Mysql 慢查询该如何优化？&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;检查是否走了索引，如果没有则优化 SQL 利用索引&lt;/li&gt;
&lt;li&gt;检查所利用的索引，是否是最优索引&lt;/li&gt;
&lt;li&gt;检查所查字段是否都是必须的，是否查询了过多字段，查出了多余数据检查表中数据是否过多，是否应该进行分库分表了&lt;/li&gt;
&lt;li&gt;检查数据库实例所在机器的性能配置，是否太低，是否可以适当增加资源&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;41-mysql锁有哪些如何理解&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#41-mysql锁有哪些如何理解&#34;&gt;#&lt;/a&gt; 41. Mysql 锁有哪些，如何理解&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;按锁粒度分类
&lt;ul&gt;
&lt;li&gt;行锁：锁某行数据，锁粒度最小，并发度高&lt;/li&gt;
&lt;li&gt;表锁：锁整张表，锁粒度最大，并发度低&lt;/li&gt;
&lt;li&gt;间隙锁：锁的是一个区间&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;读写分类
&lt;ul&gt;
&lt;li&gt;共享锁：也就是读锁。一个事务给某行数据加了读锁，其他事务也可以读，但是不能写&lt;/li&gt;
&lt;li&gt;排它锁：也就是写锁，一个事务给某行数据加了写锁，其他事务不能读，也不能写&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;还可以分为
&lt;ul&gt;
&lt;li&gt;乐观锁：并不会真正的去锁某行记录，而是通过一个版本号来实现的&lt;/li&gt;
&lt;li&gt;悲观锁：上面所的行锁、表锁等都是悲观锁&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;在事务的隔离级别实现中，就需要利用锁来解决幻读&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;42-redis和mysql如何保证数据一致&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#42-redis和mysql如何保证数据一致&#34;&gt;#&lt;/a&gt; 42. Redis 和 Mysql 如何保证数据一致&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;先更新 Mysql，再更新 Redis&lt;/strong&gt;，如果更新 Redis 失败，可能仍然不一致&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;先删除 Redis 存数据，再更新 Mysql&lt;/strong&gt;，再次查询的时候在将数据添加到存中，这种方案能解决 1 方案的问题，但是在高并发下性能较低，而且仍然会出现数据不一致的问题，比如线程 1 删除了 Redis 缓存数据，正在更新 Mysql，此时另外一个查询再查询，那么就会把 Mysql 中老数据又查到 Redis 中&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;延时双删&lt;/strong&gt;，步骤是：先删除 Redis 存数据，再更新 Mysql，延几百毫秒再删除 Redis 存数据，这样就算在更新 Mysql 时，有其他线程读了 Mysql，把老教据读到了 Redis 中，那么也会被删除掉，从而把数据保持一致&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;43-redis有哪些数据结构-分别有哪些典型的应用场景&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#43-redis有哪些数据结构-分别有哪些典型的应用场景&#34;&gt;#&lt;/a&gt; 43. Redis 有哪些数据结构？分别有哪些典型的应用场景？&lt;/h2&gt;
&lt;p&gt;Redis 的数据结构有:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;字符串 string&lt;/strong&gt;: 可以用来做最简单的数，可以存某个简单的字符串，也可以存某个 json 格式的字符审，Redis 分布式锁的实现就利用了这种数结构，还包括可以实现计数器、Session 共享、分布式 ID&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;哈希表 hash&lt;/strong&gt;: 可以用来存储一些 key-value 对，更适合用来存储对象&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;列表 list&lt;/strong&gt;: Redis 的列表通过命令的组合，既可以当做栈，也可以当做队列来使用，可以用来缓存类似微信公众号、微博等消息流数据&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;集合 set&lt;/strong&gt;: 和列表类似，也可以存储多个元素，但是不能重复，集合可以进行交集、并集、差集操作，从而可以实现类似，我和某人共同关注的人、朋友圈点赞等功能&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;有序集合 zset&lt;/strong&gt;: 集合是无序的，有序集合可以设置顺序，可以用来实现排行榜功能&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;mvcc机制rc级别解决脏读问题rr级别怎么解决不可重复读问题&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#mvcc机制rc级别解决脏读问题rr级别怎么解决不可重复读问题&#34;&gt;#&lt;/a&gt; MVCC 机制，RC 级别解决脏读问题，RR 级别怎么解决不可重复读问题&lt;/h2&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RyYWNreGlhb3hpbjMyMS9hcnRpY2xlL2RldGFpbHMvMTIyMTU3MTcx&#34;&gt;一图看懂 MVCC 机制，RC 级别解决脏读问题，RR 级别怎么解决不可重复读问题【MySQL 系列】_mvcc 实现 rr 和读提交 - CSDN 博客&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;脏读是怎么产生的&lt;/strong&gt;，即事务 A 更改了某条数据，事务 B 读取，随后事务因为某些原因回滚了，此时事务 B 读的数据就是 “脏数据”，称为脏读。产生脏读的原因也很简单，事务 B 读取了事务 A 未提交的数据。因此读已提交（只能读取事务提交后的数据）能解决脏读问题。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;不可重复读问题&lt;/strong&gt;，是事务 A 读取了某条数据，随后事务 B 更改了这条数据，事务 A 再次读取，发现数据不一致了（即使读已提交，也不能解决不可重复读问题，因为事务 B 如果已经提交了事务，此时读已提交隔离级别下是可以读到的，这里也涉及到了 MVCC 机制，后面会详细讲），因此读已提交解决不了不可重复读问题。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;MVCC&lt;/strong&gt;（Mutil-Version Concurrency Control）多版本并发控制机制，实现了 MySQL 在 InnoDB 引擎下 RC 级别和 RR 级别下对数据库的并发访问，每次 select 操作会访问数据库中的版本链记录，其他事务可以修改这条记录，而 select 根据当前隔离级别去版本链中找到对应的版本记录，实现了读 - 写，写 - 读的并发执行，提升了系统的性能。&lt;/p&gt;
&lt;p&gt;先解析三个概念，&lt;strong&gt;当前读、快照读和 ReadView&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;当前读&lt;/strong&gt;：读的都是最新版本的数据，会对数据进行加锁操作，防止其他事务修改当前数据。是悲观锁的一种实现方式。insert、update、select …for update、select…lock in share mode 都是当前读；&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;快照读&lt;/strong&gt;：最普通的不加锁的 select 读到的数据，读到的不一定是最新数据，有可能是之前历史版本的数据；&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;ReadView&lt;/strong&gt;：快照读的一种形式，MySQL 执行 MVCC 提取数据的依据；本质是一个数据结构，其中包括几下几个部分：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;m_ids：当前活跃的事务 ID 集合（开启但未提交的事务 ID）；&lt;/li&gt;
&lt;li&gt;min_trx_ids: 最小活跃事务 ID，小于它说明事务已经提交；&lt;/li&gt;
&lt;li&gt;max_trx_ids: 预分配的事务 ID（下一个事务开启分配的事务 ID），即当前最大事务 ID+1；大于它说明该事物是 ReadView 生成之后才开启；&lt;/li&gt;
&lt;li&gt;creator_trx_id:ReadView 创建者的事务编号；&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;版本链&lt;/strong&gt;：MySQL 数据库中，每条数据除肉眼可见的数据之外，还有几个隐藏字段：&lt;br /&gt;
1.db_trx_id: 记录最近修改这条记录的事务 ID；&lt;br /&gt;
2.db_roll_pointer: 回滚指针，指向指向这条数据的上一个版本记录；&lt;br /&gt;
3.db_row_id: 隐藏的自增 ID（隐藏的自增主键），如果表没有主键，InnoDB 会自动以 db_row_id 生成主键索引；&lt;/p&gt;
&lt;p&gt;实际上，RC 和 RR 两个隔离级别，实现的主要区别在于 ReadView 的时机不一样，RC 隔离级别下，每次快照读都会生成一个 ReadView；而 RR 级别下，只有在第一次快照读时生成 ReadView，后面会延续使用；事务根据生成的 ReadView 去版本链中寻找自己能够访问的数据，最后得到所读的数据；而这个寻找可读数据的规则就至关重要了。&lt;/p&gt;
&lt;h2 id=&#34;redis-16-个常见使用场景&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#redis-16-个常见使用场景&#34;&gt;#&lt;/a&gt; Redis 16 个常见使用场景&lt;/h2&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Fnb25pZTIwMTIxOC9hcnRpY2xlL2RldGFpbHMvMTIzNjQwODcx&#34;&gt;Redis 16 个常见使用场景_redis 用途 - CSDN 博客&lt;/span&gt;&lt;/p&gt;
&lt;h2 id=&#34;分布式锁redisson的使用看门狗机制&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#分布式锁redisson的使用看门狗机制&#34;&gt;#&lt;/a&gt; 分布式锁 Redisson 的使用，看门狗机制&lt;/h2&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzY5MTk0Mi9hcnRpY2xlL2RldGFpbHMvMTA3NTkxMTM3&#34;&gt;分布式锁 Redisson 的使用，看门狗机制_分布式锁使用了啥，看门狗机制，锁的默认超时时间是多少 - CSDN 博客&lt;/span&gt;&lt;/p&gt;
&lt;h2 id=&#34;如何使用redis做一个定时任务&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#如何使用redis做一个定时任务&#34;&gt;#&lt;/a&gt; 如何使用 redis 做一个定时任务？&lt;/h2&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1c2h1YW5naGFvMTIzL2FydGljbGUvZGV0YWlscy8xMTM4NTc4NjI=&#34;&gt;如何使用 redis 做一个定时任务？_redis 定时任务 - CSDN 博客&lt;/span&gt;&lt;/p&gt;
&lt;h1 id=&#34;spring&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#spring&#34;&gt;#&lt;/a&gt; Spring&lt;/h1&gt;
&lt;h2 id=&#34;21-applicationcontext和beanfactory有什么区别&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#21-applicationcontext和beanfactory有什么区别&#34;&gt;#&lt;/a&gt; 21. ApplicationContext 和 BeanFactory 有什么区别&lt;/h2&gt;
&lt;p&gt;BeanFactory 是 Spring 中非常核心的组件，表示 Bean 工厂，可以生成 bean，维护 bean，&lt;/p&gt;
&lt;p&gt;而 ApplicationContxt 继承了 Beanfactory，所以具有 BeanFactory 的特点。&lt;/p&gt;
&lt;p&gt;ApplicationContext 除了继承 BeanFactory 之外，还继承了诸如 EnvironmentCapable、MessageSource、ApplicationEventPublisher 等接口，从而 ApplicationContext 还有获取系统环境变量、国际化、事件发布等功能，这是 BeanFactory 不具备的。&lt;/p&gt;
&lt;h2 id=&#34;48-spring-boot是如何启动tomcat的&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#48-spring-boot是如何启动tomcat的&#34;&gt;#&lt;/a&gt; 48. Spring Boot 是如何启动 Tomcat 的&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;首先，SpringBoot 在启动时会先创建一个 Spring 容器&lt;/li&gt;
&lt;li&gt;在创建 Spring 容器时程中，会 @ConditionalOnClass 技术来判新当前 classpath 中是否存在 Tomcat 依赖，如果存在会生成一个启动 Tomcat 的 Bean&lt;/li&gt;
&lt;li&gt;Spring 容器创建完之后，就会获取启动 Tomcat 的 Bean，并创建 Tomcat 对象，并绑定端口等，然后启动 Tomcat&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;49-spring-boot中常用注解及其底层实现&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#49-spring-boot中常用注解及其底层实现&#34;&gt;#&lt;/a&gt; 49. Spring Boot 中常用注解及其底层实现&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;@SpringBootApplication&lt;/strong&gt; 注解：这个注解标识了一个 SpringBoot 工程，它实际上是另外三个注解的组合，这三个注解是:
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;@SpringBootConfiquration&lt;/strong&gt;: 这个注解实际就是一个 @Configuration，表示启动类也是一个配置类&lt;/li&gt;
&lt;li&gt;@&lt;strong&gt;EnableAutoConfiquration&lt;/strong&gt;: 向 Spring 容器中导入了一个 Selector，用来加载 ClassPath 下 SpringFatories 中所定义的自动配置类，将这些自动动载为配置 Bean&lt;/li&gt;
&lt;li&gt;@&lt;strong&gt;ComponentScan&lt;/strong&gt;: 标识扫描路径，因为默认是没有配置实际扫描路径，所以 SpringBoot 扫描的路径是启动类所在的当前目录&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;@&lt;strong&gt;Bean&lt;/strong&gt; 注解：用来定义 Bean，类似于 XML 中的 bean &amp;gt; 标签，Spring 在启动时，会对加了 @Bean 注解的方法进行解折，将方法的名字做为 beanName，并通过执行方法得到 bean 对象&lt;/li&gt;
&lt;li&gt;@&lt;strong&gt;Controller&lt;/strong&gt;、@&lt;strong&gt;Service&lt;/strong&gt;、 @&lt;strong&gt;ResponseBody&lt;/strong&gt;、@&lt;strong&gt;Autowired&lt;/strong&gt; 等&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;52-spring-优点&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#52-spring-优点&#34;&gt;#&lt;/a&gt; 52. Spring 优点&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;轻量级&lt;/strong&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;控制反转（IOC）&lt;/strong&gt;、依赖注入&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;切片编程（AOP）&lt;/strong&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;容器&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;MVC 框架&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;事务管理&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;异常处理&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;可拓展性&lt;/strong&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;spring-ioc的理解&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#spring-ioc的理解&#34;&gt;#&lt;/a&gt; &lt;strong&gt;Spring IOC 的理解&lt;/strong&gt;&lt;/h2&gt;
&lt;p&gt;控制反转&lt;/p&gt;
&lt;p&gt;整个 IOC 容器创建的流程和步骤如下：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;向 bean 工厂中设置一些参数&lt;/li&gt;
&lt;li&gt;加载解析 bean 对象&lt;/li&gt;
&lt;li&gt;BeanPostProcessor 的注册功能&lt;/li&gt;
&lt;li&gt;通过反射的方式讲 BeanDefinition 对象实例化成具体的 bean 对象&lt;/li&gt;
&lt;li&gt;bean 对象的初始化过程&lt;/li&gt;
&lt;li&gt;生成完整的 bean 对象&lt;/li&gt;
&lt;li&gt;通过 getBean 方法可以直接获取&lt;/li&gt;
&lt;li&gt;销毁过程&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;spring-aop的理解&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#spring-aop的理解&#34;&gt;#&lt;/a&gt; &lt;strong&gt;spring AOP 的理解&lt;/strong&gt;&lt;/h2&gt;
&lt;p&gt;面向切面编程（AOP）：允许程序员模块化横向业务逻辑，或定义核心部分的功能，例如&lt;strong&gt;日志管理和事务管理&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;在 Spring AOP 中，切面通过带有 **@Aspect** 注解的类实现&lt;/p&gt;
&lt;p&gt;通知 (Advice)：通知表示在方法执行前后需要执行的动作。实际上它是 Spring AOP 框架在程序执行过程中触发的一些代码。有前置通知、后置通知、环绕通知等&lt;/p&gt;
&lt;p&gt;动态代理：代理是将通知应用到目标对象后创建的对象。从客户端的角度看，代理对象和目标对象是一样的。&lt;/p&gt;
&lt;h2 id=&#34;事务&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#事务&#34;&gt;#&lt;/a&gt; 事务&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;事务是逻辑上的一组操作，要么都执行，要么都不执行。&lt;/strong&gt;&lt;/p&gt;
&lt;h3 id=&#34;事务的特性acid&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#事务的特性acid&#34;&gt;#&lt;/a&gt; &lt;strong&gt;事务的特性（ACID）&lt;/strong&gt;&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;原子性&lt;/strong&gt;（ &lt;code&gt;Atomicity&lt;/code&gt; ）：事务是最小的执行单位，不允许分割。事务的原子性确保动作要么全部完成，要么完全不起作用；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;一致性&lt;/strong&gt;（ &lt;code&gt;Consistency&lt;/code&gt; ）：执行事务前后，数据保持一致，例如转账业务中，无论事务是否成功，转账者和收款人的总额应该是不变的；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;隔离性&lt;/strong&gt;（ &lt;code&gt;Isolation&lt;/code&gt; ）：并发访问数据库时，一个用户的事务不被其他事务所干扰，各并发事务之间数据库是独立的；&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;持久性&lt;/strong&gt;（ &lt;code&gt;Durability&lt;/code&gt; ）：一个事务被提交之后。它对数据库中数据的改变是持久的，即使数据库发生故障也不应该对其有任何影响。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;🌈 这里要额外补充一点：&lt;strong&gt;只有保证了事务的持久性、原子性、隔离性之后，一致性才能得到保障。也就是说 A、I、D 是手段，C 是目的&lt;/strong&gt;&lt;/p&gt;
&lt;h3 id=&#34;事务管理&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#事务管理&#34;&gt;#&lt;/a&gt; &lt;strong&gt;事务管理&lt;/strong&gt;&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;编程式事务管理&lt;/strong&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;通过  &lt;code&gt;TransactionTemplate&lt;/code&gt;  或者 &lt;code&gt;TransactionManager&lt;/code&gt;  手动管理事务，实际应用中很少使用&lt;/p&gt;
&lt;ol start=&#34;2&#34;&gt;
&lt;li&gt;&lt;strong&gt;声明式事务管理&lt;/strong&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;推荐使用（代码侵入性最小），实际是通过 AOP 实现（基于 &lt;code&gt;@Transactional&lt;/code&gt;  的全注解方式使用最多）。&lt;/p&gt;
&lt;p&gt;使用  &lt;code&gt;@Transactional&lt;/code&gt;  注解进行事务管理的示例代码如下：&lt;/p&gt;
&lt;figure class=&#34;highlight java&#34;&gt;&lt;figcaption data-lang=&#34;java&#34;&gt;&lt;/figcaption&gt;&lt;table&gt;&lt;tr&gt;&lt;td data-num=&#34;1&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token annotation punctuation&#34;&gt;@Transactional&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;propagation &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Propagation&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;token constant&#34;&gt;REQUIRED&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;2&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;public&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;void&lt;/span&gt; aMethod &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;3&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;  &lt;span class=&#34;token comment&#34;&gt;//do something&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;4&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;  &lt;span class=&#34;token class-name&#34;&gt;B&lt;/span&gt; b &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;new&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;B&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;5&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;  &lt;span class=&#34;token class-name&#34;&gt;C&lt;/span&gt; c &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;new&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;C&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;6&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;  b&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;token function&#34;&gt;bMethod&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;7&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;  c&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;token function&#34;&gt;cMethod&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;8&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;h2 id=&#34;54-spring-事务什么时候会失效&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#54-spring-事务什么时候会失效&#34;&gt;#&lt;/a&gt; 54. Spring 事务什么时候会失效？&lt;/h2&gt;
&lt;p&gt;spring 事务的原理是 AOP，进行了切面增强，那么失效的根本原因是这个 AOP 不起作用了！常见情况有如下几种&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;发生自调用，类里面使用 this 调用本类的方法 (this 通常省略)，此时这个 this 对象不是代理类，而是 UserService 对象本身！&lt;/li&gt;
&lt;li&gt;解决方法很简单，让那个 this 变成 UserService 的代理类即可！&lt;/li&gt;
&lt;li&gt;方法不是 public 的: @Transactional 只能用于 public 的方法上，否则事务不会失效，如果要用在非 public 法上，可以开启 AspectJ 代理模式&lt;/li&gt;
&lt;li&gt;数据库不支持事务&lt;/li&gt;
&lt;li&gt;没有被 spring 管理&lt;/li&gt;
&lt;li&gt;异常被吃掉，事务不会回滚 (或者抛出的异常没有被定义，默认为 RuntimeException)&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;55-spring中bean是线程安全的吗&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#55-spring中bean是线程安全的吗&#34;&gt;#&lt;/a&gt; 55. Spring 中 Bean 是线程安全的吗&lt;/h2&gt;
&lt;p&gt;Spring 本身并没有针对 Bean 做线程安全的处理，所以:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;如果 Bean 是无状态的，那么 Bean 则是线程安全的&lt;/li&gt;
&lt;li&gt;如果 Bean 是有状态的，那么 Bean 则不是线程安全的&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;另外，Bean 是不是线程安全，跟 Bean 的作用域没有关系，Bean 的作用域只是表示 Bean 的生命周期范围，对于任何生命固期的 Bean 都是一个对象，这个对象是不是线程安全的，还是得看这个 Bean 对象本身。&lt;/p&gt;
&lt;p&gt;tips：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;有状态对象 (Stateful Bean)&lt;/strong&gt; ：就是 ** 有实例变量的对象，可以保存数据，是非线程安全的。** 每个用户有自己特有的一个实例，在用户的生存期内，bean 保持了用户的信息，即 “有状态”；一旦用户灭亡（调用结束或实例结束），bean 的生命期也告结束。即每个用户最初都会得到一个初始的 bean。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;无状态对象 (Stateless Bean)&lt;/strong&gt;：就是 ** 没有实例变量的对象，不能保存数据，是不变类，是线程安全的。**bean 一旦实例化就被加进会话池中，各个用户都可以共用。即使用户已经消亡，bean 的生命期也不一定结束，它可能依然存在于会话池中，供其他用户调用。由于没有特定的用户，那么也就不能保持某一用户的状态，所以叫无状态 bean。但无状态会话 bean 并非没有状态，如果它有自己的属性（变量），那么这些变量就会受到所有调用它的用户的影响，这是在实际应用中必须注意的。&lt;/p&gt;
&lt;h2 id=&#34;spring-configuration注解&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#spring-configuration注解&#34;&gt;#&lt;/a&gt; Spring @Configuration 注解&lt;/h2&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlb3h5ay9hcnRpY2xlL2RldGFpbHMvNzk4MDAwMjA=&#34;&gt;Spring @Configuration 注解_springconfiguration 注解 - CSDN 博客&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;从 &lt;code&gt;Spring3.0&lt;/code&gt; ， &lt;code&gt;@Configuration&lt;/code&gt;  用于定义配置类，可替换 &lt;code&gt;xml&lt;/code&gt;  配置文件，被注解的类内部包含有一个或多个被 &lt;code&gt;@Bean&lt;/code&gt;  注解的方法，这些方法将会被 &lt;code&gt;AnnotationConfigApplicationContext&lt;/code&gt;  或 &lt;code&gt;AnnotationConfigWebApplicationContext&lt;/code&gt;  类进行扫描，并用于构建 &lt;code&gt;bean&lt;/code&gt;  定义，初始化 &lt;code&gt;Spring&lt;/code&gt;  容器。&lt;/p&gt;
&lt;p&gt;注意： &lt;code&gt;@Configuration&lt;/code&gt;  注解的配置类有如下要求：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;@Configuration 不可以是 &lt;code&gt;final&lt;/code&gt;  类型；&lt;/li&gt;
&lt;li&gt;@Configuration 不可以是匿名类；&lt;/li&gt;
&lt;li&gt;嵌套的 configuration 必须是静态类。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;spring中bean及bean的理解与new对象的区别&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#spring中bean及bean的理解与new对象的区别&#34;&gt;#&lt;/a&gt; Spring 中 Bean 及 @Bean 的理解与 new 对象的区别&lt;/h2&gt;
&lt;p&gt;spring 有一个 Ioc 容器：Spring 容器是 Spring 框架的核心。容器将创建对象，把它们连接在一起，配置它们，并管理他们的整个生命周期从创建到销毁。Spring 容器使用依赖注入（DI）来管理组成一个应用程序的组件。这些对象被称为 Spring Beans。 一些对象创建和使用完毕之后不会被销毁，放进对象池（某种集合）以备下次使用，下次再需要这个对象，不 new，直接从池里取，节省时间，也就是说我们可以随时使用和销毁。&lt;/p&gt;
&lt;p&gt;同理 Spring 的 @Bean 注解用于告诉方法，产生一个 Bean 对象，然后这个 Bean 对象交给 Spring 管理。产生这个 Bean 对象的方法 Spring 只会调用一次，随后这个 Spring 将会将这个 Bean 对象放在自己的 IOC 容器中。&lt;/p&gt;
&lt;p&gt;而使用 new 关键字创建的对象属于强引用对象，所谓强引用，就是 jvm 垃圾回收机制永远不会回收这类对象，这时候需要手动移除引用。如果没有移除，这个对象将一直存在，久而久之，会引起内存泄露问题。&lt;/p&gt;
&lt;p&gt;垃圾回收 (Garbage Collection) 是 Java 虚拟机 (JVM) 垃圾回收器提供的一种用于在空闲时间不定时回收无任何对象引用的对象占据的内存空间的一种机制。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;   强引用（Strong Reference）：如“Object obj = new Object（）”，这类引用是Java程序中最普遍的。只要强引用还存在，垃圾收集器就永远不会回收掉被引用的对象。

  new对象是因为类的构造方法一旦被修改，new的对象就出错了，如果是用了spring，就不用理会构造方法是否被修改，而拿来用就可以。
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;总的来说：Bean 和 new 但是创建对象，但是 Bean 所创建的对象会集中放在一个容器中方便管理&lt;/p&gt;
&lt;h2 id=&#34;autowired-与resource的区别详细&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#autowired-与resource的区别详细&#34;&gt;#&lt;/a&gt; @Autowired 与 @Resource 的区别（详细）&lt;/h2&gt;
&lt;p&gt;@Resource 的作用相当于 @Autowired，只不过 **@Autowired 按 byType 自动注入 **，而 **@Resource 默认按 byName 自动注入 ** 罢了。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;@Resource 有两个属性是比较重要的，分是 name 和 type&lt;/strong&gt;，Spring 将 @Resource 注解的 name 属性解析为 bean 的名字，而 type 属性则解析为 bean 的类型。所以如果使用 name 属性，则使用 byName 的自动注入策略，而使用 type 属性时则使用 byType 自动注入策略。如果既不指定 name 也不指定 type 属性，这时将通过反射机制使用 byName 自动注入策略。&lt;/p&gt;
</content>
        <category term="Java" />
        <updated>2024-07-14T01:56:54.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2024/06/23/%E7%AC%AC%E4%BA%8C%E6%AC%A1%E9%9D%A2%E8%AF%95%E5%87%86%E5%A4%87/</id>
        <title>第二次面试准备</title>
        <link rel="alternate" href="http://example.com/2024/06/23/%E7%AC%AC%E4%BA%8C%E6%AC%A1%E9%9D%A2%E8%AF%95%E5%87%86%E5%A4%87/"/>
        <content type="html">&lt;h1 id=&#34;第二次面试准备&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#第二次面试准备&#34;&gt;#&lt;/a&gt; 第二次面试准备&lt;/h1&gt;
&lt;p&gt;我的简历，又又又优化了一下&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240623164731985.png&#34; alt=&#34;image-20240623164731985&#34; /&gt;&lt;/p&gt;
&lt;h2 id=&#34;了解一下公司&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#了解一下公司&#34;&gt;#&lt;/a&gt; 了解一下公司&lt;/h2&gt;
&lt;h3 id=&#34;公司介绍&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#公司介绍&#34;&gt;#&lt;/a&gt; 公司介绍&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;云行计划技术布道者&lt;/li&gt;
&lt;li&gt;成立于 2009 年，坐落于杭州湾畔，我们自认为是中国比较优秀的互联网服务提供商。自成立以来，专注于&lt;strong&gt;云计算技术、移动互联应用、B/S 架构系统研发&lt;/strong&gt;，为企业客户的互联网应用提供一站式服务。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;（来自 boss）&lt;/p&gt;
&lt;h3 id=&#34;官网&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#官网&#34;&gt;#&lt;/a&gt; 官网&lt;/h3&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240623165735071.png&#34; alt=&#34;image-20240623165735071&#34; /&gt;&lt;/p&gt;
&lt;p&gt;这个地方加载的很慢，如何优化&lt;/p&gt;
&lt;p&gt;&amp;lt;img src=&amp;quot;image-20240623165917959.png&amp;quot; alt=&amp;quot;image-20240623165917959&amp;quot;/&amp;gt;&lt;/p&gt;
&lt;h2 id=&#34;岗位要求&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#岗位要求&#34;&gt;#&lt;/a&gt; 岗位要求&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;扎实的 Java&lt;/li&gt;
&lt;li&gt;熟练使用 Linux&lt;/li&gt;
&lt;li&gt;熟练 Mysql、PostgreSQL&lt;/li&gt;
&lt;li&gt;Spring、Dubbo&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;自我介绍&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#自我介绍&#34;&gt;#&lt;/a&gt; 自我介绍&lt;/h2&gt;
&lt;h2 id=&#34;项目&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#项目&#34;&gt;#&lt;/a&gt; &lt;strong&gt;项目&lt;/strong&gt;&lt;/h2&gt;
&lt;h2 id=&#34;基础知识&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#基础知识&#34;&gt;#&lt;/a&gt; 基础知识&lt;/h2&gt;
&lt;h3 id=&#34;redis&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#redis&#34;&gt;#&lt;/a&gt; Redis&lt;/h3&gt;
&lt;p&gt;见 面试准备一 以及 Redis 学习记录&lt;/p&gt;
&lt;h3 id=&#34;linux&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#linux&#34;&gt;#&lt;/a&gt; Linux&lt;/h3&gt;
&lt;p&gt;……&lt;/p&gt;
&lt;h3 id=&#34;java&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#java&#34;&gt;#&lt;/a&gt; Java&lt;/h3&gt;
&lt;p&gt;……&lt;/p&gt;
&lt;h3 id=&#34;spring-postgresql&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#spring-postgresql&#34;&gt;#&lt;/a&gt; Spring、&lt;s&gt;PostgreSQL&lt;/s&gt;&lt;/h3&gt;
&lt;h4 id=&#34;什么是spring框架spring框架有哪些主要模块&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#什么是spring框架spring框架有哪些主要模块&#34;&gt;#&lt;/a&gt; 什么是 Spring 框架？Spring 框架有哪些主要模块？&lt;/h4&gt;
&lt;p&gt;Spring 是一个&lt;strong&gt;轻量级的 JavaEE 框架&lt;/strong&gt;，它主要解决企业应用中的复杂性问题。&lt;/p&gt;
&lt;p&gt;Spring 框架有三个核心部分: &lt;strong&gt;lOC 容器、AOP 和数据访问 / 集成层。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;lOC 容器提供了一种对象创建和对象之间关系管理的机制，以实现松散耦合和可扩展性，&lt;/p&gt;
&lt;p&gt;AOP 提供了一种很好的方式来实现横向关注点的处理，如事务管理，安全检查，缓存等。&lt;/p&gt;
&lt;p&gt;数据访问 / 集成层则提供了许多针对不同数据持久化技术的实现，比如 JDBC，ORM 和 NoSQL。&lt;/p&gt;
&lt;p&gt;Spring 框架本身亦是按照设计模式精心打造，这使得我们可以在开发环境中安心的集成 Spring 框架，不必担心 Spring 是如何在后台进行工作的。spring 框架至今已集成了 20 多个模块。这些模块主要被分如下图所示的核心容器、数据访问 / 集成、Web、AOP (面向切面编程)、工具、消息和测试模块&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;生态、基石&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240623192514857.png&#34; alt=&#34;image-20240623192514857&#34; /&gt;&lt;/p&gt;
&lt;h4 id=&#34;spring优点&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#spring优点&#34;&gt;#&lt;/a&gt; Spring 优点&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;轻量级&lt;/strong&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;控制反转（IOC）&lt;/strong&gt;、依赖注入&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;切片编程（AOP）&lt;/strong&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;容器&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;MVC 框架&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;事务管理&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;异常处理&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;可拓展性&lt;/strong&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h4 id=&#34;谈一下你对于springioc的理解&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#谈一下你对于springioc的理解&#34;&gt;#&lt;/a&gt; 谈一下你对于 springIOC 的理解&lt;/h4&gt;
&lt;p&gt;控制反转&lt;/p&gt;
&lt;p&gt;整个 IOC 容器创建的流程和步骤如下：向 bean 工厂中设置一些参数、加载解析 bean 对象、BeanPostProcessor 的注册功能、通过反射的方式讲 BeanDefinition 对象实例化成具体的 bean 对象、bean 对象的初始化过程、生成完整的 bean 对象，通过 getBean 方法可以直接获取、销毁过程&lt;/p&gt;
&lt;h4 id=&#34;bean的生命周期&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#bean的生命周期&#34;&gt;#&lt;/a&gt; bean 的生命周期&lt;/h4&gt;
&lt;p&gt;……&lt;/p&gt;
&lt;h4 id=&#34;自动装配的各种模式&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#自动装配的各种模式&#34;&gt;#&lt;/a&gt; 自动装配的各种模式&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;byName&lt;/strong&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;byType、constructor&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;autodetect、no&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id=&#34;beanfactory和applicationcontext有什么区别&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#beanfactory和applicationcontext有什么区别&#34;&gt;#&lt;/a&gt; BeanFactory 和 ApplicationContext 有什么区别？&lt;/h4&gt;
&lt;p&gt;加载：BeanFactory 采用的是 ** 延迟加载（lazy-loading）** 的方式，即只有在使用到某个 Bean 时 才会对该 Bean 进行加载和实例化。而 ApplicationContext 则是在容器启动 时，&lt;strong&gt;一次性创建所有的 Bean&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;创建：BeanFactory 通常以&lt;strong&gt;编程的方式创建&lt;/strong&gt;，需要手动编写代码来配置和获取 Bean。而 ApplicationContext 除了支持编程方式创建外，还支持&lt;strong&gt;声明方式创建&lt;/strong&gt;，如使用 XML 配置文件或注解 来配置 Bean。&lt;/p&gt;
&lt;p&gt;功能：ApplicationContext 接口作为 BeanFactory 的&lt;strong&gt;派生&lt;/strong&gt;，不仅提供了 BeanFactory 所具有的功 能，还提供了更完整的框架功能。&lt;/p&gt;
&lt;h4 id=&#34;spring-aop的理解&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#spring-aop的理解&#34;&gt;#&lt;/a&gt; spring AOP 的理解&lt;/h4&gt;
&lt;p&gt;面向切面编程（AOP）：允许程序员模块化横向业务逻辑，或定义核心部分的功能，例如&lt;strong&gt;日志管理和事&lt;/strong&gt; 务管理。&lt;/p&gt;
&lt;p&gt;在 Spring AOP 中，切面通过带有 **@Aspect** 注解的类实现&lt;/p&gt;
&lt;p&gt;通知 (Advice)：通知表示在方法执行前后需要执行的动作。实际上它是 Spring AOP 框架在程序执行过程 中触发的一些代码。有前置通知、后置通知、环绕通知等&lt;/p&gt;
&lt;p&gt;动态代理：代理是将通知应用到目标对象后创建的对象。从客户端的角度看，代理对象和目标对象是一样 的。&lt;/p&gt;
&lt;h4 id=&#34;spring中用到了哪些设计模式&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#spring中用到了哪些设计模式&#34;&gt;#&lt;/a&gt; spring 中用到了哪些设计模式&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;单例模式：bean 默认都是单例的&lt;/li&gt;
&lt;li&gt;原型模式：指定作用域为 prototype&lt;/li&gt;
&lt;li&gt;工厂模式：BeanFactory&lt;/li&gt;
&lt;li&gt;模板方法：postProcessBeanFactory,onRefresh,initPropertyValue&lt;/li&gt;
&lt;li&gt;策略模式：XmlBeanDefinitionReader,PropertiesBeanDefinitionReader&lt;/li&gt;
&lt;li&gt;观察者模式：listener，event，multicast&lt;/li&gt;
&lt;li&gt;适配器模式：Adapter&lt;/li&gt;
&lt;li&gt;装饰者模式：BeanWrapper&lt;/li&gt;
&lt;li&gt;责任链模式：使用 aop 的时候会先生成一个拦截器链&lt;/li&gt;
&lt;li&gt;代理模式：动态代理&lt;/li&gt;
&lt;li&gt;委托者模式：delegate&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;mysql&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#mysql&#34;&gt;#&lt;/a&gt; MySQL&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;索引：b + 树、哈希、位图&lt;/li&gt;
&lt;li&gt;MySQL 优化：索引、查询优化（少子查询、模糊查询、全表查询）、表结构优化、缓存优化（Redis）、硬件优化&lt;/li&gt;
&lt;li&gt;慢查询：查询花费时间很多的日志&lt;/li&gt;
&lt;li&gt;死锁：避免大量查询、给事务加锁、增加悲观锁、设置合理超时时间&lt;/li&gt;
&lt;li&gt;优化大量数据插入：每一次插入的数量变多（合适数量），避免死锁，占用大量系统资源，磁盘空间&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;dubbo&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#dubbo&#34;&gt;#&lt;/a&gt; &lt;s&gt;Dubbo&lt;/s&gt;&lt;/h3&gt;
&lt;p&gt;&lt;s&gt;随着互联网的发展，&lt;strong&gt;网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行&lt;/strong&gt;，亟需一个治理系统确保架构有条不紊的演进。&lt;/s&gt;&lt;/p&gt;
&lt;p&gt;&lt;s&gt;Apache Dubbo 最初是为了解决&lt;strong&gt;阿里巴巴内部的微服务架构问题&lt;/strong&gt;而设计并开发的，最早在 2008 年，阿里巴巴就将 Dubbo 捐献到开源社区。在 2017 年，Dubbo 被正式捐献 Apache 软件基金会并成为 Apache 顶级项目，开始了一段新的征程。&lt;/s&gt;&lt;/p&gt;
&lt;h4 id=&#34;为什么需要-dubbo它能做什么&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#为什么需要-dubbo它能做什么&#34;&gt;#&lt;/a&gt; &lt;s&gt;为什么需要 Dubbo，它能做什么？&lt;/s&gt;&lt;/h4&gt;
&lt;p&gt;&lt;s&gt;按照微服务架构的定义，采用它的组织能够很好的提高业务迭代效率与系统稳定性，但前提是要先能保证微服务按照期望的方式运行，要做到这一点需要解决服务拆分与定义、数据通信、地址发现、流量管理、数据一致性、系统容错能力等一系列问题。&lt;/s&gt;&lt;/p&gt;
&lt;p&gt;&lt;s&gt;Dubbo 可以帮助解决如下微服务实践问题：&lt;/s&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;s&gt;&lt;strong&gt;微服务编程范式和工具&lt;/strong&gt;&lt;/s&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;s&gt;Dubbo 支持基于 IDL 或语言特定方式的服务定义，提供多种形式的服务调用形式（如同步、异步、流式等）&lt;/s&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;s&gt;&lt;strong&gt;高性能的 RPC 通信&lt;/strong&gt;&lt;/s&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;s&gt;Dubbo 帮助解决微服务组件之间的通信问题，提供了基于 HTTP、HTTP/2、TCP 等的多种高性能通信协议实现，并支持序列化协议扩展，在实现上解决网络连接管理、数据传输等基础问题。&lt;/s&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;s&gt;&lt;strong&gt;微服务监控与治理&lt;/strong&gt;&lt;/s&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;s&gt;Dubbo 官方提供的服务发现、动态配置、负载均衡、流量路由等基础组件可以很好的帮助解决微服务基础实践的问题。除此之外，您还可以用 Admin 控制台监控微服务状态，通过周边生态完成限流降级、数据一致性、链路追踪等能力。&lt;/s&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;s&gt;&lt;strong&gt;部署在多种环境&lt;/strong&gt;&lt;/s&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;s&gt;Dubbo 服务可以直接部署在容器、Kubernetes、Service Mesh 等多种架构下。&lt;/s&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;s&gt;&lt;strong&gt;活跃的社区&lt;/strong&gt;&lt;/s&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;s&gt;Dubbo 项目托管在 Apache 社区，有来自国际、国内的活跃贡献者维护着超 10 个生态项目，贡献者包括来自海外、阿里巴巴、工商银行、携程、蚂蚁、腾讯等知名企业技术专家，确保 Dubbo 及时解决项目缺陷、需求及安全漏洞，跟进业界最新技术发展趋势。&lt;/s&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;s&gt;&lt;strong&gt;庞大的用户群体&lt;/strong&gt;&lt;/s&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;s&gt;Dubbo3 已在阿里巴巴成功落地，实现了对老版本 HSF2 框架全面升级，成为阿里集团面向云原生时代的统一服务框架底座，庞大的用户群体是 Dubbo 保持稳定性、需求来源、先进性的基础。&lt;/s&gt;&lt;/p&gt;
&lt;h4 id=&#34;dubbo-不是什么&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#dubbo-不是什么&#34;&gt;#&lt;/a&gt; &lt;s&gt;Dubbo 不是什么？&lt;/s&gt;&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;s&gt;&lt;strong&gt;不是应用开发框架的替代者&lt;/strong&gt;&lt;/s&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;s&gt;Dubbo 设计为让开发者以主流的应用开发框架的开发模式工作，它不是各个语言应用开发框架的替代者，如它不是 Spring/Spring Boot 的竞争者，当你使用 Spring 时，Dubbo 可以无缝的与 Spring &amp;amp; Spring Boot 集成在一起。&lt;/s&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;s&gt;&lt;strong&gt;不仅仅只是一款 RPC 框架&lt;/strong&gt;&lt;/s&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;s&gt;Dubbo 提供了内置 RPC 通信协议实现，但它不仅仅是一款 RPC 框架。首先，它不绑定某一个具体的 RPC 协议，开发者可以在基于 Dubbo 开发的微服务体系中使用多种通信协议；其次，除了 RPC 通信之外，Dubbo 提供了丰富的服务治理能力与生态。&lt;/s&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;s&gt;&lt;strong&gt;不是 gRPC 协议的替代品&lt;/strong&gt;&lt;/s&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;s&gt;Dubbo 支持基于 gRPC 作为底层通信协议，在 Dubbo 模式下使用 gRPC 可以带来更好的开发体验，享有统一的编程模型和更低的服务治理接入成本&lt;/s&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;s&gt;&lt;strong&gt;不只有 Java 语言实现&lt;/strong&gt;&lt;/s&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;s&gt;自 Dubbo3 开始，Dubbo 提供了 Java、Golang、Rust、Node.js 等多语言实现，未来会有更多的语言实现。&lt;/s&gt;&lt;/p&gt;
&lt;h2 id=&#34;知识拓展&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#知识拓展&#34;&gt;#&lt;/a&gt; 知识拓展&lt;/h2&gt;
&lt;h2 id=&#34;引用&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#引用&#34;&gt;#&lt;/a&gt; 引用&lt;/h2&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9jbi5kdWJiby5hcGFjaGUub3JnL3poLWNuL292ZXJ2aWV3L3doYXQv&#34;&gt;Dubbo 介绍 | Apache Dubbo&lt;/span&gt;&lt;/p&gt;
</content>
        <category term="面试" />
        <updated>2024-06-23T08:42:22.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2024/06/05/%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90/</id>
        <title>数据分析</title>
        <link rel="alternate" href="http://example.com/2024/06/05/%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90/"/>
        <content type="html">&lt;h2 id=&#34;大三下的实践周做一个数据分析&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#大三下的实践周做一个数据分析&#34;&gt;#&lt;/a&gt; 大三下的实践周，做一个数据分析&lt;/h2&gt;
&lt;p&gt;……&lt;/p&gt;
&lt;h2 id=&#34;数据获取&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#数据获取&#34;&gt;#&lt;/a&gt; 数据获取&lt;/h2&gt;
&lt;p&gt;一开始爬的智联招聘的数据，但是由于他后来改成 js 动态加载了，github 上以前的代码都用不了，我自己写呢，用了俩种方法&lt;/p&gt;
&lt;h3 id=&#34;request解析&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#request解析&#34;&gt;#&lt;/a&gt; request 解析&lt;/h3&gt;
&lt;figure class=&#34;highlight python&#34;&gt;&lt;figcaption data-lang=&#34;python&#34;&gt;&lt;/figcaption&gt;&lt;table&gt;&lt;tr&gt;&lt;td data-num=&#34;1&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; os&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;2&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; re&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;3&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; time&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;4&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; requests&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;5&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;from&lt;/span&gt; bs4 &lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; BeautifulSoup&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;6&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;from&lt;/span&gt; fake_useragent &lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; UserAgent&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;7&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;from&lt;/span&gt; openpyxl &lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; Workbook&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; load_workbook&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;8&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;9&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; sqlite3&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;10&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;11&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;12&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;# DRIVER_PATH = &#39;G:\DLibrary\chromedriver-win64\chromedriver.exe&#39;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;13&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;14&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;# def init_db(dbpath):&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;15&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;#     sql = &#39;&#39;&#39;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;16&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;#             create table IF NOT EXISTS movie250&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;17&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;#             (&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;18&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;#             id integer primary key autoincrement,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;19&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;#             name text,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;20&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;#             year text&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;21&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;#             )&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;22&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;#         &#39;&#39;&#39;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;23&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;#&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;24&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;#     conn = sqlite3.connect(dbpath)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;25&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;#     cursor = conn.cursor()&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;26&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;#&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;27&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;#     cursor.execute(sql)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;28&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;#&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;29&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;#     conn.commit()&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;30&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;#     conn.close()&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;31&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;32&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;33&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;saveData2DB&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;datalist&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;34&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;with&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;open&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;./data.txt&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;a&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; encoding&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;utf-8&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;as&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;file&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;35&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;for&lt;/span&gt; data &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; datalist&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;36&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token builtin&#34;&gt;file&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;write&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;data &lt;span class=&#34;token operator&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;/n&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;37&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;38&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;39&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;getpostinfo&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;url&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; headers&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;40&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    url_split &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; url&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;split&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;?&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;41&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    url &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; url_split&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;42&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    url &lt;span class=&#34;token operator&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;?refcode=4019&amp;amp;srccode=401901&amp;amp;preactionid=948d2073-65a0-497b-8123-6f56ca3e1af8&#39;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;43&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    r &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; requests&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;get&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;url&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; headers&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;headers&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; timeout&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;10&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;44&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    r&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;raise_for_status&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;45&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    r&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;encoding &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;utf-8&#39;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;46&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;47&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    soup &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; BeautifulSoup&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;r&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;html.parser&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;48&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;49&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    postinfo &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;50&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# todo None，登陆验证？&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;51&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;soup&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;52&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;53&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    post &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; soup&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;find&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;attrs&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;class&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;summary-plane__title&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;split&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39; &#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;54&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    desc &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; soup&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;find&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;attrs&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;class&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;describtion__detail-content&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;split&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39; &#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;55&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;56&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    postinfo&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;append&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;post&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;57&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    postinfo&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;append&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;desc&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;58&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;59&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;postinfo&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;60&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;61&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    saveData2DB&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;postinfo&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;62&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;63&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;64&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;getonepagelist&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;url&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; headers&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;65&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    r &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; requests&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;get&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;url&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; headers&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;headers&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; timeout&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;10&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;66&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    r&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;raise_for_status&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;67&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    r&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;encoding &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;utf-8&#39;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;68&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;69&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    soup &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; BeautifulSoup&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;r&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;html.parser&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;70&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;71&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    lsts &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; soup&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;find_all&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;attrs&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;class&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;jobinfo__top&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;72&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;lsts&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;73&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;74&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;for&lt;/span&gt; lst &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; lsts&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;75&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        href &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; lst&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;a&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;href&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;76&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        time&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;sleep&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0.5&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;77&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        getpostinfo&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;href&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; headers&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;78&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;79&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;80&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;if&lt;/span&gt; __name__ &lt;span class=&#34;token operator&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;__main__&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;81&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# 本地获取&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;82&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    ua &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; UserAgent&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;83&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# ua.random 随机获取一个请求头&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;84&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# headers = &amp;#123;&#34;useragent&#34;: ua.random&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;85&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;86&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;with&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;open&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#34;./cookie&#34;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#34;r&#34;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; encoding&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#34;utf-8&#34;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;as&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;file&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;87&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        Cookie &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;file&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;read&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;88&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# print(cookie)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;89&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;90&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    headers &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;91&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# &#39;:authority&#39;: &#39;i.zhaopin.com&#39;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;92&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# &#39;:method&#39;: &#39;GET&#39;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;93&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# &#39;:path&#39;: &#39;/&#39;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;94&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# &#39;:scheme&#39;: &#39;https&#39;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;95&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token string&#34;&gt;&#39;Accept&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;96&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token string&#34;&gt;&#39;Accept-Encoding&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;gzip, deflate, br, zstd&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;97&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token string&#34;&gt;&#39;Accept-Language&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;zh-CN,zh;q=0.9,en;q=0.8&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;98&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;99&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# &#39;Connection&#39;: &#39;keep-alive&#39;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;100&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# &#39;Content-Length&#39;: &#39;1216&#39;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;101&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# &#39;Content-Type&#39;: &#39;text/plain;charset=UTF-8&#39;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;102&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# &#39;Host&#39;: &#39;dkapi.geetest.com&#39;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;103&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# &#39;Origin&#39;: &#39;https://jobs.zhaopin.com&#39;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;104&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;105&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token string&#34;&gt;&#39;User-Agent&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36 Edg/125.0.0.0&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;106&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# &#39;Priority&#39;: &#39;u=0,i&#39;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;107&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token string&#34;&gt;&#39;Referer&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;https://jobs.zhaopin.com/&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;108&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token string&#34;&gt;&#39;Sec-Ch-Ua&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;&#34;Microsoft Edge&#34;;v =&#34;125&#34;,&#34;Chromium&#34;;v=&#34;125&#34;,&#34;Not.A/Brand&#34;;v =&#34;24&#34;&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;109&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token string&#34;&gt;&#39;Sec-Ch-Ua-Mobile&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;?0&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;110&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token string&#34;&gt;&#39;Sec-Ch-Ua-Platform&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;Windows&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;111&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token string&#34;&gt;&#39;Sec-Fetch-Dest&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;script&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;112&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token string&#34;&gt;&#39;Sec-Fetch-Mode&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;no-cors&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;113&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token string&#34;&gt;&#39;Sec-Fetch-Site&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;same-site&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;114&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token string&#34;&gt;&#39;Upgrade-Insecure-Requests&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;1&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;115&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token string&#34;&gt;&#39;Cookie&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; Cookie&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;116&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;117&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;118&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    turn &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;2&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;119&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;for&lt;/span&gt; i &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;range&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; turn&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;120&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string-interpolation&#34;&gt;&lt;span class=&#34;token string&#34;&gt;f&#39;正在爬取第&lt;/span&gt;&lt;span class=&#34;token interpolation&#34;&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;页&#39;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;121&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        url &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token string-interpolation&#34;&gt;&lt;span class=&#34;token string&#34;&gt;f&#39;https://sou.zhaopin.com/?jl=653&amp;amp;kw=Java&amp;amp;p=&lt;/span&gt;&lt;span class=&#34;token interpolation&#34;&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;&lt;/span&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;122&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        getonepagelist&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;url&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; headers&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;123&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string-interpolation&#34;&gt;&lt;span class=&#34;token string&#34;&gt;f&#39;第&lt;/span&gt;&lt;span class=&#34;token interpolation&#34;&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;页爬取完成&#39;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;h3 id=&#34;selenium&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#selenium&#34;&gt;#&lt;/a&gt; selenium&lt;/h3&gt;
&lt;figure class=&#34;highlight python&#34;&gt;&lt;figcaption data-lang=&#34;python&#34;&gt;&lt;/figcaption&gt;&lt;table&gt;&lt;tr&gt;&lt;td data-num=&#34;1&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;from&lt;/span&gt; selenium &lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; webdriver&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;2&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;from&lt;/span&gt; selenium&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;webdriver&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;common&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;by &lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; By&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;3&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;from&lt;/span&gt; selenium&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;webdriver&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;chrome&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;service &lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; Service &lt;span class=&#34;token keyword&#34;&gt;as&lt;/span&gt; ChromeService&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;4&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;from&lt;/span&gt; webdriver_manager&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;chrome &lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; ChromeDriverManager&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;5&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;from&lt;/span&gt; bs4 &lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; BeautifulSoup&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;6&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; time&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;7&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;8&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;# 初始化 Selenium WebDriver&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;9&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;service &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; ChromeService&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;executable_path&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#34;G:\DLibrary\chromedriver-win64\chromedriver.exe&#34;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;10&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;driver &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; webdriver&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;Chrome&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;service&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;service&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;11&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;12&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;13&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;getpostinfo&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;url&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;14&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# url_split = url.split(&#39;?&#39;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;15&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# url = url_split[0]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;16&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# url += &#39;?refcode=4019&amp;amp;srccode=401901&amp;amp;preactionid=948d2073-65a0-497b-8123-6f56ca3e1af8&#39;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;17&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# r = requests.get(url, headers=headers, timeout=10)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;18&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# r.raise_for_status()&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;19&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# r.encoding = &#39;utf-8&#39;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;20&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;21&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    driver&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;get&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;url&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;22&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;23&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    html &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; driver&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;page_source&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;24&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;25&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# 使用 BeautifulSoup 解析 HTML&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;26&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    soup &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; BeautifulSoup&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;html&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;html.parser&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;27&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;soup&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;28&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;29&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    postinfo &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;30&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;31&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    post &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; soup&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;find&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;attrs&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;class&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;summary-plane__title&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;split&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39; &#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;32&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    desc &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; soup&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;find&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;attrs&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;class&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;describtion__detail-content&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;split&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39; &#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;33&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;34&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    postinfo&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;append&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;post&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;35&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    postinfo&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;append&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;desc&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;36&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;37&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;postinfo&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;38&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;39&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# saveData2DB(postinfo)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;40&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;41&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;42&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;getonepagelist&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;url&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;43&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    driver&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;get&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;url&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;44&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;45&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    html &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; driver&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;page_source&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;46&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;47&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# 使用 BeautifulSoup 解析 HTML&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;48&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    soup &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; BeautifulSoup&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;html&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;html.parser&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;49&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;50&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# 进行你需要的解析操作&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;51&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# print(soup.prettify())&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;52&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;53&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    lsts &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; soup&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;find_all&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;attrs&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;class&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;jobinfo__top&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;54&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;lsts&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;55&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;56&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;for&lt;/span&gt; lst &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; lsts&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;57&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        href &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; lst&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;a&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;href&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;58&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        time&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;sleep&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0.5&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;59&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        getpostinfo&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;href&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;60&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;61&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;62&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;if&lt;/span&gt; __name__ &lt;span class=&#34;token operator&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;__main__&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;63&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    turn &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;2&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;64&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;for&lt;/span&gt; i &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;range&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; turn&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;65&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string-interpolation&#34;&gt;&lt;span class=&#34;token string&#34;&gt;f&#39;正在爬取第&lt;/span&gt;&lt;span class=&#34;token interpolation&#34;&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;页&#39;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;66&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        url &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token string-interpolation&#34;&gt;&lt;span class=&#34;token string&#34;&gt;f&#39;https://sou.zhaopin.com/?jl=653&amp;amp;kw=Java&amp;amp;p=&lt;/span&gt;&lt;span class=&#34;token interpolation&#34;&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;&lt;/span&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;67&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        getonepagelist&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;url&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;68&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string-interpolation&#34;&gt;&lt;span class=&#34;token string&#34;&gt;f&#39;第&lt;/span&gt;&lt;span class=&#34;token interpolation&#34;&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;页爬取完成&#39;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;69&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;70&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# 进行你需要的解析操作&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;71&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# print(soup.prettify())&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;p&gt;都以失败告终，我还在登陆验证纠结了好久。&lt;/p&gt;
&lt;h3 id=&#34;换个网站解决不了问题就解决问题本身&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#换个网站解决不了问题就解决问题本身&#34;&gt;#&lt;/a&gt; 换个网站（解决不了问题，就解决问题本身）&lt;/h3&gt;
&lt;p&gt;换了个网站爬，杭州人才网&lt;/p&gt;
&lt;figure class=&#34;highlight python&#34;&gt;&lt;figcaption data-lang=&#34;python&#34;&gt;&lt;/figcaption&gt;&lt;table&gt;&lt;tr&gt;&lt;td data-num=&#34;1&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; os&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;2&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; re&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;3&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; time&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;4&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; requests&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;5&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;from&lt;/span&gt; bs4 &lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; BeautifulSoup&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;6&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;from&lt;/span&gt; fake_useragent &lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; UserAgent&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;7&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;8&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;import&lt;/span&gt; pandas &lt;span class=&#34;token keyword&#34;&gt;as&lt;/span&gt; pd&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;9&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;10&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;11&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;saveData2DB&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;datalist&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;12&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    columns &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;id&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;工位名称&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;薪资&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;工作地点&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;经验要求&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;学历要求&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;应届生接受情况&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;工作福利&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;招聘人数&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;13&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;               &lt;span class=&#34;token string&#34;&gt;&#39;到岗时间&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;年龄要求&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;婚姻情况&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;任职要求&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;公司内容&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;公司类型&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;公司规模&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;14&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# 将列表转换为 DataFrame&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;15&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    new_data &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; pd&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;DataFrame&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;datalist&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; columns&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;columns&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;16&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;17&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# 打印结果以确认&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;18&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# print(new_data)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;19&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;20&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# 追加到现有的 CSV 文件（如果文件不存在则创建）&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;21&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    PATH &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;data_hzrc3.csv&#39;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;22&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;try&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;23&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        df &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; pd&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;read_csv&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;PATH&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; encoding&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;utf-8&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;24&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# 追加新数据&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;25&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        df &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; pd&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;concat&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;df&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; new_data&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; ignore_index&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token boolean&#34;&gt;True&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;26&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;except&lt;/span&gt; FileNotFoundError&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;27&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# 如果文件不存在，则新建一个 DataFrame&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;28&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        df &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; new_data&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;29&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;30&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# 保存更新后的 DataFrame 到 CSV 文件&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;31&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    df&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;to_csv&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;PATH&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; index&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token boolean&#34;&gt;False&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; encoding&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;utf-8&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;32&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# print (&#34;data_hzrc.csv 文件中。&#34;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;33&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;34&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;35&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;getonepagelist&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token builtin&#34;&gt;id&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; url&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; headers&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;36&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    r &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; requests&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;get&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;url&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; headers&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;headers&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; timeout&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;10&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;37&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    r&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;raise_for_status&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;38&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    r&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;encoding &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;utf-8&#39;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;39&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;40&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    soup &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; BeautifulSoup&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;r&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;html.parser&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;41&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# print(soup)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;42&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;43&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# 如果为空&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;44&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;if&lt;/span&gt; soup&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;find&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;attrs&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;class&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;job_details_salary_n&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;is&lt;/span&gt; &lt;span class=&#34;token boolean&#34;&gt;None&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;45&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#34;该岗位不存在&#34;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;46&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;return&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;47&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;48&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    postinfo &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token builtin&#34;&gt;id&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;49&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;50&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    job_name &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; soup&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;find&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;attrs&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;class&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;job_details_name&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;split&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39; &#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;51&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    job_salary_n &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; soup&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;find&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;attrs&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;class&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;job_details_salary_n&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;split&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39; &#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;52&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    postinfo&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;append&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;job_name&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;53&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    postinfo&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;append&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;job_salary_n&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;54&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;55&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    details &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; soup&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;find&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;attrs&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;class&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;job_details_info&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;split&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#34;|&#34;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;56&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    details_segments &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;segment&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;strip&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;for&lt;/span&gt; segment &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; details &lt;span class=&#34;token keyword&#34;&gt;if&lt;/span&gt; segment&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;strip&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;  &lt;span class=&#34;token comment&#34;&gt;# （地点，经验要求，学历要求，（是否接受应届生））&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;57&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;while&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;len&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;details_segments&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;58&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        details_segments&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;append&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#34; &#34;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;59&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# print(details_segments)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;60&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    postinfo &lt;span class=&#34;token operator&#34;&gt;+=&lt;/span&gt; details_segments&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;61&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;62&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    job_details_welfare &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#34;没有写福利，快跑！&#34;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;63&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;if&lt;/span&gt; soup&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;find&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;attrs&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;class&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;job_details_welfare&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;is&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;not&lt;/span&gt; &lt;span class=&#34;token boolean&#34;&gt;None&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;64&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        job_details_welfare &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; soup&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;find&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;attrs&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;class&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;job_details_welfare&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text  &lt;span class=&#34;token comment&#34;&gt;# 福利&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;65&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        job_details_welfare &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; job_details_welfare&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;strip&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;replace&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#34;\n&#34;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#34;,&#34;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;66&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# print(job_details_welfare)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;67&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    postinfo&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;append&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;job_details_welfare&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;68&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;69&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    job_details_describe_yq &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;70&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;if&lt;/span&gt; soup&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;find_all&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;attrs&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;class&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;job_details_describe_yq&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;is&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;not&lt;/span&gt; &lt;span class=&#34;token boolean&#34;&gt;None&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;71&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        job_details_describe_yq &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; soup&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;find_all&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;attrs&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;class&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;job_details_describe_yq&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;72&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# print(job_details_describe_yq)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;73&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;74&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    job_details_describe_segments_tmp &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#34;&#34;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;4&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;75&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;for&lt;/span&gt; job_details_describe &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; job_details_describe_yq&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;76&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#34;招聘人数&#34;&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; job_details_describe&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;77&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            job_details_describe_segments_tmp&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; job_details_describe&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;78&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;elif&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#34;到岗时间&#34;&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; job_details_describe&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;79&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            job_details_describe_segments_tmp&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; job_details_describe&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;80&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;elif&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#34;年龄要求&#34;&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; job_details_describe&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;81&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            job_details_describe_segments_tmp&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; job_details_describe&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;82&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;elif&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#34;婚况要求&#34;&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; job_details_describe&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;83&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            job_details_describe_segments_tmp&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; job_details_describe&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;84&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# print(job_details_describe_segments_tmp)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;85&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    postinfo &lt;span class=&#34;token operator&#34;&gt;+=&lt;/span&gt; job_details_describe_segments_tmp  &lt;span class=&#34;token comment&#34;&gt;# 招聘人数…&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;86&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;87&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    description &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#34;&#34;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;88&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    ps &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; soup&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;find&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;attrs&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#34;job_details_describe&#34;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;find_all&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;p&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;89&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;for&lt;/span&gt; i&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; p &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;enumerate&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;ps&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;90&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        description &lt;span class=&#34;token operator&#34;&gt;+=&lt;/span&gt; p&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;strip&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;91&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# print(description)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;92&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    postinfo&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;append&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;description&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;  &lt;span class=&#34;token comment&#34;&gt;# 任职要求…&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;93&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;94&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    compply_right_span_cs &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; soup&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;find_all&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;attrs&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;class&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;Compply_right_span_c&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;95&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;for&lt;/span&gt; i&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; compply_right_span_c &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;enumerate&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;compply_right_span_cs&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;96&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        compply_right_span_cs&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; compply_right_span_c&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;text&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;97&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# print(compply_right_span_cs[:4])&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;98&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    postinfo &lt;span class=&#34;token operator&#34;&gt;+=&lt;/span&gt; compply_right_span_cs&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;  &lt;span class=&#34;token comment&#34;&gt;# 能源 / 环保 / 矿产 民营 20-99 人 （融资大部分企业都没写，就不要了，只要前三个）&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;99&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;100&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# 拼接&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;101&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# postinfo.append(job_name)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;102&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# postinfo.append(job_salary_n)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;103&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# postinfo += details_segments&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;104&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# postinfo.append(job_details_welfare)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;105&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# postinfo += job_details_describe_segments_tmp  # 招聘人数…&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;106&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# postinfo.append (description)  # 任职要求…&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;107&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;108&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;postinfo&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;109&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# print(len(postinfo))&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;110&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;111&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# saveData2DB(postinfo)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;112&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;113&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;114&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;if&lt;/span&gt; __name__ &lt;span class=&#34;token operator&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;token string&#34;&gt;&#39;__main__&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;115&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# 本地获取&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;116&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    ua &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; UserAgent&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;117&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# ua.random 随机获取一个请求头&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;118&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# headers = &amp;#123;&#34;useragent&#34;: ua.random&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;119&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;120&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# with open(&#34;./cookie&#34;, &#34;r&#34;, encoding=&#34;utf-8&#34;) as file:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;121&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;#     Cookie = file.read()&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;122&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# print(cookie)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;123&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;124&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    headers &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;125&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token string&#34;&gt;&#39;User-Agent&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; ua&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;random&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;126&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;127&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# 8482&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;128&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;for&lt;/span&gt; i &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;range&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;8482&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;129&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# print (f&#39; 正在爬取第 &amp;#123;i&amp;#125; 个 &#39;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;130&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        url &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token string-interpolation&#34;&gt;&lt;span class=&#34;token string&#34;&gt;f&#39;https://www.hangpin.com.cn/job/&lt;/span&gt;&lt;span class=&#34;token interpolation&#34;&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;.html&#39;&lt;/span&gt;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;131&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        getonepagelist&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; url&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; headers&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;132&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        time&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;sleep&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;133&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;print&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string-interpolation&#34;&gt;&lt;span class=&#34;token string&#34;&gt;f&#39;第&lt;/span&gt;&lt;span class=&#34;token interpolation&#34;&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;个爬取完成&#39;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;134&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;135&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# url = f&#39;https://www.hangpin.com.cn/job/6454.html&#39;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;136&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;# getonepagelist(6454, url, headers)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;h2 id=&#34;数据分析&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#数据分析&#34;&gt;#&lt;/a&gt; 数据分析&lt;/h2&gt;
&lt;p&gt;数据可视化&lt;/p&gt;
&lt;h2 id=&#34;总结&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#总结&#34;&gt;#&lt;/a&gt; 总结&lt;/h2&gt;
&lt;p&gt;懂了好些关于爬虫的知识，&lt;/p&gt;
&lt;p&gt;但是反爬虫还不是很懂，以及 JS 动态的数据该怎么爬&lt;/p&gt;
</content>
        <updated>2024-06-05T03:01:09.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2024/05/17/%E8%A7%82%E7%9C%8Bchatgpt-4o%E5%8F%91%E5%B8%83%E4%BC%9A/</id>
        <title>观看chatgpt-4o发布会</title>
        <link rel="alternate" href="http://example.com/2024/05/17/%E8%A7%82%E7%9C%8Bchatgpt-4o%E5%8F%91%E5%B8%83%E4%BC%9A/"/>
        <content type="html">&lt;p&gt;观看 vedal 看 chatgpt-4o 发布会……&lt;/p&gt;
&lt;p&gt;（vedal：一个人工智能 vtuber 的家长、制作者）&lt;/p&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly93d3cuYmlsaWJpbGkuY29tL3ZpZGVvL0JWMWpnTWZldkVDVA==&#34;&gt;【与 AI VTuber 工程师 Vedal 一起看 OpenAI GPT-4o 发布会 【Neuro-sama】（文化绿洲）】&lt;/span&gt;&lt;/p&gt;
&lt;h1 id=&#34;发布会内容&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#发布会内容&#34;&gt;#&lt;/a&gt; 发布会内容&lt;/h1&gt;
&lt;h2 id=&#34;chatgpt-4o-可以在电脑上使用而非和以前一样的网页端&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#chatgpt-4o-可以在电脑上使用而非和以前一样的网页端&#34;&gt;#&lt;/a&gt; chatgpt-4o 可以在电脑上使用，而非和以前一样的网页端&lt;/h2&gt;
&lt;p&gt;看到的显示内容&lt;/p&gt;
&lt;p&gt;……&lt;/p&gt;
&lt;h2 id=&#34;chatgpt-4o-api&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#chatgpt-4o-api&#34;&gt;#&lt;/a&gt; chatgpt-4o API&lt;/h2&gt;
&lt;p&gt;能在 chatgpt 以外的地方使用 chatgpt-4o&lt;/p&gt;
&lt;p&gt;……&lt;/p&gt;
&lt;h2 id=&#34;chatgpt-4o-语音-voice-mode&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#chatgpt-4o-语音-voice-mode&#34;&gt;#&lt;/a&gt; chatgpt-4o 语音 Voice Mode&lt;/h2&gt;
&lt;p&gt;neuro 的语音输入是语音识别，然后把文字输入到模型。这样子存在听错的问题，且无法对环境音，声音的情况以及其他进行判断。我之前把讯飞语音接入到项目也是这样子做的。&lt;/p&gt;
&lt;h3 id=&#34;多模态输入&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#多模态输入&#34;&gt;#&lt;/a&gt; 多模态输入&lt;/h3&gt;
&lt;p&gt;可以&lt;strong&gt;语音、视觉、文字同时理解&lt;/strong&gt;，&lt;strong&gt;听得懂声音的缓急&lt;/strong&gt;，且&lt;strong&gt;可以打断它的输出&lt;/strong&gt;。&lt;/p&gt;
&lt;h3 id=&#34;tts&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#tts&#34;&gt;#&lt;/a&gt; TTS&lt;/h3&gt;
&lt;p&gt;不是传统的 TTS，能有&lt;strong&gt;不同音色的转换&lt;/strong&gt;（比如机器人式音色，唱歌的方法）。&lt;/p&gt;
&lt;p&gt;（输入部分开源社区有相应项目）&lt;/p&gt;
&lt;h2 id=&#34;chatgpt-4o-视觉&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#chatgpt-4o-视觉&#34;&gt;#&lt;/a&gt; chatgpt-4o 视觉&lt;/h2&gt;
&lt;h3 id=&#34;线性方程指导&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#线性方程指导&#34;&gt;#&lt;/a&gt; 线性方程指导&lt;/h3&gt;
&lt;p&gt;加入视觉，比如写下一个线性方程，然后让它给出提示（像一个老师一样）&lt;/p&gt;
&lt;p&gt;它能一步步提示，并很好地做到 &lt;strong&gt;指导&lt;/strong&gt; 这件事&lt;/p&gt;
&lt;p&gt;最后画上，爱心，有误导性的 t（+），G（6），能正确识别，并有感情的返回（似乎有笑声）&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240517095423190.png&#34; alt=&#34;image-20240517095423190&#34; /&gt;&lt;/p&gt;
&lt;h3 id=&#34;识别屏幕&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#识别屏幕&#34;&gt;#&lt;/a&gt; 识别屏幕&lt;/h3&gt;
&lt;p&gt;电脑版，可以获取到屏幕内容，看得懂代码，并分析输出&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240517095650310.png&#34; alt=&#34;image-20240517095650310&#34; /&gt;&lt;/p&gt;
&lt;h2 id=&#34;其他&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#其他&#34;&gt;#&lt;/a&gt; 其他&lt;/h2&gt;
&lt;h3 id=&#34;实时翻译输出&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#实时翻译输出&#34;&gt;#&lt;/a&gt; 实时翻译 + 输出&lt;/h3&gt;
&lt;p&gt;实现了意大利语和英语的&lt;strong&gt;实时翻译&lt;/strong&gt;&lt;/p&gt;
&lt;h3 id=&#34;识别人表情的情感&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#识别人表情的情感&#34;&gt;#&lt;/a&gt; 识别人表情的情感&lt;/h3&gt;
&lt;p&gt;……&lt;/p&gt;
&lt;h1 id=&#34;&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#&#34;&gt;#&lt;/a&gt; &lt;/h1&gt;
</content>
        <category term="chatgpt" />
        <updated>2024-05-17T01:35:15.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2024/04/26/%E5%9F%BA%E4%BA%8E%E5%A4%A7%E6%A8%A1%E5%9E%8B%E6%9E%84%E5%BB%BA%E6%99%BA%E8%83%BD%E9%97%AE%E7%AD%94%E7%B3%BB%E7%BB%9F/</id>
        <title>基于大模型构建智能问答系统</title>
        <link rel="alternate" href="http://example.com/2024/04/26/%E5%9F%BA%E4%BA%8E%E5%A4%A7%E6%A8%A1%E5%9E%8B%E6%9E%84%E5%BB%BA%E6%99%BA%E8%83%BD%E9%97%AE%E7%AD%94%E7%B3%BB%E7%BB%9F/"/>
        <content type="html">&lt;h1 id=&#34;需求&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#需求&#34;&gt;#&lt;/a&gt; 需求&lt;/h1&gt;
&lt;p&gt;老师：现有的 AI 还不太可控，可靠性不强，对企业来说，微调大模型意义不大。我是想在&lt;strong&gt;个性数据表&lt;/strong&gt;的基础上使用 AI，把所有的数据喂给 ai 来训练，变成把现有数据整理为 20 个数据表比如人际关系表、科研工作表。提问 xxx 的手机号为多少时？不是由 AI 来回答，由 AI 来确定，上面这句话应该属于哪个表 (比如确定为人际关系表)，再从人际关系表中找出相应的信息来返回。&lt;/p&gt;
&lt;p&gt;看法：基于知识库问答？也许并不需要 &amp;quot;整理成 20 个数据表&amp;quot;，&lt;/p&gt;
&lt;h1 id=&#34;学习&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#学习&#34;&gt;#&lt;/a&gt; 学习&lt;/h1&gt;
&lt;h2 id=&#34;技术方案选型&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#技术方案选型&#34;&gt;#&lt;/a&gt; &lt;strong&gt;技术方案选型&lt;/strong&gt;&lt;/h2&gt;
&lt;p&gt;目前，大模型已经可以通过对自然语言的理解揣摩用户意图，并对原始知识进行汇总、整合，进而生成更具逻辑和完整性的答案。然而，仍存在以下几个问题，导致我们不能直接使用这些模型来对特定领域知识进行问答。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;专业性不足：作为通用大模型，对专业领域知识的训练不足，可能会产生幻觉以及信息丰富度不足的问题。&lt;/li&gt;
&lt;li&gt;时效性问题：模型的训练数据基于某个时间之前的数据，缺乏最新的信息，每次添加新数据都会导致高昂的训练成本。&lt;/li&gt;
&lt;li&gt;安全性问题：模型无法访问企业内部私密文档，且这些文档不能直接用于 Fine-Tuning。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;为了解决这些问题，业界采用了如下几种技术手段来为大型模型提供额外知识。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Fine-Tuning（微调）：使用特定领域的知识对基础大模型进行微调，以改变神经网络参数的权重。虽然适用于特定任务或风格，但需要大量资源和高质量的训练数据。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Prompt 工程&lt;/strong&gt;：将行业领域的知识作为输入消息提供给模型，让模型对消息中的知识进行分析和处理。这种方法在正确性和精度上表现良好，但有文本长度限制，对于大规模数据不够高效。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;与传统搜索结合&lt;/strong&gt;：使用传统搜索技术构建基础知识库，然后使用大语言模型处理用户请求，对召回结果进行二次加工。这种方法具有更高的可控性和效率，并适用于大规模数据。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;为了确保准确性和效率，我们选择了第 2 种和第 3 种方式相结合的方案，&lt;strong&gt;通过向量数据库将知识外挂作为大模型记忆体，使用 LangChain 作为基础开发框架来构建知识库问答系统，最终依靠 Prompt 工程和大模型进行交互。&lt;/strong&gt;&lt;/p&gt;
&lt;h1 id=&#34;引用&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#引用&#34;&gt;#&lt;/a&gt; 引用&lt;/h1&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly96aHVhbmxhbi56aGlodS5jb20vcC82ODA3MjUxMjA=&#34;&gt;数据库运维工作量直接减少 50%，基于大模型构建智能问答系统的技术分享 - 知乎 (zhihu.com)&lt;/span&gt;&lt;/p&gt;
</content>
        <category term="LLM" />
        <category term="AI" />
        <updated>2024-04-26T02:45:42.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2024/04/12/%E7%AC%AC%E4%B8%80%E6%AC%A1%E9%9D%A2%E8%AF%95%E5%87%86%E5%A4%87/</id>
        <title>第一次面试准备</title>
        <link rel="alternate" href="http://example.com/2024/04/12/%E7%AC%AC%E4%B8%80%E6%AC%A1%E9%9D%A2%E8%AF%95%E5%87%86%E5%A4%87/"/>
        <content type="html">&lt;h1 id=&#34;前言&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#前言&#34;&gt;#&lt;/a&gt; 前言&lt;/h1&gt;
&lt;p&gt;大概三月末的时候，学校有个招聘会，然后我投了几家。刚刚打电话，问我明早有没有时间远程面试&lt;/p&gt;
&lt;p&gt;没多想就答应了下来，这下好了，得回顾一下简历上写的东西了&lt;/p&gt;
&lt;p&gt;对的，很烂&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412121818555.png&#34; alt=&#34;image-20240412121818555&#34; /&gt;&lt;/p&gt;
&lt;p&gt;想着把 Redis 看一下（其实我还没学完，当时想着做简历就写上去了，而且最近在忙着比赛和打游戏，Java 这方面已经落下很多了）&lt;/p&gt;
&lt;p&gt;也许到时候可以把面试官往我最近比赛的方面引。&lt;/p&gt;
&lt;h1 id=&#34;可能的面试内容&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#可能的面试内容&#34;&gt;#&lt;/a&gt; 可能的面试内容&lt;/h1&gt;
&lt;p&gt;时间紧任务重，能准备的也不是很充分&lt;/p&gt;
&lt;h2 id=&#34;自我介绍&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#自我介绍&#34;&gt;#&lt;/a&gt; &lt;s&gt;自我介绍&lt;/s&gt;&lt;/h2&gt;
&lt;p&gt;……&lt;/p&gt;
&lt;h2 id=&#34;redis项目的细节&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#redis项目的细节&#34;&gt;#&lt;/a&gt; Redis 项目的细节 *&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;五种类型&lt;/p&gt;
&lt;p&gt;字符串、列表、hash、set、zset&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;持久化策略&lt;/p&gt;
&lt;p&gt;…&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;内存淘汰策略&lt;/p&gt;
&lt;p&gt;懒惰性删除 + 定期删除，懒惰性：用的时候才查是否过期。缺点：可能会有数据一直用不到，一直存在在内存。定期删除：定期删，缺点：遍历，时间长，内存压力大&lt;/p&gt;
&lt;p&gt;结合：抽取一部分定期删除 + 懒惰&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;主从、哨兵&lt;/p&gt;
&lt;p&gt;主服务器、从服务器，&lt;/p&gt;
&lt;p&gt;哨兵：监控、提醒、自动故障迁移、统一的配置管理&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;其他见 &lt;em&gt;Redis 学习记录&lt;/em&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;spring-boot的相关知识&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#spring-boot的相关知识&#34;&gt;#&lt;/a&gt; Spring boot 的相关知识&lt;/h2&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412231410321.png&#34; alt=&#34;image-20240412231410321&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412231458213.png&#34; alt=&#34;image-20240412231458213&#34; /&gt;&lt;/p&gt;
&lt;h2 id=&#34;最近比赛的内容&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#最近比赛的内容&#34;&gt;#&lt;/a&gt; 最近比赛的内容&lt;/h2&gt;
&lt;p&gt;见 &lt;em&gt;A25&lt;/em&gt;&lt;/p&gt;
&lt;h2 id=&#34;git&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#git&#34;&gt;#&lt;/a&gt; Git&lt;/h2&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412231950813.png&#34; alt=&#34;image-20240412231950813&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412232258004.png&#34; alt=&#34;image-20240412232258004&#34; /&gt;&lt;/p&gt;
&lt;h1 id=&#34;面后整理&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#面后整理&#34;&gt;#&lt;/a&gt; 面后整理&lt;/h1&gt;
&lt;h2 id=&#34;自我介绍-2&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#自我介绍-2&#34;&gt;#&lt;/a&gt; 自我介绍&lt;/h2&gt;
&lt;p&gt;阿巴阿巴&lt;/p&gt;
&lt;h2 id=&#34;问我什么项目提升最大redis&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#问我什么项目提升最大redis&#34;&gt;#&lt;/a&gt; 问我什么项目提升最大（Redis）&lt;/h2&gt;
&lt;p&gt;我说了 Redis 的那个，介绍一下项目实现，因为没有开视频，我对着昨晚做的 Redis 讲 + 分布式锁&lt;/p&gt;
&lt;p&gt;（懂不懂一天速成 Redis 的含金量 后仰.jpg）&lt;/p&gt;
&lt;h2 id=&#34;mysql&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#mysql&#34;&gt;#&lt;/a&gt; Mysql&lt;/h2&gt;
&lt;p&gt;索引、having、group by&lt;/p&gt;
&lt;h2 id=&#34;mybatis配置文件&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#mybatis配置文件&#34;&gt;#&lt;/a&gt; MyBatis 配置文件&lt;/h2&gt;
&lt;p&gt;Mysql 配置，MyBatis 插件的配置类……&lt;/p&gt;
&lt;h2 id=&#34;spring-boot&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#spring-boot&#34;&gt;#&lt;/a&gt; Spring Boot&lt;/h2&gt;
&lt;p&gt;AOP（可恶，看了的没问，没看的忘了）&lt;/p&gt;
&lt;h2 id=&#34;java基础&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#java基础&#34;&gt;#&lt;/a&gt; Java 基础&lt;/h2&gt;
&lt;p&gt;ArrayList 和 LinkedList 区别：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;ArrayList 基于动态数组实现的非线程安全的集合；LinkedList 基于链表实现的非线程安全的集合。&lt;/li&gt;
&lt;li&gt;对于随机 index 访问的 get 和 set 方法，一般 ArrayList 的速度要优于 LinkedList。因为 ArrayList 直接通过数组下标直接找到元素；LinkedList 要移动指针遍历每个元素直到找到为止。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;问我什么课感兴趣&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#问我什么课感兴趣&#34;&gt;#&lt;/a&gt; 问我什么课感兴趣&lt;/h2&gt;
&lt;p&gt;我说了 Java + 操作系统 + 数据结构&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;操作系统&lt;/p&gt;
&lt;p&gt;银行家算法&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;git工具&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#git工具&#34;&gt;#&lt;/a&gt; git 工具&lt;/h2&gt;
&lt;p&gt;常用命令&lt;/p&gt;
&lt;h2 id=&#34;最近比赛的内容-2&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#最近比赛的内容-2&#34;&gt;#&lt;/a&gt; 最近比赛的内容&lt;/h2&gt;
&lt;p&gt;因为我时不时提一嘴，我最近在打比赛，然后后面终于问了。&lt;strong&gt;之前在牛客学的精髓，引导面试官占据主导权&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;这我可太熟了，然后问我参数的意义&lt;/p&gt;
&lt;h2 id=&#34;由于涉及到ai问我ai对我们it行业的帮助&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#由于涉及到ai问我ai对我们it行业的帮助&#34;&gt;#&lt;/a&gt; 由于涉及到 AI，问我 AI 对我们 IT 行业的帮助&lt;/h2&gt;
&lt;p&gt;弱 AI，基于大数据而不是逻辑，所以只能辅助开发，而非独立开发&lt;/p&gt;
&lt;h2 id=&#34;结尾&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#结尾&#34;&gt;#&lt;/a&gt; 结尾&lt;/h2&gt;
&lt;p&gt;问了一下我的情况&lt;/p&gt;
&lt;h2 id=&#34;感想&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#感想&#34;&gt;#&lt;/a&gt; 感想&lt;/h2&gt;
&lt;p&gt;上次双选会，哥们就拿着之前做好的简历过去投，啥也没准备&lt;/p&gt;
&lt;p&gt;所以这一次算是第一次面试，昨天接到电话后一直在准备（虽然也玩了好些），但确实是半天速成 Redis，把敲代码的过程大部分跳了，然后关注原理，并记录。看完后昨晚看了一遍记录，今天看了一遍。&lt;/p&gt;
&lt;p&gt;然后再对着简历，准备了俩 Spring Boot 高频考点，粗看了一下 Git。早上还很早就醒了，害怕，jpg&lt;/p&gt;
</content>
        <category term="面试" />
        <updated>2024-04-12T04:15:51.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2024/03/22/%E6%99%BA%E6%97%85%E9%97%AE%E7%AD%94/</id>
        <title>智旅问答</title>
        <link rel="alternate" href="http://example.com/2024/03/22/%E6%99%BA%E6%97%85%E9%97%AE%E7%AD%94/"/>
        <content type="html">&lt;h2 id=&#34;问题说明&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#问题说明&#34;&gt;#&lt;/a&gt; 问题说明&lt;/h2&gt;
&lt;p&gt;基于给定目标城市，城市可由参赛选手自己选择。通过网络、书籍等方法整理收集目标城市的文旅数据，包括但不限于&lt;strong&gt;城市的历史、名人、景点、饮食特色、热门店铺等信息&lt;/strong&gt;，构建语料库，并基于大模型微调的相关技术方法，实现基于大模型的语料库问答系统。其中对于大模型的选择可以选取一些开源模型，如 GLM、modelscope 开源的 GPT-3 中文版本、LLaMA、BLOOM 等。&lt;/p&gt;
&lt;p&gt;&lt;em&gt;此次基于 chatglm3-6b 进行微调，使用较低的配置实现较高的性能&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;&lt;s&gt;&lt;em&gt;24/04/09 突然觉得在做无意义的事，找一段文本或者根本不找，让一个模型（copilot、kimi…）跑出些问答数据集，再塞给另一个模型微调……&lt;/em&gt;&lt;/s&gt;&lt;/p&gt;
&lt;h2 id=&#34;期望&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#期望&#34;&gt;#&lt;/a&gt; 期望&lt;/h2&gt;
&lt;p&gt;基于目标城市的文旅数据，构建语料库并进行大模型的微调，实现基于大模型的语料库问答系统。通过问答系统实现用户输入以下问题，问题示例如下：&lt;/p&gt;
&lt;p&gt;请推荐 XX 城市的三个最热门的景点？&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;XX 景点位于什么地方？&lt;/li&gt;
&lt;li&gt;介绍一下 XX 景点的历史？&lt;/li&gt;
&lt;li&gt;XX 附近有什么推荐的小吃店铺？&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;该问答系统能够给出上述问题的回复。&lt;/p&gt;
&lt;h2 id=&#34;要求&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#要求&#34;&gt;#&lt;/a&gt; 要求&lt;/h2&gt;
&lt;p&gt;收集目标城市的相关文旅数据，进行语料库的构建（方法不限），并基于语料库进行大模型微调，实现基于该语料库的问答系统。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;详细方案内容完备，具有可行性和先进性；&lt;/li&gt;
&lt;li&gt;模型支持至少两轮问答；&lt;/li&gt;
&lt;li&gt;具备大模型的基础问答能力和基于语料库的问答能力。考核方法基于用户提供的语料范围，编制问题，对模型进行提问，对模型问答能力进行评估；&lt;/li&gt;
&lt;li&gt;具有交互界面，可通过浏览器进行访问，页面的访问延迟和问答的响应延迟不超过 10s；&lt;/li&gt;
&lt;li&gt;语料库数据不低于 3000 条。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;todo&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#todo&#34;&gt;#&lt;/a&gt; TODO&lt;/h2&gt;
&lt;ul class=&#34;task-list&#34;&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_0&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_0&#34;&gt; 语料库格式、内容&lt;/label&gt;&lt;/p&gt;
&lt;p&gt;&lt;s&gt;（instruction + output + history + input + ？）&lt;/s&gt;&lt;/p&gt;
&lt;p&gt;查看 SHA1 码：certutil -hashfile &amp;lt;filename&amp;gt; SHA1&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_1&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_1&#34;&gt; 使用高德地图 API 或爬点什么网站的数据或使用其他方法构建语料库&lt;/label&gt;&lt;/p&gt;
&lt;p&gt;（在建了在建了…）&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_2&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_2&#34;&gt; 使用了高德地图的 API，能否使模型能调用 agent（工具），再根据返回的 json 进行回答&lt;/label&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_3&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_3&#34;&gt; 对于&lt;strong&gt;城市的历史、名人、景点、饮食特色、热门店铺等信息&lt;/strong&gt;，考虑到语聊集的格式，&lt;/label&gt;&lt;/p&gt;
&lt;p&gt;&lt;s&gt;某某某的周边热门店铺有哪些，不太方便输入，可以考虑语聊集 + 工具调用的方法，&lt;/s&gt;&lt;/p&gt;
&lt;p&gt;好像也挺方便，比如 instruction 灵隐寺周边的奶茶店 output 古茗、一点点等……&lt;/p&gt;
&lt;p&gt;（支持多轮，如果能再问 “灵隐寺最近的古茗”，此处调用 API 回答是否能加分）&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_4&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_4&#34;&gt; &lt;s&gt;希望能把 composition-demo 里的 chat 和 tool 结合起来，并不以 streamlit 形式输出，&lt;/s&gt;&lt;/label&gt;&lt;/p&gt;
&lt;p&gt;”Tool: 工具模式，模型除了对话外，还可以通过工具进行其他操作 “&lt;/p&gt;
&lt;p&gt;似乎不需要结合？&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_5&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_5&#34;&gt; 微调 &lt;s&gt;p-tuning&lt;/s&gt; | Lora | DPO |etc.&lt;/label&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;24/03/30&lt;/em&gt; Lora 微调好了，且无报错的导出了模型，但是问答效果不好，想试试 DPO&lt;/p&gt;
&lt;p&gt;​	 04/01 开始着手微调的优化：秩 (r)、缩放系数 (alpha)：一般 alpha 是 r 的两倍&lt;/p&gt;
&lt;p&gt;​				是否需要制作偏好数据集（太麻烦了，优先级低）&lt;/p&gt;
&lt;p&gt;​				“微调是为了修正一些向量的参数”，但假如通过微调修改了 chatglm 的自我认知，？&lt;/p&gt;
&lt;p&gt;​	04/02 偏好数据集，制作中！&lt;/p&gt;
&lt;p&gt;​				制作好了，第一次 DPO 微调&lt;/p&gt;
&lt;p&gt;&amp;lt;img src=&amp;quot;image-20240402153832714.png&amp;quot; alt=&amp;quot;image-20240402153832714&amp;quot; style=&amp;quot;zoom: 67%;&amp;quot; /&amp;gt;&lt;/p&gt;
&lt;p&gt;​				微调出来效果貌似也一般，如果想准确回答的话，不应该用过&lt;strong&gt;向量数据库&lt;/strong&gt;吗（后知后觉），毕竟 chatGPT 也无法做到数据向的精准回答（增大某些词的参数吗…）&lt;/p&gt;
&lt;p&gt;​		04/03 微调出了什么 **… 数据集不够大，轮数太多，导致了灾难性遗忘，只会阿巴阿巴了&lt;/p&gt;
&lt;p&gt;​					调小轮数试试（DPO epochs3，r8，alpha16，0.15）&lt;/p&gt;
&lt;p&gt;​		04/06 看看 open AI 文档 &lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9naXRodWIuY29tL29wZW5haS9vcGVuYWktY29va2Jvb2svYmxvYi9tYWluL2V4YW1wbGVzL1F1ZXN0aW9uX2Fuc3dlcmluZ191c2luZ19lbWJlZGRpbmdzLmlweW5i&#34;&gt;Question answering using embeddings-based search&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;​					&lt;strong&gt;Note: To answer questions based on text documents, we recommend the procedure in&lt;/strong&gt; &lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9naXRodWIuY29tL29wZW5haS9vcGVuYWktY29va2Jvb2svYmxvYi9tYWluL2V4YW1wbGVzL1F1ZXN0aW9uX2Fuc3dlcmluZ191c2luZ19lbWJlZGRpbmdzLmlweW5i&#34;&gt;Question Answering using Embeddings&lt;/span&gt;&lt;strong&gt;.&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;​					推荐使用 Embedding，不涉及微调，难搞&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240406135627455.png&#34; alt=&#34;image-20240406135627455&#34; /&gt;&lt;/p&gt;
&lt;p&gt;​		04/08 扩充一下数据集，再试着调一下&lt;/p&gt;
&lt;p&gt;​					模型评估（loss、准确度）&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_6&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_6&#34;&gt; 模型评估调优、测试&lt;/label&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;​		&lt;strong&gt;知名景点&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;​		&lt;strong&gt;/ 小众景点&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;​		&lt;strong&gt;不存在的景点不乱答（幻觉现象少）&lt;/strong&gt;&lt;/p&gt;
&lt;ul class=&#34;task-list&#34;&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_7&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_7&#34;&gt; 能回答附带图片（感觉是加分项）&lt;/label&gt;&lt;/p&gt;
&lt;p&gt;conversation 里有 image 属性，似乎可以使用 / 拓展&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_8&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_8&#34;&gt; 前后端联调&lt;/label&gt;&lt;/p&gt;
&lt;p&gt;24/03/30 尝试看源码，把 chatglm 提供的综合 demo 去除 streamlit&lt;/p&gt;
&lt;p&gt;​	 03/31 fastAPI ?  似乎就 chat 而言，每次需要传输的，就是 conversation.py 里的&lt;/p&gt;
&lt;p&gt;​	 04/01 查看了 FastAPI、uvicorn、Flask、ASGI/WSGI，&lt;s&gt;还是保留 streamlit（比如使用它的 session）+fastAPI 吧，好复杂（shi 山代码是如何形成的）&lt;/s&gt;&lt;/p&gt;
&lt;p&gt;​	04/02 尝试用 FastAPI 给前端提供数据了&lt;/p&gt;
&lt;p&gt;​				&lt;s&gt;目前看需要俩，一个是前端加载时提供一个 client；一个是 conversation 对话&lt;/s&gt;&lt;/p&gt;
&lt;p&gt;​				从好几个方向写，但总感觉很卡手。无法同时部署 streamlit 和 uvicorn（FastAPI），俩服务器就不互通，数据使用起来很难受。Flask 和 streamlit 一样，是写在后端的前端界面。如果用 Vue+node.js，中间多出来的 request、response，以及前端该如何做，很陌生&lt;/p&gt;
&lt;p&gt;​	04/03 有点混乱，简单的来看，就是前端，携带一推数据，用 get 向后端发起请求&lt;/p&gt;
&lt;p&gt;​				后端收到请求后，此处对应的功能就是原代码中的 if prompt_text&lt;/p&gt;
&lt;p&gt;​				需要解决的&lt;/p&gt;
&lt;p&gt;​					&lt;s&gt;BaseModel 类&lt;/s&gt;（删掉就能跑了，好神奇）&lt;/p&gt;
&lt;p&gt;​					history 这些参数该如何存储（json）&lt;/p&gt;
&lt;p&gt;​	04/04 改来改去，改好了一个，&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240404105119348.png&#34; alt=&#34;image-20240404105119348&#34; /&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240414013121762.png&#34; alt=&#34;image-20240414013121762&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240414013128871.png&#34; alt=&#34;image-20240414013128871&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240414013136042.png&#34; alt=&#34;image-20240414013136042&#34; /&gt;&lt;/p&gt;
&lt;h3 id=&#34;后续计算机设计大赛&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#后续计算机设计大赛&#34;&gt;#&lt;/a&gt; 后续（计算机设计大赛）&lt;/h3&gt;
&lt;ul class=&#34;task-list&#34;&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_9&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_9&#34;&gt; &lt;strong&gt;数据集优化&lt;/strong&gt;，使之更符合自然语言 &amp;amp; 多样化 —&amp;gt; 微调 —&amp;gt; 生成回答数据集 —&amp;gt; 计算相似度&lt;br /&gt;
…&lt;/label&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_10&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_10&#34;&gt; 未微调过的模型 生成回答数据集 计算相似度 作为对比（前提是有&lt;strong&gt;高质量数据集&lt;/strong&gt;）&lt;br /&gt;
…&lt;/label&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_11&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_11&#34;&gt; &lt;strong&gt;加一个功能&lt;/strong&gt;：当用户查看我们网站的内容时，为了便于浏览，用户可以通过模型输入要搜索的内容，快速找到网站中的内容&lt;/label&gt;&lt;/p&gt;
&lt;p&gt;初步解决方法：问答的函数内，放一个函数，&lt;em&gt;实现:&lt;/em&gt; 先判断内容是否与网站内容有关，有则返回一个字符串 &amp;quot;您是否在查找这个 {网站链接}&amp;quot;，无则返回空。并拼接到此次回答中。&lt;/p&gt;
&lt;p&gt;此处的判断，&amp;quot;与… 有关联&amp;quot;。v1：用列表（优先级）+ 字典（键值对） [{&amp;quot;西湖&amp;quot;: &amp;quot;URL&amp;quot;}, ……]，对输入进行处理，输入包含的词是否在字典里&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_12&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_12&#34;&gt; &lt;strong&gt;加一个功能&lt;/strong&gt;：希望在问答中能回答制定精品路线，明确关键词（如 &amp;quot;两天&amp;quot;、&amp;quot;指定几个景点&amp;quot;）&lt;br /&gt;
…&lt;/label&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_13&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_13&#34;&gt; &lt;strong&gt;加一个语音输入&lt;/strong&gt;：讯飞 API&lt;/label&gt;&lt;/p&gt;
&lt;p&gt;借鉴了四五年前的项目 https://github.com/Ma-Tao007/xunfei-vioceAl-vueSDK.git&lt;/p&gt;
&lt;p&gt;没想到讯飞这么早就把语音转文字免费使用了吗（500 次 / 天）&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_14&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_14&#34;&gt; 加上调用&lt;strong&gt;天气&lt;/strong&gt; API&lt;/label&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_15&#34; checked=&#34;true&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_15&#34;&gt; &lt;strong&gt;代码重构&lt;/strong&gt;，去除 st&lt;br /&gt;
 没用到 st 的缓存什么的，只是用 st 显示，所以安全去除了&lt;/label&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_16&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_16&#34;&gt; 希望能&lt;strong&gt;联网&lt;/strong&gt;（查询一些网站）, 检索增强 RAG&lt;br /&gt;
 之前的痛点是如要查询旅游攻略，需要多方平台查询对比，且搜索引擎给出的链接繁多。&lt;br /&gt;
我们能做到联网，并统筹多方资讯，给出一个较优的回答。&lt;/label&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_17&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_17&#34;&gt; 增加天气、客流量等数据的（实时）&lt;strong&gt;数据可视化&lt;/strong&gt;&lt;/label&gt;&lt;/p&gt;
&lt;p&gt;……&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_18&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_18&#34;&gt; Groq 快速推理机制&lt;br /&gt;
…&lt;/label&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li class=&#34;task-list-item&#34;&gt;
&lt;p&gt;&lt;input type=&#34;checkbox&#34; id=&#34;cbx_19&#34; disabled=&#34;true&#34; /&gt;&lt;label for=&#34;cbx_19&#34;&gt; Phidata—AI 助手框架&lt;/label&gt;&lt;/p&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9naXRodWIuY29tL3BoaWRhdGFocS9waGlkYXRh&#34;&gt;https://github.com/phidatahq/phidata&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;img src=&amp;quot;image-20240428115123566.png&amp;quot; alt=&amp;quot;image-20240428115123566&amp;quot; style=&amp;quot;zoom:50%;&amp;quot; /&amp;gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;05/06 截止前&lt;/p&gt;
&lt;p&gt;老师认为还是太空了，技术也得讲，检索得讲，可以个例子，说 “岳庙” 就能知道指的是 “岳王庙”&lt;/p&gt;
&lt;hr /&gt;
&lt;h1 id=&#34;相关知识&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#相关知识&#34;&gt;#&lt;/a&gt; 相关知识&lt;/h1&gt;
&lt;h2 id=&#34;peft&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#peft&#34;&gt;#&lt;/a&gt; PEFT&lt;/h2&gt;
&lt;p&gt;PEFT（Parameter-Efficient Fine-Tuning）是 hugging face 开源的&lt;strong&gt;一个参数高效微调大模型的工具&lt;/strong&gt;，里面集成了 4 种微调大模型的方法，可以通过微调少量参数就达到接近微调全量参数的效果，使得在 GPU 资源不足的情况下也可以微调大模型。&lt;/p&gt;
&lt;h2 id=&#34;llama-factory&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#llama-factory&#34;&gt;#&lt;/a&gt; llama-factory&lt;/h2&gt;
&lt;p&gt;Unify Efficient Fine-Tuning of 100+ LLMs，GitHub 上的一个统筹了&lt;strong&gt;支持多种大语言模型微调的工具&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;项目特色&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;多种模型：LLaMA、LLaVA、Mistral、Mixtral-MoE、Qwen、Yi、Gemma、Baichuan、&lt;strong&gt;ChatGLM&lt;/strong&gt;、Phi 等等。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;集成方法：（增量）预训练、（多模态）指令监督微调（SFT）、奖励模型训练、PPO 训练、DPO 训练和 ORPO 训练。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;多种精度：32 比特全参数微调、16 比特冻结微调、16 比特 LoRA 微调和基于 AQLM/AWQ/GPTQ/LLM.int8 的 2/4/8 比特 QLoRA 微调。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;先进算法：GaLore、BAdam、DoRA、LongLoRA、LLaMA Pro、Mixture-of-Depths、&lt;strong&gt;LoRA+&lt;/strong&gt;、LoftQ 和 Agent 微调。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;实用技巧：FlashAttention-2、Unsloth、RoPE scaling、NEFTune 和 rsLoRA。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;实验监控：LlamaBoard、TensorBoard、Wandb、MLflow 等等。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;极速推理：基于 vLLM 的 OpenAI 风格 API、浏览器界面和命令行接口。&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;于是就用这个了&lt;/p&gt;
&lt;p&gt;链接 &lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9naXRodWIuY29tL2hpeW91Z2EvTExhTUEtRmFjdG9yeS9ibG9iL21haW4vUkVBRE1FX3poLm1k&#34;&gt;https://github.com/hiyouga/LLaMA-Factory/blob/main/README_zh.md&lt;/span&gt;&lt;/p&gt;
&lt;h2 id=&#34;微调&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#微调&#34;&gt;#&lt;/a&gt; 微调&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;微调不是为了准确的搜索数据库（Embeddings 才是）&lt;/strong&gt;，微调是为了修正一些向量的参数：比方说我想写一个短视频口播文案，同样是论证观点，口播并不会像写论文等书面文案一样用严格的格式让你理解逻辑结构，所以&lt;strong&gt;一般口播中就不会用首先其次再次这样的说法。那么我需要通过训练把这些词的权重降低。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;重点是&lt;strong&gt;方法&lt;/strong&gt;和&lt;strong&gt;高质量数据集&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;微调可以分为全微调和部分微调两个方法：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;全微调（Full Fine-tuning）：全微调是指对整个预训练模型进行微调，包括所有的模型参数。在这种方法中，预训练模型的所有层和参数都会被更新和优化，以适应目标任务的需求。这种微调方法通常适用于&lt;strong&gt;任务和预训练模型之间存在较大差异&lt;/strong&gt;的情况，或者&lt;strong&gt;任务需要模型具有高度灵活性和自适应能力&lt;/strong&gt;的情况。Full Fine-tuning 需要较大的计算资源和时间，但可以获得更好的性能。&lt;/li&gt;
&lt;li&gt;部分微调（Repurposing）：部分微调是指在微调过程中只更新模型的顶层或少数几层，而保持预训练模型的底层参数不变。这种方法的目的是在保留预训练模型的通用知识的同时，通过微调顶层来适应特定任务。Repurposing 通常适用于目标任务与预训练模型之间&lt;strong&gt;有一定相似性&lt;/strong&gt;的情况，或者&lt;strong&gt;任务数据集较小&lt;/strong&gt;的情况。由于只更新少数层，Repurposing 相对于 Full Fine-tuning 需要较少的计算资源和时间，但在某些情况下性能可能会有所降低。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;从另一层次看，微调预训练模型的方法：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;微调所有层：将预训练模型的所有层都参与微调，以适应新的任务。&lt;/li&gt;
&lt;li&gt;微调顶层：只微调预训练模型的顶层，以适应新的任务。&lt;/li&gt;
&lt;li&gt;冻结底层：将预训练模型的底层固定不变，只对顶层进行微调。&lt;/li&gt;
&lt;li&gt;逐层微调：从底层开始，逐层微调预训练模型，直到所有层都被微调。&lt;/li&gt;
&lt;li&gt;迁移学习：将预训练模型的知识迁移到新的任务中，以提高模型性能。这种方法通常使用微调顶层或冻结底层的方法。&lt;/li&gt;
&lt;/ol&gt;
&lt;h3 id=&#34;p-tuning和lora的区别&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#p-tuning和lora的区别&#34;&gt;#&lt;/a&gt; p-tuning 和 Lora 的区别&lt;/h3&gt;
&lt;h4 id=&#34;p-tuning&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#p-tuning&#34;&gt;#&lt;/a&gt; p-tuning&lt;/h4&gt;
&lt;p&gt;p-tuning v2 并不是一个新技术，而是之前用于少样本学习，少样本学习分为离散型模板和连续性模板，离散性模板主要是构建文字描述模板，而连续型模板则是插入连续型 token 构成的模板，之前文章中我也讲述了离散型和连续型两种 prompt 方法。&lt;/p&gt;
&lt;p&gt;p-tuning v2 简单来说其实是 soft prompt 的一种改进，soft prompt 是只作用在 embedding 层中，实际测试下来只作用在 embedding 层的话交互能力会变弱，而且冻结模型所有参数去学习插入 token，改变量偏小使得效果有时候不太稳定，会差于微调。p-tuning v2 则不只是针对 embedding 层，而是将连续型 token 插入每一层，增大改变量和交互性。&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240330185124412.png&#34; alt=&#34;image-20240330185124412&#34; /&gt;&lt;/p&gt;
&lt;p&gt;soft prompt 比较依靠模型参数量，在参数量超过 10B 的模型上，效果追上了 fine-tune，但是 ptuning v2 因为每层插入了 token，增大模型训练的改变量，&lt;strong&gt;更加适用于小一点的模型&lt;/strong&gt;&lt;/p&gt;
&lt;h4 id=&#34;lora&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#lora&#34;&gt;#&lt;/a&gt; Lora&lt;/h4&gt;
&lt;p&gt;Lora 主要在模型中注入可训练模块，大模型在预训练完收敛之后模型包含许多进行矩阵乘法的稠密层，这些层通常是满秩的，在微调过程中其实改变量是比较小的，在矩阵乘法中表现为低秩的改变，注入可训练层的目的是想下游微调的低秩改变由可训练层来学习，冻结模型其他部分，大大减少模型训练参数。&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240330185200220.png&#34; alt=&#34;image-20240330185200220&#34; /&gt;&lt;/p&gt;
&lt;p&gt;推理计算的时候，因为没有改变预训练权重，所以换不同的下游任务时，lora 模型保存的权重也是可以相应加载进来的，通过矩阵分解的方法参数量减少了很多，且推理时可以并行，对于推理性能并没有增加多少负担，算是比较好的低资源微调方法。&lt;/p&gt;
&lt;h5 id=&#34;low-rank-adaptation低秩适配&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#low-rank-adaptation低秩适配&#34;&gt;#&lt;/a&gt; &lt;s&gt;Low-rank Adaptation 低秩适配:&lt;/s&gt;&lt;/h5&gt;
&lt;p&gt;&lt;s&gt;低秩适配方法致力于将模型权重的改变限制在一个&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly93d3cuemhpaHUuY29tL3NlYXJjaD9xPSVFNCVCRCU4RSVFNyVBNyVBOSVFNSVBRCU5MCVFNyVBOSVCQSVFOSU5NyVCNCZhbXA7c2VhcmNoX3NvdXJjZT1FbnRpdHkmYW1wO2h5YnJpZF9zZWFyY2hfc291cmNlPUVudGl0eSZhbXA7aHlicmlkX3NlYXJjaF9leHRyYT0lN0IlMjJzb3VyY2VUeXBlJTIyJTNBJTIyYW5zd2VyJTIyJTJDJTIyc291cmNlSWQlMjIlM0EzMzcwNjU2MTQ3JTdE&#34;&gt;低秩子空间&lt;/span&gt;内。这通常涉及对模型的权重矩阵进行分解，只微调其中的一小部分参数。这样可以有效减少计算资源的消耗，同时仍然允许模型有足够的灵活性来学习新任务。&lt;strong&gt;LoRA&lt;/strong&gt; 和它的变种，如 Q-LoRA、Delta-LoRA、LoRA-FA 等，都属于这个类别。&lt;/s&gt;&lt;/p&gt;
&lt;h4 id=&#34;总结&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#总结&#34;&gt;#&lt;/a&gt; 总结&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;共同点&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;两者对于低资源微调大模型的&lt;strong&gt;都是冻结大模型参数&lt;/strong&gt;，通过小模块来学习微调产生的低秩改变。但目前存在的一些问题就是这两种训练方式很容易参数&lt;strong&gt;灾难性遗忘&lt;/strong&gt;，因为模型在微调的时候整个模型层参数未改变，而少参数的学习模块微调时却是改变量巨大，容易给模型在推理时产生较大偏置，使得以前的回答能力被可学习模块带偏，在微调的时候也必须注意可学习模块不能过于拟合微调数据，否则会丧失原本的预训练知识能力，产生灾难性遗忘。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;最好能够在微调语料中也加入通用学习语料一起微调，避免产生对微调语料极大的偏向&lt;/strong&gt;，在 instruct gpt 论文中也提到在强化学习 ppo 的时候模型也会很容易对于 ppo 数据拟合，降低模型通用自然语言任务能力，所以在 ppo loss 中加入了 SFT 梯度和预训练梯度来缓解这种遗忘问题。&lt;/p&gt;
&lt;hr /&gt;
&lt;p&gt;&lt;strong&gt;区别&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;LoRA（Low-Rank Adaptation）&lt;/strong&gt;：LoRA 是一种高效的参数微调技术，旨在&lt;strong&gt;解决过拟合&lt;/strong&gt;问题。它通过增加一个参数来调整模型中的知识级别，使其更好地适应特定任务。虽然不需要大量带标签的数据，&lt;strong&gt;但可能需要更多的计算资源&lt;/strong&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;P-tuning v2&lt;/strong&gt;：P-tuning v2 是一种改进的微调方法，它通过使用预训练模型的一部分来进行微调，而不是使用整个预训练模型。这种方法可以减少计算需求，同时提高模型性能。然而，&lt;strong&gt;P-tuning v2 可能需要更精细的参数调整&lt;/strong&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;如果你有大量标注数据，&lt;strong&gt;SFT&lt;/strong&gt;（Standard Fine-Tuning） 可能是更好的选择。对于半监督学习场景，&lt;strong&gt;LoRA&lt;/strong&gt; 可能更适合。而对于防止过拟合和轻量级微调场景，&lt;strong&gt;Freeze&lt;/strong&gt; 可能更合适。请根据你的需求选择最适合的方法，以优化你的模型性能。（来自 copilot）&lt;/p&gt;
&lt;h3 id=&#34;fine-tune-a-mistral-7b-model-with-direct-preference-optimization&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#fine-tune-a-mistral-7b-model-with-direct-preference-optimization&#34;&gt;#&lt;/a&gt; &lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly90b3dhcmRzZGF0YXNjaWVuY2UuY29tL2ZpbmUtdHVuZS1hLW1pc3RyYWwtN2ItbW9kZWwtd2l0aC1kaXJlY3QtcHJlZmVyZW5jZS1vcHRpbWl6YXRpb24tNzA4MDQyNzQ1YWFj&#34;&gt;Fine-tune a Mistral-7b model with Direct Preference Optimization&lt;/span&gt;&lt;/h3&gt;
&lt;p&gt;&lt;em&gt;hugging face 上某一榜上前三提供的一种微调方法，前提：已经经过监督式微调的模型 + 高质量偏好数据集，不知道能不能学习一下&lt;/em&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# 以下是作者提供的参数
# LoRA configuration
peft_config = LoraConfig(
    r=16,
    lora_alpha=16,
    lora_dropout=0.05,
    bias=&amp;quot;none&amp;quot;,
    task_type=&amp;quot;CAUSAL_LM&amp;quot;,
    target_modules=[&#39;k_proj&#39;, &#39;gate_proj&#39;, &#39;v_proj&#39;, &#39;up_proj&#39;, &#39;q_proj&#39;, &#39;o_proj&#39;, &#39;down_proj&#39;]
)

# Training arguments
training_args = TrainingArguments(
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    gradient_checkpointing=True,
    learning_rate=5e-5,
    lr_scheduler_type=&amp;quot;cosine&amp;quot;,
    max_steps=200,
    save_strategy=&amp;quot;no&amp;quot;,
    logging_steps=1,
    output_dir=new_model,
    optim=&amp;quot;paged_adamw_32bit&amp;quot;,
    warmup_steps=100,
    bf16=True,
    report_to=&amp;quot;wandb&amp;quot;,
)

# Create DPO trainer
dpo_trainer = DPOTrainer(
    model,
    ref_model,
    args=training_args,
    train_dataset=dataset,
    tokenizer=tokenizer,
    peft_config=peft_config,
    beta=0.1,
    max_prompt_length=1024,
    max_length=1536,
)

# Fine-tune model with DPO
dpo_trainer.train()
&lt;/code&gt;&lt;/pre&gt;
&lt;h4 id=&#34;学习率的重要性&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#学习率的重要性&#34;&gt;#&lt;/a&gt; &lt;strong&gt;学习率的重要性&lt;/strong&gt;&lt;/h4&gt;
&lt;p&gt;目前深度学习使用的都是非常简单的一阶收敛算法，梯度下降法，不管有多少自适应的优化算法，本质上都是对梯度下降法的各种变形，所以初始学习率对深层网络的收敛起着决定性的作用，下面就是梯度下降法的公式&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240402154527727.png&#34; alt=&#34;image-20240402154527727&#34; /&gt;&lt;/p&gt;
&lt;p&gt;这里 α 就是学习率，如果学习率太小，会导致网络 loss 下降非常慢，如果学习率太大，那么参数更新的幅度就非常大，就会导致网络收敛到局部最优点，或者 loss 直接开始增加，如下图所示。&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;v2-6f1772cefad4befccd3e6cfd83b1fbfd_720w.webp&#34; alt=&#34;img&#34; /&gt;&lt;/p&gt;
&lt;h3 id=&#34;大模型微调步骤&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#大模型微调步骤&#34;&gt;#&lt;/a&gt; 大模型微调步骤&lt;/h3&gt;
&lt;p&gt;大模型微调如上文所述有很多方法，并且对于每种方法都会有不同的微调流程、方式、准备工作和周期。然而大部分的大模型微调，都有以下几个主要步骤，并需要做相关的准备：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;准备数据集&lt;/strong&gt;：收集和准备与目标任务相关的训练数据集。确保数据集质量和标注准确性，并进行必要的数据清洗和预处理。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;选择预训练模型 / 基础模型&lt;/strong&gt;：根据目标任务的性质和数据集的特点，选择适合的预训练模型。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;设定微调策略&lt;/strong&gt;：根据任务需求和可用资源，选择适当的微调策略。考虑是进行全微调还是部分微调，以及微调的层级和范围。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;设置超参数&lt;/strong&gt;：确定微调过程中的超参数，如学习率、批量大小、训练轮数等。这些超参数的选择对微调的性能和收敛速度有重要影响。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;初始化模型参数&lt;/strong&gt;：根据预训练模型的权重，初始化微调模型的参数。对于全微调，所有模型参数都会被随机初始化；对于部分微调，只有顶层或少数层的参数会被随机初始化。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;进行微调训练&lt;/strong&gt;：使用准备好的数据集和微调策略，对模型进行训练。在训练过程中，根据设定的超参数和优化算法，逐渐调整模型参数以最小化&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly93d3cuemhpaHUuY29tL3NlYXJjaD9xPSVFNiU4RCU5RiVFNSVBNCVCMSVFNSU4NyVCRCVFNiU5NSVCMCZhbXA7c2VhcmNoX3NvdXJjZT1FbnRpdHkmYW1wO2h5YnJpZF9zZWFyY2hfc291cmNlPUVudGl0eSZhbXA7aHlicmlkX3NlYXJjaF9leHRyYT0lN0IlMjJzb3VyY2VUeXBlJTIyJTNBJTIyYW5zd2VyJTIyJTJDJTIyc291cmNlSWQlMjIlM0EzMzcwNjU2MTQ3JTdE&#34;&gt;损失函数&lt;/span&gt;。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;模型评估和调优&lt;/strong&gt;：在训练过程中，使用验证集对模型进行定期评估，并根据评估结果调整超参数或微调策略。这有助于提高模型的性能和泛化能力。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;测试模型性能&lt;/strong&gt;：在微调完成后，使用测试集对最终的微调模型进行评估，以获得最终的性能指标。这有助于评估模型在实际应用中的表现。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;模型部署和应用&lt;/strong&gt;：将微调完成的模型部署到实际应用中，并进行进一步的优化和调整，以满足实际需求。&lt;/li&gt;
&lt;/ol&gt;
&lt;h4 id=&#34;使用llama-factory示例&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#使用llama-factory示例&#34;&gt;#&lt;/a&gt; 使用 LLaMA-Factory 示例&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;数据集准备&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;按照要求 LLaMA-Factory\data\README_zh.md 里的格式准备好数据集，格式的话，可以在生成时就按照特定格式生成，也可以后期写脚本修改成需要的格式&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;在 LLaMA-Factory\data\dataset_info.json 把该数据集配置好 需要使用 SHA1 码。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;certutil -hashfile &amp;lt;filename&amp;gt; SHA1 # 查看SHA1码
&lt;/code&gt;&lt;/pre&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;训练&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;启动 LLaMA-Factory 的 webUI&lt;/li&gt;
&lt;li&gt;设置好参数（参数可以参考下面文档调）&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;模型评估&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;训练结果好与坏可以从给出的 loss 函数来看，不震荡、收敛到 1 左右的就还行&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;模型调用&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;可以在 webUI 的 chat 部分加载，把训练好的适配器加上后，即可调用。缺点是貌似有 bug，有时候会出现 assistant、自问自答等情况&lt;/p&gt;
&lt;p&gt;也可以导出模型，使用 chatglm 文件夹下的 demo 启动的话，缺点是导出耗时&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;h3 id=&#34;调参&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#调参&#34;&gt;#&lt;/a&gt; 调参&lt;/h3&gt;
&lt;p&gt;以下是 LLaMA-Factory 里，可以修改的大部分参数&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240429130319802.png&#34; alt=&#34;image-20240429130319802&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240429130430005.png&#34; alt=&#34;image-20240429130430005&#34; /&gt;&lt;/p&gt;
&lt;h4 id=&#34;训练阶段sft&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#训练阶段sft&#34;&gt;#&lt;/a&gt; 训练阶段（SFT…）&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;SFT&lt;/p&gt;
&lt;p&gt;监督微调&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;DPO&lt;/p&gt;
&lt;p&gt;直接偏好微调，一个问题 X 多个回答（优质、劣质）&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;…&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id=&#34;学习率&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#学习率&#34;&gt;#&lt;/a&gt; 学习率&lt;/h4&gt;
&lt;p&gt;数值举例：5e-5 的计算是&lt;strong&gt;科学计数法&lt;/strong&gt;中的一个数值，即 5 乘以 10 的负 5 次方，即 0.00005&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th style=&#34;text-align:center&#34;&gt;&lt;/th&gt;
&lt;th style=&#34;text-align:center&#34;&gt;学习率过大&lt;/th&gt;
&lt;th style=&#34;text-align:center&#34;&gt;学习率过小&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td style=&#34;text-align:center&#34;&gt;学习速度&lt;/td&gt;
&lt;td style=&#34;text-align:center&#34;&gt;快&lt;/td&gt;
&lt;td style=&#34;text-align:center&#34;&gt;慢&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td style=&#34;text-align:center&#34;&gt;使用时间点&lt;/td&gt;
&lt;td style=&#34;text-align:center&#34;&gt;训练开始&lt;/td&gt;
&lt;td style=&#34;text-align:center&#34;&gt;一定轮数&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td style=&#34;text-align:center&#34;&gt;副作用&lt;/td&gt;
&lt;td style=&#34;text-align:center&#34;&gt;易损失值爆炸；易震荡&lt;/td&gt;
&lt;td style=&#34;text-align:center&#34;&gt;易过拟合；收敛速度慢&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;&lt;img data-src=&#34;v2-c1c72c00c93f778ad91cefb6c8a8665d_720w.webp&#34; alt=&#34;img&#34; /&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;曲线 初始时 上扬 【红线】：&lt;br /&gt;
Solution：初始 学习率过大 导致 振荡，应减小学习率，并 从头 开始训练 。&lt;/li&gt;
&lt;li&gt;曲线 初始时 强势下降 没多久 归于水平 【紫线】：&lt;br /&gt;
Solution：后期 学习率过大 导致 无法拟合，应减小学习率，并 重新训练 后几轮 。&lt;/li&gt;
&lt;li&gt;曲线 全程缓慢 【黄线】：&lt;br /&gt;
Solution：初始 学习率过小 导致 收敛慢，应增大学习率，并 从头 开始训练 。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;参考链接：&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9saW5rLnpoaWh1LmNvbS8/dGFyZ2V0PWh0dHBzJTNBLy9ibG9nLmNzZG4ubmV0L3FxXzMzNDg1NDM0L2FydGljbGUvZGV0YWlscy84MDQ1Mjk0MQ==&#34;&gt;深度学习：学习率 learning rate 的设定规律&lt;/span&gt;&lt;/p&gt;
&lt;h4 id=&#34;epochs训练轮数&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#epochs训练轮数&#34;&gt;#&lt;/a&gt; Epochs 训练轮数&lt;/h4&gt;
&lt;p&gt;目前智旅项目的轮数都是在 3~24 轮。跟学习率、数据集等有关。轮数过多会过拟合。&lt;/p&gt;
&lt;h4 id=&#34;最大梯度范数&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#最大梯度范数&#34;&gt;#&lt;/a&gt; 最大梯度范数&lt;/h4&gt;
&lt;p&gt;梯度是指损失函数对模型参数的偏导数，它表示了模型在当前参数值下的变化方向和速度。通过限制梯度的最大范数，可以控制模型参数的更新幅度，防止梯度爆炸（gradient explosion）或梯度消失（gradient vanishing）&lt;/p&gt;
&lt;p&gt;例如前面我们学的学习率，你设置一个较大的值，那极可能会梯度爆炸，你会看到曲线过山车一样！所以这个参数可以一定程度上减少这种情况！&lt;strong&gt;一般默认 1&lt;/strong&gt;。&lt;/p&gt;
&lt;h4 id=&#34;梯度累积&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#梯度累积&#34;&gt;#&lt;/a&gt; 梯度累积&lt;/h4&gt;
&lt;p&gt;梯度累积允许我们将多个小批次的梯度相加，然后再进行参数更新。梯度累积对于具有较大批大小的模型或具有较小 GPU 显存的情况特别有用&lt;/p&gt;
&lt;p&gt;这相当于让大模型去学习，如果一边学，一边把之前所学进行总结，通常比较累，而且需要消耗的显存也越大。如果让大模型看了 10 页书之后再总结，是不是学得更轻松些？占用的显存资源也少了。！但也会导致训练速度变慢。&lt;/p&gt;
&lt;h4 id=&#34;计算类型fp16&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#计算类型fp16&#34;&gt;#&lt;/a&gt; 计算类型（FP16…）&lt;/h4&gt;
&lt;p&gt;&lt;s&gt;FP16 是 16 位浮点数数据类型，相比于传统的 32 位浮点数（FP32），它可以减少一半的存储空间和计算开销。在混合精度训练中，模型参数和梯度可以使用 FP16 进行计算和存储，从而减少内存占用和计算时间。然而，由于 FP16 的精度较低，可能会引入一些数值精度损失，导致训练过程中的数值不够准确&lt;/s&gt;&lt;/p&gt;
&lt;p&gt;&lt;s&gt;BF16 是一种更为近似于 FP32 的 16 位浮点数数据类型。相比于 FP16，BF16 在保持较低的存储和计算开销的同时，提供了更接近 FP32 的数值精度。因此，BF16 在混合精度训练中可以更好地平衡计算效率和数值精度。&lt;/s&gt;&lt;/p&gt;
&lt;p&gt;&lt;s&gt;有些模型会有推荐训练方法，你只需要知道什么回事即可，默认 FP16&lt;/s&gt;&lt;/p&gt;
&lt;h4 id=&#34;截断长度&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#截断长度&#34;&gt;#&lt;/a&gt; 截断长度&lt;/h4&gt;
&lt;p&gt;一条数据分词后会成为一个 token 序列，当 token 序列的长度超过截断长度时会被分割成若干段输入进模型，这里保持 1024 不变&lt;/p&gt;
&lt;h4 id=&#34;batch-size批处理大小&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#batch-size批处理大小&#34;&gt;#&lt;/a&gt; &lt;strong&gt;Batch size&lt;/strong&gt; (批处理大小)&lt;/h4&gt;
&lt;p&gt;一般来说，在合理的范围之内，&lt;strong&gt;越大的 batch size&lt;/strong&gt; 使下降方向越准确，震荡越小；batch size 如果过大，则可能会出现局部最优的情况（这也是其中的一个缺点吧）。&lt;strong&gt;小的 bath size&lt;/strong&gt; 引入的随机性更大，难以达到收敛，极少数情况下可能会效果变好。&lt;/p&gt;
&lt;p&gt;会影响训练的稳定性，Batch size 过小会使 Loss 曲线振荡的比较大，大小一般按照 2 的次幂规律选择，这是为了硬件计算效率考虑的。&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412092213348.png&#34; alt=&#34;image-20240412092213348&#34; /&gt;&lt;/p&gt;
&lt;p&gt;（此处问题可能 batch size 太小了（如果学习率问题不大的话））&lt;/p&gt;
&lt;p&gt;考虑到我们的显卡，一般设置在 2~8 之间&lt;/p&gt;
&lt;h4 id=&#34;验证集比例&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#验证集比例&#34;&gt;#&lt;/a&gt; 验证集比例&lt;/h4&gt;
&lt;p&gt;一般设置成 0.2&lt;/p&gt;
&lt;h4 id=&#34;学习率调节器&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#学习率调节器&#34;&gt;#&lt;/a&gt; 学习率调节器&lt;/h4&gt;
&lt;p&gt;使用默认的 cosine&lt;/p&gt;
&lt;h4 id=&#34;其他参数&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#其他参数&#34;&gt;#&lt;/a&gt; 其他参数&lt;/h4&gt;
&lt;p&gt;……&lt;/p&gt;
&lt;h4 id=&#34;部分参数&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#部分参数&#34;&gt;#&lt;/a&gt; 部分参数&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;可训练层数&lt;/p&gt;
&lt;p&gt;……&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;可训练模块&lt;/p&gt;
&lt;p&gt;……&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id=&#34;lora参数设置&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#lora参数设置&#34;&gt;#&lt;/a&gt; LoRA 参数设置&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;LoRA 秩&lt;/p&gt;
&lt;p&gt;一般为 8，是缩放系数的一半&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;LoRA 缩放系数&lt;/p&gt;
&lt;p&gt;一般为 16&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;随机丢弃&lt;/p&gt;
&lt;p&gt;一般设置成 0.1&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h4 id=&#34;loss-损失函数&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#loss-损失函数&#34;&gt;#&lt;/a&gt; loss 损失函数&lt;/h4&gt;
&lt;p&gt;train loss 不断下降，test loss 不断下降，说明网络仍在学习；&lt;/p&gt;
&lt;p&gt;train loss 不断下降，test loss 趋于不变，说明网络过拟合；&lt;/p&gt;
&lt;p&gt;train loss 趋于不变，test loss 不断下降，说明数据集 100% 有问题；&lt;/p&gt;
&lt;p&gt;train loss 趋于不变，test loss 趋于不变，说明学习遇到瓶颈，需要减小学习率或批量数目；&lt;/p&gt;
&lt;p&gt;train loss 不断上升，test loss 不断上升，说明网络结构设计不当，训练超参数设置不当，数据集经过清洗等问题。&lt;/p&gt;
&lt;h4 id=&#34;top-p采样-temperature温度&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#top-p采样-temperature温度&#34;&gt;#&lt;/a&gt; top-p 采样 /temperature 温度&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;temperature  官网解释&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. We generally recommend altering this or top_p but not both.&lt;/p&gt;
&lt;p&gt;翻译：“采样温度” 是在 0 到 2 之间选择的参数。较高的值（如 0.8）会使输出更具随机性，而较低的值（如 0.2）则会使输出更集中，更确定性。通常，我们建议修改 “采样温度” 或 “top_p” 其中之一，而不是同时修改两者。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;top-p 采样 官网解释&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass. So 0.1 means only the tokens comprising the top 10% probability mass are considered.&lt;/p&gt;
&lt;p&gt;翻译：&amp;quot;nucleus sampling&amp;quot;（核采样或者叫做 top-p 采样）是一个替代温度采样的方法，其中模型考虑了具有 top_p 概率质量的 token 的结果。因此，0.1 表示只考虑包含在最高 10% 概率质量中的 token。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;总结&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&amp;quot;temperature&amp;quot; 影响了结果的随机性，而 &amp;quot;top_p&amp;quot; 则影响了结果的确定性。但他们是从不同的角度影响输出的：temperature 更偏向于控制输出的 “随机性”，而 top-p 则是在给定的可能结果中设定一个 “阈值”。&lt;/p&gt;
&lt;h3 id=&#34;文本相似度&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#文本相似度&#34;&gt;#&lt;/a&gt; 文本相似度&lt;/h3&gt;
&lt;p&gt;为了&lt;strong&gt;评估&lt;/strong&gt;我们微调后的效果，我们引入&lt;strong&gt;文本相似度&lt;/strong&gt;，而使用&lt;strong&gt;余弦相似度&lt;/strong&gt;来判断文本相似度高与否&lt;/p&gt;
&lt;p&gt;初步实现：jieba 分词 + 余弦相似度 + numpy 处理 + matplotlib.pyplot 画图&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;	# 计算平均值
    average = sum(data) / len(data)
    # 输出结果
    print(&amp;quot;平均值为:&amp;quot;, average)

    # 生成示例数据，假设这是余弦相似度的一些值
    cosine_similarities = data  # 生成1000个随机余弦相似度值，范围在0到1之间

    # 统计相似度值的频率分布
    bins = np.linspace(0, 1, 50)  # 将x轴分为50个区间
    hist, bins = np.histogram(cosine_similarities, bins=bins)

    # 绘制频率分布图
    plt.bar(bins[:-1], hist, width=(bins[1] - bins[0]), align=&#39;edge&#39;)
    plt.xlabel(&amp;quot;余弦相似度&amp;quot;)
    plt.ylabel(&amp;quot;数量&amp;quot;)
    plt.title(&amp;quot;余弦相似度的频率分布图&amp;quot;)
    plt.show()
&lt;/code&gt;&lt;/pre&gt;
&lt;h3 id=&#34;langchain-agentchatglm-6b-本地知识库联网检索能力&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#langchain-agentchatglm-6b-本地知识库联网检索能力&#34;&gt;#&lt;/a&gt; [LangChain Agent] ChatGLM-6B + 本地知识库 + 联网检索能力&lt;/h3&gt;
&lt;h4 id=&#34;agent&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#agent&#34;&gt;#&lt;/a&gt; Agent&lt;/h4&gt;
&lt;p&gt;** 什么是 Agent？** 简单讲 Agent 利用 LLM 的理解推理能力来简化原本十分复杂的逻辑判断，决定什么问题由什么工具来解决，最后汇总成一个 “答案” 返回给用户。&lt;/p&gt;
&lt;p&gt;LangChain 把这个过程用一个非常经典的 Prompt 模板定义了出来，这个模板中包括四个环节：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Thought（LLM 的思考过程和决定）&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Action（要采取的行动以及要给他的输入）&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Observation（执行 Action 后预计的输出结果）&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Tools（Action 行动的调用函数）&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;prompt 示例&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240504123333424.png&#34; alt=&#34;image-20240504123333424&#34; /&gt;&lt;/p&gt;
&lt;h4 id=&#34;rag检索增强&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#rag检索增强&#34;&gt;#&lt;/a&gt; RAG 检索增强&lt;/h4&gt;
&lt;p&gt;……&lt;/p&gt;
&lt;h4 id=&#34;无头浏览器&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#无头浏览器&#34;&gt;#&lt;/a&gt; &lt;s&gt;无头浏览器&lt;/s&gt;&lt;/h4&gt;
&lt;p&gt;……&lt;/p&gt;
&lt;h1 id=&#34;引用&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#引用&#34;&gt;#&lt;/a&gt; 引用：&lt;/h1&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly93d3cuemhpaHUuY29tL3F1ZXN0aW9uLzYzODgwMzQ4OC9hbnN3ZXIvMzM3MDY1NjE0Nw==&#34;&gt;初学者如何对大模型进行微调？ - 爱吃牛油果的璐璐的回答 - 知乎&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzM3NTc0MTg3L2FydGljbGUvZGV0YWlscy8xMzEyNDE4OTI=&#34;&gt;p-tuning 和 Lora 的区别_ptuning 和 lora 对比 - CSDN 博客&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly90b3dhcmRzZGF0YXNjaWVuY2UuY29tL2ZpbmUtdHVuZS1hLW1pc3RyYWwtN2ItbW9kZWwtd2l0aC1kaXJlY3QtcHJlZmVyZW5jZS1vcHRpbWl6YXRpb24tNzA4MDQyNzQ1YWFj&#34;&gt;Fine-tune a Mistral-7b model with Direct Preference Optimization | by Maxime Labonne | Towards Data Science&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly96aHVhbmxhbi56aGlodS5jb20vcC80MjAwNTM4MzE=&#34;&gt;loss 问题汇总（不收敛、震荡、nan） - 知乎 (zhihu.com)&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly96aHVhbmxhbi56aGlodS5jb20vcC82NjM0ODMxODk=&#34;&gt;2023 - 全网首个 (Q) Lora 微调大模型指令说明书！收藏就对了！45 天玩转大模型微调 + 知识库落地！8/45 - 知乎 (zhihu.com)&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09ubHlfQVIvYXJ0aWNsZS9kZXRhaWxzLzEzNzE0ODk1MA==&#34;&gt;LLaMA Factory+ModelScope 实战 —— 使用 Web UI 进行监督微调_modalscope webui 不能启动 - CSDN 博客&lt;/span&gt;&lt;/p&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly96aHVhbmxhbi56aGlodS5jb20vcC82MzU3MjQ3MDcjJUU0JUJBJThDJUVGJUJDJTg5QWdlbnRfJUU1JTkyJThDX0NoYXRHTE0=&#34;&gt;定制基于 ChatGLM-6B 的本地知识库 + 联网检索能力的 LangChain Agent - 知乎 (zhihu.com)&lt;/span&gt;&lt;/p&gt;
</content>
        <category term="AI" />
        <updated>2024-03-22T07:01:23.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2024/02/12/supervised-learing-part01/</id>
        <title>supervised learing part01</title>
        <link rel="alternate" href="http://example.com/2024/02/12/supervised-learing-part01/"/>
        <content type="html">&lt;p&gt;监督式机器学习与非监督式机器学习&lt;/p&gt;
&lt;p&gt;1. 监督学习&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;1.1 回归 regression&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;1.2 分类 classification&lt;/p&gt;
&lt;p&gt;Age 和 Tumor Size 可以当做是维度，可以引入 n 维，并可以找到这 n 维度下的 O 和 X 的边界&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240212112345431.png&#34; alt=&#34;image-20240212112345431&#34; /&gt;&lt;/p&gt;
&lt;p&gt;2. 非监督学习&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;聚类算法 clustering&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240212120641463.png&#34; alt=&#34;image-20240212120641463&#34; /&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
</content>
        <category term="机器学习" />
        <updated>2024-02-12T03:05:35.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2024/02/11/Long-term-Memory/</id>
        <title>Long-term Memory-机器学习01</title>
        <link rel="alternate" href="http://example.com/2024/02/11/Long-term-Memory/"/>
        <content type="html">&lt;p&gt;想了解一下如何实现 GLM 的长记忆，以实现像 neuro 那样的长记忆功能。&lt;/p&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly95dWxsZXlpLm1lZGl1bS5jb20vbGFyZ2UtbGFuZ3VhZ2UtbW9kZWxzLWxsbS13aXRoLWxvbmctdGVybS1tZW1vcnktYWR2YW5jZW1lbnRzLWFuZC1vcHBvcnR1bml0aWVzLWluLWdlbmFpLWZjYzM1OTBmMWMwZQ==&#34;&gt;AI has a long-term memory problem (how to make neural networks less forgetful)&lt;/span&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;

“虽然像OpenAI的GPT这样的AI模型被训练了数十亿条数据，但它们不会记住你向它们展示的任何东西，甚至不会记住它们向你返回的任何东西，”Pinecone的创始人兼首席执行官Edo Liberty说道。“AI模型是无状态的。它们没有记忆。”

显然，“如果你无法回忆起任何东西，记忆就是无用的，”Liberty说。

在生成AI上下文和范围的局限性
今天许多领先的AI系统都是循环神经网络（RNNs）。这种深度学习方法使用过去的信息来提高对当前和未来输入的性能。其中最常用的之一是长短期记忆（LSTM）模型。

这些模型可以处理顺序信息，并保留一定数量的先前输入的上下文以处理下一个输入，CELUS战略发展合伙人兼联合创始人André Alcalde解释道。

“你可以考虑在处理句子中的单词时，这对你有多有用，”他说道。

例如，你可能有些单词是从先前的单词中引用的，所以这个模型能够保持对有限数量的输入的理解。

但这是关于LSTM模型的关键词：它们是有限的。

简单来说，“神经网络通常是健忘的，”Gartner分析师Erick Brethenoux说道。

他们“记住”了以前训练会话中的信息，并在短时间内将其考虑在内，他说。当新的训练信息进入时，模型将识别它之前见过和未见过的内容，并利用它来适应和修改。

但是，如果它看到了某些东西，然后在下一个会话中没有看到它——或者在那之后的会话中也没有看到它——模型将忘记该信息。在某种意义上，模型正在考虑：“在[当前会话]之前要记住多少个会话？”

Alcalde还指出，LSTM——以及RNNs一般——在实际应用中可能会遇到一些问题，比如训练过程中的指数（或消失）梯度、长时间的训练期和计算内存效率低下。

“要将少量数据存储在神经网络内存中，您可能需要训练大量参数，”他解释道。

更长期的AI记忆模型
Alcalde表示，长期记忆模型可以通过使用注意力增强的LSTM或具有注意力机制的新的神经网络架构来解决这些问题。这使得模型能够更好地关注重要的上下文信息，并将其视为更重要的信息。

因此，长期记忆能够更长时间地保留上下文信息，并以更节省内存的方式进行操作，从而节省计算资源，他说。这为语言模型和翻译任务提供了更好的性能，因为它们可以更好地理解正在处理的文本的上下文。

“就像人类保持长期记忆一样，[模型]可以捕获并保留几个月甚至几年的上下文，”Alcalde说道。

为了提高这种能力，例如，一组研究人员最近提出了他们所谓的“主动长期记忆网络”。他们将其描述为“一种能够在学习新知识的同时保持先前学习到的感官输入和行为输出之间关联的序列多任务深度学习模型”。

他们写道，“在人工神经网络中进行持续学习时，当顺序学习不同任务时会出现干扰和遗忘。”

增强AI记忆的矢量数据库的力量
提高AI记忆的另一种工具是矢量数据库。

正如Pinecone的Liberty所解释的，AI应用依赖于理解自然语言或图像等输入的模型。就像大脑使用化学或电神经信号传递信息一样，AI模型将它们对您展示的任何东西的理解编码为称为矢量嵌入的数字格式。

但是，他说，传统的关系数据库不设计存储和搜索矢量嵌入；AI模型需要一个专门的数据库——矢量数据库——它允许开发人员搜索“这些记忆”以找到最相关的内容，Liberty说。

矢量数据库存储大量的嵌入和相关元数据，例如标签或原始用户输入。然后，它使用算

法对这些嵌入进行索引以进行快速检索。然后，当给定一个查询（也是嵌入的形式）时，它会迅速返回最相关的结果。

“这其中的美妙之处在于搜索是通过含义而不是精确匹配完成的，因此您不需要在数据库中有任何与查询完全匹配的内容才能获得有用的答案，”Liberty说。

应用含义和上下文
Liberty表示，矢量数据库试图解决的基本问题有两个。第一个是搜索应用中缺乏意义。他指出，几十年来，工具一直依赖于将查询中的关键字与数据库中的关键字匹配。

他描述的第二个问题——他将其描述为“最近的但更痛苦的”问题，因为它阻止组织实施像ChatGPT这样的高级工具——是缺乏上下文。

“ChatGPT之类的解决方案可以解释和生成语言，但它生成的答案并不总是正确的，”他说道。这是一种被称为“幻觉”的现象。

矢量数据库可以通过让工程师构建应用程序，该应用程序搜索嵌入而不是原始文本来解决搜索应用程序中缺乏意义的问题。这种语义搜索可以产生显著更好的结果，Liberty说。

他说：“在搜索应用程序或推荐系统中，这意味着更满意的用户。”“在安全系统中，这意味着更好地检测威胁。”

与此同时，矢量数据库通过让工程师存储和发现相关上下文，并将其与原始输入/问题一起提供给AI模型来解决缺乏上下文的问题。然后，AI模型将基于其对语言的理解以及“超相关”信息生成对问题的答案。

“AI总是会给出答案，但不总是正确的，”他说。“当您将AI模型与用于长期记忆的矢量数据库相结合时，它会给出正确的答案。”

人类化行为——而不是人类的替代品
最终，长期记忆可以推动AI模型朝着更像人类行为的学习路径发展，Alcalde说。

例如，它们可以从自己的互动中学习；记住并仅应用“消耗”的书籍、新闻、音频和视频中的重要信息块；并且具有参考这些内容的能力。

但是，Brethenoux说，前进的道路应该是具有“混合学习能力”的人与机器结合。

Gartner提出了一个高级概念，称为“复合AI”或“混合AI”。这是“将不同的AI技术结合应用以提高学习效率，扩展知识表示水平，并最终以更有效的方式解决更广泛的业务问题。”

Brethenoux指出，自然，人类有长期记忆，并且我们的大脑利用抽象、感知和上下文来做出决策。正如他所说，机器应该给我们提供一些我们可以解释和行动的东西，以共生的方式。

“我希望我们不仅仅是为了自动化事物，也不仅仅是将事物呈现给人类，而是要找到更好的方法来增强智能，”他说。
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;[Large Language Models (LLM) with Long-Term Memory: Advancements and Opportunities in GenAI Applications](&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly93d3cuc2R4Y2VudHJhbC5jb20vYXJ0aWNsZXMvYW5hbHlzaXMvYWktaGFzLWEtbG9uZy10ZXJtLW1lbW9yeS1wcm9ibGVtLWhvdy10by1tYWtlLW5ldXJhbC1uZXR3b3Jrcy1sZXNzLWZvcmdldGZ1bC8yMDIzLzAzLw==&#34;&gt;AI has a long-term memory problem (how to make neural networks less forgetful) - SDxCentral&lt;/span&gt;)&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;导论
大型语言模型（LLMs）是在大量文本库上训练的参数众多的先进机器学习模型。从技术角度来看，语言建模（LM）是推动机器语言智能进步的关键技术。LM的主要目标是开发能够准确估计生成单词序列概率的模型，从而便于估计与未来标记相关或不存在的概率。

自然语言处理及相关学科的最新发展得益于大型语言模型（LLMs），如ChatGPT。研究表明，当这些模型达到一定规模时，它们会表现出新兴行为，例如具有“推理”能力。通过结合“思维链”方法，即推理示例或简单提示如“我们逐步思考”，这些模型可以通过明确的逻辑步骤回答问题。

一个LLMs可以处理的例子是：“所有鲸鱼都是哺乳动物，所有哺乳动物都有肾脏；因此，所有鲸鱼都有肾脏。”这个特定的例子在研究界引起了极大的兴奋。之所以如此激动，是因为推理的能力被认为是人类智能的基本特征，而目前的人工智能系统往往被认为缺乏这种能力。

尽管大型语言模型（LLMs）在特定推理任务上表现出色，但它们的通用推理能力以及它们可以参与推理过程的程度仍然存在争议。这种不确定性引发了研究界的持续辩论和不同观点。例如，有人说LLMs是“足够的零-shot推理者”，而其他作者得出的结论是“LLMs在日常规划/推理任务上仍有很长的路要走，这对人类来说并不构成挑战”。

在本文中，我们开始探讨记忆在推动LLMs、一些新兴架构以及它们应用的机会中的作用。后续文章将更多地涵盖实现细节和不同方法与设计模式的具体内容。

带有长期记忆的LLMs
LLMs建立在一种称为Transformer模型的深度学习架构上。Transformer模型利用自注意机制来确定文本序列中单词或元素之间的关系。这一基础及相关发展使得模型能够更好地理解和生成具有更大上下文和连贯性的文本。

为了提高LLMs的能力，研究人员考虑将长期记忆机制纳入这些模型。长期记忆允许模型在较长时间内存储信息，并在开发响应时利用这些信息。目前有两种主要方式可以将长期记忆纳入其中。

LLMs可以纳入长期记忆的一种方式是利用额外的记忆组件，例如第三方数据库，包括向量数据库或（知识）图数据库。这些组件存储事实数据或嵌入，模型可以访问并用于生成文本。通过访问这些外部记忆，LLMs可以提供更精确和准确的响应。

另一种方式是将记忆纳入模型本身。例如，模型可以包括一个内部记忆模块（例如索引、修改的注意机制等），在文本处理过程中存储相关数据。这种内部记忆可以被修改和访问，以影响模型的行为。通过在实际模型架构中使用长期记忆，LLMs可以展示更一致的行为，并针对给定上下文创建适当的响应。

架构设计考虑因素:
开发具有长期记忆的LLMs时必须考虑几个架构因素。一些关键考虑因素包括：

存储：模型的内存应该足够大，可以存储和检索相关信息。内存组件的大小和架构必须设计为容纳预期长期数据量。
存储更新：模型应该包括机制，以对新输入或数据进行长期记忆的修订。这确保了记忆的及时更新，并与当前上下文相关。
记忆检索：模型需要有效的访问和检索机制，用于从长期记忆中检索信息。这个检索过程必须快速而准确，以使模型能够在文本生成过程中利用存储的信息而不会造成过多的延迟。这在使用外部记忆组件的方法中尤为重要，比如第三方数据库。
与注意机制结合：模型的长期记忆应该与自注意机制结合。这使得模型能够在文本生成过程中关注记忆的相关部分，并根据存储的数据做出明智的决策。
训练和选择：训练具有长期记忆的LLMs需要对记忆在训练过程中如何更新和利用有透彻的理解。为了确保有效地学习和利用存储的数据，必须采用健壮的选择技术来考虑记忆组件。
为此，研究界出现了一些新的新兴架构，试图考虑这些设计考虑因素，同时改进成

本和长期记忆效率。一个例子，如下图所示，是添加一个解耦缓存层，在训练过程中保持新鲜，以补充预训练模型。

另一个例子如下图所示，是“Hyena Hierarchy”，该架构试图通过在新的稠密、无注意力架构中使用亚二次运算符来打破注意力机制的二次障碍（导致缩放成本和计算时间）。

使用来自Poli等人（2023）的Hyena Hierarchy的示例架构

这些新的范式以及研究和开发社区中出现的其他范式将在未来的文章中更详细地探讨。

GenAI应用的进展和机会
基于LLM的GenAI应用的发展为许多领域带来了新的机会。随着模型在理解和记忆扩展上变得越来越熟练，它们可以在越来越复杂和动态的情况下得到利用。

LLMs的进展
提高文本生成中的上下文理解和连贯性
GenAI应用程序理解和生成具有增强上下文理解和连贯性的文本的能力是它们的重要优势之一。现代LLMs，如GPT-3.5及以上版本，已经在大量数据上进行了训练，可能会产生更恰当和与上下文相关的响应。这种改进使得跨多个应用程序进行更有意义和精确的交互成为可能。这在长期记忆机制的改进方面进一步加强，涵盖了以下领域。

提高生成响应的准确性和特异性：
将LLMs调整到获得特定领域专业知识的能力是GenAI应用程序的主要优势之一。这超越了仅仅使用现有通用LLMs的“导言”或提示工程化。通过向模型引入大量特定领域的数据并相应地调整其参数，我们可以训练它生成表现出对话题的深刻理解的响应。这种专业化使得模型能够提供更精确和与上下文相关的数据。

此外，通过使用精细调整的LLMs，GenAI应用在信息检索方面表现出色。通过整合长期记忆机制，这些模型可以以更高的精度和相关性检索信息，从而使模型能够向用户查询提供更准确的结果。

一致的行为和减少LLMs中的偏见：
确保LLMs的一致性，减少LLMs中的幻觉和消除LLMs中的偏见，是具有巨大挑战的。通过在LLMs中利用更好的长期记忆机制，我们可以潜在地改善以下领域的偏见：

减少偏见：AI模型从数据中获取知识。如果训练数据中包含偏见，模型也会展现出相同的偏见。因此，关键是精心策划一个平衡和多样化的训练数据集。这需要精确的数据选择和评估，以减少内在和显性偏见。更好的长期记忆可以提高输出的质量，减少幻觉并可能减少有偏见的输出。

公平评估：实施和监测公正度指标可以帮助量化偏见。这些指标可以作为LLMs行为的指导原则。这其中一部分还涉及到审视LLMs在用户互动层面的输入（提示）和输出（响应）。在这方面，具有外部长期记忆机制也可能会有所帮助。在整个过程中进行定期审计和评估是识别和纠正AI系统中任何偏见的重要环节。

算法透明性：大多数LLMs在决策过程中仍然非常不透明。虽然有解释性AI技术可以帮助识别内在偏见，揭示模型是如何做出决策的，但是新兴模型架构中的记忆机制也有可能提供机会，使模型更加透明。例如，可以冻结或更新模型的某些部分或其运行的长期记忆的技术可能使模型保持最新，但也确保其符合“被遗忘权”等法规而无需重新训练。

机会:
生成AI是人工智能的一个子领域，其重点是开发模型和系统以生成新的独特内容。与传统的人工智能系统相比，传统AI系统旨在识别和分类现有数据，而生成AI旨在生成新的数据，模仿其所接触的训练数据的趋势和特征。在LLMs中加强记忆功能可以显著影响以下领域：

内容创作：AI在生成书面内容方面已经取得了显著进展，包括诗歌、新闻文章和技术论文。例如，企业可以使用AI生成营销文案或提供内容建议，从而极大地减少创建和修改内容的时间。此外，生成AI模型使用生成对抗网络（GANs）、变分自动编码器（VAEs）和R

NN等方法来生成新的内容，如图片、视频、文本和音乐。这些模型发现了训练数据的基本模式和框架，然后利用这些信息生成具有类似特征的新样本。更长的记忆时间可以帮助基于更长的上下文演变内容，并参考以前的陈述或作品中的关键要素。

个性化体验：无论是通过生成个性化购买体验还是在教育中创建独特的学习路径，生成AI都有潜力个性化我们日常生活的许多方面。改进的记忆功能将提供更好的个性化能力，可以考虑更长时间的偏好。

药物发现：生成AI已经用于预测分子的潜在属性，并在药物发现中生成新的潜在药物候选物。这已经被证明可以显著加速药物发现和开发过程。更好的长期记忆可以通过包含更多关于每种分子或药物候选物的上下文信息，进一步提高这些应用的潜力。

结论
尽管有令人兴奋的发展和机会，但仍然存在重大挑战。训练这些先进LLMs的计算复杂性很高，它们的复杂性使得理解和控制它们变得更加困难。研究人员仍在探索如何有效地处理这些权衡。这个讨论的一个关键部分是LLMs和GenAI更广泛的长期记忆的作用。

对这些先进的AI模型的伦理影响的关注不断增长。仍然存在未解决的隐私问题，特别是考虑到模型可以记住信息很长时间。至关重要的是，这些模型是否会记住并延续有害或有偏见的行为。

研究人员、开发人员、监管机构和最终用户必须合作解决这些挑战。为了负责任地挖掘基于LLM的GenAI应用的每一种潜力，有必要开发新的方法来理解模型、AI使用的伦理标准以及更有效的隐私保护方法。

总之，基于记忆和上下文的GenAI应用的快速发展代表了人工智能发展的重要里程碑。随着我们继续挑战AI可以回忆、推理和识别的界限，人类与人工智能任务之间的界限变得越来越模糊。LLMs的发展为各行各业提供了有趣的机会，但也带来了新的挑战。随着我们继续发展人工智能，前方的道路既令人兴奋又充满潜力。
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;上篇文章内的配图&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;0fb7O_linBXjDTysw.png&#34; alt=&#34;img&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Example architecture with augmented memory mechanism from&lt;/em&gt; &lt;a href=&#34;https://arxiv.org/pdf/2306.07174.pdf&#34;&gt;&lt;em&gt;Wang et al. (2023)&lt;/em&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;0YJ9EjdKTiBi6ox6q.png&#34; alt=&#34;img&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Example architecture using Hyena Hierarchy from&lt;/em&gt; &lt;a href=&#34;https://arxiv.org/abs/2302.10866&#34;&gt;&lt;em&gt;Poli et al. (2023)&lt;/em&gt;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;算是初步学习机器学习相关的知识，此前只听过些专有名词。&lt;/p&gt;
&lt;p&gt;但是之前就看过一些向量数据库和知识图片的文章，在看上述两篇文章之前，我就认为可以使用到类似概念的数据库来存储，&lt;/p&gt;
&lt;p&gt;“应该是修改某一部分的 “记忆”，使完成本次对话的时候，能够可能访问到该此更新。而不是携带前 n 次的 qa。”&lt;/p&gt;
&lt;p&gt;“记忆也应该有多层。”&lt;/p&gt;
&lt;p&gt;今天也看了 GLM 的&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly93d3cuYmlsaWJpbGkuY29tL3ZpZGVvL0JWMWI2NDIxdTc0RS8/c2hhcmVfc291cmNlPWNvcHlfd2ViJmFtcDt2ZF9zb3VyY2U9ZmYyY2QxYmIyMDc2NmE2OTE5ZTJhZmM3ZmEzNjM2YTM=&#34;&gt; 2024，智能体 Builder 时代，来临了吗？&lt;/span&gt;，初步了解了大模型的架构&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240211194517900.png&#34; alt=&#34;image-20240211194517900&#34; /&gt;&lt;/p&gt;
</content>
        <category term="GLM" />
        <updated>2024-02-11T11:26:02.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2024/01/27/redis%E5%AD%A6%E4%B9%A0%E8%AE%B0%E5%BD%95/</id>
        <title>redis学习记录</title>
        <link rel="alternate" href="http://example.com/2024/01/27/redis%E5%AD%A6%E4%B9%A0%E8%AE%B0%E5%BD%95/"/>
        <content type="html">&lt;p&gt;&lt;em&gt;大三上的寒假，玩了两周后，觉得该学一些东西了，于是在 b 站上找项目跟做，最后在鱼皮的推荐下，跟做了黑马的 redis。&lt;/em&gt;&lt;/p&gt;
&lt;h3 id=&#34;问题1resp连接不上虚拟机上的redis&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#问题1resp连接不上虚拟机上的redis&#34;&gt;#&lt;/a&gt; 问题 1：RESP 连接不上虚拟机上的 redis&lt;/h3&gt;
&lt;h4 id=&#34;搜索了csdnresp项目下的issue做了如下操作&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#搜索了csdnresp项目下的issue做了如下操作&#34;&gt;#&lt;/a&gt; 搜索了 CSDN，RESP 项目下的 issue，做了如下操作：&lt;/h4&gt;
&lt;p&gt;我检查了配置文件，重新按照安装说明配置了一遍 redis，都无法解决&lt;/p&gt;
&lt;p&gt;—&amp;gt; 不是 redis 的问题&lt;/p&gt;
&lt;p&gt;我又试了试我电脑能不能 ping 上虚拟机，查找了如何获取虚拟机的 ip（ &lt;code&gt;ip addr&lt;/code&gt; ），ping 成功了&lt;/p&gt;
&lt;p&gt;—&amp;gt; 不是我电脑的问题&lt;/p&gt;
&lt;p&gt;虚拟机没学，于是我也束手无策了&lt;/p&gt;
&lt;p&gt;吃完饭后又尝试搜了一下，看了一下 &lt;a href=&#34;%5B%E5%85%8D%E8%B4%B9Redis%E5%9B%BE%E5%BD%A2%E5%8C%96%E7%95%8C%E9%9D%A2%EF%BC%88RESP%EF%BC%89%E4%B8%8B%E8%BD%BD%E5%9C%B0%E5%9D%80%E5%92%8C%E8%BF%9E%E6%8E%A5%E6%AD%A5%E9%AA%A4_resp%E4%B8%8B%E8%BD%BD-CSDN%E5%8D%9A%E5%AE%A2%5D(https://blog.csdn.net/drhnb/article/details/131717836)&#34;&gt;免费 Redis 图形化界面（RESP）下载地址和连接步骤&lt;/a&gt; ，发现里面有写到连接不上的问题，是 linux 的防火墙拦截了（不太懂 ping 的规则，能 ping 成功，但是防火墙会拦截）&lt;/p&gt;
&lt;h4 id=&#34;连接不成功尝试在linux中执行下面的两个命令&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#连接不成功尝试在linux中执行下面的两个命令&#34;&gt;#&lt;/a&gt; 连接不成功：尝试在 linux 中执行下面的两个命令：&lt;/h4&gt;
&lt;p&gt;以下命令是用于配置 Linux 防火墙（firewalld）以开放指定的端口 （6379/tcp）。&lt;br /&gt;
1、&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;firewall-cmd --zone=public --add-port=6379/tcp --permanent
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这个命令添加一个规则到 “public” 区域（zone）的防火墙配置中，允许通过端口 6379 的 TCP 连接。–permanent 参数表示该规则将被永久保存，重新启动后仍然有效。&lt;/p&gt;
&lt;p&gt;2、&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;firewall-cmd --reload
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;这个命令重新加载防火墙规则，使最新的修改生效。当你添加、删除或修改防火墙规则时，都需要执行这个命令才能使更改生效。&lt;/p&gt;
&lt;p&gt;注意事项：&lt;/p&gt;
&lt;p&gt;以上命令需要以管理员权限（例如 root 用户或者使用 sudo）来执行。&lt;br /&gt;
1、在执行前，请确保已经安装了 firewalld，并且正在运行。&lt;br /&gt;
2、6379 是 Redis 默认的端口号，如果你在使用其他端口，则需要相应地修改上述命令中的端口号。&lt;/p&gt;
&lt;h3 id=&#34;git问题&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#git问题&#34;&gt;#&lt;/a&gt; git 问题&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;F:\HexoBlog2&amp;gt;ssh -T git@github.com
ssh: connect to host github.com port 22: Connection timed out
&lt;/code&gt;&lt;/pre&gt;
&lt;h4 id=&#34;解决&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#解决&#34;&gt;#&lt;/a&gt; 解决&lt;/h4&gt;
&lt;p&gt;此处是端口问题，可能是被占用了或者什么的&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git clone git@github.com:xxxxx/xxxx.git my-awesome-proj
Cloning into &#39;my-awesome-proj&#39;...
ssh: connect to host github.com port 22: Connection timed out
fatal: Could not read from remote repository.

$ # This should also timeout
$ ssh -T git@github.com
ssh: connect to host github.com port 22: Connection timed out

$ # but this might work
$ # 换个端口尝试，成功
$ ssh -T -p 443 git@ssh.github.com
Hi xxxx! You&#39;ve successfully authenticated, but GitHub does not provide shell access.

$ # Override SSH settings
$ # 添加一个配置文件，会读取该文件，使用配置的端口
$ vim ~/.ssh/config
```
# Add section below to it
Host github.com
  Hostname ssh.github.com
  Port 443
```
$ ssh -T git@github.com
Hi xxxxx! You&#39;ve successfully authenticated, but GitHub does not
provide shell access.

$ git clone git@github.com:xxxxxx/xxxxx.git my-awesome-proj
Cloning into &#39;my-awesome-proj&#39;...
remote: Enumerating objects: 15, done.
remote: Counting objects: 100% (15/15), done.
remote: Compressing objects: 100% (14/14), done.
remote: Total 15 (delta 0), reused 15 (delta 0), pack-reused 0
Receiving objects: 100% (15/15), 22.90 KiB | 4.58 MiB/s, done.
&lt;/code&gt;&lt;/pre&gt;
&lt;h3 id=&#34;记录&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#记录&#34;&gt;#&lt;/a&gt; 记录&lt;/h3&gt;
&lt;h4 id=&#34;短信登陆部分&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#短信登陆部分&#34;&gt;#&lt;/a&gt; 短信登陆部分&lt;/h4&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412122633753.png&#34; alt=&#34;image-20240412122633753&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412122758798.png&#34; alt=&#34;image-20240412122758798&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412123054149.png&#34; alt=&#34;image-20240412123054149&#34; /&gt;&lt;/p&gt;
&lt;h4 id=&#34;缓存&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#缓存&#34;&gt;#&lt;/a&gt; 缓存&lt;/h4&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412123942695.png&#34; alt=&#34;image-20240412123942695&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412124114988.png&#34; alt=&#34;image-20240412124114988&#34; /&gt;&lt;/p&gt;
&lt;h5 id=&#34;缓存更新策略&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#缓存更新策略&#34;&gt;#&lt;/a&gt; 缓存更新策略&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412124326274.png&#34; alt=&#34;image-20240412124326274&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412124636426.png&#34; alt=&#34;image-20240412124636426&#34; /&gt;&lt;/p&gt;
&lt;p&gt;一般用第一个&lt;img data-src=&#34;image-20240412124808845.png&#34; alt=&#34;image-20240412124808845&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412125028236.png&#34; alt=&#34;image-20240412125028236&#34; /&gt;&lt;/p&gt;
&lt;h5 id=&#34;缓存穿透&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#缓存穿透&#34;&gt;#&lt;/a&gt; 缓存穿透&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412130240329.png&#34; alt=&#34;image-20240412130240329&#34; /&gt;&lt;/p&gt;
&lt;h5 id=&#34;缓存雪崩&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#缓存雪崩&#34;&gt;#&lt;/a&gt; 缓存雪崩&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412130346583.png&#34; alt=&#34;image-20240412130346583&#34; /&gt;&lt;/p&gt;
&lt;h5 id=&#34;缓存击穿&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#缓存击穿&#34;&gt;#&lt;/a&gt; 缓存击穿&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412130622535.png&#34; alt=&#34;image-20240412130622535&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412130742006.png&#34; alt=&#34;image-20240412130742006&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412130802722.png&#34; alt=&#34;image-20240412130802722&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412131031442.png&#34; alt=&#34;image-20240412131031442&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412131423996.png&#34; alt=&#34;image-20240412131423996&#34; /&gt;&lt;/p&gt;
&lt;h4 id=&#34;优惠券秒杀&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#优惠券秒杀&#34;&gt;#&lt;/a&gt; 优惠券秒杀&lt;/h4&gt;
&lt;h5 id=&#34;全局id生成器&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#全局id生成器&#34;&gt;#&lt;/a&gt; 全局 ID 生成器&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412140415747.png&#34; alt=&#34;image-20240412140415747&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412140436380.png&#34; alt=&#34;image-20240412140436380&#34; /&gt;&lt;/p&gt;
&lt;h5 id=&#34;实现功能&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#实现功能&#34;&gt;#&lt;/a&gt; 实现功能&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412140853291.png&#34; alt=&#34;image-20240412140853291&#34; /&gt;&lt;/p&gt;
&lt;h5 id=&#34;超卖问题&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#超卖问题&#34;&gt;#&lt;/a&gt; 超卖问题&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412141102576.png&#34; alt=&#34;image-20240412141102576&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412141125679.png&#34; alt=&#34;image-20240412141125679&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412141309616.png&#34; alt=&#34;image-20240412141309616&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412141410276.png&#34; alt=&#34;image-20240412141410276&#34; /&gt;&lt;/p&gt;
&lt;h5 id=&#34;一人一单功能&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#一人一单功能&#34;&gt;#&lt;/a&gt; 一人一单功能&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412141516843.png&#34; alt=&#34;image-20240412141516843&#34; /&gt;&lt;/p&gt;
&lt;h4 id=&#34;分布式锁&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#分布式锁&#34;&gt;#&lt;/a&gt; 分布式锁&lt;/h4&gt;
&lt;h5 id=&#34;并发安全问题&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#并发安全问题&#34;&gt;#&lt;/a&gt; 并发安全问题&lt;/h5&gt;
&lt;p&gt;多个 JVM 的锁监视器不一样，会同时放行&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412142353714.png&#34; alt=&#34;image-20240412142353714&#34; /&gt;&lt;/p&gt;
&lt;h5 id=&#34;基于redis的分布式锁&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#基于redis的分布式锁&#34;&gt;#&lt;/a&gt; 基于 Redis 的分布式锁&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412142523089.png&#34; alt=&#34;image-20240412142523089&#34; /&gt;&lt;/p&gt;
&lt;h5 id=&#34;超时释放导致误删&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#超时释放导致误删&#34;&gt;#&lt;/a&gt; 超时释放导致误删&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412144240999.png&#34; alt=&#34;image-20240412144240999&#34; /&gt;&lt;br /&gt;
&lt;img data-src=&#34;image-20240412144612172.png&#34; alt=&#34;image-20240412144612172&#34; /&gt;&lt;/p&gt;
&lt;h5 id=&#34;原子性问题-事务&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#原子性问题-事务&#34;&gt;#&lt;/a&gt; 原子性问题 （事务）&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412145321833.png&#34; alt=&#34;image-20240412145321833&#34; /&gt;&lt;/p&gt;
&lt;p&gt;解决方法&lt;/p&gt;
&lt;p&gt;用 Lua 脚本批量执行命令，达到原子性&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412160658766.png&#34; alt=&#34;image-20240412160658766&#34; /&gt;&lt;/p&gt;
&lt;h5 id=&#34;redission&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#redission&#34;&gt;#&lt;/a&gt; Redission&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412161148239.png&#34; alt=&#34;image-20240412161148239&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412161447719.png&#34; alt=&#34;image-20240412161447719&#34; /&gt;&lt;/p&gt;
&lt;h5 id=&#34;使用redission的分布式锁&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#使用redission的分布式锁&#34;&gt;#&lt;/a&gt; 使用 Redission 的分布式锁&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412161535930.png&#34; alt=&#34;image-20240412161535930&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412161908045.png&#34; alt=&#34;image-20240412161908045&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412161945922.png&#34; alt=&#34;image-20240412161945922&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412162327381.png&#34; alt=&#34;image-20240412162327381&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412162658354.png&#34; alt=&#34;image-20240412162658354&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412163406408.png&#34; alt=&#34;image-20240412163406408&#34; /&gt;&lt;/p&gt;
&lt;h4 id=&#34;优化优惠券秒杀&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#优化优惠券秒杀&#34;&gt;#&lt;/a&gt; 优化优惠券秒杀&lt;/h4&gt;
&lt;p&gt;把&lt;strong&gt;抢购&lt;/strong&gt;和&lt;strong&gt;下单&lt;/strong&gt;分开&lt;/p&gt;
&lt;h5 id=&#34;基于redis优化秒杀资格判断使用lua脚本&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#基于redis优化秒杀资格判断使用lua脚本&#34;&gt;#&lt;/a&gt; 基于 Redis 优化秒杀资格判断（使用 Lua 脚本）&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412164112620.png&#34; alt=&#34;image-20240412164112620&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412164924880.png&#34; alt=&#34;image-20240412164924880&#34; /&gt;&lt;/p&gt;
&lt;h5 id=&#34;基于阻塞队列优化异步下单&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#基于阻塞队列优化异步下单&#34;&gt;#&lt;/a&gt; 基于阻塞队列优化异步下单&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412164621748.png&#34; alt=&#34;image-20240412164621748&#34; /&gt;&lt;/p&gt;
&lt;h5 id=&#34;问题解决消息队列&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#问题解决消息队列&#34;&gt;#&lt;/a&gt; 问题 &amp;amp; 解决（消息队列）&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412165449807.png&#34; alt=&#34;image-20240412165449807&#34; /&gt;&lt;/p&gt;
&lt;h4 id=&#34;消息队列&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#消息队列&#34;&gt;#&lt;/a&gt; 消息队列&lt;/h4&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412180418366.png&#34; alt=&#34;image-20240412180418366&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412180446142.png&#34; alt=&#34;image-20240412180446142&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;img src=&amp;quot;image-20240412183222085.png&amp;quot; alt=&amp;quot;image-20240412183222085&amp;quot; style=&amp;quot;zoom: 50%;&amp;quot; /&amp;gt;&lt;/p&gt;
&lt;h5 id=&#34;redis的list模拟消息队列&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#redis的list模拟消息队列&#34;&gt;#&lt;/a&gt; redis 的 list 模拟消息队列&lt;/h5&gt;
&lt;p&gt;…&lt;/p&gt;
&lt;h5 id=&#34;pubsub发布订阅&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#pubsub发布订阅&#34;&gt;#&lt;/a&gt; pubsub 发布订阅&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412181838756.png&#34; alt=&#34;image-20240412181838756&#34; /&gt;&lt;/p&gt;
&lt;h5 id=&#34;stream类型消息队列&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#stream类型消息队列&#34;&gt;#&lt;/a&gt; STREAM 类型消息队列&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412182433868.png&#34; alt=&#34;image-20240412182433868&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;img src=&amp;quot;image-20240412182643317.png&amp;quot; alt=&amp;quot;image-20240412182643317&amp;quot; style=&amp;quot;zoom:50%;&amp;quot; /&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;img src=&amp;quot;image-20240412183033083.png&amp;quot; alt=&amp;quot;image-20240412183033083&amp;quot; style=&amp;quot;zoom:67%;&amp;quot; /&amp;gt;&lt;/p&gt;
&lt;h4 id=&#34;功能-达人探店&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#功能-达人探店&#34;&gt;#&lt;/a&gt; 功能 - 达人探店&lt;/h4&gt;
&lt;h5 id=&#34;发布&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#发布&#34;&gt;#&lt;/a&gt; 发布&lt;/h5&gt;
&lt;p&gt;…&lt;/p&gt;
&lt;h5 id=&#34;查看&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#查看&#34;&gt;#&lt;/a&gt; 查看&lt;/h5&gt;
&lt;p&gt;…&lt;/p&gt;
&lt;h5 id=&#34;点赞功能&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#点赞功能&#34;&gt;#&lt;/a&gt; 点赞功能&lt;/h5&gt;
&lt;p&gt;…&lt;/p&gt;
&lt;h5 id=&#34;点赞排行榜&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#点赞排行榜&#34;&gt;#&lt;/a&gt; 点赞排行榜&lt;/h5&gt;
&lt;p&gt;在 Redis 获取 top n&lt;/p&gt;
&lt;h4 id=&#34;功能-好友关注&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#功能-好友关注&#34;&gt;#&lt;/a&gt; 功能 - 好友关注&lt;/h4&gt;
&lt;h5 id=&#34;关注取关&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#关注取关&#34;&gt;#&lt;/a&gt; 关注取关&lt;/h5&gt;
&lt;p&gt;…&lt;/p&gt;
&lt;h5 id=&#34;共同关注&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#共同关注&#34;&gt;#&lt;/a&gt; 共同关注&lt;/h5&gt;
&lt;p&gt;把关注列表放到 redis，取交集&lt;/p&gt;
&lt;h5 id=&#34;feed流&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#feed流&#34;&gt;#&lt;/a&gt; Feed 流&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412190422462.png&#34; alt=&#34;image-20240412190422462&#34; /&gt;&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412190413921.png&#34; alt=&#34;image-20240412190413921&#34; /&gt;&lt;/p&gt;
&lt;p&gt;实现方案&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412190835135.png&#34; alt=&#34;image-20240412190835135&#34; /&gt;&lt;/p&gt;
&lt;h5 id=&#34;推送到粉丝收件箱&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#推送到粉丝收件箱&#34;&gt;#&lt;/a&gt; 推送到粉丝收件箱&lt;/h5&gt;
&lt;p&gt;…&lt;/p&gt;
&lt;h5 id=&#34;滚动分页查询收件箱的思路&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#滚动分页查询收件箱的思路&#34;&gt;#&lt;/a&gt; 滚动分页查询收件箱的思路&lt;/h5&gt;
&lt;p&gt;…&lt;/p&gt;
&lt;h5 id=&#34;实现滚动分页查询&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#实现滚动分页查询&#34;&gt;#&lt;/a&gt; 实现滚动分页查询&lt;/h5&gt;
&lt;p&gt;…&lt;/p&gt;
&lt;h4 id=&#34;附近商户&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#附近商户&#34;&gt;#&lt;/a&gt; 附近商户&lt;/h4&gt;
&lt;h5 id=&#34;geo数据结构&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#geo数据结构&#34;&gt;#&lt;/a&gt; GEO 数据结构&lt;/h5&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240412193025180.png&#34; alt=&#34;image-20240412193025180&#34; /&gt;&lt;/p&gt;
&lt;h5 id=&#34;导入店铺数据到geo&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#导入店铺数据到geo&#34;&gt;#&lt;/a&gt; 导入店铺数据到 GEO&lt;/h5&gt;
&lt;p&gt;…&lt;/p&gt;
&lt;h5 id=&#34;实现附近商户功能&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#实现附近商户功能&#34;&gt;#&lt;/a&gt; 实现附近商户功能&lt;/h5&gt;
&lt;p&gt;…&lt;/p&gt;
&lt;p&gt;……&lt;/p&gt;
</content>
        <category term="git" />
        <category term="redis" />
        <category term="lunix" />
        <updated>2024-01-27T04:46:04.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2023/12/24/%E5%AE%9E%E8%AE%AD%E5%91%A8%E5%81%9A%E4%BA%86%E5%95%A5/</id>
        <title>实训周做了啥</title>
        <link rel="alternate" href="http://example.com/2023/12/24/%E5%AE%9E%E8%AE%AD%E5%91%A8%E5%81%9A%E4%BA%86%E5%95%A5/"/>
        <content type="html">&lt;h1 id=&#34;开始&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#开始&#34;&gt;#&lt;/a&gt; 开始&lt;/h1&gt;
&lt;p&gt;又到了实训周，之前实训周做了啥都忘记了…… 于是记录一下，表示我真的做了（&lt;/p&gt;
&lt;p&gt;老师的要求是，先用 Vue.js 做一个简单的 Todo List，有点基础后，再做一个微信小程序。&lt;/p&gt;
&lt;h2 id=&#34;看法&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#看法&#34;&gt;#&lt;/a&gt; 看法&lt;/h2&gt;
&lt;p&gt;我觉得前端界面，简单一点的话，就是组件的拼装，组件自身的样式，组件和同级组件的关系，组件和父级组件的关系。&lt;/p&gt;
&lt;h1 id=&#34;做todo-list&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#做todo-list&#34;&gt;#&lt;/a&gt; 做 Todo List&lt;/h1&gt;
&lt;h2 id=&#34;npm&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#npm&#34;&gt;#&lt;/a&gt; npm&lt;/h2&gt;
&lt;p&gt;，用 npm 创建了项目框架。而 bootstrap 组件库也不错，有好多好看的组件供使用&lt;/p&gt;
&lt;p&gt;&lt;code&gt;npm run dev&lt;/code&gt;&lt;/p&gt;
&lt;h2 id=&#34;数据绑定传输等&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#数据绑定传输等&#34;&gt;#&lt;/a&gt; 数据绑定传输等&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;@&lt;/code&gt; （v-on）和 &lt;code&gt;：&lt;/code&gt; （v-vbind），&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;@ 用于处理事件，而 : 用于处理属性绑定。这两个符号都是Vue.js中的常见语法糖，使代码更简洁易读 
@ 符号是 v-on 指令的缩写。它用于监听DOM事件并触发相应的Vue实例中的方法。
: 符号是 v-bind 指令的缩写。它用于动态绑定属性或表达式
查自chatgpt 2023/12/11
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;我大致理解成，@是绑定事件（函数），：是跟参数之类的有关，也就是属性&lt;/p&gt;
&lt;p&gt;&lt;code&gt;v-model&lt;/code&gt;  可以在组件上使用以实现双向绑定&lt;/p&gt;
&lt;p&gt;&lt;code&gt;&amp;#123;&amp;#123; item.task &amp;#125;&amp;#125;&lt;/code&gt;  ，可以动态获取属性的值&lt;/p&gt;
&lt;p&gt;&lt;code&gt;@click=&amp;quot;changeCompleted(item.id)&amp;quot;&lt;/code&gt; ，（）里的，可以传参，而在微信小程序里，可以用 &lt;code&gt;data-xxx=“”&lt;/code&gt;  传递参数&lt;/p&gt;
&lt;h2 id=&#34;emit的使用&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#emit的使用&#34;&gt;#&lt;/a&gt; $emit 的使用&lt;/h2&gt;
&lt;p&gt;起初是想在 todoList.vue 调用 App.vue 里的函数，我用的是方法是，在 todoList.vue 里导入 App.vue，然后用 &lt;code&gt;App.method.XXX()&lt;/code&gt; ，结果不行，后来老师说使用 emit 什么的，并帮我找到在官方文档哪，让我自己学一下。&lt;/p&gt;
&lt;p&gt;以下摘自 Vue.js - 事件 - 事件参数&lt;/p&gt;
&lt;p&gt;有时候我们会需要在触发事件时附带一个特定的值。举例来说，我们想要  &lt;code&gt;&amp;lt;BlogPost&amp;gt;&lt;/code&gt;  组件来管理文本会缩放得多大。在这个场景下，我们可以给  &lt;code&gt;$emit&lt;/code&gt;  提供一个额外的参数：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;button @click=&amp;quot;$emit(&#39;increaseBy&#39;, 1)&amp;quot;&amp;gt;
  Increase by 1
&amp;lt;/button&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后我们在父组件中监听事件，我们可以先简单写一个内联的箭头函数作为监听器，此函数会接收到事件附带的参数：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;MyButton @increase-by=&amp;quot;(n) =&amp;gt; count += n&amp;quot; /&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;或者，也可以用一个组件方法来作为事件处理函数：&lt;/p&gt;
&lt;p&gt;template&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;MyButton @increase-by=&amp;quot;increaseCount&amp;quot; /&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;该方法也会接收到事件所传递的参数：&lt;/p&gt;
&lt;p&gt;js&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;function increaseCount(n) &amp;#123;
  count.value += n
&amp;#125;
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;axios的使用&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#axios的使用&#34;&gt;#&lt;/a&gt; axios 的使用&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;npm install axios&lt;/code&gt;&lt;/p&gt;
&lt;figure class=&#34;highlight javascript&#34;&gt;&lt;figcaption data-lang=&#34;javascript&#34;&gt;&lt;/figcaption&gt;&lt;table&gt;&lt;tr&gt;&lt;td data-num=&#34;1&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token function&#34;&gt;remove&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token parameter&#34;&gt;itemid&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;2&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;				&lt;span class=&#34;token comment&#34;&gt;// 发送 POST 请求给后端添加新任务&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;3&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;				axios&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;token function&#34;&gt;post&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;http://localhost:8080/todolist/removeTodolist&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;4&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;						&lt;span class=&#34;token comment&#34;&gt;// 参数传递&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;5&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;                    	&lt;span class=&#34;token literal-property property&#34;&gt;id&lt;/span&gt;&lt;span class=&#34;token operator&#34;&gt;:&lt;/span&gt; itemid&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;6&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;					&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;token function&#34;&gt;then&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token parameter&#34;&gt;response&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;=&gt;&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;7&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;						&lt;span class=&#34;token comment&#34;&gt;// 添加成功后，重新获取待办事项列表&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;8&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;						&lt;span class=&#34;token keyword&#34;&gt;this&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;token function&#34;&gt;$emit&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#34;fetchTodoList&#34;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;9&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;					&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;10&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;					&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;token function&#34;&gt;catch&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token parameter&#34;&gt;error&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;=&gt;&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;11&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;						&lt;span class=&#34;token comment&#34;&gt;// 处理错误&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;12&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;						console&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;token function&#34;&gt;error&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#39;Error adding task:&#39;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; error&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;13&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;					&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;14&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;			&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;h2 id=&#34;后端的搭建&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#后端的搭建&#34;&gt;#&lt;/a&gt; 后端的搭建&lt;/h2&gt;
&lt;p&gt;老师说如果有后端能加分，我想着这不能错过啊，于是几个月前学的 java 的 Spring Boot + Mybatis plus + mysql 就派上用场了&lt;/p&gt;
&lt;p&gt;根据之前跟着做的一个项目配置好 Todo List 后端后，写了点简单的增删查改，好些用法都忘记了，悲。&lt;/p&gt;
&lt;h1 id=&#34;做微信小程序&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#做微信小程序&#34;&gt;#&lt;/a&gt; 做微信小程序&lt;/h1&gt;
&lt;p&gt;想着我自己也有个公众号，做一个我也能用的上的小程序接上去。&lt;/p&gt;
&lt;p&gt;挑来挑去，做了番茄时钟和一个简单的待办。&lt;/p&gt;
&lt;p&gt;也用了 van weapp 组件库，不过用不太来。&lt;/p&gt;
&lt;h2 id=&#34;界面样式&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#界面样式&#34;&gt;#&lt;/a&gt; 界面样式&lt;/h2&gt;
&lt;p&gt;&amp;lt;img src=&amp;quot;../../public/images/2023/12 / 番茄时钟主界面.png&amp;quot; alt=&amp;quot;番茄时钟主界面&amp;quot; style=&amp;quot;zoom: 50%;&amp;quot; /&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;img src=&amp;quot;../../public/images/2023/12 / 番茄时钟 active.png&amp;quot; alt=&amp;quot;番茄时钟 active&amp;quot; style=&amp;quot;zoom: 50%;&amp;quot; /&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;img src=&amp;quot;../../public/images/2023/12/todolist.png&amp;quot; alt=&amp;quot;todolist&amp;quot; style=&amp;quot;zoom: 50%;&amp;quot; /&amp;gt;&lt;/p&gt;
&lt;p&gt;&amp;lt;img src=&amp;quot;../../public/images/2023/12 / 番茄时钟 - 今日记录界面.png&amp;quot; alt=&amp;quot;番茄时钟 - 今日记录界面&amp;quot; style=&amp;quot;zoom: 50%;&amp;quot; /&amp;gt;&lt;/p&gt;
&lt;h2 id=&#34;今日诗词的api&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#今日诗词的api&#34;&gt;#&lt;/a&gt; 今日诗词的 API&lt;/h2&gt;
&lt;p&gt;搭在 github 上的 hexo 博客也接入了这个免费的 API，需要在小程序后台添加该 API 的地址到可访问名单&lt;/p&gt;
&lt;h2 id=&#34;界面的搭建&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#界面的搭建&#34;&gt;#&lt;/a&gt; 界面的搭建&lt;/h2&gt;
&lt;p&gt;直到做的差不多了，我才把大一时的前端课、近期学习的，在脑内乱成一锅粥的知识整理的差不多，也就是前端界面，简单一点的话，就是组件的拼装，组件自身的样式，组件和同级组件的关系，组件和父级组件的关系。&lt;/p&gt;
&lt;h2 id=&#34;数据&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#数据&#34;&gt;#&lt;/a&gt; 数据&lt;/h2&gt;
&lt;p&gt;数据则有的放 page 的 data 里，有的放缓存里，通过 &lt;code&gt;wx.setStorageSync(&#39;logs&#39;, logs);&lt;/code&gt;  和 &lt;code&gt;wx.getStorageSync(&#39;logs&#39;, logs);&lt;/code&gt;&lt;/p&gt;
</content>
        <category term="Vue.js" />
        <category term="微信小程序" />
        <updated>2023-12-24T06:37:13.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2023/12/11/todolist/</id>
        <title>todolist</title>
        <link rel="alternate" href="http://example.com/2023/12/11/todolist/"/>
        <content type="html">&lt;p&gt;这两周是实践周，跟着老师做点东西&lt;/p&gt;
&lt;p&gt;相对简单的是，用 vue 框架做一个简单的待办清单&lt;/p&gt;
&lt;h1 id=&#34;步骤&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#步骤&#34;&gt;#&lt;/a&gt; 步骤&lt;/h1&gt;
&lt;p&gt;结合 bootstrap 框架做了如下待办清单&lt;/p&gt;
&lt;p&gt;首先用 npm 新建一个项目（需要 npm）&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;npm init vite-app todolist
//安装需要的依赖
npm install
//启动
npm run dev
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;其中，Bootstrap 需要从官方下载（可 git clone）&lt;/p&gt;
&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9naXRodWIuY29tL3R3YnMvYm9vdHN0cmFwL3JlbGVhc2VzL2Rvd25sb2FkL3Y0LjYuMi9ib290c3RyYXAtNC42LjItZGlzdC56aXA=&#34;&gt;https://github.com/twbs/bootstrap/releases/download/v4.6.2/bootstrap-4.6.2-dist.zip&lt;/span&gt;&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;结构
todolist
--node_modules //依赖库
--public
--src
----assets //Bootstrap放这
----components //存放部件
------todoButton.vue //todolist的按钮
------todoInput.vue //todolist的输入
------todoList.vue //todolist的列表
----App.vue // 主界面
----index.css
----main.js // 启动入口
--...
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;todoButton.vue&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;template&amp;gt;
	&amp;lt;div class=&amp;quot;btn-group&amp;quot; role=&amp;quot;group&amp;quot; aria-label=&amp;quot;Basic example&amp;quot;&amp;gt;
		&amp;lt;button type=&amp;quot;button&amp;quot; class=&amp;quot;btn&amp;quot; :class=&amp;quot;active === 0 ? &#39;btn-primary&#39; : btn-secondary&amp;quot;
			@click=&amp;quot;changeActive(0)&amp;quot;&amp;gt;全部&amp;lt;/button&amp;gt;
		&amp;lt;button type=&amp;quot;button&amp;quot; class=&amp;quot;btn&amp;quot; :class=&amp;quot;active === 1 ? &#39;btn-primary&#39; : btn-secondary&amp;quot;
			@click=&amp;quot;changeActive(1)&amp;quot;&amp;gt;已完成&amp;lt;/button&amp;gt;
		&amp;lt;button type=&amp;quot;button&amp;quot; class=&amp;quot;btn&amp;quot; :class=&amp;quot;active === 2 ? &#39;btn-primary&#39; : btn-secondary&amp;quot;
			@click=&amp;quot;changeActive(2)&amp;quot;&amp;gt;未完成&amp;lt;/button&amp;gt;
	&amp;lt;/div&amp;gt;
&amp;lt;/template&amp;gt;

&amp;lt;script&amp;gt;
	export default &amp;#123;
		name: &amp;quot;todoButton&amp;quot;,
		data() &amp;#123;
			return &amp;#123;
				active: 0,
			&amp;#125;;
		&amp;#125;,
		emits: [&amp;quot;changeActive&amp;quot;],
		methods: &amp;#123;
			changeActive(index) &amp;#123;
				this.active = index;
				this.$emit(&amp;quot;changeActive&amp;quot;, index);
			&amp;#125;,
		&amp;#125;,
	&amp;#125;;
&amp;lt;/script&amp;gt;

&amp;lt;style scoped&amp;gt;
	.btn-group &amp;#123;
		width: 20%;
		margin: 20px auto;
	&amp;#125;
&amp;lt;/style&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;todoInput.vue&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;template&amp;gt;
	&amp;lt;div class=&amp;quot;input-group mb-3&amp;quot;&amp;gt;
		&amp;lt;div class=&amp;quot;input-group-prepend&amp;quot;&amp;gt;
			&amp;lt;button class=&amp;quot;btn-primary&amp;quot; @click=&amp;quot;onsubmit&amp;quot;&amp;gt;提交&amp;lt;/button&amp;gt;
		&amp;lt;/div&amp;gt;
		&amp;lt;input type=&amp;quot;text&amp;quot; class=&amp;quot;form-control&amp;quot; placeholder=&amp;quot;添加任务&amp;quot; aria-label=&amp;quot;Username&amp;quot; aria-describedby=&amp;quot;basic-addon1&amp;quot;
			v-model=&amp;quot;taskname&amp;quot;&amp;gt;
	&amp;lt;/div&amp;gt;
&amp;lt;/template&amp;gt;

&amp;lt;script&amp;gt;
	export default &amp;#123;
		name: &amp;quot;todoInput&amp;quot;,
		data() &amp;#123;
			return &amp;#123;
				taskname: &amp;quot;&amp;quot;,
			&amp;#125;;
		&amp;#125;,
		emits: [&amp;quot;addTask&amp;quot;],
		methods: &amp;#123;
			onsubmit() &amp;#123;
				this.$emit(&amp;quot;addTask&amp;quot;, this.taskname);
				this.taskname = &amp;quot;&amp;quot;;
			&amp;#125;
		&amp;#125;,
	&amp;#125;;
&amp;lt;/script&amp;gt;

&amp;lt;style scoped&amp;gt;
	.input-group &amp;#123;
		width: 40%;
		margin: 20px auto;
	&amp;#125;
&amp;lt;/style&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;todoList.vue&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;template&amp;gt;
	&amp;lt;ul class=&amp;quot;list-group&amp;quot;&amp;gt;
		&amp;lt;li class=&amp;quot;list-group-item d-flex justify-content-between align-items-center&amp;quot; v-for=&amp;quot;item in todolist&amp;quot; :
			key=&amp;quot;item.id&amp;quot;&amp;gt;
			&amp;lt;!-- 复选框 --&amp;gt;
			&amp;lt;div class=&amp;quot;form-check&amp;quot;&amp;gt;
				&amp;lt;input class=&amp;quot;form-check-input&amp;quot; type=&amp;quot;checkbox&amp;quot; value=&amp;quot;&amp;quot; :id=&amp;quot;item.id&amp;quot; v-model=&amp;quot;item.isCompleted&amp;quot;&amp;gt;
				&amp;lt;label class=&amp;quot;form-check-label&amp;quot; :for=&amp;quot;item.id&amp;quot; :class=&amp;quot;item.isCompleted ? &#39;delete&#39; : &#39;&#39;&amp;quot;&amp;gt;
					&amp;#123;&amp;#123; item.task &amp;#125;&amp;#125;
				&amp;lt;/label&amp;gt;
			&amp;lt;/div&amp;gt;
			&amp;lt;span class=&amp;quot;badge badge-success badge-pill&amp;quot; v-if=&amp;quot;item.isCompleted&amp;quot;&amp;gt;已完成&amp;lt;/span&amp;gt;
			&amp;lt;span class=&amp;quot;badge badge-warning badge-pill&amp;quot; v-else&amp;gt;未完成&amp;lt;/span&amp;gt;
		&amp;lt;/li&amp;gt;
	&amp;lt;/ul&amp;gt;
&amp;lt;/template&amp;gt;

&amp;lt;script&amp;gt;
	export default &amp;#123;
		name: &#39;todoList&#39;,
		props: &amp;#123;
			todolist: &amp;#123;
				type: Array,
				required: true,
				default: [],
			&amp;#125;
		&amp;#125;
	&amp;#125;
&amp;lt;/script&amp;gt;

&amp;lt;style scoped&amp;gt;
	.list-group &amp;#123;
		width: 40%;
		margin: 20px auto;
	&amp;#125;

	.delete &amp;#123;
		text-decoration: line-through;
	&amp;#125;
&amp;lt;/style&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;App.vue&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;template&amp;gt;
	&amp;lt;div id=&amp;quot;app&amp;quot;&amp;gt;
		&amp;lt;h1&amp;gt;TodoList&amp;lt;/h1&amp;gt;
		&amp;lt;h6&amp;gt;edit by Chen&amp;lt;/h6&amp;gt;
		&amp;lt;!-- @ 用于处理事件，而 : 用于处理属性绑定。这两个符号都是Vue.js中的常见语法糖，使代码更简洁易读 --&amp;gt;
		&amp;lt;!-- @ 符号是 v-on 指令的缩写。它用于监听DOM事件并触发相应的Vue实例中的方法。 --&amp;gt;
		&amp;lt;!-- : 符号是 v-bind 指令的缩写。它用于动态绑定属性或表达式 --&amp;gt;
		&amp;lt;!-- 查自chatgpt 2023/12/11 --&amp;gt;
		&amp;lt;todoInput @addTask=&amp;quot;addTask&amp;quot;&amp;gt;&amp;lt;/todoInput&amp;gt;
		&amp;lt;todoList :todolist=&amp;quot;todoList&amp;quot;&amp;gt;&amp;lt;/todoList&amp;gt;
		&amp;lt;todoButton @changeActive=&amp;quot;changeActive&amp;quot;&amp;gt;&amp;lt;/todoButton&amp;gt;
	&amp;lt;/div&amp;gt;
&amp;lt;/template&amp;gt;

&amp;lt;script&amp;gt;
	import todoList from &#39;./components/todoList.vue&#39;
	import todoButton from &#39;./components/todoButton.vue&#39;
	import todoInput from &#39;./components/todoInput.vue&#39;

	export default &amp;#123;
		name: &amp;quot;App&amp;quot;,
		data() &amp;#123;
			return &amp;#123;
				// 假数据
				todoList: [&amp;#123;
						id: 1,
						task: &#39;吃饭&#39;,
						isCompleted: true
					&amp;#125;,
					&amp;#123;
						id: 2,
						task: &#39;嘻嘻嘻&#39;,
						isCompleted: false
					&amp;#125;,
					&amp;#123;
						id: 3,
						task: &#39;zzzzzzzz&#39;,
						isCompleted: true
					&amp;#125;,
				],
				active: 0,
			&amp;#125;;
		&amp;#125;,
		computed: &amp;#123;
			todoList() &amp;#123;
				if (this.active === 0) &amp;#123;
					return this.todoList;
				&amp;#125; else if (this.active === 1) &amp;#123;
					return this.todoList.filter(item =&amp;gt; item.isCompleted);
				&amp;#125; else &amp;#123;
					return this.todoList.filter(item =&amp;gt; !item.isCompleted);
				&amp;#125;
			&amp;#125;
		&amp;#125;,
		methods: &amp;#123;
			changeActive(active) &amp;#123;
				this.active = active;
				console.log(this.active);
			&amp;#125;,
			addTask(taskname) &amp;#123;
				this.todoList.push(&amp;#123;
					id: this.todoList.length + 1,
					task: taskname,
					isCompleted: false,
				&amp;#125;)
			&amp;#125;,
		&amp;#125;,
		components: &amp;#123;
			todoList,
			todoButton,
			todoInput
		&amp;#125;
	&amp;#125;
&amp;lt;/script&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;main.vue&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;import &amp;#123; createApp &amp;#125; from &#39;vue&#39;
import App from &#39;./App.vue&#39;
import &#39;./assets/css/bootstrap.css&#39;
import &#39;./index.css&#39;

createApp(App).mount(&#39;#app&#39;)

&lt;/code&gt;&lt;/pre&gt;
</content>
        <category term="vue3" />
        <updated>2023-12-11T08:52:51.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2023/11/07/leetcodeDP/</id>
        <title>“leetcodeDP”</title>
        <link rel="alternate" href="http://example.com/2023/11/07/leetcodeDP/"/>
        <content type="html">&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9sZWV0Y29kZS5jbi9wcm9ibGVtcy90cmlhbmdsZS8=&#34;&gt;120. 三角形最小路径和&lt;/span&gt;&lt;/p&gt;
&lt;figure class=&#34;highlight python&#34;&gt;&lt;figcaption data-lang=&#34;python&#34;&gt;&lt;/figcaption&gt;&lt;table&gt;&lt;tr&gt;&lt;td data-num=&#34;1&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;class&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Solution&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;2&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;minimumTotal&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;self&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; triangle&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; List&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;List&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token operator&#34;&gt;&gt;&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;3&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# [2],&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;4&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# [3,4],&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;5&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# [6,5,7],&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;6&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# [4,1,8,3]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;7&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# dp[k][i] += min(dp[k-1][i-1], dp[k-1][i])&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;8&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        n &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;len&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;triangle&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;9&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;for&lt;/span&gt; i &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;range&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; n&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;10&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            m &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; i &lt;span class=&#34;token operator&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;11&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token keyword&#34;&gt;for&lt;/span&gt; j &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;range&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;m&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;12&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;                &lt;span class=&#34;token keyword&#34;&gt;if&lt;/span&gt; j &lt;span class=&#34;token operator&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;13&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;                    triangle&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;j&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;+=&lt;/span&gt; triangle&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;i&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;j&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;14&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;                &lt;span class=&#34;token keyword&#34;&gt;elif&lt;/span&gt; j &lt;span class=&#34;token operator&#34;&gt;==&lt;/span&gt; m&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;15&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;                    triangle&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;j&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;+=&lt;/span&gt; triangle&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;i&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;j&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;16&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;                &lt;span class=&#34;token keyword&#34;&gt;else&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;17&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;                    triangle&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;j&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;min&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;triangle&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;i&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;j&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; triangle&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;i&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;j&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;18&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;min&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;triangle&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9sZWV0Y29kZS5jbi9wcm9ibGVtcy9taW5pbXVtLXBhdGgtc3VtLw==&#34;&gt;64. 最小路径和&lt;/span&gt;&lt;/p&gt;
&lt;figure class=&#34;highlight python&#34;&gt;&lt;figcaption data-lang=&#34;python&#34;&gt;&lt;/figcaption&gt;&lt;table&gt;&lt;tr&gt;&lt;td data-num=&#34;1&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;class&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Solution&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;2&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;minPathSum&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;self&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; grid&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; List&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;List&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token operator&#34;&gt;&gt;&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;3&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        n &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;len&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;grid&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;4&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        m &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;len&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;grid&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;5&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# 每次只能向下或者向右移动一步&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;6&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# -&gt; dp[next] = min(dp[left], dp[up]) + dp[i]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;7&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# 第一行只能从左往右，第一列只能从上往下&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;8&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;for&lt;/span&gt; i &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;range&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; n&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;9&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            grid&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;+=&lt;/span&gt; grid&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;i&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;10&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;for&lt;/span&gt; i &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;range&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; m&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;11&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            grid&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;+=&lt;/span&gt; grid&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;i&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;12&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;13&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;for&lt;/span&gt; i &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;range&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; n&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;14&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token keyword&#34;&gt;for&lt;/span&gt; j &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;range&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; m&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;15&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;                grid&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;j&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;min&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;grid&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;i&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;j&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; grid&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;j&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;16&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;17&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;return&lt;/span&gt; grid&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;n&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;m&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9sZWV0Y29kZS5jbi9wcm9ibGVtcy91bmlxdWUtcGF0aHMtaWkv&#34;&gt;63. 不同路径 II&lt;/span&gt;&lt;/p&gt;
&lt;figure class=&#34;highlight python&#34;&gt;&lt;figcaption data-lang=&#34;python&#34;&gt;&lt;/figcaption&gt;&lt;table&gt;&lt;tr&gt;&lt;td data-num=&#34;1&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;class&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Solution&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;2&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;uniquePathsWithObstacles&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;self&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; obstacleGrid&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; List&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;List&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token operator&#34;&gt;&gt;&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;3&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        n &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;len&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;obstacleGrid&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;4&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        m &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;len&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;obstacleGrid&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;5&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token decorator annotation punctuation&#34;&gt;@cache&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;6&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;dfs&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; j&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token operator&#34;&gt;&gt;&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;7&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token comment&#34;&gt;# 如果到达右下角且右下角不为 1，则当前路线有效&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;8&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token keyword&#34;&gt;if&lt;/span&gt; i &lt;span class=&#34;token operator&#34;&gt;==&lt;/span&gt; n&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;and&lt;/span&gt; j &lt;span class=&#34;token operator&#34;&gt;==&lt;/span&gt; m&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;and&lt;/span&gt; obstacleGrid&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;j&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;!=&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;9&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;                &lt;span class=&#34;token keyword&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;10&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token comment&#34;&gt;# 如果越界或者碰到阻碍，则无效&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;11&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token keyword&#34;&gt;if&lt;/span&gt; i &lt;span class=&#34;token operator&#34;&gt;&gt;=&lt;/span&gt; n &lt;span class=&#34;token keyword&#34;&gt;or&lt;/span&gt; j &lt;span class=&#34;token operator&#34;&gt;&gt;=&lt;/span&gt; m &lt;span class=&#34;token keyword&#34;&gt;or&lt;/span&gt; obstacleGrid&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;j&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;12&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;                &lt;span class=&#34;token keyword&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;13&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token comment&#34;&gt;# 返回 向左走向下走&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;14&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token keyword&#34;&gt;return&lt;/span&gt; dfs&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;i&lt;span class=&#34;token operator&#34;&gt;+&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; j&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;+&lt;/span&gt; dfs&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; j&lt;span class=&#34;token operator&#34;&gt;+&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;15&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;return&lt;/span&gt; dfs&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;</content>
        <category term="dp" />
        <updated>2023-11-07T11:52:00.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2023/11/01/leetcode369/</id>
        <title>leetcode369</title>
        <link rel="alternate" href="http://example.com/2023/11/01/leetcode369/"/>
        <content type="html">&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9sZWV0Y29kZS5jbi9wcm9ibGVtcy9maW5kLXRoZS1rLW9yLW9mLWFuLWFycmF5Lw==&#34;&gt;2917. 找出数组中的 K-or 值&lt;/span&gt;&lt;/p&gt;
&lt;figure class=&#34;highlight python&#34;&gt;&lt;figcaption data-lang=&#34;python&#34;&gt;&lt;/figcaption&gt;&lt;table&gt;&lt;tr&gt;&lt;td data-num=&#34;1&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;class&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Solution&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;2&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;findKOr&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;self&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; nums&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; List&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; k&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token operator&#34;&gt;&gt;&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;3&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# 位运算&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;4&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        ans &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;5&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;# num &amp;lt; 2^31, i 是第 i 位&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;6&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;for&lt;/span&gt; i &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;range&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;31&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;7&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            cnt &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;8&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token comment&#34;&gt;# 所有数的二进制的第 i 位是否为 1&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;9&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token keyword&#34;&gt;for&lt;/span&gt; num &lt;span class=&#34;token keyword&#34;&gt;in&lt;/span&gt; nums&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;10&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;                &lt;span class=&#34;token keyword&#34;&gt;if&lt;/span&gt; num &lt;span class=&#34;token operator&#34;&gt;&gt;&gt;&lt;/span&gt; i &lt;span class=&#34;token operator&#34;&gt;&amp;amp;&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;11&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;                    cnt &lt;span class=&#34;token operator&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;12&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token comment&#34;&gt;# 满足条件，加&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;13&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token keyword&#34;&gt;if&lt;/span&gt; cnt &lt;span class=&#34;token operator&#34;&gt;&gt;=&lt;/span&gt; k&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;14&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;                ans &lt;span class=&#34;token operator&#34;&gt;|&lt;/span&gt;&lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt; i&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;15&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;return&lt;/span&gt; ans&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9sZWV0Y29kZS5jbi9wcm9ibGVtcy9taW5pbXVtLWVxdWFsLXN1bS1vZi10d28tYXJyYXlzLWFmdGVyLXJlcGxhY2luZy16ZXJvcy8=&#34;&gt;2918. 数组的最小相等和&lt;/span&gt;&lt;/p&gt;
&lt;figure class=&#34;highlight python&#34;&gt;&lt;figcaption data-lang=&#34;python&#34;&gt;&lt;/figcaption&gt;&lt;table&gt;&lt;tr&gt;&lt;td data-num=&#34;1&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;class&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Solution&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;2&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;minSum&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;self&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; nums1&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; List&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; nums2&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; List&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token operator&#34;&gt;&gt;&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;3&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        sum1 &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;sum&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;nums1&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;4&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        cnt1 &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; nums1&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;count&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;5&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        sum2 &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;sum&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;nums2&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;6&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        cnt2 &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; nums2&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;count&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;7&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;8&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;if&lt;/span&gt; cnt1&lt;span class=&#34;token operator&#34;&gt;==&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;and&lt;/span&gt; cnt2&lt;span class=&#34;token operator&#34;&gt;==&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;and&lt;/span&gt; sum1 &lt;span class=&#34;token operator&#34;&gt;!=&lt;/span&gt; sum2 &lt;span class=&#34;token keyword&#34;&gt;or&lt;/span&gt; cnt1&lt;span class=&#34;token operator&#34;&gt;==&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;and&lt;/span&gt; sum2 &lt;span class=&#34;token operator&#34;&gt;+&lt;/span&gt; cnt2&lt;span class=&#34;token operator&#34;&gt;&gt;&lt;/span&gt;sum1 &lt;span class=&#34;token keyword&#34;&gt;or&lt;/span&gt; cnt2&lt;span class=&#34;token operator&#34;&gt;==&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;and&lt;/span&gt; sum1 &lt;span class=&#34;token operator&#34;&gt;+&lt;/span&gt; cnt1&lt;span class=&#34;token operator&#34;&gt;&gt;&lt;/span&gt;sum2&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;9&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token keyword&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;10&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;11&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;max&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;sum1&lt;span class=&#34;token operator&#34;&gt;+&lt;/span&gt;cnt1&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; sum2&lt;span class=&#34;token operator&#34;&gt;+&lt;/span&gt;cnt2&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;p&gt;&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly9sZWV0Y29kZS5jbi9wcm9ibGVtcy9taW5pbXVtLWluY3JlbWVudC1vcGVyYXRpb25zLXRvLW1ha2UtYXJyYXktYmVhdXRpZnVsLw==&#34;&gt;2919. 使数组变美的最小增量运算数&lt;/span&gt;&lt;/p&gt;
&lt;figure class=&#34;highlight python&#34;&gt;&lt;figcaption data-lang=&#34;python&#34;&gt;&lt;/figcaption&gt;&lt;table&gt;&lt;tr&gt;&lt;td data-num=&#34;1&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;class&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Solution&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;2&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;minIncrementOperations&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;self&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; nums&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; List&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; k&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token operator&#34;&gt;&gt;&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;3&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token comment&#34;&gt;#python3 注解，记忆化搜索，其他语言可用 visit [] 数组记录&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;4&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token decorator annotation punctuation&#34;&gt;@cache&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;5&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;def&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;dp&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; j&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token operator&#34;&gt;&gt;&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;int&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;6&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token keyword&#34;&gt;if&lt;/span&gt; i &lt;span class=&#34;token operator&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;7&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;                &lt;span class=&#34;token keyword&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;8&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token comment&#34;&gt;# 不选&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;9&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            res &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; dp&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;i&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token operator&#34;&gt;+&lt;/span&gt;  &lt;span class=&#34;token operator&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;max&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;k&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;nums&lt;span class=&#34;token punctuation&#34;&gt;[&lt;/span&gt;i&lt;span class=&#34;token punctuation&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;10&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token comment&#34;&gt;# 选&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;11&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token keyword&#34;&gt;if&lt;/span&gt; j &lt;span class=&#34;token operator&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;:&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;12&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;                res &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token builtin&#34;&gt;min&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;res&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; dp&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;i&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; j&lt;span class=&#34;token operator&#34;&gt;+&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;13&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token keyword&#34;&gt;return&lt;/span&gt; res&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;14&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;15&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;return&lt;/span&gt; dp&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token builtin&#34;&gt;len&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;nums&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token operator&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;token number&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;token number&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;</content>
        <category term="dp" />
        <category term="位运算" />
        <category term="分类讨论" />
        <updated>2023-11-01T14:00:47.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2023/10/23/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F01/</id>
        <title>设计模式01</title>
        <link rel="alternate" href="http://example.com/2023/10/23/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F01/"/>
        <content type="html">&lt;p&gt;跟着该视频做的一个笔记&lt;span class=&#34;exturl&#34; data-url=&#34;aHR0cHM6Ly93d3cuYmlsaWJpbGkuY29tL3ZpZGVvL0JWMUc0NDExYzdONA==&#34;&gt;尚硅谷 Java 设计模式（图解 + 框架源码剖析）&lt;/span&gt;&lt;/p&gt;
&lt;h1 id=&#34;设计模式&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#设计模式&#34;&gt;#&lt;/a&gt; 设计模式&lt;/h1&gt;
&lt;h2 id=&#34;1设计模式的目的&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#1设计模式的目的&#34;&gt;#&lt;/a&gt; 1 设计模式的目的&lt;/h2&gt;
&lt;p&gt;编写软件过程中，程序员面临着来自&lt;strong&gt;耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性&lt;/strong&gt;等多方面的挑战，设计模式是为了让程序 (软件)，具有更好的&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;代码重用性 (即：相同功能的代码，不用多次编写)&lt;/li&gt;
&lt;li&gt;可读性 (即：编程规范性，便于其他程序员的阅读和理解)&lt;/li&gt;
&lt;li&gt;可扩展性 (即：当需要增加新的功能时，非常的方便，称为可维护)&lt;/li&gt;
&lt;li&gt;可靠性 (即：当我们增加新的功能后，对原来的功能没有影响)&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;使程序呈现&lt;strong&gt;高内聚，低耦合&lt;/strong&gt;的特性&lt;/p&gt;
&lt;h2 id=&#34;2设计模式七大原则&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#2设计模式七大原则&#34;&gt;#&lt;/a&gt; 2 设计模式七大原则&lt;/h2&gt;
&lt;p&gt;设计模式原则，其实就是程序员在编程时，应当遵守的原则，也是各种设计模式的基础 (即：设计模式为什么这样设计的依据)&lt;/p&gt;
&lt;p&gt;设计模式常用的七大原则有:&lt;/p&gt;
&lt;h3 id=&#34;21-单一职责原则single-responsibility-principle&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#21-单一职责原则single-responsibility-principle&#34;&gt;#&lt;/a&gt; 2.1 单一职责原则（Single Responsibility Principle）&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;降低类的复杂度，一个类只负责一项职责&lt;/li&gt;
&lt;li&gt;提高类的可读性，可维护性，降低变更引起的风险&lt;/li&gt;
&lt;li&gt;通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;对类来说的，即一个类应该只负责&lt;strong&gt;一项职责&lt;/strong&gt;。如类 A 负责两个不同职责：职责 1，职责 2。当职责 1 需求变更而改变 A 时，可能造成职责 2 执行错误，所以需要将类 A 的粒度分解为 A1，A2&lt;/p&gt;
&lt;h3 id=&#34;22接口隔离原则interface-segregation-principle&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#22接口隔离原则interface-segregation-principle&#34;&gt;#&lt;/a&gt; 2.2 接口隔离原则（Interface Segregation Principle）&lt;/h3&gt;
&lt;p&gt;客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上&lt;/p&gt;
&lt;p&gt;也就是说接口要细拆分，类只需要实现相关的接口，不需要实现用不到的&lt;/p&gt;
&lt;h3 id=&#34;23依赖倒转倒置原则dependence-inversion-principle&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#23依赖倒转倒置原则dependence-inversion-principle&#34;&gt;#&lt;/a&gt; 2.3 依赖倒转 (倒置) 原则（Dependence Inversion Principle）&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;高层模块不应该依赖低层模块，二者都应该依赖其抽象&lt;/li&gt;
&lt;li&gt;抽象不应该依赖细节，细节应该依赖抽象&lt;/li&gt;
&lt;li&gt;依赖倒转 (倒置) 的中心思想是面向接口编程&lt;/li&gt;
&lt;li&gt;依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在 java 中，抽象指的是接口或抽象类，细节就是具体的实现类&lt;/li&gt;
&lt;li&gt;使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;依赖倒转原则的注意事项和细节&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;低层模块尽量都要有抽象类或接口&lt;/strong&gt;，或者两者都有，程序稳定性更好，最好不要一个类孤零零的&lt;/li&gt;
&lt;li&gt;变量的声明类型尽量是抽象类或接口，这样我们的变量引用和实际对象间，就存在一个&lt;strong&gt;缓冲层&lt;/strong&gt;，利于程序扩展和优化&lt;/li&gt;
&lt;li&gt;继承时遵循里氏替换原则&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;24里氏替换原则liskov-substitution-principle&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#24里氏替换原则liskov-substitution-principle&#34;&gt;#&lt;/a&gt; 2.4 里氏替换原则（Liskov Substitution Principle）&lt;/h3&gt;
&lt;blockquote&gt;
&lt;p&gt;OO 中的继承性的思考和说明：&lt;/p&gt;
&lt;p&gt;继承包含这样一层含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然它不强制要求所有的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏。&lt;/p&gt;
&lt;p&gt;继承在给程序设计带来便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低，增加对象间的耦合性，如果一个类被其他的类所继承则当这个类需要修改时，必须考虑到所有的子类，并且父类修改后，所有涉及到子类的功能都有可能产生故障&lt;/p&gt;
&lt;p&gt;问题提出：在编程中，&lt;strong&gt;如何正确的使用继承&lt;/strong&gt;？=&amp;gt; 里氏替换原则&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;在使用继承时，遵循里氏替换原则，在&lt;strong&gt;子类中尽量不要重写父类的方法&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖来解决问题。&lt;/p&gt;
&lt;h3 id=&#34;25开闭原则open-closed-principle&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#25开闭原则open-closed-principle&#34;&gt;#&lt;/a&gt; 2.5 开闭原则 (Open Closed Principle)&lt;/h3&gt;
&lt;p&gt;开闭原则是编程中&lt;em&gt;&lt;strong&gt;最基础、最重要&lt;/strong&gt;&lt;/em&gt;的设计原则&lt;/p&gt;
&lt;p&gt;一个软件实体如类、模块和函数应该对扩展开放 (对提供方)，对修改关闭 (对使用方)。用抽象构建框架，用实扩展细节。&lt;/p&gt;
&lt;p&gt;当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化&lt;/p&gt;
&lt;h3 id=&#34;26迪米特法则demeter-principle&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#26迪米特法则demeter-principle&#34;&gt;#&lt;/a&gt; 2.6 迪米特法则（Demeter Principle）&lt;/h3&gt;
&lt;p&gt;迪米特法则的核心是降低类之间的耦合。由于每个类都减少了不必要的依赖，因此迪米特法则只是要求降低类间 (对象间) 耦合关系， 并不是要求完全没有依赖关系&lt;/p&gt;
&lt;p&gt;迪米特法则又叫&lt;strong&gt;最少知道原则&lt;/strong&gt;，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。对外除了提供的 public 方法，不对外泄露任何信息。迪米特法则还有个更简单的定义：只与直接的朋友通信&lt;/p&gt;
&lt;p&gt;直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖，关联，组合，聚合等。其中，我们称出现成员变量、方法参数、方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。&lt;/p&gt;
&lt;h3 id=&#34;27合成复用原则composite-reuse-principle&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#27合成复用原则composite-reuse-principle&#34;&gt;#&lt;/a&gt; 2.7 合成复用原则 (Composite Reuse Principle)&lt;/h3&gt;
&lt;p&gt;原则是尽量使用合成 / 聚合的方式，而不是使用继承&lt;/p&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240301154812906.png&#34; alt=&#34;&#34; /&gt;&lt;/p&gt;
&lt;h3 id=&#34;28设计模式的原则核心&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#28设计模式的原则核心&#34;&gt;#&lt;/a&gt; 2.8 设计模式的原则核心&lt;/h3&gt;
&lt;p&gt;找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。&lt;/p&gt;
&lt;p&gt;针对接口编程，而不是针对实现编程。&lt;/p&gt;
&lt;p&gt;为了交互对象之间的松耦合设计而努力。&lt;/p&gt;
&lt;h2 id=&#34;3uml类图&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#3uml类图&#34;&gt;#&lt;/a&gt; 3.UML 类图&lt;/h2&gt;
&lt;h3 id=&#34;31基本介绍&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#31基本介绍&#34;&gt;#&lt;/a&gt; 3.1 基本介绍&lt;/h3&gt;
&lt;p&gt;&lt;img data-src=&#34;image-20240301155116451.png&#34; alt=&#34;image-20240301155116451&#34; /&gt;&lt;/p&gt;
&lt;h3 id=&#34;32类图分类&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#32类图分类&#34;&gt;#&lt;/a&gt; 3.2 类图分类&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;用例图（use case）&lt;/li&gt;
&lt;li&gt;静态结构图: &lt;strong&gt;类图&lt;/strong&gt;、对象图、包图、组件图、部署图&lt;/li&gt;
&lt;li&gt;动态行为图：交互图 (时序图与协作图)、状态图、活动图&lt;/li&gt;
&lt;/ol&gt;
&lt;h3 id=&#34;33类之间的关系&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#33类之间的关系&#34;&gt;#&lt;/a&gt; 3.3 类之间的关系&lt;/h3&gt;
&lt;p&gt;依赖、泛化（继承）、实现、关联、聚合、组合&lt;/p&gt;
&lt;h4 id=&#34;依赖&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#依赖&#34;&gt;#&lt;/a&gt; 依赖&lt;/h4&gt;
&lt;p&gt;只要类中用到了对方，则构成依赖关系&lt;/p&gt;
&lt;p&gt;类成员属性、方法返回类型、方法参数接受的参数类型、方法中使用到&lt;/p&gt;
&lt;h4 id=&#34;泛化继承&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#泛化继承&#34;&gt;#&lt;/a&gt; 泛化（继承）&lt;/h4&gt;
&lt;p&gt;继承，依赖关系的特例&lt;/p&gt;
&lt;h4 id=&#34;实现&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#实现&#34;&gt;#&lt;/a&gt; 实现&lt;/h4&gt;
&lt;p&gt;接口实现，依赖关系的特例&lt;/p&gt;
&lt;h4 id=&#34;关联&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#关联&#34;&gt;#&lt;/a&gt; 关联&lt;/h4&gt;
&lt;p&gt;类与类之间的联系，依赖关系的特例&lt;/p&gt;
&lt;h4 id=&#34;聚合&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#聚合&#34;&gt;#&lt;/a&gt; 聚合&lt;/h4&gt;
&lt;p&gt;表示整体和部分的关系，整体和部分能分开，关联关系特例（private A；）&lt;/p&gt;
&lt;p&gt;如果不能分开，则升级为组合关系（private A = new A（）；）&lt;/p&gt;
&lt;h4 id=&#34;组合&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#组合&#34;&gt;#&lt;/a&gt; 组合&lt;/h4&gt;
&lt;p&gt;整体和部分不能分开&lt;/p&gt;
&lt;h2 id=&#34;4设计模式概述&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#4设计模式概述&#34;&gt;#&lt;/a&gt; 4. 设计模式概述&lt;/h2&gt;
&lt;p&gt;设计模式分为三种类型，共 23 种（？）&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;创建型模式&lt;/strong&gt;：&amp;lt;u&amp;gt; 单例模式 &amp;lt;/u&amp;gt;、抽象工厂模式、原型模式、建造者模式、&amp;lt;u &amp;gt; 工厂模式 &amp;lt;/u&amp;gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;结构型模式&lt;/strong&gt;：适配器模式、桥接模式、&amp;lt;u&amp;gt; 装饰模式 &amp;lt;/u&amp;gt;、组合模式、外观模式、享元模式、&amp;lt;u &amp;gt; 代理模式 &amp;lt;/u&amp;gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;行为型模式&lt;/strong&gt;：模版方法模式、命令模式、访问者模式、迭代器模式、&amp;lt;u&amp;gt; 观察者模式 &amp;lt;/u&amp;gt;、中介者模式、备忘录模式、解释器模式 (Interpreter 模式)、状态模式、策略模式、职责链模式 (责任链模式)&lt;/li&gt;
&lt;/ol&gt;
&lt;h3 id=&#34;单例模式&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#单例模式&#34;&gt;#&lt;/a&gt; 单例模式&lt;/h3&gt;
&lt;p&gt;单例模式有八种方式&lt;/p&gt;
&lt;h4 id=&#34;饿汉式静态常量&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#饿汉式静态常量&#34;&gt;#&lt;/a&gt; 饿汉式 (静态常量)&lt;/h4&gt;
&lt;figure class=&#34;highlight java&#34;&gt;&lt;figcaption data-lang=&#34;java&#34;&gt;&lt;/figcaption&gt;&lt;table&gt;&lt;tr&gt;&lt;td data-num=&#34;1&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;// 饿汉式（静态变量）&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;2&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;// 用之前就创建&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;3&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;class&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;4&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;5&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;// 构造器私有化，外部不能 new&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;6&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;private&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;7&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;8&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;9&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;// 本类内部创建对象实例&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;10&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;private&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;final&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;static&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton&lt;/span&gt; instance &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;new&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;11&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;12&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;// 提供一个公有的静态方法，返回对象实例&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;13&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;public&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;static&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;getInstance&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;14&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;return&lt;/span&gt; instance&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;15&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;16&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;p&gt;避免了线程同步问题，但是没实现懒加载，&lt;strong&gt;可能&lt;/strong&gt;会造成内存浪费&lt;/p&gt;
&lt;h4 id=&#34;饿汉式静态代码块&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#饿汉式静态代码块&#34;&gt;#&lt;/a&gt; 饿汉式 (静态代码块)&lt;/h4&gt;
&lt;figure class=&#34;highlight java&#34;&gt;&lt;figcaption data-lang=&#34;java&#34;&gt;&lt;/figcaption&gt;&lt;table&gt;&lt;tr&gt;&lt;td data-num=&#34;1&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;……&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;2&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token comment&#34;&gt;// 静态代码块&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;3&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;static&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;4&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        instance &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;new&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;5&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;6&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;……&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;h4 id=&#34;懒汉式线程不安全&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#懒汉式线程不安全&#34;&gt;#&lt;/a&gt; 懒汉式 (线程不安全)&lt;/h4&gt;
&lt;figure class=&#34;highlight java&#34;&gt;&lt;figcaption data-lang=&#34;java&#34;&gt;&lt;/figcaption&gt;&lt;table&gt;&lt;tr&gt;&lt;td data-num=&#34;1&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;class&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton02&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;2&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;// 构造器私有化，外部不能 new&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;3&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;private&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton02&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;4&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;5&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;6&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;private&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;static&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton02&lt;/span&gt; instance&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;7&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;8&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;// 提供一个静态的公有方法，当使用到该方法时，才去创建&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;9&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;// 饿汉模式&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;10&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;//synchronized, 解决线程同步问题，但是效率低，后续获取都要进行同步&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;11&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;public&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;static&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;synchronized&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton02&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;getInstance&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;12&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;instance &lt;span class=&#34;token operator&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;null&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;13&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            instance &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;new&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton02&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;14&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;return&lt;/span&gt; instance&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;15&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;16&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;h4 id=&#34;懒汉式线程安全同步方法&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#懒汉式线程安全同步方法&#34;&gt;#&lt;/a&gt; 懒汉式 (线程安全，同步方法)&lt;/h4&gt;
&lt;pre&gt;&lt;code&gt;synchronized //效率低，不使用
&lt;/code&gt;&lt;/pre&gt;
&lt;h4 id=&#34;懒汉式线程安全同步代码块&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#懒汉式线程安全同步代码块&#34;&gt;#&lt;/a&gt; 懒汉式 (线程安全，同步代码块)&lt;/h4&gt;
&lt;figure class=&#34;highlight java&#34;&gt;&lt;figcaption data-lang=&#34;java&#34;&gt;&lt;/figcaption&gt;&lt;table&gt;&lt;tr&gt;&lt;td data-num=&#34;1&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;public&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;static&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;synchronized&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton02&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;getInstance&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;2&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;instance &lt;span class=&#34;token operator&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;null&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;3&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token comment&#34;&gt;// 当多个现程进入后，即使一个个来，但是还是会选择创建，不使用&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;4&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token keyword&#34;&gt;synchronized&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token class-name&#34;&gt;Singleton02&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;token keyword&#34;&gt;class&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;5&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;                instance &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;new&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton02&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;6&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;            &lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;7&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;8&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;return&lt;/span&gt; instance&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;9&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;h4 id=&#34;双重检查&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#双重检查&#34;&gt;#&lt;/a&gt; 双重检查&lt;/h4&gt;
&lt;pre&gt;&lt;code&gt;public static synchronized Singleton02 getInstance() &amp;#123;
        if (instance == null) &amp;#123;
            synchronized (Singleton02.class) &amp;#123;
                if (instance == null)
                    instance = new Singleton02();
            &amp;#125;
        &amp;#125;
        return instance;
&amp;#125;
&lt;/code&gt;&lt;/pre&gt;
&lt;h4 id=&#34;静态内部类&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#静态内部类&#34;&gt;#&lt;/a&gt; 静态内部类&lt;/h4&gt;
&lt;figure class=&#34;highlight java&#34;&gt;&lt;figcaption data-lang=&#34;java&#34;&gt;&lt;/figcaption&gt;&lt;table&gt;&lt;tr&gt;&lt;td data-num=&#34;1&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;class&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton03&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;2&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;// 构造器私有化，外部不能 new&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;3&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;private&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton03&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;4&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;5&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;6&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token comment&#34;&gt;// 当外部类被装载时，静态内部类并不会装载&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;7&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;	&lt;span class=&#34;token comment&#34;&gt;// 当静态内部类装载时，是线程安全 (JVM 底层提供的机制)&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;8&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;private&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;static&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;class&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;SingletonInstance&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;9&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;private&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;static&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;final&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton03&lt;/span&gt; singleton &lt;span class=&#34;token operator&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;new&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton03&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;10&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;11&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;12&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;public&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;static&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;synchronized&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton02&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;getInstance&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;13&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token keyword&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton02&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;token function&#34;&gt;getInstance&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;14&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;15&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;h4 id=&#34;枚举&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#枚举&#34;&gt;#&lt;/a&gt; 枚举&lt;/h4&gt;
&lt;p&gt;借助 JDK1.5 中添加的枚举类实现，不仅避免多线程同步问题，而且防止反序列化重新创建新的对象&lt;/p&gt;
&lt;figure class=&#34;highlight java&#34;&gt;&lt;figcaption data-lang=&#34;java&#34;&gt;&lt;/figcaption&gt;&lt;table&gt;&lt;tr&gt;&lt;td data-num=&#34;1&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token keyword&#34;&gt;enum&lt;/span&gt; &lt;span class=&#34;token class-name&#34;&gt;Singleton04&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;2&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token constant&#34;&gt;INSTANCE&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;token comment&#34;&gt;// 属性&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;3&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;4&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token keyword&#34;&gt;public&lt;/span&gt; &lt;span class=&#34;token keyword&#34;&gt;void&lt;/span&gt; &lt;span class=&#34;token function&#34;&gt;sayLove&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;token punctuation&#34;&gt;&amp;#123;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;5&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;        &lt;span class=&#34;token class-name&#34;&gt;System&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;out&lt;span class=&#34;token punctuation&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;token function&#34;&gt;println&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;token string&#34;&gt;&#34;heart~&#34;&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;token punctuation&#34;&gt;;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;6&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;    &lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td data-num=&#34;7&#34;&gt;&lt;/td&gt;&lt;td&gt;&lt;pre&gt;&lt;span class=&#34;token punctuation&#34;&gt;&amp;#125;&lt;/span&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;&lt;h4 id=&#34;单例模式注意事项和细节说明&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#单例模式注意事项和细节说明&#34;&gt;#&lt;/a&gt; 单例模式注意事项和细节说明&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;单例模式保证了 系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能&lt;/li&gt;
&lt;li&gt;当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new&lt;/li&gt;
&lt;li&gt;单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多 (即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象 (比如数据源、session 工厂等)&lt;/li&gt;
&lt;/ol&gt;
&lt;h3 id=&#34;工厂设计模式&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#工厂设计模式&#34;&gt;#&lt;/a&gt; 工厂设计模式&lt;/h3&gt;
&lt;h4 id=&#34;简单工厂&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#简单工厂&#34;&gt;#&lt;/a&gt; 简单工厂&lt;/h4&gt;
&lt;h4 id=&#34;工厂方法&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#工厂方法&#34;&gt;#&lt;/a&gt; 工厂方法&lt;/h4&gt;
&lt;h4 id=&#34;抽象工厂&#34;&gt;&lt;a class=&#34;anchor&#34; href=&#34;#抽象工厂&#34;&gt;#&lt;/a&gt; 抽象工厂&lt;/h4&gt;
</content>
        <category term="设计模式" />
        <updated>2023-10-23T07:03:19.000Z</updated>
    </entry>
    <entry>
        <id>http://example.com/2023/10/20/dp-normal/</id>
        <title>dp_normal</title>
        <link rel="alternate" href="http://example.com/2023/10/20/dp-normal/"/>
        <content type="html">&lt;p&gt;今晚写了几题简单的动态规划。&lt;/p&gt;
&lt;p&gt;##70. 爬楼梯&lt;br /&gt;
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。&lt;br /&gt;
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？&lt;/p&gt;
&lt;p&gt;### 时间复杂度: O (N)&lt;br /&gt;
### 空间复杂度：用数组记录 O (n)， 用 p1, p2 循环 O (1)&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-python3&#34;&gt;class Solution:
    def climbStairs(self, n: int) -&amp;gt; int:
        #p[i] = p[i-1] + p[i-2]
        if n==1:
            return 1
        if n==2:
            return 2
        # p = [0] * n
        # p[0] = 1
        # p[1] = 2
        # for i in range(2, n):
        #     p[i] = p[i-1] + p[i-2]
        # return p[i]
        p1 = 1
        p2 = 2
        for i in range(2, n):
            p2, p1 = p2+p1, p2
        return p2
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;##198. 打家劫舍&lt;br /&gt;
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。&lt;br /&gt;
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。&lt;/p&gt;
&lt;p&gt;### 时间复杂度: O (N)&lt;br /&gt;
### 空间复杂度：用数组记录 O (n)&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-python3&#34;&gt;class Solution:
    def rob(self, nums: List[int]) -&amp;gt; int:
        if len(nums)==1:
            return nums[0]
        if len(nums)==2:
            return max(nums[0], nums[1])
        # dp[i] = max(dp[i-1], dp[i-2]+nums[i])
        dp = [0] * len(nums)
        dp[0] = nums[0]
        dp[1] = max(nums[0], nums[1])
        for i in range(2, len(nums)):
            dp[i] = max(dp[i-1], dp[i-2]+nums[i])
        return dp[-1] 
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;##139. 单词拆分&lt;br /&gt;
给你一个字符串 s 和一个字符串列表 wordDict 作为字典。请你判断是否可以利用字典中出现的单词拼接出 s 。&lt;/p&gt;
&lt;p&gt;注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。&lt;/p&gt;
&lt;p&gt;示例 1：&lt;br /&gt;
输入: s = &amp;quot;leetcode&amp;quot;, wordDict = [&amp;quot;leet&amp;quot;, &amp;quot;code&amp;quot;]&lt;br /&gt;
 输出: true&lt;br /&gt;
 解释：返回 true 因为 &amp;quot;leetcode&amp;quot; 可以由 &amp;quot;leet&amp;quot; 和 &amp;quot;code&amp;quot; 拼接成。&lt;/p&gt;
&lt;p&gt;### 时间复杂度: O (N2)* 字符串查找&lt;br /&gt;
 ### 空间复杂度：用数组记录 O (n)&lt;/p&gt;
&lt;pre&gt;&lt;code class=&#34;language-Python3&#34;&gt;class Solution:
    def wordBreak(self, s: str, wordDict: List[str]) -&amp;gt; bool:
        # dp[x] = &amp;#123;dp[i] + isinword(s[i:x])&amp;#125;
        n = len(s)
        # dp[i]表示s的前i位是否可以用wordDict中的单词表示
        dp = [False] * (n+1)
        # 初始化dp[0]=True，空字符可以被表示
        dp[0] = True
        for i in range(n):
            for j in range(i+1, n+1):
                if dp[i] and s[i:j] in wordDict:
                    dp[j] = True
        return dp[-1]
&lt;/code&gt;&lt;/pre&gt;
</content>
        <category term="dp" />
        <updated>2023-10-20T15:39:14.000Z</updated>
    </entry>
</feed>