【Spring】面向对象编程的Java框架

科马

于 2024-08-22 16:46:18 发布

阅读量447

点赞数 9

文章标签： java spring

本文链接：https://blog.csdn.net/weixin_63405049/article/details/141430063

版权

SpringIOC

一，理解Spring
二，Spring IOC
总结

一，理解Spring

Spring 框架简介

Spring 是一个功能强大且广泛使用的开源Java框架，旨在简化企业级应用程序的开发。它最初由Rod Johnson于2003年发布，通过提供一组全面的功能，使得Java开发更为灵活、模块化和易于维护。Spring的核心理念是依赖注入（Dependency Injection, DI）和面向切面编程（Aspect-Oriented Programming, AOP），这些特性帮助开发者构建松耦合的应用程序。

核心特征

依赖注入（Dependency Injection, DI）：
• 依赖注入是Spring的核心概念之一，它允许开发者将对象的依赖关系从代码中分离出来，通过配置文件或注解进行管理。这种方式降低了代码的耦合性，增加了代码的灵活性和可测试性。
面向切面编程（Aspect-Oriented Programming, AOP）：
• AOP允许开发者将横切关注点（如日志记录、事务管理、安全等）分离出来，集中处理。通过AOP，开发者可以在不改变业务逻辑代码的情况下，添加额外的功能。
数据访问（Spring Data）：
• Spring提供了与多种持久层技术的集成，如JDBC、Hibernate、JPA等。它通过Spring Data模块简化了数据访问层的开发，减少了重复代码的编写。
事务管理：
• Spring支持声明式事务管理，使得开发者可以通过简单的配置或注解来控制事务的边界，而无需在业务代码中手动管理事务。
Spring MVC：
• Spring MVC是Spring框架的一部分，用于构建Web应用程序。它基于Model-View-Controller模式，提供了一个灵活且易于扩展的Web开发框架。
Spring Boot：
• Spring Boot是Spring生态系统中的一个项目，旨在简化基于Spring的应用程序开发。它通过自动配置、大量的开箱即用的功能和内置的服务器（如Tomcat）帮助开发者快速启动项目。
Spring Security：
• Spring Security提供了全面的安全功能，包括认证、授权、密码加密、跨站点请求伪造（CSRF）保护等，是构建安全的企业级应用的首选框架。
Spring Cloud：
• Spring Cloud为分布式系统的开发提供了一系列工具和服务，如服务发现、配置管理、负载均衡、断路器等，帮助开发者构建微服务架构。

优势与适用场景

主要优势：

模块化设计：Spring框架由多个模块组成，开发者可以根据需求选择需要的模块，而不必加载整个框架。
丰富的生态系统：Spring拥有一个庞大的生态系统和活跃的社区，提供了大量的扩展和第三方集成。
简化开发：通过依赖注入和AOP，Spring简化了复杂的企业级开发，降低了代码的复杂性。
高度可测试性：Spring的设计理念使得应用程序的单元测试和集成测试更加方便。

适用场景：

Spring框架适用于各类Java应用的开发，无论是小型的Web应用，还是复杂的企业级分布式系统。它特别适合需要高度灵活性和可扩展性的项目。

二，Spring IOC

介绍

Spring IoC（Inversion of Control）是Spring框架的核心概念之一，通常翻译为“控制反转”。它是依赖注入（Dependency Injection, DI）实现的基础，主要用于管理对象的创建、配置和整个应用程序的生命周期。

控制反转

这里我们就需要了解一下何为”控制反转“

控制反转指的是将对象的创建和依赖关系的管理从应用程序代码中分离出来，交给Spring框架来处理。在传统的编程模式中，应用程序代码负责创建对象并管理对象之间的依赖关系，而在Spring的IoC容器中，这一过程被反转了：应用程序不再负责这些任务，而是由Spring容器接管。

让我们通过一个简单的例子来理解控制反转（IoC）在Spring中的实现。

比如：邮件服务

假设我们要构建一个简单的应用程序，其中包含一个邮件服务 EmailService，用于发送电子邮件。我们还需要一个客户端类 UserService 来使用这个邮件服务。

要用传统方法的话，在没有使用控制反转的情况下，UserService 类需要自己创建 EmailService 对象。这种方式下，UserService 直接依赖 EmailService，因此两者之间紧密耦合。

public class EmailService {
    public void sendEmail(String message) {
        System.out.println("Sending email: " + message);
    }
}

// UserService.java
public class UserService {
    private EmailService emailService;

    public UserService() {
        // 直接在构造方法中创建EmailService对象
        this.emailService = new EmailService();
    }

    public void registerUser(String username) {
        // 业务逻辑
        System.out.println("User registered: " + username);
        emailService.sendEmail("Welcome " + username + "!");
    }
}

这时候我们可以通过Spring的IoC容器，我们可以将 EmailService 的创建

和依赖注入交给Spring管理，而不是让 UserService 自己去创建对象。这可以降低类之间的耦合性。

首先配置Spring Bean（使用Java配置类）

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public EmailService emailService() {
        return new EmailService();
    }

    @Bean
    public UserService userService() {
        return new UserService(emailService());
    }
}

然后修改 UserService 类（使用构造器注入）

public class EmailService {
    public void sendEmail(String message) {
        System.out.println("Sending email: " + message);
    }
}

// UserService.java
public class UserService {
    private final EmailService emailService;

    // 通过构造器注入EmailService
    public UserService(EmailService emailService) {
        this.emailService = emailService;
    }

    public void registerUser(String username) {
        // 业务逻辑
        System.out.println("User registered: " + username);
        emailService.sendEmail("Welcome " + username + "!");
    }
}

最后使用Spring IoC容器创建对象并注入依赖

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        // 创建Spring IoC容器，并加载配置
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        // 获取UserService Bean，并使用它
        UserService userService = context.getBean(UserService.class);
        userService.registerUser("John Doe");
    }
}

这里我们比较可以发现传统方式UserService 直接创建 EmailService 对象。这意味着如果我们想更换 EmailService 的实现方式，必须修改 UserService 类的代码。这种设计导致类之间紧密耦合，灵活性差。

而我们通过控制反转方式：通过Spring的IoC容器，UserService 不再自己创建 EmailService，而是通过构造器注入的方式由Spring容器提供。这种方式下，如果我们想更换 EmailService 的实现，只需修改配置，而不需要改变业务逻辑代码。这样降低了类之间的耦合度，提高了代码的可维护性和扩展性。

因此我们就可以得到这个结论：控制反转通过将对象的创建和依赖关系的管理交给Spring IoC容器，从而让应用程序更加灵活、模块化。

依赖倒置原则

其实在了解控制反转之前，我们一定会接触一个面向对象的设计原则：依赖倒置
依赖倒置原则有两个主要定义：

1.	高层模块不应该依赖于低层模块。两者都应该依赖于抽象。
2.	抽象不应该依赖于细节。细节应该依赖于抽象。

换句话说，依赖倒置原则要求我们：

•	使用接口或抽象类 来定义高层模块（业务逻辑）的依赖，而不是直接依赖具体的实现类。
•	具体的实现类 应该实现接口或继承抽象类，从而将细节依赖于抽象。

其实用大白话来说，就是我们干活都应该去听上层的意见，我们决策不了上层的想法，上层传达到需求后，我们再将内容一一实现。

总而言之，依赖倒置原则是实现模块间解耦的关键设计原则。通过依赖于抽象而不是具体实现，开发者可以构建更灵活、可扩展、可测试的系统。这一原则在实际开发中广泛应用，尤其是在大型和复杂的系统中，能显著提高代码的质量和可维护性。

依赖注入

最后我们来说一下依赖注入，何为依赖注入呢，百度一下我们能知道：

依赖注入是一种实现控制反转（Inversion of Control, IoC）的设计模式，广泛应用于面向对象编程中，尤其是在Spring等框架中。其核心思想是将对象的依赖关系从类内部移到外部，通过构造器、方法或字段注入的方式由外部容器（如Spring IoC容器）负责注入依赖对象。

在传统的编程模式中，类通常会自己创建依赖对象，导致类之间的耦合度较高。如果依赖关系或依赖对象发生变化，需要修改类的代码。依赖注入通过将依赖对象的创建和管理交给外部容器，解除了这种耦合，使得代码更加灵活和易于维护。

依赖注入分为三种基本方式：

构造器注入（Constructor Injection）：
• 通过构造器将依赖对象传递给需要依赖的类。这种方式保证了依赖在对象创建时就被注入，因此类总是处于一种有效的状态。

public class UserService {
    private final EmailService emailService;

    // 依赖通过构造器注入
    public UserService(EmailService emailService) {
        this.emailService = emailService;
    }

    public void registerUser(String username) {
        emailService.sendEmail("Welcome " + username);
    }
}

Setter方法注入（Setter Injection）：
• 通过Setter方法将依赖对象注入类中。这种方式允许在对象创建后注入或更改依赖，提供了一定的灵活性。

public class UserService {
    private EmailService emailService;

    // 依赖通过Setter方法注入
    public void setEmailService(EmailService emailService) {
        this.emailService = emailService;
    }

    public void registerUser(String username) {
        emailService.sendEmail("Welcome " + username);
    }
}

字段注入（Field Injection）：
• 直接将依赖对象注入到类的字段中，通常通过注解（如Spring中的@Autowired）实现。虽然这种方式使用起来很方便，但它可能会导致类过于依赖外部容器，降低代码的可测试性。

public class UserService {
    @Autowired
    private EmailService emailService;

    public void registerUser(String username) {
        emailService.sendEmail("Welcome " + username);
    }
}

总结

Spring IoC、依赖注入、依赖倒置、IoC容器这几个概念紧密相关，共同构成了Spring框架的核心思想。

依赖倒置 是一种设计原则，提倡模块之间依赖抽象而不是具体实现，以实现解耦。
依赖注入 是实现依赖倒置的具体技术，通过外部注入方式将依赖对象传递给类，而不在类内部直接创建依赖对象。
控制反转（IoC） 是一种设计思想，通过将对象的控制权转移到外部容器，应用程序的依赖关系管理被外部接管。
IoC容器 是Spring框架中实现控制反转和依赖注入的核心组件。它管理应用程序中所有Bean的创建、配置和依赖注入，实现模块之间的解耦。

具体关系应该参照这张图来解释：关系图
这些概念相互作用，共同支持了Spring框架的核心功能，使得Java应用开发更加灵活、模块化和易于维护。

科马

关注

9
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
【Spring】面向对象编程的Java框架

Spring 是一个功能强大且广泛使用的开源Java框架，旨在简化企业级应用程序的开发。它最初由Rod Johnson于2003年发布，通过提供一组全面的功能，使得Java开发更为灵活、模块化和易于维护。Spring的核心理念是依赖注入（Dependency Injection, DI）和面向切面编程（Aspect-Oriented Programming, AOP），这些特性帮助开发者构建松耦合的应用程序。
复制链接

扫一扫