首页手记 Spring入门：新手必看的简单教程

Spring入门：新手必看的简单教程

标签：

Spring

概述

Spring入门介绍了Spring框架的基本概念、核心特性和优势，涵盖了开发环境的搭建、Bean管理、依赖注入以及Spring的AOP编程和事务管理等关键内容。文章详细讲解了如何配置和使用Spring框架的各项功能，帮助读者快速掌握Spring框架的使用方法。

Spring框架简介

Spring框架的基本概念

Spring框架是一个开源的Java应用程序框架，它简化了Java企业应用程序开发的复杂度。Spring最初是为了解决企业级应用开发的复杂性而设计的，通过提供一个独立于特定数据库、Web服务器和中间件的综合的解决方案，Spring帮助企业开发者迅速开发出高质量的应用程序。

Spring框架的核心特性包括：

依赖注入（Dependency Injection，DI）：Spring框架的核心特性之一，它允许在运行时动态地将依赖关系注入到对象中。
面向切面编程（Aspect Oriented Programming，AOP）：Spring框架支持AOP，使开发者可以将横切关注点（如日志、事务管理等）以方面的方式实现。
声明式事务管理：通过声明式事务管理，可以简化事务处理的代码，提高代码的重用性。
模版类：Spring框架提供了多种模版类，如JDBC、Hibernate、JPA等，旨在减少样板代码的编写。
Web框架：Spring Web MVC框架可以用于创建Web应用程序，它提供了非常丰富的功能，如请求映射、数据绑定、表单验证等。

Spring框架的优势和应用场景

优势

轻量级：Spring框架的核心是轻量级的，它的大多数核心功能只需要Java SE，而不需要Java EE的支持。
非侵入式设计：Spring框架的非侵入性设计使它能够与现有的Java应用程序无缝集成。
依赖注入：依赖注入使Spring可以将对象的依赖关系在外部配置，而不是在代码中硬编码。
面向切面编程：Spring框架提供了AOP支持，使横切关注点可以分离到单独的方面中。
声明式事务管理：Spring框架的声明式事务管理使事务处理代码更加简洁。
模版类：Spring框架提供了多种模版类，如JDBC、Hibernate、JPA等，简化了开发过程。
Web框架：Spring Web MVC框架提供了丰富的功能，如请求映射、数据绑定、表单验证等。

应用场景

企业级应用开发：Spring框架适用于开发复杂的企业级应用程序，它可以处理各种复杂性，如事务管理、安全控制、持久化、Web服务等。
Web开发：Spring Web MVC框架提供了丰富的功能，使Web应用开发更加简单。
服务层开发：Spring框架可以用于开发服务层，提供业务逻辑的实现。
数据访问：Spring框架提供了多种模版类，简化了数据访问的代码编写。
消息传递：Spring框架支持消息传递，如JMS、AMQP等。

开发环境搭建

要开始使用Spring框架，首先需要搭建开发环境。以下是一些常用的开发工具和库：

Java开发工具：如Eclipse、IntelliJ IDEA等。
Java开发环境：如JDK 1.8或更高版本。
Maven：Maven是一个强大的项目管理和构建工具，可以方便地管理项目依赖。
Spring框架：Spring框架的核心库和其他扩展库。

安装Maven

下载并安装Maven，确保Maven的mvn命令可以访问。
配置JAVA_HOME和MAVEN_HOME环境变量。
在PATH环境变量中添加%JAVA_HOME%\bin和%MAVEN_HOME%\bin。

创建Maven项目

使用Maven创建一个新的项目，以下是一个创建Spring项目的基本步骤：

打开命令行，执行以下命令创建一个Maven项目：

mvn archetype:generate -DgroupId=com.example -DartifactId=spring-demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

创建完成后，进入项目目录：
```
cd spring-demo
```

在pom.xml文件中添加Spring依赖：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>spring-demo</artifactId>
  <version>1.0.0-SNAPSHOT</version>
  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.3.10</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.3.10</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>5.3.10</version>
    </dependency>
  </dependencies>
</project>

使用IDE打开项目进行开发。

安装IDEA

如果使用IDEA开发Spring项目，以下是一些配置步骤：

下载并安装IntelliJ IDEA。
打开IntelliJ IDEA，选择File > New > Project。
选择Maven模板，填写Group Id和Artifact Id，点击Next。
选择Java版本，点击Next。
填写项目名称，选择项目位置，点击Finish。
在pom.xml文件中添加Spring依赖。
在src/main/java目录下创建一个新类，编写Spring相关的代码。

总结

以上步骤介绍了如何搭建Spring开发环境。通过配置Maven和IDE，可以快速开始Spring项目开发。接下来，我们将介绍如何使用Spring核心容器管理Bean。

使用Spring核心容器管理Bean

Bean的定义和配置

Bean的定义

Spring框架通过配置Bean来管理对象的生命周期和依赖关系。Bean是Spring容器管理的对象，它可以是任何Java对象。

Bean的配置

Bean的配置可以通过以下两种方式实现：

XML配置：
- 通过<bean>标签定义Bean。
- 使用<property>标签注入依赖。
注解配置：
- 使用@Component、@Service、@Repository等注解标记Bean。
- 使用@Autowired注解注入依赖。

XML配置示例

<bean id="helloWorld" class="com.example.HelloWorld">
    <property name="message" value="Hello, World!" />
</bean>

注解配置示例

package com.example;

import org.springframework.stereotype.Component;

@Component
public class HelloWorld {
    private String message;

    public HelloWorld() {
    }

    public HelloWorld(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class HelloWorldService {
    private HelloWorld helloWorld;

    @Autowired
    public HelloWorldService(HelloWorld helloWorld) {
        this.helloWorld = helloWorld;
    }

    public void sayHello() {
        System.out.println(helloWorld.getMessage());
    }
}

Bean的生命周期

Spring框架控制Bean的整个生命周期，包括实例化、属性设置、初始化、使用、销毁等阶段。Spring提供了多个生命周期回调方法，如@PostConstruct、@PreDestroy等。

生命周期回调方法示例

package com.example;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import org.springframework.stereotype.Component;

@Component
public class HelloWorld {
    public HelloWorld() {
        System.out.println("HelloWorld instance is created");
    }

    @PostConstruct
    public void init() {
        System.out.println("HelloWorld is initialized");
    }

    public void hello() {
        System.out.println("Hello, World!");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("HelloWorld is destroyed");
    }
}

总结

通过上述示例，我们可以看到如何在Spring中定义和配置Bean。接下来，我们将详细介绍依赖注入的概念和用法。

依赖注入

依赖注入的基本概念

依赖注入（Dependency Injection，DI）是Spring框架的核心特性之一，它允许在运行时动态地将依赖关系注入到对象中。依赖注入有三种实现方式：构造器注入、Setter注入和接口注入。

构造器注入

构造器注入通过构造函数传递依赖关系。Spring框架会在创建Bean时注入依赖。

构造器注入示例

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class HelloWorldService {
    private HelloWorld helloWorld;

    @Autowired
    public HelloWorldService(HelloWorld helloWorld) {
        this.helloWorld = helloWorld;
    }

    public void sayHello() {
        System.out.println(helloWorld.getMessage());
    }
}

Setter注入

Setter注入通过Setter方法传递依赖关系。Spring框架会在创建Bean后调用Setter方法注入依赖。

Setter注入示例

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class HelloWorldService {
    private HelloWorld helloWorld;

    @Autowired
    public void setHelloWorld(HelloWorld helloWorld) {
        this.helloWorld = helloWorld;
    }

    public void sayHello() {
        System.out.println(helloWorld.getMessage());
    }
}

接口注入

接口注入是通过定义接口实现依赖注入。Spring框架会在创建Bean时调用接口方法注入依赖。

接口注入示例

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class HelloWorldService implements HelloWorldServiceInterface {

    private HelloWorld helloWorld;

    @Autowired
    public void init(HelloWorld helloWorld) {
        this.helloWorld = helloWorld;
    }

    public void sayHello() {
        System.out.println(helloWorld.getMessage());
    }
}

interface HelloWorldServiceInterface {
    void init(HelloWorld helloWorld);
}

总结

通过上述示例，我们可以看到如何使用不同的方式实现依赖注入。接下来，我们将详细介绍Spring的自动装配功能。

Spring的自动装配功能

了解自动装配的用法

自动装配是Spring框架提供的一个特性，它允许Spring容器自动地装配依赖关系。自动装配通过@Autowired注解实现，它可以自动地将Bean注入到另一个Bean中。

自动装配的用法

单个Bean：如果只有一个Bean匹配，则自动装配会成功。
多个Bean：如果存在多个Bean匹配，则需要使用@Qualifier注解指定具体的Bean。
缺少Bean：如果找不到匹配的Bean，则会抛出异常。

示例代码

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class HelloWorldService {
    private HelloWorld helloWorld;

    @Autowired
    public HelloWorldService(HelloWorld helloWorld) {
        this.helloWorld = helloWorld;
    }

    public void sayHello() {
        System.out.println(helloWorld.getMessage());
    }
}

实现自动装配示例

单个Bean的自动装配

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class HelloWorldService {
    private HelloWorld helloWorld;

    @Autowired
    public HelloWorldService(HelloWorld helloWorld) {
        this.helloWorld = helloWorld;
    }

    public void sayHello() {
        System.out.println(helloWorld.getMessage());
    }
}

多个Bean的自动装配

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

@Component
public class HelloWorldService {
    private HelloWorld helloWorld;

    @Autowired
    public HelloWorldService(@Qualifier("helloWorldBean1") HelloWorld helloWorld) {
        this.helloWorld = helloWorld;
    }

    public void sayHello() {
        System.out.println(helloWorld.getMessage());
    }
}

@Component
public class HelloWorldBean1 {
    private String message = "Hello, World1!";
}

@Component
public class HelloWorldBean2 {
    private String message = "Hello, World2!";
}

缺少Bean的自动装配

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class HelloWorldService {
    private HelloWorld helloWorld;

    @Autowired
    public HelloWorldService(HelloWorld helloWorld) {
        this.helloWorld = helloWorld;
    }

    public void sayHello() {
        System.out.println(helloWorld.getMessage());
    }
}

总结

通过上述示例，我们可以看到如何使用自动装配功能。接下来，我们将详细介绍Spring依赖注入的实践。

Spring依赖注入的实践

通过XML配置依赖注入

Spring依赖注入可以通过XML配置实现。在XML配置文件中，使用<bean>标签定义Bean，并通过<property>标签注入依赖。

XML配置示例

定义Bean

<bean id="helloWorld" class="com.example.HelloWorld">
    <property name="message" value="Hello, World!" />
</bean>

注入依赖

<bean id="helloWorldService" class="com.example.HelloWorldService">
    <property name="helloWorld" ref="helloWorld" />
</bean>

示例代码

<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">
        <property name="message" value="Hello, World!" />
    </bean>

    <bean id="helloWorldService" class="com.example.HelloWorldService">
        <property name="helloWorld" ref="helloWorld" />
    </bean>

</beans>

package com.example;

public class HelloWorld {
    private String message;

    public HelloWorld() {
    }

    public HelloWorld(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class HelloWorldService {
    private HelloWorld helloWorld;

    @Autowired
    public HelloWorldService(HelloWorld helloWorld) {
        this.helloWorld = helloWorld;
    }

    public void sayHello() {
        System.out.println(helloWorld.getMessage());
    }
}

总结

通过上述示例，我们可以看到如何通过XML配置实现依赖注入。接下来，我们将介绍如何通过注解实现依赖注入。

通过注解实现依赖注入

Spring依赖注入也可以通过注解实现。Spring提供了@Autowired注解，可以自动地注入依赖关系。

注解注入示例

注解注入Bean

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class HelloWorldService {
    private HelloWorld helloWorld;

    @Autowired
    public HelloWorldService(HelloWorld helloWorld) {
        this.helloWorld = helloWorld;
    }

    public void sayHello() {
        System.out.println(helloWorld.getMessage());
    }
}

示例代码

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class HelloWorldService {
    private HelloWorld helloWorld;

    @Autowired
    public HelloWorldService(HelloWorld helloWorld) {
        this.helloWorld = helloWorld;
    }

    public void sayHello() {
        System.out.println(helloWorld.getMessage());
    }
}

package com.example;

import org.springframework.stereotype.Component;

@Component
public class HelloWorld {
    private String message = "Hello, World!";

    public HelloWorld() {
    }

    public HelloWorld(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

总结

通过上述示例，我们可以看到如何通过注解实现依赖注入。接下来，我们将详细介绍Spring AOP（面向切面编程）。

Spring AOP（面向切面编程）

AOP的基本概念

面向切面编程（Aspect Oriented Programming，AOP）是一种编程范式，它将横切关注点（如日志、事务管理、安全控制等）与业务逻辑分离，通过自定义的方面（Aspect）来处理这些关注点。Spring框架提供了强大的AOP支持，使开发者可以方便地实现AOP编程。

AOP术语

切面（Aspect）：横切关注点的模块，包含了多个通知（Advice）。
通知（Advice）：定义何时执行切面中的代码，可以是前置通知、后置通知等。
连接点（Joinpoint）：程序执行过程中的一个点，如方法调用或异常抛出。
切入点（Pointcut）：匹配连接点的表达式，如execution(* com.example.*.*(..))。
引入（Introduction）：向现有类添加方法或属性。
织入（Weaving）：将切面应用到目标对象，织入可以在编译时、类加载时或运行时进行。

使用Spring实现AOP

AOP配置示例

定义切面

package com.example;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {
    @Pointcut("execution(* com.example.*.*(..))")
    public void allMethods() {}

    @Before("allMethods()")
    public void logBefore() {
        System.out.println("Logging before method call");
    }
}

示例代码

package com.example;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {
    @Pointcut("execution(* com.example.*.*(..))")
    public void allMethods() {}

    @Before("allMethods()")
    public void logBefore() {
        System.out.println("Logging before method call");
    }
}

package com.example;

public class HelloWorldService {
    public void sayHello() {
        System.out.println("Hello, World!");
    }
}

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class HelloWorldService {
    public void sayHello() {
        System.out.println("Hello, World!");
    }
}

运行结果

package com.example;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        HelloWorldService service = context.getBean(HelloWorldService.class);
        service.sayHello();
    }
}

总结

通过上述示例，我们可以看到如何在Spring中实现AOP编程。接下来，我们将介绍Spring与事务管理。

Spring与事务管理

事务管理的基本概念

事务管理是企业级应用程序开发中的重要特性，它可以确保数据的一致性和完整性。Spring框架提供了声明式事务管理，使事务处理代码更加简洁。

事务管理的特性

原子性：事务是一个不可分割的工作单元，要么全部执行，要么全部不执行。
一致性：事务执行前后，数据库从一个一致性状态转换到另一个一致性状态。
隔离性：事务的执行不受其他事务的干扰。
持久性：事务提交后，数据的更改是永久性的。

声明式事务管理

Spring框架提供了声明式事务管理，使事务处理代码更加简洁。通过配置事务管理器（Transaction Manager）和事务通知（Transaction Advisor），可以在配置文件中定义事务规则。

事务管理器

事务管理器是事务管理的核心组件，它负责事务的启动、提交和回滚。Spring提供了多种事务管理器，如JtaTransactionManager、DataSourceTransactionManager等。

事务通知

事务通知定义了事务的具体规则，如事务的传播行为、隔离级别、超时等。

事务传播行为

事务传播行为定义了事务在调用其他方法时的行为。Spring提供了以下几种传播行为：

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

事务隔离级别

事务隔离级别定义了数据的隔离程度。Spring提供了以下几种隔离级别：

ISOLATION_DEFAULT：使用底层数据库的默认隔离级别。
ISOLATION_READ_UNCOMMITTED：读未提交。
ISOLATION_READ_COMMITTED：读已提交。
ISOLATION_REPEATABLE_READ：可重复读。
ISOLATION_SERIALIZABLE：串行化。

事务超时时间

事务超时时间定义了事务的最长执行时间。如果事务在指定时间内未完成，则自动回滚。

总结

通过上述介绍，我们可以看到Spring框架提供了丰富的事务管理特性。接下来，我们将详细介绍Spring框架中的事务管理配置。

Spring框架中的事务管理配置

事务管理器配置示例

配置事务管理器

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

配置事务通知

<bean id="txAdvice" class="org.springframework.transaction.interceptor.TransactionInterceptor">
    <property name="transactionManager" ref="transactionManager" />
    <property name="transactionAttributes">
        <props>
            <prop key="*">PROPAGATION_REQUIRED</prop>
        </props>
    </property>
</bean>

示例代码

配置事务管理器

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

配置事务通知

<bean id="txAdvice" class="org.springframework.transaction.interceptor.TransactionInterceptor">
    <property name="transactionManager" ref="transactionManager" />
    <property name="transactionAttributes">
        <props>
            <prop key="*">PROPAGATION_REQUIRED</prop>
        </props>
    </property>
</bean>

配置Bean

<bean id="helloWorldService" class="com.example.HelloWorldService">
    <property name="helloWorld" ref="helloWorld" />
    <aop:scoped-proxy />
</bean>

使用事务通知

package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class HelloWorldService {
    private HelloWorld helloWorld;

    @Autowired
    public HelloWorldService(HelloWorld helloWorld) {
        this.helloWorld = helloWorld;
    }

    public void sayHello() {
        System.out.println(helloWorld.getMessage());
    }
}

总结

通过上述示例，我们可以看到如何在Spring框架中配置事务管理。至此，本文介绍了Spring框架的基本概念、开发环境搭建、Bean管理、依赖注入、AOP编程和事务管理。希望这些内容对您有所帮助。如果您想进一步学习Spring框架，可以参考Maven官网和慕课网等资源。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

茅侃侃

手记
篇

粉丝

10

获赞与收藏

20

关注作者，订阅最新文章

阅读免费教程

Spring Cloud Hystrix

15个小节 6169 121

Spring Security

28个小节 16624 266

Spring MVC 入门教程

24个小节 23502 326

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

Spring入门：新手必看的简单教程

优势

应用场景

安装Maven

创建Maven项目

安装IDEA

总结

Bean的定义

Bean的配置

XML配置示例

注解配置示例

Bean的生命周期

生命周期回调方法示例

总结

依赖注入的基本概念

构造器注入

构造器注入示例

Setter注入

Setter注入示例

接口注入

接口注入示例

总结

自动装配的用法

示例代码

实现自动装配示例

单个Bean的自动装配

多个Bean的自动装配

缺少Bean的自动装配

总结

XML配置示例

定义Bean

注入依赖

示例代码

总结

注解注入示例

注解注入Bean

示例代码

总结

AOP术语

AOP配置示例

定义切面

示例代码

运行结果

总结

事务管理的特性

声明式事务管理

事务管理器

事务通知

事务传播行为

事务隔离级别

事务超时时间

总结

事务管理器配置示例

配置事务管理器

配置事务通知

示例代码

配置事务管理器

配置事务通知

配置Bean

使用事务通知

总结

阅读免费教程