初识Spring框架

Spring IOC（控制反转）是Spring框架的核心概念之一，它通过将对象的创建和依赖关系的管理交由Spring容器来完成，从而降低了组件之间的耦合度，提高了代码的灵活性和可测试性

接口 MessageService 和它的两个实现类 EmailService 和 SMSService：

public interface MessageService {
    void sendMessage(String message);
}

public class EmailService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("Sending email: " + message);
    }
}

public class SMSService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("Sending SMS: " + message);
    }
}

然后我们有一个使用 MessageService 的服务类 MessageProcessor：

public class MessageProcessor {
    private MessageService messageService;

    // 构造器注入
    public MessageProcessor(MessageService messageService) {
        this.messageService = messageService;
    }

    public void processMessage(String message) {
        // 使用MessageService发送消息
        messageService.sendMessage(message);
    }
}

在Spring中配置这些类，可以通过XML配置文件或者注解方式来实现IOC。这里演示使用XML配置文件的方式：

<!-- 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">

    <!-- 配置EmailService -->
    <bean id="emailService" class="com.example.EmailService" />

    <!-- 配置SMSService -->
    <bean id="smsService" class="com.example.SMSService" />

    <!-- 配置MessageProcessor，使用构造器注入 -->
    <bean id="messageProcessor" class="com.example.MessageProcessor">
        <constructor-arg ref="emailService" /> <!-- 传入emailService作为依赖 -->
    </bean>

</beans>

这种方式使得应用程序的各个组件更加解耦和灵活，也更易于进行单元测试和维护。

Spring依赖的jar包有：

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-beans</artifactId>
  <version>5.2.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.2.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-core</artifactId>
  <version>5.2.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-expression</artifactId>
  <version>5.2.2.RELEASE</version>
</dependency>

 

 

在Spring框架中，使用IOC（控制反转）来实现JavaBean的注入是核心功能之一

1. 创建JavaBean

首先，我们需要定义一个JavaBean。假设我们有一个 UserService 类，它依赖于 UserRepository 类。

// UserRepository.java
public class UserRepository {
    public void save() {
        System.out.println("User saved");
    }
}

// UserService.java
public class UserService {
    private UserRepository userRepository;

    // 通过构造函数注入
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void performService() {
        userRepository.save();
    }
}

2. 配置Spring容器

我们需要配置Spring容器来管理这些Bean的创建和依赖注入。可以使用XML配置文件或Java配置类。

2.1 XML配置

创建一个Spring XML配置文件 applicationContext.xml：

<!-- 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">

    <!-- 定义 UserRepository bean -->
    <bean id="userRepository" class="com.example.UserRepository"/>

    <!-- 定义 UserService bean，并注入 UserRepository -->
    <bean id="userService" class="com.example.UserService">
        <constructor-arg ref="userRepository"/>
    </bean>

</beans>

2.2 Java配置

使用Java配置类的方式来定义和注入Bean：

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

@Configuration
public class AppConfig {

    @Bean
    public UserRepository userRepository() {
        return new UserRepository();
    }

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

3. 启动Spring容器并使用Bean

我们可以通过ApplicationContext来启动Spring容器并获取Bean。

3.1 XML配置方式

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");
        UserService userService = (UserService) context.getBean("userService");
        userService.performService();
    }
}

3.2 Java配置方式

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

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        UserService userService = context.getBean(UserService.class);
        userService.performService();
    }
}

总结

通过上述步骤，我们演示了如何使用Spring IOC容器实现JavaBean的注入。无论是通过XML配置还是Java配置，Spring都可以帮助我们管理Bean的生命周期和依赖关系，从而简化代码并提高可维护性。