初识 Spring 框架

最新推荐文章于 2024-10-01 13:49:09 发布

qin031114

最新推荐文章于 2024-10-01 13:49:09 发布

阅读量79

点赞数

文章标签： spring java 后端

本文链接：https://blog.csdn.net/qin031114/article/details/133855029

版权

一、Spring框架的历史由来

Spring 中文含义为：春天

官网 : http://spring.io/

官方下载地址 : https://repo.spring.io/libs-release-local/org/springframework/spring/

GitHub : https://github.com/spring-projects

Spring是Java EE编程领域的一个轻量级开源J2EE应用程序框架，该框架由一个叫Rod Johnson的程序员在 2002 年最早提出并随后创建，是为了解决企业级编程开发中的复杂性，实现敏捷开发的应用型框架，很难想象Rod Johnson的学历 , 他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。

Spring是一个开源容器框架，它集成各类型的工具，通过核心的Bean factory实现了底层的类的实例化和生命周期的管理。在整个框架中，各类型的功能被抽象成一个个的 Bean，这样就可以实现各种功能的管理，包括动态加载和切面编程。 Spring是独特的，因为若干个原因：

它定位的领域是许多其他流行的framework没有的。Spring致力于提供一种方法管理你的业务对象。
Spring是全面的和模块化的。Spring有分层的体系结构，这意味着你能选择使用它孤立的任何部分，它的架构仍然是内在稳定的。例如，你可能选择仅仅使用Spring来简单化JDBC的使用，或用来管理所有的业务对象。

它的设计从底部帮助你编写易于测试的代码。Spring是用于测试驱动工程的理想的framework。
Spring对你的工程来说，它不需要一个以上的framework。Spring是潜在地一站式解决方案，定位于与典型应用相关的大部分基础结构。它也涉及到其他framework没有考虑到的内容。

Spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IOC、AOP及Web MVC等功能。

Spring框架主要由七部分组成，分别是 Spring Core、 Spring AOP、 Spring ORM、 Spring DAO、Spring Context、 Spring Web和 Spring Web MVC。

二、Spring IoC

IoC（Inversion of Control）即控制反转，是面向对象编程中的一种设计理念。它的核心思想是将对资源的控制权进行反转，使得类之间的依赖关系由容器动态地注入，而不是由类自身去创建和管理依赖对象。

Spring IoC容器具有以下特点：

1. 控制反转（IoC）：将对象的依赖关系从代码中解放出来，交给外部容器来管理。

2. 面向切面编程（AOP）：允许开发人员将跨多个对象的共有功能（如日志记录、安全性检查和事务管理等）模块化，并将其作为切面应用在应用程序中。

3. 容器：负责创建、配置和组装对象，以及管理它们的生命周期和依赖关系。

4. 配置管理：通过XML配置文件来管理应用程序中的对象和它们的相互关系。

5. 便于扩展：Spring框架提供了丰富的扩展点，允许开发人员定制和扩展IoC容器的功能。

总之，Spring IoC容器是一个强大的组件，它通过控制反转设计原则和面向切面编程技术来简化Java应用程序的开发和维护。利用XML配置文件来管理对象和它们的依赖关系，可以更轻松地构建和维护复杂的Java应用程序。

1. IoC和依赖注入

在传统的程序设计中，UserService要调用UserDao的方法，需要先创建一个UserDao实例对象。但随着业务的发展，项目变得越来越复杂，UserService不仅需要依赖UserDao，还可能需要依赖其他类（如GoodsDao、OrdersDao等）。

IoC和依赖注入是现代软件开发中非常重要的概念，它们帮助开发人员降低代码之间的耦合度，提高代码的可维护性和可测试性。

IoC（控制反转）是一种设计原则，旨在降低代码之间的耦合度。在传统的应用程序中，当两个对象之间存在依赖关系时，通常需要直接相互引用，这样会给代码带来较高的耦合度。而通过使用IoC容器，可以将对象的依赖关系交给容器来管理，从而降低代码之间的耦合度。

依赖注入是一种实现IoC的方式，它通过将对象的依赖关系通过构造函数或者其他方法注入到对象中。这意味着对象不需要直接管理其依赖关系，而是由外部容器来负责创建和注入依赖对象。

依赖注入的优点：

1.可以使代码更加可维护，因为依赖对象可以被轻易地替换和修改，而不需要修改使用它们的代码。

2.依赖注入使得代码更加可测试，因为依赖对象可以被模拟或者存根，从而使得测试更加简单和可靠。

在.NET开发中，有很多框架支持依赖注入，例如ASP.NET Core、Unity、Autofac等等。这些框架可以帮助我们实现依赖注入，从而使得应用程序更加可维护和可测试。

总之，IoC和依赖注入是软件开发中的重要概念，它们可以帮助我们降低代码之间的耦合度，提高代码的可维护性和可测试性。在开发应用程序时，应该考虑使用这些技术来提高代码的质量和可维护性。

2. 第一个Spring程序

了解到IoC的思想后，我们可以开始学习如何在项目中使用Spring框架来实现IoC。

Spring是一个开源的Java平台，用于开发企业级应用。它提供了一种全面的编程模型，包括IoC（控制反转）容器、AOP（面向切面编程）、ORM（对象关系映射）等核心功能。Spring致力于提供一种轻量级的解决方案，通过依赖注入和面向切面编程等技术，降低代码的耦合度和复杂性。

我们将通过一个简单的示例来展示如何编写一个基于Spring框架的Java应用程序。

1. 项目配置

首先，我们需要配置一个Java项目以使用Spring框架。创建一个新的Maven项目，然后在`pom.xml`文件中添加Spring的依赖：

```xml

<project>

...

<dependencies>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>5.3.10</version>

</dependency>

</dependencies>

...

</project>

```

这个依赖会引入Spring的核心库。

2. 创建Java类

创建一个简单的Java类，比如`HelloWorld`。在这个类中，我们将编写一个简单的`main`方法来启动应用程序。

public class HelloWorld {

public static void main(String[] args) {

System.out.println("Hello, World!");

}

}

3. 创建Spring配置文件

创建一个名为`applicationContext.xml`的Spring配置文件，并将其放在项目的资源目录下（通常是`src/main/resources`）。在配置文件中，我们将定义一个IoC容器和一个简单的bean。

<?xml version="1.0" encoding="UTF-8"?>

<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="helloWorld" class="com.example.HelloWorld" />

</beans>

4. 注入依赖

在Java类中，我们可以使用Spring的`ApplicationContext`来获取并使用bean。`ApplicationContext`允许我们通过bean的ID来查找和注入依赖。修改`HelloWorld`类以使用Spring的`ApplicationContext`：

public class HelloWorld {

public static void main(String[] args) {

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

String message = context.getBean("helloWorld", String.class);

System.out.println(message);

}

}

在这个示例中，我们使用`ClassPathXmlApplicationContext`来加载Spring配置文件。通过`getBean`方法，我们可以获取到配置文件中定义的bean。这里我们注入了一个简单的字符串消息。当然，你也可以注入其他类型的bean，只需更改`getBean`方法的参数即可。

5. 运行程序

最后，运行Java程序。你应该会看到输出：“Hello, World!”。这意味着我们成功地使用Spring框架创建了一个简单的应用程序。

3. 使用Spring IoC实现JavaBean注入

通过Spring IoC容器，我们可以将JavaBean的创建和依赖关系的管理交给框架来处理，从而实现依赖注入。

在Spring框架中，IoC（Inversion of Control）是一个核心概念，它可以帮助我们实现JavaBean的自动注入，从而降低代码的耦合性和提高开发效率。本文将介绍如何使用Spring IoC来实现JavaBean的注入。

1.定义JavaBean

首先，我们需要定义一个JavaBean类，例如一个名为User的类。这个类需要具备一些属性和对应的Getter/Setter方法，以便在注入时可以进行属性赋值。

public class User {

private String username;

private int age;

// Getter/Setter方法省略...

}

2.配置Spring容器

接下来，我们需要配置Spring IoC容器，告诉它哪些Bean需要被创建和注入。通常，我们会使用XML配置文件或注解来完成配置。

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>

</beans>

在上述示例中，我们定义了一个id为"user"的Bean，其类为com.example.User，并通过property来设置username和age属性的值。

3.加载Spring容器

在程序中，我们需要加载Spring容器以获取被管理的Bean。可以使用ApplicationContext来加载容器并获取Bean的实例。

import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class Main {

public static void main(String[] args) {

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

User user = (User) context.getBean("user"); // 根据id获取Bean实例 System.out.println("Username: " + user.getUsername());

System.out.println("Age: " + user.getAge());

}

在上述示例中，我们通过ClassPathXmlApplicationContext加载了名为"applicationContext.xml"的配置文件，并通过getBean方法获取了id为"user"的Bean实例。最后，我们可以打印出User对象的属性值。

4.运行结果

如果一切配置正确，运行程序将输出以下结果：

Username: John

Age: 25

这表明我们成功地通过Spring IoC容器实现了JavaBean的注入。

总结

本文介绍了如何使用Spring IoC实现JavaBean注入。通过配置Spring容器，我们可以将Bean的创建和属性的赋值交给框架处理，从而降低了代码的耦合性和提高了开发效率。通过合理配置和使用Spring IoC，我们能够更好地管理和利用JavaBean，使得应用程序更加灵活、易于维护。

三、Spring AOP

Spring AOP是Spring框架中非常重要的功能之一，它通过将通用逻辑封装成切面（Aspect），并与核心业务逻辑分离，从而提高系统的可维护性和扩展性。通过合理使用AOP，我们可以更好地实现代码复用、降低代码耦合度，并提高代码的质量。

1. 什么是AOP

AOP（Aspect-Oriented Programming）面向切面编程，是一种能够在程序运行期间动态地将额外代码织入到现有代码中的编程范式。它提供了一种非常灵活的机制，用于解决系统中横切关注点（如日志、事务管理等）的问题。

AOP（Aspect-Oriented Programming）是一种与面向对象编程相对的编程范式。它的核心思想是通过将横切关注点（cross-cutting concerns）与核心业务逻辑分离，降低代码的复杂度和提高代码的模块化程度。

在传统的面向对象编程中，一个类通常有一个明确的职责，但随着系统的需求变化和业务流程的增加，很容易导致一个类变得臃肿不堪，难以维护。AOP就是为了解决这个问题而生的。

AOP实际上是一种横切式技术，它可以在运行时动态地将额外的代码“织入”到现有的代码中，从而实现各种不同的横切关注点，例如：日志记录、安全授权、性能监控、事务管理等。

2. Spring AOP在项目中的运用

Spring框架提供了强大的AOP支持，可以通过AOP实现诸如日志记录、性能监控、事务管理等横切关注点的功能，提高了系统的可维护性和扩展性。

Spring AOP（Aspect-Oriented Programming）是Spring框架中非常重要的功能之一，它通过将横切关注点与核心业务逻辑分离，提供了一种优雅而可维护的方式来处理通用逻辑。在项目开发中，合理地应用Spring AOP可以提高代码的模块化程度、降低耦合度，并增强系统的可扩展性和维护性。

一、日志记录

在项目中，日志记录是一个常见且重要的需求。通过使用Spring AOP，我们可以将日志记录作为一个横切关注点，封装成一个独立的切面。这样，无论是在哪个业务方法中，只需在切面中定义相应的日志记录逻辑即可，大大减少了代码冗余，同时也方便了日志记录的管理和维护。

二、安全授权

安全授权是项目中必不可少的一环。通过Spring AOP，我们可以将安全授权逻辑作为一个横切关注点，集中管理和控制授权策略。例如，可以通过AOP对所有需要身份验证的请求进行统一处理，确保只有授权用户才能执行相关操作，从而提高系统的安全性。

三、性能监控

在开发过程中，我们经常需要监控系统的性能，例如方法的执行时间、内存的使用情况等。利用Spring AOP，我们可以很容易地将性能监控作为一个横切关注点来处理。通过在切面中添加相应的性能监控逻辑，可以方便地统计和分析系统的性能数据，帮助我们快速发现和解决潜在的性能问题。

四、事务管理

事务管理是大多数项目必不可少的一部分。Spring AOP可以将事务管理作为一个横切关注点进行处理，从而实现事务的统一管理和控制。通过将事务逻辑封装成切面，在需要进行事务管理的方法上添加相应的切点，可以轻松地实现声明式的事务控制，减少了重复编写事务管理代码的工作量，同时也提高了代码的可读性和可维护性。