【详解】Spring之—ApplicationListener接口及事务管理

原创

大盘鸡拌面

发布于 2025-09-09 21:12:55

6600

代码可运行

运行总次数：0

代码可运行

Spring之—ApplicationListener接口及事务管理

在Spring框架中，ApplicationListener 接口和事务管理是两个非常重要的概念。本文将详细介绍这两个概念，并通过示例来展示如何在实际开发中应用它们。

1. ApplicationListener接口

1.1 概述

ApplicationListener 是Spring框架中的一个接口，用于监听Spring容器中的事件。当容器中发生特定的事件时，实现了ApplicationListener接口的类可以接收到这些事件并作出相应的处理。这使得开发者可以在特定事件发生时执行自定义的逻辑，如日志记录、资源清理等。

1.2 实现ApplicationListener

要实现ApplicationListener，首先需要创建一个类并实现该接口。ApplicationListener接口有一个方法onApplicationEvent，该方法会在监听到事件时被调用。

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextStartedEvent;

public class CustomApplicationListener implements ApplicationListener<ContextStartedEvent> {
    @Override
    public void onApplicationEvent(ContextStartedEvent event) {
        System.out.println("应用上下文启动事件: " + event.getApplicationContext().getId());
    }
}

在这个例子中，我们创建了一个CustomApplicationListener类，它实现了ApplicationListener接口，并指定了监听的事件类型为ContextStartedEvent。当Spring容器启动时，onApplicationEvent方法会被调用。

1.3 注册监听器

实现ApplicationListener接口后，还需要将监听器注册到Spring容器中。可以通过在配置文件中声明或使用注解来完成这一操作。

使用XML配置

<bean id="customApplicationListener" class="com.example.CustomApplicationListener"/>

使用注解

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

@Configuration
public class AppConfig {
    @Bean
    public CustomApplicationListener customApplicationListener() {
        return new CustomApplicationListener();
    }
}

2. 事务管理

2.1 概述

事务管理是确保数据库操作一致性的重要机制。Spring框架提供了强大的事务管理功能，支持编程式和声明式两种事务管理方式。

2.2 编程式事务管理

编程式事务管理通过编写代码来控制事务的开始、提交和回滚。这种方式提供了更大的灵活性，但代码复杂度较高。

import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

public class UserService {
    private DataSourceTransactionManager transactionManager;

    public void addUser(User user) {
        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
        try {
            // 执行添加用户的业务逻辑
            transactionManager.commit(status);
        } catch (Exception e) {
            transactionManager.rollback(status);
        }
    }
}

2.3 声明式事务管理

声明式事务管理通过配置来管理事务，简化了事务管理的代码。Spring支持通过XML配置或注解来实现声明式事务管理。

使用XML配置

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="addUser" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

<aop:config>
    <aop:pointcut id="userServiceMethods" expression="execution(* com.example.UserService.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="userServiceMethods"/>
</aop:config>

使用注解

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Transactional
    public void addUser(User user) {
        // 执行添加用户的业务逻辑
    }
}

2.4 事务传播行为

Spring框架支持多种事务传播行为，常见的有：

REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则暂停当前事务。
SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务方式执行。
NOT_SUPPORTED：以非事务方式执行，如果当前存在事务，则暂停当前事务。
MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。
NESTED：如果当前存在事务，则在嵌套事务内执行；如果当前没有事务，则创建一个新的事务。

ApplicationListener接口和事务管理是Spring框架中非常实用的功能。通过实现ApplicationListener，我们可以监听并响应Spring容器中的各种事件，而通过Spring的事务管理机制，我们可以更方便地管理数据库操作的一致性和完整性。希望本文能帮助你更好地理解和使用这两个功能。

下面我将分别介绍 ApplicationListener 接口和 Spring 事务管理，并提供相应的示例代码。

1. ApplicationListener 接口

ApplicationListener 是一个接口，用于监听 Spring 应用上下文中的事件。当某个事件发生时，实现了 ApplicationListener 接口的类会接收到该事件并进行处理。

示例场景：用户注册后发送欢迎邮件

假设我们有一个用户注册功能，当用户成功注册后，我们需要发送一封欢迎邮件。我们可以使用 ApplicationListener 来监听用户注册事件，并在事件触发时发送邮件。

步骤：

定义事件：创建一个自定义事件类。
发布事件：在用户注册成功后发布事件。
监听事件：创建一个监听器类来处理事件。

1.1 定义事件

import org.springframework.context.ApplicationEvent;

public class UserRegisteredEvent extends ApplicationEvent {
    private final String email;

    public UserRegisteredEvent(Object source, String email) {
        super(source);
        this.email = email;
    }

    public String getEmail() {
        return email;
    }
}

1.2 发布事件

在用户注册成功后发布事件：

import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.stereotype.Service;

@Service
public class UserService implements ApplicationEventPublisherAware {
    private ApplicationEventPublisher publisher;

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }

    public void registerUser(String email) {
        // 注册用户的逻辑
        System.out.println("用户 " + email + " 注册成功");

        // 发布事件
        UserRegisteredEvent event = new UserRegisteredEvent(this, email);
        publisher.publishEvent(event);
    }
}

1.3 监听事件

创建一个监听器类来处理事件：

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class UserRegisteredEventListener implements ApplicationListener<UserRegisteredEvent> {
    @Override
    public void onApplicationEvent(UserRegisteredEvent event) {
        String email = event.getEmail();
        System.out.println("发送欢迎邮件给 " + email);
        // 发送邮件的逻辑
    }
}

2. Spring 事务管理

Spring 提供了多种方式来管理事务，包括编程式事务管理和声明式事务管理。声明式事务管理通过注解或 XML 配置来实现，更加简洁和易用。

示例场景：用户转账

假设我们有一个用户转账功能，需要确保转账操作在一个事务中完成，以保证数据的一致性。

步骤：

配置事务管理器：在 Spring 配置文件中配置事务管理器。
使用 @Transactional 注解：在需要事务管理的方法上添加 @Transactional 注解。

2.1 配置事务管理器

在 Spring 配置文件中配置事务管理器：

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

    <!-- 数据源配置 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
        <property name="username" value="root"/>
        <property name="password" value="password"/>
    </bean>

    <!-- JdbcTemplate 配置 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 事务管理器配置 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 启用事务注解 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

2.2 使用 `@Transactional` 注解

在需要事务管理的方法上添加 @Transactional 注解：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class AccountService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Transactional
    public void transferMoney(String fromAccount, String toAccount, double amount) {
        jdbcTemplate.update("UPDATE account SET balance = balance - ? WHERE account_number = ?", amount, fromAccount);
        jdbcTemplate.update("UPDATE account SET balance = balance + ? WHERE account_number = ?", amount, toAccount);
    }
}

Spring框架提供了丰富的功能和工具来简化Java应用的开发，其中ApplicationListener接口和事务管理是两个非常重要的特性。下面我将分别详细介绍这两个概念。

1. `ApplicationListener` 接口

ApplicationListener 是一个事件监听器接口，用于在Spring应用上下文中监听特定类型的事件。通过实现这个接口，你可以自定义事件处理器，从而在特定事件发生时执行某些操作。

基本使用步骤

定义事件：首先，你需要定义一个事件类，通常继承自ApplicationEvent。
实现监听器：然后，实现ApplicationListener接口，并指定要监听的事件类型。
发布事件：在需要的地方使用ApplicationContext的publishEvent方法发布事件。
注册监听器：确保你的监听器被Spring容器管理，可以通过注解或XML配置来实现。

示例代码

定义事件

import org.springframework.context.ApplicationEvent;

public class CustomEvent extends ApplicationEvent {
    private String message;

    public CustomEvent(Object source, String message) {
        super(source);
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

实现监听器

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class CustomEventListener implements ApplicationListener<CustomEvent> {

    @Override
    public void onApplicationEvent(CustomEvent event) {
        System.out.println("Received custom event - " + event.getMessage());
    }
}

发布事件

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;

@Service
public class EventPublisherService {

    @Autowired
    private ApplicationContext context;

    public void publishCustomEvent(String message) {
        CustomEvent event = new CustomEvent(this, message);
        context.publishEvent(event);
    }
}

注册监听器

如果你使用的是Java配置，可以直接使用@Component注解来注册监听器：

import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {
    // 其他配置
}

2. 事务管理

Spring框架提供了强大的事务管理功能，支持声明式事务管理和编程式事务管理。声明式事务管理通过AOP（面向切面编程）技术实现，而编程式事务管理则通过手动控制事务的开始、提交和回滚。

声明式事务管理

声明式事务管理是最常用的事务管理方式，它通过配置文件或注解来管理事务。

使用注解

启用事务管理：在配置类上添加@EnableTransactionManagement注解。
标注事务方法：在需要事务管理的方法上添加@Transactional注解。

示例代码

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

@Configuration
@EnableTransactionManagement
public class AppConfig {

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/yourdb");
        dataSource.setUsername("username");
        dataSource.setPassword("password");
        return dataSource;
    }

    @Bean
    public EntityManagerFactory entityManagerFactory() {
        // 配置EntityManagerFactory
    }

    @Bean
    public JpaTransactionManager transactionManager(EntityManagerFactory emf) {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(emf);
        return transactionManager;
    }
}

标注事务方法

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Transactional
    public void createUser(User user) {
        userRepository.save(user);
        // 模拟异常
        if (true) {
            throw new RuntimeException("Simulated exception");
        }
    }
}

编程式事务管理

编程式事务管理通过手动控制事务的生命周期，适用于需要更细粒度控制的场景。

示例代码

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import javax.sql.DataSource;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private DataSource dataSource;

    public void createUser(User user) {
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager(dataSource);
        TransactionDefinition definition = new DefaultTransactionDefinition();
        TransactionStatus status = transactionManager.getTransaction(definition);

        try {
            userRepository.save(user);
            // 模拟异常
            if (true) {
                throw new RuntimeException("Simulated exception");
            }
            transactionManager.commit(status);
        } catch (Exception e) {
            transactionManager.rollback(status);
        }
    }
}

总结

ApplicationListener接口：用于监听和处理Spring应用上下文中的事件，通过实现该接口并注册到Spring容器中，可以在特定事件发生时执行自定义逻辑。
事务管理：Spring提供了声明式和编程式两种事务管理方式，声明式事务管理通过注解和配置文件实现，编程式事务管理通过手动控制事务的生命周期实现。

希望这些介绍对你有所帮助！如果有任何问题或需要进一步的细节，请随时提问。

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

腾讯技术创作特训营S15#自选日志

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

腾讯技术创作特训营S15#自选日志

登录后参与评论

0 条评论

热度