面向字节_Spring_一目斋
Spring简介
Spring简介什么是Spring?spring是分层的avaSE以及javaEE应⽤于全栈的轻量级开源框架，以IOC（Inverse Of Control）控制反转,AOP(Aspect Oriented Programing)⾯向切⾯编程为核⼼，提供表现层SpringMVC以及持久层Spring,并且可整合多种其他开源框架。
spring的本质是管理对象，包括创建对象及维护对象之间的关系。
spring的优点1)⽅便解耦，简化开发通过spring的IOC可将对象的创建，以及对象之间的依赖都交由spring容器来进⾏管理，这样可以降低程序之间的耦合。
并且开发时也只需关注上层的应⽤，不⽤再多关注底层的应⽤。
2）AOP编程的⽀持spring⽀持AOP⾯向切⾯编程，许多OOP⾯向对象编程不能或很难实现的功能，都可通过AOP轻松实现。
3）声明式事务的⽀持可以将我们从单调烦闷的事务管理中解放出来，通过声明式事务的⽅式，可以灵活的进⾏事务管理，进⽽提⾼开发的质量和效率。
4）⽅便程序的测试可以⽤⾮容器依赖的编程⽅式进⾏⼏乎所有的测试⼯作，测试不再是昂贵的操作，⽽是随⼿可做的事情。
5）⽅便集成各种优秀的框架Spring可以降低各种框架的使⽤难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的直接⽀持。
6）降低javaEE的API的使⽤难度Spring对 JavaEE API（如 JDBC、JavaMail、远程调⽤等）进⾏了薄薄的封装层，使这些API 的使⽤难度⼤为降低。
7)spring框架的源码是经典学习的案例Spring的源代码设计精妙、结构清晰、匠⼼独⽤，处处体现着⼤师对Java设计模式灵活运⽤以及对 Java技术的⾼深造诣。
它的源代码⽆疑是Java技术的最佳实践的范例。
通过Spring进⾏解耦什么叫程序的耦合？在程序中，对象之间相互依赖，相互传递数据，这种相互关联的程度越⾼，程序的耦合度就越⾼。
Spring核心技术详解
Spring核⼼技术详解⼀、Sring简介Spring是⼀个分层的Java SE/EE应⽤⼀站式的轻量级开源框架。
Spring核⼼是IOC和AOP。
Spring主要优点包括：⽅便解耦，简化开发，通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进⾏控制，避免硬编码造成的程序耦合度⾼。
AOP编程的⽀持，通过Spring提供的AOP功能，⽅便进⾏⾯向切⾯编程。
声明式事务的⽀持，在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式⽅式灵活地进⾏事务的管理，提⾼开发效率和质量。
⽅便程序的测试，可以⽤⾮容器依赖的编程⽅式进⾏⼏乎所有的测试⼯作。
⽅便集成各种优秀框架，Spring提供了对各种优秀框架的直接⽀持。
⼆、Spring体系结构如下图所⽰，整个spring框架按其所属功能可以划分为五个主要模块，这五个模块⼏乎为企业应⽤提供了所需的⼀切，从持久层、业务层到表现层都拥有相应的⽀持，这就是为什么称Spring是⼀站式框架的原因。
核⼼模块(Core Container) Spring的核⼼模块实现了IoC的功能，它将类和类之间的依赖从代码中脱离出来，⽤配置的⽅式进⾏依赖关系描述。
由IoC容器负责类的创建，管理，获取等。
BeanFactory接⼝是Spring框架的核⼼接⼝，实现了容器很多核⼼的功能。
Context模块构建于核⼼模块之上，扩展了BeanFactory的功能，包括国际化，资源加载，邮件服务，任务调度等多项功能。
ApplicationContext是Context模块的核⼼接⼝。
表达式语⾔(Expression Language)是统⼀表达式语⾔(EL)的⼀个扩展，⽀持设置和获取对象属性，调⽤对象⽅法，操作数组、集合等。
使⽤它可以很⽅便的通过表达式和Spring IoC容器进⾏交互。
AOP模块Spring AOP模块提供了满⾜AOP Alliance规范的实现，还整合了AspectJ这种AOP语⾔级的框架。
spring知识点总结
spring知识点总结Spring是一个开发应用程序的Java企业应用程序框架，它以依赖注入（DI）和面向切面（AOP）为基础，可以帮助开发者开发出模块化、可重用、可扩展、可测试的应用程序。
Spring可以用来构建Web应用程序、基于REST的服务、批处理应用程序以及各种不同类型的企业级应用程序。
下面是关于Spring的一些重要知识点总结：1. 控制反转（Inversion of Control，简称IoC）：Spring的核心特性之一，通过IoC容器将对象的创建和依赖注入交给框架来管理，减少了代码的耦合度和管理对象的复杂性。
2. 依赖注入（Dependency Injection，简称DI）：是IoC的一种实现方式，通过注解或配置文件将对象的依赖关系注入到对象中，使得对象在创建时不需要自己构造依赖的对象。
3. AOP（Aspect-Oriented Programming）：面向切面编程，通过将横切关注点（如日志记录、安全性检查等）模块化，便于代码的维护和管理。
4. Spring MVC：用于构建Web应用程序的模块，提供了一种基于注解的方式来处理用户请求和生成响应，支持RESTful风格的开发。
5. 事务管理：Spring提供了对事务的支持，可以通过注解或配置文件的方式管理数据库事务，保证数据一致性和完整性。
6. 数据访问支持：Spring可以与各种数据访问技术（如JDBC、Hibernate、MyBatis等）无缝集成，简化了数据库操作的开发过程。
7. Spring Boot：Spring框架的一个子项目，用于简化Spring应用程序的配置和部署，提供了自动配置、嵌入式服务器等特性，使得开发者可以快速搭建一个可运行的Spring应用程序。
8. Spring Security：用于开发安全性强的应用程序，提供用户认证、授权、身份验证等功能。
9. Spring Cloud：基于Spring Boot开发的微服务框架，提供了服务发现、负载均衡、熔断器、配置管理等功能，帮助开发者构建分布式系统。
SpringAOP的原理和应用场景
SpringAOP的原理和应用场景SpringAOP（Aspect-Oriented Programming）是Spring框架中的一个重要组成部分，它提供了一种通过预定义的方式，将横切关注点（Cross-cutting Concerns）与业务逻辑进行解耦的机制。
本文将介绍SpringAOP的原理及其在实际应用场景中的应用。
一、SpringAOP的原理SpringAOP基于代理模式（Proxy Pattern）实现。
在SpringAOP中，通过生成与原始类（被代理类）具有相同接口的代理类，将横切逻辑编织到业务逻辑中。
在运行时，当调用代理类的方法时，会在方法执行前、后或异常抛出时插入相应的横切逻辑代码。
具体而言，SpringAOP使用了以下几个核心概念：1. 切面（Aspect）：切面是横切逻辑的模块化单元，它包含了一组通知（Advice）和切点（Pointcut）。
2. 通知（Advice）：通知定义了实际的横切逻辑代码，并规定了何时执行该代码。
SpringAOP提供了五种类型的通知：前置通知（Before）、后置通知（After）、返回通知（After-returning）、异常通知（After-throwing）和环绕通知（Around）。
3. 切点（Pointcut）：切点指定了在哪些连接点（Join Point）上执行通知。
连接点可以是方法调用、属性访问等程序执行的点。
4. 连接点（Join Point）：连接点是程序执行过程中的一个特定点，如方法调用前、方法调用后等。
通知通过切点来选择连接点。
5. 织入（Weaving）：织入是将切面应用到目标对象，并创建代理对象的过程。
织入可以在编译时、类加载时或运行时进行。
二、SpringAOP的应用场景SpringAOP可应用于各种场景，用于解决跨越多个模块或类的横切关注点问题。
以下是一些常见的SpringAOP应用场景：1. 日志记录：通过在关键方法的前后插入日志代码，实现对系统运行状态的监控和记录。
Spring技术内幕：深入解析Spring架构与设计原理
Spring技术内幕深入解析Spring架构与设计原理（一）引子缘起已经很久没有写帖子了，现在总算是有点时间写些东西，也算是对自己的一个记录吧。
刚刚完成了一个软件产品，从概念到运营都弄了一下，正在推广当中，虽然还没有能够达到盈亏平衡，但是这个过程，对自己也算是一种历练。
先不管结果如何，好呆走过这么一遭了。
我打算用这个帖子，把自己在这个过程中的一些心得，特别是对Spring新的理解，记录下来。
使用这个帖子的标题，持续下来。
简单来说，自己的软件产品是一个基于互联网的SaaS协同软件平台,操作简单，支持流程定义，管理和多种客户端 -像短信，MSN，智能手机什么的（我这里就不多做什么广告了），也有一个企业版的版本，使用的技术框架是Hibernate + Spring + Wicket，下面是Linux和MySQL，还有云计算的平台的使用，以支持其扩展性，虽然现在还没有可扩展性的需求，但似乎不难从SaaS上，就会想到云计算, 其实，它们真的是天生的一对！关于云计算，自己对这个技术很感兴趣，觉得和开源软件的结合，是很有意思的，因为它们都有基于服务的基因，在云计算平台的使用上，也有一些初步的实践。
云计算是一个很有意思的话题，但在这里主要是想谈Spring，所以对云计算，这里就先不多说了，但非常欢迎有兴趣的朋友和一起另外找地方讨论！回到正题，在我自己的产品中，其中除了Wicket和云计算外，其他都是大家非常熟知的了，像Hibernate, Spring, MySQL什么的。
在这个过程中，发现自己对一些技术点也有了新的认识，最有体会的是Spring。
当然，在这个过程中，更大的收获是对产品开发整个过程的认识，在这点上，真是一言难尽........回到自己还算了解的Spring, 这次我使用的是3.0的代码，所以，有机会也把这些代码读了几遍，比原来的理解要加深了许多，也发现了不少和2.0代码不同的地方，以及自己一些对 Spring的新的理解，这些，就让我就用这个帖子系列，给自己总结一下，也算是对自己以前的那个代码分析的帖子做一个新的交代吧。
spring原理和实现机制
spring原理和实现机制Spring框架是一个开源的应用程序框架，它提供了一种简单的方法来构建基于Java的企业级应用程序。
Spring框架的原理和实现机制主要包括：1. 控制反转（IoC）：Spring使用控制反转（Inversion of Control，IoC）来管理应用程序中的对象。
传统的应用程序中，对象的创建和依赖关系管理是由程序员来实现的，而在Spring 中，对象的创建和管理工作由容器来完成。
容器会在应用程序启动时创建对象，并通过依赖注入的方式将对象之间的依赖关系注入到相应的对象中。
2. 依赖注入（DI）：依赖注入是Spring框架的核心机制之一。
它指的是容器在创建对象时，自动将其所依赖的其他对象注入进来。
通过依赖注入，对象之间的解耦程度大大提高，使得应用程序更加灵活、可扩展和可维护。
3. 面向切面编程（AOP）：Spring框架通过面向切面编程（Aspect-Oriented Programming，AOP）来实现横切关注点的模块化。
AOP可以将应用程序的核心逻辑（称为核心关注点）与横切关注点（如日志、事务管理等）分离开来，并通过切面来统一管理这些横切关注点。
4. 核心容器：Spring框架的核心是其容器（Container）。
容器使用BeanFactory接口作为底层容器的基础，并提供了ApplicationContext接口作为更高级的容器接口。
容器负责创建和管理应用程序中的对象，并提供了丰富的配置和管理功能。
5. 层次化的模块化架构：Spring的模块化架构使得开发者可以根据自己的需要选择使用不同的模块。
例如，Spring的核心模块包括IoC容器、AOP框架和BeanFactory等，而其他模块如Spring MVC、Spring Data等则提供了特定领域的解决方案。
6. 轻量级与非侵入性：Spring框架的设计理念是轻量级和非侵入性的。
它不依赖于特定的编程模型，可以与其他技术和框架无缝集成。
简述springmvc工作原理
简述springmvc工作原理Spring MVC 是一个基于 Java 的轻量级的 web 框架，用来开发灵活、可扩展的 web 应用程序。
Spring MVC 的工作原理如下：1. 客户发出 HTTP 请求到前端控制器 DispatcherServlet。
2. DispatcherServlet 是应用的前端控制器，根据请求 URL 找到对应的处理器 Handler。
3. HandlerMapping 根据请求 URL 找到对应的处理器适配器HandlerAdapter，HandlerAdapter 是一个策略接口，负责执行具体的 Handler 。
4. HandlerAdapter 将处理器 Handler 封装成一个适配器，使其具备执行 Handler 的能力。
5. Handler 调用业务逻辑进行处理，并返回一个ModelAndView 对象。
6. ModelAndView 是 Spring MVC 的模型和视图对象，它包含处理结果数据和视图名称。
7. Handler 将处理结果数据存入 ModelAndView 中，并将视图名称返回给 HandlerAdapter。
8. HandlerAdapter 将 ModelAndView 传递给前端控制器DispatcherServlet。
9. DispatcherServlet 调用视图解析器 ViewResolver 解析视图名称，得到具体的视图对象 View。
10. View 是一个接口，负责渲染 ModelAndView 对象，将处理结果生成 HTML 返回给客户端。
11. 客户端浏览器接收到 HTML 文档，并将其呈现给用户。
以上是 Spring MVC 的工作流程，它的核心原理是通过前端控制器 DispatcherServlet 来实现请求的分发和处理，以及视图的解析和渲染。
通过 HandlerMapping、HandlerAdapter、视图解析器 ViewResolver 的配合，可以实现灵活的请求处理和视图展示，同时也能够很好地与 Spring 的依赖注入和面向切面编程等特性进行整合。
springmvc课程设计
springmvc课程设计一、教学目标本课程旨在通过Spring MVC的学习，让学生掌握基于Java的企业级Web应用开发技术，理解Spring MVC的工作原理和框架结构，培养学生运用Spring MVC解决实际问题的能力。
1.理解Spring MVC的框架结构和工作原理。
2.掌握Spring MVC的配置和使用方法。
3.熟悉Spring MVC中的主要组件，如Controller、View、Model等。
4.能够使用Spring MVC框架进行简单的Web应用开发。
5.能够根据需求设计合适的Spring MVC架构，解决实际问题。
情感态度价值观目标：1.培养学生的团队合作意识和问题解决能力。
2.培养学生对Java技术和Spring MVC框架的兴趣和热情。
二、教学内容本课程的教学内容主要包括Spring MVC的框架结构、工作原理、配置和使用方法等方面的知识。
1.Spring MVC框架结构：介绍Spring MVC的主要组件，如Controller、View、Model等，以及它们之间的关系。
2.Spring MVC工作原理：讲解Spring MVC的请求处理流程，包括请求的接收、参数的绑定、视图的渲染等。
3.Spring MVC配置和使用：讲解如何在项目中配置Spring MVC，以及如何使用Spring MVC进行Web应用开发。
4.Spring MVC高级特性：介绍Spring MVC的一些高级特性，如数据验证、异常处理、文件上传等。
三、教学方法为了提高学生的学习兴趣和主动性，本课程将采用多种教学方法，如讲授法、讨论法、案例分析法、实验法等。
1.讲授法：用于讲解Spring MVC的基本概念和原理。
2.讨论法：鼓励学生参与课堂讨论，加深对Spring MVC的理解。
3.案例分析法：通过分析实际案例，让学生掌握Spring MVC的应用技巧。
4.实验法：安排实验课，让学生亲自动手实践，巩固所学知识。
javaspring课程设计
javaspring课程设计一、课程目标知识目标：1. 学生能掌握Spring框架的基本原理，理解依赖注入、面向切面编程等核心概念；2. 学生能运用Spring框架构建Java应用程序，实现数据持久化、事务管理等功能；3. 学生了解Spring MVC架构，能独立设计并实现基于Spring MVC的Web 应用程序。
技能目标：1. 学生能熟练使用Spring框架进行项目开发，提高编码效率；2. 学生具备分析项目需求，运用Spring框架进行系统设计的能力；3. 学生能运用Spring MVC搭建Web应用，实现前后端分离，提高项目可维护性。
情感态度价值观目标：1. 学生通过学习Spring框架，培养对新技术的好奇心和探索精神；2. 学生在项目实践中，养成团队协作、沟通表达的良好习惯；3. 学生认识到编程规范和代码质量的重要性，树立良好的编程习惯。
课程性质：本课程为实践性课程，强调理论联系实际，培养学生动手能力。
学生特点：学生具备一定的Java基础，对框架有一定了解，但实际操作能力较弱。
教学要求：结合学生特点，课程设计应注重实践，以项目驱动教学，让学生在实际操作中掌握Spring框架的应用。
同时，注重培养学生的团队协作能力和编程规范。
通过本课程的学习，使学生具备独立开发基于Spring框架的应用程序的能力。
二、教学内容1. Spring框架基础原理- 依赖注入原理及实现方式- 面向切面编程（AOP）概念及应用- Spring核心容器及常用API2. Spring框架数据访问- Spring JDBC Template的使用- Spring事务管理- 整合MyBatis实现数据持久化3. Spring MVC架构- Spring MVC工作原理- 控制器（Controller）的使用- 视图解析器（View Resolver）与视图（View）配置4. 基于Spring MVC的Web应用开发- RESTful API设计与实现- 前后端分离开发模式- 跨域问题解决方案5. Spring框架进阶应用- Spring Boot快速开发- Spring Security安全框架- Spring Cloud微服务架构教学大纲安排：第1周：Spring框架基础原理学习第2周：依赖注入及AOP编程实践第3周：Spring数据访问与事务管理第4周：Spring MVC架构学习与实践第5周：基于Spring MVC的Web应用开发第6周：Spring框架进阶应用学习教学内容与教材章节关联：1. 《Java Spring实战》第1-3章：Spring框架基础原理2. 《Java Spring实战》第4-6章：Spring数据访问与事务管理3. 《Java Spring实战》第7-9章：Spring MVC架构4. 《Java Spring实战》第10-11章：基于Spring MVC的Web应用开发5. 《Java Spring实战》第12章：Spring框架进阶应用三、教学方法本课程采用以下教学方法，旨在激发学生的学习兴趣，提高实践操作能力，培养创新精神和团队协作能力。
Spring从入门到精通(共58张PPT)
REQUIRES_NEW3，、新建写事@务，开如果头当前存注在解事务，@把R当e前s事o务u挂r起c。e注入接口
Spring与Hibernate的集成
Struts+Hibernate+Spring的集成
public void init(){System.
@After 最终通知：不论一个方法是如何结束的，最终通知都运行
势。Spring 2.5 的一大增强就是引入了很多注释类，现在我们已经可以使用注解配置完
成大部分 XML 配置的功能。
基于注解的依赖注入
spring注解的使用
<prop key=“supp1ort、”> 要使用注解来代替xml的配置，要引入如下jar包：
public interface </property>
<property name=“lists”>
<list> <value></value> <ref/>
</list> </property>
<property name=“sets”> <set> <value></value> <ref/>
</set>
</property>
<property name=“maps”> <map>
注入依赖对象
在<property>或<constructor-arg>元素中使用<ref>
在<property>或<constructor-arg>元素中加上ref属性
spring内核详解
Spring作为现在最优秀的框架之一，已被广泛的使用，51CTO也曾经针对Spring框架中的JDBC应用做过报道。
本文将从另外一个视角试图剖析出Spring框架的作者设计Spring框架的骨骼架构的设计理念，有那几个核心组件？为什么需要这些组件？它们又是如何结合在一起构成Spring的骨骼架构？Spring的AOP特性又是如何利用这些基础的骨骼架构来工作的？Spring中又使用了那些设计模式来完成它的这种设计的？它的这种设计理念对对我们以后的软件设计有何启示？本文将详细解答这些问题。
Spring的骨骼架构Spring总共有十几个组件，但是真正核心的组件只有几个，下面是Spring框架的总体架构图：图1.Spring框架的总体架构图从上图中可以看出Spring框架中的核心组件只有三个：Core、Context和Beans。
它们构建起了整个Spring 的骨骼架构。
没有它们就不可能有AOP、Web等上层的特性功能。
下面也将主要从这三个组件入手分析Spring。
Spring的设计理念前面介绍了Spring的三个核心组件，如果再在它们三个中选出核心的话，那就非Beans组件莫属了，为何这样说，其实Spring就是面向Bean的编程（BOP,Bean Oriented Programming），Bean在Spring 中才是真正的主角。
Bean在Spring中作用就像Object对OOP的意义一样，没有对象的概念就像没有面向对象编程，Spring中没有Bean也就没有Spring存在的意义。
就像一次演出舞台都准备好了但是却没有演员一样。
为什么要Bean这种角色Bean或者为何在Spring如此重要，这由Spring框架的设计目标决定，Spring为何如此流行，我们用Spring 的原因是什么，想想你会发现原来Spring解决了一个非常关键的问题他可以让你把对象之间的依赖关系转而用配置文件来管理，也就是他的依赖注入机制。
spring框架概述
spring框架概述1 spring框架概述1.1 什么是springSpring是⼀个开源框架，Spring是于2003 年兴起的⼀个轻量级的Java 开发框架，由Rod Johnson开发。
它是为了解决企业应⽤开发的复杂性⽽创建的。
框架的主要优势之⼀就是其分层架构，分层架构允许使⽤者选择使⽤哪⼀个组件，同时为J2EE 应⽤程序开发提供集成的框架dao(JdbcTemplate) service(spring控制事务) web(springmvc)Spring的核⼼是控制反转（IoC）和⾯向切⾯（AOP）。
简单来说，Spring是⼀个分层的JavaSE/EE full-stack 轻量级开源框架。
1）IoC 和DI 2）AOP⼀句话描述spring：full-stack 轻量级开源框架分层： full-stack，每⼀个层都提供解决⽅案web层：struts，spring-MVCservice层：spring 事务控制 springdao层：hibernate，mybatis ， jdbcTemplate（spring提供了⼀个模板对象） --> spring-datassh:struts2+spring+hibernate（以前的了解⼀下）ssm:spring+springmvc+mybatis（现阶段常⽤）1.2 spring核⼼Spring的核⼼是控制反转（IoC）和⾯向切⾯（AOP）1.3 spring优点1.4 spring体系结构核⼼容器：beans、core、context、expressiondao service 对象的创建交给spring2 ⼊门案例：IoC【掌握】2.1 导⼊jar包4 + 1 ： 4个核⼼（beans、core、context、expression） + 1个依赖（commons-loggins...jar）2.2 ⽬标类1. 提供UserService接⼝和实现类2. 获得UserService实现类的实例之前开发中，直接new⼀个对象即可。
Spring框架核心原理解析
Spring框架核心原理解析Spring框架作为一个被广泛应用的开源框架，具备强大的功能和灵活性，为Java应用程序开发提供了便捷的解决方案。
它的成功之处在于其核心原理的设计和实现。
本文将对Spring框架的核心原理进行解析，以帮助读者更好地理解该框架的内部机制。
一、依赖注入(Dependency Injection)依赖注入是Spring框架的核心概念之一。
它的基本原理是通过将对象之间的依赖关系交由框架来管理，从而降低了类之间的耦合性。
在Spring框架中，通过配置文件或注解的方式描述对象之间的依赖关系，框架根据这些描述将所需的对象注入到相应的位置。
二、控制反转(Inversion of Control)控制反转是依赖注入的基础概念，也被称为IoC。
它的核心思想是将对象的创建和管理交给框架来完成，而不是由对象自身负责。
在Spring框架中，通过IoC容器来实现控制反转，容器负责创建、初始化和管理应用程序中的对象，开发者只需要关注对象的使用即可。
三、面向切面编程(Aspect-Oriented Programming)面向切面编程是Spring框架的另一个核心原理。
它的目的是实现横切关注点的模块化，提供更好的代码复用和解耦。
在Spring框架中，通过AOP技术可以将一系列与业务逻辑无关的功能和代码片段，比如事务管理、日志记录等，抽离出来，以切面的方式织入到应用程序中。
四、模块化设计(Modular Design)Spring框架采用模块化的设计思想，将各种功能和组件划分为不同的模块，以便更好地管理和维护。
每个模块都有清晰的职责和功能，可以根据实际需求进行选择和组合。
常用的Spring模块包括核心容器模块、数据访问模块、Web开发模块等，开发者可以灵活地按需引入。
五、灵活的扩展性和可插拔性Spring框架具备良好的扩展性和可插拔性，可以根据具体需求进行灵活的配置和定制。
开发者可以使用自定义的扩展点和接口来实现个性化的功能需求，比如自定义的数据访问层、认证授权模块等。
Spring总结
Spring总结Spring总结1、spring两⼤核⼼接⼝的区别2.spring读取配置⽂件1.BeanFactoryi从src下查找配置⽂件：Resource res = new ClassPathResource("applicationContext.xml")ii.从⽂件系统中读取配置⽂件：Resource res = new FileSystemResource("applicationContext.xml")iii.web环境中读取配置⽂件Resource res = new ServletContextResource("applicationContext.xml")2.ApplicationContextApplicationContext context = null;i从src下查找配置⽂件：context = new ClassPathXmlApplicationContext ("applicationContext.xml") ii.从⽂件系统中读取配置⽂件：context = new FileSystemXmlApplicationContext ("applicationContext.xml") iii.web环境中读取配置⽂件context = new XmlWebApplicationContext ("applicationContext.xml")3.Spring :组合对象和对象之间的关系，也可以组合框架和框架之间的关系4.Spring是轻量级的ioc和aop的容器框架1)轻量级：使⽤时程序所占⽤的资源很少，⾮侵⼊性（松耦合）2)IoC(Inversion Of Control):控制反转,对象和如何得到它的协作对象的责任反转3)AOP：⾯向切⾯的编程4)容器：控制容器内对象的⽣命周期5)框架：⼀些对象通过构建提供共通性的功能，可以简化程序的开发5.Spring第⼀个项⽬1)创建java项⽬，引⼊核⼼jar包(Spring.jar)2）引⼊配置⽂件(打印⽇志log4j:log4j.properties)Spring : applicationContext.xml3)增加测试类4）BeanFactory 是核⼼接⼝，可以获取配置⽂件中声明的对象，组合对象之间的关系，可以维护对象的⽣命周期5)spring创建对象默认是单例创建的6)使⽤ApplicationContext 代替BeanFactory （推荐使⽤），可以从框架级别上提供更多的⽀持6.不通过编码⽅式设置属性1.可以在property标签中声明属性2.DI(DenpendencyInjection)依赖注⼊的三种⽅式1)接⼝注⼊(不推荐使⽤)2)set⽅法(属性)注⼊（要先有对象）3)构造⽅法注⼊3.细讲set⽅法的属性注⼊1.属性注⼊必须有set⽅法2.⼀个对象中有另⼀个对象的引⽤的情况，在配置时采⽤ref来参照另⼀个对象，ref要和另⼀个对象的id相同3.属性是数组，list集合的场合：在属性⾥⾯使⽤list标签，如果是list集合（使⽤泛型），获得的是ArrayList类型，如果集合不使⽤泛型，可以放任何类型的数据;4.属性是map集合，使⽤map标签，获得的是LinkedHashMap类型的5.属性是set集合，使⽤set标签，获得的是LinkHashSet类型的hashSet重复不放，hashMap重复覆盖6.属性是Property集合,使⽤prop标签4.继承属性注⼊将⽗类的属性注⼊关系体现在⼦类中5.构造⽅法的注⼊1.在构造⽅法类型相同的情况下，标签的声明顺序和构造⽅法的参数顺序是完全相同的，如果不顺序不同，可增加index来区分2.在构造⽅法类型不同的情况下，多个构造⽅法不明确调⽤哪个时，可以增加参数的类型，参数的顺序没要求7.Spring属性编辑器(将字符串转换为⽇期类型)1.创建编辑器类，继承PropertyEditorSupport,重写setAsText ⽅法，注⼊属性时，⾃动调⽤，在⽅法中，最后⼀定要调⽤setV alue()放到对象的属性中2.属性编辑管理器(CustomEditorConfigurer)⾃动识别⾃定义的编辑器8.Spring的⾃动装配功能Autowire⾃动装配功能对java的简单类型不⽀持简单类型包括：基本类型，字符串类型，⽇期类型1.byName:如果⾃动装配采⽤ByName，那么使⽤时，会根据对象的属性名称在Spring环境中查找相同ID的Bean对象，如果查找到，那么直接赋值给响应的属性，如果找不到，不做任何处理byName不需要考虑特殊的情况2.byType:如果⾃动装配采⽤ByType，那么使⽤时，会根据对象的属性的类型在Spring环境中查找相同类型的Bean对象，如果查找到，那么直接赋值给响应的属性，如果找不到，不做任何处理使⽤时，需要注意，如果属性为引⽤类型时，Spring环境中如果存在多个类型相同的Bean对象，那么会发⽣错误如果属性为数组和集合时，Spring环境中如果存在多个类型相同的Bean对象，那么不会发⽣错误3.可以使⽤全局⾃动装配标签中使⽤Default-autowire="byName",只对当前⽂件有效9.Spring 的⽣命周期1.applicationContext在读取配置⽂件的时候就默认创建了对象，想在使⽤的时候再创建对象，⽤延迟加载(lazy-init = “true”),会出现这样的问题：使⽤了⾃动装配功能，那么延迟加载不起作⽤2如果创建对象后希望执⾏初始化⽅法，那么在延迟加载后声明init-method=”init”,初始化⽅法要求：⽅法⾥不能传参数，在设置属性之后执⾏，可以抛出异常3.调⽤销毁⽅法⽤destroy-method=””，很少⽤到4.对象默认是单例创建的，scope=”prototype”(原型创建)，声明这个属性之后，创建对象就是多例了，属性为scope=”singleton”,创建对象是单例的如果使⽤多例创建对象，设置延迟加载不起作⽤，肯定是在使⽤时创建5.依赖创建（depend-on）如果⼀个对象创建时，必须保证另外⼀个对象已经创建，那么使⽤依赖创建的⽅式10.Spring在web环境中的使⽤1.步骤：1.创建web环境2.增加jar包（Spring.jar）3.引⼊配置⽂件，放在src下4.修改Web.xml⽂件，增加对Spring的⽀持（增加监听器）2.在程序中就可以直接访问Spring对象了问题：如果修改了配置⽂件，必须重新启动服务器，否则不起作⽤，struts2有⾃动加载功能，注意区分3.Spring(将service对象组合到action对象中)+struts21.使⽤第⼀种⽅式，action由struts2创建，service由Spring创建2.引⼊相应的struts2配置3.引⼊额外的java包，Spring的插件：struts2-spring-plugin-2.1.8.1.jar使⽤插件jar包，不需要做其他⼯作，就可以将Action对象进⾏组合，因为底层，这个插件改变了获取Action对象及属性的创建⽅式。
Spring框架基础与实战练习题参考答案
Spring框架基础与实战练习题参考答案Spring框架作为一个轻量级的开发框架，具有强大的功能和灵活性，已广泛应用于企业级应用程序的开发中。
下面是一些关于Spring框架的基础与实战练习题的参考答案，希望能帮助你更好地理解和掌握Spring框架。
1. 什么是Spring框架？Spring框架是一个开源的Java平台，用于开发企业级应用程序。
它提供了一系列的功能模块和API，用于处理应用程序的不同方面，如依赖注入、AOP（面向切面编程）、事务管理等。
Spring框架使得应用程序的开发更加简单、高效和可测试。
2. Spring框架的核心功能有哪些？Spring框架的核心功能包括：- 依赖注入（Dependency Injection）：通过配置文件或注解方式将依赖关系注入到对象中，解耦了各个组件之间的依赖。
- AOP（Aspect-Oriented Programming）：通过切面的方式将横切逻辑（如日志、事务管理等）与核心业务逻辑分离开来，提高代码的可维护性和可重用性。
- 面向接口编程：通过接口来定义服务和业务逻辑，提高代码的灵活性和可扩展性。
- 数据访问：提供了对数据库访问的支持，如JDBC、ORM（对象关系映射）等。
- Web开发：提供了对各种Web开发框架的支持，如Spring MVC、Spring Boot等。
3. 请解释一下Spring框架中的依赖注入（DI）是什么意思？依赖注入是Spring框架的核心特性之一。
它指的是将对象之间的依赖关系由框架来处理，而不是由开发人员手动管理。
通过依赖注入，我们可以将对象之间的依赖关系配置到外部的配置文件或通过注解的方式，使得代码更加简洁和可维护。
4. 举例说明Spring框架中的依赖注入（DI）是如何实现的。
例如，我们有一个UserService接口和一个UserDao接口，UserService接口依赖于UserDao接口。
在Spring框架中，我们可以通过以下方式进行依赖注入：首先，在配置文件中定义Bean：```xml<bean id="userDao" class="erDaoImpl" /><bean id="userService" class="erServiceImpl"><property name="userDao" ref="userDao" /></bean>```然后，在UserService的实现类中注入UserDao：```javapublic class UserServiceImpl implements UserService {private UserDao userDao;public void setUserDao(UserDao userDao) {erDao = userDao;}//...}```这样，我们就将UserService依赖的UserDao通过配置文件进行了注入。
spring 原理
spring 原理1、spring原理内部最核心的就是IOC了，动态注入，让一个对象的创建不用new了，可以自动的生产，这其实就是利用java里的反射，反射其实就是在运行时动态的去创建、调用对象，Spring就是在运行时，跟xml Spring的配置文件来动态的创建对象，和调用对象里的方法的。
Spring还有一个核心就是AOP这个就是面向切面编程，可以为某一类对象进行监督和控制（也就是在调用这类对象的具体方法的前后去调用你指定的模块）从而达到对一个模块扩充的功能。
这些都是通过配置类达到的。
Spring目的：就是让对象与对象（模块与模块）之间的关系没有通过代码来关联，都是通过配置类说明管理的（Spring根据这些配置内部通过反射去动态的组装对象）Spring里用的最经典的一个设计模式就是：模板方法模式。
(这里我都不介绍了，是一个很常用的设计模式)， Spring里的配置是很多的，很难都记住，但是Spring里的精华也无非就是以上的两点，把以上两点跟理解了也就基本上掌握了Spring.Spring AOP与IOC1、IoC：概念：控制权由对象本身转向容器；由容器根据配置文件去创建实例并创建各个实例之间的依赖关系核心：bean工厂；在Spring中，bean工厂创建的各个实例称作bean二、AOP(Aspect-Oriented Programming): 面向方面编程1、代理的两种方式：静态代理：针对每个具体类分别编写代理类；针对一个接口编写一个代理类；动态代理：针对一个方面编写一个InvocationHandler，然后借用JDK反射包中的Proxy类为各种接口动态生成相应的代理类2、动态代理:不用写代理类，虚拟机根据真实对象实现的接口产生一个类，通过类实例化一个动态代理，在实例化动态代理时将真实对象及装备注入到动态代理中，向客户端公开的是动态代理，当客户端调用动态代理方法时，动态代理根据类的反射得到真实对象的Method,调用装备的invoke方法，将动态代理、Method、方法参数传与装备的invoke方法，invoke方法在唤起method方法前或后做一些处理。
Spring的常见问题及答案
Spring的常见问题及答案⽬录Spring 概述依赖注⼊Spring beansSpring注解Spring数据访问Spring⾯向切⾯编程（AOP）Spring MVCSpring 概述1. 什么是spring?Spring 是个java企业级应⽤的开源开发框架。
Spring主要⽤来开发Java应⽤，但是有些扩展是针对构建J2EE平台的web应⽤。
Spring 框架⽬标是简化Java企业级应⽤开发，并通过POJO为基础的编程模型促进良好的编程习惯。
2. 使⽤Spring框架的好处是什么？轻量：Spring 是轻量的，基本的版本⼤约2MB。
控制反转：Spring通过控制反转实现了松散耦合，对象们给出它们的依赖，⽽不是创建或查找依赖的对象们。
⾯向切⾯的编程(AOP)：Spring⽀持⾯向切⾯的编程，并且把应⽤业务逻辑和系统服务分开。
容器：Spring 包含并管理应⽤中对象的⽣命周期和配置。
MVC框架：Spring的WEB框架是个精⼼设计的框架，是Web框架的⼀个很好的替代品。
事务管理：Spring 提供⼀个持续的事务管理接⼝，可以扩展到上⾄本地事务下⾄全局事务（JTA）。
异常处理：Spring 提供⽅便的API把具体技术相关的异常（⽐如由JDBC，Hibernate or JDO抛出的）转化为⼀致的unchecked 异常。
3. Spring由哪些模块组成 ?以下是Spring 框架的基本模块：Core moduleBean moduleContext moduleExpression Language moduleJDBC moduleORM moduleOXM moduleJava Messaging Service(JMS) moduleTransaction moduleWeb moduleWeb-Servlet moduleWeb-Struts moduleWeb-Portlet module4. 核⼼容器（应⽤上下⽂) 模块。
Spring
Spring是一个轻量级的DI（IoC）和AOP容器框架。
存在的目的是用于构建轻量级的J2EE应用。
1.轻量级：应用大小和应用开支，包括应用方式2.DI（IoC)：提供松耦合的一种实现技术3.AOP：切面编程将业务逻辑从应用服务中分离4.容器：包含并管理应用对象的生命周期和配置5.框架：使用组件配置组合成复杂的应用，并提供很多基础功能项目中引入spring立即可以带来下面的好处1.降低组件之间的耦合度,实现软件各层之间的解耦。
2.可以使用容器提供的众多服务，如：事务管理服务、消息服务等等。
当我们使用容器管理事务时，开发人员就不再需要手工控制事务.也不需处理复杂的事务传播。
3.容器提供单例模式支持，开发人员不再需要自己编写实现代码。
4.容器提供了AOP技术，利用它很容易实现如权限拦截、运行期监控等功能。
5.容器提供的众多辅作类，使用这些类能够加快应用的开发，如：JdbcT emplate、HibernateT emplate。
6.Spring对于主流的应用框架提供了集成支持，如：集成Hibernate、JPA、Struts等，这样更便于应用的开发。
第一个Spring应用(1):搭建环境,在spring最基础的应用中只需要dest\spring.jar和lib\jakarta-commons\commons-logging.jar新建spring的配置文件,文件名称可以任意,位置也可以任意,但考虑到通用性,一般将配置文件存放在类路径下,配置文件的模板可以在spring 参考手册中获取(查找中输入<bean>),模板大致如下：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd"></beans>(2):实例化spring容器,通过在类路径下寻找配置文件(配置文件可以有多个,以字符数组的形式传入)/* 当存在多个配置文件时,可以将spring配置文件名,字符串数组的形式传入 */ ApplicationContext ac = new ClassPathXmlApplicationContext("Spring-config.xml");(3):将实体bean的创建与维护交由spring管理在配置文件中的<beans>下使用<bean>标签<!—指定实体bean的名称,当名称含有特殊字符时,需要用name指定,一般情况下使用id,id 在配置文件中唯一,而name可以重复指定,获取时,获取到最后一个,在name中可以使用逗号将多个名称隔开,来达到指定bean的多个名称,当id和那么都没有指定时,则以类的全名作为name,如果存在多个name和id没有指定且实例类都是一样的bean,可以使用clazzpath/#来获取,#代表在xml中存在的序号--><!—calss指定需要被管理的实体bean,需要是完整的类名--><bean id="personService"class="com.mrkay.spring.services.impl.PersonServiceImpl"/> (4):调用实体bean使用实例化的spring容器的getBean(beanNa me)获取实体bean实例化bean的三种方式（1）：使用默认的构造函数进行实例化bean<bean id=”xxx” class=”xxx.xxx.Xxx”/>（2）：使用静态工厂方法创建bean<bean id=”xxx” class=”xxx.xxx.Xxx” factory-method=”xxxx”/>（3）：使用实例化工厂方法创建bean1,先实例化工厂<bean id=”factory” class=”xxx.xxx.Xxx”/>2,然后实例化bean <bean id=”xxx” class=”xxx.xxx.Xxx” factory-method=”xxxx”/>默认情况下会在容器启动时初始化bean，但我们可以指定Bean节点的lazy-init=“true”来延迟初始化bean，这时候，只有第一次获取bean会才初始化bean。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
<Spring面试71题与答案>1.什么是spring?Spring是个java企业级应用的开源开发框架。
Spring主要用来开发Java应用，但是有些扩展是针对构建J2EE平台的web应用。
Spring框架目标是简化Java 企业级应用开发，并通过POJO为基础的编程模型促进良好的编程习惯。
2.使用Spring框架的好处是什么？∙轻量：Spring是轻量的，基本的版本大约2MB。
∙控制反转：Spring通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或查找依赖的对象们。
∙面向切面的编程(AOP)：Spring支持面向切面的编程，并且把应用业务逻辑和系统服务分开。
∙容器：Spring包含并管理应用中对象的生命周期和配置。
∙MVC框架：Spring的WEB框架是个精心设计的框架，是Web框架的一个很好的替代品。
∙事务管理：Spring提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务（JTA）。
∙异常处理：Spring提供方便的API把具体技术相关的异常（比如由JDBC，HibernateorJDO抛出的）转化为一致的unchecked异常。
3.Spring由哪些模块组成?以下是Spring框架的基本模块：∙Coremodule∙Beanmodule∙Contextmodule∙ExpressionLanguagemodule∙JDBCmodule∙ORMmodule∙OXMmodule∙JavaMessagingService(JMS)module∙Transactionmodule∙Webmodule∙Web-Servletmodule∙Web-Strutsmodule∙Web-Portletmodule4.核心容器（应用上下文)模块。
这是基本的Spring模块，提供spring框架的基础功能，BeanFactory是任何以spring为基础的应用的核心。
Spring框架建立在此模块之上，它使Spring 成为一个容器。
5.BeanFactory–BeanFactory实现举例。
Bean工厂是工厂模式的一个实现，提供了控制反转功能，用来把应用的配置和依赖从正真的应用代码中分离。
最常用的BeanFactory实现是XmlBeanFactory类。
6.XMLBeanFactory最常用的就是org.springframework.beans.factory.xml.XmlBeanFactory，它根据XML文件中的定义加载beans。
该容器从XML文件读取配置元数据并用它去创建一个完全配置的系统或应用。
7.解释AOP模块AOP模块用于发给我们的Spring应用做面向切面的开发，很多支持由AOP联盟提供，这样就确保了Spring和其他AOP框架的共通性。
这个模块将元数据编程引入Spring。
8.解释JDBC抽象和DAO模块。
通过使用JDBC抽象和DAO模块，保证数据库代码的简洁，并能避免数据库资源错误关闭导致的问题，它在各种不同的数据库的错误信息之上，提供了一个统一的异常访问层。
它还利用Spring的AOP模块给Spring应用中的对象提供事务管理服务。
9.解释对象/关系映射集成模块。
Spring通过提供ORM模块，支持我们在直接JDBC之上使用一个对象/关系映射映射(ORM)工具，Spring支持集成主流的ORM框架，如Hiberate,JDO和iBATISSQLMaps。
Spring的事务管理同样支持以上所有ORM框架及JDBC。
10.解释WEB模块。
Spring的WEB模块是构建在applicationcontext模块基础之上，提供一个适合web应用的上下文。
这个模块也包括支持多种面向web的任务，如透明地处理多个文件上传请求和程序级请求参数的绑定到你的业务对象。
它也有对JakartaStruts的支持。
11.为什么说Spring是一个容器？因为用来形容它用来存储单例的bean对象这个特性。
12.Spring配置文件Spring配置文件是个XML文件，这个文件包含了类信息，描述了如何配置它们，以及如何相互调用。
13.什么是SpringIOC容器？SpringIOC负责创建对象，管理对象（通过依赖注入（DI），装配对象，配置对象，并且管理这些对象的整个生命周期。
14.IOC的优点是什么？IOC或依赖注入把应用的代码量降到最低。
它使应用容易测试，单元测试不再需要单例和JNDI查找机制。
最小的代价和最小的侵入性使松散耦合得以实现。
IOC 容器支持加载服务时的饿汉式初始化和懒加载。
15.ApplicationContext通常的实现是什么?∙FileSystemXmlApplicationContext：此容器从一个XML文件中加载beans的定义，XMLBean配置文件的全路径名必须提供给它的构造函数。
∙ClassPathXmlApplicationContext：此容器也从一个XML文件中加载beans的定义，这里，你需要正确设置classpath因为这个容器将在classpath里找bean配置。
∙WebXmlApplicationContext：此容器加载一个XML文件，此文件定义了一个WEB应用的所有bean。
16.Bean工厂和Applicationcontexts有什么区别？Applicationcontexts提供一种方法处理文本消息，一个通常的做法是加载文件资源（比如镜像），它们可以向注册为监听器的bean发布事件。
另外，在容器或容器内的对象上执行的那些不得不由bean工厂以程序化方式处理的操作，可以在Applicationcontexts中以声明的方式处理。
Applicationcontexts实现了MessageSource接口，该接口的实现以可插拔的方式提供获取本地化消息的方法。
17.一个Spring的应用看起来象什么？∙一个定义了一些功能的接口。
∙这实现包括属性，它的Setter，getter方法和函数等。
∙SpringAOP。
∙Spring的XML配置文件。
∙使用以上功能的客户端程序。
依赖注入18.什么是Spring的依赖注入？依赖注入，是IOC的一个方面，是个通常的概念，它有多种解释。
这概念是说你不用创建对象，而只需要描述它如何被创建。
你不在代码里直接组装你的组件和服务，但是要在配置文件里描述哪些组件需要哪些服务，之后一个容器（IOC 容器）负责把他们组装起来。
19.有哪些不同类型的IOC（依赖注入）方式？∙构造器依赖注入：构造器依赖注入通过容器触发一个类的构造器来实现的，该类有一系列参数，每个参数代表一个对其他类的依赖。
∙Setter方法注入：Setter方法注入是容器通过调用无参构造器或无参static工厂方法实例化bean之后，调用该bean的setter方法，即实现了基于setter的依赖注入。
20.哪种依赖注入方式你建议使用，构造器注入，还是Setter方法注入？你两种依赖方式都可以使用，构造器注入和Setter方法注入。
最好的解决方案是用构造器参数实现强制依赖，setter方法实现可选依赖。
SpringBeans21.什么是Springbeans?Springbeans是那些形成Spring应用的主干的java对象。
它们被SpringIOC 容器初始化，装配，和管理。
这些beans通过容器中配置的元数据创建。
比如，以XML文件中<bean/>的形式定义。
Spring框架定义的beans都是单件beans。
在beantag中有个属性”singleton”，如果它被赋为TRUE，bean就是单件，否则就是一个prototypebean。
默认是TRUE，所以所有在Spring框架中的beans缺省都是单件。
22.一个SpringBean定义包含什么？一个SpringBean的定义包含容器必知的所有配置元数据，包括如何创建一个bean，它的生命周期详情及它的依赖。
23.如何给Spring容器提供配置元数据?这里有三种重要的方法给Spring容器提供配置元数据。
XML配置文件。
基于注解的配置。
基于java的配置。
24.你怎样定义类的作用域?当定义一个<bean>在Spring里，我们还能给这个bean声明一个作用域。
它可以通过bean定义中的scope属性来定义。
如，当Spring要在需要的时候每次生产一个新的bean实例，bean的scope属性被指定为prototype。
另一方面，一个bean每次使用的时候必须返回同一个实例，这个bean的scope属性必须设为singleton。
25.解释Spring支持的几种bean的作用域。
Spring框架支持以下五种bean的作用域：∙singleton:bean在每个Springioc容器中只有一个实例。
∙prototype：一个bean的定义可以有多个实例。
∙request：每次http请求都会创建一个bean，该作用域仅在基于web 的SpringApplicationContext情形下有效。
∙session：在一个HTTPSession中，一个bean定义对应一个实例。
该作用域仅在基于web的SpringApplicationContext情形下有效。
∙global-session：在一个全局的HTTPSession中，一个bean定义对应一个实例。
该作用域仅在基于web的SpringApplicationContext情形下有效。
缺省的Springbean的作用域是Singleton.26.Spring框架中的单例bean是线程安全的吗?不，Spring框架中的单例bean不是线程安全的。
27.解释Spring框架中bean的生命周期。
∙Spring容器从XML文件中读取bean的定义，并实例化bean。
∙Spring根据bean的定义填充所有的属性。
∙如果bean实现了BeanNameAware接口，Spring传递bean的ID到setBeanName方法。
∙如果Bean实现了BeanFactoryAware接口，Spring传递beanfactory 给setBeanFactory方法。
∙如果有任何与bean相关联的BeanPostProcessors，Spring会在postProcesserBeforeInitialization()方法内调用它们。
∙如果bean实现IntializingBean了，调用它的afterPropertySet方法，如果bean声明了初始化方法，调用此初始化方法。
∙如果有BeanPostProcessors和bean关联，这些bean的postProcessAfterInitialization()方法将被调用。