小白学spring笔记_小白自学spring-优快云博客

本文链接：https://blog.youkuaiyun.com/chenyong6301567/article/details/126968512

Spring的IOC和AOP机制？

我们是在使用 Spring 框架的过程中，其实就是为了使用 IOC ，依赖注入，和 AOP ，面向切面编程，这两个是Spring 的灵魂。主要用到的设计模式有工厂模式和代理模式。

IOC 就是典型的工厂模式，通过 sessionfactory 去注入实例。

AOP 就是典型的代理模式的体现。

代理模式是常用的 java 设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

spring 的 IoC 容器是 spring 的核心， spring AOP 是 spring 框架的重要组成部分。

在传统的程序设计中，当调用者需要被调用者的协助时，通常由调用者来创建被调用者的实例。但在 spring 里创建被调用者的工作不再由调用者来完成，因此控制反转（ IoC ）；创建被调用者实例的工作通常由spring 容器来完成，然后注入调用者，因此也被称为依赖注入（ DI ），依赖注入和控制反转是同一个概念。

面向方面编程（ AOP) 是以另一个角度来考虑程序结构，通过分析程序结构的关注点来完善面向对象编程（OOP ）。 OOP 将应用程序分解成各个层次的对象，而 AOP 将程序分解成多个切面。 spring AOP 只实现了方法级别的连接点，在J2EE 应用中， AOP 拦截到方法级别的操作就已经足够。在 spring 中，未来使 IoC方便地使用健壮、灵活的企业服务，需要利用 spring AOP 实现为 IoC 和企业服务之间建立联系。

IOC: 控制反转也叫依赖注入。利用了工厂模式

将对象交给容器管理，你只需要在 spring 配置文件总配置相应的 bean ，以及设置相关的属性，让

spring 容器来生成类的实例对象以及管理对象。在 spring 容器启动的时候， spring 会把你在配置文件 中配置的 bean 都初始化好，然后在你需要调用的时候，就把它已经初始化好的那些 bean 分配给你需要 调用这些 bean 的类（假设这个类名是 A ），分配的方法就是调用 A 的 setter 方法来注入，而不需要你在 A 里面 new 这些 bean 了。

注意：面试的时候，如果有条件，画图，这样更加显得你懂了 .

spring ioc 初始化流程

AOP: 面向切面编程。（ Aspect-Oriented Programming ）

AOP 可以说是对 OOP 的补充和完善。 OOP 引入封装、继承和多态性等概念来建立一种对象层次结构， 用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候， OOP 则显得无能为力。 也就是说， OOP 允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代 码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。在 OOP 设计中，它 导致了大量代码的重复，而不利于各个模块的重用。

将程序中的交叉业务逻辑（比如安全，日志，事务等），封装成一个切面，然后注入到目标对象（具体 业务逻辑）中去。 实现 AOP 的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装 饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建 “ 方面 ” ，从而使得编 译器可以在编译期间织入有关 “ 方面 ” 的代码 .

简单点解释，比方说你想在你的 biz 层所有类中都加上一个打印 ‘ 你好 ’ 的功能 , 这时就可以用 aop 思想来做 . 你先写个类写个类方法，方法经实现打印‘ 你好 ’, 然后 Ioc 这个类 ref ＝ “biz.*” 让每个类都注入即可实现。

Spring 中 Autowired 和 Resource 关键字的区别？

@Resource 和 @Autowired 都是做 bean 的注入时使用，其实 @Resource 并不是 Spring 的注解，它的包

是 javax.annotation.Resource ，需要导入，但是 Spring 支持该注解的注入。

1 、共同点

两者都可以写在字段和 setter 方法上。两者如果都写在字段上，那么就不需要再写 setter 方法。

2 、不同点

（ 1 ） @Autowired

@Autowired 为 Spring 提供的注解，需要导入包

org.springframework.beans.factory.annotation.Autowired; 只按照 byType 注入。

@Autowired 注解是按照类型（ byType ）装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许null 值，可以设置它的 required 属性为 false 。如果我们想使用按照名称（ byName ）来装配，可以结合@Qualififier 注解一起使用。如下：

（ 2 ） @Resource

@Resource 默认按照 ByName 自动注入，由 J2EE 提供，需要导入包 javax.annotation.Resource 。

@Resource 有两个重要的属性： name 和 type ，而 Spring 将 @Resource 注解的 name 属性解析为 bean 的名字，而type 属性则解析为 bean 的类型。所以，如果使用 name 属性，则使用 byName 的自动注入策略，而使用type 属性时则使用 byType 自动注入策略。如果既不制定 name 也不制定 type 属性，这时将通过反射机制使用byName 自动注入策略。

注：最好是将 @Resource 放在 setter 方法上，因为这样更符合面向对象的思想，通过 set 、 get 去操作属性，而不是直接去操作属性。

public class TestServiceImpl {

// 下面两种 @Autowired 只要使用一种即可

@Autowired

private UserDao userDao ; // 用于字段上

@Autowired

public void setUserDao ( UserDao userDao ) { // 用于属性的方法上

this . userDao = userDao ;

}

public class TestServiceImpl {

@Autowired

@Qualifier ( "userDao" )

private UserDao userDao ;

}

public class TestServiceImpl {

// 下面两种 @Resource 只要使用一种即可

@Resource ( name = "userDao" )

private UserDao userDao ; // 用于字段上

@Resource ( name = "userDao" )

public void setUserDao ( UserDao userDao ) { // 用于属性的 setter 方法上

this . userDao = userDao ;

}

} @Resource 装配顺序：

①如果同时指定了 name 和 type ，则从 Spring 上下文中找到唯一匹配的 bean 进行装配，找不到则抛出异常。

②如果指定了 name ，则从上下文中查找名称（ id ）匹配的 bean 进行装配，找不到则抛出异常。

③如果指定了 type ，则从上下文中找到类似匹配的唯一 bean 进行装配，找不到或是找到多个，都会抛出异常。

④如果既没有指定 name ，又没有指定 type ，则自动按照 byName 方式进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配。

@Resource 的作用相当于 @Autowired ，只不过 @Autowired 按照 byType 自动注入。

依赖注入的方式有几种，各是什么 ?

一、构造器注入

将被依赖对象通过构造函数的参数注入给依赖对象，并且在初始化对象的时候注入。

优点：

对象初始化完成后便可获得可使用的对象。

缺点：

当需要注入的对象很多时，构造器参数列表将会很长；

不够灵活。若有多种注入方式，每种方式只需注入指定几个依赖，那么就需要提供多个重载的构造函

数，麻烦。

二、 setter 方法注入

IoC Service Provider 通过调用成员变量提供的 setter 函数将被依赖对象注入给依赖类。

优点：

灵活。可以选择性地注入需要的对象。

缺点：

依赖对象初始化完成后由于尚未注入被依赖对象，因此还不能使用。

三、接口注入

依赖类必须要实现指定的接口，然后实现该接口中的一个函数，该函数就是用于依赖注入。该函数的参数就是要注入的对象。

优点接口注入中，接口的名字、函数的名字都不重要，只要保证函数的参数是要注入的对象类型即可。

缺点：

侵入行太强，不建议使用。

PS ：什么是侵入行？

如果类 A 要使用别人提供的一个功能，若为了使用这功能，需要在自己的类中增加额外的代码，这就是

侵入性。

讲一下什么是 Spring

Spring 是一个轻量级的 IoC 和 AOP 容器框架。是为 Java 应用程序提供基础性服务的一套框架，目的是用于简化企业应用程序的开发，它使得开发者只需要关心业务需求。常见的配置方式有三种：基于XML 的配置、基于注解的配置、基于Java 的配置。主要由以下几个模块组成：

Spring Core ：核心类库，提供 IOC 服务；

Spring Context ：提供框架式的 Bean 访问方式，以及企业级功能（ JNDI 、定时任务等）；

Spring AOP ： AOP 服务；

Spring DAO ：对 JDBC 的抽象，简化了数据访问异常的处理；

Spring ORM ：对现有的 ORM 框架的支持；

Spring Web ：提供了基本的面向 Web 的综合特性，例如多方文件上传；

Spring MVC ：提供面向 Web 应用的 Model-View-Controller 实现。

Spring MVC 流程

1 、用户发送请求至前端控制器 DispatcherServlet 。

2 、 DispatcherServlet 收到请求调用 HandlerMapping 处理器映射器。

3 、处理器映射器找到具体的处理器 ( 可以根据 xml 配置、注解进行查找 ) ，生成处理器对象及处理器拦截

器 ( 如果有则生成 ) 一并返回给 DispatcherServlet 。

4 、 DispatcherServlet 调用 HandlerAdapter 处理器适配器。

5 、 HandlerAdapter 经过适配调用具体的处理器 (Controller ，也叫后端控制器 ) 。

6 、 Controller 执行完成返回 ModelAndView 。

7 、 HandlerAdapter 将 controller 执行结果 ModelAndView 返回给 DispatcherServlet 。

8 、 DispatcherServlet 将 ModelAndView 传给 ViewReslover 视图解析器。

9 、 ViewReslover 解析后返回具体 View 。

10 、 DispatcherServlet 根据 View 进行渲染视图（即将模型数据填充至视图中）。 11 、 DispatcherServlet 响应用户。

组件说明：

以下组件通常使用框架提供实现：

DispatcherServlet ：作为前端控制器，整个流程控制的中心，控制其它组件执行，统一调度，降低组件

之间的耦合性，提高每个组件的扩展性。

HandlerMapping ：通过扩展处理器映射器实现不同的映射方式，例如：配置文件方式，实现接口方

式，注解方式等。

HandlAdapter ：通过扩展处理器适配器，支持更多类型的处理器。

ViewResolver ：通过扩展视图解析器，支持更多类型的视图解析，例如： jsp 、 freemarker 、 pdf 、

excel 等。

组件：

1 、前端控制器 DispatcherServlet （不需要工程师开发） , 由框架提供

作用：接收请求，响应结果，相当于转发器，中央处理器。有了 dispatcherServlet 减少了其它组件之间的耦合度。

用户请求到达前端控制器，它就相当于 mvc 模式中的 c ， dispatcherServlet 是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet 的存在降低了组件之间的耦合性。

2 、处理器映射器 HandlerMapping( 不需要工程师开发 ), 由框架提供

作用：根据请求的 url 查找 Handler

HandlerMapping 负责根据用户请求找到 Handler 即处理器， springmvc 提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。

3 、处理器适配器 HandlerAdapter

作用：按照特定规则（ HandlerAdapter 要求的规则）去执行 Handler

通过 HandlerAdapter 对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

4 、处理器 Handler( 需要工程师开发 )

注意：编写 Handler 时按照 HandlerAdapter 的要求去做，这样适配器才可以去正确执行 Handler

Handler 是继 DispatcherServlet 前端控制器的后端控制器，在 DispatcherServlet 的控制下 Handler 对具

体的用户请求进行处理。

由于 Handler 涉及到具体的用户业务请求，所以一般情况需要工程师根据业务需求开发 Handler 。

5 、视图解析器 View resolver( 不需要工程师开发 ), 由框架提供

作用：进行视图解析，根据逻辑视图名解析成真正的视图（ view ）

View Resolver 负责将处理结果生成 View 视图， View Resolver 首先根据逻辑视图名解析成物理视图名即

具体的页面地址，再生成 View 视图对象，最后对 View 进行渲染将处理结果通过页面展示给用户。

springmvc 框架提供了很多的 View 视图类型，包括： jstlView 、 freemarkerView 、 pdfView 等。

一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由工程师根据业务需求开发具体的页面。

6 、视图 View( 需要工程师开发 jsp...)

View 是一个接口，实现类支持不同的 View 类型（ jsp 、 freemarker 、 pdf... ）

核心架构的具体流程步骤如下：

1 、首先用户发送请求 ——>DispatcherServlet ，前端控制器收到请求后自己不进行处理，而是委托给

其他的解析器进行处理，作为统一访问点，进行全局的流程控制；

2 、 DispatcherServlet——>HandlerMapping ， HandlerMapping 将会把请求映射为

HandlerExecutionChain 对象（包含一个 Handler 处理器（页面控制器）对象、多个

HandlerInterceptor 拦截器）对象，通过这种策略模式，很容易添加新的映射策略； 3 、 DispatcherServlet——>HandlerAdapter ， HandlerAdapter 将会把处理器包装为适配器，从而支

持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；

4 、 HandlerAdapter——> 处理器功能处理方法的调用， HandlerAdapter 将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理；并返回一个ModelAndView 对象（包含模型数据、逻辑视图名）；

5 、 ModelAndView 的逻辑视图名 ——> ViewResolver ， ViewResolver 将把逻辑视图名解析为具体的 View，通过这种策略模式，很容易更换其他视图技术；

6 、 View——> 渲染， View 会根据传进来的 Model 模型数据进行渲染，此处的 Model 实际是一个 Map 数据结构，因此很容易支持其他视图技术；

7 、返回控制权给 DispatcherServlet ，由 DispatcherServlet 返回响应给用户，到此一个流程结束。

下边两个组件通常情况下需要开发：

Handler ：处理器，即后端控制器用 controller 表示。

View ：视图，即展示给用户的界面，视图中通常需要标签语言展示模型数据。

在讲 SpringMVC 之前我们先来看一下什么是 MVC 模式

MVC ： MVC 是一种设计模式

MVC 的原理图：

分析：

M-Model 模型（完成业务逻辑：有 javaBean 构成， service+dao+entity ）

V-View 视图（做界面的展示 jsp ， html…… ）

C-Controller 控制器（接收请求 —> 调用模型 —> 根据结果派发页面）

springMVC 是什么：

springMVC 是一个 MVC 的开源框架， springMVC=struts2+spring ， springMVC 就相当于是 Struts2

加上 sring 的整合，但是这里有一个疑惑就是， springMVC 和 spring 是什么样的关系呢？这个在百度百科上有一个很好的解释：意思是说，springMVC 是 spring 的一个后续产品，其实就是 spring 在原有基础上，又提供了web 应用的 MVC 模块，可以简单的把 springMVC 理解为是 spring 的一个模块（类似 AOP ， IOC这样的模块），网络上经常会说 springMVC 和 spring 无缝集成，其实 springMVC 就是 spring 的一个子模块，所以根本不需要同spring 进行整合。

看到这个图大家可能会有很多的疑惑，现在我们来看一下这个图的步骤：（可以对比 MVC 的原理图进行

理解）

第一步 : 用户发起请求到前端控制器（ DispatcherServlet ）

第二步：前端控制器请求处理器映射器（ HandlerMappering ）去查找处理器（ Handle ）：通过 xml 配

置或者注解进行查找

第三步：找到以后处理器映射器（ HandlerMappering ）像前端控制器返回执行链

（ HandlerExecutionChain ）

第四步：前端控制器（ DispatcherServlet ）调用处理器适配器（ HandlerAdapter ）去执行处理器

（ Handler ）

第五步：处理器适配器去执行 Handler

第六步： Handler 执行完给处理器适配器返回 ModelAndView

第七步：处理器适配器向前端控制器返回 ModelAndView

第八步：前端控制器请求视图解析器（ ViewResolver ）去进行视图解析

第九步：视图解析器像前端控制器返回 View

第十步：前端控制器对视图进行渲染

第十一步：前端控制器向用户响应结果

看到这些步骤我相信大家很感觉非常的乱，这是正常的，但是这里主要是要大家理解 springMVC 中的

几个组件：

前端控制器（ DispatcherServlet ）：接收请求，响应结果，相当于电脑的 CPU 。

处理器映射器（ HandlerMapping ）：根据 URL 去查找处理器

处理器（ Handler ）：（需要程序员去写代码处理逻辑的）处理器适配器（ HandlerAdapter ）：会把处理器包装成适配器，这样就可以支持多种类型的处理器，

类比笔记本的适配器（适配器模式的应用）

视图解析器（ ViewResovler ）：进行视图解析，多返回的字符串，进行处理，可以解析成对应的页面

SpringMVC 怎么样设定重定向和转发的？

（ 1 ）转发：在返回值前面加 "forward:" ，譬如 "forward:user.do?name=method4"

（ 2 ）重定向：在返回值前面加 "redirect:" ，譬如 "redirect: http://www.baidu.com "

SpringMVC 常用的注解有哪些？

@RequestMapping ：用于处理请求 url 映射的注解，可用于类或方法上。用于类上，则表示类中的所

有响应请求的方法都是以该地址作为父路径。

@RequestBody ：注解实现接收 http 请求的 json 数据，将 json 转换为 java 对象。

@ResponseBody ：注解实现将 conreoller 方法返回对象转化为 json 对象响应给客户。

Spring 的 AOP 理解：

OOP 面向对象，允许开发者定义纵向的关系，但并适用于定义横向的关系，导致了大量代码的重复，而不利于各个模块的重用。

AOP ，一般称为面向切面，作为面向对象的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“ 切面 ” （ Aspect ），减少系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。可用于权限认证、日志、事务处理。

AOP 实现的关键在于代理模式， AOP 代理主要分为静态代理和动态代理。静态代理的代表为 AspectJ ；

动态代理则以 Spring AOP 为代表。

（ 1 ） AspectJ 是静态代理的增强，所谓静态代理，就是 AOP 框架会在编译阶段生成 AOP 代理类，因此也称为编译时增强，他会在编译阶段将AspectJ( 切面 ) 织入到 Java 字节码中，运行的时候就是增强之后的 AOP对象。

（ 2 ） Spring AOP 使用的动态代理，所谓的动态代理就是说 AOP 框架不会去修改字节码，而是每次运行

时在内存中临时为方法生成一个 AOP 对象，这个 AOP 对象包含了目标对象的全部方法，并且在特定的切

点做了增强处理，并回调原对象的方法。

Spring AOP 中的动态代理主要有两种方式， JDK 动态代理和 CGLIB 动态代理：

① JDK 动态代理只提供接口的代理，不支持类的代理。核心 InvocationHandler 接口和 Proxy 类，

InvocationHandler 通过 invoke() 方法反射来调用目标类中的代码，动态地将横切逻辑和业务编织在一起；接着，Proxy 利用 InvocationHandler 动态创建一个符合某一接口的的实例 , 生成目标类的代理对象。

② 如果代理类没有实现 InvocationHandler 接口，那么 Spring AOP 会选择使用 CGLIB 来动态代理目

标类。 CGLIB （ Code Generation Library ），是一个代码生成的类库，可以在运行时动态的生成指定类的一个子类对象，并覆盖其中特定方法并添加增强代码，从而实现AOP 。 CGLIB 是通过继承的方式做的动态代理，因此如果某个类被标记为final ，那么它是无法使用 CGLIB 做动态代理的。（ 3 ）静态代理与动态代理区别在于生成 AOP 代理对象的时机不同，相对来说 AspectJ 的静态代理方式具有更好的性能，但是AspectJ 需要特定的编译器进行处理，而 Spring AOP 则无需特定的编译器处理。

Spring 的 IOC 理解

（ 1 ） IOC 就是控制反转，是指创建对象的控制权的转移，以前创建对象的主动权和时机是由自己把控的，而现在这种权力转移到Spring 容器中，并由容器根据配置文件去创建实例和管理各个实例之间的依赖关系，对象与对象之间松散耦合，也利于功能的复用。DI 依赖注入，和控制反转是同一个概念的不同角度的描述，即应用程序在运行时依赖IoC 容器来动态注入对象需要的外部资源。

（ 2 ）最直观的表达就是， IOC 让对象的创建不用去 new 了，可以由 spring 自动生产，使用 java 的反射机制，根据配置文件在运行时动态的去创建对象以及管理对象，并调用对象的方法的。

（ 3 ） Spring 的 IOC 有三种注入方式：构造器注入、 setter 方法注入、根据注解注入。

IoC 让相互协作的组件保持松散的耦合，而 AOP 编程允许你把遍布于应用各层的功能分离出来形成

可重用的功能组件。

解释一下 spring bean 的生命周期

首先说一下 Servlet 的生命周期：实例化，初始 init ，接收请求 service ，销毁 destroy ；

Spring 上下文中的 Bean 生命周期也类似，如下：

（ 1 ）实例化 Bean ：

对于 BeanFactory 容器，当客户向容器请求一个尚未初始化的 bean 时，或初始化 bean 的时候需要注入另一个尚未初始化的依赖时，容器就会调用createBean 进行实例化。对于 ApplicationContext 容器，当容器启动结束后，通过获取BeanDefifinition 对象中的信息，实例化所有的 bean 。

（ 2 ）设置对象属性（依赖注入）：

实例化后的对象被封装在 BeanWrapper 对象中，紧接着， Spring 根据 BeanDefifinition 中的信息以及通过BeanWrapper 提供的设置属性的接口完成依赖注入。

（ 3 ）处理 Aware 接口：

接着， Spring 会检测该对象是否实现了 xxxAware 接口，并将相关的 xxxAware 实例注入给 Bean ：

①如果这个 Bean 已经实现了 BeanNameAware 接口，会调用它实现的 setBeanName(String beanId) 方法，此处传递的就是Spring 配置文件中 Bean 的 id 值；

②如果这个 Bean 已经实现了 BeanFactoryAware 接口，会调用它实现的 setBeanFactory() 方法，传递的是Spring 工厂自身。

③如果这个 Bean 已经实现了 ApplicationContextAware 接口，会调用

setApplicationContext(ApplicationContext) 方法，传入 Spring 上下文；

（ 4 ） BeanPostProcessor ：

如果想对 Bean 进行一些自定义的处理，那么可以让 Bean 实现了 BeanPostProcessor 接口，那将会调用 postProcessBeforeInitialization(Object obj, String s)方法。

（ 5 ） InitializingBean 与 init-method ：

如果 Bean 在 Spring 配置文件中配置了 init-method 属性，则会自动调用其配置的初始化方法。

（ 6 ）如果这个 Bean 实现了 BeanPostProcessor 接口，将会调用 postProcessAfterInitialization(Objectobj, String s)方法；由于这个方法是在 Bean 初始化结束时调用的，所以可以被应用于内存或缓存技术；以上几个步骤完成后， Bean 就已经被正确创建了，之后就可以使用这个 Bean 了。

（ 7 ） DisposableBean ：

当 Bean 不再需要时，会经过清理阶段，如果 Bean 实现了 DisposableBean 这个接口，会调用其实现的destroy()方法；

（ 8 ） destroy-method ：

最后，如果这个 Bean 的 Spring 配置中配置了 destroy-method 属性，会自动调用其配置的销毁方法。

解释 Spring 支持的几种 bean 的作用域。

Spring 容器中的 bean 可以分为 5 个范围：

（ 1 ） singleton ：默认，每个容器中只有一个 bean 的实例，单例的模式由 BeanFactory 自身来维护。

（ 2 ） prototype ：为每一个 bean 请求提供一个实例。

（ 3 ） request ：为每一个网络请求创建一个实例，在请求完成以后， bean 会失效并被垃圾回收器回

收。

（ 4 ） session ：与 request 范围类似，确保每个 session 中有一个 bean 的实例，在 session 过期后， bean 会随之失效。

（ 5 ） global-session ：全局作用域， global-session 和 Portlet 应用相关。当你的应用部署在 Portlet 容器中工作时，它包含很多portlet 。如果你想要声明让所有的 portlet 共用全局的存储变量的话，那么这全局变量需要存储在global-session 中。全局作用域与 Servlet 中的 session 作用域效果相同。