Spring 、Spring Boot 与 Spring MVC 介绍

不想菜的鸟

已于 2023-08-14 18:24:09 修改

阅读量1.3k

点赞数 17

文章标签： java spring spring boot mvc

于 2023-07-30 17:55:16 首次发布

本文链接：https://blog.csdn.net/weixin_58697177/article/details/132009587

版权

1. Spring

1.1 什么是 Spring 框架

Spring框架是一个用于构建企业级Java应用程序的开源应用程序框架。它提供了一组综合的解决方案，用于开发Java应用程序的各个方面，包括依赖注入（Dependency Injection）、面向切面编程（Aspect-Oriented Programming）、事务管理、数据访问、Web开发等。

1.2 核心特点

Spring框架具有以下核心特点：

轻量级：Spring框架采用了轻量级的设计思想，它不依赖于庞大的第三方库或容器。Spring的核心库非常精简，只提供了基本的功能和特性，使得应用程序可以快速启动和运行。
控制反转（IoC）和依赖注入（DI）：Spring框架通过依赖注入实现了对象之间的松耦合。开发者无需自己管理对象的创建和组装，而是通过配置或注解的方式，由框架负责将依赖关系注入到对象中。这种松耦合的设计使得代码更具可测试性、可维护性和可扩展性。
面向切面编程（AOP）：Spring框架提供了对面向切面编程的支持。AOP允许开发者在不修改原有代码的情况下，通过定义切面来插入横切关注点，例如日志记录、事务管理等。这种机制提高了代码的模块化和重用性，同时将核心业务逻辑与横切关注点分离开来。
容器管理：Spring框架提供了一个容器（ApplicationContext）来管理应用程序中的对象。容器负责创建、配置和管理对象的生命周期，包括依赖注入、对象的初始化和销毁等。通过容器的管理，开发者可以更方便地管理和组织应用程序的组件。
综合的解决方案：Spring框架提供了一系列的模块和工具，涵盖了各个方面的应用开发需求。例如，Spring MVC用于构建Web应用程序，Spring JDBC用于简化数据库访问，Spring Security用于身份验证和授权等。这些模块能够根据项目的需求进行选择和集成，提供了一套综合的解决方案。
高度可扩展：Spring框架具有高度的可扩展性，开发者可以通过扩展或自定义各种组件来满足特定的需求。Spring提供了扩展点和插件机制，使得开发者可以根据项目的要求进行定制和扩展，而无需改变框架的核心代码。

1.3 IoC 与 DI 的关系

IoC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入）是紧密相关的概念，它们在软件开发中常常一起使用。
IoC是一种设计原则，它指的是将控制权从应用程序代码中转移给一个框架或容器。传统的程序设计中，应用程序代码负责创建和管理对象之间的依赖关系，而在IoC中，这种控制权被反转，由框架或容器负责创建、组装和管理对象。
DI是IoC的一种具体实现方式。它通过依赖注入的方式来实现对象之间的解耦。而依赖注入是指将一个对象所依赖的其他对象（依赖）注入到该对象中，而不是由该对象自己去创建或获取依赖对象。这样，对象之间的依赖关系由容器在运行时进行注入，从而实现了对象之间的解耦和松耦合。
简而言之，IoC是一种设计原则或思想，它强调控制权的转移和解耦，而DI是IoC的一种具体实现方式，通过依赖注入来实现对象的解耦。DI是IoC的一种具体体现，它是实现IoC的一种手段。
在Spring框架中，依赖注入是实现IoC的核心机制。Spring通过IoC容器管理对象的生命周期和依赖关系，并通过依赖注入将依赖对象注入到目标对象中。这种使用DI的方式使得开发者能够专注于业务逻辑的实现，而不需要关心对象的创建和依赖关系的管理。
总结起来，IoC强调控制权的转移和解耦，而DI是IoC的一种具体实现方式，通过依赖注入来实现对象的解耦。在实际开发中，使用DI可以实现更松散耦合、可维护和可测试的代码结构。

1.4 对比一下普通的java程序与Spring 中的依赖注入

通的Java程序和Spring框架中的依赖注入在对象创建和依赖管理方面存在一些区别。

对象创建方式：
普通的Java程序中，对象的创建通常是通过关键字new来实现的，开发者需要显式地在代码中创建和初始化对象。
在Spring框架中，对象的创建由Spring容器负责。开发者只需在配置文件或使用注解的方式中声明对象的依赖关系，Spring容器会根据配置信息自动创建和管理对象的生命周期。
依赖关系管理：
普通的Java程序中，对象之间的依赖关系通常由开发者手动管理。开发者需要在代码中显式地创建和传递依赖对象，从而实现对象之间的协作。
在Spring框架中，依赖注入通过配置或注解的方式实现。开发者只需在需要注入依赖的对象中声明相应的依赖属性，Spring容器会负责解析依赖关系并将相应的依赖对象注入到目标对象中。
松耦合性：
普通的Java程序中，对象之间的依赖通常是紧耦合的，即一个对象直接依赖于另一个对象的具体实现。这样的紧耦合关系会增加代码的复杂性和可测试性。
在Spring框架中，依赖注入实现了对象之间的松耦合。对象只需声明所需的接口或抽象类作为依赖，而不依赖于具体的实现类。这种松耦合的设计使得代码更具可测试性、可维护性和可扩展性。
可替换性和可测试性：
普通的Java程序中，由于对象之间的依赖是硬编码的，如果需要替换某个依赖对象或进行单元测试，需要手动修改代码或使用模拟对象等技术。
在Spring框架中，依赖注入使得对象的依赖关系可以在配置文件或注解中进行声明，而不需要修改源代码。这样，开发者可以轻松地替换依赖对象或使用模拟对象进行单元测试，提高了代码的可替换性和可测试性。

综上所述，Spring框架中的依赖注入相比普通的Java程序，在对象创建和依赖管理方面提供了更高的灵活性、可维护性和可测试性。它通过将对象的创建和依赖关系的管理交给Spring容器来处理，实现了对象之间的松耦合和可替换性。这使得开发者能够更专注于业务逻辑的实现，提高了代码的可读性和可维护性。

代码展示一下：
假设我们有一个简单的订单管理系统，包含订单(Order)和客户(Customer)两个类。订单类依赖于客户类来进行关联。

普通的Java程序中的依赖关系管理：

// 客户类
public class Customer {
    private String name;

    public Customer(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

// 订单类
public class Order {
    private String orderId;
    private Customer customer;

    public Order(String orderId, Customer customer) {
        this.orderId = orderId;
        this.customer = customer;
    }

    public String getOrderId() {
        return orderId;
    }

    public Customer getCustomer() {
        return customer;
    }
}

// 在主程序中手动创建并管理依赖关系
public class Main {
    public static void main(String[] args) {
        Customer customer = new Customer("zhangsan");
        Order order = new Order("12345", customer);

        System.out.println("Order ID: " + order.getOrderId());
        System.out.println("Customer Name: " + order.getCustomer().getName());
    }
}

在这个示例中，我们手动创建了Customer对象，并在创建Order对象时将Customer对象传递给Order的构造函数。
2. 使用Spring框架进行依赖注入：

// 客户类
public class Customer {
    private String name;

    public Customer(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

// 订单类
public class Order {
    private String orderId;
    private Customer customer;

    public Order(String orderId, Customer customer) {
        this.orderId = orderId;
        this.customer = customer;
    }

    public String getOrderId() {
        return orderId;
    }

    public Customer getCustomer() {
        return customer;
    }
}

// 在Spring中配置依赖注入
public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        Order order = context.getBean("order", Order.class);

        System.out.println("Order ID: " + order.getOrderId());
        System.out.println("Customer Name: " + order.getCustomer().getName());
    }
}

// Spring配置文件 applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="customer" class="com.example.Customer">
        <constructor-arg value="zhangsan"/> <!-- 通过构造函数注入依赖 -->
    </bean>

    <bean id="order" class="com.example.Order">
        <constructor-arg value="12345"/> <!-- 通过构造函数注入依赖 -->
        <constructor-arg ref="customer"/> <!-- 通过引用方式注入依赖 -->
    </bean>

</beans>

在这个示例中，我们使用Spring框架进行依赖注入。通过配置一个XML文件（applicationContext.xml）来声明对象的依赖关系。在主程序中，我们通过Spring容器获取Order对象，Spring会自动创建并注入所需的Customer对象。

1.5 五大类注解

在Spring框架中，有五个重要的注解，被称为"五大类注解"，用于在应用程序中实现依赖注入、组件扫描和声明事务等功能。这些注解是：

@Component：@Component是一个通用的注解，用于标记一个类为Spring管理的组件。它是其他注解（如@Service、@Repository、@Controller等）的父注解，可以用于任何需要被Spring管理的类。
@Repository：@Repository注解用于标记一个类为数据访问层（DAO）的组件。它通常用于与数据库交互、执行持久化操作等。
@Service：@Service注解用于标记一个类为业务逻辑层（Service）的组件。它通常包含应用程序的核心业务逻辑，并协调DAO组件的调用。
@Controller：@Controller注解用于标记一个类为控制器层（Controller）的组件。它通常处理用户请求、调用适当的Service组件，并返回适当的视图来呈现给用户。
@Configuration：@Configuration注解用于标记一个类为配置类。配置类通常包含一组用于配置Spring应用程序的Bean定义和相关配置。它是基于Java的配置方式，相对于XML配置方式。

1.6 AOP 详细介绍

AOP 的主要作用是将那些与业务无关,却为业务模块所共同调用的逻辑或责任(例如事务管理、日志管理、权限控制等)封装起来,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可维护性和可扩展性。

Aspect:切面,是一个具有通用功能的模块,如日志、异常处理、事务等。
Join Point:连接点,是程序执行过程中可能被拦截的点,如方法执行前、后或异常抛出等。
Pointcut:切入点,是通过Pointcut表达式来把Join Point匹配进来的,执行的地方。切入点可以匹配执行的方法。
Advice:通知,描述了切面儘责在切入点处完成的事情。主要类型有:前置、后置、异常抛出、返回等。
Target:目标对象,表示要增强的对象。
Weaving:织入,是把切面应用到目标对象并创建新的代理对象的过程。可以在编译期、加载期或运行期进行织入。
Introduction:引入,允许通过新的方法或属性扩展目标类。
Proxy:代理对象,AOP框架通过向目标对象创建代理来实现增强的决定。
AspectJ:一个流行的AOP框架,可以在编译期做织入,提供更强大的功能。

AOP框架:如SpringAOP和AspectJ实现AOP的功能。Spring主要通过运行时织入实现AOP,AspectJ支持多种织入点。

五大类注解的作用以及代码示例：
7. @Component注解的作用是将类标记为Spring管理的组件。它用于通用的组件类。

@Component
public class MyComponent {
    // 类的实现
}

@Repository注解的作用是将类标记为数据访问层（DAO）的组件。它用于与数据库交互、执行持久化操作等。

@Repository
public class UserRepository {
    // 类的实现
}

@Service注解的作用是将类标记为业务逻辑层（Service）的组件。它通常包含应用程序的核心业务逻辑，并协调DAO组件的调用。

@Service
public class UserService {
    // 类的实现
}

@Controller注解的作用是将类标记为控制器层（Controller）的组件。它用于处理用户请求、调用适当的Service组件，并返回适当的视图来呈现给用户。

@Controller
public class UserController {
    // 类的实现
}

@Configuration注解的作用是将类标记为配置类。配置类通常包含一组用于配置Spring应用程序的Bean定义和相关配置。它是基于Java的配置方式，相对于XML配置方式。

@Configuration
public class AppConfig {
    @Bean
    public MyBean myBean() {
        return new MyBean();
    }
}

另外，为了使注解起作用，还需要在Spring配置中启用组件扫描。您可以通过在XML配置文件中添加以下内容来启用组件扫描：

<context:component-scan base-package="com.example" />

2. Spring Boot

2.1 什么是 Spring Boot

Spring Boot是一个用于简化和加速基于Spring框架的应用程序开发的开源框架。它提供了一个约定大于配置的方式，旨在最小化开发人员在配置方面的工作量，从而使开发过程更加简单、快速和高效。

2.2 如何理解约定大于配置

约定大于配置是一种设计原则，指的是在软件开发中，通过事先定义一些约定和规则，以减少开发人员在配置方面的工作量，从而简化开发过程。

传统的软件开发往往需要大量的配置文件和手动配置步骤，开发人员需要详细配置各种参数和选项，以满足应用程序的需求。这种方式需要开发人员具备熟练的配置技能，并且容易出现配置错误和冲突。

而约定大于配置的方式则通过事先定义一些默认约定和规则，使得开发人员可以遵循这些约定而不需要进行显式的配置。这样可以大大简化配置的过程，减少出错的可能性，并提高开发效率。

在Spring Boot中，约定大于配置的思想得到了广泛应用。Spring Boot提供了一系列的默认约定和自动配置机制，开发人员只需要按照这些约定编写代码和组织项目结构，就能够快速启动应用程序，无需手动配置大量的Spring选项。

例如，Spring Boot默认约定了一些常见的目录结构，如将应用程序的主类放置在特定的包路径下，将静态资源放置在特定的目录下等。此外，Spring Boot还提供了自动配置，根据应用程序的依赖和环境，自动配置Spring的各种组件和功能，减少了手动配置的工作量。

通过约定大于配置的方式，开发人员能够更快速地上手开发，减少了不必要的配置复杂性，提高了开发效率和项目的可维护性。

我们以 Web 开发为例，来说明约定大于配置的优势：
传统方式：
在传统的Web开发中，配置一个URL映射到一个处理方法通常需要进行显式的配置。比如，在Java Servlet中，需要在web.xml配置文件中添加以下内容：

<servlet>
    <servlet-name>MyServlet</servlet-name>
    <servlet-class>com.example.MyServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>MyServlet</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

这里需要显式地指定Servlet的名称、类和URL映射的路径。如果有多个URL需要映射到不同的Servlet或处理方法，就需要编写更多的配置。

约定大于配置的方式：
现在考虑使用Spring Boot来实现相同的URL映射，通过约定大于配置的方式，可以大大简化配置的过程。

在Spring Boot中，可以在一个普通的Spring MVC控制器中定义一个处理方法，并使用@RequestMapping注解指定URL映射路径。示例如下：

@Controller
public class MyController {
    @RequestMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}

在这个例子中，我们不需要显式地配置Servlet或URL映射的细节，只需使用@Controller注解标记控制器类，并在处理方法上使用@RequestMapping注解指定URL路径。Spring Boot会根据这些约定自动配置URL映射，将/hello路径映射到hello()方法。

这种约定大于配置的方式大大简化了配置的过程，开发人员只需要按照约定来编写代码，无需手动配置大量的细节。这提高了开发效率，减少了出错的可能性，并且使代码更加易于理解和维护。

2.3 Spring Boot 的优点

简化开发：Spring Boot通过约定大于配置的原则，提供了默认的配置和自动配置机制，大大简化了开发过程。开发人员可以专注于业务逻辑的实现，而无需花费过多时间和精力在繁琐的配置上。
快速启动：Spring Boot提供了快速启动的能力，开发人员可以快速地启动和运行应用程序，减少了构建和部署的时间。它内置了常用的Servlet容器，可以将应用程序打包为可执行的JAR文件，直接在内嵌容器中运行。
自动装配：Spring Boot 提供了自动装配机制，根据应用程序的依赖关系和配置信息，智能地自动配置 Spring 的各种组件和功能，大大减少了开发人员的手动配置工作，提高了开发效率。
开箱即用的功能：Spring Boot集成了许多常用的功能和组件，如安全性、数据库访问、缓存、消息队列等。这些功能都是开箱即用的，开发人员可以直接使用，无需手动集成和配置。这大大简化了开发过程，加快了应用程序的开发速度。
自动化依赖管理：Spring Boot通过自动化依赖管理，简化了依赖库的引入和版本管理。它提供了起步依赖（Starter）的概念，开发人员只需添加相应的起步依赖，Spring Boot会自动适配依赖的版本和配置，简化了构建和管理项目的过程。
生态系统和社区支持：Spring Boot 建立在Spring框架之上，可以无缝集成 Spring 的各种功能和扩展。同时，Spring Boot 还提供了大量的第三方库和插件，可以方便地集成其他技术栈，构建全栈式应用程序。

2.4 springboot的启动注解

@SpringBootApplication：这是一个组合注解，用于标记主类（包含main方法的类）。它将三个注解组合在一起，包括@Configuration、@EnableAutoConfiguration和@ComponentScan。

@Configuration 表示该类是一个配置类
@EnableAutoConfiguration 该注解用于启用Spring Boot的自动配置机制。它会根据项目的依赖和配置来自动配置应用程序的各个组件，例如数据库连接、Web服务器等。Spring Boot根据classpath下的依赖自动推断和配置这些组件。
@ComponentScan 该注解用于指定要扫描的包路径，以加载标有@Component、@Service、@Controller等注解的组件。它会自动扫描并注册这些组件到Spring容器中，使它们可以被其他组件使用。

3. Spring MVC

3.1 什么是 Spring MVC

Spring MVC（Model-View-Controller）是Spring框架中的一部分，用于构建基于Java的Web应用程序。它是一个基于MVC设计模式的Web框架，提供了一种结构化的方式来开发Web应用程序，使开发人员能够更好地管理请求、处理逻辑和呈现视图。

3.2 核心组件

Model（模型）：模型代表应用程序的数据和业务逻辑。它可以是POJO（Plain Old Java Object）或者通过持久化框架与数据库交互。模型通常包含应用程序的状态和数据，以及处理这些数据的方法。
View（视图）：视图负责呈现模型的数据给用户。它可以是一个JSP页面、Thymeleaf模板、HTML页面或其他类型的视图技术。视图负责展示数据给用户，并与用户进行交互。
Controller（控制器）：控制器是模型和视图之间的协调者。它接收用户的请求，并根据请求的内容选择适当的模型和视图进行处理。控制器通常包含处理请求的方法，可以通过注解或配置进行映射。

3.2 工作流程

用户发送HTTP请求到Spring MVC的前端控制器
前端控制器根据请求的URL和配置的映射规则，选择相应的控制器进行处理。
控制器根据业务逻辑处理请求，可能会涉及到访问数据库、处理数据等操作。
控制器将处理结果封装成模型对象，并选择相应的视图进行渲染。
视图将模型数据呈现给用户。
用户与视图进行交互，可以发送新的请求，从而重复以上流程。

4. Springboot 和Springmvc的区别和联系

联系

Spring MVC是Spring框架的一部分，而Spring Boot则是建立在Spring框架之上的。Spring Boot可以与Spring MVC一起使用，以简化Spring MVC应用程序的配置和部署。
Spring Boot内置了Tomcat、Jetty等Web服务器，因此可以直接运行Spring MVC应用程序，无需手动配置和部署外部服务器。
Spring Boot提供了自动配置机制，可以根据应用程序的依赖和配置情况，自动配置Spring MVC的相关组件和功能，简化了配置过程。
Spring Boot还提供了许多与Web开发相关的功能和插件，例如Spring Boot Starter Web，用于自动配置Web开发所需的依赖项。

区别

Spring Boot是一个全新的框架，旨在简化Spring应用程序的开发和部署，提供了自动配置、内嵌服务器等特性。而Spring MVC是Spring框架的一部分，专注于构建Web应用程序。
Spring Boot关注于整个应用程序的配置和部署，提供了一种约定优于配置的方式，使得开发者可以更快地开发应用程序。而Spring MVC关注于处理Web请求和响应，提供了一种基于MVC模式的架构。
Spring Boot可以与Spring MVC一起使用，但它并不局限于Spring MVC，也可以与其他Spring模块（如Spring Data、Spring Security等）以及第三方库进行集成。
Spring Boot提供了许多开箱即用的功能和插件，使得开发人员可以更专注于业务逻辑的实现，而Spring MVC则提供了一套Web开发的基础架构和规范。

不想菜的鸟

关注

17
点赞
踩
27

收藏

觉得还不错? 一键收藏
打赏
14
评论
Spring 、Spring Boot 与 Spring MVC 介绍

Spring框架是一个用于构建企业级Java应用程序的开源应用程序框架。它提供了一组综合的解决方案，用于开发Java应用程序的各个方面，包括依赖注入（Dependency Injection）、面向切面编程（Aspect-Oriented Programming）、事务管理、数据访问、Web开发等。AOP 的主要作用是将那些与业务无关,却为业务模块所共同调用的逻辑或责任(例如事务管理、日志管理、权限控制等)封装起来,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可维护性和可扩展性。
复制链接

扫一扫