Spring 、Spring Boot 与 Spring MVC 介绍_spring boot mvc框架

1. Spring

1.1 什么是 Spring 框架

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

1.2 核心特点

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

1. 轻量级：Spring框架采用了轻量级的设计思想，它不依赖于庞大的第三方库或容器。Spring的核心库非常精简，只提供了基本的功能和特性，使得应用程序可以快速启动和运行。

2. 控制反转（IoC）和依赖注入（DI）：Spring框架通过依赖注入实现了对象之间的松耦合。开发者无需自己管理对象的创建和组装，而是通过配置或注解的方式，由框架负责将依赖关系注入到对象中。这种松耦合的设计使得代码更具可测试性、可维护性和可扩展性。

3. 面向切面编程（AOP）：Spring框架提供了对面向切面编程的支持。AOP允许开发者在不修改原有代码的情况下，通过定义切面来插入横切关注点，例如日志记录、事务管理等。这种机制提高了代码的模块化和重用性，同时将核心业务逻辑与横切关注点分离开来。

4. 容器管理：Spring框架提供了一个容器（ApplicationContext）来管理应用程序中的对象。容器负责创建、配置和管理对象的生命周期，包括依赖注入、对象的初始化和销毁等。通过容器的管理，开发者可以更方便地管理和组织应用程序的组件。

5. 综合的解决方案：Spring框架提供了一系列的模块和工具，涵盖了各个方面的应用开发需求。例如，Spring MVC用于构建Web应用程序，Spring JDBC用于简化数据库访问，Spring Security用于身份验证和授权等。这些模块能够根据项目的需求进行选择和集成，提供了一套综合的解决方案。

6. 高度可扩展：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框架中的依赖注入在对象创建和依赖管理方面存在一些区别。

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

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

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

1. 普通的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());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

在这个示例中，我们手动创建了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());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

// 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>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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

1.5 五大类注解

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

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

1.6 AOP 详细介绍

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

1. Aspect:切面,是一个具有通用功能的模块,如日志、异常处理、事务等。

2. Join Point:连接点,是程序执行过程中可能被拦截的点,如方法执行前、后或异常抛出等。

3. Pointcut:切入点,是通过Pointcut表达式来把Join Point匹配进来的,执行的地方。切入点可以匹配执行的方法。

4. Advice:通知,描述了切面儘责在切入点处完成的事情。主要类型有:前置、后置、异常抛出、返回等。

5. Target:目标对象,表示要增强的对象。

6. Weaving:织入,是把切面应用到目标对象并创建新的代理对象的过程。可以在编译期、加载期或运行期进行织入。

7. Introduction:引入,允许通过新的方法或属性扩展目标类。

8. Proxy:代理对象,AOP框架通过向目标对象创建代理来实现增强的决定。

9. AspectJ:一个流行的AOP框架,可以在编译期做织入,提供更强大的功能。

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

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

@Component
public class MyComponent {
    // 类的实现
}
1
2
3
4

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

@Repository
public class UserRepository {
    // 类的实现
}
1
2
3
4

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

@Service
public class UserService {
    // 类的实现
}
1
2
3
4

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

@Controller
public class UserController {
    // 类的实现
}
1
2
3
4

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

@Configuration
public class AppConfig {
    @Bean
    public MyBean myBean() {
        return new MyBean();
    }
}
1
2
3
4
5
6
7

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

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

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>
1
2
3
4
5
6
7
8

这里需要显式地指定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!";
    }
}
1
2
3
4
5
6
7

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

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

2.3 Spring Boot 的优点

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

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

3.2 工作流程

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

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开发的基础架构和规范。