HelloController

Lorem ipsum.

"; +Document doc = Jsoup.parseBodyFragment(html); +Element body = doc.body(); +``` + +> **说明** +> +> `parseBodyFragment` 方法创建一个空壳的文档，并插入解析过的 HTML 到`body`元素中。假如你使用正常的 `Jsoup.parse(String html)` 方法，通常你也可以得到相同的结果，但是明确将用户输入作为 body 片段处理，以确保用户所提供的任何糟糕的 HTML 都将被解析成 body 元素。 +> +> `Document.body()` 方法能够取得文档 body 元素的所有子元素，与 `doc.getElementsByTag("body")`相同。 + +#### 保证安全 Stay safe + +假如你可以让用户输入 HTML 内容，那么要小心避免跨站脚本攻击。利用基于 `Whitelist` 的清除器和 `clean(String bodyHtml, Whitelist whitelist)`方法来清除用户输入的恶意内容。 + +### 从 URL 加载一个文档 + +使用 `Jsoup.connect(String url)`方法 + +```java +Document doc = Jsoup.connect("http://example.com/").get(); +``` + +> **说明** +> +> `connect(String url)` 方法创建一个新的 `Connection`, 和 `get()` 取得和解析一个 HTML 文件。如果从该 URL 获取 HTML 时发生错误，便会抛出 IOException，应适当处理。 + +`Connection` 接口还提供一个方法链来解决特殊请求，具体如下： + +```java +Document doc = Jsoup.connect("http://example.com") + .data("query", "Java") + .userAgent("Mozilla") + .cookie("auth", "token") + .timeout(3000) + .post(); +``` + +### 从一个文件加载一个文档 + +可以使用静态 `Jsoup.parse(File in, String charsetName, String baseUri)` 方法 + +```java +File input = new File("/tmp/input.html"); +Document doc = Jsoup.parse(input, "UTF-8", "http://example.com/"); +``` + +> **说明** +> +> `parse(File in, String charsetName, String baseUri)` 这个方法用来加载和解析一个 HTML 文件。如在加载文件的时候发生错误，将抛出 IOException，应作适当处理。 +> +> `baseUri` 参数用于解决文件中 URLs 是相对路径的问题。如果不需要可以传入一个空的字符串。 +> +> 另外还有一个方法`parse(File in, String charsetName)` ，它使用文件的路径做为 `baseUri`。这个方法适用于如果被解析文件位于网站的本地文件系统，且相关链接也指向该文件系统。 + +## 解析 + +### 使用 DOM 方法来遍历一个文档 + +**问题** + +你有一个 HTML 文档要从中提取数据，并了解这个 HTML 文档的结构。 + +**方法** + +将 HTML 解析成一个`Document`之后，就可以使用类似于 DOM 的方法进行操作。示例代码： + +```java +File input = new File("/tmp/input.html"); +Document doc = Jsoup.parse(input, "UTF-8", "http://example.com/"); + +Element content = doc.getElementById("content"); +Elements links = content.getElementsByTag("a"); +for (Element link : links) { + String linkHref = link.attr("href"); + String linkText = link.text(); +} +``` + +**说明** + +`Elements` 这个对象提供了一系列类似于 DOM 的方法来查找元素，抽取并处理其中的数据。 + +具体如下： + +#### 查找元素 + +- `getElementById(String id)` +- `getElementsByTag(String tag)` +- `getElementsByClass(String className)` +- `getElementsByAttribute(String key)` (and related methods) +- Element siblings: `siblingElements()`, `firstElementSibling()`, `lastElementSibling()`;`nextElementSibling()`, `previousElementSibling()` +- Graph: `parent()`, `children()`, `child(int index)` + +#### 元素数据 + +- `attr(String key)`获取属性`attr(String key, String value)`设置属性 +- `attributes()`获取所有属性 +- `id()`, `className()` and `classNames()` +- `text()`获取文本内容`text(String value)` 设置文本内容 +- `html()`获取元素内 HTML`html(String value)`设置元素内的 HTML 内容 +- `outerHtml()`获取元素外 HTML 内容 +- `data()`获取数据内容（例如：script 和 style 标签) +- `tag()` and `tagName()` + +#### 操作 HTML 和文本 + +- `append(String html)`, `prepend(String html)` +- `appendText(String text)`, `prependText(String text)` +- `appendElement(String tagName)`, `prependElement(String tagName)` +- `html(String value)` + +### 使用选择器语法来查找元素 + +**问题** + +你想使用类似于 CSS 或 jQuery 的语法来查找和操作元素。 + +**方法** + +可以使用`Element.select(String selector)` 和 `Elements.select(String selector)` 方法实现： + +```java +File input = new File("/tmp/input.html"); +Document doc = Jsoup.parse(input, "UTF-8", "http://example.com/"); + +Elements links = doc.select("a[href]"); //带有href属性的a元素 +Elements pngs = doc.select("img[src$=.png]"); + //扩展名为.png的图片 + +Element masthead = doc.select("div.masthead").first(); + //class等于masthead的div标签 + +Elements resultLinks = doc.select("h3.r > a"); //在h3元素之后的a元素 +``` + +> **说明** +> +> jsoup elements 对象支持类似于[CSS](http://www.w3.org/TR/2009/PR-css3-selectors-20091215/) (或[jquery](http://jquery.com/))的选择器语法，来实现非常强大和灵活的查找功能。. +> +> 这个`select` 方法在`Document`, `Element`,或`Elements`对象中都可以使用。且是上下文相关的，因此可实现指定元素的过滤，或者链式选择访问。 +> +> Select 方法将返回一个`Elements`集合，并提供一组方法来抽取和处理结果。 + +#### Selector 选择器概述 + +- `tagname`: 通过标签查找元素，比如：`a` +- `ns|tag`: 通过标签在命名空间查找元素，比如：可以用 `fb|name` 语法来查找 `` 元素 +- `#id`: 通过 ID 查找元素，比如：`#logo` +- `.class`: 通过 class 名称查找元素，比如：`.masthead` +- `[attribute]`: 利用属性查找元素，比如：`[href]` +- `[^attr]`: 利用属性名前缀来查找元素，比如：可以用`[^data-]` 来查找带有 HTML5 Dataset 属性的元素 +- `[attr=value]`: 利用属性值来查找元素，比如：`[width=500]` +- `[attr^=value]`, `[attr$=value]`, `[attr*=value]`: 利用匹配属性值开头、结尾或包含属性值来查找元素，比如：`[href*=/path/]` +- `[attr\~=regex]`: 利用属性值匹配正则表达式来查找元素，比如： `img[src\~=(?i)\.(png|jpe?g)]` +- `*`: 这个符号将匹配所有元素 + +#### Selector 选择器组合使用 + +- `el##id`: 元素+ID，比如： `div##logo` +- `el.class`: 元素+class，比如： `div.masthead` +- `el[attr]`: 元素+class，比如： `a[href]` +- 任意组合，比如：`a[href].highlight` +- `ancestor child`: 查找某个元素下子元素，比如：可以用`.body p` 查找在"body"元素下的所有`p`元素 +- `parent > child`: 查找某个父元素下的直接子元素，比如：可以用`div.content > p` 查找 `p` 元素，也可以用`body > *` 查找 body 标签下所有直接子元素 +- `siblingA + siblingB`: 查找在 A 元素之前第一个同级元素 B，比如：`div.head + div` +- `siblingA \~ siblingX`: 查找 A 元素之前的同级 X 元素，比如：`h1 \~ p` +- `el, el, el`:多个选择器组合，查找匹配任一选择器的唯一元素，例如：`div.masthead, div.logo` + +#### 伪选择器 selectors + +- `:lt(n)`: 查找哪些元素的同级索引值（它的位置在 DOM 树中是相对于它的父节点）小于 n，比如：`td:lt(3)` 表示小于三列的元素 +- `:gt(n)`:查找哪些元素的同级索引值大于` n``，比如 `： `div p:gt(2)`表示哪些 div 中有包含 2 个以上的 p 元素 +- `:eq(n)`: 查找哪些元素的同级索引值与`n`相等，比如：`form input:eq(1)`表示包含一个 input 标签的 Form 元素 +- `:has(seletor)`: 查找匹配选择器包含元素的元素，比如：`div:has(p)`表示哪些 div 包含了 p 元素 +- `:not(selector)`: 查找与选择器不匹配的元素，比如： `div:not(.logo)` 表示不包含 class=logo 元素的所有 div 列表 +- `:contains(text)`: 查找包含给定文本的元素，搜索不区分大不写，比如： `p:contains(jsoup)` +- `:containsOwn(text)`: 查找直接包含给定文本的元素 +- `:matches(regex)`: 查找哪些元素的文本匹配指定的正则表达式，比如：`div:matches((?i)login)` +- `:matchesOwn(regex)`: 查找自身包含文本匹配指定正则表达式的元素 +- 注意：上述伪选择器索引是从 0 开始的，也就是说第一个元素索引值为 0，第二个元素 index 为 1 等 + +可以查看`Selector` API 参考来了解更详细的内容 + +### 从元素抽取属性，文本和 HTML + +**问题** + +在解析获得一个 Document 实例对象，并查找到一些元素之后，你希望取得在这些元素中的数据。 + +**方法** + +- 要取得一个属性的值，可以使用`Node.attr(String key)` 方法 +- 对于一个元素中的文本，可以使用`Element.text()`方法 +- 对于要取得元素或属性中的 HTML 内容，可以使用`Element.html()`, 或 `Node.outerHtml()`方法 + +示例： + +```java +String html = "

An example link.

"; +Document doc = Jsoup.parse(html);//解析HTML字符串返回一个Document实现 +Element link = doc.select("a").first();//查找第一个a元素 + +String text = doc.body().text(); // "An example link"//取得字符串中的文本 +String linkHref = link.attr("href"); // "http://example.com/"//取得链接地址 +String linkText = link.text(); // "example""//取得链接地址中的文本 + +String linkOuterH = link.outerHtml(); + // "example" +String linkInnerH = link.html(); // "example"//取得链接内的html内容 +``` + +> **说明** +> +> 上述方法是元素数据访问的核心办法。此外还其它一些方法可以使用： +> +> - `Element.id()` +> - `Element.tagName()` +> - `Element.className()` and `Element.hasClass(String className)` +> +> 这些访问器方法都有相应的 setter 方法来更改数据 + +**参见** + +- `Element`和`Elements`集合类的参考文档 +- [URLs 处理](http://www.open-open.com/jsoup/working-with-urls.htm) +- [使用 CSS 选择器语法来查找元素](http://www.open-open.com/jsoup/selector-syntax.htm) + +### 处理 URLs + +**问题** + +你有一个包含相对 URLs 路径的 HTML 文档，需要将这些相对路径转换成绝对路径的 URLs。 + +**方法** + +1. 在你解析文档时确保有指定`base URI`，然后 +2. 使用 `abs:` 属性前缀来取得包含`base URI`的绝对路径。代码如下： + +```java +Document doc = Jsoup.connect("http://www.open-open.com").get(); + +Element link = doc.select("a").first(); +String relHref = link.attr("href"); // == "/" +String absHref = link.attr("abs:href"); // "http://www.open-open.com/" + +``` + +> **说明** +> +> 在 HTML 元素中，URLs 经常写成相对于文档位置的相对路径： `...`. 当你使用 `Node.attr(String key)` 方法来取得 a 元素的 href 属性时，它将直接返回在 HTML 源码中指定定的值。 +> +> 假如你需要取得一个绝对路径，需要在属性名前加 `abs:` 前缀。这样就可以返回包含根路径的 URL 地址`attr("abs:href")` +> +> 因此，在解析 HTML 文档时，定义 base URI 非常重要。 +> +> 如果你不想使用`abs:` 前缀，还有一个方法能够实现同样的功能 `Node.absUrl(String key)`。 + +## 数据修改 + +### 设置属性的值 + +**问题** + +在你解析一个 `Document` 之后可能想修改其中的某些属性值，然后再保存到磁盘或都输出到前台页面。 + +**方法** + +可以使用属性设置方法 `Element.attr(String key, String value)`, 和 `Elements.attr(String key, String value)`. + +假如你需要修改一个元素的 `class` 属性，可以使用 `Element.addClass(String className)` 和`Element.removeClass(String className)` 方法。 + +`Elements` 提供了批量操作元素属性和 class 的方法，比如：要为 div 中的每一个 a 元素都添加一个`rel="nofollow"` 可以使用如下方法： + +``` +doc.select("div.comments a").attr("rel", "nofollow"); + +``` + +> **说明** +> +> 与`Element`中的其它方法一样，`attr` 方法也是返回当 `Element` (或在使用选择器是返回 `Elements`集合)。这样能够很方便使用方法连用的书写方式。比如： +> +> ``` +> doc.select("div.masthead").attr("title", "jsoup").addClass("round-box"); +> ``` + +### 设置一个元素的 HTML 内容 + +**问题** + +你需要一个元素中的 HTML 内容 + +**方法** + +可以使用`Element`中的 HTML 设置方法具体如下： + +```java +Element div = doc.select("div").first(); //

+div.html("

lorem ipsum

"); //

lorem ipsum

+div.prepend("

First

");//在div前添加html内容 +div.append("

Last

");//在div之后添加html内容 +// 添完后的结果:

First

lorem ipsum

Last

+ +Element span = doc.select("span").first(); // One +span.wrap("

"); +// 添完后的结果:

One

+``` + +> **说明** +> +> - `Element.html(String html)` 这个方法将先清除元素中的 HTML 内容，然后用传入的 HTML 代替。 +> - `Element.prepend(String first)` 和 `Element.append(String last)` 方法用于在分别在元素内部 HTML 的前面和后面添加 HTML 内容 +> - `Element.wrap(String around)` 对元素包裹一个外部 HTML 内容。 +> +> **参见** +> +> 可以查看 API 参考文档中 `Element.prependElement(String tag)`和`Element.appendElement(String tag)` 方法来创建新的元素并作为文档的子元素插入其中。 + +### 设置元素的文本内容 + +**问题** + +你需要修改一个 HTML 文档中的文本内容 + +**方法** + +可以使用`Element`的设置方法：: + +``` +Element div = doc.select("div").first(); //

+div.text("five > four"); //

five > four

+div.prepend("First "); +div.append(" Last"); +// now:

First five > four Last

+``` + +> **说明** +> +> 文本设置方法与 [HTML setter](http://jsoup.org/cookbook/modifying-data/set-html) 方法一样： +> +> - `Element.text(String text)` 将清除一个元素中的内部 HTML 内容，然后提供的文本进行代替 +> - `Element.prepend(String first)` 和 `Element.append(String last)` 将分别在元素的内部 html 前后添加文本节点。 +> +> 对于传入的文本如果含有像 `<`, `>` 等这样的字符，将以文本处理，而非 HTML。 + +## HTML 清理 + +### 消除不受信任的 HTML (来防止 XSS 攻击) + +**问题** + +在做网站的时候，经常会提供用户评论的功能。有些不怀好意的用户，会搞一些脚本到评论内容中，而这些脚本可能会破坏整个页面的行为，更严重的是获取一些机要信息，此时需要清理该 HTML，以避免跨站脚本[cross-site scripting](http://en.wikipedia.org/wiki/Cross-site_scripting)攻击（XSS）。 + +**方法** + +使用 jsoup HTML `Cleaner` 方法进行清除，但需要指定一个可配置的 `Whitelist`。 + +```java +String unsafe = + "

Link

"; +String safe = Jsoup.clean(unsafe, Whitelist.basic()); +// now:

Link

+``` + +**说明** + +XSS 又叫 CSS (Cross Site Script) ，跨站脚本攻击。它指的是恶意攻击者往 Web 页面里插入恶意 html 代码，当用户浏览该页之时，嵌入其中 Web 里面的 html 代码会被执行，从而达到恶意攻击用户的特殊目的。XSS 属于被动式的攻击，因为其被动且不好利用，所以许多人常忽略其危害性。所以我们经常只让用户输入纯文本的内容，但这样用户体验就比较差了。 + +一个更好的解决方法就是使用一个富文本编辑器 WYSIWYG 如 [CKEditor](http://ckeditor.com/) 和 [TinyMCE](http://tinymce.moxiecode.com/)。这些可以输出 HTML 并能够让用户可视化编辑。虽然他们可以在客户端进行校验，但是这样还不够安全，需要在服务器端进行校验并清除有害的 HTML 代码，这样才能确保输入到你网站的 HTML 是安全的。否则，攻击者能够绕过客户端的 Javascript 验证，并注入不安全的 HMTL 直接进入您的网站。 + +jsoup 的 whitelist 清理器能够在服务器端对用户输入的 HTML 进行过滤，只输出一些安全的标签和属性。 + +jsoup 提供了一系列的 `Whitelist` 基本配置，能够满足大多数要求；但如有必要，也可以进行修改，不过要小心。 + +这个 cleaner 非常好用不仅可以避免 XSS 攻击，还可以限制用户可以输入的标签范围。 + +**参见** + +- 参阅[XSS cheat sheet](http://ha.ckers.org/xss.html) ，有一个例子可以了解为什么不能使用正则表达式，而采用安全的 whitelist parser-based 清理器才是正确的选择。 +- 参阅`Cleaner` ，了解如何返回一个 `Document` 对象，而不是字符串 +- 参阅`Whitelist`，了解如何创建一个自定义的 whitelist +- [nofollow](http://en.wikipedia.org/wiki/Nofollow) 链接属性了解 + +## 参考 + +- [jsoup github 托管代码](https://github.com/jhy/jsoup) +- [jsoup Cookbook](https://jsoup.org/cookbook/) +- [jsoup Cookbook(中文版)](http://www.open-open.com/jsoup/) +- [不错的 jsoup 学习笔记](https://github.com/code4craft/jsoup-learning) \ No newline at end of file diff --git "a/docs/01.Java/12.\345\267\245\345\205\267/99.\345\205\266\344\273\226/06.Thumbnailator.md" "b/docs/01.Java/12.\345\267\245\345\205\267/99.\345\205\266\344\273\226/06.Thumbnailator.md" new file mode 100644 index 00000000..71151154 --- /dev/null +++ "b/docs/01.Java/12.\345\267\245\345\205\267/99.\345\205\266\344\273\226/06.Thumbnailator.md" @@ -0,0 +1,242 @@ +--- +title: Thumbnailator 快速入门 +date: 2022-02-17 22:34:30 +order: 06 +categories: + - Java + - 工具 + - 其他 +tags: + - Java + - 图形处理 + - Thumbnailator +permalink: /pages/adacc5/ +--- + +# Thumbnailator 快速入门 + +## 简介 + +`Thumbnailator` 是一个开源的 **Java** 项目，它提供了非常简单的 API 来对图片进行缩放、旋转以及加水印的处理。 + +有多简单呢？简单到一行代码就可以完成图片处理。形式如下： + +```java +Thumbnails.of(new File("path/to/directory").listFiles()) + .size(640, 480) + .outputFormat("jpg") + .toFiles(Rename.PREFIX_DOT_THUMBNAIL); +``` + +当然，Thumbnailator 还有一些使用细节，下面我会一一道来。 + +## 核心 API + +### Thumbnails + +`Thumbnails` 是使用 Thumbnailator 创建缩略图的主入口。 + +它提供了一组初始化 `Thumbnails.Builder` 的接口。 + +先看下这组接口的声明： + +```java +// 可变长度参数列表 +public static Builder of(String... files) {...} +public static Builder of(File... files) {...} +public static Builder of(URL... urls) {...} +public static Builder of(InputStream... inputStreams) {...} +public static Builder of(BufferedImage... images) {...} +// 迭代器（所有实现 Iterable 接口的 Java 对象都可以，当然也包括 List、Set） +public static Builder fromFilenames(Iterable files) {...} +public static Builder fromFiles(Iterable files) {...} +public static Builder fromURLs(Iterable urls) {...} +public static Builder fromInputStreams(Iterable inputStreams) {...} +public static Builder fromImages(Iterable images) {...} +``` + +很显然，**Thumbnails 允许通过传入文件名、文件、网络图的 URL、图片流、图片缓存多种方式来初始化构造器**。 + +因此，你可以根据实际需求来灵活的选择图片的输入方式。 + +需要注意一点：**如果输入是多个对象（无论你是直接输入容器对象或使用可变参数方式传入多个对象），则输出也必须选用输出多个对象的方式，否则会报异常。** + +### Thumbnails.Builder + +`Thumbnails.Builder` 是 `Thumbnails` 的内部静态类。它用于设置生成缩略图任务的相关参数。 + +**_注：`Thumbnails.Builder` 的构造函数是私有函数。所以，它只允许通过 `Thumbnails` 的实例化函数来进行初始化。_** + +#### 设置参数的函数 + +`Thumbnails.Builder` 提供了一组函数链形式的接口来设置缩放图参数。 + +以设置大小函数为例： + +```java +public Builder size(int width, int height) +{ + updateStatus(Properties.SIZE, Status.ALREADY_SET); + updateStatus(Properties.SCALE, Status.CANNOT_SET); + + validateDimensions(width, height); + this.width = width; + this.height = height; + + return this; +} +``` + +通过返回 this 指针，使得设置参数函数可以以链式调用的方式来使用，形式如下： + +```java +Thumbnails.of(new File("original.jpg")) + .size(160, 160) + .rotate(90) + .watermark(Positions.BOTTOM_RIGHT, ImageIO.read(new File("watermark.png")), 0.5f) + .outputQuality(0.8) + .toFile(new File("image-with-watermark.jpg")); +``` + +好处，不言自明：那就是大大简化了代码。 + +#### 输出函数 + +`Thumbnails.Builder` 提供了一组重载函数来输出生成的缩放图。 + +函数声明如下： + +```java +// 返回图片缓存 +public List asBufferedImages() throws IOException {...} +public BufferedImage asBufferedImage() throws IOException {...} +// 返回文件列表 +public List asFiles(Iterable iterable) throws IOException {...} +public List asFiles(Rename rename) throws IOException {...} +public List asFiles(File destinationDir, Rename rename) throws IOException {...} +// 创建文件 +public void toFile(File outFile) throws IOException {...} +public void toFile(String outFilepath) throws IOException {...} +public void toFiles(Iterable iterable) throws IOException {...} +public void toFiles(Rename rename) throws IOException {...} +public void toFiles(File destinationDir, Rename rename) throws IOException {...} +// 创建输出流 +public void toOutputStream(OutputStream os) throws IOException {...} +public void toOutputStreams(Iterable iterable) throws IOException {...} +``` + +### 工作流 + +Thumbnailator 的工作步骤十分简单，可分为三步： + +1. **输入**：`Thumbnails` 根据输入初始化构造器—— `Thumbnails.Builder` 。 + +2. **设置**：`Thumbnails.Builder` 设置缩放图片的参数。 + +3. **输出**：`Thumbnails.Builder` 输出图片文件或图片流。 + +> 更多详情可以参考： [Thumbnailator 官网 javadoc](https://coobird.github.io/thumbnailator/javadoc/0.4.8/) + +## 实战 + +前文介绍了 Thumbnailator 的核心 API，接下来我们就可以通过实战来看看 Thumbnailator 究竟可以做些什么。 + +Thumbnailator 生成什么样的图片，是根据设置参数来决定的。 + +### 安装 + +maven 项目中引入依赖： + +```xml + + net.coobird + thumbnailator + [0.4, 0.5) + +``` + +### 图片缩放 + +`Thumbnails.Builder` 的 `size` 函数可以设置新图片精确的宽度和高度，也可以用 `scale` 函数设置缩放比例。 + +```java +Thumbnails.of("oldFile.png") + .size(16, 16) + .toFile("newFile_16_16.png"); + +Thumbnails.of("oldFile.png") + .scale(2.0) + .toFile("newFile_scale_2.0.png"); + +Thumbnails.of("oldFile.png") + .scale(1.0, 0.5) + .toFile("newFile_scale_1.0_0.5.png"); +``` + +**oldFile.png** + +![img](http://upload-images.jianshu.io/upload_images/3101171-ba63439898602e8f.png) + +**newFile_scale_1.0_0.5.png** + +![img](http://upload-images.jianshu.io/upload_images/3101171-a01ea4515fff865d.png) + +### 图片旋转 + +`Thumbnails.Builder` 的 `size` 函数可以设置新图片的旋转角度。 + +```java +Thumbnails.of("oldFile.png") + .scale(0.8) + .rotate(90) + .toFile("newFile_rotate_90.png"); + +Thumbnails.of("oldFile.png") + .scale(0.8) + .rotate(180) + .toFile("newFile_rotate_180.png"); +``` + +**newFile_rotate_90.png** + +![img](http://upload-images.jianshu.io/upload_images/3101171-17d54bc33b38d45b.png) + +### 加水印 + +`Thumbnails.Builder` 的 `watermark` 函数可以为图片添加水印图片。第一个参数是水印的位置；第二个参数是水印图片的缓存数据；第三个参数是透明度。 + +```java +BufferedImage watermarkImage = ImageIO.read(new File("wartermarkFile.png")); +Thumbnails.of("oldFile.png") + .scale(0.8) + .watermark(Positions.BOTTOM_LEFT, watermarkImage, 0.5f) + .toFile("newFile_watermark.png"); +``` + +**wartermarkFile.png** + +![img](http://upload-images.jianshu.io/upload_images/3101171-97909ee6c066c195.png?imageMogr2/auto-orient/strip) + +**newFile_watermark.png** + +![img](http://upload-images.jianshu.io/upload_images/3101171-93eb7ef71b811a0c.png) + +### 批量处理图片 + +下面以批量给图片加水印来展示一下如何处理多个图片文件。 + +```java +BufferedImage watermarkImage = ImageIO.read(new File("wartermarkFile.png")); + +File destinationDir = new File("D:\\watermark\\"); +Thumbnails.of("oldFile.png", "oldFile2.png") + .scale(0.8) + .watermark(Positions.BOTTOM_LEFT, watermarkImage, 0.5f) + .toFiles(destinationDir, Rename.PREFIX_DOT_THUMBNAIL); +``` + +> **需要参考完整测试例代码请** [**点击这里**](https://github.com/dunwu/JavaParty/blob/master/toolbox/image/src/test/java/org/zp/image/ThumbnailatorTest.java) + +## 参考 + +[Thumbnailator 官方示例文档](https://github.com/coobird/thumbnailator/wiki/Examples) \ No newline at end of file diff --git "a/docs/01.Java/12.\345\267\245\345\205\267/99.\345\205\266\344\273\226/07.Zxing.md" "b/docs/01.Java/12.\345\267\245\345\205\267/99.\345\205\266\344\273\226/07.Zxing.md" new file mode 100644 index 00000000..d5f691bb --- /dev/null +++ "b/docs/01.Java/12.\345\267\245\345\205\267/99.\345\205\266\344\273\226/07.Zxing.md" @@ -0,0 +1,97 @@ +--- +title: ZXing 快速入门 +date: 2022-02-17 22:34:30 +order: 07 +categories: + - Java + - 工具 + - 其他 +tags: + - Java + - 条形码 + - ZXing +permalink: /pages/b563af/ +--- + +# ZXing 快速入门 + +## 简介 + +`ZXing` 是一个开源 Java 类库用于解析多种格式的 1D/2D 条形码。目标是能够对 QR 编码、Data Matrix、UPC 的 1D 条形码进行解码。其提供了多种平台下的客户端包括：J2ME、J2SE 和 Android。 + +官网：[ZXing github 仓库](https://github.com/zxing/zxing) + +## 实战 + +**_本例演示如何在一个非 android 的 Java 项目中使用 ZXing 来生成、解析二维码图片。_** + +### 安装 + +maven 项目只需引入依赖： + +```xml + + com.google.zxing + core + 3.3.0 + + + com.google.zxing + javase + 3.3.0 + +``` + +如果非 maven 项目，就去官网下载发布版本：[下载地址](https://github.com/zxing/zxing/releases) + +### 生成二维码图片 + +ZXing 生成二维码图片有以下步骤： + +1. `com.google.zxing.MultiFormatWriter` 根据内容以及图像编码参数生成图像 2D 矩阵。 +2. `com.google.zxing.client.j2se.MatrixToImageWriter` 根据图像矩阵生成图片文件或图片缓存 `BufferedImage` 。 + +```java +public void encode(String content, String filepath) throws WriterException, IOException { + int width = 100; + int height = 100; + Map encodeHints = new HashMap(); + encodeHints.put(EncodeHintType.CHARACTER_SET, "UTF-8"); + BitMatrix bitMatrix = new MultiFormatWriter().encode(content, BarcodeFormat.QR_CODE, width, height, encodeHints); + Path path = FileSystems.getDefault().getPath(filepath); + MatrixToImageWriter.writeToPath(bitMatrix, "png", path); +} +``` + +### 解析二维码图片 + +ZXing 解析二维码图片有以下步骤： + +1. 使用 `javax.imageio.ImageIO` 读取图片文件，并存为一个 `java.awt.image.BufferedImage` 对象。 + +2. 将 `java.awt.image.BufferedImage` 转换为 ZXing 能识别的 `com.google.zxing.BinaryBitmap` 对象。 + +3. `com.google.zxing.MultiFormatReader` 根据图像解码参数来解析 `com.google.zxing.BinaryBitmap` 。 + +```java +public String decode(String filepath) throws IOException, NotFoundException { + BufferedImage bufferedImage = ImageIO.read(new FileInputStream(filepath)); + LuminanceSource source = new BufferedImageLuminanceSource(bufferedImage); + Binarizer binarizer = new HybridBinarizer(source); + BinaryBitmap bitmap = new BinaryBitmap(binarizer); + HashMap decodeHints = new HashMap(); + decodeHints.put(DecodeHintType.CHARACTER_SET, "UTF-8"); + Result result = new MultiFormatReader().decode(bitmap, decodeHints); + return result.getText(); +} +``` + +完整参考示例：[测试例代码](https://github.com/dunwu/JavaParty/blob/master/toolbox/image/src/test/java/org/zp/image/QRCodeUtilTest.java) + +以下是一个生成的二维码图片示例： + +![img](http://upload-images.jianshu.io/upload_images/3101171-26b73730088f0ab8.png) + +## 参考 + +[ZXing github 仓库](https://github.com/zxing/zxing) \ No newline at end of file diff --git "a/docs/01.Java/12.\345\267\245\345\205\267/README.md" "b/docs/01.Java/12.\345\267\245\345\205\267/README.md" new file mode 100644 index 00000000..dbd1c924 --- /dev/null +++ "b/docs/01.Java/12.\345\267\245\345\205\267/README.md" @@ -0,0 +1,56 @@ +--- +title: Java 工具 +date: 2022-02-18 08:53:11 +categories: + - Java + - 工具 +tags: + - Java + - 工具 +permalink: /pages/1123e1/ +hidden: true +index: false +--- + +# Java 工具 + +## 📖 内容 + +### Java IO + +- [JSON 序列化](01.IO/01.JSON序列化.md) - [fastjson](https://github.com/alibaba/fastjson)、[Jackson](https://github.com/FasterXML/jackson)、[Gson](https://github.com/google/gson) +- [二进制序列化](01.IO/02.二进制序列化.md) - [Protobuf](https://developers.google.com/protocol-buffers)、[Thrift](https://thrift.apache.org/)、[Hessian](http://hessian.caucho.com/)、[Kryo](https://github.com/EsotericSoftware/kryo)、[FST](https://github.com/RuedigerMoeller/fast-serialization) + +### JavaBean 工具 + +- [Lombok](02.JavaBean/01.Lombok.md) +- [Dozer](02.JavaBean/02.Dozer.md) + +### Java 模板引擎 + +- [Freemark](03.模板引擎/01.Freemark.md) +- [Velocity](03.模板引擎/02.Thymeleaf.md) +- [Thymeleaf](03.模板引擎/03.Velocity.md) + +### Java 测试工具 + +- [Junit](04.测试/01.Junit.md) +- [Mockito](04.测试/02.Mockito.md) +- [Jmeter](04.测试/03.Jmeter.md) +- [JMH](04.测试/04.JMH.md) + +### 其他 + +- [Java 日志](99.其他/01.Java日志.md) +- [Java 工具包](99.其他/02.Java工具包.md) +- [Reflections](99.其他/03.Reflections.md) +- [JavaMail](99.其他/04.JavaMail.md) +- [Jsoup](99.其他/05.Jsoup.md) +- [Thumbnailator](99.其他/06.Thumbnailator.md) +- [Zxing](99.其他/07.Zxing.md) + +## 📚 资料 + +## 🚪 传送 + +◾ 💧 [钝悟的 IT 知识图谱](https://dunwu.github.io/waterdrop/) ◾ \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/00.Spring\347\273\274\345\220\210/01.Spring\346\246\202\350\277\260.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/00.Spring\347\273\274\345\220\210/01.Spring\346\246\202\350\277\260.md" new file mode 100644 index 00000000..3a202241 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/00.Spring\347\273\274\345\220\210/01.Spring\346\246\202\350\277\260.md" @@ -0,0 +1,188 @@ +--- +title: Spring Framework 综述 +date: 2019-11-22 10:46:02 +order: 01 +categories: + - Java + - 框架 + - Spring + - Spring综合 +tags: + - Java + - 框架 + - Spring +permalink: /pages/9d3091/ +--- + +# Spring Framework 综述 + +## Spring Framework 简介 + +Spring Framework 是最受欢迎的企业级 Java 应用程序开发框架。用于构建企业级应用的轻量级、一站式解决方案。 + +当谈论到大小和透明度时， Spring 是轻量级的。 Spring 框架的基础版本是在 2 MB 左右的。 + +Spring 框架的核心特性可以用于开发任何 Java 应用程序，但是在 Java EE 平台上构建 web 应用程序是需要扩展的。 Spring 框架的目标是使 J2EE 开发变得更容易使用，通过启用基于 POJO 编程模型来促进良好的编程实践。 + +Spring Framework 设计理念如下： + +- 力争让选择无处不在 +- 体现海纳百川的精神 +- 保持后向兼容性 +- 专注 API 设计 +- 追求严苛的代码质量 + +## 为什么使用 Spring + +下面列出的是使用 Spring 框架主要的好处： + +- Spring 可以使开发人员使用 POJOs 开发企业级的应用程序。只使用 POJOs 的好处是你不需要一个 EJB 容器产品，比如一个应用程序服务器，但是你可以选择使用一个健壮的 servlet 容器，比如 Tomcat 或者一些商业产品。 +- Spring 在一个单元模式中是有组织的。即使包和类的数量非常大，你只需要选择你需要的部分，而忽略剩余的那部分。 +- Spring 不会让你白费力气做重复工作，它真正的利用了一些现有的技术，像几个 ORM 框架、日志框架、JEE、Quartz 和 JDK 计时器，其他视图技术。 +- 测试一个用 Spring 编写的应用程序很容易，因为 environment-dependent 代码被放进了这个框架中。此外，通过使用 JavaBean-style POJOs，它在使用依赖注入注入测试数据时变得更容易。 +- Spring 的 web 框架是一个设计良好的 web MVC 框架，它为 web 框架，比如 Structs 或者其他工程上的或者很少受欢迎的 web 框架，提供了一个很好的供替代的选择。 +- 为将特定技术的异常（例如，由 JDBC、Hibernate，或者 JDO 抛出的异常）翻译成一致的， Spring 提供了一个方便的 API，而这些都是未经检验的异常。 +- 轻量级的 IOC 容器往往是轻量级的，例如，特别是当与 EJB 容器相比的时候。这有利于在内存和 CPU 资源有限的计算机上开发和部署应用程序。 +- Spring 提供了一个一致的事务管理界面，该界面可以缩小成一个本地事务（例如，使用一个单一的数据库）和扩展成一个全局事务（例如，使用 JTA）。 + +## 核心思想 + +Spring 最核心的两个技术思想是：IoC 和 Aop + +### IoC + +`IoC` 即 `Inversion of Control` ，意为控制反转。 + +Spring 最认同的技术是控制反转的**依赖注入（DI）**模式。控制反转（IoC）是一个通用的概念，它可以用许多不同的方式去表达，依赖注入仅仅是控制反转的一个具体的例子。 + +当编写一个复杂的 Java 应用程序时，应用程序类应该尽可能的独立于其他的 Java 类来增加这些类可重用可能性，当进行单元测试时，可以使它们独立于其他类进行测试。依赖注入（或者有时被称为配线）有助于将这些类粘合在一起，并且在同一时间让它们保持独立。 + +到底什么是依赖注入？让我们将这两个词分开来看一看。这里将依赖关系部分转化为两个类之间的关联。例如，类 A 依赖于类 B。现在，让我们看一看第二部分，注入。所有这一切都意味着类 B 将通过 IoC 被注入到类 A 中。 + +依赖注入可以以向构造函数传递参数的方式发生，或者通过使用 setter 方法 post-construction。由于依赖注入是 Spring 框架的核心部分，所以我将在一个单独的章节中利用很好的例子去解释这一概念。 + +### Aop + +Spring 框架的一个关键组件是**面向方面的程序设计（AOP）**框架。一个程序中跨越多个点的功能被称为**横切关注点**，这些横切关注点在概念上独立于应用程序的业务逻辑。有各种各样常见的很好的关于方面的例子，比如日志记录、声明性事务、安全性，和缓存等等。 + +在 OOP 中模块化的关键单元是类，而在 AOP 中模块化的关键单元是方面。AOP 帮助你将横切关注点从它们所影响的对象中分离出来，然而依赖注入帮助你将你的应用程序对象从彼此中分离出来。 + +Spring 框架的 AOP 模块提供了面向方面的程序设计实现，允许你定义拦截器方法和切入点，可以实现将应该被分开的代码干净的分开功能。我将在一个独立的章节中讨论更多关于 Spring AOP 的概念。 + +## Spring 体系结构 + +Spring 当前框架有**20**个 jar 包，大致可以分为**6**大模块: + +- 1. 为什么使用 Spring +- 2. 核心思想 + - 2.1. IoC + - 2.2. Aop +- 3. Spring 体系结构 + - 3.1. Core Container + - 3.1.1. BeanFactory + - 3.1.2. ApplicationContext + - 3.2. AOP and Instrumentation + - 3.3. Messaging + - 3.4. Data Access / Integaration + - 3.5. Web + - 3.6. Test +- 4. 术语 + +Spring 框架提供了非常丰富的功能，因此整个架构也很庞大。 +在我们实际的应用开发中，并不一定要使用所有的功能，而是可以根据需要选择合适的 Spring 模块。 + +![img](https://raw.githubusercontent.com/dunwu/images/master/cs/java/spring/spring-framework.png) + +### Core Container + +IoC 容器是 Spring 框架的核心。spring 容器使用依赖注入管理构成应用的组件，它会创建相互协作的组件之间的关联。毫无疑问，这些对象更简单干净，更容易理解，也更容易重用和测试。 +Spring 自带了几种容器的实现，可归纳为两种类型： + +#### BeanFactory + +由 org.springframework.beans.factory.BeanFactory 接口定义。 +它是最简单的容器，提供基本的 DI 支持。 + +#### ApplicationContext + +由 org.springframework.context.ApplicationContext 接口定义。 +它是基于 BeanFactory 之上构建，并提供面向应用的服务，例如从属性文件解析文本信息的能力，以及发布应用事件给感兴趣的事件监听者的能力。 +**_注：Bean 工厂对于大多数应用来说往往太低级了，所以应用上下文使用更广泛。推荐在开发中使用应用上下文容器。_** + +Spring 自带了多种应用上下文，最可能遇到的有以下几种： +`ClassPathXmlApplicationContext`：从类路径下的 XML 配置文件中加载上下文定义，把应用上下文定义文件当做类资源。 +`FileSystemXmlApplicationContext`：读取文件系统下的 XML 配置文件并加载上下文定义。 +`XmlWebApplicationContext`：读取 Web 应用下的 XML 配置文件并装载上下文定义。 + +**_范例_** + +```java +ApplicationContext context = new FileSystemXmlApplicationContext("D:\Temp\build.xml"); +ApplicationContext context2 = new ClassPathXmlApplicationContext("build.xml"); +``` + +可以看到，加载 `FileSystemXmlApplicationContext` 和 `ClassPathXmlApplicationContext` 十分相似。 +差异在于：前者在指定文件系统路径下查找 build.xml 文件；而后在所有类路径（包含 JAR 文件）下查找 build.xml 文件。 +通过引用应用上下文，可以很方便的调用 getBean() 方法从 Spring 容器中获取 Bean。 + +**相关 jar 包** + +- `spring-core`, `spring-beans`, 提供框架的基础部分，包括 IoC 和依赖注入特性。 + +- `spring-context`, 在`spring-core`, `spring-beans`基础上构建。它提供一种框架式的访问对象的方法。它也支持类似 Java EE 特性，例如：EJB，JMX 和基本 remoting。ApplicationContext 接口是它的聚焦点。 +- `springcontext-support`, 集成第三方库到 Spring application context。 +- `spring-expression`，提供一种强有力的表达语言在运行时来查询和操纵一个对象图。 + +### AOP and Instrumentation + +**相关 jar 包** + +- `spring-aop`，提供了对面向切面编程的丰富支持。 +- `spring-aspects`，提供了对 AspectJ 的集成。 +- `spring-instrument`，提供了对类 instrumentation 的支持和类加载器。 +- `spring-instrument-tomcat`，包含了 Spring 对 Tomcat 的 instrumentation 代理。 + +### Messaging + +**相关 jar 包** + +- `spring-messaging`，包含 spring 的消息处理功能，如 Message，MessageChannel，MessageHandler。 + +### Data Access / Integaration + +Data Access/Integration 层包含了 JDBC / ORM / OXM / JMS 和 Transaction 模块。 + +**相关 jar 包** + +- `spring-jdbc`，提供了一个 JDBC 抽象层。 + +- `spring-tx`，支持编程和声明式事务管理类。 +- `spring-orm`，提供了流行的对象关系型映射 API 集，如 JPA，JDO，Hibernate。 +- `spring-oxm`，提供了一个抽象层以支持对象/XML 映射的实现，如 JAXB，Castor，XMLBeans，JiBX 和 XStream. +- `spring-jms`，包含了生产和消费消息的功能。 + +### Web + +**相关 jar 包** + +- `spring-web`，提供了基本的面向 web 的功能，如多文件上传、使用 Servlet 监听器的 Ioc 容器的初始化。一个面向 web 的应用层上下文。 + +- `spring-webmvc`，包括 MVC 和 REST web 服务实现。 +- `spring-webmvc-portlet`，提供在 Protlet 环境的 MVC 实现和`spring-webmvc`功能的镜像。 + +### Test + +**相关 jar 包** + +- `spring-test`，以 Junit 和 TestNG 来支持 spring 组件的单元测试和集成测试。 + +## 术语 + +- **应用程序**：是能完成我们所需要功能的成品，比如购物网站、OA 系统。 +- **框架**：是能完成一定功能的半成品，比如我们可以使用框架进行购物网站开发；框架做一部分功能，我们自己做一部分功能，这样应用程序就创建出来了。而且框架规定了你在开发应用程序时的整体架构，提供了一些基础功能，还规定了类和对象的如何创建、如何协作等，从而简化我们开发，让我们专注于业务逻辑开发。 +- **非侵入式设计**：从框架角度可以这样理解，无需继承框架提供的类，这种设计就可以看作是非侵入式设计，如果继承了这些框架类，就是侵入设计，如果以后想更换框架之前写过的代码几乎无法重用，如果非侵入式设计则之前写过的代码仍然可以继续使用。 +- **轻量级及重量级**：轻量级是相对于重量级而言的，轻量级一般就是非入侵性的、所依赖的东西非常少、资源占用非常少、部署简单等等，其实就是比较容易使用，而重量级正好相反。 +- **POJO**：POJO（Plain Old Java Objects）简单的 Java 对象，它可以包含业务逻辑或持久化逻辑，但不担当任何特殊角色且不继承或不实现任何其它 Java 框架的类或接口。 +- **容器**：在日常生活中容器就是一种盛放东西的器具，从程序设计角度看就是装对象的的对象，因为存在放入、拿出等操作，所以容器还要管理对象的生命周期。 +- **控制反转：**即 Inversion of Control，缩写为 IoC，控制反转还有一个名字叫做依赖注入（Dependency Injection），就是由容器控制程序之间的关系，而非传统实现中，由程序代码直接操控。 +- **JavaBean**：一般指容器管理对象，在 Spring 中指 Spring IoC 容器管理对象。 \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/00.Spring\347\273\274\345\220\210/21.SpringBoot\347\237\245\350\257\206\345\233\276\350\260\261.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/00.Spring\347\273\274\345\220\210/21.SpringBoot\347\237\245\350\257\206\345\233\276\350\260\261.md" new file mode 100644 index 00000000..3a5733b4 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/00.Spring\347\273\274\345\220\210/21.SpringBoot\347\237\245\350\257\206\345\233\276\350\260\261.md" @@ -0,0 +1,951 @@ +--- +title: SpringBoot 知识图谱 +date: 2020-08-12 07:01:26 +order: 21 +categories: + - Java + - 框架 + - Spring + - Spring综合 +tags: + - Java + - 框架 + - Spring + - SpringBoot +permalink: /pages/430f53/ +--- + +# SpringBoot 知识图谱 + +> 1. 预警：本文非常长，建议先 mark 后看，也许是最后一次写这么长的文章 +> 2. 说明：前面有 4 个小节关于 Spring 的基础知识，分别是：IOC 容器、JavaConfig、事件监听、SpringFactoriesLoader 详解，它们占据了本文的大部分内容，虽然它们之间可能没有太多的联系，但这些知识对于理解 Spring Boot 的核心原理至关重要，如果你对 Spring 框架烂熟于心，完全可以跳过这 4 个小节。正是因为这个系列的文章是由这些看似不相关的知识点组成，因此取名知识清单。 + +在过去两三年的 Spring 生态圈，最让人兴奋的莫过于 Spring Boot 框架。或许从命名上就能看出这个框架的设计初衷：快速的启动 Spring 应用。因而 Spring Boot 应用本质上就是一个基于 Spring 框架的应用，它是 Spring 对“约定优先于配置”理念的最佳实践产物，它能够帮助开发者更快速高效地构建基于 Spring 生态圈的应用。 + +那 Spring Boot 有何魔法？**自动配置**、**起步依赖**、**Actuator**、**命令行界面(CLI)** 是 Spring Boot 最重要的 4 大核心特性，其中 CLI 是 Spring Boot 的可选特性，虽然它功能强大，但也引入了一套不太常规的开发模型，因而这个系列的文章仅关注其它 3 种特性。如文章标题，本文是这个系列的第一部分，将为你打开 Spring Boot 的大门，重点为你剖析其启动流程以及自动配置实现原理。要掌握这部分核心内容，理解一些 Spring 框架的基础知识，将会让你事半功倍。 + +## 一、抛砖引玉：探索 Spring IoC 容器 + +如果有看过`SpringApplication.run()`方法的源码，Spring Boot 冗长无比的启动流程一定会让你抓狂，透过现象看本质，SpringApplication 只是将一个典型的 Spring 应用的启动流程进行了扩展，因此，透彻理解 Spring 容器是打开 Spring Boot 大门的一把钥匙。 + +### 1.1、Spring IoC 容器 + +可以把 Spring IoC 容器比作一间餐馆，当你来到餐馆，通常会直接招呼服务员：点菜！至于菜的原料是什么？如何用原料把菜做出来？可能你根本就不关心。IoC 容器也是一样，你只需要告诉它需要某个 bean，它就把对应的实例（instance）扔给你，至于这个 bean 是否依赖其他组件，怎样完成它的初始化，根本就不需要你关心。 + +作为餐馆，想要做出菜肴，得知道菜的原料和菜谱，同样地，IoC 容器想要管理各个业务对象以及它们之间的依赖关系，需要通过某种途径来记录和管理这些信息。`BeanDefinition`对象就承担了这个责任：容器中的每一个 bean 都会有一个对应的 BeanDefinition 实例，该实例负责保存 bean 对象的所有必要信息，包括 bean 对象的 class 类型、是否是抽象类、构造方法和参数、其它属性等等。当客户端向容器请求相应对象时，容器就会通过这些信息为客户端返回一个完整可用的 bean 实例。 + +原材料已经准备好（把 BeanDefinition 看着原料），开始做菜吧，等等，你还需要一份菜谱，`BeanDefinitionRegistry`和`BeanFactory`就是这份菜谱，BeanDefinitionRegistry 抽象出 bean 的注册逻辑，而 BeanFactory 则抽象出了 bean 的管理逻辑，而各个 BeanFactory 的实现类就具体承担了 bean 的注册以及管理工作。它们之间的关系就如下图： + +![img](https://user-gold-cdn.xitu.io/2018/9/9/165bd49d06649b0b?imageView2/0/w/1280/h/960/format/webp/ignore-error/1) _BeanFactory、BeanDefinitionRegistry 关系图（来自：Spring 揭秘）_ + +`DefaultListableBeanFactory`作为一个比较通用的 BeanFactory 实现，它同时也实现了 BeanDefinitionRegistry 接口，因此它就承担了 Bean 的注册管理工作。从图中也可以看出，BeanFactory 接口中主要包含 getBean、containBean、getType、getAliases 等管理 bean 的方法，而 BeanDefinitionRegistry 接口则包含 registerBeanDefinition、removeBeanDefinition、getBeanDefinition 等注册管理 BeanDefinition 的方法。 + +下面通过一段简单的代码来模拟 BeanFactory 底层是如何工作的： + +``` +// 默认容器实现 +DefaultListableBeanFactory beanRegistry = new DefaultListableBeanFactory(); +// 根据业务对象构造相应的BeanDefinition +AbstractBeanDefinition definition = new RootBeanDefinition(Business.class,true); +// 将bean定义注册到容器中 +beanRegistry.registerBeanDefinition("beanName",definition); +// 如果有多个bean，还可以指定各个bean之间的依赖关系 +// ........ + +// 然后可以从容器中获取这个bean的实例 +// 注意：这里的beanRegistry其实实现了BeanFactory接口，所以可以强转， +// 单纯的BeanDefinitionRegistry是无法强制转换到BeanFactory类型的 +BeanFactory container = (BeanFactory)beanRegistry; +Business business = (Business)container.getBean("beanName"); +``` + +这段代码仅为了说明 BeanFactory 底层的大致工作流程，实际情况会更加复杂，比如 bean 之间的依赖关系可能定义在外部配置文件(XML/Properties)中、也可能是注解方式。Spring IoC 容器的整个工作流程大致可以分为两个阶段： + +①、容器启动阶段 + +容器启动时，会通过某种途径加载`Configuration MetaData`。除了代码方式比较直接外，在大部分情况下，容器需要依赖某些工具类，比如：`BeanDefinitionReader`，BeanDefinitionReader 会对加载的`Configuration MetaData`进行解析和分析，并将分析后的信息组装为相应的 BeanDefinition，最后把这些保存了 bean 定义的 BeanDefinition，注册到相应的 BeanDefinitionRegistry，这样容器的启动工作就完成了。这个阶段主要完成一些准备性工作，更侧重于 bean 对象管理信息的收集，当然一些验证性或者辅助性的工作也在这一阶段完成。 + +来看一个简单的例子吧，过往，所有的 bean 都定义在 XML 配置文件中，下面的代码将模拟 BeanFactory 如何从配置文件中加载 bean 的定义以及依赖关系： + +``` +// 通常为BeanDefinitionRegistry的实现类，这里以DeFaultListabeBeanFactory为例 +BeanDefinitionRegistry beanRegistry = new DefaultListableBeanFactory(); +// XmlBeanDefinitionReader实现了BeanDefinitionReader接口，用于解析XML文件 +XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReaderImpl(beanRegistry); +// 加载配置文件 +beanDefinitionReader.loadBeanDefinitions("classpath:spring-bean.xml"); + +// 从容器中获取bean实例 +BeanFactory container = (BeanFactory)beanRegistry; +Business business = (Business)container.getBean("beanName"); +``` + +②、Bean 的实例化阶段 + +经过第一阶段，所有 bean 定义都通过 BeanDefinition 的方式注册到 BeanDefinitionRegistry 中，当某个请求通过容器的 getBean 方法请求某个对象，或者因为依赖关系容器需要隐式的调用 getBean 时，就会触发第二阶段的活动：容器会首先检查所请求的对象之前是否已经实例化完成。如果没有，则会根据注册的 BeanDefinition 所提供的信息实例化被请求对象，并为其注入依赖。当该对象装配完毕后，容器会立即将其返回给请求方法使用。 + +BeanFactory 只是 Spring IoC 容器的一种实现，如果没有特殊指定，它采用采用延迟初始化策略：只有当访问容器中的某个对象时，才对该对象进行初始化和依赖注入操作。而在实际场景下，我们更多的使用另外一种类型的容器：`ApplicationContext`，它构建在 BeanFactory 之上，属于更高级的容器，除了具有 BeanFactory 的所有能力之外，还提供对事件监听机制以及国际化的支持等。它管理的 bean，在容器启动时全部完成初始化和依赖注入操作。 + +### 1.2、Spring 容器扩展机制 + +IoC 容器负责管理容器中所有 bean 的生命周期，而在 bean 生命周期的不同阶段，Spring 提供了不同的扩展点来改变 bean 的命运。在容器的启动阶段，`BeanFactoryPostProcessor`允许我们在容器实例化相应对象之前，对注册到容器的 BeanDefinition 所保存的信息做一些额外的操作，比如修改 bean 定义的某些属性或者增加其他信息等。 + +如果要自定义扩展类，通常需要实现`org.springframework.beans.factory.config.BeanFactoryPostProcessor`接口，与此同时，因为容器中可能有多个 BeanFactoryPostProcessor，可能还需要实现`org.springframework.core.Ordered`接口，以保证 BeanFactoryPostProcessor 按照顺序执行。Spring 提供了为数不多的 BeanFactoryPostProcessor 实现，我们以`PropertyPlaceholderConfigurer`来说明其大致的工作流程。 + +在 Spring 项目的 XML 配置文件中，经常可以看到许多配置项的值使用占位符，而将占位符所代表的值单独配置到独立的 properties 文件，这样可以将散落在不同 XML 文件中的配置集中管理，而且也方便运维根据不同的环境进行配置不同的值。这个非常实用的功能就是由 PropertyPlaceholderConfigurer 负责实现的。 + +根据前文，当 BeanFactory 在第一阶段加载完所有配置信息时，BeanFactory 中保存的对象的属性还是以占位符方式存在的，比如`${jdbc.mysql.url}`。当 PropertyPlaceholderConfigurer 作为 BeanFactoryPostProcessor 被应用时，它会使用 properties 配置文件中的值来替换相应的 BeanDefinition 中占位符所表示的属性值。当需要实例化 bean 时，bean 定义中的属性值就已经被替换成我们配置的值。当然其实现比上面描述的要复杂一些，这里仅说明其大致工作原理，更详细的实现可以参考其源码。 + +与之相似的，还有`BeanPostProcessor`，其存在于对象实例化阶段。跟 BeanFactoryPostProcessor 类似，它会处理容器内所有符合条件并且已经实例化后的对象。简单的对比，BeanFactoryPostProcessor 处理 bean 的定义，而 BeanPostProcessor 则处理 bean 完成实例化后的对象。BeanPostProcessor 定义了两个接口： + +``` +public interface BeanPostProcessor { + // 前置处理 + Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException; + // 后置处理 + Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException; +} +``` + +为了理解这两个方法执行的时机，简单的了解下 bean 的整个生命周期： + +`postProcessBeforeInitialization()`方法与`postProcessAfterInitialization()`分别对应图中前置处理和后置处理两个步骤将执行的方法。这两个方法中都传入了 bean 对象实例的引用，为扩展容器的对象实例化过程提供了很大便利，在这儿几乎可以对传入的实例执行任何操作。注解、AOP 等功能的实现均大量使用了`BeanPostProcessor`，比如有一个自定义注解，你完全可以实现 BeanPostProcessor 的接口，在其中判断 bean 对象的脑袋上是否有该注解，如果有，你可以对这个 bean 实例执行任何操作，想想是不是非常的简单？ + +再来看一个更常见的例子，在 Spring 中经常能够看到各种各样的 Aware 接口，其作用就是在对象实例化完成以后将 Aware 接口定义中规定的依赖注入到当前实例中。比如最常见的`ApplicationContextAware`接口，实现了这个接口的类都可以获取到一个 ApplicationContext 对象。当容器中每个对象的实例化过程走到 BeanPostProcessor 前置处理这一步时，容器会检测到之前注册到容器的 ApplicationContextAwareProcessor，然后就会调用其 postProcessBeforeInitialization()方法，检查并设置 Aware 相关依赖。看看代码吧，是不是很简单： + +``` +// 代码来自：org.springframework.context.support.ApplicationContextAwareProcessor +// 其postProcessBeforeInitialization方法调用了invokeAwareInterfaces方法 +private void invokeAwareInterfaces(Object bean) { + if (bean instanceof EnvironmentAware) { + ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment()); + } + if (bean instanceof ApplicationContextAware) { + ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext); + } + // ...... +} +``` + +最后总结一下，本小节内容和你一起回顾了 Spring 容器的部分核心内容，限于篇幅不能写更多，但理解这部分内容，足以让您轻松理解 Spring Boot 的启动原理，如果在后续的学习过程中遇到一些晦涩难懂的知识，再回过头来看看 Spring 的核心知识，也许有意想不到的效果。也许 Spring Boot 的中文资料很少，但 Spring 的中文资料和书籍有太多太多，总有东西能给你启发。 + +## 二、夯实基础：JavaConfig 与常见 Annotation + +### 2.1、JavaConfig + +我们知道`bean`是 Spring IOC 中非常核心的概念，Spring 容器负责 bean 的生命周期的管理。在最初，Spring 使用 XML 配置文件的方式来描述 bean 的定义以及相互间的依赖关系，但随着 Spring 的发展，越来越多的人对这种方式表示不满，因为 Spring 项目的所有业务类均以 bean 的形式配置在 XML 文件中，造成了大量的 XML 文件，使项目变得复杂且难以管理。 + +后来，基于纯 Java Annotation 依赖注入框架`Guice`出世，其性能明显优于采用 XML 方式的 Spring，甚至有部分人认为，`Guice`可以完全取代 Spring（`Guice`仅是一个轻量级 IOC 框架，取代 Spring 还差的挺远）。正是这样的危机感，促使 Spring 及社区推出并持续完善了`JavaConfig`子项目，它基于 Java 代码和 Annotation 注解来描述 bean 之间的依赖绑定关系。比如，下面是使用 XML 配置方式来描述 bean 的定义： + +``` + +``` + +而基于 JavaConfig 的配置形式是这样的： + +``` +@Configuration +public class MoonBookConfiguration { + + // 任何标志了@Bean的方法，其返回值将作为一个bean注册到Spring的IOC容器中 + // 方法名默认成为该bean定义的id + @Bean + public BookService bookService() { + return new BookServiceImpl(); + } +} +``` + +如果两个 bean 之间有依赖关系的话，在 XML 配置中应该是这样： + +``` + + + + + + + + + +``` + +而在 JavaConfig 中则是这样： + +``` +@Configuration +public class MoonBookConfiguration { + + // 如果一个bean依赖另一个bean，则直接调用对应JavaConfig类中依赖bean的创建方法即可 + // 这里直接调用dependencyService() + @Bean + public BookService bookService() { + return new BookServiceImpl(dependencyService()); + } + + @Bean + public OtherService otherService() { + return new OtherServiceImpl(dependencyService()); + } + + @Bean + public DependencyService dependencyService() { + return new DependencyServiceImpl(); + } +} +``` + +你可能注意到这个示例中，有两个 bean 都依赖于 dependencyService，也就是说当初始化 bookService 时会调用`dependencyService()`，在初始化 otherService 时也会调用`dependencyService()`，那么问题来了？这时候 IOC 容器中是有一个 dependencyService 实例还是两个？这个问题留着大家思考吧，这里不再赘述。 + +### 2.2、@ComponentScan + +`@ComponentScan`注解对应 XML 配置形式中的``元素，表示启用组件扫描，Spring 会自动扫描所有通过注解配置的 bean，然后将其注册到 IOC 容器中。我们可以通过`basePackages`等属性来指定`@ComponentScan`自动扫描的范围，如果不指定，默认从声明`@ComponentScan`所在类的`package`进行扫描。正因为如此，SpringBoot 的启动类都默认在`src/main/java`下。 + +### 2.3、@Import + +`@Import`注解用于导入配置类，举个简单的例子： + +``` +@Configuration +public class MoonBookConfiguration { + @Bean + public BookService bookService() { + return new BookServiceImpl(); + } +} +``` + +现在有另外一个配置类，比如：`MoonUserConfiguration`，这个配置类中有一个 bean 依赖于`MoonBookConfiguration`中的 bookService，如何将这两个 bean 组合在一起？借助`@Import`即可： + +``` +@Configuration +// 可以同时导入多个配置类，比如：@Import({A.class,B.class}) +@Import(MoonBookConfiguration.class) +public class MoonUserConfiguration { + @Bean + public UserService userService(BookService bookService) { + return new BookServiceImpl(bookService); + } +} +``` + +需要注意的是，在 4.2 之前，`@Import`注解只支持导入配置类，但是在 4.2 之后，它支持导入普通类，并将这个类作为一个 bean 的定义注册到 IOC 容器中。 + +### 2.4、@Conditional + +`@Conditional`注解表示在满足某种条件后才初始化一个 bean 或者启用某些配置。它一般用在由`@Component`、`@Service`、`@Configuration`等注解标识的类上面，或者由`@Bean`标记的方法上。如果一个`@Configuration`类标记了`@Conditional`，则该类中所有标识了`@Bean`的方法和`@Import`注解导入的相关类将遵从这些条件。 + +在 Spring 里可以很方便的编写你自己的条件类，所要做的就是实现`Condition`接口，并覆盖它的`matches()`方法。举个例子，下面的简单条件类表示只有在`Classpath`里存在`JdbcTemplate`类时才生效： + +``` +public class JdbcTemplateCondition implements Condition { + + @Override + public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) { + try { + conditionContext.getClassLoader().loadClass("org.springframework.jdbc.core.JdbcTemplate"); + return true; + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } + return false; + } +} +``` + +当你用 Java 来声明 bean 的时候，可以使用这个自定义条件类： + +``` +@Conditional(JdbcTemplateCondition.class) +@Service +public MyService service() { + ...... +} +``` + +这个例子中只有当`JdbcTemplateCondition`类的条件成立时才会创建 MyService 这个 bean。也就是说 MyService 这 bean 的创建条件是`classpath`里面包含`JdbcTemplate`，否则这个 bean 的声明就会被忽略掉。 + +`Spring Boot`定义了很多有趣的条件，并把他们运用到了配置类上，这些配置类构成了`Spring Boot`的自动配置的基础。`Spring Boot`运用条件化配置的方法是：定义多个特殊的条件化注解，并将它们用到配置类上。下面列出了`Spring Boot`提供的部分条件化注解： + +| 条件化注解 | 配置生效条件 | +| ------------------------------- | ------------------------------------------------------- | +| @ConditionalOnBean | 配置了某个特定 bean | +| @ConditionalOnMissingBean | 没有配置特定的 bean | +| @ConditionalOnClass | Classpath 里有指定的类 | +| @ConditionalOnMissingClass | Classpath 里没有指定的类 | +| @ConditionalOnExpression | 给定的 Spring Expression Language 表达式计算结果为 true | +| @ConditionalOnJava | Java 的版本匹配特定指或者一个范围值 | +| @ConditionalOnProperty | 指定的配置属性要有一个明确的值 | +| @ConditionalOnResource | Classpath 里有指定的资源 | +| @ConditionalOnWebApplication | 这是一个 Web 应用程序 | +| @ConditionalOnNotWebApplication | 这不是一个 Web 应用程序 | + +### 2.5、@ConfigurationProperties 与@EnableConfigurationProperties + +当某些属性的值需要配置的时候，我们一般会在`application.properties`文件中新建配置项，然后在 bean 中使用`@Value`注解来获取配置的值，比如下面配置数据源的代码。 + +``` +// jdbc config +jdbc.mysql.url=jdbc:mysql://localhost:3306/sampledb +jdbc.mysql.username=root +jdbc.mysql.password=123456 +...... + +// 配置数据源 +@Configuration +public class HikariDataSourceConfiguration { + + @Value("jdbc.mysql.url") + public String url; + @Value("jdbc.mysql.username") + public String user; + @Value("jdbc.mysql.password") + public String password; + + @Bean + public HikariDataSource dataSource() { + HikariConfig hikariConfig = new HikariConfig(); + hikariConfig.setJdbcUrl(url); + hikariConfig.setUsername(user); + hikariConfig.setPassword(password); + // 省略部分代码 + return new HikariDataSource(hikariConfig); + } +} +``` + +使用`@Value`注解注入的属性通常都比较简单，如果同一个配置在多个地方使用，也存在不方便维护的问题（考虑下，如果有几十个地方在使用某个配置，而现在你想改下名字，你改怎么做？）。对于更为复杂的配置，Spring Boot 提供了更优雅的实现方式，那就是`@ConfigurationProperties`注解。我们可以通过下面的方式来改写上面的代码： + +``` +@Component +// 还可以通过@PropertySource("classpath:jdbc.properties")来指定配置文件 +@ConfigurationProperties("jdbc.mysql") +// 前缀=jdbc.mysql，会在配置文件中寻找jdbc.mysql.*的配置项 +pulic class JdbcConfig { + public String url; + public String username; + public String password; +} + +@Configuration +public class HikariDataSourceConfiguration { + + @AutoWired + public JdbcConfig config; + + @Bean + public HikariDataSource dataSource() { + HikariConfig hikariConfig = new HikariConfig(); + hikariConfig.setJdbcUrl(config.url); + hikariConfig.setUsername(config.username); + hikariConfig.setPassword(config.password); + // 省略部分代码 + return new HikariDataSource(hikariConfig); + } +} +``` + +`@ConfigurationProperties`对于更为复杂的配置，处理起来也是得心应手，比如有如下配置文件： + +``` +#App +app.menus[0].title=Home +app.menus[0].name=Home +app.menus[0].path=/ +app.menus[1].title=Login +app.menus[1].name=Login +app.menus[1].path=/login + +app.compiler.timeout=5 +app.compiler.output-folder=/temp/ + +app.error=/error/ +``` + +可以定义如下配置类来接收这些属性 + +``` +@Component +@ConfigurationProperties("app") +public class AppProperties { + + public String error; + public List menus = new ArrayList<>(); + public Compiler compiler = new Compiler(); + + public static class Menu { + public String name; + public String path; + public String title; + } + + public static class Compiler { + public String timeout; + public String outputFolder; + } +} +``` + +`@EnableConfigurationProperties`注解表示对`@ConfigurationProperties`的内嵌支持，默认会将对应 Properties Class 作为 bean 注入的 IOC 容器中，即在相应的 Properties 类上不用加`@Component`注解。 + +## 三、削铁如泥：SpringFactoriesLoader 详解 + +JVM 提供了 3 种类加载器：`BootstrapClassLoader`、`ExtClassLoader`、`AppClassLoader`分别加载 Java 核心类库、扩展类库以及应用的类路径(`CLASSPATH`)下的类库。JVM 通过双亲委派模型进行类的加载，我们也可以通过继承`java.lang.classloader`实现自己的类加载器。 + +何为双亲委派模型？当一个类加载器收到类加载任务时，会先交给自己的父加载器去完成，因此最终加载任务都会传递到最顶层的 BootstrapClassLoader，只有当父加载器无法完成加载任务时，才会尝试自己来加载。 + +采用双亲委派模型的一个好处是保证使用不同类加载器最终得到的都是同一个对象，这样就可以保证 Java 核心库的类型安全，比如，加载位于 rt.jar 包中的`java.lang.Object`类，不管是哪个加载器加载这个类，最终都是委托给顶层的 BootstrapClassLoader 来加载的，这样就可以保证任何的类加载器最终得到的都是同样一个 Object 对象。查看 ClassLoader 的源码，对双亲委派模型会有更直观的认识： + +``` +protected Class loadClass(String name, boolean resolve) { + synchronized (getClassLoadingLock(name)) { + // 首先，检查该类是否已经被加载，如果从JVM缓存中找到该类，则直接返回 + Class c = findLoadedClass(name); + if (c == null) { + try { + // 遵循双亲委派的模型，首先会通过递归从父加载器开始找， + // 直到父类加载器是BootstrapClassLoader为止 + if (parent != null) { + c = parent.loadClass(name, false); + } else { + c = findBootstrapClassOrNull(name); + } + } catch (ClassNotFoundException e) {} + if (c == null) { + // 如果还找不到，尝试通过findClass方法去寻找 + // findClass是留给开发者自己实现的，也就是说 + // 自定义类加载器时，重写此方法即可 + c = findClass(name); + } + } + if (resolve) { + resolveClass(c); + } + return c; + } +} +``` + +但双亲委派模型并不能解决所有的类加载器问题，比如，Java 提供了很多服务提供者接口(`Service Provider Interface`，SPI)，允许第三方为这些接口提供实现。常见的 SPI 有 JDBC、JNDI、JAXP 等，这些 SPI 的接口由核心类库提供，却由第三方实现，这样就存在一个问题：SPI 的接口是 Java 核心库的一部分，是由 BootstrapClassLoader 加载的；SPI 实现的 Java 类一般是由 AppClassLoader 来加载的。BootstrapClassLoader 是无法找到 SPI 的实现类的，因为它只加载 Java 的核心库。它也不能代理给 AppClassLoader，因为它是最顶层的类加载器。也就是说，双亲委派模型并不能解决这个问题。 + +线程上下文类加载器(`ContextClassLoader`)正好解决了这个问题。从名称上看，可能会误解为它是一种新的类加载器，实际上，它仅仅是 Thread 类的一个变量而已，可以通过`setContextClassLoader(ClassLoader cl)`和`getContextClassLoader()`来设置和获取该对象。如果不做任何的设置，Java 应用的线程的上下文类加载器默认就是 AppClassLoader。在核心类库使用 SPI 接口时，传递的类加载器使用线程上下文类加载器，就可以成功的加载到 SPI 实现的类。线程上下文类加载器在很多 SPI 的实现中都会用到。但在 JDBC 中，你可能会看到一种更直接的实现方式，比如，JDBC 驱动管理`java.sql.Driver`中的`loadInitialDrivers()`方法中，你可以直接看到 JDK 是如何加载驱动的： + +``` +for (String aDriver : driversList) { + try { + // 直接使用AppClassLoader + Class.forName(aDriver, true, ClassLoader.getSystemClassLoader()); + } catch (Exception ex) { + println("DriverManager.Initialize: load failed: " + ex); + } +} +``` + +其实讲解线程上下文类加载器，最主要是让大家在看到`Thread.currentThread().getClassLoader()`和`Thread.currentThread().getContextClassLoader()`时不会一脸懵逼，这两者除了在许多底层框架中取得的 ClassLoader 可能会有所不同外，其他大多数业务场景下都是一样的，大家只要知道它是为了解决什么问题而存在的即可。 + +类加载器除了加载 class 外，还有一个非常重要功能，就是加载资源，它可以从 jar 包中读取任何资源文件，比如，`ClassLoader.getResources(String name)`方法就是用于读取 jar 包中的资源文件，其代码如下： + +``` +public Enumeration getResources(String name) throws IOException { + Enumeration[] tmp = (Enumeration[]) new Enumeration[2]; + if (parent != null) { + tmp[0] = parent.getResources(name); + } else { + tmp[0] = getBootstrapResources(name); + } + tmp[1] = findResources(name); + return new CompoundEnumeration<>(tmp); +} +``` + +是不是觉得有点眼熟，不错，它的逻辑其实跟类加载的逻辑是一样的，首先判断父类加载器是否为空，不为空则委托父类加载器执行资源查找任务，直到 BootstrapClassLoader，最后才轮到自己查找。而不同的类加载器负责扫描不同路径下的 jar 包，就如同加载 class 一样，最后会扫描所有的 jar 包，找到符合条件的资源文件。 + +类加载器的`findResources(name)`方法会遍历其负责加载的所有 jar 包，找到 jar 包中名称为 name 的资源文件，这里的资源可以是任何文件，甚至是.class 文件，比如下面的示例，用于查找 Array.class 文件： + +``` +// 寻找Array.class文件 +public static void main(String[] args) throws Exception{ + // Array.class的完整路径 + String name = "java/sql/Array.class"; + Enumeration urls = Thread.currentThread().getContextClassLoader().getResources(name); + while (urls.hasMoreElements()) { + URL url = urls.nextElement(); + System.out.println(url.toString()); + } +} +``` + +运行后可以得到如下结果： + +``` +$JAVA_HOME/jre/lib/rt.jar!/java/sql/Array.class +``` + +根据资源文件的 URL，可以构造相应的文件来读取资源内容。 + +看到这里，你可能会感到挺奇怪的，你不是要详解`SpringFactoriesLoader`吗？上来讲了一堆 ClassLoader 是几个意思？看下它的源码你就知道了： + +``` +public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories"; +// spring.factories文件的格式为：key=value1,value2,value3 +// 从所有的jar包中找到META-INF/spring.factories文件 +// 然后从文件中解析出key=factoryClass类名称的所有value值 +public static List loadFactoryNames(Class factoryClass, ClassLoader classLoader) { + String factoryClassName = factoryClass.getName(); + // 取得资源文件的URL + Enumeration urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) : ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION)); + List result = new ArrayList(); + // 遍历所有的URL + while (urls.hasMoreElements()) { + URL url = urls.nextElement(); + // 根据资源文件URL解析properties文件 + Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url)); + String factoryClassNames = properties.getProperty(factoryClassName); + // 组装数据，并返回 + result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames))); + } + return result; +} +``` + +有了前面关于 ClassLoader 的知识，再来理解这段代码，是不是感觉豁然开朗：从`CLASSPATH`下的每个 Jar 包中搜寻所有`META-INF/spring.factories`配置文件，然后将解析 properties 文件，找到指定名称的配置后返回。需要注意的是，其实这里不仅仅是会去 ClassPath 路径下查找，会扫描所有路径下的 Jar 包，只不过这个文件只会在 Classpath 下的 jar 包中。来简单看下`spring.factories`文件的内容吧： + +``` +// 来自 org.springframework.boot.autoconfigure下的META-INF/spring.factories +// EnableAutoConfiguration后文会讲到，它用于开启Spring Boot自动配置功能 +org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ +org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\ +org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\ +org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration\ +``` + +执行`loadFactoryNames(EnableAutoConfiguration.class, classLoader)`后，得到对应的一组`@Configuration`类， +我们就可以通过反射实例化这些类然后注入到 IOC 容器中，最后容器里就有了一系列标注了`@Configuration`的 JavaConfig 形式的配置类。 + +这就是`SpringFactoriesLoader`，它本质上属于 Spring 框架私有的一种扩展方案，类似于 SPI，Spring Boot 在 Spring 基础上的很多核心功能都是基于此，希望大家可以理解。 + +## 四、另一件武器：Spring 容器的事件监听机制 + +过去，事件监听机制多用于图形界面编程，比如：**点击**按钮、在文本框**输入**内容等操作被称为事件，而当事件触发时，应用程序作出一定的响应则表示应用监听了这个事件，而在服务器端，事件的监听机制更多的用于异步通知以及监控和异常处理。Java 提供了实现事件监听机制的两个基础类：自定义事件类型扩展自`java.util.EventObject`、事件的监听器扩展自`java.util.EventListener`。来看一个简单的实例：简单的监控一个方法的耗时。 + +首先定义事件类型，通常的做法是扩展 EventObject，随着事件的发生，相应的状态通常都封装在此类中： + +``` +public class MethodMonitorEvent extends EventObject { + // 时间戳，用于记录方法开始执行的时间 + public long timestamp; + + public MethodMonitorEvent(Object source) { + super(source); + } +} +``` + +事件发布之后，相应的监听器即可对该类型的事件进行处理，我们可以在方法开始执行之前发布一个 begin 事件，在方法执行结束之后发布一个 end 事件，相应地，事件监听器需要提供方法对这两种情况下接收到的事件进行处理： + +``` +// 1、定义事件监听接口 +public interface MethodMonitorEventListener extends EventListener { + // 处理方法执行之前发布的事件 + public void onMethodBegin(MethodMonitorEvent event); + // 处理方法结束时发布的事件 + public void onMethodEnd(MethodMonitorEvent event); +} +// 2、事件监听接口的实现：如何处理 +public class AbstractMethodMonitorEventListener implements MethodMonitorEventListener { + + @Override + public void onMethodBegin(MethodMonitorEvent event) { + // 记录方法开始执行时的时间 + event.timestamp = System.currentTimeMillis(); + } + + @Override + public void onMethodEnd(MethodMonitorEvent event) { + // 计算方法耗时 + long duration = System.currentTimeMillis() - event.timestamp; + System.out.println("耗时：" + duration); + } +} +``` + +事件监听器接口针对不同的事件发布实际提供相应的处理方法定义，最重要的是，其方法只接收 MethodMonitorEvent 参数，说明这个监听器类只负责监听器对应的事件并进行处理。有了事件和监听器，剩下的就是发布事件，然后让相应的监听器监听并处理。通常情况，我们会有一个事件发布者，它本身作为事件源，在合适的时机，将相应的事件发布给对应的事件监听器： + +``` +public class MethodMonitorEventPublisher { + + private List listeners = new ArrayList(); + + public void methodMonitor() { + MethodMonitorEvent eventObject = new MethodMonitorEvent(this); + publishEvent("begin",eventObject); + // 模拟方法执行：休眠5秒钟 + TimeUnit.SECONDS.sleep(5); + publishEvent("end",eventObject); + + } + + private void publishEvent(String status,MethodMonitorEvent event) { + // 避免在事件处理期间，监听器被移除，这里为了安全做一个复制操作 + List copyListeners = ➥ new ArrayList(listeners); + for (MethodMonitorEventListener listener : copyListeners) { + if ("begin".equals(status)) { + listener.onMethodBegin(event); + } else { + listener.onMethodEnd(event); + } + } + } + + public static void main(String[] args) { + MethodMonitorEventPublisher publisher = new MethodMonitorEventPublisher(); + publisher.addEventListener(new AbstractMethodMonitorEventListener()); + publisher.methodMonitor(); + } + // 省略实现 + public void addEventListener(MethodMonitorEventListener listener) {} + public void removeEventListener(MethodMonitorEventListener listener) {} + public void removeAllListeners() {} +``` + +对于事件发布者（事件源）通常需要关注两点： + +1. 在合适的时机发布事件。此例中的 methodMonitor()方法是事件发布的源头，其在方法执行之前和结束之后两个时间点发布 MethodMonitorEvent 事件，每个时间点发布的事件都会传给相应的监听器进行处理。在具体实现时需要注意的是，事件发布是顺序执行，为了不影响处理性能，事件监听器的处理逻辑应尽量简单。 +2. 事件监听器的管理。publisher 类中提供了事件监听器的注册与移除方法，这样客户端可以根据实际情况决定是否需要注册新的监听器或者移除某个监听器。如果这里没有提供 remove 方法，那么注册的监听器示例将一直被 MethodMonitorEventPublisher 引用，即使已经废弃不用了，也依然在发布者的监听器列表中，这会导致隐性的内存泄漏。 + +#### Spring 容器内的事件监听机制 + +Spring 的 ApplicationContext 容器内部中的所有事件类型均继承自`org.springframework.context.ApplicationEvent`，容器中的所有监听器都实现`org.springframework.context.ApplicationListener`接口，并且以 bean 的形式注册在容器中。一旦在容器内发布 ApplicationEvent 及其子类型的事件，注册到容器的 ApplicationListener 就会对这些事件进行处理。 + +你应该已经猜到是怎么回事了。 + +ApplicationEvent 继承自 EventObject，Spring 提供了一些默认的实现，比如：`ContextClosedEvent`表示容器在即将关闭时发布的事件类型，`ContextRefreshedEvent`表示容器在初始化或者刷新的时候发布的事件类型...... + +容器内部使用 ApplicationListener 作为事件监听器接口定义，它继承自 EventListener。ApplicationContext 容器在启动时，会自动识别并加载 EventListener 类型的 bean，一旦容器内有事件发布，将通知这些注册到容器的 EventListener。 + +ApplicationContext 接口继承了 ApplicationEventPublisher 接口，该接口提供了`void publishEvent(ApplicationEvent event)`方法定义，不难看出，ApplicationContext 容器担当的就是事件发布者的角色。如果有兴趣可以查看`AbstractApplicationContext.publishEvent(ApplicationEvent event)`方法的源码：ApplicationContext 将事件的发布以及监听器的管理工作委托给`ApplicationEventMulticaster`接口的实现类。在容器启动时，会检查容器内是否存在名为 applicationEventMulticaster 的 ApplicationEventMulticaster 对象实例。如果有就使用其提供的实现，没有就默认初始化一个 SimpleApplicationEventMulticaster 作为实现。 + +最后，如果我们业务需要在容器内部发布事件，只需要为其注入 ApplicationEventPublisher 依赖即可：实现 ApplicationEventPublisherAware 接口或者 ApplicationContextAware 接口(Aware 接口相关内容请回顾上文)。 + +## 五、出神入化：揭秘自动配置原理 + +典型的 Spring Boot 应用的启动类一般均位于`src/main/java`根路径下，比如`MoonApplication`类： + +``` +@SpringBootApplication +public class MoonApplication { + + public static void main(String[] args) { + SpringApplication.run(MoonApplication.class, args); + } +} +``` + +其中`@SpringBootApplication`开启组件扫描和自动配置，而`SpringApplication.run`则负责启动引导应用程序。`@SpringBootApplication`是一个复合`Annotation`，它将三个有用的注解组合在一起： + +``` +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.RUNTIME) +@Documented +@Inherited +@SpringBootConfiguration +@EnableAutoConfiguration +@ComponentScan(excludeFilters = { + @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), + @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) }) +public @interface SpringBootApplication { + // ...... +} +``` + +`@SpringBootConfiguration`就是`@Configuration`，它是 Spring 框架的注解，标明该类是一个`JavaConfig`配置类。而`@ComponentScan`启用组件扫描，前文已经详细讲解过，这里着重关注`@EnableAutoConfiguration`。 + +`@EnableAutoConfiguration`注解表示开启 Spring Boot 自动配置功能，Spring Boot 会根据应用的依赖、自定义的 bean、classpath 下有没有某个类等等因素来猜测你需要的 bean，然后注册到 IOC 容器中。那`@EnableAutoConfiguration`是如何推算出你的需求？首先看下它的定义： + +``` +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.RUNTIME) +@Documented +@Inherited +@AutoConfigurationPackage +@Import(EnableAutoConfigurationImportSelector.class) +public @interface EnableAutoConfiguration { + // ...... +} +``` + +你的关注点应该在`@Import(EnableAutoConfigurationImportSelector.class)`上了，前文说过，`@Import`注解用于导入类，并将这个类作为一个 bean 的定义注册到容器中，这里它将把`EnableAutoConfigurationImportSelector`作为 bean 注入到容器中，而这个类会将所有符合条件的@Configuration 配置都加载到容器中，看看它的代码： + +``` +public String[] selectImports(AnnotationMetadata annotationMetadata) { + // 省略了大部分代码，保留一句核心代码 + // 注意：SpringBoot最近版本中，这句代码被封装在一个单独的方法中 + // SpringFactoriesLoader相关知识请参考前文 + List factories = new ArrayList(new LinkedHashSet( + SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class, this.beanClassLoader))); +} +``` + +这个类会扫描所有的 jar 包，将所有符合条件的@Configuration 配置类注入的容器中，何为符合条件，看看`META-INF/spring.factories`的文件内容： + +``` +// 来自 org.springframework.boot.autoconfigure下的META-INF/spring.factories +// 配置的key = EnableAutoConfiguration，与代码中一致 +org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ +org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\ +org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\ +org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration\ +..... +``` + +以`DataSourceAutoConfiguration`为例，看看 Spring Boot 是如何自动配置的： + +``` +@Configuration +@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class }) +@EnableConfigurationProperties(DataSourceProperties.class) +@Import({ Registrar.class, DataSourcePoolMetadataProvidersConfiguration.class }) +public class DataSourceAutoConfiguration { +} +``` + +分别说一说： + +- `@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })`：当 Classpath 中存在 DataSource 或者 EmbeddedDatabaseType 类时才启用这个配置，否则这个配置将被忽略。 +- `@EnableConfigurationProperties(DataSourceProperties.class)`：将 DataSource 的默认配置类注入到 IOC 容器中，DataSourceproperties 定义为： + +``` +// 提供对datasource配置信息的支持，所有的配置前缀为：spring.datasource +@ConfigurationProperties(prefix = "spring.datasource") +public class DataSourceProperties { + private ClassLoader classLoader; + private Environment environment; + private String name = "testdb"; + ...... +} +``` + +- `@Import({ Registrar.class, DataSourcePoolMetadataProvidersConfiguration.class })`：导入其他额外的配置，就以`DataSourcePoolMetadataProvidersConfiguration`为例吧。 + +``` +@Configuration +public class DataSourcePoolMetadataProvidersConfiguration { + + @Configuration + @ConditionalOnClass(org.apache.tomcat.jdbc.pool.DataSource.class) + static class TomcatDataSourcePoolMetadataProviderConfiguration { + @Bean + public DataSourcePoolMetadataProvider tomcatPoolDataSourceMetadataProvider() { + ..... + } + } + ...... +} +``` + +DataSourcePoolMetadataProvidersConfiguration 是数据库连接池提供者的一个配置类，即 Classpath 中存在`org.apache.tomcat.jdbc.pool.DataSource.class`，则使用 tomcat-jdbc 连接池，如果 Classpath 中存在`HikariDataSource.class`则使用 Hikari 连接池。 + +这里仅描述了 DataSourceAutoConfiguration 的冰山一角，但足以说明 Spring Boot 如何利用条件话配置来实现自动配置的。回顾一下，`@EnableAutoConfiguration`中导入了 EnableAutoConfigurationImportSelector 类，而这个类的`selectImports()`通过 SpringFactoriesLoader 得到了大量的配置类，而每一个配置类则根据条件化配置来做出决策，以实现自动配置。 + +整个流程很清晰，但漏了一个大问题：`EnableAutoConfigurationImportSelector.selectImports()`是何时执行的？其实这个方法会在容器启动过程中执行：`AbstractApplicationContext.refresh()`，更多的细节在下一小节中说明。 + +## 六、启动引导：Spring Boot 应用启动的秘密 + +### 6.1 SpringApplication 初始化 + +SpringBoot 整个启动流程分为两个步骤：初始化一个 SpringApplication 对象、执行该对象的 run 方法。看下 SpringApplication 的初始化流程，SpringApplication 的构造方法中调用 initialize(Object[] sources)方法，其代码如下： + +``` +private void initialize(Object[] sources) { + if (sources != null && sources.length > 0) { + this.sources.addAll(Arrays.asList(sources)); + } + // 判断是否是Web项目 + this.webEnvironment = deduceWebEnvironment(); + setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class)); + setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class)); + // 找到入口类 + this.mainApplicationClass = deduceMainApplicationClass(); +} +``` + +初始化流程中最重要的就是通过 SpringFactoriesLoader 找到`spring.factories`文件中配置的`ApplicationContextInitializer`和`ApplicationListener`两个接口的实现类名称，以便后期构造相应的实例。`ApplicationContextInitializer`的主要目的是在`ConfigurableApplicationContext`做 refresh 之前，对 ConfigurableApplicationContext 实例做进一步的设置或处理。ConfigurableApplicationContext 继承自 ApplicationContext，其主要提供了对 ApplicationContext 进行设置的能力。 + +实现一个 ApplicationContextInitializer 非常简单，因为它只有一个方法，但大多数情况下我们没有必要自定义一个 ApplicationContextInitializer，即便是 Spring Boot 框架，它默认也只是注册了两个实现，毕竟 Spring 的容器已经非常成熟和稳定，你没有必要来改变它。 + +而`ApplicationListener`的目的就没什么好说的了，它是 Spring 框架对 Java 事件监听机制的一种框架实现，具体内容在前文 Spring 事件监听机制这个小节有详细讲解。这里主要说说，如果你想为 Spring Boot 应用添加监听器，该如何实现？ + +Spring Boot 提供两种方式来添加自定义监听器： + +- 通过`SpringApplication.addListeners(ApplicationListener... listeners)`或者`SpringApplication.setListeners(Collection> listeners)`两个方法来添加一个或者多个自定义监听器 +- 既然 SpringApplication 的初始化流程中已经从`spring.factories`中获取到`ApplicationListener`的实现类，那么我们直接在自己的 jar 包的`META-INF/spring.factories`文件中新增配置即可： + +``` +org.springframework.context.ApplicationListener=\ +cn.moondev.listeners.xxxxListener\ +``` + +关于 SpringApplication 的初始化，我们就说这么多。 + +### 6.2 Spring Boot 启动流程 + +Spring Boot 应用的整个启动流程都封装在 SpringApplication.run 方法中，其整个流程真的是太长太长了，但本质上就是在 Spring 容器启动的基础上做了大量的扩展，按照这个思路来看看源码： + +``` +public ConfigurableApplicationContext run(String... args) { + StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + ConfigurableApplicationContext context = null; + FailureAnalyzers analyzers = null; + configureHeadlessProperty(); + // ① + SpringApplicationRunListeners listeners = getRunListeners(args); + listeners.starting(); + try { + // ② + ApplicationArguments applicationArguments = new DefaultApplicationArguments(args); + ConfigurableEnvironment environment = prepareEnvironment(listeners,applicationArguments); + // ③ + Banner printedBanner = printBanner(environment); + // ④ + context = createApplicationContext(); + // ⑤ + analyzers = new FailureAnalyzers(context); + // ⑥ + prepareContext(context, environment, listeners, applicationArguments,printedBanner); + // ⑦ + refreshContext(context); + // ⑧ + afterRefresh(context, applicationArguments); + // ⑨ + listeners.finished(context, null); + stopWatch.stop(); + return context; + } + catch (Throwable ex) { + handleRunFailure(context, listeners, analyzers, ex); + throw new IllegalStateException(ex); + } + } +``` + +① 通过 SpringFactoriesLoader 查找并加载所有的`SpringApplicationRunListeners`，通过调用 starting()方法通知所有的 SpringApplicationRunListeners：应用开始启动了。SpringApplicationRunListeners 其本质上就是一个事件发布者，它在 SpringBoot 应用启动的不同时间点发布不同应用事件类型(ApplicationEvent)，如果有哪些事件监听者(ApplicationListener)对这些事件感兴趣，则可以接收并且处理。还记得初始化流程中，SpringApplication 加载了一系列 ApplicationListener 吗？这个启动流程中没有发现有发布事件的代码，其实都已经在 SpringApplicationRunListeners 这儿实现了。 + +简单的分析一下其实现流程，首先看下 SpringApplicationRunListener 的源码： + +``` +public interface SpringApplicationRunListener { + + // 运行run方法时立即调用此方法，可以用户非常早期的初始化工作 + void starting(); + + // Environment准备好后，并且ApplicationContext创建之前调用 + void environmentPrepared(ConfigurableEnvironment environment); + + // ApplicationContext创建好后立即调用 + void contextPrepared(ConfigurableApplicationContext context); + + // ApplicationContext加载完成，在refresh之前调用 + void contextLoaded(ConfigurableApplicationContext context); + + // 当run方法结束之前调用 + void finished(ConfigurableApplicationContext context, Throwable exception); + +} +``` + +SpringApplicationRunListener 只有一个实现类：`EventPublishingRunListener`。① 处的代码只会获取到一个 EventPublishingRunListener 的实例，我们来看看 starting()方法的内容： + +``` +public void starting() { + // 发布一个ApplicationStartedEvent + this.initialMulticaster.multicastEvent(new ApplicationStartedEvent(this.application, this.args)); +} +``` + +顺着这个逻辑，你可以在 ② 处的`prepareEnvironment()`方法的源码中找到`listeners.environmentPrepared(environment);`即 SpringApplicationRunListener 接口的第二个方法，那不出你所料，`environmentPrepared()`又发布了另外一个事件`ApplicationEnvironmentPreparedEvent`。接下来会发生什么，就不用我多说了吧。 + +② 创建并配置当前应用将要使用的`Environment`，Environment 用于描述应用程序当前的运行环境，其抽象了两个方面的内容：配置文件(profile)和属性(properties)，开发经验丰富的同学对这两个东西一定不会陌生：不同的环境(eg：生产环境、预发布环境)可以使用不同的配置文件，而属性则可以从配置文件、环境变量、命令行参数等来源获取。因此，当 Environment 准备好后，在整个应用的任何时候，都可以从 Environment 中获取资源。 + +总结起来，② 处的两句代码，主要完成以下几件事： + +- 判断 Environment 是否存在，不存在就创建（如果是 web 项目就创建`StandardServletEnvironment`，否则创建`StandardEnvironment`） +- 配置 Environment：配置 profile 以及 properties +- 调用 SpringApplicationRunListener 的`environmentPrepared()`方法，通知事件监听者：应用的 Environment 已经准备好 + +③、SpringBoot 应用在启动时会输出这样的东西： + +``` + . ____ _ __ _ _ + /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ +( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ + \\/ ___)| |_)| | | | | || (_| | ) ) ) ) + ' |____| .__|_| |_|_| |_\__, | / / / / + =========|_|==============|___/=/_/_/_/ + :: Spring Boot :: (v1.5.6.RELEASE) +``` + +如果想把这个东西改成自己的涂鸦，你可以研究以下 Banner 的实现，这个任务就留给你们吧。 + +④、根据是否是 web 项目，来创建不同的 ApplicationContext 容器。 + +⑤、创建一系列`FailureAnalyzer`，创建流程依然是通过 SpringFactoriesLoader 获取到所有实现 FailureAnalyzer 接口的 class，然后在创建对应的实例。FailureAnalyzer 用于分析故障并提供相关诊断信息。 + +⑥、初始化 ApplicationContext，主要完成以下工作： + +- 将准备好的 Environment 设置给 ApplicationContext +- 遍历调用所有的 ApplicationContextInitializer 的`initialize()`方法来对已经创建好的 ApplicationContext 进行进一步的处理 +- 调用 SpringApplicationRunListener 的`contextPrepared()`方法，通知所有的监听者：ApplicationContext 已经准备完毕 +- 将所有的 bean 加载到容器中 +- 调用 SpringApplicationRunListener 的`contextLoaded()`方法，通知所有的监听者：ApplicationContext 已经装载完毕 + +⑦、调用 ApplicationContext 的`refresh()`方法，完成 IoC 容器可用的最后一道工序。从名字上理解为刷新容器，那何为刷新？就是插手容器的启动，联系一下第一小节的内容。那如何刷新呢？且看下面代码： + +``` +// 摘自refresh()方法中一句代码 +invokeBeanFactoryPostProcessors(beanFactory); +``` + +看看这个方法的实现： + +``` +protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { + PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors()); + ...... +} +``` + +获取到所有的`BeanFactoryPostProcessor`来对容器做一些额外的操作。BeanFactoryPostProcessor 允许我们在容器实例化相应对象之前，对注册到容器的 BeanDefinition 所保存的信息做一些额外的操作。这里的 getBeanFactoryPostProcessors()方法可以获取到 3 个 Processor： + +``` +ConfigurationWarningsApplicationContextInitializer$ConfigurationWarningsPostProcessor +SharedMetadataReaderFactoryContextInitializer$CachingMetadataReaderFactoryPostProcessor +ConfigFileApplicationListener$PropertySourceOrderingPostProcessor +``` + +不是有那么多 BeanFactoryPostProcessor 的实现类，为什么这儿只有这 3 个？因为在初始化流程获取到的各种 ApplicationContextInitializer 和 ApplicationListener 中，只有上文 3 个做了类似于如下操作： + +``` +public void initialize(ConfigurableApplicationContext context) { + context.addBeanFactoryPostProcessor(new ConfigurationWarningsPostProcessor(getChecks())); +} +``` + +然后你就可以进入到`PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()`方法了，这个方法除了会遍历上面的 3 个 BeanFactoryPostProcessor 处理外，还会获取类型为`BeanDefinitionRegistryPostProcessor`的 bean：`org.springframework.context.annotation.internalConfigurationAnnotationProcessor`，对应的 Class 为`ConfigurationClassPostProcessor`。`ConfigurationClassPostProcessor`用于解析处理各种注解，包括：@Configuration、@ComponentScan、@Import、@PropertySource、@ImportResource、@Bean。当处理`@import`注解的时候，就会调用自动配置这一小节中的`EnableAutoConfigurationImportSelector.selectImports()`来完成自动配置功能。其他的这里不再多讲，如果你有兴趣，可以查阅参考资料 6。 + +⑧、查找当前 context 中是否注册有 CommandLineRunner 和 ApplicationRunner，如果有则遍历执行它们。 + +⑨、执行所有 SpringApplicationRunListener 的 finished()方法。 + +这就是 Spring Boot 的整个启动流程，其核心就是在 Spring 容器初始化并启动的基础上加入各种扩展点，这些扩展点包括：ApplicationContextInitializer、ApplicationListener 以及各种 BeanFactoryPostProcessor 等等。你对整个流程的细节不必太过关注，甚至没弄明白也没有关系，你只要理解这些扩展点是在何时如何工作的，能让它们为你所用即可。 + +整个启动流程确实非常复杂，可以查询参考资料中的部分章节和内容，对照着源码，多看看，我想最终你都能弄清楚的。言而总之，Spring 才是核心，理解清楚 Spring 容器的启动流程，那 Spring Boot 启动流程就不在话下了。 + +## 参考资料 + +[1][王福强著；springboot 揭秘：快速构建微服务体系; 机械工业出版社, 2016](https://link.jianshu.com/?t=http%3A%2F%2Funion-click.jd.com%2Fjdc%3Fd%3D4jESQ9) +[2][王福强著；spring 揭秘; 人民邮件出版社, 2009](https://link.jianshu.com/?t=http%3A%2F%2Funion-click.jd.com%2Fjdc%3Fd%3DyzfgeF) +[3][craig walls 著；丁雪丰译；spring boot 实战；中国工信出版集团人民邮电出版社，2016](https://link.jianshu.com/?t=http%3A%2F%2Funion-click.jd.com%2Fjdc%3Fd%3DAQ6oHO) +[4][深入探讨 java 类加载器](https://link.jianshu.com/?t=https%3A%2F%2Fwww.ibm.com%2Fdeveloperworks%2Fcn%2Fjava%2Fj-lo-classloader%2F) : [www.ibm.com/developerwo…](https://link.jianshu.com/?t=https%3A%2F%2Fwww.ibm.com%2Fdeveloperworks%2Fcn%2Fjava%2Fj-lo-classloader%2F) +[5][spring boot 实战：自动配置原理分析](https://link.jianshu.com/?t=http%3A%2F%2Fblog.csdn.net%2Fliaokailin%2Farticle%2Fdetails%2F49559951) : [blog.csdn.net/liaokailin/…](https://link.jianshu.com/?t=http%3A%2F%2Fblog.csdn.net%2Fliaokailin%2Farticle%2Fdetails%2F49559951) +[6][spring boot实战：spring boot bean加载源码分析](https://link.jianshu.com/?t=http%3A%2F%2Fblog.csdn.net%2Fliaokailin%2Farticle%2Fdetails%2F49107209)： [blog.csdn.net/liaokailin/…](https://link.jianshu.com/?t=http%3A%2F%2Fblog.csdn.net%2Fliaokailin%2Farticle%2Fdetails%2F49107209) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/00.Spring\347\273\274\345\220\210/22.SpringBoot\345\237\272\346\234\254\345\216\237\347\220\206.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/00.Spring\347\273\274\345\220\210/22.SpringBoot\345\237\272\346\234\254\345\216\237\347\220\206.md" new file mode 100644 index 00000000..a7ee34ae --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/00.Spring\347\273\274\345\220\210/22.SpringBoot\345\237\272\346\234\254\345\216\237\347\220\206.md" @@ -0,0 +1,286 @@ +--- +title: SpringBoot 基本原理 +date: 2020-08-12 07:01:26 +order: 22 +categories: + - Java + - 框架 + - Spring + - Spring综合 +tags: + - Java + - 框架 + - Spring + - SpringBoot +permalink: /pages/dbf521/ +--- + +# SpringBoot 基本原理 + +SpringBoot 为我们做的自动配置，确实方便快捷，但一直搞不明白它的内部启动原理，这次就来一步步解开 SpringBoot 的神秘面纱，让它不再神秘。 + +![img](https:////upload-images.jianshu.io/upload_images/6430208-ebcb376f96103703.png?imageMogr2/auto-orient/strip|imageView2/2/w/1200/format/webp) + +--- + +```java +@SpringBootApplication +public class Application { + public static void main(String[] args) { + SpringApplication.run(Application.class, args); + } +} +``` + +从上面代码可以看出，**Annotation 定义（@SpringBootApplication）和类定义（SpringApplication.run）**最为耀眼，所以要揭开 SpringBoot 的神秘面纱，我们要从这两位开始就可以了。 + +## SpringBootApplication 背后的秘密 + +```kotlin +@Target(ElementType.TYPE) // 注解的适用范围，其中TYPE用于描述类、接口（包括包注解类型）或enum声明 +@Retention(RetentionPolicy.RUNTIME) // 注解的生命周期，保留到class文件中（三个生命周期） +@Documented // 表明这个注解应该被javadoc记录 +@Inherited // 子类可以继承该注解 +@SpringBootConfiguration // 继承了Configuration，表示当前是注解类 +@EnableAutoConfiguration // 开启springboot的注解功能，springboot的四大神器之一，其借助@import的帮助 +@ComponentScan(excludeFilters = { // 扫描路径设置（具体使用待确认） + @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), + @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) }) +public @interface SpringBootApplication { +... +} +``` + +虽然定义使用了多个 Annotation 进行了原信息标注，但实际上重要的只有三个 Annotation： + +**@Configuration**（@SpringBootConfiguration 点开查看发现里面还是应用了@Configuration） +**@EnableAutoConfiguration +@ComponentScan** +所以，如果我们使用如下的 SpringBoot 启动类，整个 SpringBoot 应用依然可以与之前的启动类功能对等： + +```java +@Configuration +@EnableAutoConfiguration +@ComponentScan +public class Application { + public static void main(String[] args) { + SpringApplication.run(Application.class, args); + } +} +``` + +每次写这 3 个比较累，所以写一个@SpringBootApplication 方便点。接下来分别介绍这 3 个 Annotation。 + +## @Configuration + +这里的@Configuration 对我们来说不陌生，**它就是 JavaConfig 形式的 Spring Ioc 容器的配置类使用的那个@Configuration**，SpringBoot 社区推荐使用基于 JavaConfig 的配置形式，所以，这里的启动类标注了@Configuration 之后，本身其实也是一个 IoC 容器的配置类。 +举几个简单例子回顾下，XML 跟 config 配置方式的区别： + +表达形式层面 +基于 XML 配置的方式是这样： + +```xml + + + + +``` + +而基于 JavaConfig 的配置方式是这样： + +```java +@Configuration +public class MockConfiguration{ + //bean定义 +} +``` + +**任何一个标注了@Configuration 的 Java 类定义都是一个 JavaConfig 配置类。** + +注册 bean 定义层面 +基于 XML 的配置形式是这样： + +```csharp + + ... + +``` + +而基于 JavaConfig 的配置形式是这样的： + +```java +@Configuration +public class MockConfiguration{ + @Bean + public MockService mockService(){ + return new MockServiceImpl(); + } +} +``` + +**任何一个标注了@Bean 的方法，其返回值将作为一个 bean 定义注册到 Spring 的 IoC 容器，方法名将默认成该 bean 定义的 id。** + +表达依赖注入关系层面 +为了表达 bean 与 bean 之间的依赖关系，在 XML 形式中一般是这样： + +```jsx + + + + + +``` + +而基于 JavaConfig 的配置形式是这样的： + +```java +@Configuration +public class MockConfiguration{ + @Bean + public MockService mockService(){ + return new MockServiceImpl(dependencyService()); + } + + @Bean + public DependencyService dependencyService(){ + return new DependencyServiceImpl(); + } +} +``` + +**如果一个 bean 的定义依赖其他 bean,则直接调用对应的 JavaConfig 类中依赖 bean 的创建方法就可以了。** + +## @ComponentScan + +**@ComponentScan 这个注解在 Spring 中很重要，它对应 XML 配置中的元素，@ComponentScan 的功能其实就是自动扫描并加载符合条件的组件（比如@Component 和@Repository 等）或者 bean 定义，最终将这些 bean 定义加载到 IoC 容器中。** + +我们可以通过 basePackages 等属性来细粒度的定制@ComponentScan 自动扫描的范围，如果不指定，则默认 Spring 框架实现会从声明@ComponentScan 所在类的 package 进行扫描。 + +> 注：所以 SpringBoot 的启动类最好是放在 root package 下，因为默认不指定 basePackages。 + +## @EnableAutoConfiguration + +个人感觉**@EnableAutoConfiguration 这个 Annotation 最为重要**，所以放在最后来解读，大家是否还记得 Spring 框架提供的各种名字为@Enable 开头的 Annotation 定义？比如@EnableScheduling、@EnableCaching、@EnableMBeanExport 等，@EnableAutoConfiguration 的理念和做事方式其实一脉相承，简单概括一下就是，借助@Import 的支持，收集和注册特定场景相关的 bean 定义。 + +**@EnableScheduling**是通过@Import 将 Spring 调度框架相关的 bean 定义都加载到 IoC 容器。 +**@EnableMBeanExport**是通过@Import 将 JMX 相关的 bean 定义加载到 IoC 容器。 +而**@EnableAutoConfiguration**也是借助@Import 的帮助，将所有符合自动配置条件的 bean 定义加载到 IoC 容器，仅此而已！ + +@EnableAutoConfiguration 作为一个复合 Annotation,其自身定义关键信息如下： + +```kotlin +@SuppressWarnings("deprecation") +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.RUNTIME) +@Documented +@Inherited +@AutoConfigurationPackage +@Import(EnableAutoConfigurationImportSelector.class) +public @interface EnableAutoConfiguration { + ... +} +``` + +两个比较重要的注解： + +**@AutoConfigurationPackage：自动配置包** + +**@Import: 导入自动配置的组件** + +#### AutoConfigurationPackage 注解： + +```java +static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports { + + @Override + public void registerBeanDefinitions(AnnotationMetadata metadata, + BeanDefinitionRegistry registry) { + register(registry, new PackageImport(metadata).getPackageName()); + } +``` + +它其实是注册了一个 Bean 的定义。 + +new PackageImport(metadata).getPackageName()，它其实返回了当前主程序类的同级以及子级的包组件。 + +![img](https:////upload-images.jianshu.io/upload_images/6430208-439283a70a24c7a0.jpg?imageMogr2/auto-orient/strip|imageView2/2/w/281/format/webp) + +以上图为例，DemoApplication 是和 demo 包同级，但是 demo2 这个类是 DemoApplication 的父级，和 example 包同级 + +也就是说，DemoApplication 启动加载的 Bean 中，并不会加载 demo2，这也就是为什么，我们要把 DemoApplication 放在项目的最高级中。 + +#### Import(AutoConfigurationImportSelector.class)注解： + +![img](https:////upload-images.jianshu.io/upload_images/6430208-1c448a69c41dc35c.png?imageMogr2/auto-orient/strip|imageView2/2/w/877/format/webp) + +可以从图中看出 AutoConfigurationImportSelector 继承了 DeferredImportSelector 继承了 ImportSelector + +ImportSelector 有一个方法为：selectImports。 + +```dart +@Override + public String[] selectImports(AnnotationMetadata annotationMetadata) { + if (!isEnabled(annotationMetadata)) { + return NO_IMPORTS; + } + AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader + .loadMetadata(this.beanClassLoader); + AnnotationAttributes attributes = getAttributes(annotationMetadata); + List configurations = getCandidateConfigurations(annotationMetadata, + attributes); + configurations = removeDuplicates(configurations); + Set exclusions = getExclusions(annotationMetadata, attributes); + checkExcludedClasses(configurations, exclusions); + configurations.removeAll(exclusions); + configurations = filter(configurations, autoConfigurationMetadata); + fireAutoConfigurationImportEvents(configurations, exclusions); + return StringUtils.toStringArray(configurations); + } +``` + +可以看到第九行，它其实是去加载 public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";外部文件。这个外部文件，有很多自动配置的类。如下： + +![img](https:////upload-images.jianshu.io/upload_images/6430208-250f3320c15e5c99.jpg?imageMogr2/auto-orient/strip|imageView2/2/w/1200/format/webp) + +image + +其中，最关键的要属**@Import(EnableAutoConfigurationImportSelector.class)**，借助**EnableAutoConfigurationImportSelector**，**@EnableAutoConfiguration**可以帮助 SpringBoot 应用将所有符合条件的**@Configuration**配置都加载到当前 SpringBoot 创建并使用的 IoC 容器。就像一只“八爪鱼”一样。 + +![img](https:////upload-images.jianshu.io/upload_images/6430208-6f3a835755ee7710.png?imageMogr2/auto-orient/strip|imageView2/2/w/640/format/webp) + +### 自动配置幕后英雄：SpringFactoriesLoader 详解 + +借助于 Spring 框架原有的一个工具类：SpringFactoriesLoader 的支持，@EnableAutoConfiguration 可以智能的自动配置功效才得以大功告成！ + +SpringFactoriesLoader 属于 Spring 框架私有的一种扩展方案，其主要功能就是从指定的配置文件 META-INF/spring.factories 加载配置。 + +```php +public abstract class SpringFactoriesLoader { + //... + public static List loadFactories(Class factoryClass, ClassLoader classLoader) { + ... + } + + + public static List loadFactoryNames(Class factoryClass, ClassLoader classLoader) { + .... + } +} +``` + +配合**@EnableAutoConfiguration**使用的话，它更多是提供一种配置查找的功能支持，即根据@EnableAutoConfiguration 的完整类名 org.springframework.boot.autoconfigure.EnableAutoConfiguration 作为查找的 Key,获取对应的一组**@Configuration**类 + +![img](https:////upload-images.jianshu.io/upload_images/6430208-fcdfcb56828a015a?imageMogr2/auto-orient/strip|imageView2/2/w/1200/format/webp) + +上图就是从 SpringBoot 的 autoconfigure 依赖包中的 META-INF/spring.factories 配置文件中摘录的一段内容，可以很好地说明问题。 + +所以，@EnableAutoConfiguration 自动配置的魔法骑士就变成了：**从 classpath 中搜寻所有的 META-INF/spring.factories 配置文件，并将其中 org.springframework.boot.autoconfigure.EnableutoConfiguration 对应的配置项通过反射（Java Refletion）实例化为对应的标注了@Configuration 的 JavaConfig 形式的 IoC 容器配置类，然后汇总为一个并加载到 IoC 容器。** + +![img](https:////upload-images.jianshu.io/upload_images/6430208-10850d62d44c95ce.png?imageMogr2/auto-orient/strip|imageView2/2/w/822/format/webp) + +## 参考资料 + +- [一文搞懂 springboot 启动原理](https://www.jianshu.com/p/943650ab7dfd) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/00.Spring\347\273\274\345\220\210/99.Spring\351\235\242\350\257\225.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/00.Spring\347\273\274\345\220\210/99.Spring\351\235\242\350\257\225.md" new file mode 100644 index 00000000..461f16fb --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/00.Spring\347\273\274\345\220\210/99.Spring\351\235\242\350\257\225.md" @@ -0,0 +1,612 @@ +--- +title: Spring 面试 +date: 2018-08-02 17:33:32 +order: 99 +categories: + - Java + - 框架 + - Spring + - Spring综合 +tags: + - Java + - 框架 + - Spring + - 面试 +permalink: /pages/db33b0/ +--- + +# Spring 面试 + +## 综合篇 + +### 不同版本的 Spring Framework 有哪些主要功能？ + +| Version | Feature | +| ---------- | ------------------------------------------------------------------- | +| Spring 2.5 | 发布于 2007 年。这是第一个支持注解的版本。 | +| Spring 3.0 | 发布于 2009 年。它完全利用了 Java5 中的改进，并为 JEE6 提供了支持。 | +| Spring 4.0 | 发布于 2013 年。这是第一个完全支持 JAVA8 的版本。 | + +### 什么是 Spring Framework？ + +- Spring 是一个开源应用框架，旨在降低应用程序开发的复杂度。 +- 它是轻量级、松散耦合的。 +- 它具有分层体系结构，允许用户选择组件，同时还为 J2EE 应用程序开发提供了一个有凝聚力的框架。 +- 它可以集成其他框架，如 Structs、Hibernate、EJB 等，所以又称为框架的框架。 + +### 列举 Spring Framework 的优点。 + +- 由于 Spring Frameworks 的分层架构，用户可以自由选择自己需要的组件。 +- Spring Framework 支持 POJO(Plain Old Java Object) 编程，从而具备持续集成和可测试性。 +- 由于依赖注入和控制反转，JDBC 得以简化。 +- 它是开源免费的。 + +### Spring Framework 有哪些不同的功能？ + +- **轻量级** - Spring 在代码量和透明度方面都很轻便。 +- **IOC** - 控制反转 +- **AOP** - 面向切面编程可以将应用业务逻辑和系统服务分离，以实现高内聚。 +- **容器** - Spring 负责创建和管理对象（Bean）的生命周期和配置。 +- **MVC** - 对 web 应用提供了高度可配置性，其他框架的集成也十分方便。 +- **事务管理** - 提供了用于事务管理的通用抽象层。Spring 的事务支持也可用于容器较少的环境。 +- **JDBC 异常** - Spring 的 JDBC 抽象层提供了一个异常层次结构，简化了错误处理策略。 + +### Spring Framework 中有多少个模块，它们分别是什么？ + +![img](https://raw.githubusercontent.com/dunwu/images/master/cs/java/spring/spring-framework.png) + +- **Spring 核心容器** – 该层基本上是 Spring Framework 的核心。它包含以下模块： + - Spring Core + - Spring Bean + - SpEL (Spring Expression Language) + - Spring Context +- **数据访问/集成** – 该层提供与数据库交互的支持。它包含以下模块： + - JDBC (Java DataBase Connectivity) + - ORM (Object Relational Mapping) + - OXM (Object XML Mappers) + - JMS (Java Messaging Service) + - Transaction +- **Web** – 该层提供了创建 Web 应用程序的支持。它包含以下模块： + - Web + - Web – Servlet + - Web – Socket + - Web – Portlet +- **AOP** – 该层支持面向切面编程 +- **Instrumentation** – 该层为类检测和类加载器实现提供支持。 +- **Test** – 该层为使用 JUnit 和 TestNG 进行测试提供支持。 +- **几个杂项模块:** + - Messaging – 该模块为 STOMP 提供支持。它还支持注解编程模型，该模型用于从 WebSocket 客户端路由和处理 STOMP 消息。 + - Aspects – 该模块为与 AspectJ 的集成提供支持。 + +### 什么是 Spring 配置文件？ + +Spring 配置文件是 XML 文件。该文件主要包含类信息。它描述了这些类是如何配置以及相互引入的。但是，XML 配置文件冗长且更加干净。如果没有正确规划和编写，那么在大项目中管理变得非常困难。 + +### Spring 应用程序有哪些不同组件？ + +Spring 应用一般有以下组件： + +- **接口** - 定义功能。 +- **Bean 类** - 它包含属性，setter 和 getter 方法，函数等。 +- **Spring 面向切面编程（AOP）** - 提供面向切面编程的功能。 +- **Bean 配置文件** - 包含类的信息以及如何配置它们。 +- **用户程序** - 它使用接口。 + +### 使用 Spring 有哪些方式？ + +使用 Spring 有以下方式： + +- 作为一个成熟的 Spring Web 应用程序。 +- 作为第三方 Web 框架，使用 Spring Frameworks 中间层。 +- 用于远程使用。 +- 作为企业级 Java Bean，它可以包装现有的 POJO（Plain Old Java Objects）。 + +## 核心篇 + +### IoC + +#### 什么是 IoC？什么是依赖注入？什么是 Spring IoC？ + +**IoC** 即**控制反转**（Inversion of Control，缩写为 IoC）。IoC 又称为**依赖倒置原则**（设计模式六大原则之一），它的要点在于：**程序要依赖于抽象接口，不要依赖于具体实现**。它的作用就是**用于降低代码间的耦合度**。 + +IoC 的实现方式有两种： + +- **依赖注入**（Dependency Injection，简称 DI）：不通过 `new()` 的方式在类内部创建依赖类对象，而是将依赖的类对象在外部创建好之后，通过构造器、函数参数等方式传递（或注入）给类使用。 +- **依赖查找**（Dependency Lookup）：容器中的受控对象通过容器的 API 来查找自己所依赖的资源和协作对象。 + +Spring IoC 是 IoC 的一种实现。DI 是 Spring IoC 的主要实现原则。 + +![](https://raw.githubusercontent.com/dunwu/images/master/snap/20221005163639.png) + +#### 依赖注入有哪些实现方式？ + +依赖注入有如下方式： + +| 依赖注入方式 | 配置元数据举例 | +| --------------- | -------------------------------------------------- | +| Setter 方法注入 | `` | +| 构造器注入 | `` | +| 字段注入 | `@Autowired User user;` | +| 方法注入 | `@Autowired public void user(User user) { ... }` | +| 接口回调注入 | `class MyBean implements BeanFactoryAware { ... }` | + +#### 构造器注入 VS. setter 注入 + +| 构造器注入 | setter 注入 | +| -------------------------- | -------------------------- | +| 没有部分注入 | 有部分注入 | +| 不会覆盖 setter 属性 | 会覆盖 setter 属性 | +| 任意修改都会创建一个新实例 | 任意修改不会创建一个新实例 | +| 适用于设置很多属性 | 适用于设置少量属性 | + +官方推荐使用构造器注入。 + +#### BeanFactory VS. ApplicationContext + +在 Spring 中，有两种 IoC 容器：`BeanFactory` 和 `ApplicationContext`。 + +- `BeanFactory`：**`BeanFactory` 是 Spring 基础 IoC 容器**。`BeanFactory` 提供了 Spring 容器的配置框架和基本功能。 +- `ApplicationContext`：**`ApplicationContext` 是具备应用特性的 `BeanFactory` 的子接口**。它还扩展了其他一些接口，以支持更丰富的功能，如：国际化、访问资源、事件机制、更方便的支持 AOP、在 web 应用中指定应用层上下文等。 + +实际开发中，更推荐使用 `ApplicationContext` 作为 IoC 容器，因为它的功能远多于 `BeanFactory`。 + +#### BeanFactory VS. FactoryBean + +**`BeanFactory` 是 Spring 基础 IoC 容器**。 + +`FactoryBean` 是创建 Bean 的一种方式，帮助实现复杂的初始化逻辑。 + +#### Spring IoC 启动时做了哪些准备 + +IoC 配置元信息读取和解析 + +IoC 容器生命周期管理 + +Spring 事件发布 + +国际化 + +等等 + +#### Spring IoC 的实现机制是什么 + +Spring 中的 IoC 的实现原理就是工厂模式加反射机制。 + +示例： + +```java +interface Fruit { + public abstract void eat(); +} +class Apple implements Fruit { + public void eat(){ + System.out.println("Apple"); + } +} +class Orange implements Fruit { + public void eat(){ + System.out.println("Orange"); + } +} +class Factory { + public static Fruit getInstance(String ClassName) { + Fruit f=null; + try { + f=(Fruit)Class.forName(ClassName).newInstance(); + } catch (Exception e) { + e.printStackTrace(); + } + return f; + } +} +class Client { + public static void main(String[] a) { + Fruit f=Factory.getInstance("io.github.dunwu.spring.Apple"); + if(f!=null){ + f.eat(); + } + } +} +``` + +### Bean + +#### 什么是 Spring Bean + +在 Spring 中，构成应用程序主体由 Spring IoC 容器管理的对象称为 Bean。**Bean 是由 Spring IoC 容器实例化、装配和管理的对象**。 Bean 以及它们之间的依赖关系反映在容器使用的配置元数据中。 + +Spring IoC 容器本身，并不能识别配置的元数据。为此，要将这些配置信息转为 Spring 能识别的格式——`BeanDefinition` 对象。 + +**`BeanDefinition` 是 Spring 中定义 Bean 的配置元信息接口**，它包含： + +- Bean 类名 +- Bean 行为配置元素，如：作用域、自动绑定的模式、生命周期回调等 +- 其他 Bean 引用，也可称为合作者（Collaborators）或依赖（Dependencies） +- 配置设置，如 Bean 属性（Properties） + +#### 如何注册 Spring Bean + +通过 `BeanDefinition` 和外部单例对象来注册。 + +#### spring 提供了哪些配置方式？ + +- 基于 xml 配置 + +bean 所需的依赖项和服务在 XML 格式的配置文件中指定。这些配置文件通常包含许多 bean 定义和特定于应用程序的配置选项。它们通常以 bean 标签开头。例如： + +```xml + + + +``` + +- 基于注解配置 + +您可以通过在相关的类，方法或字段声明上使用注解，将 bean 配置为组件类本身，而不是使用 XML 来描述 bean 装配。默认情况下，Spring 容器中未打开注解装配。因此，您需要在使用它之前在 Spring 配置文件中启用它。例如： + +```xml + + + + +``` + +- 基于 Java API 配置 + +Spring 的 Java 配置是通过使用 @Bean 和 @Configuration 来实现。 + +1. @Bean 注解扮演与 `` 元素相同的角色。 +2. @Configuration 类允许通过简单地调用同一个类中的其他 @Bean 方法来定义 bean 间依赖关系。 + +例如： + +```java +@Configuration +public class StudentConfig { + @Bean + public StudentBean myStudent() { + return new StudentBean(); + } +} +``` + +#### spring 支持集中 bean scope？ + +Spring bean 支持 5 种 scope： + +- **Singleton** - 每个 Spring IoC 容器仅有一个单实例。 +- **Prototype** - 每次请求都会产生一个新的实例。 +- **Request** - 每一次 HTTP 请求都会产生一个新的实例，并且该 bean 仅在当前 HTTP 请求内有效。 +- **Session** - 每一次 HTTP 请求都会产生一个新的 bean，同时该 bean 仅在当前 HTTP session 内有效。 +- **Global-session** - 类似于标准的 HTTP Session 作用域，不过它仅仅在基于 portlet 的 web 应用中才有意义。Portlet 规范定义了全局 Session 的概念，它被所有构成某个 portlet web 应用的各种不同的 portlet 所共享。在 global session 作用域中定义的 bean 被限定于全局 portlet Session 的生命周期范围内。如果你在 web 中使用 global session 作用域来标识 bean，那么 web 会自动当成 session 类型来使用。 + +仅当用户使用支持 Web 的 ApplicationContext 时，最后三个才可用。 + +#### Spring Bean 的生命周期 + +![](https://raw.githubusercontent.com/dunwu/images/master/snap/20211201102734.png) + +spring bean 容器的生命周期如下： + +1. Spring 对 Bean 进行实例化（相当于 new XXX()） + +2. Spring 将值和引用注入到 Bean 对应的属性中 + +3. 如果 Bean 实现了 `BeanNameAware` 接口，Spring 将 Bean 的 ID 传递给 `setBeanName` 方法 + - 作用是通过 Bean 的引用来获得 Bean ID，一般业务中是很少有用到 Bean 的 ID 的 +4. 如果 Bean 实现了 `BeanFactoryAware` 接口，Spring 将调用 `setBeanDactory` 方法，并把 `BeanFactory` 容器实例作为参数传入。 + - 作用是获取 Spring 容器，如 Bean 通过 Spring 容器发布事件等 +5. 如果 Bean 实现了 `ApplicationContextAware` 接口，Spring 容器将调用 `setApplicationContext` 方法，把应用上下文作为参数传入 + - 作用与 `BeanFactory` 类似都是为了获取 Spring 容器，不同的是 Spring 容器在调用 `setApplicationContext` 方法时会把它自己作为 `setApplicationContext` 的参数传入，而 Spring 容器在调用 `setBeanFactory` 前需要使用者自己指定（注入）`setBeanFactory` 里的参数 `BeanFactory` +6. 如果 Bean 实现了 `BeanPostProcess` 接口，Spring 将调用 `postProcessBeforeInitialization` 方法 + - 作用是在 Bean 实例创建成功后对其进行增强处理，如对 Bean 进行修改，增加某个功能 +7. 如果 Bean 实现了 `InitializingBean` 接口，Spring 将调用 `afterPropertiesSet` 方法，作用与在配置文件中对 Bean 使用 `init-method` 声明初始化的作用一样，都是在 Bean 的全部属性设置成功后执行的初始化方法。 +8. 如果 Bean 实现了 `BeanPostProcess` 接口，Spring 将调用 `postProcessAfterInitialization` 方法 + - `postProcessBeforeInitialization` 是在 Bean 初始化前执行的，而 `postProcessAfterInitialization` 是在 Bean 初始化后执行的 +9. 经过以上的工作后，Bean 将一直驻留在应用上下文中给应用使用，直到应用上下文被销毁 +10. 如果 Bean 实现了 `DispostbleBean` 接口，Spring 将调用它的 `destory` 方法，作用与在配置文件中对 Bean 使用 `destory-method` 属性的作用一样，都是在 Bean 实例销毁前执行的方法。 + +#### 什么是 spring 的内部 bean？ + +只有将 bean 用作另一个 bean 的属性时，才能将 bean 声明为内部 bean。为了定义 bean，Spring 的基于 XML 的配置元数据在 `` 或 `` 中提供了 `` 元素的使用。内部 bean 总是匿名的，它们总是作为原型。 + +例如，假设我们有一个 Student 类，其中引用了 Person 类。这里我们将只创建一个 Person 类实例并在 Student 中使用它。 + +Student.java + +```java +public class Student { + private Person person; + //Setters and Getters +} +public class Person { + private String name; + private String address; + //Setters and Getters +} +``` + +bean.xml + +```xml + + + + + + + + + +``` + +#### 什么是 spring 装配 + +当 bean 在 Spring 容器中组合在一起时，它被称为装配或 bean 装配。 Spring 容器需要知道需要什么 bean 以及容器应该如何使用依赖注入来将 bean 绑定在一起，同时装配 bean。 + +#### 自动装配有哪些方式？ + +Spring 容器能够自动装配 bean。也就是说，可以通过检查 BeanFactory 的内容让 Spring 自动解析 bean 的协作者。 + +自动装配的不同模式： + +- **no** - 这是默认设置，表示没有自动装配。应使用显式 bean 引用进行装配。 +- **byName** - 它根据 bean 的名称注入对象依赖项。它匹配并装配其属性与 XML 文件中由相同名称定义的 bean。 +- **byType** - 它根据类型注入对象依赖项。如果属性的类型与 XML 文件中的一个 bean 名称匹配，则匹配并装配属性。 +- **构造器** - 它通过调用类的构造器来注入依赖项。它有大量的参数。 +- **autodetect** - 首先容器尝试通过构造器使用 autowire 装配，如果不能，则尝试通过 byType 自动装配。 + +#### 自动装配有什么局限？ + +- 覆盖的可能性 - 您始终可以使用 `` 和 `` 设置指定依赖项，这将覆盖自动装配。 +- 基本元数据类型 - 简单属性（如原数据类型，字符串和类）无法自动装配。 +- 令人困惑的性质 - 总是喜欢使用明确的装配，因为自动装配不太精确。 + +### AOP + +#### 什么是 AOP？ + +AOP(Aspect-Oriented Programming), 即 **面向切面编程**, 它与 OOP( Object-Oriented Programming, 面向对象编程) 相辅相成, 提供了与 OOP 不同的抽象软件结构的视角. +在 OOP 中, 我们以类(class)作为我们的基本单元, 而 AOP 中的基本单元是 **Aspect(切面)** + +#### AOP 中的 Aspect、Advice、Pointcut、JointPoint 和 Advice 参数分别是什么？ + +![img](https://raw.githubusercontent.com/dunwu/images/master/cs/java/spring/core/spring-aop.png) + +- **Aspect** - Aspect 是一个实现交叉问题的类，例如事务管理。方面可以是配置的普通类，然后在 Spring Bean 配置文件中配置，或者我们可以使用 Spring AspectJ 支持使用 @Aspect 注解将类声明为 Aspect。 +- **Advice** - Advice 是针对特定 JoinPoint 采取的操作。在编程方面，它们是在应用程序中达到具有匹配切入点的特定 JoinPoint 时执行的方法。您可以将 Advice 视为 Spring 拦截器（Interceptor）或 Servlet 过滤器（filter）。 +- **Advice Arguments** - 我们可以在 advice 方法中传递参数。我们可以在切入点中使用 args() 表达式来应用于与参数模式匹配的任何方法。如果我们使用它，那么我们需要在确定参数类型的 advice 方法中使用相同的名称。 +- **Pointcut** - Pointcut 是与 JoinPoint 匹配的正则表达式，用于确定是否需要执行 Advice。 Pointcut 使用与 JoinPoint 匹配的不同类型的表达式。Spring 框架使用 AspectJ Pointcut 表达式语言来确定将应用通知方法的 JoinPoint。 +- **JoinPoint** - JoinPoint 是应用程序中的特定点，例如方法执行，异常处理，更改对象变量值等。在 Spring AOP 中，JoinPoint 始终是方法的执行器。 + +#### 什么是通知（Advice）？ + +特定 JoinPoint 处的 Aspect 所采取的动作称为 Advice。Spring AOP 使用一个 Advice 作为拦截器，在 JoinPoint “周围”维护一系列的拦截器。 + +#### 有哪些类型的通知（Advice）？ + +- **Before** - 这些类型的 Advice 在 joinpoint 方法之前执行，并使用 @Before 注解标记进行配置。 +- **After Returning** - 这些类型的 Advice 在连接点方法正常执行后执行，并使用@AfterReturning 注解标记进行配置。 +- **After Throwing** - 这些类型的 Advice 仅在 joinpoint 方法通过抛出异常退出并使用 @AfterThrowing 注解标记配置时执行。 +- **After (finally)** - 这些类型的 Advice 在连接点方法之后执行，无论方法退出是正常还是异常返回，并使用 @After 注解标记进行配置。 +- **Around** - 这些类型的 Advice 在连接点之前和之后执行，并使用 @Around 注解标记进行配置。 + +#### 指出在 spring aop 中 concern 和 cross-cutting concern 的不同之处。 + +concern 是我们想要在应用程序的特定模块中定义的行为。它可以定义为我们想要实现的功能。 + +cross-cutting concern 是一个适用于整个应用的行为，这会影响整个应用程序。例如，日志记录，安全性和数据传输是应用程序几乎每个模块都需要关注的问题，因此它们是跨领域的问题。 + +#### AOP 有哪些实现方式？ + +实现 AOP 的技术，主要分为两大类： + +- 静态代理 - 指使用 AOP 框架提供的命令进行编译，从而在编译阶段就可生成 AOP 代理类，因此也称为编译时增强； + - 编译时编织（特殊编译器实现） + - 类加载时编织（特殊的类加载器实现）。 +- 动态代理 - 在运行时在内存中“临时”生成 AOP 动态代理类，因此也被称为运行时增强。 + - JDK 动态代理 + - CGLIB + +#### Spring AOP and AspectJ AOP 有什么区别？ + +Spring AOP 基于动态代理方式实现；AspectJ 基于静态代理方式实现。 +Spring AOP 仅支持方法级别的 PointCut；提供了完全的 AOP 支持，它还支持属性级别的 PointCut。 + +#### 如何理解 Spring 中的代理？ + +将 Advice 应用于目标对象后创建的对象称为代理。在客户端对象的情况下，目标对象和代理对象是相同的。 + +``` +Advice + Target Object = Proxy +``` + +#### 什么是编织（Weaving）？ + +为了创建一个 advice 对象而链接一个 aspect 和其它应用类型或对象，称为编织（Weaving）。在 Spring AOP 中，编织在运行时执行。请参考下图： + +![img](https://upload-images.jianshu.io/upload_images/3101171-cfaa92f0e4115b4a.png) + +## 注解 + +### 你用过哪些重要的 Spring 注解？ + +- **@Controller** - 用于 Spring MVC 项目中的控制器类。 +- **@Service** - 用于服务类。 +- **@RequestMapping** - 用于在控制器处理程序方法中配置 URI 映射。 +- **@ResponseBody** - 用于发送 Object 作为响应，通常用于发送 XML 或 JSON 数据作为响应。 +- **@PathVariable** - 用于将动态值从 URI 映射到处理程序方法参数。 +- **@Autowired** - 用于在 spring bean 中自动装配依赖项。 +- **@Qualifier** - 使用 @Autowired 注解，以避免在存在多个 bean 类型实例时出现混淆。 +- **@Scope** - 用于配置 spring bean 的范围。 +- **@Configuration**，**@ComponentScan** 和 **@Bean** - 用于基于 java 的配置。 +- **@Aspect**，**@Before**，**@After**，**@Around**，**@Pointcut** - 用于切面编程（AOP）。 + +### 如何在 spring 中启动注解装配？ + +默认情况下，Spring 容器中未打开注解装配。因此，要使用基于注解装配，我们必须通过配置`` 元素在 Spring 配置文件中启用它。 + +### @Component, @Controller, @Repository, @Service 有何区别？ + +- @Component：这将 java 类标记为 bean。它是任何 Spring 管理组件的通用构造型。spring 的组件扫描机制现在可以将其拾取并将其拉入应用程序环境中。 +- @Controller：这将一个类标记为 Spring Web MVC 控制器。标有它的 Bean 会自动导入到 IoC 容器中。 +- @Service：此注解是组件注解的特化。它不会对 @Component 注解提供任何其他行为。您可以在服务层类中使用 @Service 而不是 @Component，因为它以更好的方式指定了意图。 +- @Repository：这个注解是具有类似用途和功能的 @Component 注解的特化。它为 DAO 提供了额外的好处。它将 DAO 导入 IoC 容器，并使未经检查的异常有资格转换为 Spring DataAccessException。 + +### @Required 注解有什么用？ + +@Required 应用于 bean 属性 setter 方法。此注解仅指示必须在配置时使用 bean 定义中的显式属性值或使用自动装配填充受影响的 bean 属性。如果尚未填充受影响的 bean 属性，则容器将抛出 BeanInitializationException。 + +示例： + +```java +public class Employee { + private String name; + @Required + public void setName(String name){ + this.name=name; + } + public string getName(){ + return name; + } +} +``` + +### @Autowired 注解有什么用？ + +@Autowired 可以更准确地控制应该在何处以及如何进行自动装配。此注解用于在 setter 方法，构造器，具有任意名称或多个参数的属性或方法上自动装配 bean。默认情况下，它是类型驱动的注入。 + +```java +public class Employee { + private String name; + @Autowired + public void setName(String name) { + this.name=name; + } + public string getName(){ + return name; + } +} +``` + +### @Qualifier 注解有什么用？ + +当您创建多个相同类型的 bean 并希望仅使用属性装配其中一个 bean 时，您可以使用@Qualifier 注解和 @Autowired 通过指定应该装配哪个确切的 bean 来消除歧义。 + +例如，这里我们分别有两个类，Employee 和 EmpAccount。在 EmpAccount 中，使用@Qualifier 指定了必须装配 id 为 emp1 的 bean。 + +Employee.java + +```java +public class Employee { + private String name; + @Autowired + public void setName(String name) { + this.name=name; + } + public string getName() { + return name; + } +} +``` + +EmpAccount.java + +```java +public class EmpAccount { + private Employee emp; + + @Autowired + @Qualifier(emp1) + public void showName() { + System.out.println(“Employee name : ”+emp.getName); + } +} +``` + +### @RequestMapping 注解有什么用？ + +@RequestMapping 注解用于将特定 HTTP 请求方法映射到将处理相应请求的控制器中的特定类/方法。此注解可应用于两个级别： + +- 类级别：映射请求的 URL +- 方法级别：映射 URL 以及 HTTP 请求方法 + +## 数据篇 + +### spring DAO 有什么用？ + +Spring DAO 使得 JDBC，Hibernate 或 JDO 这样的数据访问技术更容易以一种统一的方式工作。这使得用户容易在持久性技术之间切换。它还允许您在编写代码时，无需考虑捕获每种技术不同的异常。 + +### 列举 Spring DAO 抛出的异常。 + +![img](https://raw.githubusercontent.com/dunwu/images/master/cs/java/spring/data-access/spring-data-access-exception.png) + +### spring JDBC API 中存在哪些类？ + +- JdbcTemplate +- SimpleJdbcTemplate +- NamedParameterJdbcTemplate +- SimpleJdbcInsert +- SimpleJdbcCall + +### 使用 Spring 访问 Hibernate 的方法有哪些？ + +我们可以通过两种方式使用 Spring 访问 Hibernate： + +1. 使用 Hibernate 模板和回调进行控制反转 +2. 扩展 HibernateDAOSupport 并应用 AOP 拦截器节点 + +### 列举 spring 支持的事务管理类型 + +Spring 支持两种类型的事务管理： + +1. 程序化事务管理：在此过程中，在编程的帮助下管理事务。它为您提供极大的灵活性，但维护起来非常困难。 +2. 声明式事务管理：在此，事务管理与业务代码分离。仅使用注解或基于 XML 的配置来管理事务。 + +### spring 支持哪些 ORM 框架 + +- Hibernate +- iBatis +- JPA +- JDO +- OJB + +## MVC + +### Spring MVC 框架有什么用？ + +Spring Web MVC 框架提供 **模型-视图-控制器** 架构和随时可用的组件，用于开发灵活且松散耦合的 Web 应用程序。 MVC 模式有助于分离应用程序的不同方面，如输入逻辑，业务逻辑和 UI 逻辑，同时在所有这些元素之间提供松散耦合。 + +### 描述一下 DispatcherServlet 的工作流程 + +DispatcherServlet 的工作流程可以用一幅图来说明： + +![img](https://raw.githubusercontent.com/dunwu/images/master/cs/java/spring/web/spring-dispatcher-servlet.png) + +1. 向服务器发送 HTTP 请求，请求被前端控制器 `DispatcherServlet` 捕获。 +2. `DispatcherServlet` 根据 **`-servlet.xml`** 中的配置对请求的 URL 进行解析，得到请求资源标识符（URI）。然后根据该 URI，调用 `HandlerMapping` 获得该 Handler 配置的所有相关的对象（包括 Handler 对象以及 Handler 对象对应的拦截器），最后以`HandlerExecutionChain` 对象的形式返回。 +3. `DispatcherServlet` 根据获得的`Handler`，选择一个合适的 `HandlerAdapter`。（附注：如果成功获得`HandlerAdapter`后，此时将开始执行拦截器的 preHandler(...)方法）。 +4. 提取`Request`中的模型数据，填充`Handler`入参，开始执行`Handler`（`Controller`)。在填充`Handler`的入参过程中，根据你的配置，Spring 将帮你做一些额外的工作： + - HttpMessageConveter：将请求消息（如 Json、xml 等数据）转换成一个对象，将对象转换为指定的响应信息。 + - 数据转换：对请求消息进行数据转换。如`String`转换成`Integer`、`Double`等。 + - 数据根式化：对请求消息进行数据格式化。如将字符串转换成格式化数字或格式化日期等。 + - 数据验证：验证数据的有效性（长度、格式等），验证结果存储到`BindingResult`或`Error`中。 +5. Handler(Controller)执行完成后，向 `DispatcherServlet` 返回一个 `ModelAndView` 对象； +6. 根据返回的`ModelAndView`，选择一个适合的 `ViewResolver`（必须是已经注册到 Spring 容器中的`ViewResolver`)返回给`DispatcherServlet`。 +7. `ViewResolver` 结合`Model`和`View`，来渲染视图。 +8. 视图负责将渲染结果返回给客户端。 + +### 介绍一下 WebApplicationContext + +WebApplicationContext 是 ApplicationContext 的扩展。它具有 Web 应用程序所需的一些额外功能。它与普通的 ApplicationContext 在解析主题和决定与哪个 servlet 关联的能力方面有所不同。 + +（完） + +--- + +:point_right: 想学习更多 Spring 内容可以访问我的 Spring 教程：**[spring-notes](https://github.com/dunwu/spring-notes)** + +## 资料 + +- [Top 50 Spring Interview Questions You Must Prepare In 2018](https://www.edureka.co/blog/interview-questions/spring-interview-questions/) +- [Spring Interview Questions and Answers](https://www.journaldev.com/2696/spring-interview-questions-and-answers) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/00.Spring\347\273\274\345\220\210/README.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/00.Spring\347\273\274\345\220\210/README.md" new file mode 100644 index 00000000..cb55bf58 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/00.Spring\347\273\274\345\220\210/README.md" @@ -0,0 +1,43 @@ +--- +title: Spring 综述 +date: 2020-02-26 23:48:06 +categories: + - Java + - 框架 + - Spring + - Spring综合 +tags: + - Java + - 框架 + - Spring + - SpringBoot +permalink: /pages/9e0b67/ +hidden: true +index: false +--- + +# Spring 综述 + +## 📖 内容 + +- [Spring 概述](01.Spring概述.md) +- [SpringBoot 知识图谱](21.SpringBoot知识图谱.md) +- [SpringBoot 基本原理](22.SpringBoot基本原理.md) +- [Spring 面试](99.Spring面试.md) + +## 📚 资料 + +- **官方** + - [Spring 官网](https://spring.io/) + - [Spring Framework 官方文档](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/index.html) + - [Spring Github](https://github.com/spring-projects/spring-framework) +- **书籍** + - [《Spring In Action》](https://item.jd.com/12622829.html) +- **教程** + - [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) + - [geekbang-lessons](https://github.com/geektime-geekbang/geekbang-lessons) + - [跟我学 Spring3](http://jinnianshilongnian.iteye.com/blog/1482071) + +## 🚪 传送 + +◾ 💧 [钝悟的 IT 知识图谱](https://dunwu.github.io/waterdrop/) ◾ \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/01.SpringBean.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/01.SpringBean.md" new file mode 100644 index 00000000..1df26d7b --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/01.SpringBean.md" @@ -0,0 +1,214 @@ +--- +title: Spring Bean +date: 2021-12-10 19:15:42 +order: 01 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring + - Bean + - BeanDefinition +permalink: /pages/68097d/ +--- + +# Spring Bean + +在 Spring 中，构成应用程序主体由 Spring IoC 容器管理的对象称为 Bean。**Bean 是由 Spring IoC 容器实例化、装配和管理的对象**。 Bean 以及它们之间的依赖关系反映在容器使用的配置元数据中。 + +## Spring Bean 定义 + +### BeanDefinition + +Spring IoC 容器本身，并不能识别配置的元数据。为此，要将这些配置信息转为 Spring 能识别的格式——`BeanDefinition` 对象。 + +**`BeanDefinition` 是 Spring 中定义 Bean 的配置元信息接口**，它包含： + +- Bean 类名 +- Bean 行为配置元素，如：作用域、自动绑定的模式、生命周期回调等 +- 其他 Bean 引用，也可称为合作者（Collaborators）或依赖（Dependencies） +- 配置设置，如 Bean 属性（Properties） + +#### BeanDefinition 元信息 + +`BeanDefinition` 元信息如下： + +| 属性（Property） | 说明 | +| ----------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------ | +| [Class](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-class) | 全类名，必须是具体类，不能用抽象类或接口 | +| [Name](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-beanname) | Bean 的名称或者 ID | +| [Scope](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-scopes) | Bean 的作用域（如：`singleton`、`prototype` 等） | +| [Constructor arguments](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-collaborators) | Bean 构造器参数（用于依赖注入） | +| [Properties](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-collaborators) | Bean 属性设置（用于依赖注入） | +| [Autowiring mode](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-autowire) | Bean 自动绑定模式（如：通过名称 byName） | +| [Lazy initialization mode](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-lazy-init) | Bean 延迟初始化模式（延迟和非延迟） | +| [Initialization method](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-lifecycle-initializingbean) | Bean 初始化回调方法名称 | +| [Destruction method](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-lifecycle-disposablebean) | Bean 销毁回调方法名称 | + +#### BeanDefinition 构建 + +BeanDefinition 构建方式： + +- 通过 `BeanDefinitionBuilder` + +- 通过 `AbstractBeanDefinition` 以及派生类 + +> 💻 Spring Bean 定义示例源码：[BeanDefinitionTests](https://github.com/dunwu/spring-tutorial/blob/master/codes/core/spring-core-ioc/src/test/java/io/github/dunwu/spring/core/bean/BeanDefinitionTests.java) + +### Spring Bean 命名 + +#### Spring Bean 命名规则 + +每个 Bean 拥有一个或多个标识符（identifiers），这些标识符在 Bean 所在的容器必须是唯一的。通常，一个 Bean 仅有一个标识符，如果需要额外的，可考虑使用别名（Alias）来扩充。 + +在基于 XML 的配置元信息中，开发人员**可以使用 `id` 属性、`name` 属性或来指定 Bean 标识符**。通常，Bean 的标识符由字母组成，允许出现特殊字符。如果要想引入 Bean 的别名的话，可在 `name` 属性使用半角逗号（“,”）或分号（“;”) 来间隔。 + +Spring 中，**为 Bean 指定 `id` 和 `name` 属性不是必须的**。如果不指定，Spring 会自动为 Bean 分配一个唯一的名称。尽管 Bean 的命名没有限制，不过**官方建议采用驼峰命名法来命名 Bean**。 + +#### Spring Bean 命名生成器 + +Spring 提供了两种 Spring Bean 命名生成器： + +- `DefaultBeanNameGenerator`：默认通用 `BeanNameGenerator` 实现。 +- `AnnotationBeanNameGenerator`：基于注解扫描的 `BeanNameGenerator` 实现。 + +```java +public interface BeanNameGenerator { + String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry); +} +``` + +#### Spring Bean 别名 + +Spring 支持通过 `` 属性为 Bean 设置别名。 + +Bean 别名（Alias）的作用： + +- 复用现有的 `BeanDefinition` +- 更具有场景化的命名方法，比如： + - `` + - `` + +```xml + + + + +``` + +## Spring Bean 生命周期 + +![](https://raw.githubusercontent.com/dunwu/images/master/snap/20211201102734.png) + +1. Spring 对 Bean 进行实例化（相当于 new XXX()） + +2. Spring 将值和引用注入到 Bean 对应的属性中 + +3. 如果 Bean 实现了 `BeanNameAware` 接口，Spring 将 Bean 的 ID 传递给 `setBeanName` 方法 + - 作用是通过 Bean 的引用来获得 Bean ID，一般业务中是很少有用到 Bean 的 ID 的 +4. 如果 Bean 实现了 `BeanFactoryAware` 接口，Spring 将调用 `setBeanDactory` 方法，并把 `BeanFactory` 容器实例作为参数传入。 + - 作用是获取 Spring 容器，如 Bean 通过 Spring 容器发布事件等 +5. 如果 Bean 实现了 `ApplicationContextAware` 接口，Spring 容器将调用 `setApplicationContext` 方法，把应用上下文作为参数传入 + - 作用与 `BeanFactory` 类似都是为了获取 Spring 容器，不同的是 Spring 容器在调用 `setApplicationContext` 方法时会把它自己作为 `setApplicationContext` 的参数传入，而 Spring 容器在调用 `setBeanFactory` 前需要使用者自己指定（注入）`setBeanFactory` 里的参数 `BeanFactory` +6. 如果 Bean 实现了 `BeanPostProcess` 接口，Spring 将调用 `postProcessBeforeInitialization` 方法 + - 作用是在 Bean 实例创建成功后对其进行增强处理，如对 Bean 进行修改，增加某个功能 +7. 如果 Bean 实现了 `InitializingBean` 接口，Spring 将调用 `afterPropertiesSet` 方法，作用与在配置文件中对 Bean 使用 `init-method` 声明初始化的作用一样，都是在 Bean 的全部属性设置成功后执行的初始化方法。 +8. 如果 Bean 实现了 `BeanPostProcess` 接口，Spring 将调用 `postProcessAfterInitialization` 方法 + - `postProcessBeforeInitialization` 是在 Bean 初始化前执行的，而 `postProcessAfterInitialization` 是在 Bean 初始化后执行的 +9. 经过以上的工作后，Bean 将一直驻留在应用上下文中给应用使用，直到应用上下文被销毁 +10. 如果 Bean 实现了 `DispostbleBean` 接口，Spring 将调用它的 `destory` 方法，作用与在配置文件中对 Bean 使用 `destory-method` 属性的作用一样，都是在 Bean 实例销毁前执行的方法。 + +## Spring Bean 注册 + +注册 Spring Bean 实际上是将 `BeanDefinition` 注册到 IoC 容器中。 + +### XML 配置元信息 + +Spring 的传统配置方式。在 `` 标签中配置元数据内容。 + +缺点是当 JavaBean 过多时，产生的配置文件足以让你眼花缭乱。 + +### 注解配置元信息 + +使用 `@Bean`、`@Component`、`@Import` 注解注册 Spring Bean。 + +### Java API 配置元信息 + +- 命名方式：`BeanDefinitionRegistry#registerBeanDefinition(String,BeanDefinition)` +- 非命名方式：`BeanDefinitionReaderUtils#registerWithGeneratedName(AbstractBeanDefinition,BeanDefinitionRegistry)` +- 配置类方式：`AnnotatedBeanDefinitionReader#register(Class...)` + +> 💻 Spring Bean 注册示例源码：[BeanRegistryTests](https://github.com/dunwu/spring-tutorial/blob/master/codes/core/spring-core-ioc/src/test/java/io/github/dunwu/spring/core/bean/BeanRegistryTests.java) + +## Spring Bean 实例化 + +Spring Bean 实例化方式： + +- 常规方式 + - 通过构造器（配置元信息：XML、Java 注解和 Java API） + - 通过静态方法（配置元信息：XML、Java 注解和 Java API） + - 通过 Bean 工厂方法（配置元信息：XML、Java 注解和 Java API） + - 通过 `FactoryBean`（配置元信息：XML、Java 注解和 Java API） +- 特殊方式 + - 通过 `ServiceLoaderFactoryBean`（配置元信息：XML、Java 注解和 Java API ） + - 通过 `AutowireCapableBeanFactory#createBean(java.lang.Class, int, boolean)` + - 通过 `BeanDefinitionRegistry#registerBeanDefinition(String,BeanDefinition)` + +> 💻 Spring Bean 实例化示例源码：[BeanInstantiationTests](https://github.com/dunwu/spring-tutorial/blob/master/codes/core/spring-core-ioc/src/test/java/io/github/dunwu/spring/core/bean/BeanInstantiationTests.java)、[BeanInstantiationSpecialTests](https://github.com/dunwu/spring-tutorial/blob/master/codes/core/spring-core-ioc/src/test/java/io/github/dunwu/spring/core/bean/BeanInstantiationSpecialTests.java) + +## Spring Bean 初始化和销毁 + +Spring Bean 初始化和销毁的方式有以下几种： + +1. 使用 `@PostConstruct` 和 `@PreDestroy` 注解分别指定相应的初始化方法和销毁方法。 +2. 实现 `InitializingBean` 接口的 `afterPropertiesSet()` 方法来编写初始化方法；实现 `DisposableBean` 接口的 `destroy()` 方法来编写销毁方法。 + + - `InitializingBean` 接口包含一个 `afterPropertiesSet` 方法，可以通过实现该接口，然后在这个方法中编写初始化逻辑。 + - `DisposableBean`接口包含一个 `destory` 方法，可以通过实现该接口，然后在这个方法中编写销毁逻辑。 + +3. 自定义初始化方法 + - XML 配置：`` + - Java 注解：`@Bean(initMethod = "init", destroyMethod = "destroy")` + - Java API：`AbstractBeanDefinition#setInitMethodName(String)` 和 `AbstractBeanDefinition#setDestroyMethodName(String)` 分别定义初始化和销毁方法 + +注意：如果同时存在，执行顺序会按照序列执行。 + +Bean 的延迟初始化 + +- xml 方式：`` +- 注解方式：`@Lazy` + +Spring 提供了一个 `BeanPostProcessor` 接口，提供了两个方法 `postProcessBeforeInitialization` 和 `postProcessAfterInitialization`。其中`postProcessBeforeInitialization` 在组件的初始化方法调用之前执行，`postProcessAfterInitialization` 在组件的初始化方法调用之后执行。它们都包含两个入参： + +- `bean`：当前组件对象； +- `beanName`：当前组件在容器中的名称。 + +> 💻 Spring Bean 初始化和销毁示例源码：[BeanInitDestroyTests](https://github.com/dunwu/spring-tutorial/blob/master/codes/core/spring-core-ioc/src/test/java/io/github/dunwu/spring/core/bean/BeanInitDestroyTests.java) + +## Spring Bean 垃圾回收 + +Spring Bean 垃圾回收步骤： + +1. 关闭 Spring 容器（应用上下文） +2. 执行 GC +3. Spring Bean 覆盖的 `finalize()` 方法被回调 + +## Spring Bean 作用范围 + +| Scope | Description | +| :---------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| [singleton](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-scopes-singleton) | (Default) Scopes a single bean definition to a single object instance for each Spring IoC container. | +| [prototype](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-scopes-prototype) | Scopes a single bean definition to any number of object instances. | +| [request](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-scopes-request) | Scopes a single bean definition to the lifecycle of a single HTTP request. That is, each HTTP request has its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring `ApplicationContext`. | +| [session](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-scopes-session) | Scopes a single bean definition to the lifecycle of an HTTP `Session`. Only valid in the context of a web-aware Spring `ApplicationContext`. | +| [application](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-factory-scopes-application) | Scopes a single bean definition to the lifecycle of a `ServletContext`. Only valid in the context of a web-aware Spring `ApplicationContext`. | +| [websocket](https://docs.spring.io/spring-framework/docs/current/reference/html/web.html#websocket-stomp-websocket-scope) | Scopes a single bean definition to the lifecycle of a `WebSocket`. Only valid in the context of a web-aware Spring `ApplicationContext`. | + +## 参考资料 + +- [Spring 官方文档之 Core Technologies](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans) +- [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/02.SpringIoC.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/02.SpringIoC.md" new file mode 100644 index 00000000..505172fb --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/02.SpringIoC.md" @@ -0,0 +1,921 @@ +--- +title: Spring IoC +date: 2020-08-30 16:06:10 +order: 02 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring + - IOC +permalink: /pages/915530/ +--- + +# Spring IoC + +## IoC 简介 + +### IoC 是什么 + +**IoC** 即**控制反转**（Inversion of Control，缩写为 IoC）。IoC 又称为**依赖倒置原则**（设计模式六大原则之一），它的要点在于：**程序要依赖于抽象接口，不要依赖于具体实现**。它的作用就是**用于降低代码间的耦合度**。 + +IoC 的实现方式有两种： + +- **依赖注入**（Dependency Injection，简称 DI）：不通过 `new()` 的方式在类内部创建依赖类对象，而是将依赖的类对象在外部创建好之后，通过构造函数、函数参数等方式传递（或注入）给类使用。 +- **依赖查找**（Dependency Lookup）：容器中的受控对象通过容器的 API 来查找自己所依赖的资源和协作对象。 + +理解 Ioc 的关键是要明确两个要点： + +- **谁控制谁，控制什么**：传统 Java SE 程序设计，我们直接在对象内部通过 new 进行创建对象，是程序主动去创建依赖对象；而 IoC 是有专门一个容器来创建这些对象，即由 Ioc 容器来控制对象的创建；谁控制谁？当然是 IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。 +- **为何是反转，哪些方面反转了**：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。 + +![](https://raw.githubusercontent.com/dunwu/images/master/snap/20221006120112.png) + +### IoC 能做什么 + +IoC 不是一种技术，而是编程思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了 IoC 容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。 + +其实 IoC 对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在 IoC/DI 思想中，应用程序就变成被动的了，被动的等待 IoC 容器来创建并注入它所需要的资源了。 + +IoC 很好的体现了面向对象设计法则之一—— **好莱坞法则：“别找我们，我们找你”**；即由 IoC 容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。 + +### IoC 和 DI + +其实它们是同一个概念的不同角度描述，由于控制反转概念比较含糊（可能只是理解为容器控制对象这一个层面，很难让人想到谁来维护对象关系），所以 2004 年大师级人物 Martin Fowler 又给出了一个新的名字：“依赖注入”，相对 IoC 而言，“依赖注入”明确描述了“被注入对象依赖 IoC 容器配置依赖对象”。 + +> 注：如果想要更加深入的了解 IoC 和 DI，请参考大师级人物 Martin Fowler 的一篇经典文章 [Inversion of Control Containers and the Dependency Injection pattern](http://www.martinfowler.com/articles/injection.html) 。 + +### IoC 容器 + +IoC 容器就是具有依赖注入功能的容器。IoC 容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。应用程序无需直接在代码中 new 相关的对象，应用程序由 IoC 容器进行组装。在 Spring 中 BeanFactory 是 IoC 容器的实际代表者。 + +Spring IoC 容器如何知道哪些是它管理的对象呢？这就需要配置文件，Spring IoC 容器通过读取配置文件中的配置元数据，通过元数据对应用中的各个对象进行实例化及装配。一般使用基于 xml 配置文件进行配置元数据，而且 Spring 与配置文件完全解耦的，可以使用其他任何可能的方式进行配置元数据，比如注解、基于 java 文件的、基于属性文件的配置都可以。 + +### Bean + +> **JavaBean** 是一种 JAVA 语言写成的可重用组件。为写成 JavaBean，类必须是具体的和公共的，并且具有无参数的构造器。JavaBean 对外部通过提供 getter / setter 方法来访问其成员。 + +由 IoC 容器管理的那些组成你应用程序的对象我们就叫它 Bean。Bean 就是由 Spring 容器初始化、装配及管理的对象，除此之外，bean 就与应用程序中的其他对象没有什么区别了。那 IoC 怎样确定如何实例化 Bean、管理 Bean 之间的依赖关系以及管理 Bean 呢？这就需要配置元数据，在 Spring 中由 BeanDefinition 代表，后边会详细介绍，配置元数据指定如何实例化 Bean、如何组装 Bean 等。 + +### Spring IoC + +Spring IoC 容器中的对象仅通过构造函数参数、工厂方法的参数或在对象实例被构造或从工厂方法返回后设置的属性来定义它们的依赖关系（即与它们一起工作的其他对象）。然后容器在创建 bean 时注入这些依赖项。这个过程基本上是 bean 本身通过使用类的直接构造或诸如服务定位器模式之类的机制来控制其依赖关系的实例化或位置的逆过程（因此称为控制反转）。 + +`org.springframework.beans` 和 `org.springframework.context` 是 IoC 容器的基础。 + +## IoC 容器 + +在 Spring 中，有两种 IoC 容器：`BeanFactory` 和 `ApplicationContext`。 + +- `BeanFactory`：**`BeanFactory` 是 Spring 基础 IoC 容器**。`BeanFactory` 提供了 Spring 容器的配置框架和基本功能。 +- `ApplicationContext`：**`ApplicationContext` 是具备应用特性的 `BeanFactory` 的子接口**。它还扩展了其他一些接口，以支持更丰富的功能，如：国际化、访问资源、事件机制、更方便的支持 AOP、在 web 应用中指定应用层上下文等。 + +实际开发中，更推荐使用 `ApplicationContext` 作为 IoC 容器，因为它的功能远多于 `BeanFactory`。 + +`org.springframework.context.ApplicationContext` 接口代表 Spring IoC 容器，负责实例化、配置和组装 bean。容器通过读取配置元数据来获取关于要实例化、配置和组装哪些对象的指令。配置元数据以 XML、Java 注释或 Java 代码表示。它允许您表达组成应用程序的对象以及这些对象之间丰富的相互依赖关系。 + +Spring 提供了 `ApplicationContext` 接口的几个实现，例如： + +- **[ClassPathXmlApplicationContext](https://docs.spring.io/spring-framework/docs/5.3.23/javadoc-api/org/springframework/context/support/ClassPathXmlApplicationContext.html)**：`ApplicationContext` 的实现，从 classpath 获取配置信息。 + +```java +BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath.xml"); +``` + +- **[FileSystemXmlApplicationContext](https://docs.spring.io/spring-framework/docs/5.3.23/javadoc-api/org/springframework/context/support/FileSystemXmlApplicationContext.html)**：`ApplicationContext` 的实现，从文件系统获取配置信息。 + +```java +BeanFactory beanFactory = new FileSystemXmlApplicationContext("fileSystemConfig.xml"); +``` + +在大多数应用场景中，不需要显式通过用户代码来实例化 Spring IoC 容器的一个或多个实例。 + +下图显示了 Spring IoC 容器的工作步骤 + +![img](https://raw.githubusercontent.com/dunwu/images/master/snap/20200723102456.png) + +使用 IoC 容器可分为三步骤： + +1. **配置元数据**：需要配置一些元数据来告诉 Spring，你希望容器如何工作，具体来说，就是如何去初始化、配置、管理 JavaBean 对象。 +2. **实例化容器**：由 IoC 容器解析配置的元数据。IoC 容器的 Bean Reader 读取并解析配置文件，根据定义生成 BeanDefinition 配置元数据对象，IoC 容器根据 `BeanDefinition` 进行实例化、配置及组装 Bean。 +3. **使用容器**：由客户端实例化容器，获取需要的 Bean。 + +### 配置元数据 + +**元数据（Metadata）**又称中介数据、中继数据，为描述数据的数据（data about data），主要是描述数据属性（property）的信息。 + +配置元数据的方式： + +- **基于 xml 配置**：Spring 的传统配置方式。通常是在顶级元素 `` 中通过 ``元素配置元数据。这种方式的缺点是：如果 JavaBean 过多，则产生的配置文件足以让你眼花缭乱。 +- **[基于注解配置](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-annotation-config)**：Spring 2.5 引入了对基于注解的配置元数据的支持。可以大大简化你的配置。 +- **[基于 Java 配置](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-java)**：从 Spring 3.0 开始，Spring 支持使用 Java 代码来配置元数据。通常是在 `@Configuration` 修饰的类中通过 `@Bean` 指定实例化 Bean 的方法。更多详情，可以参阅 [`@Configuration`](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Configuration.html)、[`@Bean`](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Bean.html)、[`@Import`](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Import.html) 和 [`@DependsOn`](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/DependsOn.html) 注释。 + +这些 bean 定义对应于构成应用程序的实际对象。例如：定义服务层对象、数据访问对象 (DAO)、表示对象（如 Struts Action 实例）、基础设施对象（如 Hibernate SessionFactories、JMS 队列等）。通常，不会在容器中配置细粒度的域对象，因为创建和加载域对象通常是 DAO 和业务逻辑的责任。但是，可以使用 Spring 与 AspectJ 的集成来配置在 IoC 容器控制之外创建的对象。 + +以下示例显示了基于 XML 的配置元数据的基本结构： + +```xml + + + + + + + + + + + + + + + + +``` + +### 实例化容器 + +可以通过为 `ApplicationContext` 的构造函数指定外部资源路径，来加载配置元数据。 + +```java +ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml"); +``` + +以下示例显示了服务层对象 (services.xml) 配置文件： + +```xml + + + + + + + + + + + + + + +``` + +以下示例显示了数据访问对象 (daos.xml) 配置文件： + +```xml + + + + + + + + + + + + + + +``` + +上面的示例中，服务层由 `PetStoreServiceImpl` 类和类型为 `JpaAccountDao` 和 `JpaItemDao` 的两个数据访问对象（基于 JPA 对象关系映射标准）组成。 `property name` 元素指的是 JavaBean 属性的名称，`ref` 元素指的是另一个 bean 定义的名称。 `id` 和 `ref` 元素之间的这种联系表达了协作对象之间的依赖关系。 + +**Spring 支持通过多个 xml 文件来定义 Bean，每个单独的 XML 配置文件都代表架构中的一个逻辑层或模块。可以使用 `ApplicationContext` 构造函数从所有这些 XML 片段加载 bean 定义。或者，使用 `` 元素从另一个或多个文件加载 bean 定义**。如下所示： + +```xml + + + + + + + + +``` + +在上面的示例中，外部 bean 定义从三个文件加载：`services.xml`、`messageSource.xml` 和 `themeSource.xml`。`services.xml` 文件必须和当前 xml 文件位于同一目录或类路径位置；而 `messageSource.xml` 和 `themeSource.xml` 必须位于当前文件所在目录的子目录 `resources` 下。`/resources` 的 `/` 会被忽略。但是，鉴于这些路径是相对的，最好不要使用 `/`。根据 Spring Schema，被导入文件的内容，包括顶级 `` 元素，必须是有效的 XML bean 定义。 + +> 注意： +> +> 可以，但不推荐使用相对 `“../”` 路径来引用父目录中的文件。这样做会创建对当前应用程序之外的文件的依赖。特别是，不建议将此引用用于 `classpath`：URL（例如， `classpath:../services.xml`），其中运行时解析过程会选择“最近的”类路径根，然后查看其父目录。类路径配置更改可能会导致选择不同的、不正确的目录。 +> +> 可以使用完全限定的资源位置而不是相对路径：例如，`file:C:/config/services.xml` 或 `classpath:/config/services.xml`。建议为此类绝对路径保留一定的间接性 — 例如，通过 `“${...}”` 占位符来引用运行时指定的 JVM 参数。 + +命名空间本身提供了导入指令功能。 Spring 提供的一系列 XML 命名空间中提供了除了普通 bean 定义之外的更多配置特性 — 例如，`context` 和 `util` 命名空间。 + +### 使用容器 + +`ApplicationContext` 能够维护不同 bean 及其依赖项的注册表。通过**使用方法 `T getBean(String name, Class T requiredType)`，可以检索并获取 bean 的实例**。 + +`ApplicationContext` 允许读取 bean 定义并访问它们，如以下示例所示： + +```java +// create and configure beans +ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml"); + +// retrieve configured instance +PetStoreService service = context.getBean("petStore", PetStoreService.class); + +// use configured instance +List userList = service.getUsernameList(); +``` + +最灵活的变体是 `GenericApplicationContext` 结合阅读器委托 — 例如，结合 XML 文件的 `XmlBeanDefinitionReader`，如下例所示： + +```java +GenericApplicationContext context = new GenericApplicationContext(); +new XmlBeanDefinitionReader(context).loadBeanDefinitions("services.xml", "daos.xml"); +context.refresh(); +``` + +可以在同一个 `ApplicationContext` 上混合和匹配此类读取器委托，从不同的配置源读取 bean 定义。 + +然后，可以使用 `getBean` 检索 bean 的实例。 `ApplicationContext` 接口还有一些其他方法用于检索 bean，但理想情况下，应用程序代码不应该使用它们。实际上，应用程序代码根本不应该调用 `getBean()` 方法，因此根本不依赖 Spring API。例如，Spring 与 Web 框架的集成为各种 Web 框架组件（例如控制器和 JSF 管理的 bean）提供了依赖注入，让您可以通过元数据（例如自动装配注释）声明对特定 bean 的依赖。 + +## IoC 依赖来源 + +自定义 Bean + +容器内建 Bean 对象 + +容器内建依赖 + +## IoC 配置元数据 + +IoC 容器的配置有三种方式： + +- 基于 xml 配置 +- 基于 properties 配置 +- 基于注解配置 +- 基于 Java 配置 + +作为 Spring 传统的配置方式，xml 配置方式一般为大家所熟知。 + +如果厌倦了 xml 配置，Spring 也提供了注解配置方式或 Java 配置方式来简化配置。 + +**本文，将对 Java 配置 IoC 容器做详细的介绍。** + +### Xml 配置 + +```xml + + + + + + + + + + +``` + +标签说明： + +- `` 是 Spring 配置文件的根节点。 +- `` 用来定义一个 JavaBean。`id` 属性是它的标识，在文件中必须唯一；`class` 属性是它关联的类。 +- `` 用来定义 Bean 的别名。 +- `` 用来导入其他配置文件的 Bean 定义。这是为了加载多个配置文件，当然也可以把这些配置文件构造为一个数组（new String[] {“config1.xml”, config2.xml}）传给 `ApplicationContext` 实现类进行加载多个配置文件，那一个更适合由用户决定；这两种方式都是通过调用 Bean Definition Reader 读取 Bean 定义，内部实现没有任何区别。`` 标签可以放在 `` 下的任何位置，没有顺序关系。 + +#### 实例化容器 + +实例化容器的过程： +定位资源（XML 配置文件） +读取配置信息(Resource) +转化为 Spring 可识别的数据形式（BeanDefinition） + +```java +ApplicationContext context = + new ClassPathXmlApplicationContext(new String[] {"services.xml", "daos.xml"}); +``` + +组合 xml 配置文件 +配置的 Bean 功能各不相同，都放在一个 xml 文件中，不便管理。 +Java 设计模式讲究职责单一原则。配置其实也是如此，功能不同的 JavaBean 应该被组织在不同的 xml 文件中。然后使用 import 标签把它们统一导入。 + +```xml + + +``` + +#### 使用容器 + +使用容器的方式就是通过`getBean`获取 IoC 容器中的 JavaBean。 +Spring 也有其他方法去获得 JavaBean，但是 Spring 并不推荐其他方式。 + +```java +// create and configure beans +ApplicationContext context = +new ClassPathXmlApplicationContext(new String[] {"services.xml", "daos.xml"}); +// retrieve configured instance +PetStoreService service = context.getBean("petStore", PetStoreService.class); +// use configured instance +List userList = service.getUsernameList(); +``` + +### 注解配置 + +Spring2.5 引入了注解。 +于是，一个问题产生了：**使用注解方式注入 JavaBean 是不是一定完爆 xml 方式？** +未必。正所谓，仁者见仁智者见智。任何事物都有其优缺点，看你如何取舍。来看看注解的优缺点： +**优点**：大大减少了配置，并且可以使配置更加精细——类，方法，字段都可以用注解去标记。 +**缺点**：使用注解，不可避免产生了侵入式编程，也产生了一些问题。 + +- 你需要将注解加入你的源码并编译它； + +- 注解往往比较分散，不易管控。 + +> 注：spring 中，先进行注解注入，然后才是 xml 注入，因此如果注入的目标相同，后者会覆盖前者。 + +#### 启动注解 + +Spring 默认是不启用注解的。如果想使用注解，需要先在 xml 中启动注解。 +启动方式：在 xml 中加入一个标签，很简单吧。 + +```xml + +``` + +> 注：`` 只会检索定义它的上下文。什么意思呢？就是说，如果你 +> 为 DispatcherServlet 指定了一个`WebApplicationContext`，那么它只在 controller 中查找`@Autowired`注解，而不会检查其它的路径。 + +#### `@Required` + +`@Required` 注解只能用于修饰 bean 属性的 setter 方法。受影响的 bean 属性必须在配置时被填充在 xml 配置文件中，否则容器将抛出`BeanInitializationException`。 + +```java +public class AnnotationRequired { + private String name; + private String sex; + + public String getName() { + return name; + } + + /** + * @Required 注解用于bean属性的setter方法并且它指示，受影响的bean属性必须在配置时被填充在xml配置文件中， + * 否则容器将抛出BeanInitializationException。 + */ + @Required + public void setName(String name) { + this.name = name; + } + + public String getSex() { + return sex; + } + + public void setSex(String sex) { + this.sex = sex; + } +} +``` + +#### `@Autowired` + +`@Autowired`注解可用于修饰属性、setter 方法、构造方法。 + +@Autowired 注入过程 + +- 元信息解析 +- 依赖查找 +- 依赖注入（字段、方法） + +> 注：`@Autowired`注解也可用于修饰构造方法，但如果类中只有默认构造方法，则没有必要。如果有多个构造器，至少应该修饰一个，来告诉容器哪一个必须使用。 + +可以使用 JSR330 的注解`@Inject`来替代`@Autowired`。 + +**_范例_** + +```java +public class AnnotationAutowired { + private static final Logger log = LoggerFactory.getLogger(AnnotationRequired.class); + + @Autowired + private Apple fieldA; + + private Banana fieldB; + + private Orange fieldC; + + public Apple getFieldA() { + return fieldA; + } + + public void setFieldA(Apple fieldA) { + this.fieldA = fieldA; + } + + public Banana getFieldB() { + return fieldB; + } + + @Autowired + public void setFieldB(Banana fieldB) { + this.fieldB = fieldB; + } + + public Orange getFieldC() { + return fieldC; + } + + public void setFieldC(Orange fieldC) { + this.fieldC = fieldC; + } + + public AnnotationAutowired() {} + + @Autowired + public AnnotationAutowired(Orange fieldC) { + this.fieldC = fieldC; + } + + public static void main(String[] args) throws Exception { + AbstractApplicationContext ctx = + new ClassPathXmlApplicationContext("spring/spring-annotation.xml"); + + AnnotationAutowired annotationAutowired = + (AnnotationAutowired) ctx.getBean("annotationAutowired"); + log.debug("fieldA: {}, fieldB:{}, fieldC:{}", annotationAutowired.getFieldA().getName(), + annotationAutowired.getFieldB().getName(), + annotationAutowired.getFieldC().getName()); + ctx.close(); + } +} +``` + +xml 中的配置 + +```xml + + + + + +``` + +#### `@Qualifier` + +在`@Autowired`注解中，提到了如果发现有多个候选的 bean 都符合修饰类型，Spring 就会抓瞎了。 + +那么，如何解决这个问题。 + +可以通过`@Qualifier`指定 bean 名称来锁定真正需要的那个 bean。 + +**_范例_** + +```java +public class AnnotationQualifier { + private static final Logger log = LoggerFactory.getLogger(AnnotationQualifier.class); + + @Autowired + @Qualifier("dog") /** 去除这行，会报异常 */ + Animal dog; + + Animal cat; + + public Animal getDog() { + return dog; + } + + public void setDog(Animal dog) { + this.dog = dog; + } + + public Animal getCat() { + return cat; + } + + @Autowired + public void setCat(@Qualifier("cat") Animal cat) { + this.cat = cat; + } + + public static void main(String[] args) throws Exception { + AbstractApplicationContext ctx = + new ClassPathXmlApplicationContext("spring/spring-annotation.xml"); + + AnnotationQualifier annotationQualifier = + (AnnotationQualifier) ctx.getBean("annotationQualifier"); + + log.debug("Dog name: {}", annotationQualifier.getDog().getName()); + log.debug("Cat name: {}", annotationQualifier.getCat().getName()); + ctx.close(); + } +} + +abstract class Animal { + public String getName() { + return null; + } +} + +class Dog extends Animal { + public String getName() { + return "狗"; + } +} + +class Cat extends Animal { + public String getName() { + return "猫"; + } +} +``` + +xml 中的配置 + +```xml + + + + +``` + +#### `@Resource` + +Spring 支持 JSP250 规定的注解`@Resource`。这个注解根据指定的名称来注入 bean。 + +如果没有为`@Resource`指定名称，它会像`@Autowired`一样按照类型去寻找匹配。 + +在 Spring 中，由`CommonAnnotationBeanPostProcessor`来处理`@Resource`注解。 + +**_范例_** + +```java +public class AnnotationResource { + private static final Logger log = LoggerFactory.getLogger(AnnotationResource.class); + + @Resource(name = "flower") + Plant flower; + + @Resource(name = "tree") + Plant tree; + + public Plant getFlower() { + return flower; + } + + public void setFlower(Plant flower) { + this.flower = flower; + } + + public Plant getTree() { + return tree; + } + + public void setTree(Plant tree) { + this.tree = tree; + } + + public static void main(String[] args) throws Exception { + AbstractApplicationContext ctx = + new ClassPathXmlApplicationContext("spring/spring-annotation.xml"); + + AnnotationResource annotationResource = + (AnnotationResource) ctx.getBean("annotationResource"); + log.debug("type: {}, name: {}", annotationResource.getFlower().getClass(), annotationResource.getFlower().getName()); + log.debug("type: {}, name: {}", annotationResource.getTree().getClass(), annotationResource.getTree().getName()); + ctx.close(); + } +} +``` + +xml 的配置 + +```xml + + + + +``` + +#### `@PostConstruct` 和 `@PreDestroy` + +`@PostConstruct` 和 `@PreDestroy` 是 JSR 250 规定的用于生命周期的注解。 + +从其名号就可以看出，一个是在构造之后调用的方法，一个是销毁之前调用的方法。 + +```java +public class AnnotationPostConstructAndPreDestroy { + private static final Logger log = LoggerFactory.getLogger(AnnotationPostConstructAndPreDestroy.class); + + @PostConstruct + public void init() { + log.debug("call @PostConstruct method"); + } + + @PreDestroy + public void destroy() { + log.debug("call @PreDestroy method"); + } +} +``` + +#### `@Inject` + +从 Spring3.0 开始，Spring 支持 JSR 330 标准注解（依赖注入）。 + +注：如果要使用 JSR 330 注解，需要使用外部 jar 包。 + +若你使用 maven 管理 jar 包，只需要添加依赖到 pom.xml 即可： + +```xml + + javax.inject + javax.inject + 1 + +``` + +`@Inject` 和 `@Autowired` 一样，可以修饰属性、setter 方法、构造方法。 + +**_范例_** + +```java +public class AnnotationInject { + private static final Logger log = LoggerFactory.getLogger(AnnotationInject.class); + @Inject + Apple fieldA; + + Banana fieldB; + + Orange fieldC; + + public Apple getFieldA() { + return fieldA; + } + + public void setFieldA(Apple fieldA) { + this.fieldA = fieldA; + } + + public Banana getFieldB() { + return fieldB; + } + + @Inject + public void setFieldB(Banana fieldB) { + this.fieldB = fieldB; + } + + public Orange getFieldC() { + return fieldC; + } + + public AnnotationInject() {} + + @Inject + public AnnotationInject(Orange fieldC) { + this.fieldC = fieldC; + } + + public static void main(String[] args) throws Exception { + AbstractApplicationContext ctx = + new ClassPathXmlApplicationContext("spring/spring-annotation.xml"); + AnnotationInject annotationInject = (AnnotationInject) ctx.getBean("annotationInject"); + + log.debug("type: {}, name: {}", annotationInject.getFieldA().getClass(), + annotationInject.getFieldA().getName()); + + log.debug("type: {}, name: {}", annotationInject.getFieldB().getClass(), + annotationInject.getFieldB().getName()); + + log.debug("type: {}, name: {}", annotationInject.getFieldC().getClass(), + annotationInject.getFieldC().getName()); + + ctx.close(); + } +} +``` + +### Java 配置 + +基于 Java 配置 Spring IoC 容器，实际上是**Spring 允许用户定义一个类，在这个类中去管理 IoC 容器的配置**。 + +为了让 Spring 识别这个定义类为一个 Spring 配置类，需要用到两个注解：`@Configuration`和`@Bean`。 + +如果你熟悉 Spring 的 xml 配置方式，你可以将`@Configuration`等价于``标签；将`@Bean`等价于``标签。 + +#### `@Bean` + +@Bean 的修饰目标只能是方法或注解。 + +@Bean 只能定义在 `@Configuration` 或 `@Component` 注解修饰的类中。 + +#### 声明一个 bean + +此外，@Configuration 类允许在同一个类中通过@Bean 定义内部 bean 依赖。 + +声明一个 bean，只需要在 bean 属性的 set 方法上标注@Bean 即可。 + +```java +@Configuration +public class AnnotationConfiguration { + private static final Logger log = LoggerFactory.getLogger(JavaComponentScan.class); + + @Bean + public Job getPolice() { + return new Police(); + } + + public static void main(String[] args) { + AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(AnnotationConfiguration.class); + ctx.scan("org.zp.notes.spring.beans"); + ctx.refresh(); + Job job = (Job) ctx.getBean("police"); + log.debug("job: {}, work: {}", job.getClass(), job.work()); + } +} + +public interface Job { + String work(); +} + +@Component("police") +public class Police implements Job { + @Override + public String work() { + return "抓罪犯"; + } +} +``` + +这等价于配置 + +```xml + + + +``` + +@Bean 注解用来表明一个方法实例化、配置合初始化一个被 Spring IoC 容器管理的新对象。 + +如果你熟悉 Spring 的 xml 配置，你可以将@Bean 视为等价于``标签。 + +@Bean 注解可以用于任何的 Spring `@Component` bean，然而，通常被用于`@Configuration` bean。 + +#### `@Configuration` + +`@Configuration` 是一个类级别的注解，用来标记被修饰类的对象是一个`BeanDefinition`。 + +`@Configuration` 声明 bean 是通过被 `@Bean` 修饰的公共方法。此外，`@Configuration` 允许在同一个类中通过 `@Bean` 定义内部 bean 依赖。 + +```java +@Configuration +public class AppConfig { + @Bean + public MyService myService() { + return new MyServiceImpl(); + } +} +``` + +这等价于配置 + +```xml + + + +``` + +用 `AnnotationConfigApplicationContext` 实例化 IoC 容器。 + +## 依赖解决过程 + +容器执行 bean 依赖解析如下： + +- `ApplicationContext` 使用配置元数据创建和初始化 Bean。配置元数据可以由 XML、Java 代码或注解指定。 +- 对于每个 bean，其依赖关系以属性、构造函数参数或静态工厂方法的参数的形式表示。这些依赖项在实际创建 bean 时提供给 bean。 +- 每个属性或构造函数参数都是要设置的值的实际定义，或者是对容器中另一个 bean 的引用。 +- 作为值的每个属性或构造函数参数都从其指定格式转换为该属性或构造函数参数的实际类型。默认情况下，Spring 可以将以字符串格式提供的值转换为所有内置类型，例如 int、long、String、boolean 等。 + +Spring 容器在创建容器时验证每个 bean 的配置。但是，在实际创建 bean 之前，不会设置 bean 属性本身。在创建容器时会创建 singleton 型的实例并设置为默认的 Bean。否则，只有在请求时才会创建 bean。 + +需注意：构造器注入，可能会导致无法解决循环依赖问题。 + +例如：A 类通过构造器注入需要 B 类的实例，B 类通过构造器注入需要 A 类的实例。Spring IoC 容器会在运行时检测到此循环引用，并抛出 `BeanCurrentlyInCreationException`。 + +一种解决方案是使用 setter 方法注入替代构造器注入。 + +另一种解决方案是：bean A 和 bean B 之间的循环依赖关系，强制其中一个 bean 在完全初始化之前注入另一个 bean（典型的先有鸡还是先有蛋的场景）。 + +Spring 会在容器加载时检测配置问题，例如引用不存在的 bean 或循环依赖。在实际创建 bean 时，Spring 会尽可能晚地设置属性并解析依赖关系。这意味着，如果在创建该对象或其依赖项之一时出现问题，则正确加载的 Spring 容器稍后可以在您请求对象时生成异常 — 例如，bean 由于丢失或无效而引发异常。某些配置问题的这种潜在的延迟可见性是默认情况下 ApplicationContext 实现预实例化单例 bean 的原因。以在实际需要之前创建这些 bean 的一些前期时间和内存为代价，您会在创建 ApplicationContext 时发现配置问题，而不是稍后。您仍然可以覆盖此默认行为，以便单例 bean 延迟初始化，而不是急切地预先实例化。 + +## 最佳实践 + +### singleton 的 Bean 如何注入 prototype 的 Bean + +Spring 创建的 Bean 默认是单例的，但当 Bean 遇到继承的时候，可能会忽略这一点。 + +假设有一个 SayService 抽象类，其中维护了一个类型是 ArrayList 的字段 data，用于保存方法处理的中间数据。每次调用 say 方法都会往 data 加入新数据，可以认为 SayService 是有状态，如果 SayService 是单例的话必然会 OOM。 + +```java +/** + * SayService 是有状态，如果 SayService 是单例的话必然会 OOM + */ +@Slf4j +public abstract class SayService { + + List data = new ArrayList<>(); + + public void say() { + data.add(IntStream.rangeClosed(1, 1000000) + .mapToObj(__ -> "a") + .collect(Collectors.joining("")) + UUID.randomUUID().toString()); + log.info("I'm {} size:{}", this, data.size()); + } + +} +``` + +但实际开发的时候，开发同学没有过多思考就把 SayHello 和 SayBye 类加上了 @Service 注解，让它们成为了 Bean，也没有考虑到父类是有状态的。 + +```java +@Service +@Slf4j +public class SayBye extends SayService { + + @Override + public void say() { + super.say(); + log.info("bye"); + } + +} + +@Service +@Slf4j +public class SayHello extends SayService { + + @Override + public void say() { + super.say(); + log.info("hello"); + } + +} +``` + +在为类标记上 @Service 注解把类型交由容器管理前，首先评估一下类是否有状态，然后为 Bean 设置合适的 Scope。 + +调用代码： + +```java +@Slf4j +@RestController +@RequestMapping("beansingletonandorder") +public class BeanSingletonAndOrderController { + + @Autowired + List sayServiceList; + @Autowired + private ApplicationContext applicationContext; + + @GetMapping("test") + public void test() { + log.info("===================="); + sayServiceList.forEach(SayService::say); + } + +} +``` + +可能有人认为，为 SayHello 和 SayBye 两个类都标记了 @Scope 注解，设置了 PROTOTYPE 的生命周期就可以解决上面的问题。 + +```java +@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE) +``` + +但实际上还是有问题。因为@RestController 注解 =@Controller 注解 +@ResponseBody 注解，又因为 @Controller 标记了 @Component 元注解，所以 @RestController 注解其实也是一个 Spring Bean。 + +Bean 默认是单例的，所以单例的 Controller 注入的 Service 也是一次性创建的，即使 Service 本身标识了 prototype 的范围也没用。 + +修复方式是，让 Service 以代理方式注入。这样虽然 Controller 本身是单例的，但每次都能从代理获取 Service。这样一来，prototype 范围的配置才能真正生效。 + +```java +@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE, proxyMode = ScopedProx) +``` + +## 参考资料 + +- [Spring 官方文档之 Core Technologies](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans) +- [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/03.Spring\344\276\235\350\265\226\346\237\245\346\211\276.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/03.Spring\344\276\235\350\265\226\346\237\245\346\211\276.md" new file mode 100644 index 00000000..0d1fa338 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/03.Spring\344\276\235\350\265\226\346\237\245\346\211\276.md" @@ -0,0 +1,149 @@ +--- +title: Spring 依赖查找 +date: 2020-08-30 16:06:10 +order: 03 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring + - IOC + - 依赖查找 +permalink: /pages/9a6f6b/ +--- + +# Spring 依赖查找 + +**依赖查找是主动或手动的依赖查找方式，通常需要依赖容器或标准 API 实现**。 + +IoC 依赖查找大致可以分为以下几类： + +- 根据 Bean 名称查找 +- 根据 Bean 类型查找 +- 根据 Bean 名称 + 类型查找 +- 根据 Java 注解查找 + +此外，根据查找的 Bean 对象是单一或集合对象，是否需要延迟查找等特定常见，有相应不同的 API。 + +## 单一类型依赖查找 + +单一类型依赖查找接口- `BeanFactory` + +- 根据 Bean 名称查找 + - `getBean(String)` + - Spring 2.5 覆盖默认参数：`getBean(String,Object...)` +- 根据 Bean 类型查找 + - Bean 实时查找 + - Spring 3.0 `getBean(Class)` + - Spring 4.1 覆盖默认参数：`getBean(Class,Object...)` + - Spring 5.1 Bean 延迟查找 + - `getBeanProvider(Class)` + - `getBeanProvider(ResolvableType)` +- 根据 Bean 名称 + 类型查找：`getBean(String,Class)` + +## 集合类型依赖查找 + +集合类型依赖查找接口- `ListableBeanFactory` + +- 根据 Bean 类型查找 + - 获取同类型 Bean 名称列表 + - `getBeanNamesForType(Class)` + - Spring 4.2 `getBeanNamesForType(ResolvableType)` + - 获取同类型 Bean 实例列表 + - `getBeansOfType(Class)` 以及重载方法 +- 通过注解类型查找 + + - Spring 3.0 获取标注类型 Bean 名称列表 + + - `getBeanNamesForAnnotation(Class)` + + - Spring 3.0 获取标注类型 Bean 实例列表 + + - `getBeansWithAnnotation(Class)` + + - Spring 3.0 获取指定名称+ 标注类型 Bean 实例 + + - `findAnnotationOnBean(String,Class)` + +## 层次性依赖查找 + +层次性依赖查找接口- `HierarchicalBeanFactory` + +- 双亲 `BeanFactory`：`getParentBeanFactory()` +- 层次性查找 + - 根据 Bean 名称查找 + - 基于 `containsLocalBean` 方法实现 + - 根据 Bean 类型查找实例列表 + - 单一类型：`BeanFactoryUtils#beanOfType` + - 集合类型：`BeanFactoryUtils#beansOfTypeIncludingAncestors` + - 根据 Java 注解查找名称列表 + - `BeanFactoryUtils#beanNamesForTypeIncludingAncestors` + +## 延迟依赖查找 + +Bean 延迟依赖查找接口 + +- `org.springframework.beans.factory.ObjectFactory` +- `org.springframework.beans.factory.ObjectProvider`（Spring 5 对 Java 8 特性扩展） +- 函数式接口 + - `getIfAvailable(Supplier)` + - `ifAvailable(Consumer)` +- Stream 扩展- stream() + +## 安全依赖查找 + +| 依赖查找类型 | 代表实现 | 是否安全 | +| ------------ | ------------------------------------ | -------- | +| 单一类型查找 | `BeanFactory#getBean` | 否 | +| | `ObjectFactory#getObject` | 否 | +| | `ObjectProvider#getIfAvailable` | 是 | +| | | | +| 集合类型查找 | `ListableBeanFactory#getBeansOfType` | 是 | +| | `ObjectProvider#stream` | 是 | + +注意：层次性依赖查找的安全性取决于其扩展的单一或集合类型的 `BeanFactory` 接口 + +## 内建可查找的依赖 + +`AbstractApplicationContext` 内建可查找的依赖 + +| Bean | 名称 Bean | 实例使用场景 | +| --------------------------- | -------------------------------- | ----------------------- | +| environment | Environment 对象 | 外部化配置以及 Profiles | +| systemProperties | java.util.Properties 对象 | Java 系统属性 | +| systemEnvironment | java.util.Map 对象 | 操作系统环境变量 | +| messageSource | MessageSource 对象 | 国际化文案 | +| lifecycleProcessor | LifecycleProcessor 对象 | Lifecycle Bean 处理器 | +| applicationEventMulticaster | ApplicationEventMulticaster 对象 | Spring 事件广播器 | + +注解驱动 Spring 应用上下文内建可查找的依赖（部分） + +| Bean 名称 | Bean 实例 | 使用场景 | +| ------------------------------------------------------------------------------- | ------------------------------------------- | ----------------------------------------------------- | +| org.springframework.context.annotation.internalConfigurationAnnotationProcessor | ConfigurationClassPostProcessor 对象 | 处理 Spring 配置类 | +| org.springframework.context.annotation.internalAutowiredAnnotationProcessor | AutowiredAnnotationBeanPostProcessor 对象 | 处理@Autowired 以及@Value 注解 | +| org.springframework.context.annotation.internalCommonAnnotationProcessor | CommonAnnotationBeanPostProcessor 对象 | （条件激活）处理 JSR-250 注解，如@PostConstruct 等 | +| org.springframework.context.event.internalEventListenerProcessor | EventListenerMethodProcessor 对象 | 处理标注@EventListener 的 Spring 事件监听方法 | +| org.springframework.context.event.internalEventListenerFactory | DefaultEventListenerFactory 对象 | @EventListener 事件监听方法适配为 ApplicationListener | +| org.springframework.context.annotation.internalPersistenceAnnotationProcessor | PersistenceAnnotationBeanPostProcessor 对象 | （条件激活）处理 JPA 注解场景 | + +## 依赖查找中的经典异常 + +`BeansException` 子类型 + +| 异常类型 | 触发条件（举例） | 场景举例 | +| --------------------------------- | ------------------------------------------ | -------------------------------------------- | +| `NoSuchBeanDefinitionException` | 当查找 Bean 不存在于 IoC 容器时 | `BeanFactory#getBeanObjectFactory#getObject` | +| `NoUniqueBeanDefinitionException` | 类型依赖查找时，IoC 容器存在多个 Bean 实例 | `BeanFactory#getBean(Class)` | +| `BeanInstantiationException` | 当 Bean 所对应的类型非具体类时 | `BeanFactory#getBean` | +| `BeanCreationException` | 当 Bean 初始化过程中 | Bean 初始化方法执行异常时 | +| `BeanDefinitionStoreException` | 当 `BeanDefinition` 配置元信息非法时 | XML 配置资源无法打开时 | + +## 参考资料 + +- [Spring 官方文档之 Core Technologies](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans) +- [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/04.Spring\344\276\235\350\265\226\346\263\250\345\205\245.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/04.Spring\344\276\235\350\265\226\346\263\250\345\205\245.md" new file mode 100644 index 00000000..c44e438f --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/04.Spring\344\276\235\350\265\226\346\263\250\345\205\245.md" @@ -0,0 +1,378 @@ +--- +title: Spring 依赖注入 +date: 2020-08-30 16:06:10 +order: 04 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring + - IOC + - 依赖注入 +permalink: /pages/f61a1c/ +--- + +# Spring 依赖注入 + +DI，是 Dependency Injection 的缩写，即依赖注入。依赖注入是 IoC 的最常见形式。依赖注入是手动或自动绑定的方式，无需依赖特定的容器或 API。 + +依赖注入 (Dependency Injection，简称 DI) 是一个过程，其中对象仅通过构造函数参数、工厂方法的参数或对象实例在构造或从工厂方法返回。然后容器在创建 bean 时注入这些依赖项。这个过程基本上是 bean 本身的逆过程（因此得名，控制反转），它通过使用类的直接构造或服务定位器模式自行控制其依赖项的实例化或位置。 + +使用 DI，代码更干净，当对象具有依赖关系时，解耦更有效。对象不查找其依赖项，也不知道依赖项的位置或类别。结果，您的类变得更容易测试，特别是当依赖关系在接口或抽象基类上时，它们允许在单元测试中使用存根或模拟实现。 + +**容器全权负责组件的装配，它会把符合依赖关系的对象通过 JavaBean 属性或者构造函数传递给需要的对象**。 + +DI 是组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。 + +理解 DI 的关键是：“谁依赖谁，为什么需要依赖，谁注入谁，注入了什么”，那我们来深入分析一下： + +- **谁依赖于谁：**当然是应用程序依赖于 IoC 容器； +- **为什么需要依赖：**应用程序需要 IoC 容器来提供对象需要的外部资源； +- **谁注入谁：**很明显是 IoC 容器注入应用程序某个对象，应用程序依赖的对象； +- **注入了什么**：就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。 + +## IoC 依赖注入 API + +- 根据 Bean 名称注入 +- 根据 Bean 类型注入 +- 注入容器内建 Bean 对象 +- 注入非 Bean 对象 +- 注入类型 + - 实时注入 + - 延迟注入 + +## 依赖注入模式 + +依赖注入模式可以分为手动注入模式和自动注入模式。 + +### 手动注入模式 + +手动注入模式：配置或者编程的方式，提前安排注入规则 + +- XML 资源配置元信息 +- Java 注解配置元信息 +- API 配置元信息 + +### 自动注入模式 + +自动注入模式即自动装配。自动装配（Autowiring）是指 Spring 容器可以自动装配 Bean 之间的关系。Spring 可以通过检查 `ApplicationContext` 的内容，自动解析合作者（其他 Bean）。 + +- 自动装配可以显著减少属性或构造函数参数的配置。 +- 随着对象的发展，自动装配可以更新配置。 + +> 注：由于自动装配存在一些限制和不足，官方不推荐使用。 + +#### 自动装配策略 + +当使用基于 XML 的配置元数据时，可以使用 `` 元素的 `autowire` 属性为 Bean 指定自动装配模式。自动装配模式有以下类型： + +| 模式 | 说明 | +| ------------- | ---------------------------------------------------------------------- | +| `no` | 默认值，未激活 Autowiring，需要手动指定依赖注入对象。 | +| `byName` | 根据被注入属性的名称作为 Bean 名称进行依赖查找，并将对象设置到该属性。 | +| `byType` | 根据被注入属性的类型作为依赖类型进行查找，并将对象设置到该属性。 | +| `constructor` | 特殊 byType 类型，用于构造器参数。 | + +`org.springframework.beans.factory.config.AutowireCapableBeanFactory` 是 `BeanFactory` 的子接口，它是 Spring 中用于实现自动装配的容器。 + +#### @Autowired 注入过程 + +- 元信息解析 +- 依赖查找 +- 依赖注入（字段、方法） + +#### 自动装配的限制和不足 + +自动装配有以下限制和不足： + +- 属性和构造函数参数设置中的显式依赖项会覆盖自动装配。您不能自动装配简单属性，例如基础数据类型、字符串和类（以及此类简单属性的数组）。 +- 自动装配不如显式装配精准。Spring 会尽量避免猜测可能存在歧义的结果。 +- Spring 容器生成文档的工具可能无法解析自动装配信息。 +- 如果同一类型存在多个 Bean 时，自动装配时会存在歧义。容器内的多个 Bean 定义可能与要自动装配的 Setter 方法或构造函数参数指定的类型匹配。对于数组、集合或 Map 实例，这不一定是问题。但是，对于期望单值的依赖项，如果没有唯一的 Bean 定义可用，则会引发异常。 + +> 自动装配的限制和不足，详情可以参考官方文档：[Limitations and Disadvantages of Autowiring 小节](https://docs.spring.io/spring/docs/5.2.2.RELEASE/spring-frameworkreference/core.html#beans-autowired-exceptions) + +## 依赖注入方式 + +依赖注入有如下方式： + +| 依赖注入方式 | 配置元数据举例 | +| --------------- | -------------------------------------------------- | +| Setter 方法注入 | `` | +| 构造器注入 | `` | +| 字段注入 | `@Autowired User user;` | +| 方法注入 | `@Autowired public void user(User user) { ... }` | +| 接口回调注入 | `class MyBean implements BeanFactoryAware { ... }` | + +### 构造器注入 + +- 手动模式 + - xml 配置元信息 + - 注解配置元信息 + - Java 配置元信息 +- 自动模式 + - constructor + +构造器注入是通过容器调用具有多个参数的构造函数来完成的，每个参数代表一个依赖项。调用带有特定参数的静态工厂方法来构造 bean 几乎是等价的，并且本次讨论对构造函数和静态工厂方法的参数进行了类似的处理。 + +下面是一个构造器注入示例： + +```java +public class SimpleMovieLister { + + // the SimpleMovieLister has a dependency on a MovieFinder + private final MovieFinder movieFinder; + + // a constructor so that the Spring container can inject a MovieFinder + public SimpleMovieLister(MovieFinder movieFinder) { + this.movieFinder = movieFinder; + } + + // business logic that actually uses the injected MovieFinder is omitted... +} +``` + +构造函数参数解析匹配通过使用参数的类型进行。如果 bean 定义的构造函数参数中不存在潜在的歧义，则在 bean 定义中定义构造函数参数的顺序是在实例化 bean 时将这些参数提供给适当构造函数的顺序。 + +``` +package x.y; + +public class ThingOne { + + public ThingOne(ThingTwo thingTwo, ThingThree thingThree) { + // ... + } +} +``` + +假设 ThingTwo 和 ThingThree 类没有继承关系，则不存在潜在的歧义。因此，以下配置工作正常，您无需在 `` 元素中显式指定构造函数参数索引或类型。 + +```xml + + + + + + + + + + +``` + +当引用另一个 bean 时，类型是已知的，并且可以发生匹配（就像前面的示例一样）。当使用简单类型时，例如 `true` ，Spring 无法确定 value 的类型，因此无法在没有帮助的情况下按类型匹配。考虑以下类： + +```java +package examples; + +public class ExampleBean { + + // Number of years to calculate the Ultimate Answer + private final int years; + + // The Answer to Life, the Universe, and Everything + private final String ultimateAnswer; + + public ExampleBean(int years, String ultimateAnswer) { + this.years = years; + this.ultimateAnswer = ultimateAnswer; + } +} +``` + +构造函数参数类型匹配 + +在上述场景中，如果您使用 type 属性显式指定构造函数参数的类型，则容器可以使用简单类型的类型匹配，如以下示例所示： + +```xml + + + + +``` + +构造函数参数索引匹配 + +可以使用 `index` 属性显式指定构造函数参数的索引，如以下示例所示 + +```xml + + + + +``` + +构造函数参数名称匹配 + +```xml + + + + +``` + +可以使用 `@ConstructorProperties` 显式命名构造函数参数。 + +```java +package examples; + +public class ExampleBean { + + // Fields omitted + + @ConstructorProperties({"years", "ultimateAnswer"}) + public ExampleBean(int years, String ultimateAnswer) { + this.years = years; + this.ultimateAnswer = ultimateAnswer; + } +} +``` + +### Setter 方法注入 + +- 手动模式 + - xml 配置元信息 + - 注解配置元信息 + - Java 配置元信息 +- 自动模式 + - byName + - byType + +Setter 方法注入是通过容器在调用无参数构造函数或无参数静态工厂方法来实例化 bean 后调用 bean 上的 setter 方法来完成的。 + +以下示例显示了一个只能通过使用纯 setter 注入进行依赖注入的类。 + +```java +public class SimpleMovieLister { + + // the SimpleMovieLister has a dependency on the MovieFinder + private MovieFinder movieFinder; + + // a setter method so that the Spring container can inject a MovieFinder + public void setMovieFinder(MovieFinder movieFinder) { + this.movieFinder = movieFinder; + } + + // business logic that actually uses the injected MovieFinder is omitted... +} +``` + +在 Spring 中，可以混合使用构造器注入和 setter 方法注入。建议将构造器注入用于强制依赖项；并将 setter 方法注入或配置方法用于可选依赖项。需要注意的是，在 setter 方法上使用 `@Required` 注解可用于使属性成为必需的依赖项；然而，更建议使用构造器注入来完成这项工作。 + +### 字段注入 + +手动模式（Java 注解配置元信息） + +- `@Autowired` +- `@Resource` +- `@Inject`（可选） + +### 方法注入 + +手动模式（Java 注解配置元信息） + +- `@Autowired` +- `@Resource` +- `@Inject`（可选） +- `@Bean` + +### 接口回调注入 + +Aware 系列接口回调 + +| 內建接口 | 说明 | +| -------------------------------- | ---------------------------------------------------------- | +| `BeanFactoryAware` | 获取 IoC 容器- `BeanFactory` | +| `ApplicationContextAware` | 获取 Spring 应用上下文- `ApplicationContext` 对象 | +| `EnvironmentAware` | 获取 `Environment` 对象 | +| `ResourceLoaderAware` | 获取资源加载器对象- `ResourceLoader` | +| `BeanClassLoaderAware` | 获取加载当前 Bean Class 的 `ClassLoader` | +| `BeanNameAware` | 获取当前 Bean 的名称 | +| `MessageSourceAware` | 获取 `MessageSource` 对象，用于 Spring 国际化 | +| `ApplicationEventPublisherAware` | 获取 `ApplicationEventPublishAware` 对象，用于 Spring 事件 | +| `EmbeddedValueResolverAware` | 获取 `StringValueResolver` 对象，用于占位符处理 | + +### 依赖注入选型 + +- 低依赖：构造器注入 +- 多依赖：Setter 方法注入 +- 便利性：字段注入 +- 声明类：方法注入 + +## 限定注入和延迟注入 + +### 限定注入 + +- 使用 `@Qualifier` 注解限定 + - 通过 Bean 名称限定 + - 通过分组限定 +- 通过 `@Qualifier` 注解扩展限定 + - 自定义注解：如 Spring Cloud 的 `@LoadBalanced` + +### 延迟注入 + +- 使用 `ObjectFactory` +- 使用 `ObjectProvider`（推荐） + +## 依赖注入数据类型 + +### 基础类型 + +- 基础数据类型：`boolean`、`byte`、`char`、`short`、`int`、`float`、`long`、`double` +- 标量类型：`Number`、`Character`、`Boolean`、`Enum`、`Locale`、`Charset`、`Currency`、`Properties`、`UUID` +- 常规类型：`Object`、`String`、`TimeZone`、`Calendar`、`Optional` 等 +- Spring 类型：`Resource`、`InputSource`、`Formatter` 等。 + +### 集合类型 + +数组类型：基础数据类型、标量类型、常规类型、String 类型的数组 + +集合类型： + +- `Collection`：`List`、`Set` +- `Map`：`Properties` + +## 依赖处理过程 + +入口：`DefaultListableBeanFactory#resolveDependency` + +依赖描述符：`DependencyDescriptor` + +自定义绑定候选对象处理器：`AutowireCandidateResolver` + +`@Autowired`、`@Value`、`@javax.inject.Inject` 处理器：`AutowiredAnnotationBeanPostProcessor` + +通用注解处理器：`CommonAnnotationBeanPostProcessor` + +- 注入注解 + - `javax.xml.ws.WebServiceRef` + - `javax.ejb.EJB` + - `javax.annotation.Resources` +- 生命周期注解 + - `javax.annotation.PostConstruct` + - `javax.annotation.PreDestroy` + +自定义依赖注入注解： + +- 生命周期处理 + - `InstantiationAwareBeanPostProcessor` + - `MergedBeanDefinitionPostProcessor` +- 元数据 + - `InjectionMetadata` + - `InjectionMetadata.InjectedElement` + +## 依赖查找 VS. 依赖注入 + +| 类型 | 依赖处理 | 实现复杂度 | 代码侵入性 | API 依赖性 | 可读性 | +| -------- | -------- | ---------- | ------------ | -------------- | ------ | +| 依赖查找 | 主动 | 相对繁琐 | 侵入业务逻辑 | 依赖容器 API | 良好 | +| 依赖注入 | 被动 | 相对便利 | 低侵入性 | 不依赖容器 API | 一般 | + +## 参考资料 + +- [Spring 官方文档之 Core Technologies](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans) +- [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/05.SpringIoC\344\276\235\350\265\226\346\235\245\346\272\220.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/05.SpringIoC\344\276\235\350\265\226\346\235\245\346\272\220.md" new file mode 100644 index 00000000..b633b853 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/05.SpringIoC\344\276\235\350\265\226\346\235\245\346\272\220.md" @@ -0,0 +1,124 @@ +--- +title: Spring IoC 依赖来源 +date: 2022-12-20 20:33:51 +order: 05 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring + - IOC + - 依赖注入 +permalink: /pages/a5f257/ +--- + +# Spring IoC 依赖来源 + +## 依赖查找的来源 + +查找来源 + +| 来源 | 配置元数据 | +| --------------------- | ---------------------------------------- | +| Spring BeanDefinition | `` | +| | `@Bean public User user() {...}` | +| | `BeanDefinitionBuilder` | +| 单例对象 | API 实现 | + +Spring 內建 BeanDefintion + +| Bean 名称 | Bean 实例 | 使用场景 | +| ------------------------------------------------------------------------------- | ----------------------------------------- | --------------------------------------------------- | +| org.springframework.context.annotation.internalConfigurationAnnotationProcessor | ConfigurationClassPostProcessor 对象 | 处理 Spring 配置类 | +| org.springframework.context.annotation.internalAutowiredAnnotationProcessor | AutowiredAnnotationBeanPostProcessor 对象 | 处理 @Autowired 以及 @Value 注解 | +| org.springframework.context.annotation.internalCommonAnnotationProcessor | CommonAnnotationBeanPostProcessor 对象 | （条件激活）处理 JSR-250 注解，如 @PostConstruct 等 | +| org.springframework.context.event.internalEventListenerProcessor | EventListenerMethodProcessor 对象 | 处理标注 @EventListener 的 Spring 事件监听方法 | + +Spring 內建单例对象 + +| Bean 名称 | Bean 实例 | 使用场景 | +| --------------------------- | -------------------------------- | ----------------------- | +| environment | Environment 对象 | 外部化配置以及 Profiles | +| systemProperties | java.util.Properties 对象 | Java 系统属性 | +| systemEnvironment | java.util.Map 对象 | 操作系统环境变量 | +| messageSource | MessageSource 对象 | 国际化文案 | +| lifecycleProcessor | LifecycleProcessor 对象 | Lifecycle Bean 处理器 | +| applicationEventMulticaster | ApplicationEventMulticaster 对象 | Spring 事件广播器 | + +## 依赖注入的来源 + +| 来源 | 配置元数据 | +| ---------------------- | ---------------------------------------- | +| Spring BeanDefinition | `` | +| | `@Bean public User user() {...}` | +| | `BeanDefinitionBuilder` | +| 单例对象 | API 实现 | +| 非 Spring 容器管理对象 | | + +## Spring 容器管理和游离对象 + +| 来源 | Spring Bean 对象 | 生命周期管理 | 配置元信息 | 使用场景 | +| --------------------- | ---------------- | ------------ | ---------- | ------------------ | +| Spring BeanDefinition | 是 | 是 | 有 | 依赖查找、依赖注入 | +| 单体对象 | 是 | 否 | 无 | 依赖查找、依赖注入 | +| Resolvable Dependency | 否 | 否 | 无 | 依赖注入 | + +## Spring BeanDefinition 作为依赖来源 + +- 元数据：`BeanDefinition` +- 注册：`BeanDefinitionRegistry#registerBeanDefinition` +- 类型：延迟和非延迟 +- 顺序：Bean 生命周期顺序按照注册顺序 + +## 单例对象作为依赖来源 + +- 要素 + - 来源：外部普通 Java 对象（不一定是 POJO） + - 注册：`SingletonBeanRegistry#registerSingleton` +- 限制 + - 无生命周期管理 + - 无法实现延迟初始化 Bean + +## 非 Spring 对象容器管理对象作为依赖来源 + +- 要素 + - 注册：`ConfigurableListableBeanFactory#registerResolvableDependency` +- 限制 + - 无生命周期管理 + - 无法实现延迟初始化 Bean + - 无法通过依赖查找 + +## 外部化配置作为依赖来源 + +- 要素 + - 类型：非常规 Spring 对象依赖来源 +- 限制 + - 无生命周期管理 + - 无法实现延迟初始化 Bean + - 无法通过依赖查找 + +## 问题 + +注入和查找的依赖来源是否相同？ + +否，依赖查找的来源仅限于 Spring `BeanDefinition` 以及单例对象，而依赖注入的来源还包括 Resolvable Dependency 以及 `@Value` 所标注的外部化配置 + +单例对象能在 IoC 容器启动后注册吗？ + +可以的，单例对象的注册与 `BeanDefinition` 不同，`BeanDefinition` 会被 `ConfigurableListableBeanFactory#freezeConfiguration()` 方法影响，从而冻结注册，单例对象则没有这个限制。 + +Spring 依赖注入的来源有哪些？ + +- Spring `BeanDefinition` +- 单例对象 +- Resolvable Dependency +- `@Value` 外部化配置 + +## 参考资料 + +- [Spring 官方文档之 Core Technologies](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans) +- [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/06.SpringBean\344\275\234\347\224\250\345\237\237.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/06.SpringBean\344\275\234\347\224\250\345\237\237.md" new file mode 100644 index 00000000..c07dacac --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/06.SpringBean\344\275\234\347\224\250\345\237\237.md" @@ -0,0 +1,102 @@ +--- +title: Spring Bean 作用域 +date: 2022-12-21 11:42:00 +order: 06 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring + - Bean +permalink: /pages/8289f5/ +--- + +# Spring Bean 作用域 + +## Spring Bean 作用域 + +| 来源 | 说明 | +| ----------- | ---------------------------------------------------------- | +| singleton | 默认 Spring Bean 作用域，一个 BeanFactory 有且仅有一个实例 | +| prototype | 原型作用域，每次依赖查找和依赖注入生成新 Bean 对象 | +| request | 将 Spring Bean 存储在 ServletRequest 上下文中 | +| session | 将 Spring Bean 存储在 HttpSession 中 | +| application | 将 Spring Bean 存储在 ServletContext 中 | + +## "singleton" Bean 作用域 + +![](https://raw.githubusercontent.com/dunwu/images/master/snap/20221221170833.png) + +## "prototype" Bean 作用域 + +Spring 容器没有办法管理 prototype Bean 的完整生命周期，也没有办法记录实例的存在。销毁回调方法将不会执行，可以利用 `BeanPostProcessor` 进行清扫工作。 + +## "request" Bean 作用域 + +- 配置 + - XML - `` + - Java 注解 - `@RequestScope` 或 `@Scope(WebApplicationContext.SCOPE_REQUEST)` +- 实现 + - API - RequestScope + +## "session" Bean 作用域 + +- 配置 + - XML - `` + - Java 注解 - `@SessionScope` 或 `@Scope(WebApplicationContext.SCOPE_SESSION)` +- 实现 + - API - SessionScope + +## "application" Bean 作用域 + +- 配置 + - XML - `` + - Java 注解 - `@ApplicationScope` 或 `@Scope(WebApplicationContext.SCOPE_APPLICATION)` +- 实现 + - API - ServletContextScope + +## 自定义 Bean 作用域 + +- 实现 Scope + + - `org.springframework.beans.factory.config.Scope` + +- 注册 Scope + + - API - `org.springframework.beans.factory.config.ConfigurableBeanFactory#registerScope` + +- 配置 + + ```xml + + + + + + + + + ``` + +## 问题 + +Spring 內建的 Bean 作用域有几种？ + +singleton、prototype、request、session、application 以及 websocket + +singleton Bean 是否在一个应用是唯一的？ + +否。singleton bean 仅在当前 Spring IoC 容器（BeanFactory）中是单例对象。 + +application Bean 是否可以被其他方案替代？ + +可以的，实际上，“application” Bean 与“singleton” Bean 没有本质区别 + +## 参考资料 + +- [Spring 官方文档之 Core Technologies](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans) +- [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/07.SpringBean\347\224\237\345\221\275\345\221\250\346\234\237.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/07.SpringBean\347\224\237\345\221\275\345\221\250\346\234\237.md" new file mode 100644 index 00000000..4a72cd8c --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/07.SpringBean\347\224\237\345\221\275\345\221\250\346\234\237.md" @@ -0,0 +1,186 @@ +--- +title: Spring Bean 生命周期 +date: 2022-12-21 19:26:01 +order: 07 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring + - Bean +permalink: /pages/4ab176/ +--- + +# Spring Bean 生命周期 + +## Spring Bean 元信息配置阶段 + +BeanDefinition 配置 + +- 面向资源 + - XML 配置 + - Properties 资源配置 +- 面向注解 +- 面向 API + +## Spring Bean 元信息解析阶段 + +- 面向资源 BeanDefinition 解析 + - BeanDefinitionReader + - XML 解析器 - BeanDefinitionParser +- 面向注解 BeanDefinition 解析 + - AnnotatedBeanDefinitionReader + +## Spring Bean 注册阶段 + +BeanDefinition 注册接口：BeanDefinitionRegistry + +## Spring BeanDefinition 合并阶段 + +BeanDefinition 合并 + +父子 BeanDefinition 合并 + +- 当前 BeanFactory 查找 +- 层次性 BeanFactory 查找 + +## Spring Bean Class 加载阶段 + +- ClassLoader 类加载 +- Java Security 安全控制 +- ConfigurableBeanFactory 临时 ClassLoader + +## Spring Bean 实例化前阶段 + +实例化方式 + +- 传统实例化方式：实例化策略（InstantiationStrategy） +- 构造器依赖注入 + +## Spring Bean 实例化阶段 + +非主流生命周期 - Bean 实例化前阶段 + +InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation + +## Spring Bean 实例化后阶段 + +Bean 属性赋值（Populate）判断 + +InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation + +## Spring Bean 属性赋值前阶段 + +- Bean 属性值元信息 + - PropertyValues +- Bean 属性赋值前回调 + - Spring 1.2 - 5.0：InstantiationAwareBeanPostProcessor#postProcessPropertyValues + - Spring 5.1：InstantiationAwareBeanPostProcessor#postProcessProperties + +## Spring Bean Aware 接口回调阶段 + +Spring Aware 接口： + +- BeanNameAware +- BeanClassLoaderAware +- BeanFactoryAware +- EnvironmentAware +- EmbeddedValueResolverAware +- ResourceLoaderAware +- ApplicationEventPublisherAware +- MessageSourceAware +- ApplicationContextAware + +## Spring Bean 初始化前阶段 + +已完成： + +- Bean 实例化 + +- Bean 属性赋值 + +- Bean Aware 接口回调 + +方法回调： + +- BeanPostProcessor#postProcessBeforeInitialization + +## Spring Bean 初始化阶段 + +Bean 初始化（Initialization） + +- @PostConstruct 标注方法 +- 实现 InitializingBean 接口的 afterPropertiesSet() 方法 +- 自定义初始化方法 + +## Spring Bean 初始化后阶段 + +方法回调：BeanPostProcessor#postProcessAfterInitialization + +## Spring Bean 初始化完成阶段 + +方法回调：Spring 4.1 +：SmartInitializingSingleton#afterSingletonsInstantiated + +## Spring Bean 销毁前阶段 + +方法回调：DestructionAwareBeanPostProcessor#postProcessBeforeDestruction + +## Spring Bean 销毁阶段 + +Bean 销毁（Destroy） + +- @PreDestroy 标注方法 +- 实现 DisposableBean 接口的 destroy() 方法 +- 自定义销毁方法 + +## Spring Bean 垃圾收集 + +Bean 垃圾回收（GC） + +- 关闭 Spring 容器（应用上下文） +- 执行 GC +- Spring Bean 覆盖的 finalize() 方法被回调 + +## 问题 + +**BeanPostProcessor 的使用场景有哪些**？ + +BeanPostProcessor 提供 Spring Bean 初始化前和初始化后的生命周期回调，分别对应 postProcessBeforeInitialization 以及 postProcessAfterInitialization 方法，允许对关心的 Bean 进行扩展，甚至是替换。 + +加分项：其中，ApplicationContext 相关的 Aware 回调也是基于 BeanPostProcessor 实现，即 ApplicationContextAwareProcessor。 + +**BeanFactoryPostProcessor 与 BeanPostProcessor 的区别**？ + +BeanFactoryPostProcessor 是 Spring BeanFactory（实际为 ConfigurableListableBeanFactory）的后置处理器，用于扩展 BeanFactory，或通过 BeanFactory 进行依赖查找和依赖注入。 + +BeanFactoryPostProcessor 必须有 Spring ApplicationContext 执行，BeanFactory 无法与其直接交互。 + +而 BeanPostProcessor 则直接与 BeanFactory 关联，属于 N 对 1 的关系。 + +**BeanFactory 是怎样处理 Bean 生命周期**？ + +BeanFactory 的默认实现为 `DefaultListableBeanFactory`，其中 Bean生命周期与方法映射如下： + +- BeanDefinition 注册阶段 - registerBeanDefinition +- BeanDefinition 合并阶段 - getMergedBeanDefinition +- Bean 实例化前阶段 - resolveBeforeInstantiation +- Bean 实例化阶段 - createBeanInstance +- Bean 初始化后阶段 - populateBean +- Bean 属性赋值前阶段 - populateBean +- Bean 属性赋值阶段 - populateBean +- Bean Aware 接口回调阶段 - initializeBean +- Bean 初始化前阶段 - initializeBean +- Bean 初始化阶段 - initializeBean +- Bean 初始化后阶段 - initializeBean +- Bean 初始化完成阶段 - preInstantiateSingletons +- Bean 销毁前阶段 - destroyBean +- Bean 销毁阶段 - destroyBean + +## 参考资料 + +- [Spring 官方文档之 Core Technologies](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans) +- [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/08.Spring\351\205\215\347\275\256\345\205\203\346\225\260\346\215\256.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/08.Spring\351\205\215\347\275\256\345\205\203\346\225\260\346\215\256.md" new file mode 100644 index 00000000..54150343 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/08.Spring\351\205\215\347\275\256\345\205\203\346\225\260\346\215\256.md" @@ -0,0 +1,299 @@ +--- +title: Spring 配置元数据 +date: 2022-12-21 19:49:48 +order: 08 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring + - Bean +permalink: /pages/55f315/ +--- + +# Spring 配置元数据 + +## Spring 配置元信息 + +- Spring Bean 配置元信息 - BeanDefinition +- Spring Bean 属性元信息 - PropertyValues +- Spring 容器配置元信息 +- Spring 外部化配置元信息 - PropertySource +- Spring Profile 元信息 - @Profile + +## Spring Bean 配置元信息 + +Bean 配置元信息 - BeanDefinition + +- GenericBeanDefinition：通用型 BeanDefinition +- RootBeanDefinition：无 Parent 的 BeanDefinition 或者合并后 BeanDefinition +- AnnotatedBeanDefinition：注解标注的 BeanDefinition + +## Spring Bean 属性元信息 + +- Bean 属性元信息 - PropertyValues + - 可修改实现 - MutablePropertyValues + - 元素成员 - PropertyValue +- Bean 属性上下文存储 - AttributeAccessor +- Bean 元信息元素 - BeanMetadataElement + +## Spring 容器配置元信息 + +Spring XML 配置元信息 - beans 元素相关 + +| beans 元素属性 | 默认值 | 使用场景 | +| --------------------------- | ------------ | ----------------------------------------------------------------------- | +| profile | null（留空） | Spring Profiles 配置值 | +| default-lazy-init | default | 当 outter beans “default-lazy-init” 属性存在时，继承该值，否则为“false” | +| default-merge | default | 当 outter beans “default-merge” 属性存在时，继承该值，否则为“false” | +| default-autowire | default | 当 outter beans “default-autowire” 属性存在时，继承该值，否则为“no” | +| default-autowire-candidates | null（留空） | 默认 Spring Beans 名称 pattern | +| default-init-method | null（留空） | 默认 Spring Beans 自定义初始化方法 | +| default-destroy-method | null（留空） | 默认 Spring Beans 自定义销毁方法 | + +Spring XML 配置元信息 - 应用上下文相关 + +| XML 元素 | 使用场景 | +| ---------------------------------- | ------------------------------------ | +| `` | 激活 Spring 注解驱动 | +| `` | Spring @Component 以及自定义注解扫描 | +| `` | 激活 Spring LoadTimeWeaver | +| `` | 暴露 Spring Beans 作为 JMX Beans | +| `` | 将当前平台作为 MBeanServer | +| `` | 加载外部化配置资源作为 Spring 属性配 | +| `` | 利用外部化配置资源覆盖 Spring 属 | + +## 基于 XML 文件装载 Spring Bean 配置元信息 + +底层实现 - XmlBeanDefinitionReader + +| XML 元素 | 使用场景 | +| ------------------ | --------------------------------------------- | +| `` | 单 XML 资源下的多个 Spring Beans 配置 | +| `` | 单个 Spring Bean 定义（BeanDefinition）配置 | +| `` | 为 Spring Bean 定义（BeanDefinition）映射别名 | +| `` | 加载外部 Spring XML 配置资源 | + +## 基于 Properties 文件装载 Spring Bean 配置元信息 + +底层实现 - PropertiesBeanDefinitionReader + +| Properties 属性名 | 使用场景 | +| ----------------- | ------------------------------- | +| `class` | Bean 类全称限定名 | +| `abstract` | 是否为抽象的 BeanDefinition | +| `parent` | 指定 parent BeanDefinition 名称 | +| `lazy-init` | 是否为延迟初始化 | +| `ref` | 引用其他 Bean 的名称 | +| `scope` | 设置 Bean 的 scope 属性 | +| ${n} | n 表示第 n+1 个构造器参数 | + +## 基于 Java 注解装载 Spring Bean 配置元信息 + +Spring 模式注解 + +| Spring 注解 | 场景说明 | 起始版本 | +| ---------------- | ------------------ | -------- | +| `@Repository` | 数据仓储模式注解 | 2.0 | +| `@Component` | 通用组件模式注解 | 2.5 | +| `@Service` | 服务模式注解 | 2.5 | +| `@Controller` | Web 控制器模式注解 | 2.5 | +| `@Configuration` | 配置类模式注解 | 3.0 | + +Spring Bean 定义注解 + +| Spring 注解 | 场景说明 | 起始版本 | +| ------------ | ------------------------------------------ | ----------- | --- | +| `@Bean` | 替换 XML 元素 `` | 3.0 | +| `@DependsOn` | 替代 XML 属性 `` | 3.0 | +| `@Lazy` | 替代 XML 属性 `` | 3.0 | +| `@Primary` | 替换 XML 元素 `` | 3.0 | +| `@Role` | 替换 XML 元素 `` | 3.1 | +| `@Lookup` | 替代 XML 属性 `` | 4.1 | + +Spring Bean 依赖注入注解 + +| Spring 注解 | 场景说明 | 起始版本 | +| ------------ | ----------------------------------- | -------- | +| `@Autowired` | Bean 依赖注入，支持多种依赖查找方式 | 2.5 | +| `@Qualifier` | 细粒度的 @Autowired 依赖查找 | 2.5 | + +| Java 注解 | 场景说明 | 起始版本 | +| --------- | ----------------- | -------- | +| @Resource | 类似于 @Autowired | 2.5 | +| @Inject | 类似于 @Autowired | 2.5 | + +Spring Bean 条件装配注解 + +| Spring 注解 | 场景说明 | 起始版本 | +| ------------ | -------------- | -------- | +| @Profile | 配置化条件装配 | 3.1 | +| @Conditional | 编程条件装配 | 4.0 | + +Spring Bean 生命周期回调注解 + +| Spring 注解 | 场景说明 | 起始版本 | +| -------------- | ------------------------------------------------------------- | -------- | +| @PostConstruct | 替换 XML 元素或 InitializingBean | 2.5 | +| @PreDestroy | 替换 XML 元素或 DisposableBean | 2.5 | + +Spring BeanDefinition 解析与注册 + +| Spring 注解 | 场景说明 | 起始版本 | +| --------------- | ------------------------------ | -------- | +| XML 资源 | XmlBeanDefinitionReader | 1.0 | +| Properties 资源 | PropertiesBeanDefinitionReader | 1.0 | +| Java 注解 | AnnotatedBeanDefinitionReader | 3.0 | + +## Spring Bean 配置元信息底层实现 + +### Spring XML 资源 BeanDefinition 解析与注册 + +核心 API - XmlBeanDefinitionReader + +- 资源 - Resource +- 底层 - BeanDefinitionDocumentReader + - XML 解析 - Java DOM Level 3 API + - BeanDefinition 解析 - BeanDefinitionParserDelegate + - BeanDefinition 注册 - BeanDefinitionRegistry + +### Spring Properties 资源 BeanDefinition 解析与注册 + +核心 API - PropertiesBeanDefinitionReader + +- 资源 + - 字节流 - Resource + - 字符流 - EncodedResouce +- 底层 + - 存储 - java.util.Properties + - BeanDefinition 解析 - API 内部实现 + - BeanDefinition 注册 - BeanDefinitionRegistry + +### Spring Java 注册 BeanDefinition 解析与注册 + +核心 API - AnnotatedBeanDefinitionReader + +- 资源 + - 类对象 - java.lang.Class +- 底层 + - 条件评估 - ConditionEvaluator + - Bean 范围解析 - ScopeMetadataResolver + - BeanDefinition 解析 - 内部 API 实现 + - BeanDefinition 处理 - AnnotationConfigUtils.processCommonDefinitionAnnotations + - BeanDefinition 注册 - BeanDefinitionRegistry + +## 基于 XML 文件装载 Spring IoC 容器配置元信息 + +Spring IoC 容器相关 XML 配置 + +| 命名空间 | 所属模块 | Schema 资源 URL | +| -------- | -------------- | ----------------------------------------------------------------- | +| beans | spring-beans | https://www.springframework.org/schema/beans/spring-beans.xsd | +| context | spring-context | https://www.springframework.org/schema/context/spring-context.xsd | +| aop | spring-aop | https://www.springframework.org/schema/aop/spring-aop.xsd | +| tx | spring-tx | https://www.springframework.org/schema/tx/spring-tx.xsd | +| util | spring-beans | beans https://www.springframework.org/schema/util/spring-util.xsd | +| tool | spring-beans | https://www.springframework.org/schema/tool/spring-tool.xsd | + +## 基于 Java 注解装载 Spring IoC 容器配置元信息 + +Spring IoC 容器装配注解 + +| Spring 注解 | 场景说明 | 起始版本 | +| --------------- | ------------------------------------------- | -------- | +| @ImportResource | 替换 XML 元素 `` | 3.0 | +| @Import | 导入 Configuration Class | 3.0 | +| @ComponentScan | 扫描指定 package 下标注 Spring 模式注解的类 | 3.1 | + +Spring IoC 配属属性注解 + +| Spring 注解 | 场景说明 | 起始版本 | +| ---------------- | -------------------------------- | -------- | +| @PropertySource | 配置属性抽象 PropertySource 注解 | 3.1 | +| @PropertySources | @PropertySource 集合注解 | 4.0 | + +## 基于 Extensible XML authoring 扩展 SpringXML 元素 + +Spring XML 扩展 + +- 编写 XML Schema 文件：定义 XML 结构 +- 自定义 NamespaceHandler 实现：命名空间绑定 +- 自定义 BeanDefinitionParser 实现：XML 元素与 BeanDefinition 解析 +- 注册 XML 扩展：命名空间与 XML Schema 映射 + +## Extensible XML authoring 扩展原理 + +### 触发时机 + +- AbstractApplicationContext#obtainFreshBeanFactory + - AbstractRefreshableApplicationContext#refreshBeanFactory + - AbstractXmlApplicationContext#loadBeanDefinitions + - ... + - XmlBeanDefinitionReader#doLoadBeanDefinitions + - ... + - BeanDefinitionParserDelegate#parseCustomElement + +### 核心流程 + +BeanDefinitionParserDelegate#parseCustomElement(org.w3c.dom.Element, BeanDefinition) + +- 获取 namespace +- 通过 namespace 解析 NamespaceHandler +- 构造 ParserContext +- 解析元素，获取 BeanDefinintion + +## 基于 Properties 文件装载外部化配置 + +注解驱动 + +- @org.springframework.context.annotation.PropertySource +- @org.springframework.context.annotation.PropertySources + +API 编程 + +- org.springframework.core.env.PropertySource +- org.springframework.core.env.PropertySources + +## 基于 YAML 文件装载外部化配置 + +API 编程 + +- org.springframework.beans.factory.config.YamlProcessor + - org.springframework.beans.factory.config.YamlMapFactoryBean + - org.springframework.beans.factory.config.YamlPropertiesFactoryBean + +## 问题 + +**Spring 內建 XML Schema 常见有哪些**？ + +| 命名空间 | 所属模块 | Schema 资源 URL | +| -------- | -------------- | ----------------------------------------------------------------- | +| beans | spring-beans | https://www.springframework.org/schema/beans/spring-beans.xsd | +| context | spring-context | https://www.springframework.org/schema/context/spring-context.xsd | +| aop | spring-aop | https://www.springframework.org/schema/aop/spring-aop.xsd | +| tx | spring-tx | https://www.springframework.org/schema/tx/spring-tx.xsd | +| util | spring-beans | beans https://www.springframework.org/schema/util/spring-util.xsd | +| tool | spring-beans | https://www.springframework.org/schema/tool/spring-tool.xsd | + +**Spring 配置元信息具体有哪些**？ + +- Bean 配置元信息：通过媒介（如 XML、Proeprties 等），解析 BeanDefinition +- IoC 容器配置元信息：通过媒介（如 XML、Proeprties 等），控制 IoC 容器行为，比如注解驱动、AOP 等 +- 外部化配置：通过资源抽象（如 Proeprties、YAML 等），控制 PropertySource +- Spring Profile：通过外部化配置，提供条件分支流程 + +**Extensible XML authoring 的缺点**？ + +- 高复杂度：开发人员需要熟悉 XML Schema，spring.handlers，spring.schemas 以及 Spring API +- 嵌套元素支持较弱：通常需要使用方法递归或者其嵌套解析的方式处理嵌套（子）元素 +- XML 处理性能较差：Spring XML 基于 DOM Level 3 API 实现，该 API 便于理解，然而性能较差 +- XML 框架移植性差：很难适配高性能和便利性的 XML 框架，如 JAXB + +## 参考资料 + +- [Spring 官方文档之 Core Technologies](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans) +- [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/09.Spring\345\272\224\347\224\250\344\270\212\344\270\213\346\226\207\347\224\237\345\221\275\345\221\250\346\234\237.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/09.Spring\345\272\224\347\224\250\344\270\212\344\270\213\346\226\207\347\224\237\345\221\275\345\221\250\346\234\237.md" new file mode 100644 index 00000000..fea4b398 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/09.Spring\345\272\224\347\224\250\344\270\212\344\270\213\346\226\207\347\224\237\345\221\275\345\221\250\346\234\237.md" @@ -0,0 +1,171 @@ +--- +title: Spring 应用上下文生命周期 +date: 2022-12-23 09:58:09 +order: 09 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring +permalink: /pages/ad472e/ +--- + +# Spring 应用上下文生命周期 + +## Spring 应用上下文启动准备阶段 + +AbstractApplicationContext#prepareRefresh() 方法 + +- 启动时间 - startupDate +- 状态标识 - closed(false)、active(true) +- 初始化 PropertySources - initPropertySources() +- 检验 Environment 中必须属性 +- 初始化事件监听器集合 +- 初始化早期 Spring 事件集合 + +## BeanFactory 创建阶段 + +AbstractApplicationContext#obtainFreshBeanFactory() 方法 + +- 刷新 Spring 应用上下文底层 BeanFactory - refreshBeanFactory() + - 销毁或关闭 BeanFactory，如果已存在的话 + - 创建 BeanFactory - createBeanFactory() + - 设置 BeanFactory Id + - 设置“是否允许 BeanDefinition 重复定义” - customizeBeanFactory(DefaultListableBeanFactory) + - 设置“是否允许循环引用（依赖）” - customizeBeanFactory(DefaultListableBeanFactory) + - 加载 BeanDefinition - loadBeanDefinitions(DefaultListableBeanFactory) 方法 + - 关联新建 BeanFactory 到 Spring 应用上下文 +- 返回 Spring 应用上下文底层 BeanFactory - getBeanFactory() + +## BeanFactory 准备阶段 + +AbstractApplicationContext#prepareBeanFactory(ConfigurableListableBeanFactory) 方法 + +- 关联 ClassLoader +- 设置 Bean 表达式处理器 +- 添加 PropertyEditorRegistrar 实现 - ResourceEditorRegistrar +- 添加 Aware 回调接口 BeanPostProcessor 实现 - ApplicationContextAwareProcessor +- 忽略 Aware 回调接口作为依赖注入接口 +- 注册 ResolvableDependency 对象 - BeanFactory、ResourceLoader、ApplicationEventPublisher 以及 ApplicationContext +- 注册 ApplicationListenerDetector 对象 +- 注册 LoadTimeWeaverAwareProcessor 对象 +- 注册单例对象 - Environment、Java System Properties 以及 OS 环境变量 + +## BeanFactory 后置处理阶段 + +- AbstractApplicationContext#postProcessBeanFactory(ConfigurableListableBeanFactory) 方法 + - 由子类覆盖该方法 +- AbstractApplicationContext#invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory 方法 + - 调用 BeanFactoryPostProcessor 或 BeanDefinitionRegistry 后置处理方法 + - 注册 LoadTimeWeaverAwareProcessor 对象 + +## BeanFactory 注册 BeanPostProcessor 阶段 + +AbstractApplicationContext#registerBeanPostProcessors(ConfigurableListableBeanFactory) 方法 + +- 注册 PriorityOrdered 类型的 BeanPostProcessor Beans +- 注册 Ordered 类型的 BeanPostProcessor Beans +- 注册普通 BeanPostProcessor Beans +- 注册 MergedBeanDefinitionPostProcessor Beans +- 注册 ApplicationListenerDetector 对象 + +## 初始化內建 Bean：MessageSource + +AbstractApplicationContext#initMessageSource() 方法 + +## 初始化內建 Bean：Spring 事件广播器 + +AbstractApplicationContext#initApplicationEventMulticaster() 方法 + +## Spring 应用上下文刷新阶段 + +AbstractApplicationContext#onRefresh() 方法 + +子类覆盖该方法 + +- org.springframework.web.context.support.AbstractRefreshableWebApplicationContext#onRefresh() +- org.springframework.web.context.support.GenericWebApplicationContext#onRefresh() +- org.springframework.boot.web.reactive.context.ReactiveWebServerApplicationContext#onRefresh() +- org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext#onRefresh() +- org.springframework.web.context.support.StaticWebApplicationContext#onRefresh() + +## Spring 事件监听器注册阶段 + +AbstractApplicationContext#registerListeners() 方法 + +- 添加当前应用上下文所关联的 ApplicationListener 对象（集合） +- 添加 BeanFactory 所注册 ApplicationListener Beans +- 广播早期 Spring 事件 + +## BeanFactory 初始化完成阶段 + +AbstractApplicationContext#finishBeanFactoryInitialization(ConfigurableListableBeanFactory) 方法 + +- BeanFactory 关联 ConversionService Bean，如果存在 +- 添加 StringValueResolver 对象 +- 依赖查找 LoadTimeWeaverAware Bean +- BeanFactory 临时 ClassLoader 置为 null +- BeanFactory 冻结配置 +- BeanFactory 初始化非延迟单例 Beans + +## Spring 应用上下刷新完成阶段 + +AbstractApplicationContext#finishRefresh() 方法 + +- 清除 ResourceLoader 缓存 - clearResourceCaches() @since 5.0 +- 初始化 LifecycleProcessor 对象 - initLifecycleProcessor() +- 调用 LifecycleProcessor#onRefresh() 方法 +- 发布 Spring 应用上下文已刷新事件 - ContextRefreshedEvent +- 向 MBeanServer 托管 Live Beans + +## Spring 应用上下文启动阶段 + +AbstractApplicationContext#start() 方法 + +- 启动 LifecycleProcessor + - 依赖查找 Lifecycle Beans + - 启动 Lifecycle Beans +- 发布 Spring 应用上下文已启动事件 - ContextStartedEvent + +## Spring 应用上下文停止阶段 + +AbstractApplicationContext#stop() 方法 + +- 停止 LifecycleProcessor + - 依赖查找 Lifecycle Beans + - 停止 Lifecycle Beans +- 发布 Spring 应用上下文已停止事件 - ContextStoppedEvent + +## Spring 应用上下文关闭阶段 + +AbstractApplicationContext#close() 方法 + +- 状态标识：active(false)、closed(true) +- Live Beans JMX 撤销托管 + - LiveBeansView.unregisterApplicationContext(ConfigurableApplicationContext) +- 发布 Spring 应用上下文已关闭事件 - ContextClosedEvent +- 关闭 LifecycleProcessor + - 依赖查找 Lifecycle Beans + - 停止 Lifecycle Beans +- 销毁 Spring Beans +- 关闭 BeanFactory +- 回调 onClose() +- 注册 Shutdown Hook 线程（如果曾注册） + +## 问题 + +**Spring 应用上下文生命周期有哪些阶段**？ + +- 刷新阶段 - ConfigurableApplicationContext#refresh() +- 启动阶段 - ConfigurableApplicationContext#start() +- 停止阶段 - ConfigurableApplicationContext#stop() +- 关闭阶段 - ConfigurableApplicationContext#close() + +## 参考资料 + +- [Spring 官方文档之 Core Technologies](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans) +- [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/10.SpringAop.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/10.SpringAop.md" new file mode 100644 index 00000000..1a89468a --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/10.SpringAop.md" @@ -0,0 +1,399 @@ +--- +title: Spring AOP +date: 2020-02-26 23:47:47 +order: 10 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring + - AOP +permalink: /pages/53aedb/ +--- + +# Spring AOP + +## AOP 概念 + +### 什么是 AOP + +AOP(Aspect-Oriented Programming，即 **面向切面编程**)与 OOP( Object-Oriented Programming，面向对象编程) 相辅相成，提供了与 OOP 不同的抽象软件结构的视角。 + +在 OOP 中，我们以类(class)作为我们的基本单元，而 AOP 中的基本单元是 **Aspect(切面)** + +### 术语 + +#### Aspect(切面) + +`aspect` 由 `pointcount` 和 `advice` 组成, 它既包含了横切逻辑的定义, 也包括了连接点的定义. Spring AOP 就是负责实施切面的框架, 它将切面所定义的横切逻辑织入到切面所指定的连接点中. +AOP 的工作重心在于如何将增强织入目标对象的连接点上, 这里包含两个工作: + +1. 如何通过 pointcut 和 advice 定位到特定的 joinpoint 上 +2. 如何在 advice 中编写切面代码. + +**可以简单地认为, 使用 @Aspect 注解的类就是切面.** + +#### advice(增强) + +由 aspect 添加到特定的 join point(即满足 point cut 规则的 join point) 的一段代码. +许多 AOP 框架, 包括 Spring AOP, 会将 advice 模拟为一个拦截器(interceptor), 并且在 join point 上维护多个 advice, 进行层层拦截. +例如 HTTP 鉴权的实现, 我们可以为每个使用 RequestMapping 标注的方法织入 advice, 当 HTTP 请求到来时, 首先进入到 advice 代码中, 在这里我们可以分析这个 HTTP 请求是否有相应的权限, 如果有, 则执行 Controller, 如果没有, 则抛出异常. 这里的 advice 就扮演着鉴权拦截器的角色了. + +#### 连接点(join point) + +> a point during the execution of a program, such as the execution of a method or the handling of an exception. In Spring AOP, a join point always represents a method execution. + +程序运行中的一些时间点, 例如一个方法的执行, 或者是一个异常的处理. +`在 Spring AOP 中, join point 总是方法的执行点, 即只有方法连接点.` + +#### 切点(point cut) + +匹配 join point 的谓词(a predicate that matches join points). +Advice 是和特定的 point cut 关联的, 并且在 point cut 相匹配的 join point 中执行. +`在 Spring 中, 所有的方法都可以认为是 joinpoint, 但是我们并不希望在所有的方法上都添加 Advice, 而 pointcut 的作用就是提供一组规则(使用 AspectJ pointcut expression language 来描述) 来匹配joinpoint, 给满足规则的 joinpoint 添加 Advice.` + +#### 关于 join point 和 point cut 的区别 + +在 Spring AOP 中, 所有的方法执行都是 join point. 而 point cut 是一个描述信息, 它修饰的是 join point, 通过 point cut, 我们就可以确定哪些 join point 可以被织入 Advice. 因此 join point 和 point cut 本质上就是两个不同纬度上的东西. +`advice 是在 join point 上执行的, 而 point cut 规定了哪些 join point 可以执行哪些 advice` + +#### introduction + +为一个类型添加额外的方法或字段. Spring AOP 允许我们为 `目标对象` 引入新的接口(和对应的实现). 例如我们可以使用 introduction 来为一个 bean 实现 IsModified 接口, 并以此来简化 caching 的实现. + +#### 目标对象(Target) + +织入 advice 的目标对象. 目标对象也被称为 `advised object`. +`因为 Spring AOP 使用运行时代理的方式来实现 aspect, 因此 adviced object 总是一个代理对象(proxied object)` +`注意, adviced object 指的不是原来的类, 而是织入 advice 后所产生的代理类.` + +#### AOP proxy + +一个类被 AOP 织入 advice, 就会产生一个结果类, 它是融合了原类和增强逻辑的代理类. +在 Spring AOP 中, 一个 AOP 代理是一个 JDK 动态代理对象或 CGLIB 代理对象. + +#### 织入(Weaving) + +将 aspect 和其他对象连接起来, 并创建 adviced object 的过程. +根据不同的实现技术, AOP 织入有三种方式: + +- 编译器织入, 这要求有特殊的 Java 编译器. +- 类装载期织入, 这需要有特殊的类装载器. +- 动态代理织入, 在运行期为目标类添加增强(Advice)生成子类的方式. + Spring 采用动态代理织入, 而 AspectJ 采用编译器织入和类装载期织入. + +### advice 的类型 + +- before advice, 在 join point 前被执行的 advice. 虽然 before advice 是在 join point 前被执行, 但是它并不能够阻止 join point 的执行, 除非发生了异常(即我们在 before advice 代码中, 不能人为地决定是否继续执行 join point 中的代码) +- after return advice, 在一个 join point 正常返回后执行的 advice +- after throwing advice, 当一个 join point 抛出异常后执行的 advice +- after(final) advice, 无论一个 join point 是正常退出还是发生了异常, 都会被执行的 advice. +- around advice, 在 join point 前和 joint point 退出后都执行的 advice. 这个是最常用的 advice. + +### 关于 AOP Proxy + +Spring AOP 默认使用标准的 JDK 动态代理(dynamic proxy)技术来实现 AOP 代理, 通过它, 我们可以为任意的接口实现代理. +`如果需要为一个类实现代理, 那么可以使用 CGLIB 代理.` 当一个业务逻辑对象没有实现接口时, 那么 Spring AOP 就默认使用 CGLIB 来作为 AOP 代理了. 即如果我们需要为一个方法织入 advice, 但是这个方法不是一个接口所提供的方法, 则此时 Spring AOP 会使用 CGLIB 来实现动态代理. 鉴于此, Spring AOP 建议基于接口编程, 对接口进行 AOP 而不是类. + +### 彻底理解 aspect, join point, point cut, advice + +看完了上面的理论部分知识, 我相信还是会有不少朋友感觉到 AOP 的概念还是很模糊, 对 AOP 中的各种概念理解的还不是很透彻. 其实这很正常, 因为 AOP 中的概念是在是太多了, 我当时也是花了老大劲才梳理清楚的. +下面我以一个简单的例子来比喻一下 AOP 中 aspect, jointpoint, pointcut 与 advice 之间的关系. + +让我们来假设一下, 从前有一个叫爪哇的小县城, 在一个月黑风高的晚上, 这个县城中发生了命案. 作案的凶手十分狡猾, 现场没有留下什么有价值的线索. 不过万幸的是, 刚从隔壁回来的老王恰好在这时候无意中发现了凶手行凶的过程, 但是由于天色已晚, 加上凶手蒙着面, 老王并没有看清凶手的面目, 只知道凶手是个男性, 身高约七尺五寸. 爪哇县的县令根据老王的描述, 对守门的士兵下命令说: 凡是发现有身高七尺五寸的男性, 都要抓过来审问. 士兵当然不敢违背县令的命令, 只好把进出城的所有符合条件的人都抓了起来. + +来让我们看一下上面的一个小故事和 AOP 到底有什么对应关系. +首先我们知道, 在 Spring AOP 中 join point 指代的是所有方法的执行点, 而 point cut 是一个描述信息, 它修饰的是 join point, 通过 point cut, 我们就可以确定哪些 join point 可以被织入 Advice. 对应到我们在上面举的例子, 我们可以做一个简单的类比, join point 就相当于 **爪哇的小县城里的百姓**, point cut 就相当于 **老王所做的指控, 即凶手是个男性, 身高约七尺五寸**, 而 advice 则是施加在符合老王所描述的嫌疑人的动作: **抓过来审问**. +为什么可以这样类比呢? + +- join point --> 爪哇的小县城里的百姓: 因为根据定义, join point 是所有可能被织入 advice 的候选的点, 在 Spring AOP 中, 则可以认为所有方法执行点都是 join point. 而在我们上面的例子中, 命案发生在小县城中, 按理说在此县城中的所有人都有可能是嫌疑人. +- point cut --> 男性, 身高约七尺五寸: 我们知道, 所有的方法(joint point) 都可以织入 advice, 但是我们并不希望在所有方法上都织入 advice, 而 pointcut 的作用就是提供一组规则来匹配 joinpoint, 给满足规则的 joinpoint 添加 advice. 同理, 对于县令来说, 他再昏庸, 也知道不能把县城中的所有百姓都抓起来审问, 而是根据`凶手是个男性, 身高约七尺五寸`, 把符合条件的人抓起来. 在这里`凶手是个男性, 身高约七尺五寸` 就是一个修饰谓语, 它限定了凶手的范围, 满足此修饰规则的百姓都是嫌疑人, 都需要抓起来审问. +- advice --> 抓过来审问, advice 是一个动作, 即一段 Java 代码, 这段 Java 代码是作用于 point cut 所限定的那些 join point 上的. 同理, 对比到我们的例子中, `抓过来审问` 这个动作就是对作用于那些满足 `男性, 身高约七尺五寸` 的`爪哇的小县城里的百姓`. +- aspect: aspect 是 point cut 与 advice 的组合, 因此在这里我们就可以类比: **"根据老王的线索, 凡是发现有身高七尺五寸的男性, 都要抓过来审问"** 这一整个动作可以被认为是一个 aspect. + +或则我们也可以从语法的角度来简单类比一下. 我们在学英语时, 经常会接触什么 `定语`, `被动句` 之类的概念, 那么可以做一个不严谨的类比, 即 `joinpoint` 可以认为是一个 `宾语`, 而 `pointcut` 则可以类比为修饰 `joinpoint` 的定语, 那么整个 `aspect` 就可以描述为: `满足 pointcut 规则的 joinpoint 会被添加相应的 advice 操作.` + +## @AspectJ 支持 + +**`@AspectJ`** 是一种使用 Java 注解来实现 AOP 的编码风格。 + +@AspectJ 风格的 AOP 是 AspectJ Project 在 AspectJ 5 中引入的, 并且 Spring 也支持 @AspectJ 的 AOP 风格. + +### 使能 @AspectJ 支持 + +@AspectJ 可以以 XML 的方式或以注解的方式来使能, 并且不论以哪种方式使能@ASpectJ, 我们都必须保证 aspectjweaver.jar 在 classpath 中. + +#### 使用 Java Configuration 方式使能@AspectJ + +```java +@Configuration +@EnableAspectJAutoProxy +public class AppConfig { +} +``` + +#### 使用 XML 方式使能@AspectJ + +``` + +``` + +### 定义 aspect(切面) + +当使用注解 **@Aspect** 标注一个 Bean 后, 那么 Spring 框架会自动收集这些 Bean, 并添加到 Spring AOP 中, 例如: + +```java +@Component +@Aspect +public class MyTest { +} +``` + +`注意, 仅仅使用@Aspect 注解, 并不能将一个 Java 对象转换为 Bean, 因此我们还需要使用类似 @Component 之类的注解.` +`注意, 如果一个类被@Aspect 标注, 则这个类就不能是其他 aspect 的 **advised object** 了, 因为使用 @Aspect 后, 这个类就会被排除在 auto-proxying 机制之外.` + +### 声明 pointcut + +一个 pointcut 的声明由两部分组成: + +- 一个方法签名, 包括方法名和相关参数 +- 一个 pointcut 表达式, 用来指定哪些方法执行是我们感兴趣的(即因此可以织入 advice). + +在@AspectJ 风格的 AOP 中, 我们使用一个方法来描述 pointcut, 即: + +```java +@Pointcut("execution(* com.xys.service.UserService.*(..))") // 切点表达式 +private void dataAccessOperation() {} // 切点前面 +``` + +`这个方法必须无返回值.` +`这个方法本身就是 pointcut signature, pointcut 表达式使用@Pointcut 注解指定.` +上面我们简单地定义了一个 pointcut, 这个 pointcut 所描述的是: 匹配所有在包 **com.xys.service.UserService** 下的所有方法的执行. + +#### 切点标志符(designator) + +AspectJ5 的切点表达式由标志符(designator)和操作参数组成. 如 "execution(\* greetTo(..))" 的切点表达式, \*\*execution** 就是标志符, 而圆括号里的 \*\*\***greetTo(..) 就是操作参数 + +##### execution + +匹配 join point 的执行, 例如 "execution(\* hello(..))" 表示匹配所有目标类中的 hello() 方法. 这个是最基本的 pointcut 标志符. + +##### within + +匹配特定包下的所有 join point, 例如 `within(com.xys.*)` 表示 com.xys 包中的所有连接点, 即包中的所有类的所有方法. 而`within(com.xys.service.*Service)` 表示在 com.xys.service 包中所有以 Service 结尾的类的所有的连接点. + +##### this 与 target + +this 的作用是匹配一个 bean, 这个 bean(Spring AOP proxy) 是一个给定类型的实例(instance of). 而 target 匹配的是一个目标对象(target object, 即需要织入 advice 的原始的类), 此对象是一个给定类型的实例(instance of). + +##### bean + +匹配 bean 名字为指定值的 bean 下的所有方法, 例如: + +``` +bean(*Service) // 匹配名字后缀为 Service 的 bean 下的所有方法 +bean(myService) // 匹配名字为 myService 的 bean 下的所有方法 +``` + +##### args + +匹配参数满足要求的的方法. +例如: + +```java +@Pointcut("within(com.xys.demo2.*)") +public void pointcut2() { +} + +@Before(value = "pointcut2() && args(name)") +public void doSomething(String name) { + logger.info("---page: {}---", name); +} +``` + +```java +@Service +public class NormalService { + private Logger logger = LoggerFactory.getLogger(getClass()); + + public void someMethod() { + logger.info("---NormalService: someMethod invoked---"); + } + + public String test(String name) { + logger.info("---NormalService: test invoked---"); + return "服务一切正常"; + } +} +``` + +当 NormalService.test 执行时, 则 advice `doSomething` 就会执行, test 方法的参数 name 就会传递到 `doSomething` 中. + +常用例子: + +```java +// 匹配只有一个参数 name 的方法 +@Before(value = "aspectMethod() && args(name)") +public void doSomething(String name) { +} + +// 匹配第一个参数为 name 的方法 +@Before(value = "aspectMethod() && args(name, ..)") +public void doSomething(String name) { +} + +// 匹配第二个参数为 name 的方法 +Before(value = "aspectMethod() && args(*, name, ..)") +public void doSomething(String name) { +} +``` + +##### @annotation + +匹配由指定注解所标注的方法, 例如: + +```java +@Pointcut("@annotation(com.xys.demo1.AuthChecker)") +public void pointcut() { +} +``` + +则匹配由注解 `AuthChecker` 所标注的方法. + +#### 常见的切点表达式 + +##### 匹配方法签名 + +``` +// 匹配指定包中的所有的方法 +execution(* com.xys.service.*(..)) + +// 匹配当前包中的指定类的所有方法 +execution(* UserService.*(..)) + +// 匹配指定包中的所有 public 方法 +execution(public * com.xys.service.*(..)) + +// 匹配指定包中的所有 public 方法, 并且返回值是 int 类型的方法 +execution(public int com.xys.service.*(..)) + +// 匹配指定包中的所有 public 方法, 并且第一个参数是 String, 返回值是 int 类型的方法 +execution(public int com.xys.service.*(String name, ..)) +``` + +##### 匹配类型签名 + +``` +// 匹配指定包中的所有的方法, 但不包括子包 +within(com.xys.service.*) + +// 匹配指定包中的所有的方法, 包括子包 +within(com.xys.service..*) + +// 匹配当前包中的指定类中的方法 +within(UserService) + + +// 匹配一个接口的所有实现类中的实现的方法 +within(UserDao+) +``` + +##### 匹配 Bean 名字 + +``` +// 匹配以指定名字结尾的 Bean 中的所有方法 +bean(*Service) +``` + +##### 切点表达式组合 + +``` +// 匹配以 Service 或 ServiceImpl 结尾的 bean +bean(*Service || *ServiceImpl) + +// 匹配名字以 Service 结尾, 并且在包 com.xys.service 中的 bean +bean(*Service) && within(com.xys.service.*) +``` + +### 声明 advice + +advice 是和一个 pointcut 表达式关联在一起的, 并且会在匹配的 join point 的方法执行的前/后/周围运行. `pointcut 表达式可以是简单的一个 pointcut 名字的引用, 或者是完整的 pointcut 表达式`. +下面我们以几个简单的 advice 为例子, 来看一下一个 advice 是如何声明的. + +#### Before advice + +```java +/** + * @author xiongyongshun + * @version 1.0 + * @created 16/9/9 13:13 + */ +@Component +@Aspect +public class BeforeAspectTest { + // 定义一个 Pointcut, 使用切点表达式函数来描述对哪些 Join point 使用 advise. + @Pointcut("execution(* com.xys.service.UserService.*(..))") + public void dataAccessOperation() { + } +} +``` + +```java +@Component +@Aspect +public class AdviseDefine { + // 定义 advise + @Before("com.xys.aspect.PointcutDefine.dataAccessOperation()") + public void doBeforeAccessCheck(JoinPoint joinPoint) { + System.out.println("*****Before advise, method: " + joinPoint.getSignature().toShortString() + " *****"); + } +} +``` + +这里, **@Before** 引用了一个 pointcut, 即 "com.xys.aspect.PointcutDefine.dataAccessOperation()" 是一个 pointcut 的名字. +如果我们在 advice 在内置 pointcut, 则可以: + +```java +@Component +@Aspect +public class AdviseDefine { + // 将 pointcut 和 advice 同时定义 + @Before("within(com.xys.service..*)") + public void doAccessCheck(JoinPoint joinPoint) { + System.out.println("*****doAccessCheck, Before advise, method: " + joinPoint.getSignature().toShortString() + " *****"); + } +} +``` + +#### around advice + +around advice 比较特别, 它可以在一个方法的之前之前和之后添加不同的操作, 并且甚至可以决定何时, 如何, 是否调用匹配到的方法. + +```java +@Component +@Aspect +public class AdviseDefine { + // 定义 advise + @Around("com.xys.aspect.PointcutDefine.dataAccessOperation()") + public Object doAroundAccessCheck(ProceedingJoinPoint pjp) throws Throwable { + StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + // 开始 + Object retVal = pjp.proceed(); + stopWatch.stop(); + // 结束 + System.out.println("invoke method: " + pjp.getSignature().getName() + ", elapsed time: " + stopWatch.getTotalTimeMillis()); + return retVal; + } +} +``` + +around advice 和前面的 before advice 差不多, 只是我们把注解 **@Before** 改为了 **@Around** 了. + +## 参考资料 + +- [《 Spring 实战（第 4 版）》](https://item.jd.com/11899370.html) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/20.Spring\350\265\204\346\272\220\347\256\241\347\220\206.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/20.Spring\350\265\204\346\272\220\347\256\241\347\220\206.md" new file mode 100644 index 00000000..b285f663 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/20.Spring\350\265\204\346\272\220\347\256\241\347\220\206.md" @@ -0,0 +1,261 @@ +--- +title: Spring 资源管理 +date: 2019-09-04 19:46:41 +order: 20 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring + - Resource +permalink: /pages/a1549f/ +--- + +# Spring 资源管理 + +> Version 6.0.3 + +## Resource 接口 + +相对标准 URL 访问机制，Spring 的 `org.springframework.core.io.Resource` 接口抽象了对底层资源的访问接口，提供了一套更好的访问方式。 + +```java +public interface Resource extends InputStreamSource { + + boolean exists(); + + boolean isReadable(); + + boolean isOpen(); + + boolean isFile(); + + URL getURL() throws IOException; + + URI getURI() throws IOException; + + File getFile() throws IOException; + + ReadableByteChannel readableChannel() throws IOException; + + long contentLength() throws IOException; + + long lastModified() throws IOException; + + Resource createRelative(String relativePath) throws IOException; + + String getFilename(); + + String getDescription(); +} +``` + +正如 `Resource` 接口的定义所示，它扩展了 `InputStreamSource` 接口。`Resource` 最核心的方法如下： + +- `getInputStream()` - 定位并且打开当前资源，返回当前资源的 `InputStream`。每次调用都会返回一个新的 `InputStream`。调用者需要负责关闭流。 +- `exists()` - 判断当前资源是否真的存在。 +- `isOpen()` - 判断当前资源是否是一个已打开的 `InputStream`。如果为 true，则 `InputStream` 不能被多次读取，必须只读取一次然后关闭以避免资源泄漏。对所有常用资源实现返回 false，`InputStreamResource` 除外。 +- `getDescription()` - 返回当前资源的描述，当处理资源出错时，资源的描述会用于错误信息的输出。一般来说，资源的描述是一个完全限定的文件名称，或者是当前资源的真实 URL。 + +常见 Spring 资源接口： + +| 类型 | 接口 | +| ---------- | ----------------------------------------------------- | +| 输入流 | `org.springframework.core.io.InputStreamSource` | +| 只读资源 | `org.springframework.core.io.Resource` | +| 可写资源 | `org.springframework.core.io.WritableResource` | +| 编码资源 | `org.springframework.core.io.support.EncodedResource` | +| 上下文资源 | `org.springframework.core.io.ContextResource` | + +![](https://raw.githubusercontent.com/dunwu/images/master/snap/20221223155859.png) + +## 内置的 Resource 实现 + +Spring 包括几个内置的 Resource 实现： + +| 资源来源 | 前缀 | 说明 | +| ---------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| [`UrlResource`](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#resources-implementations-urlresource) | `file:`、`https:`、`ftp:` 等 | `UrlResource` 封装了一个 `java.net.URL` 对象，**用于访问可通过 URL 访问的任何对象**，例如文件、HTTPS 目标、FTP 目标等。所有 URL 都可以通过标准化的字符串形式表示，因此可以使用适当的标准化前缀来指示一种 URL 类型与另一种 URL 类型的区别。这包括：`file`：用于访问文件系统路径；`https`：用于通过 HTTPS 协议访问资源；`ftp`：用于通过 FTP 访问资源等等。 | +| [`ClassPathResource`](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#resources-implementations-classpathresource) | `classpath:` | `ClassPathResource` **从类路径上加载资源**。它使用线程上下文加载器、给定的类加载器或指定的 class 类型中的任意一个来加载资源。 | +| [`FileSystemResource`](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#resources-implementations-filesystemresource) | `file:` | `FileSystemResource` **是 `java.io.File` 的资源实现**。它还支持 `java.nio.file.Path` ，应用 Spring 的标准对字符串路径进行转换。`FileSystemResource` 支持解析为文件和 URL。 | +| [`PathResource`](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#resources-implementations-pathresource) | 无 | `PathResource` 是 `java.nio.file.Path` 的资源实现。 | +| [`ServletContextResource`](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#resources-implementations-servletcontextresource) | 无 | `ServletContextResource` **是 `ServletContext` 的资源实现**。它表示相应 Web 应用程序根目录中的相对路径。 | +| [`InputStreamResource`](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#resources-implementations-inputstreamresource) | 无 | `InputStreamResource` **是指定 `InputStream` 的资源实现**。注意：如果该 `InputStream` 已被打开，则不可以多次读取该流。 | +| [`ByteArrayResource`](https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#resources-implementations-bytearrayresource) | 无 | `ByteArrayResource` 是指定的二进制数组的资源实现。它会为给定的字节数组创建一个 `ByteArrayInputStream`。 | + +## ResourceLoader 接口 + +`ResourceLoader` 接口用于加载 `Resource` 对象。其定义如下： + +```java +public interface ResourceLoader { + + Resource getResource(String location); + + ClassLoader getClassLoader(); +} +``` + +Spring 中主要的 ResourceLoader 实现： + +![](https://raw.githubusercontent.com/dunwu/images/master/snap/20221223164745.png) + +Spring 中，所有的 `ApplicationContext` 都实现了 `ResourceLoader` 接口。因此，所有 `ApplicationContext` 都可以通过 `getResource()` 方法获取 `Resource` 实例。 + +【示例】 + +```java +// 如果没有指定资源前缀，Spring 会尝试返回合适的资源 +Resource template = ctx.getResource("some/resource/path/myTemplate.txt"); +// 如果指定 classpath: 前缀，Spring 会强制使用 ClassPathResource +Resource template = ctx.getResource("classpath:some/resource/path/myTemplate.txt"); +// 如果指定 file:、http 等 URL 前缀，Spring 会强制使用 UrlResource +Resource template = ctx.getResource("file:///some/resource/path/myTemplate.txt"); +Resource template = ctx.getResource("http://myhost.com/resource/path/myTemplate.txt"); +``` + +下表列举了 Spring 根据各种位置路径加载资源的策略： + +| 前缀 | 样例 | 说明 | +| ------------ | -------------------------------- | :----------------------------------- | +| `classpath:` | `classpath:com/myapp/config.xml` | 从类路径加载 | +| `file:` | `file:///data/config.xml` | 以 URL 形式从文件系统加载 | +| `http:` | `http://myserver/logo.png` | 以 URL 形式加载 | +| 无 | `/data/config.xml` | 由底层的 ApplicationContext 实现决定 | + +## ResourcePatternResolver 接口 + +`ResourcePatternResolver` 接口是 `ResourceLoader` 接口的扩展，它的作用是定义策略，根据位置模式解析 `Resource` 对象。 + +```java +public interface ResourcePatternResolver extends ResourceLoader { + + String CLASSPATH_ALL_URL_PREFIX = "classpath*:"; + + Resource[] getResources(String locationPattern) throws IOException; +} +``` + +`PathMatchingResourcePatternResolver` 是一个独立的实现，可以在 `ApplicationContext` 之外使用，也可以被 `ResourceArrayPropertyEditor` 用于填充 `Resource[]` bean 属性。`PathMatchingResourcePatternResolver` 能够将指定的资源位置路径解析为一个或多个匹配的 `Resource` 对象。 + +> 注意：任何标准 `ApplicationContext` 中的默认 `ResourceLoader` 实际上是 `PathMatchingResourcePatternResolver` 的一个实例，它实现了 `ResourcePatternResolver` 接口。 + +## ResourceLoaderAware 接口 + +`ResourceLoaderAware` 接口是一个特殊的回调接口，用来标记提供 `ResourceLoader` 引用的对象。`ResourceLoaderAware` 接口定义如下： + +```java +public interface ResourceLoaderAware { + void setResourceLoader(ResourceLoader resourceLoader); +} +``` + +当一个类实现 `ResourceLoaderAware` 并部署到应用程序上下文中（作为 Spring 管理的 bean）时，它会被应用程序上下文识别为 `ResourceLoaderAware`，然后，应用程序上下文会调用 `setResourceLoader(ResourceLoader)`，将自身作为参数提供（请记住，Spring 中的所有应用程序上下文都实现 `ResourceLoader` 接口）。 + +由于 `ApplicationContext` 是一个 `ResourceLoader`，该 bean 还可以实现 `ApplicationContextAware` 接口并直接使用提供的应用程序上下文来加载资源。但是，一般来说，如果您只需要这些，最好使用专门的 `ResourceLoader` 接口。该代码将仅耦合到资源加载接口（可以被视为实用程序接口），而不耦合到整个 Spring `ApplicationContext` 接口。 + +在应用程序中，还可以使用 `ResourceLoader` 的自动装配作为实现 `ResourceLoaderAware` 接口的替代方法。传统的构造函数和 `byType` 自动装配模式能够分别为构造函数参数或 setter 方法参数提供 `ResourceLoader`。为了获得更大的灵活性（包括自动装配字段和多参数方法的能力），请考虑使用基于注解的自动装配功能。在这种情况下，`ResourceLoader` 会自动连接到需要 `ResourceLoader` 类型的字段、构造函数参数或方法参数中，只要相关字段、构造函数或方法带有 `@Autowired` 注解即可。 + +## 资源依赖 + +如果 bean 本身要通过某种动态过程来确定和提供资源路径，那么 bean 可以使用 `ResourceLoader` 或 `ResourcePatternResolver` 接口来加载资源。例如，考虑加载某种模板，其中所需的特定资源取决于用户的角色。如果资源是静态的，完全消除 `ResourceLoader` 接口（或 `ResourcePatternResolver` 接口）的使用，让 bean 公开它需要的 `Resource` 属性，并期望将它们注入其中是有意义的。 + +使注入这些属性变得简单的原因是所有应用程序上下文都注册并使用一个特殊的 JavaBeans `PropertyEditor`，它可以将 `String` 路径转换为 `Resource` 对象。例如，下面的 MyBean 类有一个 `Resource` 类型的模板属性。 + +【示例】 + +```xml + + + +``` + +请注意，配置中引用的模板资源路径没有前缀，因为应用程序上下文本身将用作 `ResourceLoader`，资源本身将根据需要通过 `ClassPathResource`，`FileSystemResource` 或 ServletContextResource 加载，具体取决于上下文的确切类型。 + +如果需要强制使用特定的资源类型，则可以使用前缀。以下两个示例显示如何强制使用 `ClassPathResource` 和 `UrlResource`（后者用于访问文件系统文件）。 + +```xml + + +``` + +可以通过 `@Value` 注解加载资源文件 `myTemplate.txt`，示例如下： + +```java +@Component +public class MyBean { + + private final Resource template; + + public MyBean(@Value("${template.path}") Resource template) { + this.template = template; + } + + // ... +} +``` + +Spring 的 `PropertyEditor` 会根据资源文件的路径字符串，加载 `Resource` 对象，并将其注入到 MyBean 的构造方法。 + +如果想要加载多个资源文件，可以使用 `classpath*:` 前缀，例如：`classpath*:/config/templates/*.txt`。 + +```java +@Component +public class MyBean { + + private final Resource[] templates; + + public MyBean(@Value("${templates.path}") Resource[] templates) { + this.templates = templates; + } + + // ... +} +``` + +## 应用上下文和资源路径 + +### 构造应用上下文 + +应用上下文构造函数（针对特定的应用上下文类型）通常将字符串或字符串数组作为资源的位置路径，例如构成上下文定义的 XML 文件。 + +【示例】 + +```java +ApplicationContext ctx = new ClassPathXmlApplicationContext("conf/appContext.xml"); +ApplicationContext ctx = new FileSystemXmlApplicationContext("conf/appContext.xml"); +ApplicationContext ctx = new FileSystemXmlApplicationContext("classpath:conf/appContext.xml"); +ApplicationContext ctx = new ClassPathXmlApplicationContext( + new String[] {"services.xml", "daos.xml"}, MessengerService.class); +``` + +### 使用通配符构造应用上下文 + +ApplicationContext 构造器的中的资源路径可以是单一的路径（即一对一地映射到目标资源）；也可以是通配符形式——可包含 classpath\*：也可以是前缀或 ant 风格的正则表达式（使用 spring 的 PathMatcher 来匹配）。 + +示例： + +```java +ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath*:conf/appContext.xml"); +``` + +使用 `classpath*` 表示类路径下所有匹配文件名称的资源都会被获取(本质上就是调用了 ClassLoader.getResources(…) 方法），接着将获取到的资源组装成最终的应用上下文。 + +在位置路径的其余部分，`classpath*:` 前缀可以与 PathMatcher 结合使用，如：`classpath*:META-INF/*-beans.xml`。 + +## 问题 + +Spring 配置资源中有哪些常见类型？ + +- XML 资源 +- Properties 资源 +- YAML 资源 + +## 参考资料 + +- [Spring 官方文档之 Core Technologies](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans) +- [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/21.Spring\346\240\241\351\252\214.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/21.Spring\346\240\241\351\252\214.md" new file mode 100644 index 00000000..d99a6fcc --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/21.Spring\346\240\241\351\252\214.md" @@ -0,0 +1,637 @@ +--- +title: Spring 校验 +date: 2022-12-22 17:42:28 +order: 21 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring +permalink: /pages/fe6aad/ +--- + +# Spring 校验 + +Java API 规范(`JSR303`)定义了`Bean`校验的标准`validation-api`，但没有提供实现。`hibernate validation`是对这个规范的实现，并增加了校验注解如`@Email`、`@Length`等。`Spring Validation`是对`hibernate validation`的二次封装，用于支持`spring mvc`参数自动校验。 + +## 快速入门 + +### 引入依赖 + +如果 spring-boot 版本小于 2.3.x，spring-boot-starter-web 会自动传入 hibernate-validator 依赖。如果 spring-boot 版本大于 2.3.x，则需要手动引入依赖： + +```xml + + org.hibernate.validator + hibernate-validator-parent + 6.2.5.Final + +``` + +对于 web 服务来说，为防止非法参数对业务造成影响，在 Controller 层一定要做参数校验的！大部分情况下，请求参数分为如下两种形式： + +- POST、PUT 请求，使用 requestBody 传递参数； +- GET 请求，使用 requestParam/PathVariable 传递参数。 + +实际上，不管是 requestBody 参数校验还是方法级别的校验，最终都是调用 Hibernate Validator 执行校验，Spring Validation 只是做了一层封装。 + +### 校验示例 + +（1）在实体上标记校验注解 + +```kotlin +@Data +@NoArgsConstructor +@AllArgsConstructor +public class User implements Serializable { + + @NotNull + private Long id; + + @NotBlank + @Size(min = 2, max = 10) + private String name; + + @Min(value = 1) + @Max(value = 100) + private Integer age; + +} +``` + +（2）在方法参数上声明校验注解 + +```less +@Slf4j +@Validated +@RestController +@RequestMapping("validate1") +public class ValidatorController { + + /** + * {@link RequestBody} 参数校验 + */ + @PostMapping(value = "save") + public DataResult save(@Valid @RequestBody User entity) { + log.info("保存一条记录：{}", JSONUtil.toJsonStr(entity)); + return DataResult.ok(true); + } + + /** + * {@link RequestParam} 参数校验 + */ + @GetMapping(value = "queryByName") + public DataResult queryByName( + @RequestParam("username") + @NotBlank + @Size(min = 2, max = 10) + String name + ) { + User user = new User(1L, name, 18); + return DataResult.ok(user); + } + + /** + * {@link PathVariable} 参数校验 + */ + @GetMapping(value = "detail/{id}") + public DataResult detail(@PathVariable("id") @Min(1L) Long id) { + User user = new User(id, "李四", 18); + return DataResult.ok(user); + } + +} +``` + +（3）如果请求参数不满足校验规则，则会抛出 `ConstraintViolationException` 或 `MethodArgumentNotValidException` 异常。 + +### 统一异常处理 + +在实际项目开发中，通常会用统一异常处理来返回一个更友好的提示。 + +```java +@Slf4j +@ControllerAdvice +public class GlobalExceptionHandler { + + /** + * 处理所有不可知的异常 + */ + @ResponseBody + @ResponseStatus(HttpStatus.OK) + @ExceptionHandler(Throwable.class) + public Result handleException(Throwable e) { + log.error("未知异常", e); + return new Result(ResultStatus.HTTP_SERVER_ERROR.getCode(), e.getMessage()); + } + + /** + * 统一处理请求参数校验异常(普通传参) + * + * @param e ConstraintViolationException + * @return {@link DataResult} + */ + @ResponseBody + @ResponseStatus(HttpStatus.BAD_REQUEST) + @ExceptionHandler({ ConstraintViolationException.class }) + public Result handleConstraintViolationException(final ConstraintViolationException e) { + log.error("ConstraintViolationException", e); + List errors = new ArrayList<>(); + for (ConstraintViolation violation : e.getConstraintViolations()) { + Path path = violation.getPropertyPath(); + List pathArr = StrUtil.split(path.toString(), ','); + errors.add(pathArr.get(0) + " " + violation.getMessage()); + } + return new Result(ResultStatus.REQUEST_ERROR.getCode(), CollectionUtil.join(errors, ",")); + } + + /** + * 处理参数校验异常 + * + * @param e MethodArgumentNotValidException + * @return {@link DataResult} + */ + @ResponseBody + @ResponseStatus(HttpStatus.BAD_REQUEST) + @ExceptionHandler({ MethodArgumentNotValidException.class }) + private Result handleMethodArgumentNotValidException(final MethodArgumentNotValidException e) { + log.error("MethodArgumentNotValidException", e); + List errors = new ArrayList<>(); + for (ObjectError error : e.getBindingResult().getAllErrors()) { + errors.add(((FieldError) error).getField() + " " + error.getDefaultMessage()); + } + return new Result(ResultStatus.REQUEST_ERROR.getCode(), CollectionUtil.join(errors, ",")); + } + +} +``` + +## 进阶使用 + +### 分组校验 + +在实际项目中，可能多个方法需要使用同一个 DTO 类来接收参数，而不同方法的校验规则很可能是不一样的。这个时候，简单地在 DTO 类的字段上加约束注解无法解决这个问题。因此，spring-validation 支持了分组校验的功能，专门用来解决这类问题。 + +（1）定义分组 + +```java +@Target({ ElementType.FIELD, ElementType.PARAMETER }) +@Retention(RetentionPolicy.RUNTIME) +public @interface AddCheck { } + +@Target({ ElementType.FIELD, ElementType.PARAMETER }) +@Retention(RetentionPolicy.RUNTIME) +public @interface EditCheck { } +``` + +（2）在实体上标记校验注解 + +```less +@Data +public class User2 { + + @NotNull(groups = EditCheck.class) + private Long id; + + @NotNull(groups = { AddCheck.class, EditCheck.class }) + @Size(min = 2, max = 10, groups = { AddCheck.class, EditCheck.class }) + private String name; + + @IsMobile(message = "不是有效手机号", groups = { AddCheck.class, EditCheck.class }) + private String mobile; + +} +``` + +（3）在方法上根据不同场景进行校验分组 + +```less +@Slf4j +@Validated +@RestController +@RequestMapping("validate2") +public class ValidatorController2 { + + /** + * {@link RequestBody} 参数校验 + */ + @PostMapping(value = "add") + public DataResult add(@Validated(AddCheck.class) @RequestBody User2 entity) { + log.info("添加一条记录：{}", JSONUtil.toJsonStr(entity)); + return DataResult.ok(true); + } + + /** + * {@link RequestBody} 参数校验 + */ + @PostMapping(value = "edit") + public DataResult edit(@Validated(EditCheck.class) @RequestBody User2 entity) { + log.info("编辑一条记录：{}", JSONUtil.toJsonStr(entity)); + return DataResult.ok(true); + } + +} +``` + +### 嵌套校验 + +前面的示例中，DTO 类里面的字段都是基本数据类型和 String 类型。但是实际场景中，有可能某个字段也是一个对象，这种情况先，可以使用嵌套校验。 +post +比如，上面保存 User 信息的时候同时还带有 Job 信息。需要注意的是，此时 DTO 类的对应字段必须标记@Valid 注解。 + +```less +@Data +public class UserDTO { + + @Min(value = 10000000000000000L, groups = Update.class) + private Long userId; + + @NotNull(groups = {Save.class, Update.class}) + @Length(min = 2, max = 10, groups = {Save.class, Update.class}) + private String userName; + + @NotNull(groups = {Save.class, Update.class}) + @Length(min = 6, max = 20, groups = {Save.class, Update.class}) + private String account; + + @NotNull(groups = {Save.class, Update.class}) + @Length(min = 6, max = 20, groups = {Save.class, Update.class}) + private String password; + + @NotNull(groups = {Save.class, Update.class}) + @Valid + private Job job; + + @Data + public static class Job { + + @Min(value = 1, groups = Update.class) + private Long jobId; + + @NotNull(groups = {Save.class, Update.class}) + @Length(min = 2, max = 10, groups = {Save.class, Update.class}) + private String jobName; + + @NotNull(groups = {Save.class, Update.class}) + @Length(min = 2, max = 10, groups = {Save.class, Update.class}) + private String position; + } + + /** + * 保存的时候校验分组 + */ + public interface Save { + } + + /** + * 更新的时候校验分组 + */ + public interface Update { + } +} +复制代码 +``` + +嵌套校验可以结合分组校验一起使用。还有就是嵌套集合校验会对集合里面的每一项都进行校验，例如`List`字段会对这个 list 里面的每一个 Job 对象都进行校验 + +### 自定义校验注解 + +（1）自定义校验注解 `@IsMobile` + +```less +@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE }) +@Retention(RUNTIME) +@Constraint(validatedBy = MobileValidator.class) +public @interface IsMobile { + + String message(); + + Class[] groups() default {}; + + Class[] payload() default {}; + +} +``` + +（2）实现 `ConstraintValidator` 接口，编写 `@IsMobile` 校验注解的解析器 + +```java +import cn.hutool.core.util.StrUtil; +import io.github.dunwu.spring.core.validation.annotation.IsMobile; +import io.github.dunwu.tool.util.ValidatorUtil; + +import javax.validation.ConstraintValidator; +import javax.validation.ConstraintValidatorContext; + +public class MobileValidator implements ConstraintValidator { + + @Override + public void initialize(IsMobile isMobile) { } + + @Override + public boolean isValid(String s, ConstraintValidatorContext constraintValidatorContext) { + if (StrUtil.isBlank(s)) { + return false; + } else { + return ValidatorUtil.isMobile(s); + } + } + +} +``` + +### 自定义校验 + +可以通过实现 `org.springframework.validation.Validator` 接口来自定义校验。 + +有以下要点 + +- 实现 `supports` 方法 +- 实现 `validate` 方法 + - 通过 `Errors` 对象收集错误 + - `ObjectError`：对象（Bean）错误： + - `FieldError`：对象（Bean）属性（Property）错误 + - 通过 `ObjectError` 和 `FieldError` 关联 `MessageSource` 实现获取最终的错误文案 + +```less +package io.github.dunwu.spring.core.validation; + +import io.github.dunwu.spring.core.validation.annotation.Valid; +import io.github.dunwu.spring.core.validation.config.CustomValidatorConfig; +import io.github.dunwu.spring.core.validation.entity.Person; +import org.springframework.stereotype.Component; +import org.springframework.validation.Errors; +import org.springframework.validation.ValidationUtils; +import org.springframework.validation.Validator; + +import java.lang.annotation.Annotation; +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +@Component +public class CustomValidator implements Validator { + + private final CustomValidatorConfig validatorConfig; + + public CustomValidator(CustomValidatorConfig validatorConfig) { + this.validatorConfig = validatorConfig; + } + + /** + * 本校验器只针对 Person 对象进行校验 + */ + @Override + public boolean supports(Class clazz) { + return Person.class.equals(clazz); + } + + @Override + public void validate(Object target, Errors errors) { + ValidationUtils.rejectIfEmpty(errors, "name", "name.empty"); + + List fields = getFields(target.getClass()); + for (Field field : fields) { + Annotation[] annotations = field.getAnnotations(); + for (Annotation annotation : annotations) { + if (annotation.annotationType().getAnnotation(Valid.class) != null) { + try { + ValidatorRule validatorRule = validatorConfig.findRule(annotation); + if (validatorRule != null) { + validatorRule.valid(annotation, target, field, errors); + } + } catch (Exception e) { + e.printStackTrace(); + } + } + } + } + } + + private List getFields(Class clazz) { + // 声明Field数组 + List fields = new ArrayList<>(); + // 如果class类型不为空 + while (clazz != null) { + // 添加属性到属性数组 + Collections.addAll(fields, clazz.getDeclaredFields()); + clazz = clazz.getSuperclass(); + } + return fields; + } + +} +``` + +### 快速失败(Fail Fast) + +Spring Validation 默认会校验完所有字段，然后才抛出异常。可以通过一些简单的配置，开启 Fali Fast 模式，一旦校验失败就立即返回。 + +```scss +@Bean +public Validator validator() { + ValidatorFactory validatorFactory = Validation.byProvider(HibernateValidator.class) + .configure() + // 快速失败模式 + .failFast(true) + .buildValidatorFactory(); + return validatorFactory.getValidator(); +} +``` + +## Spring 校验原理 + +### Spring 校验使用场景 + +- Spring 常规校验（Validator） +- Spring 数据绑定（DataBinder） +- Spring Web 参数绑定（WebDataBinder） +- Spring WebMVC/WebFlux 处理方法参数校验 + +### Validator 接口设计 + +- 接口职责 + - Spring 内部校验器接口，通过编程的方式校验目标对象 +- 核心方法 + - `supports(Class)`：校验目标类能否校验 + - `validate(Object,Errors)`：校验目标对象，并将校验失败的内容输出至 Errors 对象 +- 配套组件 + - 错误收集器：`org.springframework.validation.Errors` + - Validator 工具类：`org.springframework.validation.ValidationUtils` + +### Errors 接口设计 + +- 接口职责 + - 数据绑定和校验错误收集接口，与 Java Bean 和其属性有强关联性 +- 核心方法 + - `reject` 方法（重载）：收集错误文案 + - `rejectValue` 方法（重载）：收集对象字段中的错误文案 +- 配套组件 + - Java Bean 错误描述：`org.springframework.validation.ObjectError` + - Java Bean 属性错误描述：`org.springframework.validation.FieldError` + +### Errors 文案来源 + +Errors 文案生成步骤 + +- 选择 Errors 实现（如：`org.springframework.validation.BeanPropertyBindingResult`） +- 调用 reject 或 rejectValue 方法 +- 获取 Errors 对象中 ObjectError 或 FieldError +- 将 ObjectError 或 FieldError 中的 code 和 args，关联 MessageSource 实现（如：`ResourceBundleMessageSource`） + +### spring web 校验原理 + +#### RequestBody 参数校验实现原理 + +在 spring-mvc 中，`RequestResponseBodyMethodProcessor` 是用于解析 `@RequestBody` 标注的参数以及处理`@ResponseBody` 标注方法的返回值的。其中，执行参数校验的逻辑肯定就在解析参数的方法 `resolveArgument()` 中： + +```java +@Override +public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, + NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception { + + parameter = parameter.nestedIfOptional(); + Object arg = readWithMessageConverters(webRequest, parameter, parameter.getNestedGenericParameterType()); + String name = Conventions.getVariableNameForParameter(parameter); + + if (binderFactory != null) { + WebDataBinder binder = binderFactory.createBinder(webRequest, arg, name); + if (arg != null) { + // 尝试进行参数校验 + validateIfApplicable(binder, parameter); + if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) { + // 如果存在校验错误，则抛出 MethodArgumentNotValidException + throw new MethodArgumentNotValidException(parameter, binder.getBindingResult()); + } + } + if (mavContainer != null) { + mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult()); + } + } + + return adaptArgumentIfNecessary(arg, parameter); +} +``` + +可以看到，resolveArgument()调用了 validateIfApplicable()进行参数校验。 + +```java +protected void validateIfApplicable(WebDataBinder binder, MethodParameter parameter) { + // 获取参数注解，如 @RequestBody、@Valid、@Validated + Annotation[] annotations = parameter.getParameterAnnotations(); + for (Annotation ann : annotations) { + // 先尝试获取 @Validated 注解 + Validated validatedAnn = AnnotationUtils.getAnnotation(ann, Validated.class); + // 如果标注了 @Validated，直接开始校验。 + // 如果没有，那么判断参数前是否有 Valid 开头的注解。 + if (validatedAnn != null || ann.annotationType().getSimpleName().startsWith("Valid")) { + Object hints = (validatedAnn != null ? validatedAnn.value() : AnnotationUtils.getValue(ann)); + Object[] validationHints = (hints instanceof Object[] ? (Object[]) hints : new Object[] {hints}); + // 执行校验 + binder.validate(validationHints); + break; + } + } +} +``` + +以上代码，就解释了 Spring 为什么能同时支持 `@Validated`、`@Valid` 两个注解。 + +接下来，看一下 WebDataBinder.validate() 的实现： + +```typescript +@Override +public void validate(Object target, Errors errors, Object... validationHints) { + if (this.targetValidator != null) { + processConstraintViolations( + // 此处调用 Hibernate Validator 执行真正的校验 + this.targetValidator.validate(target, asValidationGroups(validationHints)), errors); + } +} +``` + +通过上面代码，可以看出 Spring 校验实际上是基于 Hibernate Validator 的封装。 + +#### 方法级别的参数校验实现原理 + +Spring 支持根据方法去进行拦截、校验，原理就在于应用了 AOP 技术。具体来说，是通过 `MethodValidationPostProcessor` 动态注册 AOP 切面，然后使用 `MethodValidationInterceptor` 对切点方法织入增强。 + +```java +public class MethodValidationPostProcessor extends AbstractBeanFactoryAwareAdvisingPostProcessorimplements InitializingBean { + @Override + public void afterPropertiesSet() { + // 为所有 @Validated 标注的 Bean 创建切面 + Pointcut pointcut = new AnnotationMatchingPointcut(this.validatedAnnotationType, true); + // 创建 Advisor 进行增强 + this.advisor = new DefaultPointcutAdvisor(pointcut, createMethodValidationAdvice(this.validator)); + } + + // 创建 Advice，本质就是一个方法拦截器 + protected Advice createMethodValidationAdvice(@Nullable Validator validator) { + return (validator != null ? new MethodValidationInterceptor(validator) : new MethodValidationInterceptor()); + } +} +``` + +接着看一下 `MethodValidationInterceptor`： + +```scss +public class MethodValidationInterceptor implements MethodInterceptor { + @Override + public Object invoke(MethodInvocation invocation) throws Throwable { + // 无需增强的方法，直接跳过 + if (isFactoryBeanMetadataMethod(invocation.getMethod())) { + return invocation.proceed(); + } + // 获取分组信息 + Class[] groups = determineValidationGroups(invocation); + ExecutableValidator execVal = this.validator.forExecutables(); + Method methodToValidate = invocation.getMethod(); + Set> result; + try { + // 方法入参校验，最终还是委托给 Hibernate Validator 来校验 + result = execVal.validateParameters( + invocation.getThis(), methodToValidate, invocation.getArguments(), groups); + } + catch (IllegalArgumentException ex) { + ... + } + // 有异常直接抛出 + if (!result.isEmpty()) { + throw new ConstraintViolationException(result); + } + // 真正的方法调用 + Object returnValue = invocation.proceed(); + // 对返回值做校验，最终还是委托给Hibernate Validator来校验 + result = execVal.validateReturnValue(invocation.getThis(), methodToValidate, returnValue, groups); + // 有异常直接抛出 + if (!result.isEmpty()) { + throw new ConstraintViolationException(result); + } + return returnValue; + } +} +``` + +实际上，不管是 requestBody 参数校验还是方法级别的校验，最终都是调用 Hibernate Validator 执行校验，Spring Validation 只是做了一层封装。 + +## 问题 + +**Spring 有哪些校验核心组件**？ + +- 检验器：`org.springframework.validation.Validator` +- 错误收集器：`org.springframework.validation.Errors` +- Java Bean 错误描述：`org.springframework.validation.ObjectError` +- Java Bean 属性错误描述：`org.springframework.validation.FieldError` +- Bean Validation 适配：`org.springframework.validation.beanvalidation.LocalValidatorFactoryBean` + +## 参考资料 + +- [Spring 官方文档之 Core Technologies](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans) +- [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) +- https://juejin.cn/post/6856541106626363399 \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/22.Spring\346\225\260\346\215\256\347\273\221\345\256\232.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/22.Spring\346\225\260\346\215\256\347\273\221\345\256\232.md" new file mode 100644 index 00000000..3c5fe260 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/22.Spring\346\225\260\346\215\256\347\273\221\345\256\232.md" @@ -0,0 +1,181 @@ +--- +title: Spring 数据绑定 +date: 2022-12-22 19:26:57 +order: 22 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring + - 数据绑定 +permalink: /pages/267b4c/ +--- + +# Spring 数据绑定 + +**Spring 数据绑定(Data Binding)的作用是将用户的输入动态绑定到 JavaBean**。换句话说，Spring 数据绑定机制是将属性值设置到目标对象中。 + +在 Spring 中，数据绑定功能主要由 `DataBinder` 类实现。此外，`BeanWrapper` 也具有类似的功能，但 `DataBinder` 额外支持字段验证、字段格式化和绑定结果分析。 + +![](https://raw.githubusercontent.com/dunwu/images/master/snap/20230111150930.png) + +## 快速入门 + +定义一个用于测试的 JavaBean + +```java +public class TestBean { + + private int num; + + public int getNum() { + return num; + } + + public void setNum(int num) { + this.num = num; + } + + @Override + public String toString() { + return "TestBean{" + "num=" + num + '}'; + } + +} +``` + +数据绑定示例 + +```java +public class DataBindingDemo { + + public static void main(String[] args) { + + MutablePropertyValues mpv = new MutablePropertyValues(); + mpv.add("num", "10"); + + TestBean testBean = new TestBean(); + DataBinder db = new DataBinder(testBean); + + db.bind(mpv); + System.out.println(testBean); + } + +} +``` + +## Spring 数据绑定使用场景 + +- Spring `BeanDefinition` 到 Bean 实例创建 +- Spring 数据绑定（`DataBinder`） +- Spring Web 参数绑定（`WebDataBinder`） + +## DataBinder + +在 Spring 中，`DataBinder` 类是数据绑定功能的基类。`WebDataBinder` 是 `DataBinder` 的子类，主要用于 Spring Web 数据绑定，此外，还有一些 `WebDataBinder` 的扩展子类，其类族如下图所示： + +![](https://raw.githubusercontent.com/dunwu/images/master/snap/20230111152225.png) + +DataBinder 核心属性： + +| 属性 | 说明 | +| ---------------------- | ------------------------------ | +| `target` | 关联目标 Bean | +| `objectName` | 目标 Bean 名称 | +| `bindingResult` | 属性绑定结果 | +| `typeConverter` | 类型转换器 | +| `conversionService` | 类型转换服务 | +| `messageCodesResolver` | 校验错误文案 Code 处理器 | +| `validators` | 关联的 Bean Validator 实例集合 | + +`DataBinder` 类的核心方法是 `bind(PropertyValues)`：将 PropertyValues Key-Value 内容映射到关联 Bean（target）中的属性上 + +- 假设 PropertyValues 中包含 name=dunwu 的键值对时, 同时 Bean 对象 User 中存在 name 属性, 当 bind 方法执行时, User 对象中的 name 属性值将被绑定为 dunwu + +## Spring 数据绑定元数据 + +DataBinder 元数据 - PropertyValues + +| 特征 | 说明 | +| ------------ | -------------------------------------------------------------------- | +| 数据来源 | BeanDefinition，主要来源 XML 资源配置 BeanDefinition | +| 数据结构 | 由一个或多个 PropertyValue 组成 | +| 成员结构 | PropertyValue 包含属性名称，以及属性值（包括原始值、类型转换后的值） | +| 常见实现 | MutablePropertyValues | +| Web 扩展实现 | ServletConfigPropertyValues、ServletRequestParameterPropertyValues | +| 相关生命周期 | InstantiationAwareBeanPostProcessor#postProcessProperties | + +## Spring 数据绑定控制参数 + +DataBinder 绑定特殊场景分析 + +- 当 PropertyValues 中包含名称 x 的 PropertyValue，目标对象 B 不存在 x 属性，当 bind 方法执 + 行时，会发生什么？ +- 当 PropertyValues 中包含名称 x 的 PropertyValue，目标对象 B 中存在 x 属性，当 bind 方法执 + 行时，如何避免 B 属性 x 不被绑定？ +- 当 PropertyValues 中包含名称 x.y 的 PropertyValue，目标对象 B 中存在 x 属性（嵌套 y 属性） + ，当 bind 方法执行时，会发生什么？ + +### DataBinder 绑定控制参数 + +| 参数名称 | 说明 | +| ------------------- | ---------------------------------- | +| ignoreUnknownFields | 是否忽略未知字段，默认值：true | +| ignoreInvalidFields | 是否忽略非法字段，默认值：false | +| autoGrowNestedPaths | 是否自动增加嵌套路径，默认值：true | +| allowedFields | 绑定字段白名单 | +| disallowedFields | 绑定字段黑名单 | +| requiredFields | 必须绑定字段 | + +## BeanWrapper 的使用场景 + +- Spring 底层 JavaBeans 基础设施的中心化接口 +- 通常不会直接使用，间接用于 BeanFactory 和 DataBinder +- 提供标准 JavaBeans 分析和操作，能够单独或批量存储 Java Bean 的属性（properties） +- 支持嵌套属性路径（nested path） +- 实现类 org.springframework.beans.BeanWrapperImpl + +## Spring 底层 Java Beans 替换实现 + +JavaBeans 核心实现 - `java.beans.BeanInfo` + +- 属性（Property） + - `java.beans.PropertyEditor` +- 方法（Method） +- 事件（Event） +- 表达式（Expression） + +Spring 替代实现 - `org.springframework.beans.BeanWrapper` + +- 属性（Property） + - `java.beans.PropertyEditor` +- 嵌套属性路径（nested path） + +## DataBinder 数据校验 + +DataBinder 与 BeanWrapper + +- bind 方法生成 BeanPropertyBindingResult +- BeanPropertyBindingResult 关联 BeanWrapper + +## 问题 + +标准 JavaBeans 是如何操作属性的？ + +| API | 说明 | +| ----------------------------- | ------------------------ | +| java.beans.Introspector | Java Beans 内省 API | +| java.beans.BeanInfo | Java Bean 元信息 API | +| java.beans.BeanDescriptor | Java Bean 信息描述符 | +| java.beans.PropertyDescriptor | Java Bean 属性描述符 | +| java.beans.MethodDescriptor | Java Bean 方法描述符 | +| java.beans.EventSetDescriptor | Java Bean 事件集合描述符 | + +## 参考资料 + +- [Spring 官方文档之 Core Technologies](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans) +- [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/23.Spring\347\261\273\345\236\213\350\275\254\346\215\242.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/23.Spring\347\261\273\345\236\213\350\275\254\346\215\242.md" new file mode 100644 index 00000000..2da331a6 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/23.Spring\347\261\273\345\236\213\350\275\254\346\215\242.md" @@ -0,0 +1,214 @@ +--- +title: Spring 类型转换 +date: 2022-12-22 19:43:59 +order: 23 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring +permalink: /pages/6662dc/ +--- + +# Spring 类型转换 + +## Spring 类型转换的实现 + +- 基于 JavaBeans 接口的类型转换实现 + - 基于 java.beans.PropertyEditor 接口扩展 +- Spring 3.0+ 通用类型转换实现 + +## 使用场景 + +| 场景 | 基于 JavaBeans 接口的类型转换实现 | Spring 3.0+ 通用类型转换实现 | +| ------------------ | --------------------------------- | ---------------------------- | +| 数据绑定 | YES | YES | +| BeanWrapper | YES | YES | +| Bean 属性类型转换 | YES | YES | +| 外部化属性类型转换 | NO | YES | + +## 基于 JavaBeans 接口的类型转换 + +核心职责 + +- 将 String 类型的内容转化为目标类型的对象 + +扩展原理 + +- Spring 框架将文本内容传递到 PropertyEditor 实现的 setAsText(String) 方法 +- PropertyEditor#setAsText(String) 方法实现将 String 类型转化为目标类型的对象 +- 将目标类型的对象传入 PropertyEditor#setValue(Object) 方法 +- PropertyEditor#setValue(Object) 方法实现需要临时存储传入对象 +- Spring 框架将通过 PropertyEditor#getValue() 获取类型转换后的对象 + +## Spring 內建 PropertyEditor 扩展 + +內建扩展（org.springframework.beans.propertyeditors 包下） + +| 转换场景 | 实现类 | +| ------------------- | ----------------------------------------------------------------- | +| String -> Byte 数组 | org.springframework.beans.propertyeditors.ByteArrayPropertyEditor | +| String -> Char | org.springframework.beans.propertyeditors.CharacterEditor | +| String -> Char 数组 | org.springframework.beans.propertyeditors.CharArrayPropertyEditor | +| String -> Charset | org.springframework.beans.propertyeditors.CharsetEditor | +| String -> Class | org.springframework.beans.propertyeditors.ClassEditor | +| String -> Currency | org.springframework.beans.propertyeditors.CurrencyEditor | +| | | + +## 自定义 PropertyEditor 扩展 + +扩展模式 + +- 扩展 `java.beans.PropertyEditorSupport` 类 + +实现 `org.springframework.beans.PropertyEditorRegistrar` + +- 实现 `registerCustomEditors(org.springframework.beans.PropertyEditorRegistry)` 方法 +- 将 `PropertyEditorRegistrar` 实现注册为 Spring Bean + +向 `org.springframework.beans.PropertyEditorRegistry` 注册自定义 PropertyEditor 实现 + +- 通用类型实现 `registerCustomEditor(Class, PropertyEditor)` +- Java Bean 属性类型实现：`registerCustomEditor(Class, String, PropertyEditor)` + +## Spring PropertyEditor 的设计缺陷 + +违反职责单一原则 + +- `java.beans.PropertyEditor` 接口职责太多，除了类型转换，还包括 Java Beans 事件和 Java GUI 交 + 互 + +`java.beans.PropertyEditor` 实现类型局限 + +- 来源类型只能为 `java.lang.String` 类型 + +`java.beans.PropertyEditor` 实现缺少类型安全 + +- 除了实现类命名可以表达语义，实现类无法感知目标转换类型 + +## Spring 3 通用类型转换接口 + +类型转换接口 - org.springframework.core.convert.converter.Converter + +- 泛型参数 S：来源类型，参数 T：目标类型 +- 核心方法：T convert(S) + +通用类型转换接口 - org.springframework.core.convert.converter.GenericConverter + +- 核心方法：convert(Object,TypeDescriptor,TypeDescriptor) +- 配对类型：org.springframework.core.convert.converter.GenericConverter.ConvertiblePair +- 类型描述：org.springframework.core.convert.TypeDescriptor + +## Spring 內建类型转换器 + +內建扩展 + +| 转换场景 | 实现类所在包名（package） | +| -------------------- | -------------------------------------------- | +| 日期/时间相关 | org.springframework.format.datetime | +| Java 8 日期/时间相关 | org.springframework.format.datetime.standard | +| 通用实现 | org.springframework.core.convert.support | + +## Converter 接口的局限性 + +局限一：缺少 Source Type 和 Target Type 前置判断 + +- 应对：增加 org.springframework.core.convert.converter.ConditionalConverter 实现 + +局限二：仅能转换单一的 Source Type 和 Target Type + +- 应对：使用 org.springframework.core.convert.converter.GenericConverter 代替 + +## GenericConverter 接口 + +`org.springframework.core.convert.converter.GenericConverter` + +| 核心要素 | 说明 | +| -------- | ----------------------------------------------------------------------------- | +| 使用场景 | 用于“复合”类型转换场景，比如 Collection、Map、数组等 | +| 转换范围 | `Set getConvertibleTypes()` | +| 配对类型 | `org.springframework.core.convert.converter.GenericConverter.ConvertiblePair` | +| 转换方法 | `convert(Object,TypeDescriptor,TypeDescriptor)` | +| 类型描述 | `org.springframework.core.convert.TypeDescriptor` | + +## 优化 GenericConverter 接口 + +GenericConverter 局限性 + +- 缺少 Source Type 和 Target Type 前置判断 +- 单一类型转换实现复杂 + +GenericConverter 优化接口 - `ConditionalGenericConverter` + +- 复合类型转换：`org.springframework.core.convert.converter.GenericConverter` +- 类型条件判断：`org.springframework.core.convert.converter.ConditionalConverter` + +## 扩展 Spring 类型转换器 + +实现转换器接口 + +- `org.springframework.core.convert.converter.Converter` +- `org.springframework.core.convert.converter.ConverterFactory` +- `org.springframework.core.convert.converter.GenericConverter` + +注册转换器实现 + +- 通过 `ConversionServiceFactoryBean` Spring Bean +- 通过 `org.springframework.core.convert.ConversionService API` + +## 统一类型转换服务 + +`org.springframework.core.convert.ConversionService` + +| 实现类型 | 说明 | +| ------------------------------------ | ----------------------------------------------------------------------------------------- | +| `GenericConversionService` | 通用 ConversionService 模板实现，不内置转化器实现 | +| `DefaultConversionService` | 基础 ConversionService 实现，内置常用转化器实现 | +| `FormattingConversionService` | 通用 Formatter + GenericConversionService 实现，不内置转化器和 Formatter 实现 | +| `DefaultFormattingConversionService` | DefaultConversionService + 格式化实现（如：JSR-354 Money & Currency, JSR-310 Date-Time） | + +## ConversionService 作为依赖 + +类型转换器底层接口 - `org.springframework.beans.TypeConverter` + +- 起始版本：Spring 2.0 +- 核心方法 - convertIfNecessary 重载方法 +- 抽象实现 - `org.springframework.beans.TypeConverterSupport` +- 简单实现 - `org.springframework.beans.SimpleTypeConverter` + +类型转换器底层抽象实现 - `org.springframework.beans.TypeConverterSupport` + +- 实现接口 - `org.springframework.beans.TypeConverter` +- 扩展实现 - `org.springframework.beans.PropertyEditorRegistrySupport` +- 委派实现 - `org.springframework.beans.TypeConverterDelegate` + +类型转换器底层委派实现 - `org.springframework.beans.TypeConverterDelegate` + +- 构造来源 - `org.springframework.beans.AbstractNestablePropertyAccessor` 实现 + - `org.springframework.beans.BeanWrapperImpl` +- 依赖 - `java.beans.PropertyEditor` 实现 + - 默认內建实现 - `PropertyEditorRegistrySupport#registerDefaultEditors` +- 可选依赖 - `org.springframework.core.convert.ConversionService` 实现 + +## 问题 + +**Spring 类型转换实现有哪些**？ + +- 基于 JavaBeans PropertyEditor 接口实现 +- Spring 3.0+ 通用类型转换实现 + +**Spring 类型转换器接口有哪些**？ + +- 类型转换接口 - `org.springframework.core.convert.converter.Converter` +- 通用类型转换接口 - `org.springframework.core.convert.converter.GenericConverter` +- 类型条件接口 - `org.springframework.core.convert.converter.ConditionalConverter` +- 综合类型转换接口 - `org.springframework.core.convert.converter.ConditionalGenericConverter` + +## 参考资料 + +- [Spring 官方文档之 Core Technologies](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans) +- [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/24.SpringEL.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/24.SpringEL.md" new file mode 100644 index 00000000..1e939038 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/24.SpringEL.md" @@ -0,0 +1,22 @@ +--- +title: Spring EL 表达式 +date: 2023-01-12 20:26:46 +order: 24 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring +permalink: /pages/1f743f/ +--- + +# Spring EL 表达式 + +## 参考资料 + +- [Spring 官方文档之 Core Technologies](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans) +- [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/25.Spring\344\272\213\344\273\266.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/25.Spring\344\272\213\344\273\266.md" new file mode 100644 index 00000000..8dc880d0 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/25.Spring\344\272\213\344\273\266.md" @@ -0,0 +1,232 @@ +--- +title: Spring 事件 +date: 2022-12-22 20:31:02 +order: 25 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring +permalink: /pages/cca414/ +--- + +# Spring 事件 + +## Java 事件/监听器编程模型 + +设计模式 - 观察者模式扩展 + +- 可观者对象（消息发送者） - java.util.Observable +- 观察者 - java.util.Observer + +标准化接口 + +- 事件对象 - java.util.EventObject +- 事件监听器 - java.util.EventListener + +## 面向接口的事件/监听器设计模式 + +事件/监听器场景举例 + +| Java 技术规范 | 事件接口 | 监听器接口 | +| --------------- | ------------------------------------- | ---------------------------------------- | +| JavaBeans | java.beans.PropertyChangeEvent | java.beans.PropertyChangeListener | +| Java AWT | java.awt.event.MouseEvent | java.awt.event.MouseListener | +| Java Swing | javax.swing.event.MenuEvent | javax.swing.event.MenuListener | +| Java Preference | java.util.prefs.PreferenceChangeEvent | java.util.prefs.PreferenceChangeListener | + +## 面向注解的事件/监听器设计模式 + +事件/监听器注解场景举例 + +| Java 技术规范 | 事件注解 | 监听器注解 | +| ------------- | ------------------------------ | ------------------------------------- | +| Servlet 3.0+ | | @javax.servlet.annotation.WebListener | +| JPA 1.0+ | @javax.persistence.PostPersist | | +| Java Common | @PostConstruct | | +| EJB 3.0+ | @javax.ejb.PrePassivate | | +| JSF 2.0+ | @javax.faces.event.ListenerFor | | + +## Spring 标准事件 - ApplicationEvent + +Java 标准事件 `java.util.EventObject` 扩展 + +- 扩展特性：事件发生事件戳 +- Spring 应用上下文 ApplicationEvent 扩展 - `ApplicationContextEvent` +- Spring 应用上下文（ApplicationContext）作为事件源 + +具体实现： + +- `org.springframework.context.event.ContextClosedEvent` +- `org.springframework.context.event.ContextRefreshedEvent` +- `org.springframework.context.event.ContextStartedEvent` +- `org.springframework.context.event.ContextStoppedEvent` + +## 基于接口的 Spring 事件监听器 + +Java 标准事件监听器 `java.util.EventListener` 扩展 + +- 扩展接口 - `org.springframework.context.ApplicationListener` +- 设计特点：单一类型事件处理 +- 处理方法：`onApplicationEvent(ApplicationEvent)` +- 事件类型：`org.springframework.context.ApplicationEvent` + +## 基于注解的 Spring 事件监听器 + +Spring 注解 - `@org.springframework.context.event.EventListener` + +| 特性 | 说明 | +| -------------------- | -------------------------------------------- | +| 设计特点 | 支持多 `ApplicationEvent` 类型，无需接口约束 | +| 注解目标 | 方法 | +| 是否支持异步执行 | 支持 | +| 是否支持泛型类型事件 | 支持 | +| 是指支持顺序控制 | 支持，配合 `@Order` 注解控制 | + +## 注册 Spring ApplicationListener + +- 方法一：ApplicationListener 作为 Spring Bean 注册 +- 方法二：通过 ConfigurableApplicationContext API 注册 + +## Spring 事件发布器 + +- 方法一：通过 ApplicationEventPublisher 发布 Spring 事件 + - 获取 ApplicationEventPublisher + - 依赖注入 +- 方法二：通过 ApplicationEventMulticaster 发布 Spring 事件 + - 获取 ApplicationEventMulticaster + - 依赖注入 + - 依赖查找 + +## Spring 层次性上下文事件传播 + +- 发生说明 +- 当 Spring 应用出现多层次 Spring 应用上下文（ApplicationContext）时，如 Spring WebMVC、Spring Boot 或 Spring Cloud 场景下，由子 ApplicationContext 发起 Spring 事件可能会传递到其 Parent ApplicationContext（直到 Root）的过程 +- 如何避免 +- 定位 Spring 事件源（ApplicationContext）进行过滤处理 + +## Spring 内建事件 + +ApplicationContextEvent 派生事件 + +- ContextRefreshedEvent ：Spring 应用上下文就绪事件 +- ContextStartedEvent ：Spring 应用上下文启动事件 +- ContextStoppedEvent ：Spring 应用上下文停止事件 +- ContextClosedEvent ：Spring 应用上下文关闭事件 + +## Spring 4.2 Payload 事件 + +Spring Payload 事件 - org.springframework.context.PayloadApplicationEvent + +- 使用场景：简化 Spring 事件发送，关注事件源主体 +- 发送方法：ApplicationEventPublisher#publishEvent(java.lang.Object) + +## 自定义 Spring 事件 + +- 扩展 org.springframework.context.ApplicationEvent +- 实现 org.springframework.context.ApplicationListener +- 注册 org.springframework.context.ApplicationListener + +## 依赖注入 ApplicationEventPublisher + +- 通过 ApplicationEventPublisherAware 回调接口 +- 通过 @Autowired ApplicationEventPublisher + +## 依赖查找 ApplicationEventMulticaster + +查找条件 + +- Bean 名称："applicationEventMulticaster" +- Bean 类型：org.springframework.context.event.ApplicationEventMulticaster + +## ApplicationEventPublisher 底层实现 + +- 接口：org.springframework.context.event.ApplicationEventMulticaster +- 抽象类：org.springframework.context.event.AbstractApplicationEventMulticaster +- 实现类：org.springframework.context.event.SimpleApplicationEventMulticaster + +## 同步和异步 Spring 事件广播 + +基于实现类 - `org.springframework.context.event.SimpleApplicationEventMulticaster` + +- 模式切换：`setTaskExecutor(java.util.concurrent.Executor)` 方法 + - 默认模式：同步 + - 异步模式：如 `java.util.concurrent.ThreadPoolExecutor` +- 设计缺陷：非基于接口契约编程 + +基于注解 - `@org.springframework.context.event.EventListener` + +- 模式切换 + - 默认模式：同步 + - 异步模式：标注 `@org.springframework.scheduling.annotation.Async` +- 实现限制：无法直接实现同步/异步动态切换 + +## Spring 4.1 事件异常处理 + +Spring 3.0 错误处理接口 - org.springframework.util.ErrorHandler + +使用场景 + +- Spring 事件（Events） + - SimpleApplicationEventMulticaster Spring 4.1 开始支持 +- Spring 本地调度（Scheduling） + - org.springframework.scheduling.concurrent.ConcurrentTaskScheduler + - org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler + +## Spring 事件/监听器实现原理 + +核心类 - `org.springframework.context.event.SimpleApplicationEventMulticaster` + +- 设计模式：观察者模式扩展 + - 被观察者 - org.springframework.context.ApplicationListener + - API 添加 + - 依赖查找 + - 通知对象 - org.springframework.context.ApplicationEvent +- 执行模式：同步/异步 +- 异常处理：org.springframework.util.ErrorHandler +- 泛型处理：org.springframework.core.ResolvableType + +## 问题 + +**Spring Boot 事件** + +| 事件类型 | 发生时机 | +| ----------------------------------- | --------------------------------------- | +| ApplicationStartingEvent | 当 Spring Boot 应用已启动时 | +| ApplicationStartedEvent | 当 Spring Boot 应用已启动时 | +| ApplicationEnvironmentPreparedEvent | 当 Spring Boot Environment 实例已准备时 | +| ApplicationPreparedEvent | 当 Spring Boot 应用预备时 | +| ApplicationReadyEvent | 当 Spring Boot 应用完全可用时 | +| ApplicationFailedEvent | 当 Spring Boot 应用启动失败时 | + +**Spring Cloud 事件** + +| 事件类型 | 发生时机 | +| -------------------------- | ------------------------------------- | +| EnvironmentChangeEvent | 当 Environment 示例配置属性发生变化时 | +| HeartbeatEvent | 当 DiscoveryClient 客户端发送心跳时 | +| InstancePreRegisteredEvent | 当服务实例注册前 | +| InstanceRegisteredEvent | 当服务实例注册后 | +| RefreshEvent | 当 RefreshEndpoint 被调用时 | +| RefreshScopeRefreshedEvent | 当 Refresh Scope Bean 刷新后 | + +**Spring 事件核心接口/组件**？ + +- Spring 事件 - org.springframework.context.ApplicationEvent +- Spring 事件监听器 - org.springframework.context.ApplicationListener +- Spring 事件发布器 - org.springframework.context.ApplicationEventPublisher +- Spring 事件广播器 - org.springframework.context.event.ApplicationEventMulticaster + +**Spring 同步和异步事件处理的使用场景**？ + +- Spring 同步事件 - 绝大多数 Spring 使用场景，如 ContextRefreshedEvent +- Spring 异步事件 - 主要 @EventListener 与 @Async 配合，实现异步处理，不阻塞主线程，比如长时间的数据计算任务等。不要轻易调整 SimpleApplicationEventMulticaster 中关联的 taskExecutor 对象，除非使用者非常了解 Spring 事件机制，否则容易出现异常行为。 + +## 参考资料 + +- [Spring 官方文档之 Core Technologies](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans) +- [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/26.Spring\345\233\275\351\231\205\345\214\226.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/26.Spring\345\233\275\351\231\205\345\214\226.md" new file mode 100644 index 00000000..e07843fd --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/26.Spring\345\233\275\351\231\205\345\214\226.md" @@ -0,0 +1,121 @@ +--- +title: Spring 国际化 +date: 2022-12-22 11:44:54 +order: 26 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring +permalink: /pages/b5b8ad/ +--- + +# Spring 国际化 + +## Spring 国际化使用场景 + +- 普通国际化文案 +- Bean Validation 校验国际化文案 +- Web 站点页面渲染 +- Web MVC 错误消息提示 + +## Spring 国际化接口 + +- 核心接口：`org.springframework.context.MessageSource` +- 主要概念 + - 文案模板编码（code） + - 文案模板参数（args） + - 区域（Locale） + +## 层次性 MessageSource + +- Spring 层次性接口回顾 + - `org.springframework.beans.factory.HierarchicalBeanFactory` + - `org.springframework.context.ApplicationContext` + - `org.springframework.beans.factory.config.BeanDefinition` +- Spring 层次性国际化接口 + - `org.springframework.context.HierarchicalMessageSource` + +## Java 国际化标准实现 + +核心接口： + +- 抽象实现 - `java.util.ResourceBundle` +- Properties 资源实现 - `java.util.PropertyResourceBundle` +- 例举实现 - `java.util.ListResourceBundle` + +`ResourceBundle` 核心特性 + +- Key-Value 设计 +- 层次性设计 +- 缓存设计 +- 字符编码控制 - `java.util.ResourceBundle.Control`（@since 1.6） +- Control SPI 扩展 - `java.util.spi.ResourceBundleControlProvider`（@since 1.8） + +## Java 文本格式化 + +- 核心接口 + - java.text.MessageFormat +- 基本用法 + - 设置消息格式模式- new MessageFormat(...) + - 格式化 - format(new Object[]{...}) +- 消息格式模式 + - 格式元素：{ArgumentIndex (,FormatType,(FormatStyle))} + - FormatType：消息格式类型，可选项，每种类型在 number、date、time 和 choice 类型选其一 + - FormatStyle：消息格式风格，可选项，包括：short、medium、long、full、integer、currency、 + percent +- 高级特性 + - 重置消息格式模式 + - 重置 java.util.Locale + - 重置 java.text.Format + +## MessageSource 开箱即用实现 + +- 基于 ResourceBundle + MessageFormat 组合 MessageSource 实现 +- org.springframework.context.support.ResourceBundleMessageSource +- 可重载 Properties + MessageFormat 组合 MessageSource 实现 +- org.springframework.context.support.ReloadableResourceBundleMessageSource + +## MessageSource 內建依赖 + +- MessageSource 內建 Bean 可能来源 +- 预注册 Bean 名称为：“messageSource”，类型为：MessageSource Bean +- 默认內建实现 - DelegatingMessageSource +- 层次性查找 MessageSource 对象 + +## 问题 + +**Spring Boot 为什么要新建 MessageSource Bean**？ + +- AbstractApplicationContext 的实现决定了 MessageSource 內建实现 +- Spring Boot 通过外部化配置简化 MessageSource Bean 构建 +- Spring Boot 基于 Bean Validation 校验非常普遍 + +**Spring 国际化接口有哪些**？ + +- 核心接口 - MessageSource +- 层次性接口 - `org.springframework.context.HierarchicalMessageSource` + +**Spring 有哪些 MessageSource 內建实现**？ + +- `org.springframework.context.support.ResourceBundleMessageSource` +- `org.springframework.context.support.ReloadableResourceBundleMessageSource` +- `org.springframework.context.support.StaticMessageSource` +- `org.springframework.context.support.DelegatingMessageSource` + +**如何实现配置自动更新 MessageSource**？ + +主要技术 + +- Java NIO 2：`java.nio.file.WatchService` +- Java Concurrency : `java.util.concurrent.ExecutorService` +- Spring：`org.springframework.context.support.AbstractMessageSource` + +## 参考资料 + +- [Spring 官方文档之 Core Technologies](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans) +- [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/27.Spring\346\263\233\345\236\213\345\244\204\347\220\206.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/27.Spring\346\263\233\345\236\213\345\244\204\347\220\206.md" new file mode 100644 index 00000000..ffc2db65 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/27.Spring\346\263\233\345\236\213\345\244\204\347\220\206.md" @@ -0,0 +1,141 @@ +--- +title: Spring 泛型处理 +date: 2022-12-22 20:11:52 +order: 27 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring +permalink: /pages/175cbd/ +--- + +# Spring 泛型处理 + +## Java 泛型基础 + +泛型类型 + +- 泛型类型是在类型上参数化的泛型类或接口 + +泛型使用场景 + +- 编译时强类型检查 +- 避免类型强转 +- 实现通用算法 + +泛型类型擦写 + +- 泛型被引入到 Java 语言中，以便在编译时提供更严格的类型检查并支持泛型编程。类型擦除确保不会 + 为参数化类型创建新类；因此，泛型不会产生运行时开销。为了实现泛型，编译器将类型擦除应用于： + - 将泛型类型中的所有类型参数替换为其边界，如果类型参数是无边界的，则将其替换为 + “Object”。因此，生成的字节码只包含普通类、接口和方法 + - 必要时插入类型转换以保持类型安全 + - 生成桥方法以保留扩展泛型类型中的多态性 + +## Java 5 类型接口 + +Java 5 类型接口 - `java.lang.reflect.Type` + +| 派生类或接口 | 说明 | +| ------------------------------------- | --------------------------------------- | +| `java.lang.Class` | Java 类 API，如 `java.lang.String` | +| `java.lang.reflect.GenericArrayType` | 泛型数组类型 | +| `java.lang.reflect.ParameterizedType` | 泛型参数类型 | +| `java.lang.reflect.TypeVariable` | 泛型类型变量，如 `Collection` 中的 E | +| `java.lang.reflect.WildcardType` | 泛型通配类型 | + +Java 泛型反射 API + +| 类型 | API | +| -------------------------------- | ---------------------------------------- | +| 泛型信息（Generics Info） | `java.lang.Class#getGenericInfo()` | +| 泛型参数（Parameters） | `java.lang.reflect.ParameterizedType` | +| 泛型父类（Super Classes） | `java.lang.Class#getGenericSuperclass()` | +| 泛型接口（Interfaces） | `java.lang.Class#getGenericInterfaces()` | +| 泛型声明（Generics Declaration） | `java.lang.reflect.GenericDeclaration` | + +## Spring 泛型类型辅助类 + +核心 API - `org.springframework.core.GenericTypeResolver` + +- 版本支持：[2.5.2 , ) +- 处理类型相关（Type）相关方法 + - `resolveReturnType` + - `resolveType` +- 处理泛型参数类型（`ParameterizedType`）相关方法 + - `resolveReturnTypeArgument` + - `resolveTypeArgument` + - `resolveTypeArguments` +- 处理泛型类型变量（`TypeVariable`）相关方法 + - `getTypeVariableMap` + +## Spring 泛型集合类型辅助类 + +核心 API - `org.springframework.core.GenericCollectionTypeResolver` + +- 版本支持：[2.0 , 4.3] +- 替换实现：`org.springframework.core.ResolvableType` +- 处理 Collection 相关 + - `getCollection*Type` +- 处理 Map 相关 + - `getMapKey*Type` + - `getMapValue*Type` + +## Spring 方法参数封装 - MethodParameter + +核心 API - `org.springframework.core.MethodParameter` + +- 起始版本：[2.0 , ) +- 元信息 + - 关联的方法 - Method + - 关联的构造器 - Constructor + - 构造器或方法参数索引 - parameterIndex + - 构造器或方法参数类型 - parameterType + - 构造器或方法参数泛型类型 - genericParameterType + - 构造器或方法参数参数名称 - parameterName + - 所在的类 - containingClass + +## Spring 4.0 泛型优化实现 - ResolvableType + +核心 API - `org.springframework.core.ResolvableType` + +- 起始版本：[4.0 , ) +- 扮演角色：`GenericTypeResolver` 和 `GenericCollectionTypeResolver` 替代者 +- 工厂方法：`for*` 方法 +- 转换方法：`as*` 方法 +- 处理方法：`resolve*` 方法 + +## ResolvableType 的局限性 + +- 局限一：ResolvableType 无法处理泛型擦写 +- 局限二：ResolvableType 无法处理非具体化的 ParameterizedType + +## 问题 + +**Java 泛型擦写发生在编译时还是运行时**？ + +运行时 + +**请介绍 Java 5 Type 类型的派生类或接口** + +- `java.lang.Class` +- `java.lang.reflect.GenericArrayType` +- `java.lang.reflect.ParameterizedType` +- `java.lang.reflect.TypeVariable` +- `java.lang.reflect.WildcardType` + +**请说明 ResolvableType 的设计优势**？ + +- 简化 Java 5 Type API 开发，屏蔽复杂 API 的运用，如 ParameterizedType +- 不变性设计（Immutability） +- Fluent API 设计（Builder 模式），链式（流式）编程 + +## 参考资料 + +- [Spring 官方文档之 Core Technologies](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans) +- [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/28.Spring\346\263\250\350\247\243.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/28.Spring\346\263\250\350\247\243.md" new file mode 100644 index 00000000..e8ce595c --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/28.Spring\346\263\250\350\247\243.md" @@ -0,0 +1,147 @@ +--- +title: Spring 注解 +date: 2022-12-23 09:08:15 +order: 28 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring +permalink: /pages/b6556f/ +--- + +# Spring 注解 + +## Spring 注解驱动编程发展历程 + +- 注解驱动启蒙时代：Spring Framework 1.x +- 注解驱动过渡时代：Spring Framework 2.x +- 注解驱动黄金时代：Spring Framework 3.x +- 注解驱动完善时代：Spring Framework 4.x +- 注解驱动当下时代：Spring Framework 5.x + +## Spring 核心注解场景分类 + +Spring 模式注解 + +| Spring 注解 | 场景说明 | 起始版本 | +| -------------- | ------------------ | -------- | +| @Repository | 数据仓储模式注解 | 2.0 | +| @Component | 通用组件模式注解 | 2.5 | +| @Service | 服务模式注解 | 2.5 | +| @Controller | Web 控制器模式注解 | 2.5 | +| @Configuration | 配置类模式注解 | 3.0 | + +装配注解 + +| Spring 注解 | 场景说明 | 起始版本 | +| --------------- | ------------------------------------------- | -------- | +| @ImportResource | 替换 XML 元素 `` | 2.5 | +| @Import | 导入 Configuration 类 | 2.5 | +| @ComponentScan | 扫描指定 package 下标注 Spring 模式注解的类 | 3.1 | + +依赖注入注解 + +| Spring 注解 | 场景说明 | 起始版本 | +| ----------- | ----------------------------------- | -------- | +| @Autowired | Bean 依赖注入，支持多种依赖查找方式 | 2.5 | +| @Qualifier | 细粒度的 @Autowired 依赖查找 | 2.5 | + +## Spring 注解编程模型 + +- 元注解（Meta-Annotations） +- Spring 模式注解（Stereotype Annotations） +- Spring 组合注解（Composed Annotations） +- Spring 注解属性别名和覆盖（Attribute Aliases and Overrides） + +## Spring 元注解（Meta-Annotations） + +- java.lang.annotation.Documented +- java.lang.annotation.Inherited +- java.lang.annotation.Repeatable + +## Spring 模式注解（Stereotype Annotations） + +理解 @Component “派⽣性”：元标注 @Component 的注解在 XML 元素或注解 @ComponentScan 扫描中“派生”了 @Component 的特性，并且从 Spring Framework 4.0 开始支持多层次“派⽣性”。 + +举例说明： + +- @Repository +- @Service +- @Controller +- @Configuration +- @SpringBootConfiguration（Spring Boot） + +@Component “派⽣性”原理 + +- 核心组件 - org.springframework.context.annotation.ClassPathBeanDefinitionScanner +- org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider +- 资源处理 - org.springframework.core.io.support.ResourcePatternResolver +- 资源-类元信息 +- org.springframework.core.type.classreading.MetadataReaderFactory +- 类元信息 - org.springframework.core.type.ClassMetadata +- ASM 实现 - org.springframework.core.type.classreading.ClassMetadataReadingVisitor +- 反射实现 - org.springframework.core.type.StandardAnnotationMetadata +- 注解元信息 - org.springframework.core.type.AnnotationMetadata +- ASM 实现 - org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor +- 反射实现 - org.springframework.core.type.StandardAnnotationMetadata + +## Spring 组合注解（Composed Annotations） + +Spring 组合注解（Composed Annotations）中的元注允许是 Spring 模式注解（Stereotype Annotation）与其他 Spring 功能性注解的任意组合。 + +## Spring 注解属性别名（Attribute Aliases） + +## Spring 注解属性覆盖（Attribute Overrides） + +## Spring @Enable 模块驱动 + +@Enable 模块驱动 + +@Enable 模块驱动是以 @Enable 为前缀的注解驱动编程模型。所谓“模块”是指具备相同领域的功能组件集合，组合所形成⼀个独⽴的单元。⽐如 Web MVC 模块、AspectJ 代理模块、Caching（缓存）模块、JMX（Java 管理扩展）模块、Async（异步处理）模块等。 + +举例说明 + +- @EnableWebMvc +- @EnableTransactionManagement +- @EnableCaching +- @EnableMBeanExport +- @EnableAsync + +@Enable 模块驱动编程模式 + +- 驱动注解：@EnableXXX +- 导入注解：@Import 具体实现 +- 具体实现 +- 基于 Configuration Class +- 基于 ImportSelector 接口实现 +- 基于 ImportBeanDefinitionRegistrar 接口实现 + +## Spring 条件注解 + +基于配置条件注解 - @org.springframework.context.annotation.Profile + +- 关联对象 - org.springframework.core.env.Environment 中的 Profiles +- 实现变化：从 Spring 4.0 开始，@Profile 基于 @Conditional 实现 + +基于编程条件注解 - @org.springframework.context.annotation.Conditional + +- 关联对象 - org.springframework.context.annotation.Condition 具体实现 + +@Conditional 实现原理 + +- 上下文对象 - org.springframework.context.annotation.ConditionContext +- 条件判断 - org.springframework.context.annotation.ConditionEvaluator +- 配置阶段 - org.springframework.context.annotation.ConfigurationCondition.ConfigurationPhase +- 判断入口 + - org.springframework.context.annotation.ConfigurationClassPostProcessor + - org.springframework.context.annotation.ConfigurationClassParser + +## 参考资料 + +- [Spring 官方文档之 Core Technologies](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans) +- [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/29.SpringEnvironment\346\212\275\350\261\241.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/29.SpringEnvironment\346\212\275\350\261\241.md" new file mode 100644 index 00000000..e95e298a --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/29.SpringEnvironment\346\212\275\350\261\241.md" @@ -0,0 +1,167 @@ +--- +title: Spring Environment 抽象 +date: 2022-12-23 09:27:44 +order: 29 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring +permalink: /pages/03d838/ +--- + +# Spring Environment 抽象 + +## 理解 Spring Environment 抽象 + +统一的 Spring 配置属性管理 + +Spring Framework 3.1 开始引入 Environment 抽象，它统一 Spring 配置属性的存储，包括占位符处理和类型转换，不仅完整地替换 PropertyPlaceholderConfigurer，而且还支持更丰富的配置属性源（PropertySource） + +条件化 Spring Bean 装配管理 + +通过 Environment Profiles 信息，帮助 Spring 容器提供条件化地装配 Bean + +## Spring Environment 接口使用场景 + +- ⽤于属性占位符处理 +- 用于转换 Spring 配置属性类型 +- 用于存储 Spring 配置属性源（PropertySource） +- 用于 Profiles 状态的维护 + +## Environment 占位符处理 + +Spring 3.1 前占位符处理 + +- 组件：org.springframework.beans.factory.config.PropertyPlaceholderConfigurer +- 接口：org.springframework.util.StringValueResolver + +Spring 3.1 + 占位符处理 + +- 组件：org.springframework.context.support.PropertySourcesPlaceholderConfigurer +- 接口：org.springframework.beans.factory.config.EmbeddedValueResolver + +## 理解条件配置 Spring Profiles + +Spring 3.1 条件配置 + +- API：org.springframework.core.env.ConfigurableEnvironment +- 修改：addActiveProfile(String)、setActiveProfiles(String...) 和 setDefaultProfiles(String...) +- 获取：getActiveProfiles() 和 getDefaultProfiles() +- 匹配：#acceptsProfiles(String...) 和 acceptsProfiles(Profiles) +- 注解：@org.springframework.context.annotation.Profile + +## Spring 4 重构 @Profile + +基于 Spring 4 org.springframework.context.annotation.Condition 接口实现 + +org.springframework.context.annotation.ProfileCondition + +## 依赖注入 Environment + +直接依赖注入 + +- 通过 EnvironmentAware 接口回调 +- 通过 @Autowired 注入 Environment + +间接依赖注入 + +- 通过 ApplicationContextAware 接口回调 +- 通过 @Autowired 注入 ApplicationContext + +## 依赖查找 Environment + +直接依赖查找 + +- 通过 org.springframework.context.ConfigurableApplicationContext#ENVIRONMENT_BEAN_NAME + +间接依赖查找 + +- 通过 org.springframework.context.ConfigurableApplicationContext#getEnvironment + +## 依赖注入 @Value + +通过注入 @Value + +实现 - org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor + +## Spring 类型转换在 Environment 中的运用 + +Environment 底层实现 + +- 底层实现 - org.springframework.core.env.PropertySourcesPropertyResolver +- 核心方法 - convertValueIfNecessary(Object,Class) +- 底层服务 - org.springframework.core.convert.ConversionService +- 默认实现 - org.springframework.core.convert.support.DefaultConversionService + +## Spring 类型转换在 @Value 中的运用 + +@Value 底层实现 + +- 底层实现 - org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor + - org.springframework.beans.factory.support.DefaultListableBeanFactory#doResolveDependency +- 底层服务 - org.springframework.beans.TypeConverter + - 默认实现 - org.springframework.beans.TypeConverterDelegate + - java.beans.PropertyEditor + - org.springframework.core.convert.ConversionService + +## Spring 配置属性源 PropertySource + +- API + - 单配置属性源 - org.springframework.core.env.PropertySource + - 多配置属性源 - org.springframework.core.env.PropertySources +- 注解 + - 单配置属性源 - @org.springframework.context.annotation.PropertySource + - 多配置属性源 - @org.springframework.context.annotation.PropertySources +- 关联 + - 存储对象 - org.springframework.core.env.MutablePropertySources + - 关联方法 - org.springframework.core.env.ConfigurableEnvironment#getPropertySources() + +## Spring 內建的配置属性源 + +內建 PropertySource + +| PropertySource 类型 | 说明 | +| -------------------------------------------------------------------- | ------------------------- | +| org.springframework.core.env.CommandLinePropertySource | 命令行配置属性源 | +| org.springframework.jndi.JndiPropertySource | JDNI 配置属性源 | +| org.springframework.core.env.PropertiesPropertySource | Properties 配置属性源 | +| org.springframework.web.context.support.ServletConfigPropertySource | Servlet 配置属性源 | +| org.springframework.web.context.support.ServletContextPropertySource | ServletContext 配置属性源 | +| org.springframework.core.env.SystemEnvironmentPropertySource | 环境变量配置属性源 | + +## 基于注解扩展 Spring 配置属性源 + +@org.springframework.context.annotation.PropertySource 实现原理 + +- 入口 - org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass + - org.springframework.context.annotation.ConfigurationClassParser#processPropertySource +- 4.3 新增语义 + - 配置属性字符编码 - encoding + - org.springframework.core.io.support.PropertySourceFactory +- 适配对象 - org.springframework.core.env.CompositePropertySource + +## 基于 API 扩展 Spring 配置属性源 + +- Spring 应用上下文启动前装配 PropertySource +- Spring 应用上下文启动后装配 PropertySource + +## 问题 + +简单介绍 Spring Environment 接口？ + +- 核心接口 - org.springframework.core.env.Environment +- 父接口 - org.springframework.core.env.PropertyResolver +- 可配置接口 - org.springframework.core.env.ConfigurableEnvironment +- 职责： + - 管理 Spring 配置属性源 + - 管理 Profiles + +## 参考资料 + +- [Spring 官方文档之 Core Technologies](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans) +- [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/31.SpringBoot\344\271\213\345\277\253\351\200\237\345\205\245\351\227\250.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/31.SpringBoot\344\271\213\345\277\253\351\200\237\345\205\245\351\227\250.md" new file mode 100644 index 00000000..da73823d --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/31.SpringBoot\344\271\213\345\277\253\351\200\237\345\205\245\351\227\250.md" @@ -0,0 +1,387 @@ +--- +title: SpringBoot 之快速入门 +date: 2021-12-10 18:22:26 +order: 31 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring + - SpringBoot +permalink: /pages/950e4d/ +--- + +# SpringBoot 之快速入门 + +## Spring Boot 简介 + +Spring Boot 可以让使用者非常方便的创建 Spring 应用。 + +Spring Boot 的目标是： + +- 为所有 Spring 开发者提供更快且可广泛访问的入门体验。 +- 开箱即用 +- 提供一系列通用的非功能特性（例如嵌入式服务、安全、指标、健康检查和外部化配置） +- 完全不需要代码生成，也不需要 XML 配置。 + +## Spring Boot 系统要求 + +Spring Boot 的构建工具要求： + +| Build Tool | Version | +| :--------- | :-------------------- | +| Maven | 3.5+ | +| Gradle | 6.8.x, 6.9.x, and 7.x | + +Spring Boot 支持的 Servlet 容器： + +| Name | Servlet Version | +| :----------- | :-------------- | +| Tomcat 9.0 | 4.0 | +| Jetty 9.4 | 3.1 | +| Jetty 10.0 | 4.0 | +| Undertow 2.0 | 4.0 | + +## 部署第一个 Spring Boot 项目 + +> 本节介绍如何开发一个小的“Hello World!” web 应用示例，来展示 Spring Boot 的一些关键功能。我们使用 Maven 来构建这个项目，因为大多数 IDE 都支持它。 + +### 环境检查 + +Spring Boot 项目依赖于 Java 环境和 Mave，开始项目之前需要先检查一下环境。 + +本地是否已安装 Java： + +```shell +$ java -version +java version "1.8.0_102" +Java(TM) SE Runtime Environment (build 1.8.0_102-b14) +Java HotSpot(TM) 64-Bit Server VM (build 25.102-b14, mixed mode) +``` + +本地是否已安装 Maven： + +```java +$ mvn -v +Apache Maven 3.5.4 (1edded0938998edf8bf061f1ceb3cfdeccf443fe; 2018-06-17T14:33:14-04:00) +Maven home: /usr/local/Cellar/maven/3.3.9/libexec +Java version: 1.8.0_102, vendor: Oracle Corporation +``` + +### 创建 pom + +我们需要从创建 Maven pom.xml 文件开始。 pom.xml 是 Maven 用于构建项目的配置文件。 + +```xml + + + 4.0.0 + + com.example + myproject + 0.0.1-SNAPSHOT + + + org.springframework.boot + spring-boot-starter-parent + 2.6.1 + + + + + +``` + +使用者可以通过运行 mvn package 来测试它 + +### 添加依赖 + +Spring Boot 提供了许多启动器（Starters）以应对不同的使用场景。使用者可将 jars 添加到类路径中。我们的示例程序在 POM 的 parent 使用 spring-boot-starter-parent。 spring-boot-starter-parent 是一个特殊的启动器，提供有用的 Maven 默认值。它还提供了一个依赖项的版本管理，可以让使用者使用时不必显示指定版本。 + +其他启动器（Starters）提供了各种针对不同使用场景的功能。比如，我们需要开发一个 Web 应用程序，就可以添加了一个 spring-boot-starter-web 依赖项。在此之前，我们可以通过运行以下命令来查看我们当前拥有的 maven 依赖： + +```shell +$ mvn dependency:tree + +[INFO] com.example:myproject:jar:0.0.1-SNAPSHOT +``` + +mvn dependency:tree 命令打印项目依赖项的层级结构。可以看到 spring-boot-starter-parent 本身没有提供任何依赖。要添加必要的依赖，需要编辑 pom.xml 并在 `` 部分添加 spring-boot-starter-web 依赖项： + +```xml + + + org.springframework.boot + spring-boot-starter-web + + +``` + +### 编写代码 + +要运行应用程序，我们需要创建一个启动类。默认情况下，Maven 从 `src/main/java` 编译源代码，因此您需要创建该目录结构，然后添加一个名为 `src/main/java/MyApplication.java` 的文件以包含以下代码： + +```java +@RestController +@EnableAutoConfiguration +public class MyApplication { + + @RequestMapping("/") + String home() { + return "Hello World!"; + } + + public static void main(String[] args) { + SpringApplication.run(MyApplication.class, args); + } + +} +``` + +说明： + +@RestController 注解告诉 Spring，这个类是用来处理 Rest 请求的。 + +`@RequestMapping` 注解提供了“路由”信息。它告诉 Spring 任何带有 `/` 路径的 HTTP 请求都应该映射到 `home` 方法。 `@RestController` 注解告诉 Spring 将结果字符串直接呈现给调用者。 + +`@EnableAutoConfiguration` 注解告诉 Spring Boot 根据你添加的 jar 依赖去自动装配 Spring。 + +> 自动配置旨在与“Starters”配合使用，但这两个概念并没有直接联系。您可以自由选择 starters 之外的 jar 依赖项。 Spring Boot 仍然尽力自动配置您的应用程序。 + +Spring Boot 的 main 方法通过调用 run 委托给 Spring Boot 的 `SpringApplication` 类。 `SpringApplication` 引导我们的应用程序，启动 Spring，进而启动自动配置的 Tomcat Web 服务器。我们需要将 `MyApplication.class` 作为参数传递给 run 方法，以告诉 `SpringApplication` 哪个是入口类。还传递 args 数组以公开任何命令行参数。 + +### 运行示例 + +此时，您的应用程序应该可以工作了。由于您使用了 spring-boot-starter-parent POM，因此您有一个有用的运行目标，可用于启动应用程序。从项目根目录键入 mvn spring-boot:run 以启动应用程序。您应该会看到类似于以下内容的输出： + +```shell +$ mvn spring-boot:run + + . ____ _ __ _ _ + /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ +( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ + \\/ ___)| |_)| | | | | || (_| | ) ) ) ) + ' |____| .__|_| |_|_| |_\__, | / / / / + =========|_|==============|___/=/_/_/_/ + :: Spring Boot :: (v2.6.1) +....... . . . +....... . . . (log output here) +....... . . . +........ Started MyApplication in 2.222 seconds (JVM running for 6.514) +``` + +如果您打开 Web 浏览器访问 localhost:8080，您应该会看到以下输出： + +``` +Hello World! +``` + +要正常退出应用程序，请按 `ctrl-c`。 + +### 创建可执行 jar + +要创建一个可执行的 jar，我们需要将 spring-boot-maven-plugin 添加到我们的 pom.xml 中。为此，请在依赖项部分下方插入以下行： + +```xml + + + + org.springframework.boot + spring-boot-maven-plugin + + + +``` + +保存 pom.xml 并从命令行运行 mvn package，如下所示： + +```shell +$ mvn package + +[INFO] Scanning for projects... +[INFO] +[INFO] ------------------------------------------------------------------------ +[INFO] Building myproject 0.0.1-SNAPSHOT +[INFO] ------------------------------------------------------------------------ +[INFO] .... .. +[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ myproject --- +[INFO] Building jar: /Users/developer/example/spring-boot-example/target/myproject-0.0.1-SNAPSHOT.jar +[INFO] +[INFO] --- spring-boot-maven-plugin:2.6.1:repackage (default) @ myproject --- +[INFO] ------------------------------------------------------------------------ +[INFO] BUILD SUCCESS +[INFO] ------------------------------------------------------------------------ +``` + +如果您查看 target 目录，应该会看到 `myproject-0.0.1-SNAPSHOT.jar`。该文件的大小应约为 10 MB。如果想看里面，可以使用 jar tvf，如下： + +```shell +$ jar tvf target/myproject-0.0.1-SNAPSHOT.jar +``` + +您还应该在目标目录中看到一个更小的名为 `myproject-0.0.1-SNAPSHOT.jar.original` 的文件。这是 Maven 在 Spring Boot 重新打包之前创建的原始 jar 文件。 + +要运行该应用程序，请使用 java -jar 命令，如下所示： + +``` +$ java -jar target/myproject-0.0.1-SNAPSHOT.jar + + . ____ _ __ _ _ + /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ +( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ + \\/ ___)| |_)| | | | | || (_| | ) ) ) ) + ' |____| .__|_| |_|_| |_\__, | / / / / + =========|_|==============|___/=/_/_/_/ + :: Spring Boot :: (v2.6.1) +....... . . . +....... . . . (log output here) +....... . . . +........ Started MyApplication in 2.536 seconds (JVM running for 2.864) +``` + +和以前一样，要退出应用程序，请按 `ctrl-c`。 + +## 通过 SPRING INITIALIZR 创建 Spring Boot 项目 + +### 创建项目 + +通过 `SPRING INITIALIZR` 工具产生基础项目 + +1. 访问：`http://start.spring.io/` +2. 选择构建工具`Maven Project`、Spring Boot 版本 `1.5.10` 以及一些工程基本信息，可参考下图所示： + +![img](https://raw.githubusercontent.com/dunwu/images/master/snap/start.spring.io.png) + +3. 点击`Generate Project`下载项目压缩包 +4. 解压压缩包，包中已是一个完整的项目。 + +如果你使用 Intellij 作为 IDE，那么你可以直接使用 SPRING INITIALIZR，参考下图操作： + +![img](https://raw.githubusercontent.com/dunwu/images/master/snap/intellij-spring-initializr.gif) + +### 项目说明 + +**重要文件** + +- `src/main/java` 路径下的 `Chapter1Application` 类：程序入口 +- `src/main/resources` 路径下的 `application.properties` ：项目配置文件 +- `src/test/java` 路径下的 `Chapter01ApplicationTests` ：程序测试入口 + +**pom.xml** + +pom 中指定 parent 为以下内容，表示此项目继承了 `spring-boot-starter-parent` 的 maven 配置（主要是指定了常用依赖、插件的版本）。 + +```xml + + org.springframework.boot + spring-boot-starter-parent + 1.5.10.RELEASE + + +``` + +此外，pom 中默认引入两个依赖包，和一个插件。 + +```xml + + + org.springframework.boot + spring-boot-starter-web + + + + org.springframework.boot + spring-boot-starter-test + test + + + + + + + org.springframework.boot + spring-boot-maven-plugin + + + +``` + +- `spring-boot-starter-web`：核心模块，包括自动配置支持、日志和 YAML。 +- `spring-boot-starter-test`：测试模块，包括 JUnit、Hamcrest、Mockito。 +- `spring-boot-maven-plugin`：spring boot 插件，提供了一系列 spring boot 相关的 maven 操作。 + - `spring-boot:build-info`，生成 Actuator 使用的构建信息文件 build-info.properties + - `spring-boot:repackage`，默认 goal。在 mvn package 之后，再次打包可执行的 jar/war，同时保留 mvn package 生成的 jar/war 为.origin + - `spring-boot:run`，运行 Spring Boot 应用 + - `spring-boot:start`，在 mvn integration-test 阶段，进行 Spring Boot 应用生命周期的管理 + - `spring-boot:stop`，在 mvn integration-test 阶段，进行 Spring Boot 应用生命周期的管理 + +### 编写 REST 服务 + +- 创建 `package` ，名为 `io.github.zp.springboot.chapter1.web`（根据项目情况修改） +- 创建 `HelloController` 类，内容如下： + +```java +@RestController +public class HelloController { + + @RequestMapping("/hello") + public String index() { + return "Hello World"; + } + +} +``` + +- 启动主程序 `XXXApplication`，打开浏览器访问`http://localhost:8080/hello` ，可以看到页面输出`Hello World` + +### 编写单元测试用例 + +在 `XXXApplicationTests` 类中编写一个简单的单元测试来模拟 HTTP 请求，具体如下： + +```java +@RunWith(SpringJUnit4ClassRunner.class) +@SpringApplicationConfiguration(classes = MockServletContext.class) +@WebAppConfiguration +public class SpringBootHelloWorldApplicationTest { + + private MockMvc mvc; + + @Before + public void setUp() { + mvc = MockMvcBuilders.standaloneSetup(new HelloController()).build(); + } + + @Test + public void getHello() throws Exception { + mvc.perform(MockMvcRequestBuilders.get("/hello").accept(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andExpect(content().string(equalTo("Hello World"))); + } + +} +``` + +使用`MockServletContext`来构建一个空的`WebApplicationContext`，这样我们创建的`HelloController`就可以在`@Before`函数中创建并传递到`MockMvcBuilders.standaloneSetup（）`函数中。 + +- 注意引入下面内容，让`status`、`content`、`equalTo`函数可用 + +```java +import static org.hamcrest.Matchers.equalTo; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; +``` + +至此已完成目标，通过 Maven 构建了一个空白 Spring Boot 项目，再通过引入 web 模块实现了一个简单的请求处理。 + +### 示例源码 + +> 示例源码：[spring-boot-web-helloworld](https://github.com/dunwu/spring-boot-tutorial/tree/master/codes/web/spring-boot-web-helloworld) + +## 参考资料 + +- [Spring Boot 官方文档之 Getting Started](https://docs.spring.io/spring-boot/docs/current/reference/html/getting-started.html#getting-started) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/32.SpringBoot\344\271\213\345\261\236\346\200\247\345\212\240\350\275\275.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/32.SpringBoot\344\271\213\345\261\236\346\200\247\345\212\240\350\275\275.md" new file mode 100644 index 00000000..8a6ab562 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/32.SpringBoot\344\271\213\345\261\236\346\200\247\345\212\240\350\275\275.md" @@ -0,0 +1,387 @@ +--- +title: SpringBoot 之属性加载详解 +date: 2019-01-10 11:55:54 +order: 32 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring + - SpringBoot +permalink: /pages/0fb992/ +--- + +# SpringBoot 之属性加载详解 + +## 加载 property 顺序 + +Spring Boot 加载 property 顺序如下： + +1. [Devtools 全局配置](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#using-boot-devtools-globalsettings) (当 devtools 被激活 `~/.spring-boot-devtools.properties`). +2. [测试环境中的 `@TestPropertySource` 注解配置](https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/test/context/TestPropertySource.html) +3. 测试环境中的属性 `properties`：[`@SpringBootTest`](https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/test/context/SpringBootTest.html) 和 [测试注解](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-testing-spring-boot-applications-testing-autoconfigured-tests). +4. 命令行参数 +5. `SPRING_APPLICATION_JSON` 属性 +6. `ServletConfig` 初始化参数 +7. `ServletContext` 初始化参数 +8. JNDI attributes from 通过 `java:comp/env` 配置的 JNDI 属性 +9. Java 系统属性 (`System.getProperties()`) +10. 操作系统环境比那里 +11. `RandomValuePropertySource` 加载 `random.*` 形式的属性 +12. jar 包外的 `application-{profile}.properties` 或 `application-{profile}.yml` 配置 +13. jar 包内的 `application-{profile}.properties` 或 `application-{profile}.yml` 配置 +14. jar 包外的 `application.properties` 或 `application.yml` 配置 +15. jar 包内的 `application.properties` 或 `application.yml` 配置 +16. `@PropertySource` 绑定的配置 +17. 默认属性 (通过 `SpringApplication.setDefaultProperties` 指定) + +## 随机属性 + +`RandomValuePropertySource` 类用于配置随机值。 + +示例： + +```properties +my.secret=${random.value} +my.number=${random.int} +my.bignumber=${random.long} +my.uuid=${random.uuid} +my.number.less.than.ten=${random.int(10)} +my.number.in.range=${random.int[1024,65536]} +``` + +## 命令行属性 + +默认情况下， `SpringApplication` 会获取 `--` 参数（例如 `--server.port=9000` ），并将这个 `property` 添加到 Spring 的 `Environment` 中。 + +如果不想加载命令行属性，可以通过 `SpringApplication.setAddCommandLineProperties(false)` 禁用。 + +## Application 属性文件 + +`SpringApplication` 会自动加载以下路径下的 `application.properties` 配置文件，将其中的属性读到 Spring 的 `Environment` 中。 + +1. 当前目录的 `/config` 子目录 +2. 当前目录 +3. classpath 路径下的 `/config` package +4. classpath 根路径 + +> 注： +> +> 以上列表的配置文件会根据顺序，后序的配置会覆盖前序的配置。 +> +> 你可以选择 [YAML(yml)](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-external-config-yaml) 配置文件替换 properties 配置文件。 + +如果不喜欢 `application.properties` 作为配置文件名，可以使用 `spring.config.name` 环境变量替换： + +``` +$ java -jar myproject.jar --spring.config.name=myproject +``` + +可以使用 `spring.config.location` 环境变量指定配置文件路径： + +```properties +$ java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties +``` + +## Profile 特定属性 + +如果定义 `application-{profile}.properties` 形式的配置文件，将被视为 `profile` 环境下的特定配置。 + +可以通过 `spring.profiles.active` 参数来激活 profile，如果没有激活的 profile,默认会加载 `application-default.properties` 中的配置。 + +## 属性中的占位符 + +`application.properties` 中的值会被 `Environment` 过滤，所以，可以引用之前定义的属性。 + +``` +app.name=MyApp +app.description=${app.name} is a Spring Boot application +``` + +> 注：你可以使用此技术来创建 Spring Boot 属性变量。请参考： [Section 77.4, “Use ‘Short’ Command Line Arguments](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#howto-use-short-command-line-arguments) + +## YAML 属性 + +Spring 框架有两个类支持加载 YAML 文件。 + +- `YamlPropertiesFactoryBean` 将 YAML 文件的配置加载为 `Properties` 。 +- `YamlMapFactoryBean` 将 YAML 文件的配置加载为 `Map` 。 + +示例 1 + +```yaml +environments: + dev: + url: http://dev.example.com + name: Developer Setup + prod: + url: http://another.example.com + name: My Cool App +``` + +等价于： + +```properties +environments.dev.url=http://dev.example.com +environments.dev.name=Developer Setup +environments.prod.url=http://another.example.com +environments.prod.name=My Cool App +``` + +YAML 支持列表形式，等价于 property 中的 `[index]` ： + +```yaml +my: +servers: + - dev.example.com + - another.example.com +``` + +等价于 + +```properties +my.servers[0]=dev.example.com +my.servers[1]=another.example.com +``` + +### 访问属性 + +`YamlPropertySourceLoader` 类会将 YAML 配置转化为 Spring `Environment` 类中的 `PropertySource` 。然后，你可以如同 properties 文件中的属性一样，使用 `@Value` 注解来访问 YAML 中配置的属性。 + +### 多 profile 配置 + +```yaml +server: + address: 192.168.1.100 +--- +spring: + profiles: development +server: + address: 127.0.0.1 +--- +spring: + profiles: production & eu-central +server: + address: 192.168.1.120 +``` + +### YAML 的缺点 + +注：YAML 注解中的属性不能通过 `@PropertySource` 注解来访问。所以，如果你的项目中使用了一些自定义属性文件，建议不要用 YAML。 + +## 属性前缀 + +```java +package com.example; + +import java.net.InetAddress; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +import org.springframework.boot.context.properties.ConfigurationProperties; + +@ConfigurationProperties(prefix="acme") +public class AcmeProperties { + + private boolean enabled; + + private InetAddress remoteAddress; + + private final Security security = new Security(); + + public boolean isEnabled() { ... } + + public void setEnabled(boolean enabled) { ... } + + public InetAddress getRemoteAddress() { ... } + + public void setRemoteAddress(InetAddress remoteAddress) { ... } + + public Security getSecurity() { ... } + + public static class Security { + + private String username; + + private String password; + + private List roles = new ArrayList<>(Collections.singleton("USER")); + + public String getUsername() { ... } + + public void setUsername(String username) { ... } + + public String getPassword() { ... } + + public void setPassword(String password) { ... } + + public List getRoles() { ... } + + public void setRoles(List roles) { ... } + + } +} +``` + +相当于支持配置以下属性： + +- `acme.enabled` +- `acme.remote-address` +- `acme.security.username` +- `acme.security.password` +- `acme.security.roles` + +然后，你需要使用 `@EnableConfigurationProperties` 注解将属性类注入配置类中。 + +```java +@Configuration +@EnableConfigurationProperties(AcmeProperties.class) +public class MyConfiguration { +} +``` + +## 属性松散绑定规则 + +Spring Boot 属性名绑定比较松散。 + +以下属性 key 都是等价的： + +| Property | Note | +| ----------------------------------- | -------- | +| `acme.my-project.person.first-name` | `-` 分隔 | +| `acme.myProject.person.firstName` | 驼峰命名 | +| `acme.my_project.person.first_name` | `_` 分隔 | +| `ACME_MYPROJECT_PERSON_FIRSTNAME` | 大写字母 | + +## 属性转换 + +如果需要类型转换，你可以提供一个 `ConversionService` bean (一个名叫 `conversionService` 的 bean) 或自定义属性配置 (一个 `CustomEditorConfigurer` bean) 或自定义的 `Converters` (被 `@ConfigurationPropertiesBinding` 注解修饰的 bena)。 + +### 时间单位转换 + +Spring 使用 `java.time.Duration` 类代表时间大小，以下场景适用： + +- 除非指定 `@DurationUnit` ，否则一个 long 代表的时间为毫秒。 +- ISO-8601 标准格式（ [`java.time.Duration`](https://docs.oracle.com/javase/8/docs/api//java/time/Duration.html#parse-java.lang.CharSequence-) 的实现就是参照此标准） +- 你也可以使用以下支持的单位： + - `ns` - 纳秒 + - `us` - 微秒 + - `ms` - 毫秒 + - `s` - 秒 + - `m` - 分 + - `h` - 时 + - `d` - 天 + +示例： + +```java +@ConfigurationProperties("app.system") +public class AppSystemProperties { + + @DurationUnit(ChronoUnit.SECONDS) + private Duration sessionTimeout = Duration.ofSeconds(30); + + private Duration readTimeout = Duration.ofMillis(1000); + + public Duration getSessionTimeout() { + return this.sessionTimeout; + } + + public void setSessionTimeout(Duration sessionTimeout) { + this.sessionTimeout = sessionTimeout; + } + + public Duration getReadTimeout() { + return this.readTimeout; + } + + public void setReadTimeout(Duration readTimeout) { + this.readTimeout = readTimeout; + } + +} +``` + +### 数据大小转换 + +Spring 使用 `DataSize` 类代表数据大小，以下场景适用： + +- long 值（默认视为 byte） +- 你也可以使用以下支持的单位： + - `B` + - `KB` + - `MB` + - `GB` + - `TB` + +示例： + +```java +@ConfigurationProperties("app.io") +public class AppIoProperties { + + @DataSizeUnit(DataUnit.MEGABYTES) + private DataSize bufferSize = DataSize.ofMegabytes(2); + + private DataSize sizeThreshold = DataSize.ofBytes(512); + + public DataSize getBufferSize() { + return this.bufferSize; + } + + public void setBufferSize(DataSize bufferSize) { + this.bufferSize = bufferSize; + } + + public DataSize getSizeThreshold() { + return this.sizeThreshold; + } + + public void setSizeThreshold(DataSize sizeThreshold) { + this.sizeThreshold = sizeThreshold; + } + +} +``` + +## 校验属性 + +```java +@ConfigurationProperties(prefix="acme") +@Validated +public class AcmeProperties { + + @NotNull + private InetAddress remoteAddress; + + @Valid + private final Security security = new Security(); + + // ... getters and setters + + public static class Security { + + @NotEmpty + public String username; + + // ... getters and setters + + } + +} +``` + +你也可以自定义一个名为 `configurationPropertiesValidator` 的校验器 Bean。获取这个 `@Bean` 的方法必须声明为 `static`。 + +## 示例源码 + +> 示例源码：[spring-boot-property](https://github.com/dunwu/spring-boot-tutorial/tree/master/codes/spring-boot-property) + +## 参考资料 + +- [Spring Boot 官方文档之 boot-features-external-config](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-external-config) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/33.SpringBoot\344\271\213Profile.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/33.SpringBoot\344\271\213Profile.md" new file mode 100644 index 00000000..667df738 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/33.SpringBoot\344\271\213Profile.md" @@ -0,0 +1,200 @@ +--- +title: SpringBoot 之 Profile +date: 2019-11-18 14:55:01 +order: 33 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring + - SpringBoot +permalink: /pages/cb598e/ +--- + +# SpringBoot 之 Profile + +> 一个应用为了在不同的环境下工作，常常会有不同的配置，代码逻辑处理。Spring Boot 对此提供了简便的支持。 +> +> 关键词： `@Profile`、`spring.profiles.active` + +## 区分环境的配置 + +### properties 配置 + +假设，一个应用的工作环境有：dev、test、prod + +那么，我们可以添加 4 个配置文件： + +- `applcation.properties` - 公共配置 +- `application-dev.properties` - 开发环境配置 +- `application-test.properties` - 测试环境配置 +- `application-prod.properties` - 生产环境配置 + +在 `applcation.properties` 文件中可以通过以下配置来激活 profile： + +```properties +spring.profiles.active = test +``` + +### yml 配置 + +与 properties 文件类似，我们也可以添加 4 个配置文件： + +- `applcation.yml` - 公共配置 +- `application-dev.yml` - 开发环境配置 +- `application-test.yml` - 测试环境配置 +- `application-prod.yml` - 生产环境配置 + +在 `applcation.yml` 文件中可以通过以下配置来激活 profile： + +```yml +spring: + profiles: + active: prod +``` + +此外，yml 文件也可以在一个文件中完成所有 profile 的配置： + +```yml +# 激活 prod +spring: + profiles: + active: prod +# 也可以同时激活多个 profile +# spring.profiles.active: prod,proddb,prodlog +--- +# dev 配置 +spring: + profiles: dev + +# 略去配置 + +--- +spring: + profiles: test + +# 略去配置 + +--- +spring.profiles: prod +spring.profiles.include: + - proddb + - prodlog + +--- +spring: + profiles: proddb + +# 略去配置 + +--- +spring: + profiles: prodlog +# 略去配置 +``` + +注意：不同 profile 之间通过 `---` 分割 + +## 区分环境的代码 + +使用 `@Profile` 注解可以指定类或方法在特定的 Profile 环境生效。 + +### 修饰类 + +```java +@Configuration +@Profile("production") +public class JndiDataConfig { + + @Bean(destroyMethod="") + public DataSource dataSource() throws Exception { + Context ctx = new InitialContext(); + return (DataSource) ctx.lookup("java:comp/env/jdbc/datasource"); + } +} +``` + +### 修饰注解 + +```java +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.RUNTIME) +@Profile("production") +public @interface Production { +} +``` + +### 修饰方法 + +```java +@Configuration +public class AppConfig { + + @Bean("dataSource") + @Profile("development") + public DataSource standaloneDataSource() { + return new EmbeddedDatabaseBuilder() + .setType(EmbeddedDatabaseType.HSQL) + .addScript("classpath:com/bank/config/sql/schema.sql") + .addScript("classpath:com/bank/config/sql/test-data.sql") + .build(); + } + + @Bean("dataSource") + @Profile("production") + public DataSource jndiDataSource() throws Exception { + Context ctx = new InitialContext(); + return (DataSource) ctx.lookup("java:comp/env/jdbc/datasource"); + } +} +``` + +## 激活 profile + +### 插件激活 profile + +``` +spring-boot:run -Drun.profiles=prod +``` + +### main 方法激活 profile + +``` +--spring.profiles.active=prod +``` + +### jar 激活 profile + +``` +java -jar -Dspring.profiles.active=prod *.jar +``` + +### 在 Java 代码中激活 profile + +直接指定环境变量来激活 profile： + +```java +System.setProperty("spring.profiles.active", "test"); +``` + +在 Spring 容器中激活 profile： + +```java +AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(); +ctx.getEnvironment().setActiveProfiles("development"); +ctx.register(SomeConfig.class, StandaloneDataConfig.class, JndiDataConfig.class); +ctx.refresh(); +``` + +## 示例源码 + +> 示例源码：[spring-boot-profile](https://github.com/dunwu/spring-boot-tutorial/tree/master/codes/spring-boot-profile) + +## 参考资料 + +- [Spring 官方文档之 Bean Definition Profiles](https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#beans-definition-profiles) +- [Spring Boot 官方文档之 boot-features-profiles](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-profiles) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/README.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/README.md" new file mode 100644 index 00000000..544eb1c1 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/01.Spring\346\240\270\345\277\203/README.md" @@ -0,0 +1,62 @@ +--- +title: Spring 核心 +date: 2020-02-26 23:47:47 +categories: + - Java + - 框架 + - Spring + - Spring核心 +tags: + - Java + - 框架 + - Spring + - SpringBoot +permalink: /pages/5e7c20/ +hidden: true +index: false +--- + +# Spring 核心 + +> 章节主要针对：Spring & Spring Boot 框架的核心技术。如；Spring Bean、IoC、依赖查找、依赖注入、AOP、数据绑定、资源管理等。 + +## 📖 内容 + +- [Spring Bean](01.SpringBean.md) +- [Spring IoC](02.SpringIoC.md) +- [Spring 依赖查找](03.Spring依赖查找.md) +- [Spring 依赖注入](04.Spring依赖注入.md) +- [Spring IoC 依赖来源](05.SpringIoC依赖来源.md) +- [Spring Bean 作用域](06.SpringBean作用域.md) +- [Spring Bean 生命周期](07.SpringBean生命周期.md) +- [Spring 配置元数据](08.Spring配置元数据.md) +- [Spring AOP](10.SpringAop.md) +- [Spring 资源管理](20.Spring资源管理.md) +- [Spring 校验](21.Spring校验.md) +- [Spring 数据绑定](22.Spring数据绑定.md) +- [Spring 类型转换](23.Spring类型转换.md) +- [Spring EL 表达式](24.SpringEL.md) +- [Spring 事件](25.Spring事件.md) +- [Spring 国际化](26.Spring国际化.md) +- [Spring 泛型处理](27.Spring泛型处理.md) +- [Spring 注解](28.Spring注解.md) +- [SpringBoot 教程之快速入门](31.SpringBoot之快速入门.md) +- [SpringBoot 之属性加载](32.SpringBoot之属性加载.md) +- [SpringBoot 之 Profile](33.SpringBoot之Profile.md) + +## 📚 资料 + +- **官方** + - [Spring 官网](https://spring.io/) + - [Spring Framework 官方文档](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/index.html) + - [Spring Github](https://github.com/spring-projects/spring-framework) +- **书籍** + - [《Spring In Action》](https://item.jd.com/12622829.html) +- **教程** + - [《小马哥讲 Spring 核心编程思想》](https://time.geekbang.org/course/intro/265) + - [geekbang-lessons](https://github.com/geektime-geekbang/geekbang-lessons) + - [跟我学 Spring3](http://jinnianshilongnian.iteye.com/blog/1482071) + +## 🚪 传送 + +◾ 💧 [钝悟的 IT 知识图谱](https://dunwu.github.io/waterdrop/) ◾ 🎯 [我的博客](https://github.com/dunwu/blog) ◾ \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/01.Spring\344\271\213\346\225\260\346\215\256\346\272\220.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/01.Spring\344\271\213\346\225\260\346\215\256\346\272\220.md" new file mode 100644 index 00000000..5d01d703 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/01.Spring\344\271\213\346\225\260\346\215\256\346\272\220.md" @@ -0,0 +1,555 @@ +--- +title: Spring 之数据源 +date: 2017-10-20 09:27:55 +order: 01 +categories: + - Java + - 框架 + - Spring + - Spring数据 +tags: + - Java + - 框架 + - Spring + - SpringBoot + - 数据库 + - DataSource +permalink: /pages/1b774c/ +--- + +# Spring 之数据源 + +> 本文基于 Spring Boot 2.7.3 版本。 + +## Spring Boot 数据源基本配置 + +Spring Boot 提供了一系列 `spring.datasource.*` 配置来控制 `DataSource` 的配置。用户可以在 `application.properties` 或 `application.yml` 文件中指定数据源配置。这些配置项维护在 [`DataSourceProperties`](https://github.com/spring-projects/spring-boot/tree/v2.7.4/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceProperties.java) 。 + +下面是一个最基本的 mysql 数据源配置示例（都是必填项）： + +```properties +# 数据库访问地址 +spring.datasource.url = jdbc:mysql://localhost:3306/spring_tutorial?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8 +# 数据库驱动类，必须保证驱动类是可加载的 +spring.datasource.driver-class-name = com.mysql.cj.jdbc.Driver +# 数据库账号 +spring.datasource.username = root +# 数据库账号密码 +spring.datasource.password = root +``` + +需要根据实际情况，替换 `url`、`username`、`password`。 + +## Spring Boot 连接嵌入式数据源 + +使用内存嵌入式数据库开发应用程序通常很方便。显然，内存数据库不提供持久存储。使用者需要在应用程序启动时填充数据库，并准备在应用程序结束时丢弃数据。 + +Spring Boot 可以自动配置嵌入式数据库 [H2](https://www.h2database.com/)、[HSQL](https://hsqldb.org/) 和 [Derby](https://db.apache.org/derby/)。使用者无需提供任何连接 URL，只需要包含对要使用的嵌入式数据库的构建依赖项。如果类路径上有多个嵌入式数据库，需要设置 `spring.datasource.embedded-database-connection` 配置属性来控制使用哪一个。将该属性设置为 none 会禁用嵌入式数据库的自动配置。 + +> 注意：如果在测试中使用此功能，无论使用多少应用程序上下文，整个测试套件都会重用同一个数据库。如果要确保每个上下文都有一个单独的嵌入式数据库，则应将 `spring.datasource.generate-unique-name` 设置为 true。 + +下面，通过一个实例展示如何连接 H2 嵌入式数据库。 + +（1）在 pom.xml 中引入所需要的依赖： + +```xml + + org.springframework.boot + spring-boot-starter-data-jdbc + + + com.h2database + h2 + +``` + +（2）数据源配置 + +```properties +spring.datasource.jdbc-url = jdbc:h2:mem:test +spring.datasource.driver-class-name = org.h2.Driver +spring.datasource.username = sa +spring.datasource.password = +``` + +## Spring Boot 连接池化数据源 + +> 完整示例：[spring-boot-data-jdbc](https://github.com/dunwu/spring-tutorial/tree/master/codes/data/spring-boot-data-jdbc) + +在生产环境中，出于性能考虑，一般会通过数据库连接池连接数据源。 + +除了 [`DataSourceProperties`](https://github.com/spring-projects/spring-boot/tree/v2.7.4/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceProperties.java) 中的数据源通用配置以外，Spring Boot 还支持通过使用类似`spring.datasource.hikari.*`、`spring.datasource.tomcat.*`、`spring.datasource.dbcp2.*` 和 `spring.datasource.oracleucp.*` 的前缀来配置指定的数据库连接池属性。 + +下面，就是一份 hikari 的连接池配置示例： + +```properties +# 连接池名称 +spring.datasource.hikari.pool-name = SpringTutorialHikariPool +# 最大连接数，小于等于 0 会被重置为默认值 10；大于零小于 1 会被重置为 minimum-idle 的值 +spring.datasource.hikari.maximum-pool-size = 10 +# 最小空闲连接，默认值10，小于 0 或大于 maximum-pool-size，都会重置为 maximum-pool-size +spring.datasource.hikari.minimum-idle = 10 +# 连接超时时间（单位：毫秒），小于 250 毫秒，会被重置为默认值 30 秒 +spring.datasource.hikari.connection-timeout = 60000 +# 空闲连接超时时间，默认值 600000（10分钟），大于等于 max-lifetime 且 max-lifetime>0，会被重置为0；不等于 0 且小于 10 秒，会被重置为 10 秒 +# 只有空闲连接数大于最大连接数且空闲时间超过该值，才会被释放 +spring.datasource.hikari.idle-timeout = 600000 +# 连接最大存活时间，不等于 0 且小于 30 秒，会被重置为默认值 30 分钟。该值应该比数据库所设置的超时时间短 +spring.datasource.hikari.max-lifetime = 540000 +``` + +Spring Boot 会按以下顺序检测连接池是否可用，如果可用就选择对应的池化 `DataSource`： + +HikariCP -> Tomcat pooling DataSource -> DBCP2 -> Oracle UCP + +用户也可以通过 `spring.datasource.type` 来指定数据源类型。 + +此外，也可以使用 `DataSourceBuilder` 手动配置其他连接池。如果自定义 DataSource bean，则不会发生自动配置。 `DataSourceBuilder` 支持以下连接池： + +- HikariCP +- Tomcat pooling `Datasource` +- Commons DBCP2 +- Oracle UCP & `OracleDataSource` +- Spring Framework’s `SimpleDriverDataSource` +- H2 `JdbcDataSource` +- PostgreSQL `PGSimpleDataSource` +- C3P0 + +### 引入 Spring Boot 依赖 + +你可以通过 Spring Boot 官方的初始化器（[Spring Initializr](https://start.spring.io/)）选择需要的组件来创建一个 Spring Boot 工程。或者，直接在 pom.xml 中引入所需要的依赖： + +```xml + + org.springframework.boot + spring-boot-starter-data-jdbc + + + mysql + mysql-connector-java + +``` + +### 测试单数据源连接 + +```java +import lombok.extern.slf4j.Slf4j; +import org.springframework.boot.CommandLineRunner; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.jdbc.core.JdbcTemplate; + +import java.sql.Connection; +import javax.sql.DataSource; + +@Slf4j +@SpringBootApplication +public class SpringBootDataJdbcApplication implements CommandLineRunner { + + private final JdbcTemplate jdbcTemplate; + + public SpringBootDataJdbcApplication(JdbcTemplate jdbcTemplate) { + this.jdbcTemplate = jdbcTemplate; + } + + public static void main(String[] args) { + SpringApplication.run(SpringBootDataJdbcApplication.class, args); + } + + @Override + public void run(String... args) throws Exception { + DataSource dataSource = jdbcTemplate.getDataSource(); + + Connection connection; + if (dataSource != null) { + connection = dataSource.getConnection(); + } else { + log.error("连接数据源失败！"); + return; + } + + if (connection != null) { + log.info("数据源 Url: {}", connection.getMetaData().getURL()); + } else { + log.error("连接数据源失败！"); + } + } + +} +``` + +运行 `main` 方法后，控制台会输出以下内容，表示数据源连接成功： + +``` +20:50:18.449 [main] [INFO ] i.g.d.s.d.SpringBootDataJdbcApplication.run - 数据源 Url: jdbc:mysql://localhost:3306/spring_tutorial?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8 +``` + +## Spring Boot 连接多数据源 + +> 完整示例：[spring-boot-data-jdbc-multi-datasource](https://github.com/dunwu/spring-tutorial/tree/master/codes/data/spring-boot-data-jdbc-multi-datasource) + +Spring Boot 连接多数据源所需要的依赖并无不同，主要差异在于数据源的配置。Spring Boot 默认的数据源配置类为 `org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration`。使用者只要指定一些必要的 spring.datasource 配置，`DataSourceAutoConfiguration` 类就会自动完成剩下的数据源实例化工作。 + +### 多数据源配置 + +下面的示例中，自定义了一个数据源配置类，通过读取不同的 spring.datasource.xxx 来完成对于不同数据源的实例化工作。对于 JDBC 来说，最重要的，就是实例化 `DataSource` 和 `JdbcTemplate`。 + +```java +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.boot.jdbc.DataSourceBuilder; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.Primary; +import org.springframework.jdbc.core.JdbcTemplate; + +@Configuration +public class DataSourceConfig { + + @Primary + @Bean("mysqlDataSource") + @ConfigurationProperties(prefix = "spring.datasource.mysql") + public DataSource mysqlDataSource() { + return DataSourceBuilder.create().build(); + } + + @Primary + @Bean("mysqlJdbcTemplate") + public JdbcTemplate mysqlJdbcTemplate(@Qualifier("mysqlDataSource") DataSource dataSource) { + return new JdbcTemplate(dataSource); + } + + @Bean("h2DataSource") + @ConfigurationProperties(prefix = "spring.datasource.h2") + public DataSource h2DataSource() { + return DataSourceBuilder.create().build(); + } + + @Bean(name = "h2JdbcTemplate") + public JdbcTemplate h2JdbcTemplate(@Qualifier("h2DataSource") DataSource dataSource) { + return new JdbcTemplate(dataSource); + } + +} +``` + +`application.properties` 或 `application.yml` 配置文件中也必须以 `@ConfigurationProperties` 所指定的配置前缀进行配置： + +```properties +# 数据源一：Mysql +spring.datasource.mysql.jdbc-url = jdbc:mysql://localhost:3306/spring_tutorial?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8&useSSL=false +spring.datasource.mysql.driver-class-name = com.mysql.cj.jdbc.Driver +spring.datasource.mysql.username = root +spring.datasource.mysql.password = root +# 数据源一：H2 +spring.datasource.h2.jdbc-url = jdbc:h2:mem:test +spring.datasource.h2.driver-class-name = org.h2.Driver +spring.datasource.h2.username = sa +spring.datasource.h2.password = +``` + +### 测试多数据源连接 + +```java + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.boot.CommandLineRunner; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.jdbc.core.JdbcTemplate; + +import java.sql.Connection; +import java.sql.SQLException; +import javax.sql.DataSource; + +@SpringBootApplication +public class SpringBootDataJdbcMultiDataSourceApplication implements CommandLineRunner { + + private static final Logger log = LoggerFactory.getLogger(SpringBootDataJdbcMultiDataSourceApplication.class); + + private final UserDao mysqlUserDao; + + private final UserDao h2UserDao; + + public SpringBootDataJdbcMultiDataSourceApplication(@Qualifier("mysqlUserDao") UserDao mysqlUserDao, + @Qualifier("h2UserDao") UserDao h2UserDao) { + this.mysqlUserDao = mysqlUserDao; + this.h2UserDao = h2UserDao; + } + + public static void main(String[] args) { + SpringApplication.run(SpringBootDataJdbcMultiDataSourceApplication.class, args); + } + + @Override + public void run(String... args) throws Exception { + + if (mysqlUserDao != null && mysqlUserDao.getJdbcTemplate() != null) { + printDataSourceInfo(mysqlUserDao.getJdbcTemplate()); + log.info("Connect to mysql datasource success."); + } else { + log.error("Connect to mysql datasource failed!"); + return; + } + + if (h2UserDao != null) { + printDataSourceInfo(h2UserDao.getJdbcTemplate()); + log.info("Connect to h2 datasource success."); + } else { + log.error("Connect to h2 datasource failed!"); + return; + } + + // 主数据源执行 JDBC SQL + mysqlUserDao.recreateTable(); + + // 次数据源执行 JDBC SQL + h2UserDao.recreateTable(); + } + + private void printDataSourceInfo(JdbcTemplate jdbcTemplate) throws SQLException { + + DataSource dataSource = jdbcTemplate.getDataSource(); + + Connection connection; + if (dataSource != null) { + connection = dataSource.getConnection(); + } else { + log.error("Get dataSource failed!"); + return; + } + + if (connection != null) { + log.info("DataSource Url: {}", connection.getMetaData().getURL()); + } else { + log.error("Connect to datasource failed!"); + } + } + +} +``` + +运行 `main` 方法后，控制台会输出以下内容，表示数据源连接成功： + +``` +21:16:44.654 [main] [INFO ] i.g.d.s.d.SpringBootDataJdbcMultiDataSourceApplication.printDataSourceInfo - DataSource Url: jdbc:mysql://localhost:3306/spring_tutorial?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8&useSSL=false +21:16:44.654 [main] [INFO ] i.g.d.s.d.SpringBootDataJdbcMultiDataSourceApplication.run - Connect to mysql datasource success. + +21:16:44.726 [main] [INFO ] i.g.d.s.d.SpringBootDataJdbcMultiDataSourceApplication.printDataSourceInfo - DataSource Url: jdbc:h2:mem:test +21:16:44.726 [main] [INFO ] i.g.d.s.d.SpringBootDataJdbcMultiDataSourceApplication.run - Connect to h2 datasource success. +``` + +## Spring 之数据源 + +如果你的项目是传统的 Spring 项目，当然也可以轻松建立数据源连接，只是需要自行设置的配置更多一些。 + +### 引入 Spring 依赖 + +在 pom.xml 中引入所需要的依赖： + +```xml + + + com.alibaba + druid + + + mysql + mysql-connector-java + + + + org.springframework + spring-context-support + + + org.springframework + spring-jdbc + + + org.springframework + spring-tx + + + +``` + +### Spring 配置数据源 + +Spring 配置数据源有多种方式，下面一一列举： + +#### 使用 JNDI 数据源 + +如果 Spring 应用部署在支持 JNDI 的 WEB 服务器上（如 WebSphere、JBoss、Tomcat 等），就可以使用 JNDI 获取数据源。 + +```xml + + + + + + + + + + + +``` + +#### 使用数据库连接池 + +Spring 本身并没有提供数据库连接池的实现，需要自行选择合适的数据库连接池。下面是一个使用 [Druid](https://github.com/alibaba/druid) 作为数据库连接池的示例： + +```xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +``` + +#### 基于 JDBC 驱动的数据源 + +```xml + + + + + + +``` + +## SpringBoot 数据源配置 + +> Spring Boot 数据库配置官方文档：https://docs.spring.io/spring-boot/docs/current/reference/html/data.html#data.sql + +通过前面的实战，我们已经知道了 Spring、Spring Boot 是如何连接数据源，并通过 JDBC 方式访问数据库。 + +SpringBoot 数据源的配置方式是在 `application.properties` 或 `application.yml` 文件中指定 `spring.datasource.*` 的配置。 + +（1）数据源基本配置方式是指定 url、用户名、密码 + +```properties +spring.datasource.url=jdbc:mysql://localhost/test +spring.datasource.username=dbuser +spring.datasource.password=dbpass +``` + +（2）配置 JNDI + +如果想要通过 JNDI 方式连接数据源，可以采用如下方式： + +```properties +spring.datasource.jndi-name=java:jboss/datasources/customers +``` + +## DataSourceAutoConfiguration 类 + +显而易见，Spring Boot 的配置更加简化，那么， Spring Boot 做了哪些工作，使得接入更加便捷呢？奥秘就在于 `spring-boot-autoconfigure` jar 包，其中定义了大量的 Spring Boot 自动配置类。其中，与数据库访问相关的比较核心的配置类有： + +- `DataSourceAutoConfiguration`：数据源自动配置类 +- `JdbcTemplateAutoConfiguration`：`JdbcTemplate` 自动配置类 +- `DataSourceTransactionManagerAutoConfiguration`：数据源事务管理自动配置类 +- `JndiDataSourceAutoConfiguration`：JNDI 数据源自动配置类 +- `EmbeddedDataSourceConfiguration`：嵌入式数据库数据源自动配置类 +- 等等 + +这些自动配置类会根据各种条件控制核心类的实例化。 + +`DataSourceAutoConfiguration` 是数据源自动配置类，它负责实例化 `DataSource`。 + +`DataSourceAutoConfiguration` 的源码如下（省略部分代码）： + +```java +@AutoConfiguration(before = SqlInitializationAutoConfiguration.class) +@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class }) +@ConditionalOnMissingBean(type = "io.r2dbc.spi.ConnectionFactory") +@EnableConfigurationProperties(DataSourceProperties.class) +@Import(DataSourcePoolMetadataProvidersConfiguration.class) +public class DataSourceAutoConfiguration { + + @Configuration(proxyBeanMethods = false) + @Conditional(EmbeddedDatabaseCondition.class) + @ConditionalOnMissingBean({ DataSource.class, XADataSource.class }) + @Import(EmbeddedDataSourceConfiguration.class) + protected static class EmbeddedDatabaseConfiguration { + } + + @Configuration(proxyBeanMethods = false) + @Conditional(PooledDataSourceCondition.class) + @ConditionalOnMissingBean({ DataSource.class, XADataSource.class }) + @Import({ DataSourceConfiguration.Hikari.class, DataSourceConfiguration.Tomcat.class, + DataSourceConfiguration.Dbcp2.class, DataSourceConfiguration.OracleUcp.class, + DataSourceConfiguration.Generic.class, DataSourceJmxConfiguration.class }) + protected static class PooledDataSourceConfiguration { + } + + static class PooledDataSourceCondition extends AnyNestedCondition { + // 略 + } + + static class PooledDataSourceAvailableCondition extends SpringBootCondition { + // 略 + } + + static class EmbeddedDatabaseCondition extends SpringBootCondition { + // 略 + } +} +``` + +`DataSourceAutoConfiguration` 类的源码解读： + +- `DataSourceProperties` 是 `DataSourceAutoConfiguration` 的配置选项类，允许使用者通过设置选项控制 `DataSource` 初始化行为。 +- `DataSourceAutoConfiguration` 通过 `@Import` 注解引入 `DataSourcePoolMetadataProvidersConfiguration` 类。 +- `DataSourceAutoConfiguration` 中定义了两个内部类：嵌入式数据源配置类 `EmbeddedDatabaseConfiguration` 和池化数据源配置类 `PooledDataSourceConfiguration`，分别标记了不同的实例化条件。 + - 当满足 `EmbeddedDatabaseConfiguration` 的示例化条件时，将引入 `EmbeddedDataSourceConfiguration` 类初始化数据源，这个类实际上是加载嵌入式数据源驱动的 ClassLoader 去进行初始化。 + - 当满足 `PooledDataSourceConfiguration` 的示例化条件时，将引入 `DataSourceConfiguration.Hikari.class`、`DataSourceConfiguration.Tomcat.class`、`DataSourceConfiguration.Dbcp2.class`、`DataSourceConfiguration.OracleUcp.class`、`DataSourceConfiguration.Generic.class`、`DataSourceJmxConfiguration.class` 这些配置类，分别对应不同的数据库连接池方式。具体选用哪种数据库连接池，可以通过 `spring.datasource.type` 配置指定。其中，Hikari 是 Spring Boot 默认的数据库连接池，spring-boot-starter-data-jdbc 中内置了 Hikari 连接池驱动包。如果想要替换其他数据库连接池，前提是必须先手动引入对应的连接池驱动包。 + +## 参考资料 + +- [Spring 官网](https://spring.io/) +- [Spring Framework 官方文档](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/index.html) +- [Spring Boot 官方文档](https://docs.spring.io/spring-boot/docs/current/reference/html/data.html) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/02.Spring\344\271\213JDBC.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/02.Spring\344\271\213JDBC.md" new file mode 100644 index 00000000..e1990392 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/02.Spring\344\271\213JDBC.md" @@ -0,0 +1,768 @@ +--- +title: Spring 之 JDBC +date: 2019-02-18 14:33:55 +order: 02 +categories: + - Java + - 框架 + - Spring + - Spring数据 +tags: + - Java + - 框架 + - Spring + - SpringBoot + - JDBC + - JdbcTemplate +permalink: /pages/cf19fd/ +--- + +# Spring 之 JDBC + +JDBC 是 Java 语言中用来规范客户端程序如何访问数据库的应用程序接口，提供了增、删、改、查数据库的方法。 + +## JDBC 入门示例 + +JDBC 的工作步骤大致如下： + +1. 创建实体类。 +2. 声明数据库读写接口的 DAO 接口。定义 DAO 的好处在于对于数据层上层的业务，调用 DAO 时仅关注对外暴露的读写方法，而不考虑底层的具体持久化方式。这样，便于替换持久化方式。 +3. 创建一个 DAO 接口的实现类，使用 Spring 的 JDBC 模板去实现接口。 +4. 最后，定义一个 DAO 接口的实现类的 JavaBean，并将数据源注入进去。 + +假设，我们要通过 Spring + JDBC 访问一张 Mysql 数据表 `user`，`user` 表的数据结构如下： + +```sql +-- 创建用户表 +CREATE TABLE `user` ( + `id` BIGINT(20) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT 'ID', + `name` VARCHAR(255) NOT NULL DEFAULT '' COMMENT '用户名', + `age` INT(3) NOT NULL DEFAULT 0 COMMENT '年龄', + `address` VARCHAR(255) NOT NULL DEFAULT '' COMMENT '地址', + `email` VARCHAR(255) NOT NULL DEFAULT '' COMMENT '邮件', + PRIMARY KEY (`id`), + UNIQUE (`name`) +) COMMENT = '用户表'; + +INSERT INTO `user` (`name`, `age`, `address`, `email`) +VALUES ('张三', 18, '北京', 'xxx@163.com'); +INSERT INTO `user` (`name`, `age`, `address`, `email`) +VALUES ('李四', 19, '上海', 'xxx@163.com'); +``` + +### 定义实体 + +```java +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import lombok.ToString; + +import java.util.Objects; + +@Data +@ToString +@NoArgsConstructor +@AllArgsConstructor +public class User { + private Long id; + private String name; + private Integer age; + private String address; + private String email; +} +``` + +### 定义 DAO 接口 + +```java +import org.springframework.jdbc.core.JdbcTemplate; + +import java.util.List; + +/** + * user 表 Dao 接口 + * + * @author Zhang Peng + * @since 2019-11-18 + */ +public interface UserDao { + + // DML + // ------------------------------------------------------------------- + void insert(User user); + + void batchInsert(List users); + + void deleteByName(String name); + + void deleteAll(); + + void update(User user); + + Integer count(); + + List list(); + + User queryByName(String name); + + JdbcTemplate getJdbcTemplate(); + + // DDL + // ------------------------------------------------------------------- + void truncate(); + + void recreateTable(); + +} +``` + +### 定义 DAO 实现类 + +通过 `JdbcTemplate` 执行对应数据源符合语法的 SQL，即可完成各种数据库访问。 + +```java +package io.github.dunwu.springboot.core.data.jdbc; + +import org.springframework.dao.EmptyResultDataAccessException; +import org.springframework.jdbc.core.BeanPropertyRowMapper; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.stereotype.Repository; +import org.springframework.transaction.annotation.Transactional; + +import java.util.ArrayList; +import java.util.List; + +/** + * user 表 Dao 接口实现类 + * + * @author Zhang Peng + * @since 2019-11-18 + */ +@Repository +public class UserDaoImpl implements UserDao { + + private JdbcTemplate jdbcTemplate; + + public UserDaoImpl(JdbcTemplate jdbcTemplate) { + this.jdbcTemplate = jdbcTemplate; + } + + @Override + public void insert(User user) { + jdbcTemplate.update("INSERT INTO user(name, age, address, email) VALUES(?, ?, ?, ?)", + user.getName(), user.getAge(), user.getAddress(), user.getEmail()); + } + + @Override + @Transactional(rollbackFor = Exception.class) + public void batchInsert(List users) { + String sql = "INSERT INTO user(name, age, address, email) VALUES(?, ?, ?, ?)"; + + List params = new ArrayList<>(); + + users.forEach(user -> { + params.add(new Object[] { user.getName(), user.getAge(), user.getAddress(), user.getEmail() }); + }); + jdbcTemplate.batchUpdate(sql, params); + } + + @Override + public void deleteByName(String name) { + jdbcTemplate.update("DELETE FROM user WHERE name = ?", name); + } + + @Override + @Transactional(rollbackFor = Exception.class) + public void deleteAll() { + jdbcTemplate.execute("DELETE FROM user"); + } + + @Override + public void update(User user) { + jdbcTemplate.update("UPDATE user SET name=?, age=?, address=?, email=? WHERE id=?", + user.getName(), user.getAge(), user.getAddress(), user.getEmail(), user.getId()); + } + + @Override + public Integer count() { + try { + return jdbcTemplate.queryForObject("SELECT COUNT(*) FROM user", Integer.class); + } catch (EmptyResultDataAccessException e) { + return null; + } + } + + @Override + public List list() { + return jdbcTemplate.query("SELECT * FROM user", new BeanPropertyRowMapper<>(User.class)); + } + + @Override + public User queryByName(String name) { + try { + return jdbcTemplate.queryForObject("SELECT * FROM user WHERE name = ?", + new BeanPropertyRowMapper<>(User.class), name); + } catch (EmptyResultDataAccessException e) { + return null; + } + } + + @Override + public JdbcTemplate getJdbcTemplate() { + return jdbcTemplate; + } + + @Override + public void truncate() { + jdbcTemplate.execute("TRUNCATE TABLE user"); + } + + @Override + public void recreateTable() { + jdbcTemplate.execute("DROP TABLE IF EXISTS user"); + + String sqlStatement = + "CREATE TABLE IF NOT EXISTS user (\n" + + " id BIGINT(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT 'Id',\n" + + " name VARCHAR(255) NOT NULL DEFAULT '' COMMENT '用户名',\n" + + " age INT(3) NOT NULL DEFAULT 0 COMMENT '年龄',\n" + + " address VARCHAR(255) NOT NULL DEFAULT '' COMMENT '地址',\n" + + " email VARCHAR(255) NOT NULL DEFAULT '' COMMENT '邮件',\n" + + " PRIMARY KEY (id)\n" + + ") COMMENT = '用户表';"; + jdbcTemplate.execute(sqlStatement); + } + +} +``` + +### 测试类 + +```java +import lombok.extern.slf4j.Slf4j; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.annotation.Rollback; + +import java.util.ArrayList; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +@Slf4j +@Rollback +@SpringBootTest(classes = { SpringBootDataJdbcApplication.class }) +public class DataJdbcMysqlDataSourceTest { + + @Autowired + private UserDao userDAO; + + @BeforeEach + public void before() { + userDAO.truncate(); + } + + @Test + public void insert() { + userDAO.insert(new User("张三", 18, "北京", "user1@163.com")); + User linda = userDAO.queryByName("张三"); + assertThat(linda).isNotNull(); + } + + @Test + public void batchInsert() { + List users = new ArrayList<>(); + users.add(new User("张三", 18, "北京", "user1@163.com")); + users.add(new User("李四", 19, "上海", "user1@163.com")); + users.add(new User("王五", 18, "南京", "user1@163.com")); + users.add(new User("赵六", 20, "武汉", "user1@163.com")); + + userDAO.batchInsert(users); + int count = userDAO.count(); + assertThat(count).isEqualTo(4); + + List list = userDAO.list(); + assertThat(list).isNotEmpty().hasSize(4); + list.forEach(user -> { + log.info(user.toString()); + }); + } + + @Test + public void delete() { + List users = new ArrayList<>(); + users.add(new User("张三", 18, "北京", "user1@163.com")); + users.add(new User("李四", 19, "上海", "user1@163.com")); + users.add(new User("王五", 18, "南京", "user1@163.com")); + users.add(new User("赵六", 20, "武汉", "user1@163.com")); + userDAO.batchInsert(users); + + userDAO.deleteByName("张三"); + User user = userDAO.queryByName("张三"); + assertThat(user).isNull(); + + userDAO.deleteAll(); + List list = userDAO.list(); + assertThat(list).isEmpty(); + } + + @Test + public void update() { + userDAO.insert(new User("张三", 18, "北京", "user1@163.com")); + User oldUser = userDAO.queryByName("张三"); + oldUser.setName("张三丰"); + userDAO.update(oldUser); + User newUser = userDAO.queryByName("张三丰"); + assertThat(newUser).isNotNull(); + } + +} +``` + +## Spring Boot JDBC + +> 完整示例：[spring-boot-data-jdbc](https://github.com/dunwu/spring-tutorial/tree/master/codes/data/jdbc/spring-boot-data-jdbc) + +### 引入 Spring Boot 依赖 + +你可以通过 Spring Boot 官方的初始化器（[Spring Initializr](https://start.spring.io/)）选择需要的组件来创建一个 Spring Boot 工程。或者，直接在 pom.xml 中引入所需要的依赖： + +```xml + + org.springframework.boot + spring-boot-starter-parent + 2.7.7 + + + + + org.springframework.boot + spring-boot-starter-data-jdbc + + + mysql + mysql-connector-java + + +``` + +### 配置数据源 + +引入依赖后，需要在 `application.properties` 或 `application.yml` 文件中指定数据源配置。 + +下面是一个最基本的数据源配置示例： + +```properties +spring.datasource.url = jdbc:mysql://localhost:3306/spring_tutorial?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8 +spring.datasource.driver-class-name = com.mysql.cj.jdbc.Driver +spring.datasource.username = root +spring.datasource.password = root +``` + +需要根据实际情况，替换 `url`、`username`、`password`。 + +### 测试 + +```java +import lombok.extern.slf4j.Slf4j; +import org.springframework.boot.CommandLineRunner; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.jdbc.core.JdbcTemplate; + +import java.sql.Connection; +import javax.sql.DataSource; + +@Slf4j +@SpringBootApplication +public class SpringBootDataJdbcApplication implements CommandLineRunner { + + private final JdbcTemplate jdbcTemplate; + + public SpringBootDataJdbcApplication(JdbcTemplate jdbcTemplate) { + this.jdbcTemplate = jdbcTemplate; + } + + public static void main(String[] args) { + SpringApplication.run(SpringBootDataJdbcApplication.class, args); + } + + @Override + public void run(String... args) throws Exception { + DataSource dataSource = jdbcTemplate.getDataSource(); + + Connection connection; + if (dataSource != null) { + connection = dataSource.getConnection(); + } else { + log.error("连接数据源失败！"); + return; + } + + if (connection != null) { + log.info("数据源 Url: {}", connection.getMetaData().getURL()); + } else { + log.error("连接数据源失败！"); + } + } + +} +``` + +运行 `main` 方法后，控制台会输出以下内容，表示数据源连接成功： + +``` +20:50:18.449 [main] [INFO ] i.g.d.s.d.SpringBootDataJdbcApplication.run - 数据源 Url: jdbc:mysql://localhost:3306/spring_tutorial?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8 +``` + +## Spring JDBC + +> 完整示例：[spring-data-jdbc](https://github.com/dunwu/spring-tutorial/tree/master/codes/data/jdbc/spring-data-jdbc) + +`spring-boot-starter-data-jdbc` 引入了 `spring-jdbc` ，其 JDBC 特性就是基于 `spring-jdbc`。 + +### 引入 Spring 依赖 + +在 pom.xml 中引入所需要的依赖： + +```xml + + + com.alibaba + druid + + + mysql + mysql-connector-java + + + + org.springframework + spring-context-support + + + org.springframework + spring-jdbc + + + org.springframework + spring-tx + + + +``` + +### 基于 JDBC 驱动的数据源配置 + +下面是一个 mysql 的 JDBC 数据源配置实例： + +```xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +``` + +### 测试 + +```java + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.ApplicationContext; +import org.springframework.context.support.ClassPathXmlApplicationContext; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +import java.io.IOException; +import java.sql.SQLException; + +@SuppressWarnings("all") +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(locations = { "classpath:data/spring-mysql.xml" }) +public class MysqlJdbcTest { + + @Autowired + private ApplicationContext ctx; + + @Before + public void before() { + ctx = JdbcDemo.getMysqlApplicationContext(); + } + + @Test + public void testExecJdbcOper() throws SQLException, IOException { + UserDao userDao = (UserDaoImpl) ctx.getBean("userDao"); + JdbcDemo.execJdbcOper(userDao); + } + + @After + public void after() { + ((ClassPathXmlApplicationContext) ctx).close(); + } + +} +``` + +## JdbcTemplate API + +Spring 将数据访问的样板式代码提取到模板类中。Spring 提供了 3 个 JDBC 模板类： + +- `JdbcTemplate`：最基本的 Spring JDBC 模板，这个模板支持最简单的 JDBC 数据库访问功能以及简单的索引参数查询。 +- `SimpleJdbcTemplate`：改模板类利用 Java 5 的一些特性，如自动装箱、泛型以及可变参数列表来简化 JDBC 模板的使用。 +- `NamedParameterJdbcTemplate`：使用该模板类执行查询时，可以将查询值以命名参数的形式绑定到 SQL 中，而不是使用简单的索引参数。 + +`spring-jdbc` 最核心的 API 无疑就是 `JdbcTemplate`，可以说所有的 JDBC 数据访问，几乎都是围绕着这个类去工作的。Spring 对数据库的操作在 Jdbc 层面做了深层次的封装，利用依赖注入，把数据源配置装配到 `JdbcTemplate` 中，再由 `JdbcTemplate` 负责具体的数据访问。 + +`JdbcTemplate` 主要提供以下几类方法： + +- `execute` 方法：可以用于执行任何 SQL 语句，一般用于执行 DDL 语句； +- `update` 方法及 `batchUpdate` 方法：`update` 方法用于执行新增、修改、删除等语句；`batchUpdate` 方法用于执行批处理相关语句； +- `query` 方法及 `queryForXXX` 方法：用于执行查询相关语句； +- `call` 方法：用于执行存储过程、函数相关语句。 + +为了方便演示，以下增删改查操作都围绕一个名为 user 的表（该表的主键 id 是自增序列）进行，该表的数据实体如下： + +```java +public class User { + private Integer id; + private String name; + private Integer age; + + // 省略 getter/setter +} +``` + +数据实体只要是一个纯粹的 Java Bean 即可，无需任何注解修饰。 + +### execute 方法 + +使用 execute 执行 DDL 语句，创建一个名为 test 的数据库，并在此数据库下新建一个名为 user 的表。 + +```java +public void recreateTable() { + jdbcTemplate.execute("DROP DATABASE IF EXISTS test"); + jdbcTemplate.execute("CREATE DATABASE test"); + jdbcTemplate.execute("USE test"); + jdbcTemplate.execute("DROP TABLE if EXISTS user"); + jdbcTemplate.execute("DROP TABLE if EXISTS user"); + // @formatter:off + StringBuilder sb = new StringBuilder(); + sb.append("CREATE TABLE user (id int (10) unsigned NOT NULL AUTO_INCREMENT,\n") + .append("name varchar (64) NOT NULL DEFAULT '',\n") + .append("age tinyint (3) NOT NULL DEFAULT 0,\n") + .append("PRIMARY KEY (ID));\n"); + // @formatter:on + jdbcTemplate.execute(sb.toString()); +} +``` + +### update 方法 + +新增数据 + +```java +public void insert(String name, Integer age) { + jdbcTemplate.update("INSERT INTO user(name, age) VALUES(?, ?)", name, age); +} +``` + +删除数据 + +```java +public void delete(String name) { + jdbcTemplate.update("DELETE FROM user WHERE name = ?", name); +} +``` + +修改数据 + +```java +public void update(User user) { + jdbcTemplate.update("UPDATE USER SET name=?, age=? WHERE id=?", user.getName(), user.getAge(), user.getId()); +} +``` + +批处理 + +```java +public void batchInsert(List users) { + String sql = "INSERT INTO user(name, age) VALUES(?, ?)"; + + List params = new ArrayList<>(); + + users.forEach(item -> { + params.add(new Object[] {item.getName(), item.getAge()}); + }); + jdbcTemplate.batchUpdate(sql, params); +} +``` + +### query 方法 + +查单个对象 + +```java +public User queryByName(String name) { + try { + return jdbcTemplate + .queryForObject("SELECT * FROM user WHERE name = ?", new BeanPropertyRowMapper<>(User.class), name); + } catch (EmptyResultDataAccessException e) { + return null; + } +} +``` + +查多个对象 + +```java +public List list() { + return jdbcTemplate.query("select * from USER", new BeanPropertyRowMapper(User.class)); +} +``` + +获取某个记录某列或者 count、avg、sum 等函数返回唯一值 + +```java +public Integer count() { + try { + return jdbcTemplate.queryForObject("SELECT COUNT(*) FROM user", Integer.class); + } catch (EmptyResultDataAccessException e) { + return null; + } +} +``` + +## SpringBoot JDBC 配置 + +### JdbcTemplateAutoConfiguration 类 + +`JdbcTemplateAutoConfiguration` 是 `JdbcTemplate` 自动配置类，它负责实例化 `JdbcTemplate`。 + +```java +@Configuration(proxyBeanMethods = false) +@ConditionalOnClass({ DataSource.class, JdbcTemplate.class }) +@ConditionalOnSingleCandidate(DataSource.class) +@AutoConfigureAfter(DataSourceAutoConfiguration.class) +@EnableConfigurationProperties(JdbcProperties.class) +@Import({ JdbcTemplateConfiguration.class, NamedParameterJdbcTemplateConfiguration.class }) +public class JdbcTemplateAutoConfiguration { + +} +``` + +`JdbcTemplateAutoConfiguration` 类的源码解读： + +- `@AutoConfigureAfter(DataSourceAutoConfiguration.class)` 表明 `JdbcTemplateAutoConfiguration` 必须在 `DataSourceAutoConfiguration` 执行完之后才开始工作，这意味着：`JdbcTemplate` 的初始化必须在 `DataSource` 初始化之后。 +- `JdbcProperties` 是 `JdbcTemplateAutoConfiguration` 的配置选项类，允许使用者通过设置选项控制 `JdbcTemplate` 初始化行为。 +- `@Import({ JdbcTemplateConfiguration.class, NamedParameterJdbcTemplateConfiguration.class })` 表明引入 `JdbcTemplateConfiguration`、`NamedParameterJdbcTemplateConfiguration` 两个配置类，具体的实例化 `JdbcTemplate` 的工作也是放在这两个配置中完成。 + +### JdbcTemplateConfiguration 类 + +`JdbcTemplateConfiguration` 源码如下： + +```java +@Configuration(proxyBeanMethods = false) +@ConditionalOnMissingBean(JdbcOperations.class) +class JdbcTemplateConfiguration { + + @Bean + @Primary + JdbcTemplate jdbcTemplate(DataSource dataSource, JdbcProperties properties) { + JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource); + JdbcProperties.Template template = properties.getTemplate(); + jdbcTemplate.setFetchSize(template.getFetchSize()); + jdbcTemplate.setMaxRows(template.getMaxRows()); + if (template.getQueryTimeout() != null) { + jdbcTemplate.setQueryTimeout((int) template.getQueryTimeout().getSeconds()); + } + return jdbcTemplate; + } + +} +``` + +`JdbcTemplateConfiguration` 源码解读：`JdbcTemplateConfiguration` 中根据 `DataSource` 和 `JdbcProperties` 实例化了一个 `JdbcTemplate`。 + +### NamedParameterJdbcTemplateConfiguration 类 + +`NamedParameterJdbcTemplateConfiguration` 源码如下： + +```java +@Configuration(proxyBeanMethods = false) +@ConditionalOnSingleCandidate(JdbcTemplate.class) +@ConditionalOnMissingBean(NamedParameterJdbcOperations.class) +class NamedParameterJdbcTemplateConfiguration { + + @Bean + @Primary + NamedParameterJdbcTemplate namedParameterJdbcTemplate(JdbcTemplate jdbcTemplate) { + return new NamedParameterJdbcTemplate(jdbcTemplate); + } + +} +``` + +`NamedParameterJdbcTemplateConfiguration` 源码解读：`NamedParameterJdbcTemplateConfiguration` 中根据 `JdbcTemplate` 实例化了一个 `NamedParameterJdbcTemplate`。 + +## spring-data-jdbc + +Spring Data 项目包含了对 JDBC 的存储库支持，并将自动为 `CrudRepository` 上的方法生成 SQL。对于更高级的查询，提供了 `@Query` 注解。 + +当 classpath 上存在必要的依赖项时，Spring Boot 将自动配置 Spring Data 的 JDBC 存储库。它们可以通过 `spring-boot-starter-data-jdbc` 的单一依赖项添加到项目中。如有必要，可以通过将 `@EnableJdbcRepositories` 批注或 `JdbcConfiguration` 子类添加到应用程序来控制 Spring Data JDBC 的配置。 + +> 更多 Spring Data JDBC 细节，可以参考 [Spring Data JDBC 官方文档](http://spring.io/projects/spring-data-jdbc)。 + +## 参考资料 + +- [Spring 官网](https://spring.io/) +- [Spring Framework 官方文档](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/index.html) +- [Spring Boot 官方文档](https://docs.spring.io/spring-boot/docs/current/reference/html/data.html) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/03.Spring\344\271\213\344\272\213\345\212\241.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/03.Spring\344\271\213\344\272\213\345\212\241.md" new file mode 100644 index 00000000..5a9b29fe --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/03.Spring\344\271\213\344\272\213\345\212\241.md" @@ -0,0 +1,1272 @@ +--- +title: Spring 之事务 +date: 2022-09-22 07:46:49 +order: 03 +categories: + - Java + - 框架 + - Spring + - Spring数据 +tags: + - Java + - 框架 + - Spring + - SpringBoot + - 事务 +permalink: /pages/128c54/ +--- + +# Spring 之事务 + +Spring 针对 Java Transaction API (JTA)、JDBC、Hibernate 和 Java Persistence API(JPA) 等事务 API，实现了一致的编程模型，而 Spring 的声明式事务功能更是提供了极其方便的事务配置方式，配合 Spring Boot 的自动配置，大多数 Spring Boot 项目只需要在方法上标记 `@Transactional` 注解，即可一键开启方法的事务性配置。 + +## 理解事务 + +在软件开发领域，全有或全无的操作被称为**事务（transaction）**。事务允许你将几个操作组合成一个要么全部发生要么全部不发生的工作单元。传统上 Java EE 开发对事务管理有两种选择：**全局事务**或**本地事务**，两者都有很大的局限性。 + +### 事务的特性 + +事务应该具有 4 个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为 **ACID**。 + +- **原子性（Atomic）**：一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。 +- **一致性（Consistent）**：事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。 +- **隔离性（Isolated）**：一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。 +- **持久性（Durable）**：持久性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。 + +### 全局事务 + +全局事务允许您使用多个事务资源，通常是关系数据库和消息队列。应用服务器通过 JTA 管理全局事务，这是一个繁琐的 API（部分原因在于其异常模型）。此外，JTA UserTransaction 通常需要来自 JNDI，这意味着您还需要使用 JNDI 才能使用 JTA。全局事务的使用限制了应用程序代码的任何潜在重用，因为 JTA 通常仅在应用程序服务器环境中可用。 + +以前，使用全局事务的首选方式是通过 EJB CMT（容器管理事务）。 CMT 是一种声明式事务管理（不同于程序化事务管理）。 EJB CMT 消除了对与事务相关的 JNDI 查找的需要，尽管使用 EJB 本身就需要使用 JNDI。它消除了大部分（但不是全部）编写 Java 代码来控制事务的需要。其明显的缺点是 CMT 与 JTA 和应用程序服务器环境相关联。此外，它仅在选择在 EJB 中实现业务逻辑（或至少在事务性 EJB 外观之后）时才可用。一般来说，EJB 的负面影响是如此之大，以至于这不是一个有吸引力的提议，尤其是在面对声明式事务管理的引人注目的替代方案时。 + +### 本地事务 + +本地事务是指定资源的，例如与 JDBC 连接关联的事务。本地事务可能更容易使用，但有一个明显的缺点：它们不能跨多个事务资源工作。例如，使用 JDBC 连接管理事务的代码不能在全局 JTA 事务中运行。因为应用服务器不参与事务管理，它不能确保跨多个资源的正确性（值得注意的是，大多数应用程序使用单个事务资源。）。另一个缺点是本地事务对编程模型具有侵入性。 + +### Spring 对事务的支持 + +Spring 通过回调机制将实际的事务实现从事务性的代码中抽象出来。Spring 解决了全局和本地事务的缺点。它允许开发人员在任何环境中使用一致的编程模型。您只需编写一次代码，它就可以从不同环境中的不同事务管理策略中受益。Spring 提供了对编码式和声明式事务管理的支持，大多数情况下都推荐使用声明式事务管理。 + +- 编码式事务允许用户在代码中精确定义事务的边界 +- 声明式事务（基于 AOP）有助于用户将操作与事务规则进行解耦 + +通过程序化事务管理，开发人员可以使用 Spring 事务抽象，它可以在任何底层事务基础上运行。使用首选的声明性模型，开发人员通常编写很少或根本不编写与事务管理相关的代码，因此不依赖 Spring 事务 API 或任何其他事务 API。 + +### Spring 事务的优点 + +Spring 框架为事务管理提供了一致的抽象，具有以下好处： + +- 跨不同事务 API 的一致编程模型，例如 Java Transaction API (JTA)、JDBC、Hibernate 和 Java Persistence API (JPA)。 +- 支持声明式事务管理。 +- 用于编程事务管理的 API 比复杂事务 API（如 JTA）更简单。 +- 与 Spring 的数据访问抽象完美集成。 + +## 核心 API + +### TransactionManager + +Spring 事务抽象的关键是事务策略的概念。事务策略由 `TransactionManager` 定义，特别是用于命令式事务管理的 `org.springframework.transaction.PlatformTransactionManager` 接口和用于响应式事务管理的 `org.springframework.transaction.ReactiveTransactionManager` 接口。 + +![](https://raw.githubusercontent.com/dunwu/images/master/snap/20220922073737.png) + +#### PlatformTransactionManager + +以下清单显示了 `PlatformTransactionManager` API 的定义： + +```java +public interface PlatformTransactionManager extends TransactionManager { + + TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException; + + void commit(TransactionStatus status) throws TransactionException; + + void rollback(TransactionStatus status) throws TransactionException; +} +``` + +`PlatformTransactionManager` 是一个 SPI 接口，所以使用者可以以编程方式使用它。因为 `PlatformTransactionManager` 是一个接口，所以可以根据需要轻松地 MOCK 或存根。它不依赖于查找策略，例如 JNDI。 `PlatformTransactionManager` 实现的定义与 Spring IoC 容器中的任何其他对象（或 bean）一样。仅此一项优势就使 Spring 事务成为有价值的抽象，即使您使用 JTA 也是如此。与直接使用 JTA 相比，您可以更轻松地测试事务代码。 + +同样，为了与 Spring 的理念保持一致，任何 `PlatformTransactionManager` 接口的方法可以抛出的 `TransactionException` 都是未经检查的（也就是说，它扩展了 `java.lang.RuntimeException` 类）。事务架构故障几乎总是致命的。极少数情况下，应用程序可以从事务失败中恢复，开发人员可以选择捕获和处理 `TransactionException`。重点是开发人员并非被迫这样做。 + +`getTransaction(..)` 方法根据 `TransactionDefinition` 参数返回一个 `TransactionStatus` 对象。如果当前调用堆栈中存在匹配的事务，则返回的 `TransactionStatus` 可能表示新事务或可以表示现有事务。后一种情况的含义是，与 Java EE 事务上下文一样，`TransactionStatus` 与执行线程相关联。 + +从以上可以看出，具体的事务管理机制对 Spring 来说是透明的，它并不关心那些，那些是对应各个平台需要关心的，所以 Spring 事务管理的一个优点就是为不同的事务 API 提供一致的编程模型，如 JTA、JDBC、Hibernate、JPA。下面分别介绍各个平台框架实现事务管理的机制。 + +#### JDBC 事务 + +如果应用程序中直接使用 JDBC 来进行持久化，`DataSourceTransactionManager` 会为你处理事务边界。为了使用 `DataSourceTransactionManager`，你需要使用如下的 XML 将其装配到应用程序的上下文定义中： + +```xml + + + +``` + +实际上，`DataSourceTransactionManager` 是通过调用 `java.sql.Connection` 来管理事务，而后者是通过 `DataSource` 获取到的。通过调用连接的 `commit()` 方法来提交事务，同样，事务失败则通过调用 `rollback()` 方法进行回滚。 + +#### Hibernate 事务 + +如果应用程序的持久化是通过 Hibernate 实现的，那么你需要使用 `HibernateTransactionManager`。对于 Hibernate3，需要在 Spring 上下文定义中添加如下的 `bean` 声明： + +```xml + + + +``` + +`sessionFactory` 属性需要装配一个 Hibernate 的 session 工厂，`HibernateTransactionManager` 的实现细节是它将事务管理的职责委托给 `org.hibernate.Transaction` 对象，而后者是从 Hibernate Session 中获取到的。当事务成功完成时，`HibernateTransactionManager` 将会调用 `Transaction` 对象的 `commit()` 方法，反之，将会调用 `rollback()` 方法。 + +#### Java 持久化 API 事务（JPA） + +Hibernate 多年来一直是事实上的 Java 持久化标准，但是现在 Java 持久化 API 作为真正的 Java 持久化标准进入大家的视野。如果你计划使用 JPA 的话，那你需要使用 Spring 的 `JpaTransactionManager` 来处理事务。你需要在 Spring 中这样配置 `JpaTransactionManager`： + +```xml + + + +``` + +`JpaTransactionManager` 只需要装配一个 JPA 实体管理工厂（`javax.persistence.EntityManagerFactory` 接口的任意实现）。`JpaTransactionManager` 将与由工厂所产生的 JPA EntityManager 合作来构建事务。 + +#### Java 原生 API 事务（JTA） + +如果你没有使用以上所述的事务管理，或者是跨越了多个事务管理源（比如两个或者是多个不同的数据源），你就需要使用`JtaTransactionManager`： + +```xml + + + +``` + +`JtaTransactionManager` 将事务管理的责任委托给 `javax.transaction.UserTransaction` 和 `javax.transaction.TransactionManager` 对象，其中事务成功完成通过 `UserTransaction.commit()` 方法提交，事务失败通过 `UserTransaction.rollback()` 方法回滚。 + +#### ReactiveTransactionManager + +Spring 还为使用响应式类型或 Kotlin 协程的响应式应用程序提供了事务管理抽象。以下清单显示了 `org.springframework.transaction.ReactiveTransactionManager` 定义的事务策略： + +```java +public interface ReactiveTransactionManager extends TransactionManager { + + Mono getReactiveTransaction(TransactionDefinition definition) throws TransactionException; + + Mono commit(ReactiveTransaction status) throws TransactionException; + + Mono rollback(ReactiveTransaction status) throws TransactionException; +} +``` + +响应式事务管理器主要是一个 SPI，所以使用者可以以编程方式使用它。因为 `ReactiveTransactionManager` 是一个接口，所以可以根据需要轻松地 MOCK 或存根。 + +### TransactionDefinition + +`PlatformTransactionManager` 通过 `getTransaction(TransactionDefinition definition)` 方法来得到事务，这个方法里面的参数是 `TransactionDefinition` 类，这个类就定义了一些基本的事务属性。事务属性可以理解成事务的一些基本配置，描述了事务策略如何应用到方法上。 + +`TransactionDefinition` 接口内容如下： + +```java +public interface TransactionDefinition { + int getPropagationBehavior(); // 返回事务的传播行为 + int getIsolationLevel(); // 返回事务的隔离级别，事务管理器根据它来控制另外一个事务可以看到本事务内的哪些数据 + int getTimeout(); // 返回事务必须在多少秒内完成 + boolean isReadOnly(); // 事务是否只读，事务管理器能够根据这个返回值进行优化，确保事务是只读的 +} +``` + +我们可以发现 `TransactionDefinition` 正好用来定义事务属性，下面详细介绍一下各个事务属性。 + +#### 传播行为 + +事务的传播行为（propagation behavior）是指：当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。Spring 定义了七种传播行为： + +| 传播行为 | 含义 | +| --------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `PROPAGATION_REQUIRED` | 表示当前方法必须运行在事务中。如果当前事务存在，方法将会在该事务中运行。否则，会启动一个新的事务 | +| `PROPAGATION_SUPPORTS` | 表示当前方法不需要事务上下文，但是如果存在当前事务的话，那么该方法会在这个事务中运行 | +| `PROPAGATION_MANDATORY` | 表示该方法必须在事务中运行，如果当前事务不存在，则会抛出一个异常 | +| `PROPAGATION_REQUIRED_NEW` | 表示当前方法必须运行在它自己的事务中。一个新的事务将被启动。如果存在当前事务，在该方法执行期间，当前事务会被挂起。如果使用 JTATransactionManager 的话，则需要访问 TransactionManager | +| `PROPAGATION_NOT_SUPPORTED` | 表示该方法不应该运行在事务中。如果存在当前事务，在该方法运行期间，当前事务将被挂起。如果使用 JTATransactionManager 的话，则需要访问 TransactionManager | +| `PROPAGATION_NEVER` | 表示当前方法不应该运行在事务上下文中。如果当前正有一个事务在运行，则会抛出异常 | +| `PROPAGATION_NESTED` | 表示如果当前已经存在一个事务，那么该方法将会在嵌套事务中运行。嵌套的事务可以独立于当前事务进行单独地提交或回滚。如果当前事务不存在，那么其行为与 PROPAGATION_REQUIRED 一样。注意各厂商对这种传播行为的支持是有所差异的。可以参考资源管理器的文档来确认它们是否支持嵌套事务 | + +_注：以下具体讲解传播行为的内容参考自 Spring 事务机制详解_ + +1. PROPAGATION_REQUIRED 如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。 + +```java +// 事务属性 PROPAGATION_REQUIRED +methodA { + …… + methodB(); + …… +} +``` + +```java +// 事务属性 PROPAGATION_REQUIRED +methodB { + …… +} +``` + +使用 spring 声明式事务，spring 使用 AOP 来支持声明式事务，会根据事务属性，自动在方法调用之前决定是否开启一个事务，并在方法执行之后决定事务提交或回滚事务。 + +单独调用 methodB 方法： + +```java +main { + metodB(); +} +``` + +相当于 + +```java +Main { + Connection con=null; + try{ + con = getConnection(); + con.setAutoCommit(false); + + //方法调用 + methodB(); + + //提交事务 + con.commit(); + } Catch(RuntimeException ex) { + //回滚事务 + con.rollback(); + } finally { + //释放资源 + closeCon(); + } +} +``` + +Spring 保证在 methodB 方法中所有的调用都获得到一个相同的连接。在调用 methodB 时，没有一个存在的事务，所以获得一个新的连接，开启了一个新的事务。 +单独调用 MethodA 时，在 MethodA 内又会调用 MethodB. + +执行效果相当于： + +```java +main{ + Connection con = null; + try{ + con = getConnection(); + methodA(); + con.commit(); + } catch(RuntimeException ex) { + con.rollback(); + } finally { + closeCon(); + } +} +``` + +调用 MethodA 时，环境中没有事务，所以开启一个新的事务.当在 MethodA 中调用 MethodB 时，环境中已经有了一个事务，所以 methodB 就加入当前事务。 + +2. `PROPAGATION_SUPPORTS` 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。但是对于事务同步的事务管理器，`PROPAGATION_SUPPORTS` 与不使用事务有少许不同。 + +```java +//事务属性 PROPAGATION_REQUIRED +methodA(){ + methodB(); +} + +//事务属性 PROPAGATION_SUPPORTS +methodB(){ + …… +} +``` + +单纯的调用 methodB 时，methodB 方法是非事务的执行的。当调用 methdA 时,methodB 则加入了 methodA 的事务中,事务地执行。 + +3. `PROPAGATION_MANDATORY` 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。 + +``` +//事务属性 PROPAGATION_REQUIRED +methodA(){ + methodB(); +} + +//事务属性 PROPAGATION_MANDATORY + methodB(){ + …… +} +``` + +当单独调用 methodB 时，因为当前没有一个活动的事务，则会抛出异常 throw new IllegalTransactionStateException(“Transaction propagation ‘mandatory’ but no existing transaction found”);当调用 methodA 时，methodB 则加入到 methodA 的事务中，事务地执行。 + +4. `PROPAGATION_REQUIRES_NEW` 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。 + +``` +//事务属性 PROPAGATION_REQUIRED +methodA(){ + doSomeThingA(); + methodB(); + doSomeThingB(); +} + +//事务属性 PROPAGATION_REQUIRES_NEW +methodB(){ + …… +} +``` + +调用 A 方法： + +``` +main(){ + methodA(); +} +``` + +相当于 + +``` +main(){ + TransactionManager tm = null; + try{ + //获得一个JTA事务管理器 + tm = getTransactionManager(); + tm.begin();//开启一个新的事务 + Transaction ts1 = tm.getTransaction(); + doSomeThing(); + tm.suspend();//挂起当前事务 + try{ + tm.begin();//重新开启第二个事务 + Transaction ts2 = tm.getTransaction(); + methodB(); + ts2.commit();//提交第二个事务 + } Catch(RunTimeException ex) { + ts2.rollback();//回滚第二个事务 + } finally { + //释放资源 + } + //methodB执行完后，恢复第一个事务 + tm.resume(ts1); + doSomeThingB(); + ts1.commit();//提交第一个事务 + } catch(RunTimeException ex) { + ts1.rollback();//回滚第一个事务 + } finally { + //释放资源 + } +} +``` + +在这里，我把 ts1 称为外层事务，ts2 称为内层事务。从上面的代码可以看出，ts2 与 ts1 是两个独立的事务，互不相干。Ts2 是否成功并不依赖于 ts1。如果 methodA 方法在调用 methodB 方法后的 doSomeThingB 方法失败了，而 methodB 方法所做的结果依然被提交。而除了 methodB 之外的其它代码导致的结果却被回滚了。使用 PROPAGATION_REQUIRES_NEW,需要使用 JtaTransactionManager 作为事务管理器。 + +5. `PROPAGATION_NOT_SUPPORTED` 总是非事务地执行，并挂起任何存在的事务。使用 PROPAGATION_NOT_SUPPORTED,也需要使用 JtaTransactionManager 作为事务管理器。（代码示例同上，可同理推出） +6. PROPAGATION_NEVER 总是非事务地执行，如果存在一个活动事务，则抛出异常。 +7. PROPAGATION_NESTED 如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按 TransactionDefinition.PROPAGATION_REQUIRED 属性执行。这是一个嵌套事务,使用 JDBC 3.0 驱动时,仅仅支持 DataSourceTransactionManager 作为事务管理器。需要 JDBC 驱动的 java.sql.Savepoint 类。有一些 JTA 的事务管理器实现可能也提供了同样的功能。使用 PROPAGATION_NESTED，还需要把 PlatformTransactionManager 的 nestedTransactionAllowed 属性设为 true;而 nestedTransactionAllowed 属性值默认为 false。 + +``` +//事务属性 PROPAGATION_REQUIRED +methodA(){ + doSomeThingA(); + methodB(); + doSomeThingB(); +} + +//事务属性 PROPAGATION_NESTED +methodB(){ + …… +} +``` + +如果单独调用 methodB 方法，则按 REQUIRED 属性执行。如果调用 methodA 方法，相当于下面的效果： + +``` +main(){ + Connection con = null; + Savepoint savepoint = null; + try{ + con = getConnection(); + con.setAutoCommit(false); + doSomeThingA(); + savepoint = con2.setSavepoint(); + try{ + methodB(); + } catch(RuntimeException ex) { + con.rollback(savepoint); + } finally { + //释放资源 + } + doSomeThingB(); + con.commit(); + } catch(RuntimeException ex) { + con.rollback(); + } finally { + //释放资源 + } +} +``` + +当 methodB 方法调用之前，调用 setSavepoint 方法，保存当前的状态到 savepoint。如果 methodB 方法调用失败，则恢复到之前保存的状态。但是需要注意的是，这时的事务并没有进行提交，如果后续的代码(doSomeThingB()方法)调用失败，则回滚包括 methodB 方法的所有操作。 + +嵌套事务一个非常重要的概念就是内层事务依赖于外层事务。外层事务失败时，会回滚内层事务所做的动作。而内层事务操作失败并不会引起外层事务的回滚。 + +PROPAGATION_NESTED 与 PROPAGATION_REQUIRES_NEW 的区别:它们非常类似,都像一个嵌套事务，如果不存在一个活动的事务，都会开启一个新的事务。使用 PROPAGATION_REQUIRES_NEW 时，内层事务与外层事务就像两个独立的事务一样，一旦内层事务进行了提交后，外层事务不能对其进行回滚。两个事务互不影响。两个事务不是一个真正的嵌套事务。同时它需要 JTA 事务管理器的支持。 + +使用 PROPAGATION_NESTED 时，外层事务的回滚可以引起内层事务的回滚。而内层事务的异常并不会导致外层事务的回滚，它是一个真正的嵌套事务。DataSourceTransactionManager 使用 savepoint 支持 PROPAGATION_NESTED 时，需要 JDBC 3.0 以上驱动及 1.4 以上的 JDK 版本支持。其它的 JTA TrasactionManager 实现可能有不同的支持方式。 + +PROPAGATION_REQUIRES_NEW 启动一个新的, 不依赖于环境的 “内部” 事务. 这个事务将被完全 commited 或 rolled back 而不依赖于外部事务, 它拥有自己的隔离范围, 自己的锁, 等等. 当内部事务开始执行时, 外部事务将被挂起, 内务事务结束时, 外部事务将继续执行。 + +另一方面, PROPAGATION_NESTED 开始一个 “嵌套的” 事务, 它是已经存在事务的一个真正的子事务. 潜套事务开始执行时, 它将取得一个 savepoint. 如果这个嵌套事务失败, 我们将回滚到此 savepoint. 潜套事务是外部事务的一部分, 只有外部事务结束后它才会被提交。 + +由此可见, PROPAGATION_REQUIRES_NEW 和 PROPAGATION_NESTED 的最大区别在于, PROPAGATION_REQUIRES_NEW 完全是一个新的事务, 而 PROPAGATION_NESTED 则是外部事务的子事务, 如果外部事务 commit, 嵌套事务也会被 commit, 这个规则同样适用于 roll back. + +PROPAGATION_REQUIRED 应该是我们首先的事务传播行为。它能够满足我们大多数的事务需求。 + +#### 隔离级别 + +事务的第二个维度就是隔离级别（isolation level）。隔离级别定义了一个事务可能受其他并发事务影响的程度。 + +1. 并发事务引起的问题 + +在典型的应用程序中，多个事务并发运行，经常会操作相同的数据来完成各自的任务。并发虽然是必须的，但可能会导致一下的问题。 + +- 脏读（Dirty reads）——脏读发生在一个事务读取了另一个事务改写但尚未提交的数据时。如果改写在稍后被回滚了，那么第一个事务获取的数据就是无效的。 +- 不可重复读（Nonrepeatable read）——不可重复读发生在一个事务执行相同的查询两次或两次以上，但是每次都得到不同的数据时。这通常是因为另一个并发事务在两次查询期间进行了更新。 +- 幻读（Phantom read）——幻读与不可重复读类似。它发生在一个事务（T1）读取了几行数据，接着另一个并发事务（T2）插入了一些数据时。在随后的查询中，第一个事务（T1）就会发现多了一些原本不存在的记录。 + +**不可重复读与幻读的区别** + +不可重复读的重点是修改: +同样的条件, 你读取过的数据, 再次读取出来发现值不一样了 +例如：在事务 1 中，Mary 读取了自己的工资为 1000,操作并没有完成 + +``` + con1 = getConnection(); + select salary from employee empId ="Mary"; +``` + +在事务 2 中，这时财务人员修改了 Mary 的工资为 2000,并提交了事务. + +``` + con2 = getConnection(); + update employee set salary = 2000; + con2.commit(); +``` + +在事务 1 中，Mary 再次读取自己的工资时，工资变为了 2000 + +``` + //con1 + select salary from employee empId ="Mary"; +``` + +在一个事务中前后两次读取的结果并不一致，导致了不可重复读。 + +幻读的重点在于新增或者删除： +同样的条件, 第 1 次和第 2 次读出来的记录数不一样 +例如：目前工资为 1000 的员工有 10 人。事务 1,读取所有工资为 1000 的员工。 + +``` + con1 = getConnection(); + Select * from employee where salary =1000; +``` + +共读取 10 条记录 + +这时另一个事务向 employee 表插入了一条员工记录，工资也为 1000 + +``` + con2 = getConnection(); + Insert into employee(empId,salary) values("Lili",1000); + con2.commit(); +``` + +事务 1 再次读取所有工资为 1000 的员工 + +``` + //con1 + select * from employee where salary =1000; +``` + +共读取到了 11 条记录，这就产生了幻像读。 + +从总的结果来看, 似乎不可重复读和幻读都表现为两次读取的结果不一致。但如果你从控制的角度来看, 两者的区别就比较大。 +对于前者, 只需要锁住满足条件的记录。 +对于后者, 要锁住满足条件及其相近的记录。 + +2. 隔离级别 + +| 隔离级别 | 含义 | +| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | +| ISOLATION_DEFAULT | 使用后端数据库默认的隔离级别 | +| ISOLATION_READ_UNCOMMITTED | 最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读 | +| ISOLATION_READ_COMMITTED | 允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生 | +| ISOLATION_REPEATABLE_READ | 对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生 | +| ISOLATION_SERIALIZABLE | 最高的隔离级别，完全服从 ACID 的隔离级别，确保阻止脏读、不可重复读以及幻读，也是最慢的事务隔离级别，因为它通常是通过完全锁定事务相关的数据库表来实现的 | + +#### 只读 + +事务的第三个特性是它是否为只读事务。如果事务只对后端的数据库进行该操作，数据库可以利用事务的只读特性来进行一些特定的优化。通过将事务设置为只读，你就可以给数据库一个机会，让它应用它认为合适的优化措施。 + +#### 事务超时 + +为了使应用程序很好地运行，事务不能运行太长的时间。因为事务可能涉及对后端数据库的锁定，所以长时间的事务会不必要的占用数据库资源。事务超时就是事务的一个定时器，在特定时间内事务如果没有执行完毕，那么就会自动回滚，而不是一直等待其结束。 + +#### 回滚规则 + +事务五边形的最后一个方面是一组规则，这些规则定义了哪些异常会导致事务回滚而哪些不会。默认情况下，事务只有遇到运行期异常时才会回滚，而在遇到检查型异常时不会回滚（这一行为与 EJB 的回滚行为是一致的） +但是你可以声明事务在遇到特定的检查型异常时像遇到运行期异常那样回滚。同样，你还可以声明事务遇到特定的异常不回滚，即使这些异常是运行期异常。 + +### TransactionStatus + +`TransactionStatus` 接口为事务代码提供了一种简单的方式来控制事务执行和查询事务状态。这些概念应该很熟悉，因为它们对所有事务 API 都是通用的。以下清单显示了 `TransactionStatus` 接口： + +```java +public interface TransactionStatus extends TransactionExecution, SavepointManager, Flushable { + + @Override + boolean isNewTransaction(); + + boolean hasSavepoint(); + + @Override + void setRollbackOnly(); + + @Override + boolean isRollbackOnly(); + + void flush(); + + @Override + boolean isCompleted(); +} +``` + +可以发现这个接口描述的是一些处理事务提供简单的控制事务执行和查询事务状态的方法，在回滚或提交的时候需要应用对应的事务状态。 + +### TransactionTemplate + +Spring 提供了对编程式事务和声明式事务的支持。编程式事务允许用户在代码中精确定义事务的边界，而声明式事务（基于 AOP）有助于用户将操作与事务规则进行解耦。TransactionTemplate 就是用于支持编程式事务的核心 API。 + +采用 TransactionTemplate 和采用其他 Spring 模板，如 JdbcTempalte 和 HibernateTemplate 是一样的方法。它使用回调方法，把应用程序从处理取得和释放资源中解脱出来。如同其他模板，TransactionTemplate 是线程安全的。代码片段： + +```java + TransactionTemplate tt = new TransactionTemplate(); // 新建一个TransactionTemplate + Object result = tt.execute( + new TransactionCallback(){ + public Object doTransaction(TransactionStatus status){ + updateOperation(); + return resultOfUpdateOperation(); + } + }); // 执行execute方法进行事务管理 +``` + +使用 TransactionCallback()可以返回一个值。如果使用 TransactionCallbackWithoutResult 则没有返回值。 + +## 声明式事务管理 + +> 大多数 Spring 用户选择声明式事务管理。此选项对应用程序代码的影响最小，因此最符合非侵入式轻量级容器的理想。 + +Spring 框架的声明式事务管理是通过 Spring AOP 实现的。然而，由于事务方面代码随 Spring 发行版一起提供并且可以以样板方式使用，因此通常不必理解 AOP 概念即可有效地使用此代码。 + +Spring 框架的声明式事务管理类似于 EJB CMT，因为您可以指定事务行为（或缺少它）到单个方法级别。如有必要，您可以在事务上下文中进行 `setRollbackOnly()` 调用。两种类型的事务管理之间的区别是： + +- 与绑定到 JTA 的 EJB CMT 不同，Spring 框架的声明式事务管理适用于任何环境。通过调整配置文件，它可以使用 JDBC、JPA 或 Hibernate 处理 JTA 事务或本地事务。 +- 您可以将 Spring 声明式事务管理应用于任何类，而不仅仅是诸如 EJB 之类的特殊类。 +- Spring 提供声明性回滚规则，这是一个没有 EJB 等效功能的特性。提供了对回滚规则的编程和声明性支持。 +- Spring 允许您使用 AOP 自定义事务行为。例如，您可以在事务回滚的情况下插入自定义行为。您还可以添加任意 advice 以及事务性 advice。使用 EJB CMT，您无法影响容器的事务管理，除非使用 `setRollbackOnly()`。 +- Spring 不像高端应用服务器那样支持跨远程调用传播事务上下文。如果您需要此功能，我们建议您使用 EJB。但是，在使用这种特性之前要仔细考虑，因为通常情况下，不希望事务跨越远程调用。 + +回滚规则的概念很重要。它们让您指定哪些异常（和 throwable）应该导致自动回滚。您可以在配置中以声明方式指定它，而不是在 Java 代码中。因此，尽管您仍然可以在 TransactionStatus 对象上调用 setRollbackOnly() 来回滚当前事务，但通常您可以指定 MyApplicationException 必须始终导致回滚的规则。此选项的显着优势是业务对象不依赖于事务基础架构。例如，它们通常不需要导入 Spring 事务 API 或其他 Spring API。 + +尽管 EJB 容器默认行为会在系统异常（通常是运行时异常）上自动回滚事务，但 EJB CMT 不会在应用程序异常（即除 java.rmi.RemoteException 之外的检查异常）上自动回滚事务。虽然声明式事务管理的 Spring 默认行为遵循 EJB 约定（回滚仅在未经检查的异常上自动），但自定义此行为通常很有用。 + +### Spring 声明式事务管理的实现 + +关于 Spring 框架的声明式事务支持，最重要的概念是这种支持是通过 AOP 代理启用的，并且事务 advice 是由元数据驱动的（目前是基于 XML 或基于注释的）。 AOP 与事务元数据的结合产生了一个 AOP 代理，它使用 `TransactionInterceptor` 和适当的 `TransactionManager` 实现来驱动围绕方法调用的事务。 + +Spring 的 `TransactionInterceptor` 为命令式和响应式编程模型提供事务管理。拦截器通过检查方法返回类型来检测所需的事务管理风格。返回响应式类型的方法，例如 Publisher 或 Kotlin Flow（或它们的子类型）有资格进行响应式事务管理。包括 void 在内的所有其他返回类型都使用代码路径进行命令式事务管理。 + +事务管理风格会影响需要哪个事务管理器。命令式事务需要 `PlatformTransactionManager`，而响应式事务使用 `ReactiveTransactionManager` 实现。 + +> `@Transactional` 通常与 `PlatformTransactionManager` 管理的线程绑定事务一起使用，将事务公开给当前执行线程中的所有数据访问操作。注意：这不会传播到方法中新启动的线程。 +> +> 由 `ReactiveTransactionManager` 管理的反应式事务使用 Reactor 上下文而不是线程本地属性。因此，所有参与的数据访问操作都需要在同一个反应式管道中的同一个 Reactor 上下文中执行。 + +下图显示了在事务代理上调用方法的概念视图： + +![](https://raw.githubusercontent.com/dunwu/images/master/snap/20220927093737.png) + +### 声明式事务示例 + +考虑以下接口及其伴随的实现。此示例使用 Foo 和 Bar 类作为占位符，以便您可以专注于事务使用，而无需关注特定的域模型。就本示例而言，DefaultFooService 类在每个已实现方法的主体中抛出 `UnsupportedOperationException` 实例这一事实很好。该行为使您可以看到正在创建的事务，然后回滚以响应 `UnsupportedOperationException` 实例。 + +以下清单显示了 FooService 接口： + +```java +// the service interface that we want to make transactional + +package x.y.service; + +public interface FooService { + + Foo getFoo(String fooName); + + Foo getFoo(String fooName, String barName); + + void insertFoo(Foo foo); + + void updateFoo(Foo foo); + +} +``` + +以下示例显示了上述接口的实现： + +```java +package x.y.service; + +public class DefaultFooService implements FooService { + + @Override + public Foo getFoo(String fooName) { + // ... + } + + @Override + public Foo getFoo(String fooName, String barName) { + // ... + } + + @Override + public void insertFoo(Foo foo) { + // ... + } + + @Override + public void updateFoo(Foo foo) { + // ... + } +} +``` + +假设 FooService 接口的前两个方法 getFoo(String) 和 getFoo(String, String) 必须在具有只读语义的事务上下文中运行，并且其他方法 insertFoo(Foo) 和 updateFoo(Foo )，必须在具有读写语义的事务上下文中运行。以下配置将在接下来的几段中详细说明： + +```xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +``` + +检查前面的配置。它假定您要使服务对象 fooService bean 具有事务性。要应用的事务语义封装在 `` 定义中。`` 定义读作“所有以 get 开头的方法都将在只读事务的上下文中运行，所有其他方法都将以默认事务语义运行”。`` 标签的 `transaction-manager` 属性设置为将驱动事务的 TransactionManager bean 的名称（在本例中为 txManager bean）。 + +> 如果要连接的 TransactionManager 的 bean 名称具有名称 transactionManager，则可以省略事务 advice (tx:advice/) 中的 transaction-manager 属性。如果要连接的 TransactionManager bean 有任何其他名称，则必须显式使用 transaction-manager 属性，如前面的示例所示。 + +`` 定义确保由 `txAdvice` bean 定义的事务性建议在程序中的适当位置运行。首先，您定义一个切入点，该切入点与 `FooService` 接口 (fooServiceOperation) 中定义的任何操作的执行相匹配。然后，您使用一个 adviser 将切入点与 `txAdvice` 相关联。结果表明，在执行 fooServiceOperation 时，会运行 `txAdvice` 定义的建议。 + +一个常见的要求是使整个服务层具有事务性。最好的方法是更改切入点表达式以匹配服务层中的任何操作。以下示例显示了如何执行此操作： + +```xml + + + + +``` + +前面显示的配置用于围绕从 fooService bean 定义创建的对象创建事务代理。代理配置了事务 advice，以便在代理上调用适当的方法时，根据与该方法关联的事务配置，启动、暂停、标记为只读等事务。考虑以下测试驱动前面显示的配置的程序： + +```java +public final class Boot { + + public static void main(final String[] args) throws Exception { + ApplicationContext ctx = new ClassPathXmlApplicationContext("context.xml"); + FooService fooService = ctx.getBean(FooService.class); + fooService.insertFoo(new Foo()); + } +} +``` + +### 回滚一个声明性事务 + +Spring 框架中，触发事务回滚的推荐方式是在事务上下文的代码中抛出异常。Spring 事务框架会捕获任何未处理的异常，并确定是否将事务标记为回滚。 + +在其默认配置中，Spring 事务框架只会将存在运行时且未经检查异常的事务标记为回滚。也就是说，当抛出的异常是 `RuntimeException` 的实例或子类时。（默认情况下，错误实例也会导致回滚）。从事务方法抛出的检查异常不会导致默认配置中的回滚。 + +您可以通过指定回滚规则，明确指定哪些异常类型将导致事务回滚。 + +> 回滚规则约定在抛出指定异常时是否应回滚事务，并且规则基于模式。模式可以是完全限定的类名或异常类型的完全限定类名的子字符串（必须是 `Throwable` 的子类），目前不支持通配符。例如，`javax.servlet.ServletException` 或 `ServletException` 的值将匹配 `javax.servlet.ServletException` 及其子类。 +> +> 回滚规则可以通过 `rollback-for` 和 `no-rollback-for` 属性在 XML 中配置，这允许将模式指定为字符串。使用 `@Transactional` 时，可以通过 `rollbackFor` / `noRollbackFor` 和`rollbackForClassName` / `noRollbackForClassName` 属性配置回滚规则，它们允许将模式分别指定为类引用或字符串。当异常类型被指定为类引用时，其完全限定名称将用作模式。因此，`@Transactional(rollbackFor = example.CustomException.class)` 等价于 `@Transactional(rollbackForClassName = 'example.CustomException')`。 + +以下 XML 片段演示了如何通过 `rollback-for` 属性提供异常模式来为已检查的、特定的 `Exception` 类型配置回滚： + +```xml + + + + + + +``` + +如果您不希望在抛出异常时回滚事务，您还可以指定“不回滚”规则。下面的例子告诉 Spring 事务框架，即使在面对未处理的 InstrumentNotFoundException 时也要提交伴随事务。 + +```xml + + + + + + +``` + +当 Spring Framework 事务框架捕获到异常，并检查配置的回滚规则以确定是否将事务标记为回滚时，由最重要的匹配规则决定。因此，在以下配置的情况下，除 `InstrumentNotFoundException` 之外的任何异常都会导致伴随事务的回滚。 + +```xml + + + + + +``` + +您还可以以编程方式指示所需的回滚。虽然很简单，但这个过程非常具有侵入性，并且将您的代码与 Spring Framework 的事务基础设施紧密耦合。以下示例显示如何以编程方式指示所需的回滚。 + +```java +public void resolvePosition() { + try { + // some business logic... + } catch (NoProductInStockException ex) { + // trigger rollback programmatically + TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); + } +} +``` + +如果可能的话，强烈建议您使用声明性方法进行回滚。如果您绝对需要，可以使用程序化回滚，但它的使用与实现干净的基于 POJO 的架构背道而驰。 + +### 为不同的 Bean 配置不同的事务语义 + +考虑您有许多服务层对象的场景，并且您希望对每个对象应用完全不同的事务配置。您可以通过定义具有不同 `` 元素和不同 `advice-ref` 属性值的切点来实现这一点。 + +作为一个比较点，首先假设您的所有服务层类都定义在根 x.y.service 包中。要使作为该包（或子包）中定义的类的实例并且名称以 Service 结尾的所有 bean 都具有默认的事务配置，您可以编写以下内容： + +```xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +``` + +以下示例显示了如何使用完全不同的事务设置配置两个不同的 bean + +```xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +``` + +### `` 配置 + +`` 的默认配置为： + +- 传播设置是 `REQUIRED` + +- 隔离级别为 `DEFAULT` + +- 事务是 read-write + +- 事务超时默认为底层事务系统的默认超时，如果不支持超时，则为无。 + +- 任何 `RuntimeException` 都会触发回滚，而任何已检查的 `Exception` 都不会 + +`` 配置属性 + +| 属性 | 是否必要 | 默认值 | 描述 | +| :---------------- | :------- | :--------- | :--------------------------------------------------------------------------- | +| `name` | Yes | | 与事务属性关联的方法名称。支持通配符，如：`get*`、`handle*`、`on*Event` | +| `propagation` | No | `REQUIRED` | 事务传播行为 | +| `isolation` | No | `DEFAULT` | 事务隔离级别。仅适用于 `REQUIRED` 或 `REQUIRES_NEW` 的传播设置。 | +| `timeout` | No | -1 | 事务超时时间（单位：秒）。仅适用于 `REQUIRED` 或 `REQUIRES_NEW` 的传播设置。 | +| `read-only` | No | false | read-write 或 read-only 事务。 | +| `rollback-for` | No | | 触发回滚的 `Exception` 实例列表（通过逗号分隔）。 | +| `no-rollback-for` | No | | 不触发回滚的 `Exception` 实例列表（通过逗号分隔）。 | + +### 使用 `@Transactional` 注解 + +除了基于 XML 的声明式事务配置方法之外，您还可以使用基于注解的方法。 + +下面是一个使用 `@Transactional` 注解的示例： + +```java +@Transactional +public class DefaultFooService implements FooService { + + @Override + public Foo getFoo(String fooName) { + // ... + } + + @Override + public Foo getFoo(String fooName, String barName) { + // ... + } + + @Override + public void insertFoo(Foo foo) { + // ... + } + + @Override + public void updateFoo(Foo foo) { + // ... + } +} +``` + +如上所述在类级别使用，`@Transactional` 注解表明声明类（及其子类）的所有方法都使用默认事务配置。或者，可以单独为每个方法指定注解。请注意，类级别的注解不适用于类层次结构中的祖先类；在这种情况下，继承的方法需要在本地重新声明才能参与子类级别的注解。 + +当上面的 POJO 类在 Spring 上下文中定义为 bean 时，您可以通过 `@Configuration` 类中的 `@EnableTransactionManagement` 注解使 bean 实例具有事务性。 + +在 XML 配置中， `` 标签提供了类似的便利： + +```xml + + + + + + + + + + + + + + + + + + + +``` + +#### `@Transactional` 配置 + +| Property | Type | Description | +| :------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------- | +| [value](https://docs.spring.io/spring-framework/docs/current/reference/html/data-access.html#tx-multiple-tx-mgrs-with-attransactional) | `String` | Optional qualifier that specifies the transaction manager to be used. | +| `transactionManager` | `String` | Alias for `value`. | +| `label` | Array of `String` labels to add an expressive description to the transaction. | Labels may be evaluated by transaction managers to associate implementation-specific behavior with the actual transaction. | +| [propagation](https://docs.spring.io/spring-framework/docs/current/reference/html/data-access.html#tx-propagation) | `enum`: `Propagation` | Optional propagation setting. | +| `isolation` | `enum`: `Isolation` | Optional isolation level. Applies only to propagation values of `REQUIRED` or `REQUIRES_NEW`. | +| `timeout` | `int` (in seconds of granularity) | Optional transaction timeout. Applies only to propagation values of `REQUIRED` or `REQUIRES_NEW`. | +| `timeoutString` | `String` (in seconds of granularity) | Alternative for specifying the `timeout` in seconds as a `String` value — for example, as a placeholder. | +| `readOnly` | `boolean` | Read-write versus read-only transaction. Only applicable to values of `REQUIRED` or `REQUIRES_NEW`. | +| `rollbackFor` | Array of `Class` objects, which must be derived from `Throwable.` | Optional array of exception types that must cause rollback. | +| `rollbackForClassName` | Array of exception name patterns. | Optional array of exception name patterns that must cause rollback. | +| `noRollbackFor` | Array of `Class` objects, which must be derived from `Throwable.` | Optional array of exception types that must not cause rollback. | +| `noRollbackForClassName` | Array of exception name patterns. | Optional array of exception name patterns that must not cause rollback. | + +#### 多事务管理器场景下使用 `@Transactional` + +某些情况下，应用程序中可能需要接入多个数据源，相应的，也需要多个独立的事务管理器。使用者可以使用 `@Transactional` 注释的 value 或 `transactionManager` 属性来选择性地指定要使用的 `TransactionManager` 的标识。这可以是 bean 名称或事务管理器 bean 的限定符值。 + +```java +public class TransactionalService { + + @Transactional("order") + public void setSomething(String name) { ... } + + @Transactional("account") + public void doSomething() { ... } + + @Transactional("reactive-account") + public Mono doSomethingReactive() { ... } +} +``` + +下面展示如何定义 `TransactionManager`： + +```xml + + + + ... + + + + + ... + + + + + ... + + +``` + +在这种情况下，`TransactionalService` 上的各个方法在单独的事务管理器下运行，由 order、account 和 reactive-account 限定符区分。如果没有找到明确指定的 `TransactionManager` bean，则仍使用默认的 `` 目标 bean 名称。 + +#### 自定义组合注解 + +如果您发现在许多不同的方法上重复使用 `@Transactional` 相同的属性，可以使用 Spring 的元注解自定义组合注解。 + +```java +@Target({ElementType.METHOD, ElementType.TYPE}) +@Retention(RetentionPolicy.RUNTIME) +@Transactional(transactionManager = "order", label = "causal-consistency") +public @interface OrderTx { +} + +@Target({ElementType.METHOD, ElementType.TYPE}) +@Retention(RetentionPolicy.RUNTIME) +@Transactional(transactionManager = "account", label = "retryable") +public @interface AccountTx { +} +``` + +使用示例： + +```java +public class TransactionalService { + + @OrderTx + public void setSomething(String name) { + // ... + } + + @AccountTx + public void doSomething() { + // ... + } +} +``` + +在上面的示例中，我们使用语法来定义事务管理器限定符和事务标签，但我们也可以包括传播行为、回滚规则、超时和其他特性。 + +#### 事务传播 + +在 Spring 管理的事务中，请注意物理事务和逻辑事务之间的差异，以及传播设置如何应用于这种差异。 + +![](https://raw.githubusercontent.com/dunwu/images/master/snap/20220928114544.png) + +`PROPAGATION_REQUIRED` 强制执行物理事务，如果尚不存在事务，则在当前范围的本地执行或参与更大范围定义的现有“外部”事务。这是同一线程内的常见调用堆栈安排中的一个很好的默认设置（例如，委托给多个存储库方法的服务外观，其中所有底层资源都必须参与服务级事务）。 + +当传播设置为 PROPAGATION_REQUIRED 时，将为应用该设置的每个方法创建一个逻辑事务范围。每个这样的逻辑事务范围可以单独确定仅回滚状态，外部事务范围在逻辑上独立于内部事务范围。在标准 PROPAGATION_REQUIRED 行为的情况下，所有这些范围都映射到同一个物理事务。因此，在内部事务范围内设置的仅回滚标记确实会影响外部事务实际提交的机会。 + +但是，在内部事务范围设置了仅回滚标记的情况下，外部事务尚未决定回滚本身，因此回滚（由内部事务范围静默触发）是意外的。此时会引发相应的 `UnexpectedRollbackException`。这是预期的行为，因此事务的调用者永远不会被误导以为执行了提交，而实际上并没有执行。因此，如果内部事务（外部调用者不知道）默默地将事务标记为仅回滚，外部调用者仍会调用提交。外部调用者需要接收 `UnexpectedRollbackException` 以清楚地指示执行了回滚。 + +![](https://raw.githubusercontent.com/dunwu/images/master/snap/20220928115243.png) + +PROPAGATION_REQUIRES_NEW 与 PROPAGATION_REQUIRED 相比，始终为每个受影响的事务范围使用独立的物理事务，从不参与外部范围的现有事务。在这种安排下，底层资源事务是不同的，因此可以独立提交或回滚，外部事务不受内部事务回滚状态的影响，内部事务的锁在完成后立即释放。这样一个独立的内部事务也可以声明自己的隔离级别、超时和只读设置，而不是继承外部事务的特性。 + +## JDBC 异常抽象 + +Spring 会将数据操作的异常转换为 `DataAccessException`。 + +Spring 是怎么认识那些错误码的 + +通过 SQLErrorCodeSQLExceptionTranslator 解析错误码 + +ErrorCode 定义（sql-error-codes.xml 文件） + +## Spring 事务最佳实践 + +![img](https://raw.githubusercontent.com/dunwu/images/master/snap/20200805171418.png) + +### Spring 事务未生效 + +使用 `@Transactional` 注解开启声明式事务时，最容易忽略的问题是，很可能事务并没有生效。 + +`@Transactional` 生效原则： + +#### @Transactional 方法必须是 public + +原则一：除非特殊配置（比如使用 AspectJ 静态织入实现 AOP），否则**只有定义在 `public` 方法上的 `@Transactional` 才能生效**。原因是，Spring 默认通过动态代理的方式实现 AOP，对目标方法进行增强，private 方法无法代理到，Spring 自然也无法动态增强事务处理逻辑。 + +【示例】错误使用 `@Transactional` 案例一 + +```java + @Transactional + void createUserPrivate(UserEntity entity) { + userRepository.save(entity); + if (entity.getName().contains("test")) { throw new RuntimeException("invalid username!"); } + } + + //私有方法 + public int createUserWrong1(String name) { + try { + this.createUserPrivate(new UserEntity(name)); + } catch (Exception ex) { + log.error("create user failed because {}", ex.getMessage()); + } + return userRepository.findByName(name).size(); + } +``` + +当传入名为 test 的用户实体，会抛出异常，但 `@Transactional` 未生效，不会触发回滚。 + +#### 必须通过 Spring 注入的 Bean 进行调用 + +原则二：**必须通过代理过的类从外部调用目标方法才能生效**。 + +【示例】错误使用 `@Transactional` 案例二 + +```java + //自调用 + public int createUserWrong2(String name) { + try { + this.createUserPublic(new UserEntity(name)); + } catch (Exception ex) { + log.error("create user failed because {}", ex.getMessage()); + } + return userRepository.findByName(name).size(); + } + + //可以传播出异常 + @Transactional + public void createUserPublic(UserEntity entity) { + userRepository.save(entity); + if (entity.getName().contains("test")) { throw new RuntimeException("invalid username!"); } + } +``` + +当传入名为 test 的用户实体，会抛出异常，但 `@Transactional` 未生效，不会触发回滚。 + +说明：Spring 通过 AOP 技术对方法进行字节码增强，要调用增强过的方法必然是调用代理后的对象。 + +### 事务虽然生效但未回滚 + +通过 AOP 实现事务处理可以理解为，使用 `try…catch…` 来包裹标记了 `@Transactional` 注解的方法，当方法出现了异常并且满足**一定条件**的时候，在 `catch` 里面我们可以设置事务回滚，没有异常则直接提交事务。 + +“一定条件”，主要包括两点： + +第一，只有异常传播出了标记了 @Transactional 注解的方法，事务才能回滚。在 Spring 的 TransactionAspectSupport 里有个 invokeWithinTransaction 方法，里面就是处理事务的逻辑。 + +第二，默认情况下，**出现 RuntimeException（非受检异常）或 Error 的时候，Spring 才会回滚事务**。 + +```java +@Service +@Slf4j +public class UserService { + + @Autowired + private UserRepository userRepository; + + //异常无法传播出方法，导致事务无法回滚 + @Transactional + public void createUserWrong1(String name) { + try { + userRepository.save(new UserEntity(name)); + throw new RuntimeException("error"); + } catch (Exception ex) { + log.error("create user failed", ex); + } + } + + //即使出了受检异常也无法让事务回滚 + @Transactional + public void createUserWrong2(String name) throws IOException { + userRepository.save(new UserEntity(name)); + otherTask(); + } + + //因为文件不存在，一定会抛出一个IOException + private void otherTask() throws IOException { + Files.readAllLines(Paths.get("file-that-not-exist")); + } + +} +``` + +在 createUserWrong1 方法中会抛出一个 RuntimeException，但由于方法内 catch 了所有异常，异常无法从方法传播出去，事务自然无法回滚。 + +在 createUserWrong2 方法中，注册用户的同时会有一次 otherTask 文件读取操作，如果文件读取失败，我们希望用户注册的数据库操作回滚。虽然这里没有捕获异常，但因为 otherTask 方法抛出的是受检异常，createUserWrong2 传播出去的也是受检异常，事务同样不会回滚。 + +【解决方案一】如果你希望自己捕获异常进行处理的话，也没关系，**可以手动设置 `TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();` 让当前事务处于回滚状态**： + +```java +@Transactional +public void createUserRight1(String name) { + try { + userRepository.save(new UserEntity(name)); + throw new RuntimeException("error"); + } catch (Exception ex) { + log.error("create user failed", ex); + TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); + } +} +``` + +【解决方案二】在注解中声明 `@Transactional(rollbackFor = Exception.class)`，期望遇到所有的 Exception 都回滚事务（来突破默认不回滚受检异常的限制）： + +```java +@Transactional(rollbackFor = Exception.class) +public void createUserRight2(String name) throws IOException { + userRepository.save(new UserEntity(name)); + otherTask(); +} +``` + +### 细化事务传播方式 + +如果方法涉及多次数据库操作，并希望将它们作为独立的事务进行提交或回滚，那么 +我们需要考虑进一步细化配置事务传播方式，也就是 `@Transactional` 注解的 `Propagation` 属性。 + +```java +/** + * {@link Propagation#REQUIRES_NEW} 表示执行到这个方法时需要开启新的事务，并挂起当前事务 + */ +@Transactional(propagation = Propagation.REQUIRES_NEW) +public void createSubUserWithExceptionRight(UserEntity entity) { + log.info("createSubUserWithExceptionRight start"); + userRepository.save(entity); + throw new RuntimeException("invalid status"); +} +``` + +## 参考资料 + +- [Spring 官网](https://spring.io/) +- [Spring 官方文档](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/index.html) +- [Spring Boot 官方文档](https://docs.spring.io/spring-boot/docs/current/reference/html/data.html) +- [《Java 业务开发常见错误 100 例》](https://time.geekbang.org/column/intro/100047701) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/04.Spring\344\271\213JPA.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/04.Spring\344\271\213JPA.md" new file mode 100644 index 00000000..8d362789 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/04.Spring\344\271\213JPA.md" @@ -0,0 +1,609 @@ +--- +title: Spring 之 JPA +date: 2019-02-18 14:33:55 +order: 04 +categories: + - Java + - 框架 + - Spring + - Spring数据 +tags: + - Java + - 框架 + - Spring + - SpringBoot + - JPA +permalink: /pages/a03d7b/ +--- + +# Spring 之 JPA + +JPA 为对象关系映射提供了一种基于 POJO 的持久化模型。 + +- 简化数据持久化代码的开发 +- 为 Java 社区屏蔽不同持久化 API 的差异 + +## 快速入门 + +（1）在 pom.xml 中引入依赖 + +```xml + + org.springframework.boot + spring-boot-starter-data-jpa + +``` + +（2）设置启动注解 + +```java +// 【可选】指定扫描的 Entity 目录，如果不指定，会扫描全部目录 +@EntityScan("io.github.dunwu.springboot.data.jpa") +// 【可选】指定扫描的 Repository 目录，如果不指定，会扫描全部目录 +@EnableJpaRepositories(basePackages = {"io.github.dunwu.springboot.data.jpa"}) +// 【可选】开启 JPA auditing 能力，可以自动赋值一些字段，比如创建时间、最后一次修改时间等等 +@EnableJpaAuditing +@SpringBootApplication +public class Application { + public static void main(String[] args) { + SpringApplication.run(Application.class, args); + } +} +``` + +（3）配置 + +```properties +# 数据库连接 +spring.datasource.url = jdbc:mysql://localhost:3306/spring_tutorial?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8 +spring.datasource.driver-class-name = com.mysql.cj.jdbc.Driver +spring.datasource.username = root +spring.datasource.password = root +# 是否打印 JPA SQL 日志 +spring.jpa.show-sql = true +# Hibernate的DDL策略 +spring.jpa.hibernate.ddl-auto = create-drop +``` + +（4）定义实体 + +```java +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import lombok.ToString; + +import java.util.Objects; +import javax.persistence.*; + +@Entity +@Data +@ToString +@NoArgsConstructor +@AllArgsConstructor +public class User { + + @Id + @GeneratedValue(strategy = GenerationType.AUTO) + private Long id; + + @Column(unique = true) + private String name; + + private Integer age; + + private String address; + + private String email; + + public User(String name, Integer age, String address, String email) { + this.name = name; + this.age = age; + this.address = address; + this.email = email; + } + + @Override + public int hashCode() { + return Objects.hash(id, name); + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + + if (!(o instanceof User)) { + return false; + } + + User user = (User) o; + + if (id != null && id.equals(user.id)) { + return true; + } + + return name.equals(user.name); + } + +} +``` + +（5）定义 Repository + +```java + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; +import org.springframework.data.rest.core.annotation.RepositoryRestResource; +import org.springframework.transaction.annotation.Transactional; +import org.springframework.web.bind.annotation.PathVariable; + +import java.util.List; + +@RepositoryRestResource(collectionResourceRel = "user", path = "user") +public interface UserRepository extends JpaRepository { + + User findUserById(@PathVariable("id") Long id); + + /** + * 根据用户名查找用户 + *

+ * 示例：http://localhost:8080/user/search/findByName?name=lisi + * + * @param name 用户名 + * @return {@link User} + */ + User findUserByName(@Param("name") String name); + + /** + * 根据邮箱查找用户 + *

+ * 示例：http://localhost:8080/user/search/findByEmail?email=xxx@163.com + * + * @param email 邮箱 + * @return {@link User} + */ + @Query("from User u where u.email=:email") + List findByEmail(@Param("email") String email); + + /** + * 根据用户名删除用户 + * + * @param name 用户名 + */ + @Transactional(rollbackFor = Exception.class) + void deleteByName(@Param("name") String name); + +} +``` + +（6）测试 + +```java +@Slf4j +@SpringBootTest(classes = { DataJpaApplication.class }) +public class DataJpaTests { + + @Autowired + private UserRepository repository; + + @BeforeEach + public void before() { + repository.deleteAll(); + } + + @Test + public void insert() { + User user = new User("张三", 18, "北京", "user1@163.com"); + repository.save(user); + Optional optional = repository.findById(user.getId()); + assertThat(optional).isNotNull(); + assertThat(optional.isPresent()).isTrue(); + } + + @Test + public void batchInsert() { + List users = new ArrayList<>(); + users.add(new User("张三", 18, "北京", "user1@163.com")); + users.add(new User("李四", 19, "上海", "user1@163.com")); + users.add(new User("王五", 18, "南京", "user1@163.com")); + users.add(new User("赵六", 20, "武汉", "user1@163.com")); + repository.saveAll(users); + + long count = repository.count(); + assertThat(count).isEqualTo(4); + + List list = repository.findAll(); + assertThat(list).isNotEmpty().hasSize(4); + list.forEach(this::accept); + } + + private void accept(User user) { log.info(user.toString()); } + + @Test + public void delete() { + List users = new ArrayList<>(); + users.add(new User("张三", 18, "北京", "user1@163.com")); + users.add(new User("李四", 19, "上海", "user1@163.com")); + users.add(new User("王五", 18, "南京", "user1@163.com")); + users.add(new User("赵六", 20, "武汉", "user1@163.com")); + repository.saveAll(users); + + repository.deleteByName("张三"); + assertThat(repository.findUserByName("张三")).isNull(); + + repository.deleteAll(); + List list = repository.findAll(); + assertThat(list).isEmpty(); + } + + @Test + public void findAllInPage() { + List users = new ArrayList<>(); + users.add(new User("张三", 18, "北京", "user1@163.com")); + users.add(new User("李四", 19, "上海", "user1@163.com")); + users.add(new User("王五", 18, "南京", "user1@163.com")); + users.add(new User("赵六", 20, "武汉", "user1@163.com")); + repository.saveAll(users); + + PageRequest pageRequest = PageRequest.of(1, 2); + Page page = repository.findAll(pageRequest); + assertThat(page).isNotNull(); + assertThat(page.isEmpty()).isFalse(); + assertThat(page.getTotalElements()).isEqualTo(4); + assertThat(page.getTotalPages()).isEqualTo(2); + + List list = page.get().collect(Collectors.toList()); + System.out.println("user list: "); + list.forEach(System.out::println); + } + + @Test + public void update() { + User oldUser = new User("张三", 18, "北京", "user1@163.com"); + oldUser.setName("张三丰"); + repository.save(oldUser); + + User newUser = repository.findUserByName("张三丰"); + assertThat(newUser).isNotNull(); + } + +} +``` + +## 常用 JPA 注解 + +### 实体 + +#### `@Entity` + +#### `@MappedSuperclass` + +当多个实体有共同的属性字段，比如说 id，则可以把它提炼出一个父类，并且加上 `@MappedSuperclass`，则实体基类就可以继承了。 + +#### `@Table` + +当实体名和表名不一致时，可以通过 `@Table(name="CUSTOMERS")` 的形式来明确指定一个表名。 + +### 主键 + +#### `@Id` + +@Id 注解用于声明一个实体类的属性映射为数据库的主键。 + +#### `@GeneratedValue` + +`@GeneratedValue` 用于标注主键的生成策略，通过 `strategy` 属性指定。 + +默认情况下，JPA 自动选择一个最适合底层数据库的主键生成策略：SqlServer 对应 identity，MySQL 对应 auto increment。 + +在 `javax.persistence.GenerationType` 中定义了以下几种可供选择的策略： + +```java +public enum GenerationType { + TABLE, + SEQUENCE, + IDENTITY, + AUTO +} +``` + +- `IDENTITY`：采用数据库 ID 自增长的方式来自增主键字段，Oracle 不支持这种方式； +- `AUTO`： JPA 自动选择合适的策略，是默认选项； +- `SEQUENCE`：通过序列产生主键，通过 `@SequenceGenerator` 注解指定序列名，MySql 不支持这种方式 +- `TABLE`：通过表产生主键，框架借由表模拟序列产生主键，使用该策略可以使应用更易于数据库移植。 + +也就是如果你没有指定 strategy 属性，默认策略是 AUTO，JPA 会根据你使用的数据库来自动选择策略，比如说我使用的是 mysql 则，自动的主键策略就是 IDENTITY （auto increment）。 + +### 映射 + +#### `@Column` + +当你的 entity 属性名和数据库中的字段名不一致，可以使用 `@Column` 明确指定，它也可以设置一些属性 + +```java +@Column(length = 10, nullable = false, unique = true) +``` + +```java +@Column(columnDefinition = "INT(3)") +private int age; +``` + +`@Column` 支持的参数： + +- `unique` 属性表示该字段是否为唯一标识，默认为 false。如果表中有一个字段需要唯一标识，则既可以使用该标记，也可以使用 `@Table` 标记中的 `@UniqueConstraint`。 +- `nullable` 属性表示该字段是否可以为 `null` 值，默认为 true。 +- `insertable` 属性表示在使用 `INSERT` 插入数据时，是否需要插入该字段的值。 +- `updatable` 属性表示在使用 `UPDATE` 更新数据时，是否需要更新该字段的值。`insertable` 和 `updatable` 属性一般多用于只读的属性，例如主键和外键等。这些字段的值通常是自动生成的。 +- `columnDefinition` 属性表示创建表时，该字段创建的 SQL 语句，一般用于通过 Entity 生成表定义时使用。 +- `table` 属性表示当映射多个表时，指定表的表中的字段。默认值为主表的表名。 +- `length` 属性表示字段的长度，当字段的类型为 `varchar` 时，该属性才有效，默认为 255 个字符。 +- `precision` 属性和 scale 属性表示精度，当字段类型为 `double` 时，`precision` 表示数值的总长度，`scale` 表示小数点所占的位数。 + +`@JoinTable` + +`@JoinColumn` + +### 关系 + +表关系映射（双向映射） + +- `@OneToOne`：一对一关系 +- `@OneToMany`：一对多 +- `@ManyToMany`（不推荐使用，而是采用用中间对象，把多对多拆成两个对多一关系） + +字段映射（单向映射）： + +- `@Embedded`、`@Embeddable` 嵌入式关系（单向映射） +- `@ElementCollection` 集合一对多关系（单向映射） + +#### `@OneToOne` + +`@OneToOne` 表示一对一关系 + +#### `@OneToMany` + +`@OneToMany` 表示一对多关系 + +`@ManyToOne` + +`@ManyToMany` + +`OrderBy` + +## 查询 + +查询方式有： + +- 方法名字方式查询 + +- `@Query` 注解方式查询 +- 动态 SQL 方式查询 + +- Example 方式查询 + +`JpaRepository` 提供了如下表所述的内置查询 + +- `List findAll();` - 返回所有实体 +- `List findAllById(Iterable var1);` - 返回指定 id 的所有实体 +- `T getOne(ID var1);` - 根据 id 返回对应的实体，如果未找到，则返回空。 +- `List findAll(Sort var1);` - 返回所有实体，按照指定顺序返回。 +- `Page findAll(Pageable var1);` - 返回实体列表，实体的 offset 和 limit 通过 pageable 来指定 + +### 方法名字方式查询方式 + +Spring Data 通过查询的方法名和参数名来自动构造一个 JPA QQL 查询。 + +```java +public interface UserRepository extends JpaRepository { + public User findByName(String name); +} +``` + +方法名和参数名要遵守一定的规则，Spring Data JPA 才能自动转换为 JPQL： + +- 方法名通常包含多个实体属性用于查询，属性之间可以使用 `AND` 和 `OR` 连接，也支持 `Between`、`LessThan`、`GreaterThan`、`Like`； + +- 方法名可以以 `findBy`、`getBy`、`queryBy` 开头； + +- 查询结果可以排序，方法名包含 OrderBy+属性+ASC（DESC）； + +- 可以通过 `Top`、`First` 来限定查询的结果集； + +- 一些特殊的参数可以出现在参数列表里，比如 `Pageeable`、`Sort` + +示例： + +```java +// 根据名字查询，且按照名字升序 +List findByLastnameOrderByFirstnameAsc(String name); + +// 根据名字查询，且使用翻页查询 +Page findByLastname(String lastname, Pageable pageable); + +// 查询满足条件的前10个用户 +List findFirst10ByLastname(String lastname, Sort sort); + +// 使用And联合查询 +List findByFirstnameAndLastname(String firstname, String lastname); + +// 使用Or查询 +List findDistinctPeopleByLastnameOrFirstname(String lastname, String firstname); + +// 使用like查询，name 必须包含like中的%或者? +public User findByNameLike(String name); +``` + +| Keyword | Sample | JPQL snippet | +| ------------------- | --------------------------------------------------------- | ------------------------------------------------------------------ | +| `And` | `findByLastnameAndFirstname` | `… where x.lastname = ?1 and x.firstname = ?2` | +| `Or` | `findByLastnameOrFirstname` | `… where x.lastname = ?1 or x.firstname = ?2` | +| `Is,Equals` | `findByFirstname,findByFirstnameIs,findByFirstnameEquals` | `… where x.firstname = 1?` | +| `Between` | `findByStartDateBetween` | `… where x.startDate between 1? and ?2` | +| `LessThan` | `findByAgeLessThan` | `… where x.age < ?1` | +| `LessThanEqual` | `findByAgeLessThanEqual` | `… where x.age <= ?1` | +| `GreaterThan` | `findByAgeGreaterThan` | `… where x.age > ?1` | +| `GreaterThanEqual` | `findByAgeGreaterThanEqual` | `… where x.age >= ?1` | +| `After` | `findByStartDateAfter` | `… where x.startDate > ?1` | +| `Before` | `findByStartDateBefore` | `… where x.startDate < ?1` | +| `IsNull` | `findByAgeIsNull` | `… where x.age is null` | +| `IsNotNull,NotNull` | `findByAge(Is)NotNull` | `… where x.age not null` | +| `Like` | `findByFirstnameLike` | `… where x.firstname like ?1` | +| `NotLike` | `findByFirstnameNotLike` | `… where x.firstname not like ?1` | +| `StartingWith` | `findByFirstnameStartingWith` | `… where x.firstname like ?1` (parameter bound with appended `%`) | +| `EndingWith` | `findByFirstnameEndingWith` | `… where x.firstname like ?1` (parameter bound with prepended `%`) | +| `Containing` | `findByFirstnameContaining` | `… where x.firstname like ?1` (parameter bound wrapped in `%`) | +| `OrderBy` | `findByAgeOrderByLastnameDesc` | `… where x.age = ?1 order by x.lastname desc` | +| `Not` | `findByLastnameNot` | `… where x.lastname <> ?1` | +| `In` | `findByAgeIn(Collection ages)` | `… where x.age in ?1` | +| `NotIn` | `findByAgeNotIn(Collection age)` | `… where x.age not in ?1` | +| `True` | `findByActiveTrue()` | `… where x.active = true` | +| `False` | `findByActiveFalse()` | `… where x.active = false` | +| `IgnoreCase` | `findByFirstnameIgnoreCase` | `… where UPPER(x.firstame) = UPPER(?1)` | + +### @Query 注解方式查询 + +注解 `@Query` 允许在方法上使用 JPQL。 + +其中操作针对的是对象名和对象属性名，而非数据库中的表名和字段名。 + +```java +@Query("select u form User u where u.name=?1 and u.depantment.id=?2"); +public User findUser(String name, Integer departmentId); +``` + +```java +@Query("form User u where u.name=?1 and u.depantment.id=?2"); +public User findUser(String name, Integer departmentId); +``` + +如果使用 SQL 而不是 JPSQL，可以使用 `nativeQuery` 属性，设置为 true。 + +```java +@Query(value="select * from user where name=?1 and department_id=?2", nativeQuery=true) +public User nativeQuery(String name, Integer departmentId); +``` + +无论 JPQL，还是 SQL，都支持"命名参数"： + +```java +@Query(value="select * from user where name=:name and department_id=:departmentId", nativeQuery=true) +public User nativeQuery2(String name, Integer departmentId); +``` + +如果 SQL 活着 JPQL 查询结果集并非 Entity，可以用 `Object[]` 数组代替，比如分组统计每个部分的用户数 + +```java +@Query(value="select department_id,count(*) from user group by department_id", nativeQuery=true) +public List queryUserCount() +``` + +这条查询将返回数组，对象类型依赖于查询结果，被示例中，返回的是 `String` 和 `BigInteger` 类型 + +查询时可以使用 `Pageable` 和 `Sort` 来完成翻页和排序。 + +```java +@Query("select u from User u where department.id=?1") +public Page QueryUsers(Integer departmentId, Pageable page); +``` + +`@Query` 还允许 SQL 更新、删除语句，此时必须搭配 `@Modifying` 使用，比如： + +```java +@Modifying +@Query("update User u set u.name= ?1 where u.id= ?2") +int updateName(String name, Integer id); +``` + +### 动态 SQL 方式查询 + +可参考：[SpringDataJpa 中的复杂查询和动态查询，多表查询](https://juejin.cn/post/6844904160807092237) + +### Example 方式查询 + +允许根据实体创建一个 Example 对象，Spring Data 通过 Example 对象来构造 JPQL。但是使用不灵活条件是 AND,不能使用 or，时间的大于小于，between 等。 + +继承 `JpaRepository` + +```java + List findAll(Example var1); + List findAll(Example var1, Sort var2); +``` + +```java +public List getByExample(String name) { + Department dept = new Department(); + dept.setId(1); + + User user = new User(); + user.setName(name); + user.setDepartment(dept); + Example example = Example.of(user); + List list = userDao.findAll(example); + return list +} +``` + +以上代码首先创建了 User 对象，设置查询条件，名称为参数 name，部门 id 为 1，通过 `Example.of` 构造了此查询。 + +大部分查询并非完全匹配查询，ExampleMatcher 提供了更多的条件指定.比如以 xxx 开头的所有用户，则可以使用以下代码构造 + +```java +ExampleMatcher matcher = ExampleMatcher.matching().withMatcher("xxx", + GenericPropertyMatchers.startsWith().ignoreCase()); +Example example = Example.of(user, matcher); +``` + +### 排序 Sort + +Sort 对象用来指定排序，最简单的 Sort 对象构造可以传入一个属性名列表（不是数据库列名，是属性名）。默认采用升序排序。 + +```java +Sort sort = new Sort("id"); +//Sort sort = new Sort(Direction.DESC, "id"); +return userDao.findAll(sort); +``` + +Hibernate 根据 Sort 构造了排序条件，Sort("id") 表示按照 id 采用默认升序进行排序 + +其他 Sort 的构造方法还包括以下主要的一些： + +- `public Sort(String... properties)`，按照指定的属性列表升序排序。 +- `public Sort(Sort.Direction direction, String... properties)`，按照指定属性列表排序，排序由 direction 指定，direction 是一个枚举类型，有 `Direction.ASC` 和 `Direction.DESC`。 +- `public Sort(Sort.Order... orders)`，可以通过 Order 静态方法来创建 + - `public static Sort.Order asc(String property)` + - `public static Sort.Order desc(String property)` + +### 分页 Page 和 Pageable + +Pageable 接口用于构造翻页查询，PageRequest 是其实现类，可以通过提供的工厂方法创建 PageRequest： + +注意我这边使用的是 sring boot 2.0.2 ，jpa 版本是 2.0.8，新版本与之前版本的操作方法有所不同。 + +- `public static PageRequest of(int page, int size)` + +- `public static PageRequest of(int page, int size, Sort sort)` - 也可以在 PageRequest 中加入排序 + +- `public static PageRequest of(int page, int size, Direction direction, String... properties)`，或者自定义排序规则 + +page 是从 0 开始，表示查询页，size 指每页的期望行数。 + +Spring Data 翻页查询总是返回 Page 对象，Page 对象提供了以下常用的方法 + +- `int getTotalPages();`，总的页数 +- `long getTotalElements();` - 返回总数 +- `List getContent();` - 返回此次查询的结果集 + +## 核心 API + +![](https://raw.githubusercontent.com/dunwu/images/master/snap/20230123160810.png) + +## 参考资料 + +- [Spring 官网](https://spring.io/) +- [Spring Framework 官方文档](https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/index.html) +- [Spring Boot 官方文档](https://docs.spring.io/spring-boot/docs/current/reference/html/data.html) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/10.Spring\351\233\206\346\210\220Mybatis.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/10.Spring\351\233\206\346\210\220Mybatis.md" new file mode 100644 index 00000000..d20f39b6 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/10.Spring\351\233\206\346\210\220Mybatis.md" @@ -0,0 +1,252 @@ +--- +title: Spring 集成 Mybatis +date: 2019-05-09 17:09:25 +order: 10 +categories: + - Java + - 框架 + - Spring + - Spring数据 +tags: + - Java + - 框架 + - Spring + - SpringBoot + - MyBatis + - PageHelper + - Mapper +permalink: /pages/88219e/ +--- + +# Spring 集成 Mybatis + +[Mybatis 官网](http://www.mybatis.org/mybatis-3/) 是一款持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生类型、接口和 Java 的 POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。 + +## 快速入门 + +要使用 MyBatis，只需将 [mybatis-x.x.x.jar](https://github.com/mybatis/mybatis-3/releases) 文件置于类路径（classpath）中即可。 + +如果使用 Maven 来构建项目，则需将下面的依赖代码置于 pom.xml 文件中： + +```xml + + org.mybatis + mybatis + x.x.x + +``` + +### 从 XML 中构建 SqlSessionFactory + +每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先配置的 Configuration 实例来构建出 SqlSessionFactory 实例。 + +从 XML 文件中构建 SqlSessionFactory 的实例非常简单，建议使用类路径下的资源文件进行配置。但也可以使用任意的输入流（InputStream）实例，比如用文件路径字符串或 file:// URL 构造的输入流。MyBatis 包含一个名叫 Resources 的工具类，它包含一些实用方法，使得从类路径或其它位置加载资源文件更加容易。 + +```java +String resource = "org/mybatis/example/mybatis-config.xml"; +InputStream inputStream = Resources.getResourceAsStream(resource); +SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); +``` + +XML 配置文件中包含了对 MyBatis 系统的核心设置，包括获取数据库连接实例的数据源（DataSource）以及决定事务作用域和控制方式的事务管理器（TransactionManager）。后面会再探讨 XML 配置文件的详细内容，这里先给出一个简单的示例： + +```xml + + + + + + + + + + + + + + + + + + +``` + +当然，还有很多可以在 XML 文件中配置的选项，上面的示例仅罗列了最关键的部分。注意 XML 头部的声明，它用来验证 XML 文档的正确性。environment 元素体中包含了事务管理和连接池的配置。mappers 元素则包含了一组映射器（mapper），这些映射器的 XML 映射文件包含了 SQL 代码和映射定义信息。 + +### 不使用 XML 构建 SqlSessionFactory + +如果你更愿意直接从 Java 代码而不是 XML 文件中创建配置，或者想要创建你自己的配置构建器，MyBatis 也提供了完整的配置类，提供了所有与 XML 文件等价的配置项。 + +```java +DataSource dataSource = BlogDataSourceFactory.getBlogDataSource(); +TransactionFactory transactionFactory = new JdbcTransactionFactory(); +Environment environment = new Environment("development", transactionFactory, dataSource); +Configuration configuration = new Configuration(environment); +configuration.addMapper(BlogMapper.class); +SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration); +``` + +注意该例中，configuration 添加了一个映射器类（mapper class）。映射器类是 Java 类，它们包含 SQL 映射注解从而避免依赖 XML 映射文件。不过，由于 Java 注解的一些限制以及某些 MyBatis 映射的复杂性，要使用大多数高级映射（比如：嵌套联合映射），仍然需要使用 XML 映射文件进行映射。有鉴于此，如果存在一个同名 XML 映射文件，MyBatis 会自动查找并加载它（在这个例子中，基于类路径和 BlogMapper.class 的类名，会加载 BlogMapper.xml）。具体细节稍后讨论。 + +### 从 SqlSessionFactory 中获取 SqlSession + +既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。例如： + +```java +try (SqlSession session = sqlSessionFactory.openSession()) { + Blog blog = (Blog) session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101); +} +``` + +诚然，这种方式能够正常工作，对使用旧版本 MyBatis 的用户来说也比较熟悉。但现在有了一种更简洁的方式——使用和指定语句的参数和返回值相匹配的接口（比如 BlogMapper.class），现在你的代码不仅更清晰，更加类型安全，还不用担心可能出错的字符串字面值以及强制类型转换。 + +例如： + +```java +try (SqlSession session = sqlSessionFactory.openSession()) { + BlogMapper mapper = session.getMapper(BlogMapper.class); + Blog blog = mapper.selectBlog(101); +} +``` + +现在我们来探究一下这段代码究竟做了些什么。 + +### 探究已映射的 SQL 语句 + +现在你可能很想知道 SqlSession 和 Mapper 到底具体执行了些什么操作，但 SQL 语句映射是个相当广泛的话题，可能会占去文档的大部分篇幅。但为了让你能够了解个大概，这里先给出几个例子。 + +在上面提到的例子中，一个语句既可以通过 XML 定义，也可以通过注解定义。我们先看看 XML 定义语句的方式，事实上 MyBatis 提供的所有特性都可以利用基于 XML 的映射语言来实现，这使得 MyBatis 在过去的数年间得以流行。如果你用过旧版本的 MyBatis，你应该对这个概念比较熟悉。但相比于之前的版本，新版本改进了许多 XML 的配置，后面我们会提到这些改进。这里给出一个基于 XML 映射语句的示例，它应该可以满足上个示例中 SqlSession 的调用。 + +```xml + + + + + +``` + +为了这个简单的例子，我们似乎写了不少配置，但其实并不多。在一个 XML 映射文件中，可以定义无数个映射语句，这样一来，XML 头部和文档类型声明部分就显得微不足道了。文档的其它部分很直白，容易理解。它在命名空间 “org.mybatis.example.BlogMapper” 中定义了一个名为 “selectBlog” 的映射语句，这样你就可以用全限定名 “org.mybatis.example.BlogMapper.selectBlog” 来调用映射语句了，就像上面例子中那样： + +```java +Blog blog = (Blog) session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101); +``` + +你可能会注意到，这种方式和用全限定名调用 Java 对象的方法类似。这样，该命名就可以直接映射到在命名空间中同名的映射器类，并将已映射的 select 语句匹配到对应名称、参数和返回类型的方法。因此你就可以像上面那样，不费吹灰之力地在对应的映射器接口调用方法，就像下面这样： + +```java +BlogMapper mapper = session.getMapper(BlogMapper.class); +Blog blog = mapper.selectBlog(101); +``` + +第二种方法有很多优势，首先它不依赖于字符串字面值，会更安全一点；其次，如果你的 IDE 有代码补全功能，那么代码补全可以帮你快速选择到映射好的 SQL 语句。 + +**提示** **对命名空间的一点补充** + +在之前版本的 MyBatis 中，**命名空间（Namespaces）**的作用并不大，是可选的。但现在，随着命名空间越发重要，你必须指定命名空间。 + +命名空间的作用有两个，一个是利用更长的全限定名来将不同的语句隔离开来，同时也实现了你上面见到的接口绑定。就算你觉得暂时用不到接口绑定，你也应该遵循这里的规定，以防哪天你改变了主意。长远来看，只要将命名空间置于合适的 Java 包命名空间之中，你的代码会变得更加整洁，也有利于你更方便地使用 MyBatis。 + +**命名解析：**为了减少输入量，MyBatis 对所有具有名称的配置元素（包括语句，结果映射，缓存等）使用了如下的命名解析规则。 + +- 全限定名（比如 “com.mypackage.MyMapper.selectAllThings）将被直接用于查找及使用。 +- 短名称（比如 “selectAllThings”）如果全局唯一也可以作为一个单独的引用。如果不唯一，有两个或两个以上的相同名称（比如 “com.foo.selectAllThings” 和 “com.bar.selectAllThings”），那么使用时就会产生“短名称不唯一”的错误，这种情况下就必须使用全限定名。 + +对于像 BlogMapper 这样的映射器类来说，还有另一种方法来完成语句映射。它们映射的语句可以不用 XML 来配置，而可以使用 Java 注解来配置。比如，上面的 XML 示例可以被替换成如下的配置： + +```java +package org.mybatis.example; +public interface BlogMapper { + @Select("SELECT * FROM blog WHERE id = #{id}") + Blog selectBlog(int id); +} +``` + +使用注解来映射简单语句会使代码显得更加简洁，但对于稍微复杂一点的语句，Java 注解不仅力不从心，还会让本就复杂的 SQL 语句更加混乱不堪。因此，如果你需要做一些很复杂的操作，最好用 XML 来映射语句。 + +选择何种方式来配置映射，以及是否应该要统一映射语句定义的形式，完全取决于你和你的团队。换句话说，永远不要拘泥于一种方式，你可以很轻松地在基于注解和 XML 的语句映射方式间自由移植和切换。 + +### 作用域（Scope）和生命周期 + +理解我们之前讨论过的不同作用域和生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题。 + +**提示** **对象生命周期和依赖注入框架** + +依赖注入框架可以创建线程安全的、基于事务的 SqlSession 和映射器，并将它们直接注入到你的 bean 中，因此可以直接忽略它们的生命周期。如果对如何通过依赖注入框架使用 MyBatis 感兴趣，可以研究一下 MyBatis-Spring 或 MyBatis-Guice 两个子项目。 + +#### SqlSessionFactoryBuilder + +这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例，但最好还是不要一直保留着它，以保证所有的 XML 解析资源可以被释放给更重要的事情。 + +#### SqlSessionFactory + +SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏习惯”。因此 SqlSessionFactory 的最佳作用域是应用作用域。有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。 + +#### SqlSession + +每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中，比如 Servlet 框架中的 HttpSession。如果你现在正在使用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。这个关闭操作很重要，为了确保每次都能执行关闭操作，你应该把这个关闭操作放到 finally 块中。下面的示例就是一个确保 SqlSession 关闭的标准模式： + +```java +try (SqlSession session = sqlSessionFactory.openSession()) { + // 你的应用逻辑代码 +} +``` + +在所有代码中都遵循这种使用模式，可以保证所有数据库资源都能被正确地关闭。 + +#### 映射器实例 + +映射器是一些绑定映射语句的接口。映射器接口的实例是从 SqlSession 中获得的。虽然从技术层面上来讲，任何映射器实例的最大作用域与请求它们的 SqlSession 相同。但方法作用域才是映射器实例的最合适的作用域。也就是说，映射器实例应该在调用它们的方法中被获取，使用完毕之后即可丢弃。映射器实例并不需要被显式地关闭。尽管在整个请求作用域保留映射器实例不会有什么问题，但是你很快会发现，在这个作用域上管理太多像 SqlSession 的资源会让你忙不过来。因此，最好将映射器放在方法作用域内。就像下面的例子一样： + +```java +try (SqlSession session = sqlSessionFactory.openSession()) { + BlogMapper mapper = session.getMapper(BlogMapper.class); + // 你的应用逻辑代码 +} +``` + +## Mybatis 扩展工具 + +### Mybatis Plus + +[MyBatis-Plus](https://github.com/baomidou/mybatis-plus)（简称 MP）是一个 [MyBatis](https://www.mybatis.org/mybatis-3/) 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。 + +【集成示例】[spring-boot-data-mybatis-plus](https://github.com/dunwu/spring-tutorial/tree/develop/codes/data/orm/spring-boot-data-mybatis-plus) + +### Mapper + +[Mapper](https://github.com/abel533/Mapper) 是一个 Mybatis CRUD 扩展插件。 + +Mapper 的基本原理是将实体类映射为数据库中的表和字段信息，因此实体类需要通过注解配置基本的元数据，配置好实体后，只需要创建一个继承基础接口的 Mapper 接口就可以开始使用了。 + +【集成示例】[spring-boot-data-mybatis-mapper](https://github.com/dunwu/spring-tutorial/tree/develop/codes/data/orm/spring-boot-data-mybatis-mapper) + +### PageHelper + +[PageHelper](https://github.com/pagehelper/Mybatis-PageHelper) 是一个 Mybatis 通用分页插件。 + +【集成示例】[spring-boot-data-mybatis-mapper](https://github.com/dunwu/spring-tutorial/tree/develop/codes/data/orm/spring-boot-data-mybatis-mapper) + +## 参考资料 + +- **官方** + - [Mybatis Github](https://github.com/mybatis/mybatis-3) + - [Mybatis 官网](http://www.mybatis.org/mybatis-3/) + - [MyBatis 官方代码生成（mybatis-generator）](https://github.com/mybatis/generator) + - [MyBatis 官方集成 Spring（mybatis-spring）](https://github.com/mybatis/spring) + - [Mybatis 官方集成 Spring Boot（mybatis-spring-boot）](https://github.com/mybatis/spring-boot-starter) +- **扩展插件** + - [MyBatis-Plus](https://github.com/baomidou/mybatis-plus) - CRUD 扩展插件、代码生成器、分页器等多功能 + - [Mapper](https://github.com/abel533/Mapper) - Mybatis CRUD 扩展插件 + - [PageHelper](https://github.com/pagehelper/Mybatis-PageHelper) - Mybatis 通用分页插件 +- **文章** + - [深入理解 mybatis 原理](https://blog.csdn.net/luanlouis/article/details/40422941) + - [mybatis 源码中文注释](https://github.com/tuguangquan/mybatis) + - [MyBatis Generator 详解](https://blog.csdn.net/isea533/article/details/42102297) + - [Mybatis 常见面试题](https://juejin.im/post/5aa646cdf265da237e095da1) + - [Mybatis 中强大的 resultMap](https://juejin.im/post/5cee8b61e51d455d88219ea4) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/20.SpringData\347\273\274\345\220\210.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/20.SpringData\347\273\274\345\220\210.md" new file mode 100644 index 00000000..d4120edf --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/20.SpringData\347\273\274\345\220\210.md" @@ -0,0 +1,301 @@ +--- +title: Spring Data 综合 +date: 2023-02-08 09:10:35 +order: 20 +categories: + - Java + - 框架 + - Spring + - Spring数据 +tags: + - Java + - 框架 + - Spring + - SpringBoot +permalink: /pages/191cdb/ +--- + +# Spring Data 综合 + +Spring Data Repository 抽象的目标是显著减少各种访问持久化存储的样板式代码。 + +## 核心概念 + +Repository 是 Spring Data 的核心接口。此接口主要用作标记接口，以捕获要使用的类型并帮助您发现扩展此接口的接口。`CrudRepository` 和 `ListCrudRepository` 接口为被管理的实体类提供复杂的 CRUD 功能。`ListCrudRepository` 提供等效方法，但它们返回 `List`，而 `CrudRepository` 方法返回 `Iterable`。 + +`CrudRepository` 接口定义： + +```java +public interface CrudRepository extends Repository { + + S save(S entity); + + Optional findById(ID primaryKey); + + Iterable findAll(); + + long count(); + + void delete(T entity); + + boolean existsById(ID primaryKey); + + // … more functionality omitted. +} +``` + +> Spring Data 项目也提供了一些特定持久化技术的抽象接口，如：JpaRepository 或 MongoRepository。这些接口扩展了 CrudRepository 并暴露了一些持久化技术的底层功能。 + +除了 `CrudRepository` 之外，还有一个 `PagingAndSortingRepository` 接口，它添加了额外的方法来简化对实体的分页访问： + +```java +public interface PagingAndSortingRepository { + + Iterable findAll(Sort sort); + + Page findAll(Pageable pageable); +} +``` + +【示例】要按页面大小 20 访问 User 的第二页，可以执行如下操作 + +```java +PagingAndSortingRepository repository = // … get access to a bean +Page users = repository.findAll(PageRequest.of(1, 20)); +``` + +除了查询方法之外，计数和删除时的查询也是可用的。 + +【示例】根据姓氏计数 + +```java +interface UserRepository extends CrudRepository { + long countByLastname(String lastname); +} +``` + +【示例】根据姓氏删除 + +```java +interface UserRepository extends CrudRepository { + + long deleteByLastname(String lastname); + + List removeByLastname(String lastname); +} +``` + +## 查询方法 + +使用 Spring Data 对数据库进行查询有以下四步： + +1. 声明一个扩展 `Repository` 或其子接口的接口，并指定泛型类型（实体类和 ID 类型），如以下示例所示： + + ```java + interface PersonRepository extends Repository { … } + ``` + +2. 在接口中声明查询方法 + + ```java + interface PersonRepository extends Repository { + List findByLastname(String lastname); + } + ``` + +3. 使用 [JavaConfig](https://docs.spring.io/spring-data/jdbc/docs/current/reference/html/#repositories.create-instances.java-config) 或 [XML 配置](https://docs.spring.io/spring-data/jdbc/docs/current/reference/html/#repositories.create-instances)为这些接口创建代理实例 + + ```java + @EnableJpaRepositories + class Config { … } + ``` + +4. 注入 `Repository` 实例并使用 + + ```java + class SomeClient { + + private final PersonRepository repository; + + SomeClient(PersonRepository repository) { + this.repository = repository; + } + + void doSomething() { + List persons = repository.findByLastname("Matthews"); + } + } + ``` + +## 定义 Repository + +首先需要定义一个 Repository 接口，该接口必须扩展 Repository 并且指定泛型类型（实体类和 ID 类型）。如果想为该实体暴露 CRUD 方法，可以扩展 CrudRepository 接口。 + +### 微调 Repository 定义 + +Spring Data 提供了很多种 Repository 以应对不同的需求场景。 + +`CrudRepository` 提供了 CRUD 功能。 + +`ListCrudRepository` 和 `CrudRepository` 类似，但对于那些返回多个实体的方法，它返回一个 `List` 而不是 `Iterable`，这样使用可能更方便。 + +如果使用响应式框架，可以使用 `ReactiveCrudRepository` 或 `RxJava3CrudRepository`。 + +`CoroutineCrudRepository` 支持 Kotlin 的协程特性。 + +`PagingAndSortingRepository` 提供了分页、排序功能。 + +如果不想扩展 Spring Data 接口，还可以使用 `@RepositoryDefinition` 注释您的 `Repository` 接口。扩展一个 CRUD Repository 接口，需要暴露一组完整的方法来操作实体。如果希望对暴露的方法有选择性，可以将要暴露的方法从 CRUD Repository 复制到自定义的 Repository 中。这样做时，可以更改方法的返回类型。如果可能，Spring Data 将遵循返回类型。例如，对于返回多个实体的方法，可以选择 `Iterable`、`List`、`Collection` 或 `VAVR` 列表。 + +自定义基础 `Repository` 接口，必须用 `@NoRepositoryBean` 标记。这可以防止 Spring Data 尝试直接创建它的实例并失败，因为它无法确定该 Repository 的实体，因为它仍然包含一个通用类型变量。 + +以下示例显示了如何有选择地暴露 CRUD 方法（在本例中为 findById 和 save）： + +```java +@NoRepositoryBean +interface MyBaseRepository extends Repository { + + Optional findById(ID id); + + S save(S entity); +} + +interface UserRepository extends MyBaseRepository { + User findByEmailAddress(EmailAddress emailAddress); +} +``` + +### 使用多个 Spring 数据模块 + +有时，程序中需要使用多个 Spring Data 模块。在这种情况下，必须区分持久化技术。当检测到类路径上有多个 Repository 工厂时，Spring Data 进入严格的配置模式。 + +如果定义的 Repository 扩展了特定模块中的 Repository，则它是特定 Spring Data 模块的有效候选者。 + +如果实体类使用了特定模块的类型注解，则它是特定 Spring Data 模块的有效候选者。 Spring Data 模块接受第三方注解（例如 JPA 的 `@Entity`）或提供自己的注解（例如用于 Spring Data MongoDB 和 Spring Data Elasticsearch 的 `@Document`）。 + +以下示例显示了一个使用模块特定接口（在本例中为 JPA）的 Repository： + +```java +interface MyRepository extends JpaRepository { } + +@NoRepositoryBean +interface MyBaseRepository extends JpaRepository { … } + +interface UserRepository extends MyBaseRepository { … } +``` + +MyRepository 和 UserRepository 扩展了 JpaRepository。它们是 Spring Data JPA 模块的有效候选者。 + +以下示例显示了一个使用通用接口的 Repository + +```java +interface AmbiguousRepository extends Repository { … } + +@NoRepositoryBean +interface MyBaseRepository extends CrudRepository { … } + +interface AmbiguousUserRepository extends MyBaseRepository { … } +``` + +AmbiguousRepository 和 AmbiguousUserRepository 仅扩展了 Repository 和 CrudRepository。虽然这在使用唯一的 Spring Data 模块时很好，但是存在多个模块时，无法区分这些 Repository 应该绑定到哪个特定的 Spring Data。 + +以下示例显示了一个使用带注解的实体类的 Repository + +```java +interface PersonRepository extends Repository { … } + +@Entity +class Person { … } + +interface UserRepository extends Repository { … } + +@Document +class User { … } +``` + +PersonRepository 引用 Person，它使用 JPA @Entity 注解进行标记，因此这个 Repository 显然属于 Spring Data JPA。 UserRepository 引用 User，它使用 Spring Data MongoDB 的 @Document 注解进行标记。 + +以下错误示例显示了一个使用带有混合注解的实体类的 Repository + +```java +interface JpaPersonRepository extends Repository { … } + +interface MongoDBPersonRepository extends Repository { … } + +@Entity +@Document +class Person { … } +``` + +此示例中的实体类同时使用了 JPA 和 Spring Data MongoDB 的注解。示例中定义了两个 Repository：JpaPersonRepository 和 MongoDBPersonRepository。一个用于 JPA，另一个用于 MongoDB。 Spring Data 不再能够区分 Repository，这会导致未定义的行为。 + +区分 Repository 的最后一种方法是确定 Repository 扫描 package 的范围。 + +```java +@EnableJpaRepositories(basePackages = "com.acme.repositories.jpa") +@EnableMongoRepositories(basePackages = "com.acme.repositories.mongo") +class Configuration { … } +``` + +## 定义查询方法 + +Repository 代理有两种方法可以从方法名称派生特定于存储的查询： + +- 通过直接从方法名称派生查询。 +- 通过使用手动定义的查询。 + +可用选项取决于实际存储。但是，必须有一个策略来决定创建什么实际查询。 + +### 查询策略 + +以下策略可用于Repository 基础结构来解析查询。对于 Java 配置，您可以使用 EnableJpaRepositories 注释的 queryLookupStrategy 属性。特定数据存储可能不支持某些策略。 + +- `CREATE` 尝试从查询方法名称构造特定存储的查询。 +- `USE_DECLARED_QUERY` 尝试查找已声明的查询，如果找不到则抛出异常。 +- `CREATE_IF_NOT_FOUND` （默认）结合了 `CREATE` 和 `USE_DECLARED_QUERY`。 + +### 查询创建 + +Spring Data 中有一套内置的查询构建器机制，可以自动映射符合命名和参数规则的方法。 + +```java +interface PersonRepository extends Repository { + + List findByEmailAddressAndLastname(EmailAddress emailAddress, String lastname); + + // Enables the distinct flag for the query + List findDistinctPeopleByLastnameOrFirstname(String lastname, String firstname); + List findPeopleDistinctByLastnameOrFirstname(String lastname, String firstname); + + // Enabling ignoring case for an individual property + List findByLastnameIgnoreCase(String lastname); + // Enabling ignoring case for all suitable properties + List findByLastnameAndFirstnameAllIgnoreCase(String lastname, String firstname); + + // Enabling static ORDER BY for a query + List findByLastnameOrderByFirstnameAsc(String lastname); + List findByLastnameOrderByFirstnameDesc(String lastname); +} +``` + +解析查询方法名称分为主语和谓语。第一部分 (find…By, exists…By) 定义查询的主语，第二部分构成谓词。主语可以包含更多的表达。 `find`（或其他引入关键字）和 `By` 之间的任何文本都被认为是描述性的，除非使用其中一个结果限制关键字，例如 `Distinct` 在要创建的查询上设置不同的标志或 `Top`/`First` 限制查询结果。 + +> 参考： +> +> [Spring Data 支持的查询主语关键词](https://docs.spring.io/spring-data/jdbc/docs/current/reference/html/#appendix.query.method.subject) +> +> [Spring Data 支持的查询谓语关键词](https://docs.spring.io/spring-data/jdbc/docs/current/reference/html/#appendix.query.method.predicate) + +## 创建 Repository 实例 + +## 自定义 Repository 实现 + +## Spring Data 扩展 + +## 参考资料 + +- [Redis 官网](https://redis.io/) +- [Redis Github](https://github.com/redis/redis) +- [spring-data-redis Github](https://github.com/spring-projects/spring-data-redis) +- [Spring Data Redis 官方文档](https://docs.spring.io/spring-data/redis/docs/current/reference/html/) +- [Spring Data 官方示例](https://github.com/spring-projects/spring-data-examples/) \ No newline at end of file diff --git "a/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/21.Spring\350\256\277\351\227\256Redis.md" "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/21.Spring\350\256\277\351\227\256Redis.md" new file mode 100644 index 00000000..c8bf04e3 --- /dev/null +++ "b/docs/01.Java/13.\346\241\206\346\236\266/01.Spring/02.Spring\346\225\260\346\215\256/21.Spring\350\256\277\351\227\256Redis.md" @@ -0,0 +1,248 @@ +--- +title: Spring 访问 Redis +date: 2023-01-31 20:54:42 +order: 21 +categories: + - Java + - 框架 + - Spring + - Spring数据 +tags: + - Java + - 框架 + - Spring + - SpringBoot + - Redis +permalink: /pages/65e4a2/ +--- + +# Spring 访问 Redis + +## 简介 + +[Redis](https://redis.io/) 是一个被数百万开发人员用作数据库、缓存、流引擎和消息代理的开源内存数据库。 + +在 Spring 中，[spring-data-redis](https://github.com/spring-projects/spring-data-redis) 项目对访问 [Redis](https://redis.io/) 进行了 API 封装，提供了便捷的访问方式。 [spring-data-redis](https://github.com/spring-projects/spring-data-redis) + +[spring-boot](https://github.com/spring-projects/spring-boot) 项目中的子模块 [spring-boot-starter-data-redis](https://github.com/spring-projects/spring-boot/tree/main/spring-boot-project/spring-boot-starters/spring-boot-starter-data-redis) 基于 [spring-data-redis](https://github.com/spring-projects/spring-data-redis) 项目，做了二次封装，大大简化了 Redis 的相关配置。 + +## Spring Boot 快速入门 + +### 引入依赖 + +在 pom.xml 中引入依赖： + +```xml + + org.springframework.boot + spring-boot-starter-data-redis + +``` + +### 数据源配置 + +```properties +spring.redis.database = 0 +spring.redis.host = localhost +spring.redis.port = 6379 +spring.redis.password = +``` + +### 定义实体 + +```java +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; +import lombok.ToString; + +import java.io.Serializable; + +@Data +@ToString +@NoArgsConstructor +@AllArgsConstructor +public class User implements Serializable { + + private static final long serialVersionUID = 4142994984277644695L; + + private Long id; + private String name; + private Integer age; + private String address; + private String email; + +} +``` + +### 定义 CRUD 接口 + +```java +import java.util.Map; + +public interface UserService { + + void batchSetUsers(Map users); + + long count(); + + User getUser(Long id); + + void setUser(User user); + +} +``` + +### 创建 CRUD 接口实现 + +```java + +import cn.hutool.core.bean.BeanUtil; +import org.springframework.data.redis.core.RedisTemplate; +import org.springframework.stereotype.Service; + +import java.util.Map; + +@Service +public class UserServiceImpl implements UserService { + + public static final String DEFAULT_KEY = "spring:tutorial:user"; + + private final RedisTemplate redisTemplate; + + public UserServiceImpl(RedisTemplate redisTemplate) { + this.redisTemplate = redisTemplate; + } + + @Override + public void batchSetUsers(Map users) { + redisTemplate.opsForHash().putAll(DEFAULT_KEY, users); + } + + @Override + public long count() { + return redisTemplate.opsForHash().size(DEFAULT_KEY); + } + + @Override + public User getUser(Long id) { + Object obj = redisTemplate.opsForHash().get(DEFAULT_KEY, id.toString()); + return BeanUtil.toBean(obj, User.class); + } + + @Override + public void setUser(User user) { + redisTemplate.opsForHash().put(DEFAULT_KEY, user.getId().toString(), user); + } + +} +``` + +### 创建 Application + +创建 Application，实例化一个 `RedisTemplate` 对象。 + +```java +import com.fasterxml.jackson.annotation.JsonAutoDetect; +import com.fasterxml.jackson.annotation.PropertyAccessor; +import com.fasterxml.jackson.databind.ObjectMapper; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Primary; +import org.springframework.data.redis.connection.RedisConnectionFactory; +import org.springframework.data.redis.core.RedisTemplate; +import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer; +import org.springframework.data.redis.serializer.StringRedisSerializer; + +@Slf4j +@SpringBootApplication +public class RedisQuickstartApplication { + + @Autowired + private ObjectMapper objectMapper; + + @Bean + @Primary + public RedisTemplate redisTemplate(RedisConnectionFactory factory) { + + // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public + objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); + // // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常 + // objectMapper.activateDefaultTyping(new DefaultBaseTypeLimitingValidator(), + // ObjectMapper.DefaultTyping.NON_FINAL); + + // 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式） + Jackson2JsonRedisSerializer

JavaTutorial

${message}

javatool

示例列表

Hello ${name}!

Hello

基本的 CRUD 应用

User Information

JavaTutorial