Android 打包AAB+PAD(java篇)（上）
AAB ? ? ? ?Android App Bundle 是 Android 新推出的一种官方发布格式，可让你以更高效的方式开发和发布应用。借助 Android App Bundle，你可以更轻松地以更小的应用提供优质的使用体验，从而提升安装成功率并减少卸载量。转换过程轻松便捷。你无需重构代码即可开始获享较小应用的优势。改用这种格式后，你可以体验模块化应用开发和可自定义功能交付，并从中受益。Play Asset Delivery ? ? ? ?Play Asset Delivery (PAD) 将 app bundle 的优势带到游戏中。它允许超过 150 MB 的游戏替换旧版扩展文件 (OBB)，方法是将包含游戏所需的所有资源的单个工件发布到 Play。PAD 提供了灵活的分发模式、自动更新、压缩和增量修补功能，并且可免费使用。使用 PAD，所有资源包均在 Google Play 上托管和提供，因此你无需使用内容分发网络 (CDN) 向玩家提供游戏资源。 ? ? ? ?Play Asset Delivery 使用资源包，资源包由资源（如纹理、着色器和声音）组成，但不包含可执行代码。通过 Dynamic Delivery，你可以按照以下三种分发模式自定义如何以及何时将各个资源包下载到设备上：安装时分发、快速跟进式分发和按需分发。分发模式 ? ? ? ?install-time 资源包在用户安装应用时分发。这些资源包以拆分 APK（APK 集的一部分）的形式提供。它们也称为“预先”资源包；你可以在应用启动时立即使用这些资源包。这些资源包会增加 Google Play 商店上列出的应用大小。用户无法修改或删除这些资源包。 ? ? ? ?fast-follow 资源包会在用户安装应用后立即自动下载；用户无需打开应用即可开始 fast-follow 下载。此类下载不会阻止用户访问应用。这些资源包会增加 Google Play 商店上列出的应用大小。 ? ? ? ?on-demand 资源包会在应用运行时下载。 ? ? ? ?Google Play 商店会以归档文件（而非拆分 APK）的形式提供配置为 fast-follow 和 on-demand 的资源包。这些资源包随后会在应用的内部存储空间中展开。你可以使用 Play Core API 查询以这种方式提供的资源包的位置。应用无法假设这些文件的存在或其位置，因为它们可能会被用户删除，或由 Play Core SDK 在游戏会话之间移动。尽管这些文件可由应用写入，你也应将其视为只读文件，因为资源包补丁程序依赖于这些文件的完整性。资源更新 ? ? ? ?更新应用时，install-time Asset Pack 会作为基础应用更新的一部分进行更新（开发者无需执行任何操作）。对于 fast-follow 和 on-demand Asset Pack 的应用更新，则遵循以下步骤：1、系统将应用的补丁程序（包括所有资产）下载到设备上的安全位置。2、更新应用二进制文件；这包括所有 install-time Asset Pack。3、之前下载的所有 Asset Pack 变为无效。4、将资产的补丁程序复制并应用到存储在应用内部存储空间中的资产。 ? ? ? ?在大多数情况下，当用户打开游戏时，整体更新已完成，用户可以立即开始玩更新后的版本。在极少数情况下，当用户打开应用时，应用二进制文件可能已完成更新，但资产的补丁程序应用过程尚未完成，因此用户尚无法访问这些资产。为了应对此类情形，你需要针对这些资产提供相应的“正在更新”界面元素，或构建逻辑来处理尚无法访问的无效资源。由于只有在所有 Asset Pack 类型均已下载后，应用二进制文件才会更新，因此补丁程序的应用操作会在本地以离线方式进行，且应快速完成。纹理压缩格式定位 ? ? ? ?纹理压缩是一种有损图像压缩，可让 GPU 使用专用硬件直接从压缩纹理进行渲染，从而减少所需的纹理内存和内存带宽用量。借助纹理压缩格式定位功能，你可以在 Android App Bundle 中添加使用多种纹理压缩格式压缩的纹理，并且依靠 Google Play 自动为每种设备提供采用最佳纹理压缩格式的资源。应用版本更新 ? ? ? ?新版本的应用上传到 Google Play 后，如果用户未在设备上更新该应用，他们可以打开之前的应用版本。在这种情况下，如有必要，应用可以通过调用 In-App Updates API 选择强制更新或建议更新。借助此 API，你可以从应用内触发更新，而不是让用户从 Google Play 商店触发更新。下载大小上限Asset Pack 因具有较高的大小上限而成为大型游戏的理想之选：1、每个 fast-follow 和 on-demand Asset Pack 的下载大小上限为 512 MB。2、所有 install-time Asset Pack 的总下载大小上限为 1 GB。3、一个 Android App Bundle 中的所有 Asset Pack 的总下载大小上限为 2 GB。4、一个 Android App Bundle 中最多可以使用 50 个资源包。如果你使用的是纹理压缩格式定位，那么这些下载限制会分别应用于每个独一无二的纹理格式。针对Java 代码构建 ? ? ? ?你可以按照以下步骤将 Play Asset Delivery 内置到项目的 Android App Bundle 中。你无需使用 Android Studio 即可执行这些步骤。1、将 Play Core 库导入项目。// In your app’s build.gradle file:
...
dependencies {
// This dependency is downloaded from the Google’s Maven repository.
// So, make sure you also include that repository in your project's build.gradle file.
implementation 'com.google.android.play:core:1.10.0'
// For Kotlin users also add the Kotlin extensions library for Play Core:
implementation 'com.google.android.play:core-ktx:1.8.1'
...
}Play Core KTX 库是可选的，为常规 Play Core 库中的异步方法调用提供了 Kotlin 协程版本，并且提供了其他有用的扩展，使得从 Kotlin 使用 API 更为得心应手。2、在项目的 build.gradle 文件中将 Android Gradle 插件的版本更新为4.0.0 或更高版本。3、在项目的顶级目录中，为 Asset Pack 创建一个目录。此目录名称将用作 Asset Pack 名称。Asset Pack 名称必须以字母开头，并且只能包含字母、数字和下划线。4、在 Asset Pack 目录中，创建一个 build.gradle 文件并添加以下代码。请务必指定 Asset Pack 的名称，并且仅指定一种分发类型：// In the asset pack’s build.gradle file:
apply plugin: 'com.android.asset-pack'
assetPack {
packName = "asset-pack-name" // Directory name for the asset pack
dynamicDelivery {
deliveryType = "[ install-time | fast-follow | on-demand ]"
}
}5、在项目的应用?build.gradle文件中，添加项目中每个 Asset Pack 的名称，如下所示：// In the app build.gradle file:
android {
...
assetPacks = [":asset-pack-name", ":asset-pack2-name"]
}6、在项目的?settings.gradle?文件中，添加项目中的所有 Asset Pack，如下所示：// In the settings.gradle file:
include ':app'
include ':asset-pack-name'
include ':asset-pack2-name'7、在 Asset Pack 目录中，创建以下子目录：src/main/assets。8、将资产放置在 src/main/assets 目录中。你也可以在此处创建子目录。应用的目录结构现在应如下所示：1)build.gradle2)settings.gradle3)app/4)asset-pack-name/build.gradle5)asset-pack-name/src/main/assets/your-asset-directories9、使用 Gradle 构建 Android App Bundle。在生成的 app bundle 中，根级目录现在包含以下内容：1)asset-pack-name/manifest/AndroidManifest.xml：配置 Asset Pack 的标识符和分发模式2)asset-pack-name/assets/your-asset-directories：此目录包含作为 Asset Pack 的一部分分发的所有资产Gradle 会为每个 Asset Pack 生成清单，并为你输出 assets/ 目录。10、(可选)配置 App Bundle 以支持不同的纹理压缩格式。常见的纹理压缩格式：DDS 或 S3TC：有时称为 DXTC 或 DXTn。OpenGL 支持此格式的三种形式。ETC1：大多数设备都支持此格式。这种格式不支持透明度，但游戏可将第二个纹理文件用于 Alpha 通道组件。ETC2：支持 GLES3 的所有设备均支持此格式。PVRTC：iOS 游戏常用的格式，在某些 Android 设备上也受支持。ASTC：专为取代之前的格式而设计的新格式。比先前的格式更加灵活，因为它支持各种块大小。使用这种格式可以帮助你优化游戏大小。支持的格式及支持相应格式设备所占的百分比：
Google Java编程风格规范(2020年4月原版翻译)
Google Java Style Guide这份文档是Google Java编程风格规范的完整定义。当且仅当一个Java源文件符合此文档中的规则， 我们才认为它符合Google的Java编程风格。与其它的编程风格指南一样，这里所讨论的不仅仅是编码格式美不美观的问题， 同时也讨论一些约定及编码标准。然而，这份文档主要侧重于我们所普遍遵循的规则， 对于那些不是明确强制要求的，我们尽量避免提供意见。1.1 术语说明在本文档中，除非另有说明：术语class可表示一个普通类，枚举类，接口或是annotation类型(@interface)术语comment只用来指代实现的注释(implementation comments)，我们不使用“documentation comments”一词，而是用Javadoc。其他的术语说明会偶尔在后面的文档出现。1.2 指南说明本文档中的示例代码并不作为规范。也就是说，虽然示例代码是遵循Google编程风格，但并不意味着这是展现这些代码的唯一方式。 示例中的格式选择不应该被强制定为规则。源文件基础2.1 文件名源文件以其最顶层的类名来命名，大小写敏感，文件扩展名为.java。2.2 文件编码：UTF-8源文件编码格式为UTF-8。2.3 特殊字符2.3.1 空白字符除了行结束符序列，ASCII水平空格字符(0×20，即空格)是源文件中唯一允许出现的空白字符，这意味着：所有其它字符串中的空白字符都要进行转义。制表符不用于缩进。2.3.2 特殊转义序列对于具有特殊转义序列的任何字符(\b, \t, \n, \f, \r, “, ‘及)，我们使用它的转义序列，而不是相应的八进制(比如\012)或Unicode(比如\u000a)转义。2.3.3 非ASCII字符对于剩余的非ASCII字符，是使用实际的Unicode字符(比如∞)，还是使用等价的Unicode转义符(比如\u221e)，取决于哪个能让代码更易于阅读和理解。Tip: 在使用Unicode转义符或是一些实际的Unicode字符时，建议做些注释给出解释，这有助于别人阅读和理解。例如：String unitAbbrev = "μs"; | 赞，即使没有注释也非常清晰String unitAbbrev = "\u03bcs"; // "μs" | 允许，但没有理由要这样做String unitAbbrev = "\u03bcs"; // Greek letter mu, "s" | 允许，但这样做显得笨拙还容易出错String unitAbbrev = "\u03bcs"; | 很糟，读者根本看不出这是什么return '\ufeff' + content; // byte order mark | Good，对于非打印字符，使用转义，并在必要时写上注释提示: 永远不要因为担心某些程序可能无法正确处理非 ascii 字符而降低代码的可读性。 如果出现这种情况，那些程序就会被破坏，必须修复。3 源文件结构一个源文件包含(按顺序地)：许可证或版权信息(如有需要)package语句import语句一个顶级类(只有一个)以上每个部分之间用一个空行隔开。3.1 许可证或版权信息如果一个文件包含许可证或版权信息，那么它应当被放在文件最前面。3.2 package语句package语句不换行，列限制(4.4节)并不适用于package语句。(即package语句写在一行里)3.3 import语句3.3.1 import不要使用通配符不使用通配符导入import java.util.*;，无论是静态导入还是其他导入。3.3.2 不要换行import语句不换行，列限制(4.4节, 列限制: 100)并不适用于import语句。(每个import语句独立成行)3.3.3 顺序和间距import语句可分为以下几组，按照这个顺序，每组由一个空行分隔：单个块中的所有静态导入单个块中的所有非静态导入如果同时存在静态和非静态导入，则用一个空行分隔这两个块。 导入语句之间没有其他空行。3.3.4 不要使用类的静态导入静态导入不要用于静态嵌套类，它们是通过正常导入导入的。3.4 类声明3.4.1 只有一个顶级类声明每个顶级类都在一个与它同名的源文件中。例外：package-info.java，该文件中可没有package-info类。3.4.2 类成员顺序类的成员顺序对易学性有很大的影响，但这也不存在唯一的通用法则。不同的类对成员的排序可能是不同的。 最重要的一点，每个类应该以某种逻辑去排序它的成员，维护者应该要能解释这种排序逻辑。比如， 新的方法不能总是习惯性地添加到类的结尾，因为这样就是按时间顺序, 而非某种逻辑来排序的。3.4.2.1 重载：永远不要拆分当一个类有多个构造函数，或是多个同名方法，这些函数/方法应该按顺序出现在一起，中间不要放进其它函数/方法。4 格式化术语说明：块状结构(block-like construct)指的是一个类，方法或构造函数的主体。需要注意的是，数组初始化中的初始值可被选择性地视为块状结构(4.8.3.1节)。4.1 大括号4.1.1 使用大括号(即使是可选的)大括号与if, else, for, do, while语句一起使用，即使只有一条语句(或是空)，也应该把大括号写上。4.1.2 非空块：K & R 风格对于非空块和块状结构，大括号遵循 Kernighan 和 Ritchie 风格 (Egyptian brackets):左大括号前不换行左大括号后换行右大括号前换行如果右大括号是一个语句、函数体或类的终止，则右大括号后换行; 否则不换行。例如，如果右大括号后面是else或逗号，则不换行。示例：return () -> {
while (condition()) {
method();
}
};
return new MyClass() {
@Override public void method() {
if (condition()) {
try {
something();
} catch (ProblemException e) {
recover();
}
} else if (otherCondition()) {
somethingElse();
} else {
lastThing();
}
}
};4.8.1节给出了enum类的一些例外。4.1.3 空块：可以用简洁版本一个空的块状结构里什么也不包含，大括号可以简洁地写成{}，不需要换行。例外：如果它是一个多块语句的一部分(if/else 或 try/catch/finally) ，即使大括号内没内容，右大括号也要换行。示例：// This is acceptable
void doNothing() {}
// This is equally acceptable
void doNothingElse() {
}这是不可接受的: 多块语句中没有简洁的空块// This is not acceptable: No concise empty blocks in a multi-block statement
try {
doSomething();
} catch (Exception e) {}4.2 块缩进：2个空格每当开始一个新的块，缩进增加2个空格，当块结束时，缩进返回先前的缩进级别。缩进级别适用于代码和注释。(见4.1.2节中的代码示例)4.3 一行一个语句每个语句后跟一个换行符(a line break)。4.4 列限制(Column limit)：100Java 代码的列限制为100个字符，除了下述例外，任何一行如果超过这个字符数限制，必须自动换行。例外：不可能满足列限制的行(例如，Javadoc中的一个长URL，或是一个长的JSNI方法参考)。package和import语句(见3.2节和3.3节)。注释中那些可能被剪切并粘贴到shell中的命令行。4.5 自动换行(Line-wrapping)术语注意: 当本来可以合法占用一行的代码被分成多行时，我们称之为自动换行(line-wrapping)。我们并没有全面，确定性的准则来决定在每一种情况下如何自动换行。很多时候，对于同一段代码会有好几种有效的自动换行方式。注意(Note): 虽然行换行的典型原因是为了避免溢出列限制，但即使是实际上符合列限制的代码也可能由作者自行决定是否进行行换行。提示(Tip): 提取方法或局部变量可以解决问题，而不需要换行。4.5.1 从哪里断开自动换行的基本准则是：更倾向于在更高的语法级别处断开。如果在非赋值运算符处断开，那么在该符号前断开(比如+，它将位于下一行)。注意：这一点与Google其它语言的编程风格不同(如C++和JavaScript)。 这条规则也适用于以下“类运算符”符号：点分隔符(.)，类型界限中的&（<T extends Foo & Bar>)，catch块中的管道符号(catch (FooException | BarException e)如果在赋值运算符处断开，通常的做法是在该符号后断开(比如=，它与前面的内容留在同一行)。这条规则也适用于foreach语句中的分号。方法名或构造函数名与左括号留在同一行。逗号(,)与其前面的内容留在同一行。在 lambda 中，与箭头相邻的直线不会断开，除非如果 lambda 的主体由单个无支撑表达式组成，那么在箭头之后可能会立即出现断开。 例子:MyLambda<String, Long, Object> lambda =
(String label, Long value, Object obj) -> {
...
};
Predicate<String> predicate = str ->
longExpressionInvolving(str);注意: 换行主要目标是有清晰的代码，而不一定是适合最小行数的代码。4.5.2 自动换行时缩进至少+4个空格自动换行时，第一行后的每一行至少比第一行多缩进4个空格(注意：制表符不用于缩进。见2.3.1节)。当存在连续自动换行时，缩进可能会多缩进不只4个空格(语法元素存在多级时)。一般而言，两个连续行使用相同的缩进当且仅当它们开始于同级语法元素。第4.6.3水平对齐一节中指出，不鼓励使用可变数目的空格来对齐前面行的符号。4.6 空白4.6.1 垂直空白以下情况需要使用一个空行：类内连续的成员之间：字段，构造函数，方法，嵌套类，静态初始化块，实例初始化块。例外：两个连续字段之间的空行是可选的，用于字段的空行主要用来对字段进行逻辑分组。在函数体内，语句的逻辑分组间使用空行。类内的第一个成员前或最后一个成员后的空行是可选的(既不鼓励也不反对这样做，视个人喜好而定)。要满足本文档中其他节的空行要求(比如3.3节：import语句)多个连续的空行是允许的，但没有必要这样做(我们也不鼓励这样做)。4.6.2 水平空白除了语言需求和其它规则，并且除了文字，注释和Javadoc用到单个空格，单个ASCII空格也出现在以下几个地方：分隔任何保留字与紧随其后的左括号(()(如if, for catch等)。分隔任何保留字与其前面的右大括号(})(如else, catch)。在任何左大括号前({)，两个例外：@SomeAnnotation({a, b})(不使用空格)。String[][] x = foo;(大括号间没有空格，见下面的Note)。在任何二元或三元运算符的两侧。这也适用于以下“类运算符”符号：类型界限中的&(<T extends Foo & Bar>)。catch块中的管道符号(catch (FooException | BarException e)。foreach语句中的分号。在, : ;及右括号())后如果在一条语句后做注释，则双斜杠(//)两边都要空格。这里可以允许多个空格，但没有必要。类型和变量之间：List<String> list数组初始化中，大括号内的空格是可选的，即new int[] {5, 6}和new int[] { 5, 6 }都是可以的。Note：这个规则并不要求或禁止一行的开关或结尾需要额外的空格，只对内部空格做要求。4.6.3 水平对齐：不做要求术语说明：水平对齐指的是通过增加可变数量的空格来使某一行的字符与上一行的相应字符对齐。这是允许的(而且在不少地方可以看到这样的代码)，但Google编程风格对此不做要求。即使对于已经使用水平对齐的代码，我们也不需要去保持这种风格。以下示例先展示未对齐的代码，然后是对齐的代码：private int x; // this is fine
private Color color; // this too
private int x; // permitted, but future edits
private Color color; // may leave it unalignedTip：对齐可增加代码可读性，但它为日后的维护带来问题。考虑未来某个时候，我们需要修改一堆对齐的代码中的一行。 这可能导致原本很漂亮的对齐代码变得错位。很可能它会提示你调整周围代码的空白来使这一堆代码重新水平对齐(比如程序员想保持这种水平对齐的风格)， 这就会让你做许多的无用功，增加了reviewer的工作并且可能导致更多的合并冲突。4.7 用小括号来限定组：推荐除非作者和reviewer都认为去掉小括号也不会使代码被误解，或是去掉小括号能让代码更易于阅读，否则我们不应该去掉小括号。 我们没有理由假设读者能记住整个Java运算符优先级表。4.8 特殊结构4.8.1 枚举类枚举常量间用逗号隔开，换行可选。private enum Answer {
YES {
@Override public String toString() {
return "yes";
}
},
NO,
MAYBE
}没有方法和文档的枚举类可写成数组初始化的格式：private enum Suit { CLUBS, HEARTS, SPADES, DIAMONDS }由于枚举类也是一个类，因此所有适用于其它类的格式规则也适用于枚举类。4.8.2 变量声明4.8.2.1 每次只声明一个变量不要使用组合声明，比如int a, b;。4.8.2.2 需要时才声明，并尽快进行初始化不要在一个代码块的开头把局部变量一次性都声明了(这是c语言的做法)，而是在第一次需要使用它时才声明。 局部变量在声明时最好就进行初始化，或者声明后尽快进行初始化。4.8.3 数组4.8.3.1 数组初始化：可写成块状结构数组初始化可以写成块状结构，比如，下面的写法都是OK的：new int[] { new int[] {
0, 1, 2, 3 0,
} 1,
2,
new int[] { 3,
0, 1, }
2, 3
} new int[]
{0, 1, 2, 3}4.8.3.2 非C风格的数组声明中括号是类型的一部分：String[] args， 而非String args[]。4.8.4 switch语句术语说明：switch块的大括号内是一个或多个语句组。每个语句组包含一个或多个switch标签(case FOO:或default:)，后面跟着一条或多条语句。4.8.4.1 缩进与其它块状结构一致，switch块中的内容缩进为2个空格。每个switch标签后新起一行，再缩进2个空格，写下一条或多条语句。4.8.4.2 Fall-through：注释在一个switch块内，每个语句组要么通过break, continue, return或抛出异常来终止，要么通过一条注释来说明程序将继续执行到下一个语句组， 任何能表达这个意思的注释都是OK的(典型的是用// fall through)。这个特殊的注释并不需要在最后一个语句组(一般是default)中出现。示例：switch (input) {
case 1:
case 2:
prepareOneOrTwo();
// fall through
case 3:
handleOneTwoOrThree();
break;
default:
handleLargeNumber(input);
}4.8.4.3 default的情况要写出来每个switch语句都包含一个default语句组，即使它什么代码也不包含。4.8.5 注解(Annotations)注解紧跟在文档块后面，应用于类、方法和构造函数，一个注解独占一行。这些换行不属于自动换行(第4.5节，自动换行)，因此缩进级别不变。例如：@Override
@Nullable
public String getNameIfPresent() { ... }例外：单个的注解可以和签名的第一行出现在同一行。例如：@Override public int hashCode() { ... }应用于字段的注解紧随文档块出现，应用于字段的多个注解允许与字段出现在同一行。例如：@Partial @Mock DataLoader loader;参数和局部变量注解没有特定规则。4.8.6 注释4.8.6.1 块注释风格块注释与其周围的代码在同一缩进级别。它们可以是/* ... */风格，也可以是// ...风格。对于多行的/* ... */注释，后续行必须从*开始， 并且与前一行的*对齐。以下示例注释都是OK的。/*
* This is // And so /* Or you can
* okay. // is this. * even do this. */
*/注释不要封闭在由星号或其它字符绘制的框架里。Tip：在写多行注释时，如果你希望在必要时能重新换行(即注释像段落风格一样)，那么使用/* ... */。4.8.7 修饰符类和成员的modifiers如果存在，则按Java语言规范中推荐的顺序出现。Class and member modifiers, when present, appear in the order recommended by the Java Language Specification:public protected private abstract default static final transient volatile synchronized native strictfp5 命名约定5.1 对所有标识符都通用的规则标识符只能使用ASCII字母和数字，因此每个有效的标识符名称都能匹配正则表达式\w+。在Google其它编程语言风格中使用的特殊前缀或后缀，如name_, mName, s_name和kName，在Java编程风格中都不再使用。5.2 标识符类型的规则5.2.1 包名包名全部小写，连续的单词只是简单地连接起来，不使用下划线。5.2.2 类名类名都以UpperCamelCase风格编写。类名通常是名词或名词短语，接口名称有时可能是形容词或形容词短语。现在还没有特定的规则或行之有效的约定来命名注解类型。测试类的命名以它要测试的类的名称开始，以Test结束。例如，HashTest或HashIntegrationTest。5.2.3 方法名方法名都以lowerCamelCase风格编写。方法名通常是动词或动词短语。下划线可能出现在JUnit测试方法名称中用以分隔名称的逻辑组件。一个典型的模式是：test<MethodUnderTest>_<state>，例如testPop_emptyStack。 并不存在唯一正确的方式来命名测试方法。5.2.4 常量名常量名命名模式为CONSTANT_CASE，全部字母大写，用下划线分隔单词。那，到底什么算是一个常量？每个常量都是一个静态final字段，但不是所有静态final字段都是常量。在决定一个字段是否是一个常量时， 考虑它是否真的感觉像是一个常量。例如，如果任何一个该实例的观测状态是可变的，则它几乎肯定不会是一个常量。 只是永远不打算改变对象一般是不够的，它要真的一直不变才能将它示为常量。// Constants
static final int NUMBER = 5;
static final ImmutableList<String> NAMES = ImmutableList.of("Ed", "Ann");
static final ImmutableMap<String, Integer> AGES = ImmutableMap.of("Ed", 35, "Ann", 32);
static final Joiner COMMA_JOINER = Joiner.on(','); // because Joiner is immutable
static final SomeMutableType[] EMPTY_ARRAY = {};
enum SomeEnum { ENUM_CONSTANT }
// Not constants
static String nonFinal = "non-final";
final String nonStatic = "non-static";
static final Set<String> mutableCollection = new HashSet<String>();
static final ImmutableSet<SomeMutableType> mutableElements = ImmutableSet.of(mutable);
static final ImmutableMap<String, SomeMutableType> mutableValues =
ImmutableMap.of("Ed", mutableInstance, "Ann", mutableInstance2);
static final Logger logger = Logger.getLogger(MyClass.getName());
static final String[] nonEmptyArray = {"these", "can", "change"};这些名字通常是名词或名词短语。5.2.5 非常量字段名非常量字段名以lowerCamelCase风格编写。这些名字通常是名词或名词短语。5.2.6 参数名参数名以lowerCamelCase风格编写。参数应该避免用单个字符命名。5.2.7 局部变量名局部变量名以lowerCamelCase风格编写，比起其它类型的名称，局部变量名可以有更为宽松的缩写。虽然缩写更宽松，但还是要避免用单字符进行命名，除了临时变量和循环变量。即使局部变量是final和不可改变的，也不应该把它示为常量，自然也不能用常量的规则去命名它。5.2.8 类型变量名类型变量可用以下两种风格之一进行命名：单个的大写字母，后面可以跟一个数字(如：E, T, X, T2)。以类命名方式(5.2.2节)，后面加个大写的T(如：RequestT, FooBarT)。5.3 驼峰式命名法(CamelCase)驼峰式命名法分大驼峰式命名法(UpperCamelCase)和小驼峰式命名法(lowerCamelCase)。 有时，我们有不只一种合理的方式将一个英语词组转换成驼峰形式，如缩略语或不寻常的结构(例如”IPv6”或”iOS”)。Google指定了以下的转换方案。名字从散文形式(prose form)开始:把短语转换为纯ASCII码，并且移除任何单引号。例如：”Müller’s algorithm”将变成”Muellers algorithm”。把这个结果切分成单词，在空格或其它标点符号(通常是连字符)处分割开。推荐：如果某个单词已经有了常用的驼峰表示形式，按它的组成将它分割开(如”AdWords”将分割成”ad words”)。 需要注意的是”iOS”并不是一个真正的驼峰表示形式，因此该推荐对它并不适用。现在将所有字母都小写(包括缩写)，然后将单词的第一个字母大写：每个单词的第一个字母都大写，来得到大驼峰式命名。除了第一个单词，每个单词的第一个字母都大写，来得到小驼峰式命名。最后将所有的单词连接起来得到一个标识符。示例：Prose form Correct Incorrect
"XML HTTP request" XmlHttpRequest XMLHTTPRequest
"new customer ID" newCustomerId newCustomerID
"inner stopwatch" innerStopwatch innerStopWatch
"supports IPv6 on iOS?" supportsIpv6OnIos supportsIPv6OnIOS
"YouTube importer" YouTubeImporter
YoutubeImporter*加星号处表示可以，但不推荐。Note：在英语中，某些带有连字符的单词形式不唯一。例如：”nonempty”和”non-empty”都是正确的，因此方法名checkNonempty和checkNonEmpty也都是正确的。编程实践6.1 @Override：能用则用只要是合法的，就把@Override注解给用上。6.2 捕获的异常：不能忽视除了下面的例子，对捕获的异常不做响应是极少正确的。(典型的响应方式是打印日志，或者如果它被认为是不可能的，则把它当作一个AssertionError重新抛出。)如果它确实是不需要在catch块中做任何响应，需要做注释加以说明(如下面的例子)。try {
int i = Integer.parseInt(response);
return handleNumericResponse(i);
} catch (NumberFormatException ok) {
// it's not numeric; that's fine, just continue
}
return handleTextResponse(response);例外：在测试中，如果一个捕获的异常被命名为expected，则它可以被不加注释地忽略。下面是一种非常常见的情形，用以确保所测试的方法会抛出一个期望中的异常， 因此在这里就没有必要加注释。try {
emptyStack.pop();
fail();
} catch (NoSuchElementException expected) {
}6.3 静态成员：使用类进行调用使用类名调用静态的类成员，而不是具体某个对象或表达式。Foo aFoo = ...;
Foo.aStaticMethod(); // good
aFoo.aStaticMethod(); // bad
somethingThatYieldsAFoo().aStaticMethod(); // very bad6.4 Finalizers: 禁用极少会去重写Object.finalize。Tip：不要使用finalize。如果你非要使用它，请先仔细阅读和理解Effective Java 第7条款：“Avoid Finalizers”，然后不要使用它。7 Javadoc7.1 格式7.1.1 一般形式Javadoc块的基本格式如下所示：/**
* Multiple lines of Javadoc text are written here,
* wrapped normally...
*/
public int method(String p1) { ... }或者是以下单行形式：/** An especially short bit of Javadoc. */基本格式总是OK的。当整个Javadoc块能容纳于一行时(且没有Javadoc标记@XXX)，可以使用单行形式。7.1.2 段落空行(即，只包含最左侧星号的行)会出现在段落之间和Javadoc标记(@XXX)之前(如果有的话)。 除了第一个段落，每个段落第一个单词前都有标签<p>，并且它和第一个单词间没有空格。7.1.3 Javadoc标记标准的Javadoc标记按以下顺序出现：@param, @return, @throws, @deprecated, 前面这4种标记如果出现，描述都不能为空。 当描述无法在一行中容纳，连续行需要至少再缩进4个空格。7.2 摘要片段每个类或成员的Javadoc以一个简短的摘要片段开始。这个片段是非常重要的，在某些情况下，它是唯一出现的文本，比如在类和方法索引中。这只是一个小片段，可以是一个名词短语或动词短语，但不是一个完整的句子。它不会以A {@code Foo} is a...或This method returns...开头, 它也不会是一个完整的祈使句，如Save the record...。然而，由于开头大写及被加了标点，它看起来就像是个完整的句子。Tip：一个常见的错误是把简单的Javadoc写成/** @return the customer ID */，这是不正确的。它应该写成/** Returns the customer ID. */。7.3 哪里需要使用Javadoc至少在每个public类及它的每个public和protected成员处使用Javadoc，以下是一些例外：7.3.1 例外：不言自明的方法对于简单明显的方法如getFoo，Javadoc是可选的(即，是可以不写的)。这种情况下除了写“Returns the foo”，确实也没有什么值得写了。单元测试类中的测试方法可能是不言自明的最常见例子了，我们通常可以从这些方法的描述性命名中知道它是干什么的，因此不需要额外的文档说明。Tip：如果有一些相关信息是需要读者了解的，那么以上的例外不应作为忽视这些信息的理由。例如，对于方法名getCanonicalName， 就不应该忽视文档说明，因为读者很可能不知道词语canonical name指的是什么。7.3.2 例外：重写如果一个方法重写了超类中的方法，那么Javadoc并非必需的。7.3.3 非必需的Javadoc其他类和成员可以根据需要或需要使用 Javadoc。每当一个实现注释被用来定义一个类或成员的总体目标或行为时，该注释就被编写为 Javadoc (使用 / * *)。非必需的 Javadoc 并不严格要求遵循第7.1.2、7.1.3和7.2节的格式化规则，尽管当然推荐这样做。参考https://github.com/google/styleguidehttps://google.github.io/styleguide/javaguide.htmlhttps://www.cnblogs.com/Juli/p/7309450.html
Python web服务器3: 静态服务器&并发web服务器
一、总体内容1.1、显示固定的页面1.2、tcp长连接和短连接1.3、返回浏览器需要的界面分析：实现http服务器的类型二、显示固定的页面2.1、服务器端代码（TCP）import socket
def server_client(new_socket):
"""为这个客户端返回数据"""
# # 组织相应 头信息(header)
# 1.接收浏览器发送过来的请求，即 http请求
# GET / HTTP/1.1
# ....
request = new_socket.recv(1024)
print(request)
# 2.返回http格式的数据，给浏览器
# 2.1、准备发送给浏览器的数据---header
response = "HTTP/1.1 200 OK\r\n" # 200表示找到这个资源
response += "\r\n" # 用一个空的行与body进行隔开
# 2.2、准备发送给浏览器的数据 ---body
response += "<h4>您好吗？/h4>"
new_socket.send(response.encode("utf-8"))
# 3.关闭套接字
new_socket.close()
def main():
"""用来完成整体的控制"""
# 1.创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 2.绑定
tcp_server_socket.bind(("192.168.3.6", 7280))
# 3.变为监听套接字
tcp_server_socket.listen(128)
while True:
# 4.等待客户端的链接
new_socket, client_addr = tcp_server_socket.accept()
# 5.为这个客户端服务
server_client(new_socket)
# 6.关闭监听的套接字
tcp_server_socket.close()
if __name__ == '__main__':
main()服务器端网页端: 输入?IP:端口号?就可以显示网页三、tcp长连接和短连接TCP在真正的读写操作之前，server与client之间必须建立一个连接，当读写操作完成后，双方不再需要这个连接时它们可以释放这个连接，连接的建立通过三次握手，释放则需要四次握手，所以说每个连接的建立都是需要资源消耗和时间消耗的。3.1、TCP通信的整个过程，如下图:3.2、TCP短连接模拟一种TCP短连接的情况:client 向 server 发起连接请求server 接到请求，双方建立连接client 向 server 发送消息server 回应 client一次读写完成，此时双方任何一个都可以发起 close 操作在步骤5中，一般都是 client 先发起 close 操作。当然也不排除有特殊的情况。从上面的描述看，短连接一般只会在 client/server 间传递一次读写操作！3.3、TCP长连接再模拟一种长连接的情况:client 向 server 发起连接server 接到请求，双方建立连接client 向 server 发送消息server 回应 client一次读写完成，连接不关闭后续读写操作...长时间操作之后client发起关闭请求3.4、TCP长/短连接操作过程(1)、短连接的操作步骤是：建立连接——数据传输——关闭连接...建立连接——数据传输——关闭连接(2)、长连接的操作步骤是：建立连接——数据传输...（保持连接）...数据传输——关闭连接3.5、TCP长/短连接的优点和缺点长连接可以省去较多的TCP建立和关闭的操作，减少浪费，节约时间。对于频繁请求资源的客户来说，较适用长连接。client与server之间的连接如果一直不关闭的话，会存在一个问题，随着客户端连接越来越多，server早晚有扛不住的时候，这时候server端需要采取一些策略，如关闭一些长时间没有读写事件发生的连接，这样可以避免一些恶意连接导致server端服务受损；如果条件再允许就可以以客户端机器为颗粒度，限制每个客户端的最大长连接数，这样可以完全避免某个蛋疼的客户端连累后端服务。短连接对于服务器来说管理较为简单，存在的连接都是有用的连接，不需要额外的控制手段。但如果客户请求频繁，将在TCP的建立和关闭操作上浪费时间和带宽。3.6、TCP长/短连接的应用场景长连接多用于操作频繁，点对点的通讯，而且连接数不能太多情况。每个TCP连接都需要三次握手，这需要时间，如果每个操作都是先连接，再操作的话那么处理速度会降低很多，所以每个操作完后都不断开，再次处理时直接发送数据包就OK了，不用建立TCP连接。例如：数据库的连接用长连接，如果用短连接频繁的通信会造成socket错误，而且频繁的socket 创建也是对资源的浪费。而像WEB网站的http服务一般都用短链接，因为长连接对于服务端来说会耗费一定的资源，而像WEB网站这么频繁的成千上万甚至上亿客户端的连接用短连接会更省一些资源，如果用长连接，而且同时有成千上万的用户，如果每个用户都占用一个连接的话，那可想而知吧。所以并发量大，但每个用户无需频繁操作情况下需用短连好。四、返回浏览器需要的界面分析 以及 并发服务器4.1、服务器端代码import socket
import re
def server_client(new_socket):
"""为这个客户端返回数据"""
# # 组织相应 头信息(header)
# 1.接收浏览器发送过来的请求，即 http请求
# GET / HTTP/1.1
# ....
request = new_socket.recv(1024).decode("utf-8")
# print(request)
request_lines = request.splitlines()
print("")
print(">"*20)
print(request_lines)
# GET /index.html HTTP/1.1
# get post put del
file_name = ""
ret = re.match(r"[^/]+(/[^ ]*)",request_lines[0])
if ret:
file_name = ret.group(1)
print("file_name=%s" % file_name)
print("*"*50,file_name)
if file_name == "/":
file_name = "/index.html"
# 2.返回http格式的数据，给浏览器
# 2.1、准备发送给浏览器的数据---header
try:
f = open("./html"+file_name,"rb")
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
response += "----file not found"
new_socket.send(response.encode("utf-8"))
else:
print("-----------OK------------")
html_content = f.read()
f.close()
response = "HTTP/1.1 200 OK\r\n" # 200表示找到这个资源
response += "\r\n" # 用一个空的行与body进行隔开
# 2.2、准备发送给浏览器的数据 ---body
# 将response的header发送给浏览器
new_socket.send(response.encode("utf-8"))
# 将response的 body 发送给浏览器
new_socket.send(html_content)
# 3.关闭套接字
new_socket.close()
def main():
"""用来完成整体的控制"""
# 1.创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 2.绑定
tcp_server_socket.bind(("192.168.3.6", 7590))
# 3.变为监听套接字
tcp_server_socket.listen(128)
while True:
# 4.等待客户端的链接
new_socket, client_addr = tcp_server_socket.accept()
# 5.为这个客户端服务
server_client(new_socket)
# 6.关闭监听的套接字
tcp_server_socket.close()
if __name__ == '__main__':
main()分析一下上面代码中的正则：ret = re.match(r"[^/]+(/[^ ]*)",request_lines[0])”^”这个字符是在中括号 []中被使用的话就是表示字符类的否定，如果不是的话就是表示限定开头。我这里说的是直接在[]中使用，不包括嵌套使用。其实也就是说 [] 代表的是一个字符集，^ 只有在字符集中才是反向字符集的意思。[^/]+(/[^ ]*： 意思是 : [^/]:除了 / 以外，+：至少一个字符，/[^ ]*：表示除了空格，也就是到空格就不匹配了，*：表示匹配前一个字符出现0次或者无限次，即可有可无4.2、多进程实现http服务器import socket
import multiprocessing
import re
def server_client(new_socket):
"""为这个客户端返回数据"""
# # 组织相应 头信息(header)
# 1.接收浏览器发送过来的请求，即 http请求
# GET / HTTP/1.1
# ....
request = new_socket.recv(1024).decode("utf-8")
# print(request)
request_lines = request.splitlines()
print("")
print(">"*20)
print(request_lines)
# GET /index.html HTTP/1.1
# get post put del
file_name = ""
ret = re.match(r"[^/]+(/[^ ]*)",request_lines[0])
if ret:
file_name = ret.group(1)
print("file_name=%s" % file_name)
print("*"*50,file_name)
if file_name == "/":
file_name = "/index.html"
# 2.返回http格式的数据，给浏览器
# 2.1、准备发送给浏览器的数据---header
try:
f = open("./html"+file_name,"rb")
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
response += "----file not found"
new_socket.send(response.encode("utf-8"))
else:
print("-----------OK------------")
html_content = f.read()
f.close()
response = "HTTP/1.1 200 OK\r\n" # 200表示找到这个资源
response += "\r\n" # 用一个空的行与body进行隔开
# 2.2、准备发送给浏览器的数据 ---body
# 将response的header发送给浏览器
new_socket.send(response.encode("utf-8"))
# 将response的 body 发送给浏览器
new_socket.send(html_content)
# 3.关闭套接字
new_socket.close()
def main():
"""用来完成整体的控制"""
# 1.创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 2.绑定
tcp_server_socket.bind(("192.168.3.6", 7590))
# 3.变为监听套接字
tcp_server_socket.listen(128)
while True:
# 4.等待客户端的链接
new_socket, client_addr = tcp_server_socket.accept()
# 5.开辟一个进程为这个客户端服务
p = multiprocessing.Process(target=server_client,args=(new_socket,))
p.start()
new_socket.close()
# 6.关闭监听的套接字
tcp_server_socket.close()
if __name__ == '__main__':
main()提示：上面代码在while True:里面有一个：new_socket.close(),因为进程是复制一份资源，进程里面有一个new_socket指向资源，主进程也有一份指向资源，等子进程 new_socket 调用close()的时候，资源不会被释放，所以在主进程先把指向子进程的资源释放掉缺点：每一个子进程都要复制一份资源，如果很多很多客户端，那么服务器的内存就很快用完，服务器会承受不了，那么我们就需要用 多线程 了4.3、多线程实现http服务把上面代码在while True:改为如下import threading
while True:
# 4.等待客户端的链接
new_socket, client_addr = tcp_server_socket.accept()
# 5.开辟一个进程为这个t客户端服务
t = threading.Thread(target=server_client,args=(new_socket,))
t.start()提示：上面代码在while True:里面没有一个：new_socket.close(),因为多线程没有复制一份资源，子线程 new_socket 调用close()的时候，资源被释放缺点：每一个子线程都要开辟一条线程，如果很多很多客户端，那么服务器也会受不了的，并不是子线程越多越好4.3、协程gevent实现http服务器import gevent
from gevent import monkey
# 将程序中用到的耗时操作的代码，换为gevent中自己实现的模块
monkey.patch_all()
while True:
# 4.等待客户端的链接
new_socket, client_addr = tcp_server_socket.accept()
# 5.开辟一个协程为这个t客户端服务
gevent.spawn(server_client,new_socket)4.4、单进程非堵塞 模型from socket import *
import time
# 用来存储所有的新链接的socket
g_socket_list = list()
def main():
server_socket = socket(AF_INET, SOCK_STREAM)
server_socket.setsockopt(SOL_SOCKET, SO_REUSEADDR , 1)
server_socket.bind(('', 7890))
server_socket.listen(128)
# 将套接字设置为非堵塞
# 设置为非堵塞后，如果accept时，恰巧没有客户端connect，那么accept会
# 产生一个异常，所以需要try来进行处理
server_socket.setblocking(False)
while True:
# 用来测试
time.sleep(0.5)
try:
newClientInfo = server_socket.accept()
except Exception as result:
pass
else:
print("一个新的客户端到来:%s" % str(newClientInfo))
newClientInfo[0].setblocking(False) # 设置为非堵塞
g_socket_list.append(newClientInfo)
for client_socket, client_addr in g_socket_list:
try:
recvData = client_socket.recv(1024)
if recvData:
print('recv[%s]:%s' % (str(client_addr), recvData))
else:
print('[%s]客户端已经关闭' % str(client_addr))
client_socket.close()
g_socket_list.remove((client_socket,client_addr))
except Exception as result:
pass
print(g_socket_list) # for test
if __name__ == '__main__':
main()4.5、epollIO 多路复用就是我们说的select，poll，epoll，有些地方也称这种IO方式为event driven IO。select/epoll的好处就在于单个process就可以同时处理多个网络连接的IO。它的基本原理就是select，poll，epoll这个function会不断的轮询所负责的所有socket，当某个socket有数据到达了，就通知用户进程。epoll 简单模型import socket
import select
# 创建套接字
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 设置可以重复使用绑定的信息
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1)
# 绑定本机信息
s.bind(("",7788))
# 变为被动
s.listen(128)
# 创建一个epoll对象
epoll = select.epoll()
# 测试，用来打印套接字对应的文件描述符
# print(s.fileno())
# print(select.EPOLLIN|select.EPOLLET)
# 注册事件到epoll中
# epoll.register(fd[, eventmask])
# 注意，如果fd已经注册过，则会发生异常
# 将创建的套接字添加到epoll的事件监听中
epoll.register(s.fileno(), select.EPOLLIN|select.EPOLLET)
connections = {}
addresses = {}
# 循环等待客户端的到来或者对方发送数据
while True:
# epoll 进行 fd 扫描的地方 -- 未指定超时时间则为阻塞等待
epoll_list = epoll.poll()
# 对事件进行判断
for fd, events in epoll_list:
# print fd
# print events
# 如果是socket创建的套接字被激活
if fd == s.fileno():
new_socket, new_addr = s.accept()
print('有新的客户端到来%s' % str(new_addr))
# 将 conn 和 addr 信息分别保存起来
connections[new_socket.fileno()] = new_socket
addresses[new_socket.fileno()] = new_addr
# 向 epoll 中注册 新socket 的 可读 事件
epoll.register(new_socket.fileno(), select.EPOLLIN|select.EPOLLET)
# 如果是客户端发送数据
elif events == select.EPOLLIN:
# 从激活 fd 上接收
recvData = connections[fd].recv(1024).decode("utf-8")
if recvData:
print('recv:%s' % recvData)
else:
# 从 epoll 中移除该 连接 fd
epoll.unregister(fd)
# server 侧主动关闭该 连接 fd
connections[fd].close()
print("%s---offline---" % str(addresses[fd]))
del connections[fd]
del addresses[fd]说明- EPOLLIN （可读）- EPOLLOUT （可写）- EPOLLET （ET模式）epoll 对文件描述符的操作有两种模式：LT（level trigger）和ET（edge trigger）。LT模式是默认模式，LT模式与ET模式的区别如下：LT模式：当epoll检测到描述符事件发生并将此事件通知应用程序，应用程序可以不立即处理该事件。下次调用epoll时，会再次响应应用程序并通知此事件。ET模式：当epoll检测到描述符事件发生并将此事件通知应用程序，应用程序必须立即处理该事件。如果不处理，下次调用epoll时，不会再次响应应用程序并通知此事件。web静态服务器-epool:以下代码，支持http的长连接，即使用了Content-Length(也就是返回内容的长度)import socket
import time
import sys
import re
import select
class WSGIServer(object):
"""定义一个WSGI服务器的类"""
def __init__(self, port, documents_root):
# 1. 创建套接字
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 2. 绑定本地信息
self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.server_socket.bind(("", port))
# 3. 变为监听套接字
self.server_socket.listen(128)
self.documents_root = documents_root
# 创建epoll对象
self.epoll = select.epoll()
# 将tcp服务器套接字加入到epoll中进行监听
self.epoll.register(self.server_socket.fileno(), select.EPOLLIN|select.EPOLLET)
# 创建添加的fd对应的套接字
self.fd_socket = dict()
def run_forever(self):
"""运行服务器"""
# 等待对方链接
while True:
# epoll 进行 fd 扫描的地方 -- 未指定超时时间则为阻塞等待
epoll_list = self.epoll.poll()
# 对事件进行判断
for fd, event in epoll_list:
# 如果是服务器套接字可以收数据，那么意味着可以进行accept
if fd == self.server_socket.fileno():
new_socket, new_addr = self.server_socket.accept()
# 向 epoll 中注册 连接 socket 的 可读 事件
self.epoll.register(new_socket.fileno(), select.EPOLLIN | select.EPOLLET)
# 记录这个信息
self.fd_socket[new_socket.fileno()] = new_socket
# 接收到数据
elif event == select.EPOLLIN:
request = self.fd_socket[fd].recv(1024).decode("utf-8")
if request:
self.deal_with_request(request, self.fd_socket[fd])
else:
# 在epoll中注销客户端的信息
self.epoll.unregister(fd)
# 关闭客户端的文件句柄
self.fd_socket[fd].close()
# 在字典中删除与已关闭客户端相关的信息
del self.fd_socket[fd]
def deal_with_request(self, request, client_socket):
"""为这个浏览器服务器"""
if not request:
return
request_lines = request.splitlines()
for i, line in enumerate(request_lines):
print(i, line)
# 提取请求的文件(index.html)
# GET /a/b/c/d/e/index.html HTTP/1.1
ret = re.match(r"([^/]*)([^ ]+)", request_lines[0])
if ret:
print("正则提取数据:", ret.group(1))
print("正则提取数据:", ret.group(2))
file_name = ret.group(2)
if file_name == "/":
file_name = "/index.html"
# 读取文件数据
try:
f = open(self.documents_root+file_name, "rb")
except:
response_body = "file not found, 请输入正确的url"
response_header = "HTTP/1.1 404 not found\r\n"
response_header += "Content-Type: text/html; charset=utf-8\r\n"
response_header += "Content-Length: %d\r\n" % len(response_body)
response_header += "\r\n"
# 将header返回给浏览器
client_socket.send(response_header.encode('utf-8'))
# 将body返回给浏览器
client_socket.send(response_body.encode("utf-8"))
else:
content = f.read()
f.close()
response_body = content
response_header = "HTTP/1.1 200 OK\r\n"
response_header += "Content-Length: %d\r\n" % len(response_body)
response_header += "\r\n"
# 将数据返回给浏览器
client_socket.send(response_header.encode("utf-8")+response_body)
# 设置服务器服务静态资源时的路径
DOCUMENTS_ROOT = "./html"
def main():
"""控制web服务器整体"""
# python3 xxxx.py 7890
if len(sys.argv) == 2:
port = sys.argv[1]
if port.isdigit():
port = int(port)
else:
print("运行方式如: python3 xxx.py 7890")
return
print("http服务器使用的port:%s" % port)
http_server = WSGIServer(port, DOCUMENTS_ROOT)
http_server.run_forever()
if __name__ == "__main__":
main()总结：I/O 多路复用的特点：‘通过一种机制使一个进程能同时等待多个文件描述符，而这些文件描述符（套接字描述符）其中的任意一个进入读就绪状态，epoll()函数就可以返回。 所以, IO多路复用，本质上不会有并发的功能，因为任何时候还是只有一个进程或线程进行工作，它之所以能提高效率是因为select\epoll 把进来的socket放到他们的 '监视' 列表里面，当任何socket有可读可写数据立马处理，那如果select\epoll 手里同时检测着很多socket， 一有动静马上返回给进程处理，总比一个一个socket过来,阻塞等待,处理高效率。当然也可以多线程/多进程方式，一个连接过来开一个进程/线程处理，这样消耗的内存和进程切换页会耗掉更多的系统资源。 所以我们可以结合IO多路复用和多进程/多线程 来高性能并发，IO复用负责提高接受socket的通知效率，收到请求后，交给进程池/线程池来处理逻辑。
Fastjson 和 Spring 进行集成
在 Spring MVC 中集成 Fastjson如果你使用 Spring MVC 来构建 Web 应用并对性能有较高的要求的话，可以使用 Fastjson 提供的FastJsonHttpMessageConverter 来替换 Spring MVC 默认的 HttpMessageConverter 以提高 @RestController @ResponseBody @RequestBody 注解的 JSON序列化速度。下面是配置方式，非常简单。XML式如果是使用 XML 的方式配置 Spring MVC 的话，只需在 Spring MVC 的 XML 配置文件中加入下面配置即可。<mvc:annotation-driven>
<mvc:message-converters>
<bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter"/>
</mvc:message-converters>
</mvc:annotation-driven>通常默认配置已经可以满足大部分使用场景，如果你想对它进行自定义配置的话，你可以添加 FastJsonConfig Bean。<mvc:annotation-driven>
<mvc:message-converters>
<bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
<property name="fastJsonConfig" ref="fastJsonConfig"/>
</bean>
</mvc:message-converters>
</mvc:annotation-driven>
<bean id="fastJsonConfig" class="com.alibaba.fastjson.support.config.FastJsonConfig">
<!-- 自定义配置... -->
</bean>编程式如果是使用编程的方式（通常是基于 Spring Boot 项目）配置 Spring MVC 的话只需继承 WebMvcConfigurerAdapter 覆写 configureMessageConverters 方法即可，就像下面这样。@Configuration
public class WebMvcConfigurer extends WebMvcConfigurerAdapter {
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter();
//自定义配置...
//FastJsonConfig config = new FastJsonConfig();
//config.set ...
//converter.setFastJsonConfig(config);
converters.add(converter);
}
}在 Spring Data Redis 中集成 Fastjson编程式如果是使用编程的方式（通常是基于 Spring Boot 项目）配置 RedisTemplate 的话只需在你的配置类(被@Configuration注解修饰的类)中显式创建 RedisTemplate Bean，设置 Serializer 即可。@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate redisTemplate = new RedisTemplate();
redisTemplate.setConnectionFactory(redisConnectionFactory);
GenericFastJsonRedisSerializer fastJsonRedisSerializer = new GenericFastJsonRedisSerializer();
redisTemplate.setDefaultSerializer(fastJsonRedisSerializer);//设置默认的Serialize，包含 keySerializer & valueSerializer
//redisTemplate.setKeySerializer(fastJsonRedisSerializer);//单独设置keySerializer
//redisTemplate.setValueSerializer(fastJsonRedisSerializer);//单独设置valueSerializer
return redisTemplate;
}通常使用 GenericFastJsonRedisSerializer 即可满足大部分场景，如果你想定义特定类型专用的 RedisTemplate 可以使用 FastJsonRedisSerializer 来代替 GenericFastJsonRedisSerializer ，配置是类似的。参考阿里FastJson的使用_json_qq_30920821的博客-CSDN博客https://blog.csdn.net/qq_30920821/article/details/78417690
阿里ESC试用体验
基本情况介绍本人今年大四，就读于西南地区某211高校，马上要去广东读数据科学方向的硕士。前段时间，有一个客户需要我把爬虫进程部署在他们公司的服务器上，但是由于我没有相关服务器的使用经历，所以在朋友的推荐下，选择了阿里云的飞天加速计划，该计划让我对服务器有了一个初识。使用过程&体验服务器原来可以操作电脑那样简单此前，我只使用过windows系统，在我的认知里，服务器系统都是黑框的Linux,但让我很惊喜的是，服务器其实也可以有Windows系统的，名字叫做Windows server，当然更进一步肯定是要学习和使用Linux的，但是作为过渡，我很满意Windows server的系统，通过远程连接，可以实现远程的连接，真的非常的方便！完美兼容开发工具-以VScode为例我本人是乐于尝试和学习新的事物的，但是又很喜欢用的顺手的东西，比如VScode，基本上我所有的开发工作都会使用VScode完成，很显然，作为拥有众多插件工具的VScode当然是连接服务器的，通过公钥的配置，你甚至可以实现不输入密码直接连接，具体操作细节大概就是安装一套插件（3个），配置ssh-config，超级简单的实现，然后就像处理本地任务一样处理服务器任务就可以啦~简单轻松的步数体验或许你会觉得一个服务器真的高级，但其实真的很简单，无论是拥有它还是使用它。以我的个人需求为例，爬虫项目的部署，那就是连接远程桌面，然后当成自己本地电脑操作就好，又或是作为一个小型网页的服务器，也就是安装两个软件的步骤，然后将你的网页文件放在tomcat的队友目录下就好啦~下一阶段的计划拥有一台自己的服务器的体验真是太棒了，相当于打开了新世界的大门，既然服务器都有了，当然要建造自己的网站，下一步计划就是在阿里云买一个域名，然后学习biji比较基础的JSP，开始开发一个自己的网页，用来放自己的博客，还是有很长的路要走，因为此前可是HTML都是没学过的哦，继续加油哦~
Maven 镜像源加速和私服配置
华为开源镜像站加速下载开源组件settings.xml 在 mirrors 标签中添加 mirror 子节点：<mirror>
<id>huawei-cloud-mirror</id>
<mirrorOf>central</mirrorOf>
<url>https://repo.huaweicloud.com/repository/maven/</url>
</mirror>配置华为私有库下载settings.xml 中设置仓库凭证：servers 节点中添加如下配置<server>
<id>releases</id>
<username>************</username>
<password>************</password>
</server>
<server>
<id>snapshots</id>
<username>************</username>
<password>************</password>
</server>在 profiles 节点中添加如下配置。并需要在 settings.xml 文件<activeProfiles>标签中启用。<profile>
<id>MyProfile</id>
<repositories>
<repository>
<id>releases</id>
<url>https://devrepo.devcloud.cn-north-4.huaweicloud.com/07/nexus/content/repositories/088dbeef3980f4050f6fc007779eab60_1_0/</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
<repository>
<id>snapshots</id>
<url>https://devrepo.devcloud.cn-north-4.huaweicloud.com/07/nexus/content/repositories/088dbeef3980f4050f6fc007779eab60_2_0/</url>
<releases>
<enabled>false</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
</repositories>
</profile>阿里云开源镜像站加速下载开源组件在<mirrors></mirrors>标签中添加mirror子节点,<mirror>
<id>aliyun-mirror</id>
<mirrorOf>central</mirrorOf>
<url>https://maven.aliyun.com/repository/public</url>
</mirror>如果想使用其它代理仓库,可在 profile 下的 repositories 节点中加入对应的仓库使用地址。以使用 Spring 代理仓为例：<repository>
<id>spring</id>
<url>https://maven.aliyun.com/repository/spring</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>配置华为私有库下载在 settings.xml 中添加认证信息 在 Maven 默认 settings.xml 中找到 servers 的部分，添加一个 server 配置如下。<servers>
<server>
<id>rdc-releases</id>
<username>***</username>
<password>******</password>
</server>
<server>
<id>rdc-snapshots</id>
<username>***</username>
<password>******</password>
</server>
</servers>在 profiles 节点添加如下配置, 其中 repository 是顺序搜索下载包的.<profile>
<id>rdc-private-repo</id>
<repositories>
<repository>
<id>rdc-releases</id>
<url>https://repo.rdc.aliyun.com/repository/78947-release-CfzLQ7/</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
<repository>
<id>rdc-snapshots</id>
<url>https://repo.rdc.aliyun.com/repository/78947-snapshot-XtuBsZ/</url>
<releases>
<enabled>false</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>rdc-releases</id>
<url>https://repo.rdc.aliyun.com/repository/78947-release-CfzLQ7/</url>
<releases>
<enabled>true</enabled>
</releases>
<snapshots>
<enabled>false</enabled>
</snapshots>
</pluginRepository>
<pluginRepository>
<id>rdc-snapshots</id>
<url>https://repo.rdc.aliyun.com/repository/78947-snapshot-XtuBsZ/</url>
<releases>
<enabled>false</enabled>
</releases>
<snapshots>
<enabled>true</enabled>
</snapshots>
</pluginRepository>
</pluginRepositories>
</profile>使用 properties 简化 url 配置<?xml version="1.0" encoding="UTF-8"?>
<settings
xmlns="http://maven.apache.org/SETTINGS/1.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
<mirrors>
<mirror>
<id>huawei-yun-mirror</id>
<mirrorOf>central</mirrorOf>
<url>https://repo.huaweicloud.com/repository/maven/</url>
</mirror>
</mirrors>
<profiles>
<profile>
<id>my-profile</id>
<properties>
<my.repo.url>---------YOUE_URL---------</my.repo.url>
</properties>
<repositories>
<repository>
<id>my-repo</id>
<url>${my.repo.url}</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>my-repo</id>
<url>${my.repo.url}</url>
</pluginRepository>
</pluginRepositories>
</profile>
</profiles>
<activeProfiles>
<activeProfile>my-profile</activeProfile>
</activeProfiles>
</settings>拉取制品mvn clean package参考华为开源镜像站软件开发服务华为云https://mirrors.huaweicloud.com/homeMaven 仓库 · 云效 Packages · 企业级制品仓库 https://packages.aliyun.com/mavenMaven 查看当前生效配置、pom、环境变量等命令（mvn help用法） - 简书 https://www.jianshu.com/p/6184fa25fd53
推荐两款在用免费云端 IDE
优点: 无需手动安装；预设常见Java , Python, JS 等环境, 支持创建网页预览，在线开发调试。实验楼内置 IDE (1小时短期使用)搭载 Ubuntu系统, 这好像是个bug, 非会员使用该课程也提供外网环境. 可用于一些简单实验, 每次可申请1个小时使用时长, 可续期.此课程可连外网-Spring 框架基础入门_Java - 实验楼https://www.shiyanlou.com/courses/578预装 mysql, 以下命令可以启用数据库sudo service mysql start
mysql -u root预装 c语言环境, 以下命令可运行$ gcc -o hello hello.c
$ ./hello腾讯云 Cloud Studio (可长期使用)Cloud Studio 是基于浏览器的集成式开发环境（IDE），您可以使用它进行代码编写和编译运行。Cloud Studio 和本地 IDE 相比具有以下优势：无需安装，跨平台，只要有浏览器就可以使用；预置常用环境，无需手动安装；支持创建网页预览，在线开发调试。数量限制：目前每个用户最多可以创建 5 个工作空间，并且只能同时运行一个工作空间，如果您需要打开另一个工作空间需要先关闭当前运行中的工作空间。时间限制：每个用户每日可以使用工作空间共四小时，超出时间将不可使用（连接云主机的工作空间无此限制）。目前 Cloud Studio 使用 Coding.net 账号登录，您可以先免费注册一个 CODING 团队。注册完成后，点击右上角导航中的图标就可以回到 Cloud Studio 中进行云端开发了。老版地址貌似还能用,使用时长无限制https://studio.dev.tencent.com/dashboard/workspace新版登陆地址(每天畅享4小时)https://e.coding.net/signin
从零开始学设计模式(八)：装饰器模式(Decorator Pattern)
定义在编程语言中一般有两种方式给一个类或者对象增加额外的行为或者功能：一种是继承：一个子类继承一个父类可以使得子类在拥有自身方法之外还能够同时拥有父类的方法。还有一种是关联：即将一个类的对象嵌入到另一个对象中，并且由另一个对象决定是否调用嵌入对象的行为来扩展自己的功能，可见这种方式是动态的比继承更加灵活。而嵌入的对象就是这里要说的装饰器。装饰器模式是继承关系的一个替代方案，在不必改变原类文件和原类使用的继承的情况? 下，通过使用对象之间的关联关系来取代类之间的继承关系，从而能够动态的给一个对? ?象拓展一些额外的功能。它也是一种对象结构型模式。组成部分装饰器模式具有以下四个成员角色：抽象构件角色（Project）：给出一个接口，以规范准备接收附加责任的对象。具体构件角色（Employe）：定义一个将要接收附加责任的类。装饰角色（Manager）：持有一个构件对象的实例，并定义一个与抽象构件接口一致的接口。具体装饰角色（ManagerA、ManagerB）：负责给构件对象贴上附加的责任。例子这里以手机的功能为例：声明一个抽象构件角色手机的公共接口，并且具有拍照的功能：public interface Phone {
//手机具有拍照的功能
void photo();
}
复制代码再声明一个具体构件角色，public class OldPhone implements Phone{
@Override
public void photo() {
System.out.println("手机的拍照功能");
}
}
复制代码抽象装饰角色：public class NewPhone implements Phone{
public OldPhone oldPhone;
public NewPhone(OldPhone oldPhone) {
this.oldPhone = oldPhone;
}
@Override
public void photo() {
System.out.println("手机的拍照功能");
}
}
复制代码具体装饰角色：public class ConcreteDecorator extends NewPhone {
public ConcreteDecorator(OldPhone oldPhone) {
super(oldPhone);
}
public void photo() {
super.photo();
video();
}
public void video() {
System.out.println("为手机增加额外的拍视频的功能");
}
}
复制代码测试：public class Test {
public static void main(String[] args) {
Phone p = new OldPhone();
p.photo();
Phone phone = new ConcreteDecorator(new OldPhone());
phone.photo();
}
}
复制代码结果：通过例子可以看到，没有改变原来的OldPhone类，同时也没有定义他的子类而实现了Phone的扩展新增了拍视频的功能，这就是装饰器模式的作用。装饰器模式优点：1、装饰器模式与继承关系的目的都是要扩展对象的功能，但是装饰模式可以提供比继承更多的灵活性。2、可以通过一种动态的方式来扩展一个对象的功能，通过配置文件可以在运行时选择不同的装饰器，从而实现不同的行为。3、通过使用不同的具体装饰类以及这些装饰类的排列组合，可以创造出很多不同行为的组合。可以使用多个具体装饰类来装饰同一对象，得到功能更为强大的对象。4、具体构件类与具体装饰类可以独立变化，用户可以根据需要增加新的具体构件类和具体装饰类，在使用时再对其进行组合，原有代码无须改变，符合“开闭原则”装饰器模式缺点1、使用装饰器模式进行系统设计时将产生很多小对象，这些对象的区别在于它们之间相互连接的方式有所不同，而不是它们的类或者属性值有所不同，同时还将产生很多具体装饰类，增加了系统的复杂性2、装饰器模式比继承更加灵活机动的特性，但同时也装饰模式比继承更加易于出错，排错也很困难，对于多次装饰的对象，调试时寻找错误可能需要逐级排查，较为烦琐。装饰器模式和继承的区别：前面说了装饰器模式和继承机制都可以给一个类或者对象增加额外的行为或者功能，那么它们有什么区别：继承比较于装饰器模式的优点在于代码结构清晰，而且实现简单；但是对于每一个的需要增强的类都要创建具体的子类来帮助其增强，这样会导致继承体系过于庞大。而装饰器模式则可以动态的对对多个需要增强的类进行增强，同理需要维护需要增强的类的实例。进而使得代码稍微复杂。装饰器模式与适配器模式的区别：装饰器模式和适配器模式都是类结构设计模式，它们又有什么区别：1、适配器模式主要用来兼容那些不能在一起工作的类，将它们转化为可以兼容目标接口，虽然也可以实现和装饰器一样的增加新职责，但是它的目的并不是这个。而装饰器模式主要是给被装饰的增加新职责的。2、适配器模式是用新接口来调用原接口，原接口对新系统是不可见或者说不可用的。而装饰器模式原封不动的使用原接口，系统对装饰的对象也通过原接口来完成使用。3、适配器模式是知道被适配者的详细情况的；而装饰器模式只知道其接口是什么，至于其具体类型（是基类还是其他派生类）只有在运行期间才知道。使用场景1、当需要给一个现有类添加附加职责，而又不能采用生成子类的方法进行扩充时。例如，该类被隐藏或者该类是终极类或者采用继承方式会产生大量的子类。2、当需要通过对现有的一组基本功能进行排列组合而产生非常多的功能时，采用继承关系很难实现，而采用装饰器模式却很好实现。3、当对象的功能要求可以动态地添加，也可以再动态地撤销时。4、装饰器模式在java中的最著名的应用就是I/O 标准库的设计了。比如，InputStream 的子类 FilterInputStream，OutputStream 的子类 FilterOutputStream，Reader 的子类 BufferedReader 以及 FilterReader，还有 Writer 的子类 BufferedWriter、FilterWriter 以及 PrintWriter 等，它们都是抽象装饰类。
从零开始学设计模式(七)：代理模式（Proxy Pattern）
定义代理模式可以说是在日常开发中听到用到最多的设计模式之一了。代理模式的定义：由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。它是一种对象结构型模式。所以可以这样理解：比如你要租房子，你不能直接与房东进行访问和他进行交谈，这时候你就需要一个房屋中介，你把你的需求告诉他，房东把他的需求也告诉他，这时候他负责作为中间的传话筒传递你们的意思，间接的提供了你对于房东的一个访问！组成部分通过对于代理模式的定义和描述可以发现它应该有三个关键的角色：你、房东、房屋中介。即：抽象角色Subject：声明真实对象和代理对象的共同接口。房东。代理角色Proxy：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。房屋中介。真实角色RealSubject：代理角色所代表的真实对象，是我们最终要引用的对象。你。代理模式的分类我们经常听到一个词：动态代理，既然有动态代理，与之对应肯定有静态代理。所以代理模式主要分为动态和静态代理两种设计模式。接下来分别介绍下：静态代理静态代理指得是由程序员创建代理类或特定工具自动生成源代码再对其编译，在程序运行前代理类的 .class 文件就已经存在了。静态代理的例子：抽象角色，真实对象和代理对象共同的接口 这里是房东的角色：package com.jiangxia.ProxyPattern.jingtaiProxy;
/**
* @Author: 江夏
* @Date: 2021/10/31/10:07
* @Description:抽象对象：房东 提供 签约 看房的功能
*/
public interface FangDong {
//签约功能
public void sign ();
//看房功能
public void lookHouse ();
}
复制代码代理角色需要实现抽象角色的方法，这里是中介的角色：package com.jiangxia.ProxyPattern.jingtaiProxy;
/**
* @Author: 江夏
* @Date: 2021/10/31/10:10
* @Description:
*/
public class ZhongJie implements FangDong{
public FangDong fangDong;
public ZhongJie(FangDong fangDong) {
this.fangDong = fangDong;
}
@Override
public void sign() {
System.out.println("中介替房东答应与你签约");
}
@Override
public void lookHouse() {
System.out.println("中介替房东带你去看房");
}
}
复制代码真实角色，你：package com.jiangxia.ProxyPattern.jingtaiProxy;
/**
* @Author: 江夏
* @Date: 2021/10/31/10:13
* @Description:
*/
public class FangKe implements FangDong{
@Override
public void sign() {
System.out.println("你签合同了！");
}
@Override
public void lookHouse() {
System.out.println("你去看房了！");
}
}
复制代码测试代码：/**
* @Author: 江夏
* @Date: 2021/10/31/10:15
* @Description:
*/
public class Test {
public static void main(String[] args) {
FangDong fangke = new FangKe();
FangDong zhongjie = new ZhongJie(new FangKe());
zhongjie.lookHouse();
zhongjie.sign();
}
}
复制代码输出结果如下：动态代理与静态代理不同的是动态代理类的源码是程序在运行期间由JVM根据反射等机制动态生成的，所以不存在代理类的字节码文件。代理角色和真实角色的联系在程序运行时确定。动态代理是一种较为高级的代理模式，它的典型应用就是Spring AOP。动态代理的例子：抽象角色和真实角色即房东和房客代码和上面一样。主要区别是代理角色的处理以及方法的调用：代理代码如下：package com.jiangxia.ProxyPattern.Dongtai;
import com.jiangxia.ProxyPattern.jingtaiProxy.FangDong;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class proxyHandler implements InvocationHandler {
private FangDong userImpl;
public proxyHandler(FangDong userImpl){
this.userImpl= userImpl;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object object = null;
//方法开始前做一些事情
if (method.getName().equals("sign")) {
//激活调用的方法
object = method.invoke(userImpl, args);
}
//方法结束后做一些事情
return object;
}
}
复制代码测试代码：package com.jiangxia.ProxyPattern.Dongtai;
import com.jiangxia.ProxyPattern.jingtaiProxy.FangDong;
import com.jiangxia.ProxyPattern.jingtaiProxy.FangKe;
import java.lang.reflect.Proxy;
public class Test {
public static void main(String[] args) {
FangDong fangek =new FangKe();
proxyHandler handler = new proxyHandler(fangek);
FangDong zhongjie = (FangDong)Proxy.newProxyInstance
(ClassLoader.getSystemClassLoader(), new Class[]{FangDong.class}, handler);
zhongjie.sign();
}
}
复制代码运行结果：代理模式优点1、业务类只需要关注业务逻辑本身，保证了业务类的重用性。这是代理的共有优点。2、能够协调调用者和被调用者，在一定程度上降低了系统的耦合度。3、虚拟代理通过使用一个小对象来代表一个大对象，可以减少系 统资源的消耗，对系统进行优化并提高运行速度。4、保护代理可以控制对真实对象的使用权限。5、远程代理使得客户端可以访问在远程机器上的对象，远程机器 可能具有更好的计算性能与处理速度，可以快速响应并处理客户端请求。代理模式缺点1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢，例如保护代理。2、实现代理模式需要额外的工作，而且有些代理模式的实现过程较为复杂，例如远程代理。应用场景当无法或不想直接引用某个对象或访问某个对象存在困难时，可以通过代理对象来间接访问。使用代理模式主要有两个目的：一是保护目标对象，二是增强目标对象。前面分析了代理模式的结构与特点，现在来分析以下的应用场景。1、远程代理，这种方式通常是为了隐藏目标对象存在于不同地址空间的事实，方便客户端访问。例如，用户申请某些网盘空间时，会在用户的文件系统中建立一个虚拟的硬盘，用户访问虚拟硬盘时实际访问的是网盘空间。2、虚拟代理，这种方式通常用于要创建的目标对象开销很大时。例如，下载一幅很大的图像需要很长时间，因某种计算比较复杂而短时间无法完成，这时可以先用小比例的虚拟代理替换真实的对象，消除用户对服务器慢的感觉。3、安全代理，这种方式通常用于控制不同种类客户对真实对象的访问权限。4、智能指引，主要用于调用目标对象时，代理附加一些额外的处理功能。例如，增加计算真实对象的引用次数的功能，这样当该对象没有被引用时，就可以自动释放它。5、延迟加载，指为了提高系统的性能，延迟对目标的加载。例如，Hibernate 中就存在属性的延迟加载和关联表的延时加载。6、Spring中的AOP使用的就是动态代理
【云原生 | Devops篇】Jenkins安装与实战（二）
二、Jenkins实战1、准备一个git项目进行测试我们以 gitee 为例， github 可能太慢了。需要 idea 安装 gitee 插件。或者自己熟悉手动命令也行。简要说明一下，其实这里用 gitee、github 或者用 gitcode 都能实现的，具体用哪个，同学们可以自行选择步骤：idea创建Spring Boot项目VCS - 创建git 仓库gitee创建一个仓库，本地上传到仓库上idea提交内容到gitee开发项目基本功能，并在项目中创建一个jenkinsfile文件创建一个名为 devops-java-demo的流水线项目，使用项目自己的流水线Jenkins的工作流程先定义一个流水线项目，指定项目的 git 位置流水线启动1 、先去 git 位置自动拉取代码2 、解析拉取代码里面的 Jenkinsfile 文件3 、按照 Jenkinsfile 指定的流水线开始加工项目不太会写流水线配置文件可以参考官方文档，非常详细的 官网流水线的说明文档：流水线Jenkins 重要的点1 、 jenkins 的家目录 /var/jenkins_home 已经被我们 docker 外部挂载了 /var/lib/docker/volumes/jenkins-data/_data2 、 WORKSPACE （工作空间） =/var/jenkins_home/workspace/java-devops-demo每一个流水线项目，占用一个文件夹位置BUILD_NUMBER=5；当前第几次构建
WORKSPACE_TMP（临时目录）=/var/jenkins_home/workspace/java-devops-demo@tmp
JOB_URL=http://192.168.88.163:8080/job/java-devops-demo/3 、常用的环境如果没有， jenkins 配置环境一大堆操作4 、 jenkins_url ：http://192.168.88.163:8080/小案例测试： // 写流水线的脚本（声明式、脚本式）
pipeline{
// 全部的CICD流程都需要在这里定义
// 任何一个代理可用就可以执行
agent any
// 定义一些环境信息
// 定义流水线的加工流程
stages {
// 流水线的所有阶段
// 1、编译
stage('编译'){
steps{
// 要做的所有事情
echo "编译..."
}
}
// 2、测试
stage('测试'){
steps{
// 要做的所有事情
echo "测试..."
}
}
// 3、打包
stage('打包'){
steps{
// 要做的所有事情
echo "打包..."
}
}
// 4、部署
stage('部署'){
steps{
// 要做的所有事情
echo "部署..."
}
}
}
