Spring

前言

  • Spring 是最受欢迎的企业级 Java 应用程序开发框架,数以百万的来自世界各地的开发人员使用 Spring 框架来创建性能好、易于测试、可重用的代码。

  • Spring 框架是一个开源的 Java 平台,它最初是由 Rod Johnson 编写的,并且于 2003 年 6 月首次在 Apache 2.0 许可下发布。

  • Spring 是轻量级的框架,其基础版本只有 2 MB 左右的大小。

  • Spring 框架的核心特性是可以用于开发任何 Java 应用程序,但是在 Java EE 平台上构建 web 应用程序是需要扩展的。

  • Spring 官网

  • Spring 教程

  • Spring 快速入门

1、Spring

  • Spring 是一个基于 IOC(Inversion Of Control,反转控制)和 AOP(Aspect Oriented Program,面向切面编程)结构的 J2EE 系统的框架,目标是使 J2EE 开发变得更容易使用。

  • 通过启用基于 POJO(Plain Old Java Objects,普通老式 Java 对象)编程模型来促进良好的编程实践。

  • Spring MVCSpring Boot 都属于 Spring。

    • Spring MVC 是基于 Spring 的一个 MVC 框架,主要用于开发 WEB 应用和网络接口,它是 Spring 的一个模块。
    • Spring Boot 是基于 Spring 的一套快速开发整合包,它的目的在于实现自动配置,降低项目搭建的复杂度。

    • Spring Cloud 是一个基于 Spring Boot 实现的云应用开发工具。

1.1 配置

  • 新建 applicationContext.xml:是 Spring 的核心配置文件。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <bean name="c" class="com.how2java.pojo.Category"> <!-- 定义关键字 c -->
    <property name="name" value="category 1" />
    </bean>

    </beans>
  • 通过关键字 c 即可获取 Category 对象,该对象获取的时候,即被注入了字符串 “category 1“ 到 name 属性中。

    1
    2
    3
    4
    5
    6
    7
    public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext(new String[] { "applicationContext.xml" });

    Category c = (Category) context.getBean("c"); // 通过关键字 c 获取 Category 对象

    System.out.println(c.getName()); // 输出 category 1
    }
  • 基本原理:

    • 传统的方式:

      • 通过 new 关键字主动创建一个对象。
    • IOC 方式:

      • 对象的生命周期由 Spring 来管理,直接从 Spring 那里去获取一个对象。

1.2 IOC / DI

  • IOC(Inversion Of Control)反转控制。

    • 是 Spring 的基础。
    • 简单说就是创建对象由以前的程序员自己 new 构造方法来调用,变成了交由 Spring 创建对象。
    • 就像控制权从本来在自己手里,交给了 Spring。
  • DI(Dependency Inject)依赖注入。

    • 简单地说就是拿到的对象的属性,已经被注入好相关值了,直接使用即可。
  • 注解方式 IOC/DI:告诉 Spring 要用注解的方式进行配置。

    1
    2
    3
    4
    <!-- applicationContext.xml -->

    <!-- 告诉 Spring 要用注解的方式进行配置 -->
    <context:annotation-config />
    1
    2
    3
    4
    <!-- applicationContext.xml -->

    <!-- 告诉 Spring,bean 都放在 com.how2java.pojo 这个包下 -->
    <context:component-scan base-package="com.how2java.pojo" />
  • 关键字

关键字 介绍
@Autowired
@Resource
@Component 表示这是一个 bean,由 Spring 进行管理

1.3 注入对象

  • 使用 ref 来注入另一个对象。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    <!-- applicationContext.xml -->

    <bean name="c" class="com.how2java.pojo.Category">
    <property name="name" value="category 1" />
    </bean>

    <bean name="p" class="com.how2java.pojo.Product">
    <property name="name" value="product1" />
    <property name="category" ref="c" />
    </bean>

2、AOP 面向切面编程

  • AOP(Aspect Oriented Program)面向切面编程。

  • 在面向切面编程的思想里面,核心业务功能和切面功能分别独立进行开发,然后把切面功能和核心业务功能 “编织” 在一起,这就叫 AOP。

  • 周边功能在 Spring 的面向切面编程思想里,即被定义为切面。

  • 在面向切面编程的思想里面,把功能分为核心业务功能,和周边功能。这种能够选择性的,低耦合的把周边和核心业务功能结合在一起的编程思想,就叫做切面编程。

    • 所谓的 核心业务,比如 登陆,增加数据,删除数据都叫核心业务。
    • 所谓的 周边功能,比如 性能统计,日志,事务管理等等。
  • 配置 AOP

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    <!-- applicationContext.xml -->

    <bean name="s" class="com.how2java.service.ProductService">
    </bean>

    <!-- 声明业务对象 -->
    <bean id="loggerAspect" class="com.how2java.aspect.LoggerAspect"/>

    <!-- 声明日志切面 -->
    <aop:config>

    <!-- 指定核心业务功能 -->
    <aop:pointcut id="loggerCutpoint"
    expression=
    "execution(* com.how2java.service.ProductService.*(..)) "/>

    <!-- 指定辅助功能 -->
    <aop:aspect id="logAspect" ref="loggerAspect">
    <aop:around pointcut-ref="loggerCutpoint" method="log"/>
    </aop:aspect>
    </aop:config>
  • 注解方式 AOP

    1
    2
    3
    4
    5
    6
    7
    8
    <!-- applicationContext.xml -->

    <!-- 扫描包 com.how2java.aspect 和 com.how2java.service,定位业务类和切面类 -->
    <context:component-scan base-package="com.how2java.aspect" />
    <context:component-scan base-package="com.how2java.service" />

    <!-- 找到被注解了的切面类,进行切面配置 -->
    <aop:aspectj-autoproxy />
  • 关键字

关键字 介绍
@Aspect 表示这是一个切面
@Component 表示这是一个 bean,由 Spring 进行管理
@Around 表示这个类中的所有方法进行切面操作

3、单元测试

  • 注解方式测试

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

    import com.how2java.pojo.Category;

    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")
    public class TestSpring {

    @Autowired
    Category c;

    @Test
    public void test(){
    System.out.println(c.getName());
    }
    }
  • 关键字

关键字 介绍
@RunWith 表示这是一个 Spring 的测试类
@ContextConfiguration 定位 Spring 的配置文件
@Autowired 给这个测试类装配Category对象
@Test 测试逻辑

4、Spring MVC

  • Spring MVC 是基于 Spring 的一个 MVC 框架。

  • 主要用于开发 WEB 应用和网络接口,它是 Spring 的一个模块,通过 Dispatcher Servlet, ModelAndView 和 View Resolver,让应用开发变得很容易。

5、Spring Boot

  • Spring Boot 是基于 Spring 的一套快速开发整合包。

  • 它的目的在于实现自动配置,降低项目搭建的复杂度,如需要搭建一个接口服务,通过 Spring Boot,几行代码即可实现。

6、Spring Cloud

  • Spring Cloud 是一个基于 Spring Boot 实现的云应用开发工具。

  • Spring Cloud 包含了多个子项目,比如:Spring Cloud Netflix 、Spring Cloud Config、Spring Cloud Stream、Spring Cloud Bus、Spring Cloud Sleuth 等项目。

7、Spring 常见面试题

7.1 Spring

  • 1、问题:你对 Spring 框架的理解(特点)?Spring 框架有哪些模块?

    • Spring 一种用来简化企业应用级开发的一种开源框架。
    • 简化开发:它对常用的 API 做了封装,比如对 JDBC 的封装,使用 Spring JDBC 访问数据库,就不需要考虑如何获取连接和关闭的问题。
    • 解耦:Spring 帮我们管理软件之间的依赖关系,这样对象之间的耦合性就降低了,这样的维护性就得到了提高。
    • 集成其它框架:方便扩展和优化其功能,例如和 Mybatis 的集成等。
    • Spring 框架是按照设计模式精心打造的,这使得我们在开发环境中,能方便的使用框架,不用考虑后台是怎么进行的。
    • Spring 容器是Spring框架中一个核心的模块,用来管理对象的创建,销毁和初始化扥操作,以及对象之间的依赖关系等。
    • 目前 Spring 框架已经集合成 20 多个模块:

  • 2、问题:Spring 的优点?

    • 简化开发,解耦,集成其它框架。
    • 低侵入式设计,代码污染级别较低。
    • Spring 的 DI(依赖注入)机制降低了业务对象替换的复杂性,提高了软件之间的解耦。
    • Spring AOP(面向切面编程)支持将一些通用的任务进行集中式的管理,例如:安全,事务,日志等,从而使代码能更好的复用。
  • 3、问题:什么是控制反转(IOC),什么是依赖注入(DI)?

    • IOC:Inversion of control 反转控制,就是对象之间的依赖关系由容器来创建,对象之间的关系本来是由我们开发者自己创建和维护的,在我们使用 Spring 框架后,对象之间的关系由容器来创建和维护,将开发者做的事让容器做,这就是控制反转。BeanFactory 接口是 Spring IOC 容器的核心接口。
    • DI:Dependency Injection 依赖注入,我们在使用 Spring 容器的时候,容器通过调用 set 方法或者是构造器来建立对象之间的依赖关系。通过 IOC 创建对象的时候,可以注入字符串甚至其他对象。比如 DAO 就会注入 session factory。
    • 通常 IOC 和 DI 是紧密结合,一起使用的,控制反转是目标,依赖注入是我们实现控制反转的一种手段。
  • 4、问题:Java 中实现依赖注入的三种方式?

    • 构造器注入
    • set 方法注入
    • 接口注入
  • 5、问题:Spring 容器中如何创建对象?

    • 无参构造创建
    • 静态工厂创建
    • 实例工厂创建
  • 6、问题:Spring 有几种配置方式?

    • 基于 XML 文件的配置:这种配置文件的格式常用 <beans> 开头,然后运用一系列的 bean 定义和专门的应用配置选项组成。Spring XML 配置方式是使用被 Spring 命名空间所支持的一些列 XML 的标签来实现的。
    • 基于注解的配置:可以使用注解的方式来代替 XML 方式的 bean 元素的配置。这就是组件扫描,常用依赖注入的一些注解有:@Controller @Service @Autowired @RequestMapping @RequestParam @ModelAttribute @Cacheable @CacheFlush @Resource @PostConstruct @PreDestroy @Repository @Scope @SessionAttributes @InitBinder @Required @Qualifier。
    • 组件扫描:容器会扫描 base-package 指定的包及其子包下面的所有类,如果该类有一些特定的注解,则纳入容器进行管理。
    • 在类前面添加的一些特定的注解:@Component 通用注解 @Repository 持久层注解 @Service 业务层注解、@Controller 控制层注解。
    • 基于 Java 的配置。
  • 7、问题:Spring Bean 的生命周期?

    • 指 Spring 中 bean 元素被实例化,和被销毁的过程。我们通过 init-method 属性指定初始化方法;通过 destroy-method 方法指定销毁方法。
    • 注意:只有作用域为 Singleton 的时候才会有效。Spring 作为当前 Java 最流行、最强大的轻量级框架,受到了程序员的热烈欢迎。准确的了解 Spring Bean 的生命周期是非常必要的。我们通常使用 ApplicationContext 作为 Spring 容器。这里,我们讲的也是 ApplicationContext 中 Bean 的生命周期。而实际上 BeanFactory 也是差不多的,只不过处理器需要手动注册。
  • 8、问题:解释什么叫延迟加载?

    • 默认情况下,容器启动之后会将所有作用域为单例的 bean 创建好;但是有的业务场景我们并不需要它提前都创建好;
    • 此时,我们可以在 bean 中设置 lzay-init=“true”,这样,当容器启动之后,作用域为单例的 bean,就不在创建。
  • 9、问题:解释什么是自动装配?

    • 就是将一个 Bean 注入到其它的 Bean 的 Property 中,默认情况下,容器不会自动装配,需要我们手动设定。Spring 可以通过向 Bean Factory 中注入的方式来搞定 bean 之间的依赖关系,达到自动装配的目的。
    • 自动装配建议少用,如果要使用,建议使用 ByName。
  • 10、问题:Spring bean 元素的作用域?

    • 当通过 Spring 容器创建一个 Bean 实例的时候,不仅可以完成 bean 实例的实力化,还可以为 bean 指定作用域。Spring bean 元素的支持以下 5 种作用域:
    • Singleton:单例模式,在整个 spring IOC 容器中,使用 singleton 定义的 bean 将只有一个实例。
    • Prototype:多例模式,每次通过容器中的 getBean 方法获取 prototype 定义的 beans 时,都会产生一个新的 bean 的实例。
    • Request:对于每次 Http 请求,使用 request 定义的 bean 都会产生一个新的实例,只有在 web 应用时候,该作用域才会有效。
    • Session:对于每次 Http Session,使用 session 定义的 Bean 都将产生一个新的实例。
    • Globalsession:每个全局的 Http Sesisonn,使用 session 定义的本都将产生一个新的实例。
  • 11、问题:Spring 中的 bean 是线程安全的么?

    • Spring 框架并没有对单例的 bean 进行多线程的封装处理,线程安全问题和并发问题,需要我们开发者自己考虑。
    • 但实际上,大部分的 Spring bean 并没有可变的状态(比如:service 类和 dao 类),所有在某种程度上来说 Spring 单例 bean 是线程安全的。如果 bean 有多种状态的话(比如: View Model 对象),就需要自行考虑线程安全问题。
  • 12、问题:如何在 Spring 中注入一个 Java Collection ?

    • Spring 提供理论四种集合类的配置元素:
    • <list>:该标签用来装配有重复值的 list 值。
    • <set>:该标签用来装配没有重复值的 set 值。
    • <map>:该标签科以用来注入键值对。
    • <props>:该标签用来支持注入键值对和字符串类型键值对。
  • 13、问题:Spring 框架中都用到了哪些设计模式?

    • 代理模式,在 AOP 中被使用最多。
    • 单例模式,在 Spring 配置文件中定义 bean 的时候默认的是单例模式。
    • 工厂模式, BeanFactory 用来创建对象的实例。
    • 模板方法,用来解决重复性代码。
    • 前端控制器,Spring 提供了 DispatcherSerclet 来对请求进行分发。
    • 视图帮助,Spring 提供了一系列的 JSP 标签。
    • 依赖注入,它是惯穿于 BeanFactory/ApplicationContext 接口的核心理念。
  • 14、问题:Spring 中的事件处理?

    • Spring 的核心是 ApplicatonContext,它负责管理 bean 的完整的生命周期。Spring 提供了以下内置事件:ContextRefreshedEvent ContextStartedEvent ContextStoppedEvent ContextClosedEvent RequestHandleEvent。
    • 由于 Spring 的事件处理是单线程的,所以如果一个事件被发布,直至并且除非所有的接收者得到的该消息,该进程被阻塞并且流程将不会继续。因此,如果事件处理被使用,在设计应用程序时应注意。
    • 监听上下文事件
    • 自定义事件
  • 15、问题:Spring AOP(面向切面)编程的原理?

    • AOP 面向切面编程,它是一种思想。
      • 它就是针对业务处理过程中的切面进行提取,以达到优化代码的目的,减少重复代码的目的。
      • 就比如,在编写业务逻辑代码的时候,我们习惯性的都要写:日志记录,事物控制,以及权限控制等,每一个子模块都要写这些代码,代码明显存在重复。
      • 这时候,我们运用面向切面的编程思想,采用横切技术,将代码中重复的部分,不影响主业务逻辑的部分抽取出来,放在某个地方进行集中式的管理,调用。形成日志切面,事物控制切面,权限控制切面。
      • 这样,我们就只需要关系业务的逻辑处理,即提高了工作的效率,又使得代码变的简洁优雅。
      • 这就是面向切面的编程思想,它是面向对象编程思想的一种扩展。
    • AOP 的使用场景:
      • 缓存、权限管理、内容传递、错误处理、懒加载、记录跟踪、优化、校准、调试、持久化、资源池、同步管理、事物控制等。
    • AOP 的相关概念:
      • 切面(Aspect)
      • 连接点 (JoinPoint)
      • 通知(Advice)
      • 切入点(Pointcut)
      • 代理(Proxy)
      • 织入(WeaVing)
    • Spring AOP 的编程原理?
      • 代理机制 JDK 的动态代理:只能用于实现了接口的类产生代理。
      • Cglib 代理:针对没有实现接口的类产生代理,应用的是底层的字节码增强技术,生成当前类的子类对象。
  • 16、问题:解释一下代理模式(Proxy)

    • 代理模式:代理模式就是本该我做的事,我不做,我交给代理人去完成。就比如,我生产了一些产品,我自己不卖,我委托代理商帮我卖,让代理商和顾客打交道,我自己负责主要产品的生产就可以了。代理模式的使用,需要有本类,和代理类,本类和代理类共同实现统一的接口。然后在main中调用就可以了。本类中的业务逻辑一般是不会变动的,在我们需要的时候可以不断的添加代理对象,或者修改代理类来实现业务的变更。
    • 代理模式可以分为:静态代理 优点:可以做到在不修改目标对象功能的前提下,对目标功能扩展 缺点:因为本来和代理类要实现统一的接口,所以会产生很多的代理类,类太多,一旦接口增加方法,目标对象和代理对象都要维护。动态代理(JDK代理/接口代理)代理对象,不需要实现接口,代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象,需要我们指定代理对象/目标对象实现的接口的类型。Cglib代理 特点: 在内存中构建一个子类对象,从而实现对目标对象功能的扩展。
    • 使用场景:修改代码的时候。不用随便去修改别人已经写好的代码,如果需要修改的话,可以通过代理的方式来扩展该方法。隐藏某个类的时候,可以为其提供代理类 当我们要扩展某个类功能的时候,可以使用代理类 当一个类需要对不同的调用者提供不同的调用权限的时候,可以使用代理类来实现。 减少本类代码量的时候。需要提升处理速度的时候。就比如我们在访问某个大型系统的时候,一次生成实例会耗费大量的时间,我们可以采用代理模式,当用来需要的时候才生成实例,这样就能提高访问的速度。

7.2 Spring MVC

  • 1、问题:什么是 Spring MVC ?

    • Spring MVC 是一个基于 MVC 架构的用来简化 web 应用程序开发的应用开发框架,它是 Spring 的一部分,它和 Struts2 一样都属于表现层的框架。
    • MVC(Model 模型 View 视图 Controller 控制器):这是一种软件架构思想,是一种开发模式,将软件划分为三种不同类型的模块,分别是模型,视图,和控制器。
      • 模型:用于封装业务逻辑处理(java 类);
      • 视图:用于数据展现和操作界面(Servlet);
      • 控制器:用于协调视图和模型(jsp);
    • 处理流程:视图将请求发送给控制器,由控制器选择对应的模型来处理;模型将处理结果交给控制器,控制器选择合适的视图来展现处理结果;

  • 2、问题:Spring MVC 的五大组键?

    • 前端控制器(DispatcherServlet)
    • 映射处理器(HandlerMapping)
    • 处理器(Controller)
    • 模型和视图(ModelAndView)
    • 视图解析器(ViewResolver)
  • 3、问题:Spring MVC 的运行原理?

    • 客户端请求提交到 前端控制器;
    • 由 前端控制器 控制器查询一个或多个 映射处理器。
    • 找到处理请求的 处理器,前端控制器 将请求提交到 处理器。
    • 处理器 调用业务逻辑处理后,返回 模型和视图。
    • 前端控制器 查询一个或多个 视图解析器,找到 模型和视图 指定的视图。
    • 视图负责将结果显示到客户。

  • 4、问题:Spring MVC 的控制器是不是单例模式,如果是,有什么问题,怎么解决?

    • 是单例模式,所以在多线程访问的时候有线程安全问题,不要用同步,会影响性能,解决方案是在控制器里面不能写字段。
  • 5、问题:Spring MVC 怎样设定重定向和转发?

    • 在返回值的前面加 ”forword”,就可以实现让结果转发;
    • 在返回值的前面加上 ”redirect”,就可以让返回值重定向。
  • 6、问题:Spring MVC 的优点?

    • 基于 View 框架的无缝集成,采用 IOC 便于测试。
    • 典型的纯 MVC 架构,Struts 是不完全基于 MVC 框架的。
    • 与 tapestry 是纯正的 Servlet 系统。
  • 7、问题:Spring MVC 中控制器的注解一般用哪个,有没有别的注解可以代替?

    • 一般用 @Controller 注解,表示是表现层,不能使用别的注解代替。
  • 8、问题:@RequestMapping 注解用在类上面有什么作用?

    • 用于类上,表示类中的所有响应请求的方法都是以该地址作为父路径。
  • 9、问题:基于注解的 Spring MVC 的应用编程步骤?

    • Step1:导包 (Spring-webmvc), 添加 spring 配置文件,配置前端控制器 dispatcherServlet。
    • Step2: 写 Controller。
    • Step3:写 JSP。
    • Step4:在 Spring 的配置文件里面添加视图解析器、组建扫描、mvc 注解扫描。
  • 10、问题:Spring MVC 如何读取请求参数值?

    • 方式1:通过 request。
    • 方式2:通过 @RequestParam。
    • 方式3:通过 Javabean。
  • 11、问题:Spring MVC 如何向页面传值?

    • 方式1: 绑定数据到 request。
    • 方式2: 返回 ModelandView。
    • 方式3:绑定数据到 ModelMap。
    • 方式4:绑定数据到 Session。
  • 12、问题:系统如何分层?

    • 表现层(UI):数据的展现,操作页面,请求转发。
    • 业务层(服务层):封装业务处理逻辑。
    • 持久层(数据访问层):封装数据访问逻辑。
    • 各层之间的关系:表示层通过接口调用业务层,业务层通过接口调用持久层,这样,当下一层发生变化改变,不影响上一层的数据。 MVC 是一种表现层的架构思想。

  • 13、问题:Spring MVC 如何解决中文乱码问题?

    • 可以使用 Spring MVC 提供的过滤器(CharacterEncodingFilter)来解决;
    • 只需要配置该过滤器就可以,需要注意的是:过滤器的编码设置应该与 jsp 页面保存一致 表单的提交方式设置为 post。
  • 14、问题:Spring MVC 中的拦截器问题?

    • DispatcherServlet 收到请求之后,如果有拦截器,则先执行拦截器的方法,在执行处理器的方法;
    • 注意:过滤器属于Servlet规范,拦截的是 Servlet 容器的调用过程。
    • 拦截器属于 spring 框架,拦截的是 DispatcherServlet 的调用过程
    • 如何写一个拦截器:
      • 1)写一个 java 类,实现 HandlerInterceptor 接口;
      • 2)在接口方法当中,实现处理逻辑;
      • 3)配置拦截器;
      • 4)拦截器还可以设置优先级:依据配置的顺序来执行。
  • 15、问题:Spring MVC 的异常处理?

    • 可以将异常抛给 Spring 框架,由 Spring 框架来处理;我们只需要配置简单的异常处理器,在异常处理器中添视图页面即可。
  • 16、问题:Spring MVC 和 Struts2 的异同?

    • Spring MVC 是一个基于 MVC 架构的用来简化 web 应用程序开发的应用开发框架,它是 Spring 的一部分,它和 Struts2 一样都属于表现层的框架。
    • Spring MVC 是典型的纯 MVC 架构,Struts 是不完全基于 MVC 框架的。
文章目录
  1. 1. 前言
  2. 2. 1、Spring
    1. 2.1. 1.1 配置
    2. 2.2. 1.2 IOC / DI
    3. 2.3. 1.3 注入对象
  3. 3. 2、AOP 面向切面编程
  4. 4. 3、单元测试
  5. 5. 4、Spring MVC
  6. 6. 5、Spring Boot
  7. 7. 6、Spring Cloud
  8. 8. 7、Spring 常见面试题
    1. 8.1. 7.1 Spring
    2. 8.2. 7.2 Spring MVC
隐藏目录