imtoken钱包下载2.0中心|spring

imtoken钱包下载2.0中心|spring

作者： imtoken钱包下载2.0中心
2024-03-09 20:32:57

Spring | Home

ng | HomeSkip to main contentWhy SpringOverviewMicroservicesReactiveEvent DrivenCloudWeb ApplicationsServerlessBatchLearnOverviewQuickstartGuidesBlogProjectsOverviewSpring BootSpring FrameworkSpring CloudSpring Cloud Data FlowSpring DataSpring IntegrationSpring BatchSpring SecurityView all projectsDEVELOPMENT TOOLSSpring Tools 4Spring InitializrAcademyCoursesGet CertifiedSolutionsOverviewTanzu Spring RuntimeSpring ConsultingSpring Academy For TeamsSecurity AdvisoriesCommunityOverviewEventsTeamSpring makes Javasimple.modern.productive.reactive.cloud-ready.Why SpringQuickstartNEWS|State of Spring SurveyWhat Spring can doMicroservicesQuickly deliver production‑grade features with independently evolvable microservices.ReactiveSpring's asynchronous, nonblocking architecture means you can get more from your computing resources.CloudYour code, any cloud—we’ve got you covered. Connect and scale your services, whatever your platform.Web appsFrameworks for fast, secure, and responsive web applications connected to any data store.ServerlessThe ultimate flexibility. Scale up on demand and scale to zero when there’s no demand.Event DrivenIntegrate with your enterprise. React to business events. Act on your streaming data in realtime.BatchAutomated tasks. Offline processing of data at a time to suit you.@SpringBootApplication@RestControllerpublic class DemoApplication {@GetMapping("/helloworld")public String hello() {return"Hello World!";}}Level up your Java™ code

With Spring Boot in your app, just a few lines of code is all you need to start building services like a boss.

New to Spring? Try our simple quickstart guide.Most [of our] services today are all based on Spring Boot. I think the most important thing is that [Spring] has just been very well maintained over the years...that is important for us for the long term because we don’t want to be switching to a new framework every two years.Paul Bakker, Senior Software Engineer, NetflixWatch nowGet aheadVMware offers training and certification to turbo-charge your progress.Learn moreGet supportTanzu Spring Runtime offers support and binaries for OpenJDK™, Spring, and Apache Tomcat® in one simple subscription.Learn moreUpcoming eventsCheck out all the upcoming events in the Spring community.View allWhy SpringMicroservicesReactiveEvent DrivenCloudWeb ApplicationsServerlessBatchLearnQuickstartGuidesBlogCommunityEventsTeamSolutionsTanzu Spring RuntimeSpring ConsultingSpring Academy For TeamsSpring AdvisoriesProjectsTrainingThank YouGet the Spring newsletterThank you for your interest. Someone will get back to you shortly.Copyright © 2005 - 2024 Broadcom. All Rights Reserved. The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries. Terms of Use • Privacy • Trademark Guidelines • Your California Privacy Rights • Cookie SettingsApache®, Apache Tomcat®, Apache Kafka®, Apache Cassandra™, and Apache Geode™ are trademarks or registered trademarks of the Apache Software Foundation in the United States and/or other countries. Java™, Java™ SE, Java™ EE, and OpenJDK™ are trademarks of Oracle and/or its affiliates. Kubernetes® is a registered trademark of the Linux Foundation in the United States and other countries. Linux® is the registered trademark of Linus Torvalds in the United States and other countries. Windows® and Microsoft® Azure are registered trademarks of Microsoft Corporation. “AWS” and “Amazon Web Services” are trademarks or registered trademarks of Amazon.com Inc. or its affiliates. All other trademarks and copyrights are property of their respective owners and are only mentioned for informative purposes. Other names may be trademarks of their respective owners.

spring 中文文档 - spring 中文网

spring 中文文档 - spring 中文网

spring 中文网

Everything about spring.

��

spring 中文网

中文文档

交�论�

在线留言

关�我们

spring 中文文档

2023-08-24

📖 文档列表

Spring

Spring Boot

Spring Security

Spring Data

Spring Data Jdbc

Spring Data Jpa

Spring Data MongoDB

Spring Data Redis

Spring Cloud

Spring Cloud Bus

Spring Cloud Gateway

Spring Cloud Kubernetes

Spring Cloud Circuit Breaker

Spring Cloud Config

Spring Cloud OpenFeign

Spring Authorization Server

Spring Batch

Spring Amqp

TODO

🚫 版�声�

本站中的内容��� spring.io ，�始版�归�� spring.io。本站内容由 springdoc.cn 进行翻译，整�。�供个人学习�研究，未�许�，�得进行任何转载�商用或�之相关的行为。 商标声�：Spring 是 Pivotal Software, Inc. 在�国以�其他国家的商标。

� 关注

微信公众�

论� Spring Boot 中文社区

QQ交�群 586178491

☕ �赠

如�你觉得文档内容对你有帮助，�以考虑 “V我50� 请我�个肯德基，这将会鼓励我投入更多的时间和精力到文档的翻译工作中。

微信

支付�

（你�以通过这�方�进行催更，或者�出翻译新文档的需求💖�）

📩 �系

邮箱：kevinblandy.cn@gmail.com / 747692844@qq.com

微信：KevinBlandy

📮 文档�馈

译者对 spring 技术的��有�，如�你��文档中存在错误，或者是有�以改进的地方，甚至难以�解�些内容的��，都欢� �交�馈。

在此，特别感谢那些为文档�出了贡献的用户，谢谢你们。

dokcn

hugh-zhan9

lightingtime

wurara

©� 版�声�： 未�本站（SPRINGDOC.CN）许�，任何个人或组织严�转载本站的任何内容。本站拥有所有�布在本站的�创作�的版�。未�许�转载本站内容将被视为侵�行为，本站将采�法律手段维护自身的�法�益。

广告

近期文章

使用最新的Mistral AI API，在 Java 和 Spring AI 中进行函数调用

使用 JUnit 和 @DataJpaTest 测试 Spring Data Repository

Spring Data JPA 执行 INSERT 时跳过 SELECT

Spring Data JPA Repository 和数�库视图

Spring Data Jpa 中的 Query Hint

分类

教程 

474

æ–°é—» 

7

标签

arthas (1)

caffeine (1)

docker (9)

eureka (2)

fastjson (1)

feign (3)

flyway (2)

freemarker (2)

graalvm (3)

gradle (1)

graphql (3)

groovy (1)

gson (2)

h2 (2)

hibernate (4)

httpclient (1)

jackson (4)

java (9)

jooq (5)

jpa (4)

jsp (2)

junit (2)

jwt (4)

kafka (15)

keycloak (7)

kubernetes (1)

log4j2 (3)

maven (2)

minio (1)

mongodb (2)

mybatis (1)

mybatis-plus (1)

mysql (2)

oauth2 (12)

openapi (4)

openfeign (7)

postgres (4)

pulsar (1)

querydsl (2)

react (1)

redis (9)

resilience4j (1)

rsocket (1)

sentinel (1)

shiro (1)

spring (125)

spring-ai (2)

spring-authorization-server (2)

spring-batch (3)

spring-boot (195)

spring-cloud (6)

spring-cloud-aws (2)

spring-cloud-azure (1)

spring-cloud-config (3)

spring-cloud-gateway (9)

spring-cloud-sleuth (1)

spring-cloud-stream (5)

spring-data-jpa (23)

spring-data-redis (3)

spring-integration (1)

spring-jdbc (1)

spring-modulith (3)

spring-native (1)

spring-restdocs (1)

spring-retry (2)

spring-security (47)

spring-statemachine (1)

spring-ws (1)

springdoc (4)

springfox (1)

sqlite (1)

ssl (1)

swagger (9)

thymeleaf (4)

webflux (11)

webfulux (1)

websocket (6)

yaml (1)

zuul (2)

网上邻居

Spring Boot 中文社区

MyBatis Plus

Knife4j

Maven 中文站

Hutool

Jpom 项目�维

投稿 | ��政策

|

�ICP备2023000086�-1

© 2024 springdoc.cn ä¿�留一切æ�ƒåˆ©ã€‚

商标声�：Spring 是 Pivotal Software, Inc. 在�国以�其他国家的商标。

Spring 教程

Spring 教程

w3schools 教程

HTML

CSS

JAVASCRIPT

BOOTSTRAP

JQUERY

PHP

SQL

PYTHON

PYTHON2

JAVA

C

C++

C#

Linux

AI

教程库

参考手册

测验

练习

HOWTO

FAQ

Spring 核心基础

Spring - 主页

Spring - 概述

Spring - 架构

Spring - 下载安装

Spring - Hello World 示例

Spring - IoC 容器

Spring - IoC 容器

BeanFactory 容器

ApplicationContext 容器

Spring - Bean 定义

Spring - Bean 作用域

Spring - Bean 生命周期

Spring - Bean 回调方法

Spring - Bean 继承

Spring - 依赖注入

Spring - 依赖注入

基于构造函数的依赖注入

基于 Setter 的依赖注入

Spring - 注入内部 Beans

Spring - 注入集合

Spring - Beans 自动装配

Spring - 自动装配

Spring - 自动装配 byName

Spring - 自动装 byType

Spring - 自动装 constructor

Spring - 基于注解的配置

Spring - 基于注解的配置

Spring - 注解 @Required

Spring - 注解 @Autowired

Spring - 注解 @Qualifier

Spring - 注解 JSR-250

Spring - 基于 Java 的配置

Spring - 事件处理

Spring - 自定义事件

Spring - Spring 框架的 AOP

Spring 框架的 AOP

基于 XML 模式

基于@AspectJ

Spring - JDBC 框架

Spring JDBC 框架

Spring JDBC 示例

Spring SQL 存储过程

Spring - 事务管理

Spring - 事务管理

Spring 程序化事务管理

Spring 声明式事务管理

Spring - Web MVC 框架示例

Spring - Log4J 进行日志记录

Spring 其他资源

Spring - 有用的资源

Spring Boot

Spring Cloud

Spring MVC

Spring Batch

Spring Boot & H2

Spring Boot JPA

Spring Boot ORM

Spring OXM

Spring AOP

Spring Boot CLI

Spring JDBC

Spring 依赖注入

Spring 表达式

Spring 安全框架

Spring Web 服务

Spring 教程

Spring 框架是一个开源 Java 平台，它为非常容易和非常快速地开发健壮的 Java 应用程序提供全面的基础架构支持。 Spring 框架最初由 Rod Johnson 编写，于 2003 年 6 月在 Apache 2.0 许可下首次发布。本教程基于 2015 年 3 月发布的 Spring Framework 4.1.6 版本编写。

为什么要学习 Spring?

Spring 是最流行的企业 Java 应用程序开发框架。 全球数以百万计的开发人员使用 Spring 框架来创建高性能、易于测试和可重用的代码。

Spring 框架是一个开源的 Java 平台。 它最初由 Rod Johnson 编写，并于 2003 年 6 月在 Apache 2.0 许可下首次发布。

在大小和透明度方面，Spring 是轻量级的。 Spring 框架的基本版本约为 2MB。

Spring 框架的核心特性可用于开发任何 Java 应用程序，但也有一些扩展可用于在 Java EE 平台之上构建 Web 应用程序。 Spring 框架旨在通过启用基于 POJO 的编程模型使 J2EE 开发更易于使用并促进良好的编程实践。

Spring 的应用

以下是使用 Spring 框架的几个巨大好处的列表 −

基于 POJO - Spring 使开发人员能够使用 POJO 开发企业级应用程序。 仅使用 POJO 的好处是您不需要 EJB 容器产品，例如应用程序服务器，但您可以选择仅使用强大的 servlet 容器，例如 Tomcat 或某些商业产品。

模块化 - Spring 以模块化方式组织。 即使包和类的数量很多，您也只需要担心您需要的，而忽略其余的。

与现有框架集成 - Spring 并没有重新发明，而是真正利用了一些现有技术，如几个 ORM 框架、日志框架、JEE、Quartz 和 JDK 计时器以及其他视图技术。

可测试性 - 测试用 Spring 编写的应用程序很简单，因为依赖于环境的代码被移到了这个框架中。 此外，通过使用 JavaBeanstyle POJO，使用依赖注入来注入测试数据变得更加容易。

Web MVC - Spring 的 web 框架是一个设计良好的 web MVC 框架，它为 Struts 等 web 框架或其他过度设计或不太流行的 web 框架提供了一个很好的替代方案。

中央异常处理 - Spring 提供了一个方便的 API 来将特定于技术的异常（例如，由 JDBC、Hibernate 或 JDO 抛出）转换为一致的、未经检查的异常。

轻量级 - 轻量级 IoC 容器往往是轻量级的，例如，与 EJB 容器相比时尤其如此。 这有利于在内存和 CPU 资源有限的计算机上开发和部署应用程序。

事务管理 - Spring 提供一致的事务管理接口，可以缩小到本地事务（例如，使用单个数据库）并扩展到全局事务（例如，使用 JTA）。

谁适合阅读本教程?

本教程是为需要详细了解 Spring 框架及其架构和实际用法的 Java 程序员设计的。 本教程将带您进入中级专业知识水平，从那里您可以将自己提升到更高水平的专业知识。

阅读本教程前，您需要了解的知识

在继续学习本教程之前，您应该对 Java 编程语言有一个很好的了解。 还需要对 Eclipse IDE 有基本的了解，因为所有示例都是使用 Eclipse IDE 编译的。

❮ 上一节

下一节 ❯

颜色选择器

热门教程

HTML 教程

CSS 教程

JavaScript 教程

Python 教程

SQL 教程

PHP 教程

JAVA 教程

Excel 教程

读后有收获微信请站长喝咖啡

报告错误

打印

关于

学习路线

×

错误报告

如果您发现内容有误或提出修改建议，请随时向我们发送 E-mail 邮件:

421660149@qq.com

您的建议:

您的 E-mail:

页面地址:

内容描述:

提交

×

感谢您的帮助！

您的建议已发送到 W3schools。

W3Schools 在线教程提供的内容仅用于学习和测试，不保证内容的正确性。通过使用本站内容随之而来的风险与本站无关。

Copyright 2020-2024 关于我们 | 隐私条款 | 学习路线 | 京ICP备14045893号-9

Spring-全面讲解（无比详细）入门看这一篇就够了 - 知乎

Spring-全面讲解（无比详细）入门看这一篇就够了 - 知乎切换模式写文章登录/注册Spring-全面讲解（无比详细）入门看这一篇就够了落白1、Spring框架体系2、 IOC2.1 什么是IOC2.3 基于配置文件的di实现2.3.1 什么是di2.3.2 入门案例2.3.3 环境搭建2.3.4 案例总结2.3.5 简单类型属性的赋值（set注入）2.3.6 非简单类型属性的赋值（set注入）2.3.7 构造注入2.3.8 非简单类型的自动注入2.4 基于注解的di实现2.4.1 简单类型的注解di实现2.4.2 引用类型的注解di实现3、AOP3.1 动态代理3.1.1 jdk动态代理3.1.2 cglib动态代理3.1.3 动态代理的好处3.2 什么是AOP3.2.1 AOP常用术语3.2.2 切面的构成3.3 使用aspectJ框架实现AOP3.3.1 aspectJ简介3.3.2 @Before前置通知3.3.3 @AfterReturning后置通知3.3.4 @Around环绕通知（功能最强的通知）4、整合mybatis4.1 梳理整合思路4.2 整合实现4.2.1 环境搭建4.2.2 案例5、处理事务5.1 什么是事务5.2 使用spring内部注解处理事务5.2.1 环境搭建5.3 使用aspectj框架处理事务6、开发web项目环境搭建案例1、Spring框架体系看前必知，由于本文非常之详细，所以篇幅较长，望耐住性子，保证一定会有收获，先上spring体系结构思维导图。下文的顺序基本也是按照此导图进行展开讲述。2、 IOC2.1 什么是IOCIoC (Inversion of Control) : 控制反转， 是一个理论，概念，思想。把对象的创建，赋值，管理工作都交给代码之外的容器实现， 也就是对象的创建是有其它外部资源完成，这样做实现了与解耦合。正转：对象的创建、赋值等操作交由程序员手动完成，即使用类似new Xxx(Xxx Xxx)、Xxx.setXxx()语句完成对象的创建与赋值，缺点是一旦程序功能发生改变，涉及到的类就要修改代理，耦合度高，不便于维护和管理。反转：对象的创建、赋值等操作交由代码之外的容器实现，有容器代替程序员完成对象的创建、赋值；且当程序功能发生变化时，只需要修改容器的配置文件即可。java实现创建对象的方式有哪些1、构造方法：new student()2、反射3、序列化4、动态代理5、容器：tomcat容器、ioc容器其实在以前我们已经接触过了容器创建对象的场景，还记得tomcat服务器吗，在tomcat启动时会实例化servletContext上下文对象；在发出请求时，相应的servlet对象也不是由开发人员进行实例化的，而是在tomcat内部由tomcat容器实例化的，回忆一下在学习javaweb的时候，我们有写过类似new XxxServlet()这样的代码吗，现在想必大家对容器有一个大概的概念了吧。2.3 基于配置文件的di实现2.3.1 什么是diDI（Dependency Injection） :依赖注入， 只需要在程序中提供要使用的对象名称就可以， 至于对象如何在容器中创建， 赋值，查找都由容器内部实现。DI是ioc技术的实现方式（即容器如何创建对象这一问题的实现方式）2.3.2 入门案例使用ioc容器创建对象，调用对象的方法2.3.3 环境搭建创建maven项目，目前都是javase项目，推荐使用骨架，选择quickstart加入maven依赖：分别是spring依赖、junit依赖创建类（接口和它的实现类）创建spring需要使用的配置文件测试本人的项目结构如下接口和实现类//接口

public interface SomeService {

void doSome();

}

//实现类

public class SomeServiceImpl implements SomeService {

//无参构造

public SomeServiceImpl() {

System.out.println("SomeServiceImpl类的无参构造执行了...");

}

@Override

public void doSome() {

System.out.println("执行了SomeServiceImpl的doSome()方法");

}

}ioc配置文件

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

测试程序//使用spring容器创建对象

@Test

public void test02() {

//1、指定spring配置文件的名称

String config = "beans.xml";

//2、创建表示spring容器的对象 ApplicationContext

//ClassPathXmlApplicationContext：表示从类路径中加载spring配置文件

ApplicationContext ac = new ClassPathXmlApplicationContext(config);

//3、从容器中获取对象

SomeService service = (SomeService)ac.getBean("someService");

//4、调用方法

service.doSome();

}

/**

* 测试spring容器创建对象的时机

* 在创建spring容器时，会创建配置文件中的所有对象

*/

@Test

public void test03() {

//1、指定spring配置文件路径

String config = "beans.xml";

//2、创建spring容器

ApplicationContext ac = new ClassPathXmlApplicationContext(config);

/**

* 测试输出结果：

* SomeServiceImpl类的无参构造执行了...

* SomeServiceImpl类的无参构造执行了...

* 验证了spring调用类的无参构造完成对象的创建

*/

}

//获取spring容器中java对象的信息

@Test

public void test04() {

String config = "beans.xml";

ApplicationContext ac = new ClassPathXmlApplicationContext(config);

//获取spring容器中对象的个数

int beansCount = ac.getBeanDefinitionCount();

System.out.println("spring容器中的对象个数="+beansCount);

//获取spring容器中对象的名称（即bean标签的id值）

String[] beansNames = ac.getBeanDefinitionNames();

for (String beanName : beansNames) {

System.out.println(beanName);

}

}2.3.4 案例总结spring配置文件中一个bean标签就代表一个对象，该对象有bean标签的id值唯一标识，从spring拿对象是使用getBean(“bean标签的id值”)spring默认是使用类的无参构造来创建对象的2.3.5 简单类型属性的赋值（set注入）在入门案例的总结我们说过了spring容器默认是使用无参构造构造来实例化对象的，那么对象的属性必定为初始值，例如int类型为0，boolean类型为false等，那么当我们想使用相关属性进行操作时必然要手动使用set方法给属性赋值，那么有没有办法让容器帮我们完成对象属性的赋值呢？让我们直接就能够从容器中拿到有属性值的对象？答案是肯定的，下面就通过代码演示简单类型的属性赋值。set注入要求JavaBean必须要有set方法，因为ioc容器是使用javabean的set方法进行属性赋值的spring容器调用的是setXxx()方法，而不管对象是否具有Xxx属性（即对象没有的属性只要有set方法也可以实现注入），Xxx不区分大小写看看代码：JavaBeanpublic class Student {

private String name;

private int age;

private School school;

public void setName(String name) {

this.name = name;

}

public void setAge(int age) {

this.age = age;

}

public void setSchool(School school) {

this.school = school;

}

@Override

public String toString() {

return "Student{" +

"name='" + name + '\'' +

", age=" + age +

", school=" + school +

'}';

}

}spring配置文件

测试类//使用set注入给对象属性赋值

@Test

public void test01() {

String config = "ba01/applicationContext.xml";

ApplicationContext ac = new ClassPathXmlApplicationContext(config);

//执行完14行此时Student对象的属性已被赋值，获取对象进行验证

Student stu = (Student) ac.getBean("student");

System.out.println(stu); //Student{name='张三', age=23}

}

//验证set注入调用的是对象的set方法

@Test

public void test02() {

String config = "ba01/applicationContext.xml";

/*

* 此时会调用set方法进行赋值

* setName...

* setAge...

*/

ApplicationContext ac = new ClassPathXmlApplicationContext(config);

}

//验证没有属性的setXxx方法是否报错

@Test

public void test03() {

String config = "ba01/applicationContext.xml";

ApplicationContext ac = new ClassPathXmlApplicationContext(config);

//获取对象

Student stu = (Student) ac.getBean("student");

}2.3.6 非简单类型属性的赋值（set注入）上文中的set注入使用property标签的name和value属性给对象属性赋值，但是value知识给简单类型属性赋值，对于非简单类型我们是使用property标签的name和ref属性给对象属性赋值。我们现在给Student类增加一个属性address，该属性是一个引用类型，那当ioc容器创建Student对象时如何给address属性赋值呢？Student类：别的地方与上文的student类一致，这里只给出address属性和其set方法//引用类型属性

private Address address;

public void setAddress(Address address) {

System.out.println("引用类型address的set方法执行了...");

this.address = address;

}Address类public class Address {

private String homeAddress;

private String schoolAddress;

public void setHomeAddress(String homeAddress) {

this.homeAddress = homeAddress;

}

public void setSchoolAddress(String schoolAddress) {

this.schoolAddress = schoolAddress;

}

@Override

public String toString() {

return "Address{" +

"homeAddress='" + homeAddress + '\'' +

", schoolAddress='" + schoolAddress + '\'' +

'}';

}

}applicationContext.xml配置文件

上文执行流程分析：当ioc容器创建id为student的对象时，会进行set注入，当执行到最后一个propert标签时发现使用了ref属性，则ioc容器知道了name为address的属性是非简单类型，它就会暂时跳过address属性的赋值以及Student对象的创建，转而去配置文件的下文去找bean标签id值等于ref属性值的对象，现将该对象创建，再将该对象赋值给之前的address属性并将Student对象创建。2.3.7 构造注入顾名思义，构造注入是使用javabean的构造方法进行属性的赋值的。与set注入一样，构造注入要求javabean必须提供构造方法，且必须是有参构造（如果是无参构造还怎么给属性赋值，对吧），构造注入使用较少，了解就可以了，我们一般使用set注入。看看代码吧，将Student类的set方法注释，加入构造方法，别的地方不用改变，只需要改变spring配置文件即可（这里就可以看出ioc容器与程序的解耦合的好处了）。

2.3.8 非简单类型的自动注入对于非简单类型，我们在上面是使用ref属性指向一个非简单类型的对象来完成赋值的，那么当ioc容器每次给一个对象的非简单类型属性赋值时，就要在bean标签内部写一行ref这样的代码，这样会造成重复代码的大量堆积，可以使用引用类型的自动注入。有两种方式的引用类型自动注入byName形式的引用类型自动注入：通过java对象引用类型的属性名与spring容器中bean标签对象的id值一样且数据类型是一致的，这样能够实现引用类型的自动注入byType形式的引用类型自动注入通过java对象引用类型属性的数据类型和spring容器中 bean标签的class属性值是同源关系；常见的同源关系：1）java引用类型属性数据类型和bean标签的class属性值数据类型一样2）java引用类型属性数据类型和bean标签的class属性值数据类型是父子关系3）java引用类型属性数据类型和bean标签的class属性值数据类型是接口和实现类关系注意：在一个配置文件中，符合条件的同源关系只能有一个下面通过配置文件来详细说明两种形式的实现，在这里还是以Student类的address属性为例来说明。byName形式

匹配详解： 当ioc容器在创建Student对象时，发现使用了autowire属性且属性值为byName，ioc容器就会去Student类中去拿引用类型的属性名与和spring配置文件中的bean标签的id值进行比对，若发现有一致的且数据类型一致，则将该对象赋值给引用类型属性。byType形式

2.4 基于注解的di实现除了使用配置文件实现ioc创建对象的功能外，使用spring提供的注解也可以实现di。下面来介绍注解方式的di实现，下面是spring提供的di实现的常用注解。@Component：该注解的功能是使用spring容器创建对象1）、在要创建对象的类的声明上方加入该注解，该注解有一个属性value，value为spring创建的该类对象的id值2）、开发中使用将value省略，直接使用双引号将值键入即可3）、该注解使用类的无参构造创建对象@Repository 创建dao类对象，访问数据库的对象@Service 创建service类对象，业务层对象@Controller 创建控制器对象，用于分发用户的请求和显示处理结果下面通过代码来看看@Component注解是怎么实现di的。@Component(value = "student")

public class Student {

...

}该语句就等价为在spring配置文件中进行了以下声明但是怎么让配置文件知道哪些类是使用注解进行创建对象的呢？需要在配置文件中声明组件扫描器当spring读取配置文件时，读取到组件扫描器声明语句时，就会去base-package指定的包和其子包下去递归的寻找有注解修饰的类，并根据注解的功能去执行相应的动作2.4.1 简单类型的注解di实现简单类型的注入使用@Value注解实现，哪些简单类型要设置属性值，直接在简单类型属性声明语句的上面加入注解@Value即可，并在@Value的括号内键入属性值，注意不论简单类型属性的数据类型，均由双引号将属性值括起来。例如之前的Student类使用注解注入如下。@Component("student")

public class Student {

@Value("张三")

private String name;

@Value("23")

private int age;

}注意别忘了该类要加注解@Component注解，因为要创建该类对象。2.4.2 引用类型的注解di实现引用类型的注入使用@Autowired注解完成。@Autowired@Autowired是spring提供的属性赋值，用于给引用类型赋值，有byName和byType两种方式，默认使用byType方式自动注入若是要强制至于byName方式，要在@Autowired注解下面加入 @Qualifier(value = “bean的id”)注解，若程序在给引用类型注入时在xml文件中找不到 该id的bean标签或者手找不到该id的@Component注解，则报错；若不想让程序在赋值失败时报错，可以在@Autowired注解的required属性值置为false还是拿Student类的school属性的赋值来举例。学生类@Component("student")

public class Student {

/*引用类型注入（byType方式）

@Autowired

private School school;*/

//引用类型赋值（byName方式）

@Autowired(required = false)

@Qualifier(value = "mySchool")

private School school;

}School类@Component("mySchool")

public class School {

//注入值

@Value("西南大学")

private String schoolAddress;

@Value("新疆")

private String homeAddress;

@Override

public String toString() {

return "School{" +

"schoolAddress='" + schoolAddress + '\'' +

", homeAddress='" + homeAddress + '\'' +

'}';

}

}3、AOP3.1 动态代理3.1.1 jdk动态代理使用jdk中的Proxy，Method，InvocaitonHanderl创建代理对象。 jdk动态代理要求目标类必须实现接口，关于细节本文就不赘述了。要求：必须要有接口目标类必须实现接口（一个或多个）3.1.2 cglib动态代理第三方的工具库，创建代理对象，原理是继承。 通过继承目标类，创建子类。子类就是代理对象。 要求目标类不能是final的，方法也不能是final的3.1.3 动态代理的好处在目标类源代码不改变的情况下，增加功能。减少代码的重复专注业务逻辑代码解耦合，让你的业务功能和日志，事务非业务功能分离。3.2 什么是AOP面向切面编程， 基于动态代理的，可以使用jdk，cglib两种代理方式。Aop就是动态代理的规范化， 把动态代理的实现步骤，方式都定义好了， 让开发人员用一种统一的方式，使用动态代理实现。3.2.1 AOP常用术语Aspect: 切面，给你的目标类增加的功能，就是切面。 像日志，事务都是切面。切面的特点： 一般都是非业务方法，独立使用的。JoinPoint:连接点 ，连接业务方法和切面的位置。需要给哪个方法增加切面，这个方法就是连接点。Pointcut : 切入点 ，指多个连接点方法的集合。目标对象： 给哪个类的方法增加功能， 这个类就是目标对象。Advice:通知，通知表示切面功能执行的时间。3.2.2 切面的构成切面就是要给别的方法进行增强的方法，一个切面有以下三个要素。切面的功能代码，切面干什么切面的执行位置，使用Pointcut表示切面执行的位置切面的执行时间，使用Advice表示时间，在目标方法之前，还是目标方法之后。3.3 使用aspectJ框架实现AOP3.3.1 aspectJ简介aspectJ是一个开源的专门做aop的框架。spring框架中集成了aspectj框架，通过spring就能使用aspectj的功能。aspectJ框架实现aop有两种方式：使用xml的配置文件 ： 配置全局事务使用注解，我们在项目中要做aop功能，一般都使用注解， aspectj有5个注解。再使用aspectJ做aop之前要先加入aspectJ依赖。

org.springframework

spring-aspects

5.2.5.RELEASE

3.3.2 @Before前置通知前置通知注解修饰的切面在连接点方法之前执行。下面通过一段代码体验一下。声明接口IServicepublic interface IService {

void doSome(String name, int age);

}声明实现类ServiceImplpublic class ServiceImpl implements IService {

@Override

public void doSome(String name, int age) {

System.out.println("===doSome()===");

}

}声明切面@Aspect

public class MyAspectJ {

/**

* 定义功能增强方法（方法就是切面）

* 1、方法的必须为public

* 2、方法无返回值

* 3、方法名称自定义

* 4、方法可以有参数，也可以没有参数

* 5、方法的定义上方加入注解，表示切入点的执行时机

@Before(value = "execution(public void com.mms.ba01.ServiceImpl.doSome(String,int))")

public void beforeLog() {

System.out.println("前置通知->系统当前时间：" + new Date());

}

*/

/*

前置通知，带方法参数的切面

切面方法有参数时要求参数是JoinPoint类型，参数名自定义，该参数就代表了连接点方法，即doSome方法

使用该参数可以获取切入点表达式、切入点方法签名、目标对象等

*/

@Before(value = "execution(* *..ServiceImpl.doSome(..))")

public void beforeLog(JoinPoint jp) {

System.out.println("连接点方法的方法签名="+jp.getSignature());

System.out.println("连接点方法的方法名="+jp.getSignature().getName());

//获取连接点方法参数

Object[] args = jp.getArgs();

for (Object arg : args) {

System.out.println("arg="+arg);

}

}

}测试public class MyTest {

//aop前置通知

@Test

public void test01() {

String config = "ba01/applicationContext.xml";

ApplicationContext ac = new ClassPathXmlApplicationContext(config);

//获取目标对象，此时的service就是spring生成的代理对象

//注意返回值类型是接口类型，不能是实现类接口，否则报错

IService service = (IService) ac.getBean("service");

//使用代理对象执行方法

service.doSome("张三",23);

}

}3.3.3 @AfterReturning后置通知在IService接口中新增方法：Student doStudent(Student student);在ServiceImpl实现doStudent方法@Override

public Student doStudent(Student student) {

return student;

}切面类代码@Aspect

public class MyAspectJ {

/**

* @AfterReturning: 后置通知，在连接点方法执行之后执行后置通知方法

* 方法定义格式：

* 1、公共方法

* 2、没有返回值

* 3、方法名称自定义

* 4、与前置通知一样，可以有JoinPoint类型参数，该参数表示连接点方法对象；还可以有一个

* Object类型参数，用于接收连接点方法的执行结果，注意该参数的参数名必须与切入点表达式

* 的returning属性的属性值一致，表示将returning属性值赋给Object对象

*/

/*@AfterReturning(value = "execution(* *..ServiceImpl.doOther(..))", returning = "obj")

public void afterTransaction(JoinPoint jp, Object obj) {

System.out.println("doOther方法的返回参数="+obj);

System.out.println("事务已提交...");

经过验证：在后置通知切面内不能改变连接点方法的返回值

}*/

@AfterReturning(value = "execution(* *..ServiceImpl.doStudent(..))", returning = "obj")

public void afterTransaction(JoinPoint jp, Object obj) {

System.out.println(obj);

Student student = new Student();

student.setName("李四");

student.setAge(24);

obj = student;

System.out.println("===查看是否改变了连接点方法的返回值==="+obj);

/*

经过验证：在后置通知切面内不能改变连接点方法的返回值

*/

}

}3.3.4 @Around环绕通知（功能最强的通知）环绕通知是功能最强的通知，它的本质就是jdk动态代理，他可以在连接点方法之前和之后都可以执行，最厉害的是他可以改变连接点方法的执行结果（返回结果）。还是拿上面的doStudent(Student student)方法来说明，经过验证前置通知和后置通知都不能改变doStudent(Student student)方法的返回值。下面看一下环绕通知是如何做的。切面类@Aspect

public class MyAspectJ {

/*

环绕通知：@Around(切入点表达式)

1、环绕通知是最重要的一个通知，他表示在连接点方法的前或者后都可以执行，它的本质就是jdk动态代理的invoke

方法的method参数

2、定义格式

a、public

b、必须有返回值，类型为Object

*/

@Around(value = "pointCut()")

/*

再次回忆一下jdk动态代理的invoke方法的定义

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

是不是感觉与下面的方法定义眼熟啊，没错，环绕通知切面的定义实质上就是jdk动态代理

*/

public Object around(ProceedingJoinPoint pj) throws Throwable {

System.out.println("环绕通知在连接点方法之前执行了...");

Object result = null;

result = pj.proceed();

Student student = new Student();

student.setName("李四");

student.setAge(24);

//改变连接点方法返回值

result = student;

System.out.println("事务已提交...");

return result;

}

/*

使用pointcut管理切面表达式

1、在一个切面类中，若多个切面的切面表达式均为同一个，每次都要写重复的代码，此时就可以使用pointcut来

管理切面表达式了

2、定义格式：

公共public

无返回值

无参数

*/

@Pointcut(value = "execution(* *.doStudent(..))")

public void pointCut() {

//空方法体

}

}4、整合mybatis4.1 梳理整合思路所谓的spring整合mybatis就是把两者集成在一起，就像使用一个框架一样。mybatis框架开发步骤定义mapper接口，定义方法定义mapper.xml映射文件创建mybatis核心配置文件创建SqlSession对象，使用该对象生成mapper接口的代理对象执行方法spring整合mybatis的核心就是把mybatis开发用到的对象交由spring容器ioc来创建，这样就做到了整合的目的。在开发中，我们一般不使用mybatis自带的数据源，而是使用别的数据源，比如c3p0，dbcp等，本人使用的是阿里的druid数据源。4.2 整合实现4.2.1 环境搭建导入相关依赖：

junit

junit

4.11

test

org.springframework

spring-context

5.2.5.RELEASE

org.springframework

spring-jdbc

5.2.5.RELEASE

org.mybatis

mybatis

3.5.1

org.mybatis

mybatis-spring

1.3.1

mysql

mysql-connector-java

5.1.9

com.alibaba

druid

1.1.12

src/main/java

**/*.properties

**/*.xml

false

maven-compiler-plugin

3.1

1.8

1.8

重点是注意resources标签的配置，很多人都是在这里出错导致程序运行报错找不到mapper.xml文件4.2.2 案例本案例从student表中查询学生和新增学生功能。实体类Student

public class Student {

private int stuNo;

private String stuName;

private int cardID;

private int classID;

public Student() {

}

public Student(int stuNo, String stuName, int cardID, int classID) {

this.stuNo = stuNo;

this.stuName = stuName;

this.cardID = cardID;

this.classID = classID;

}

public int getStuNo() {

return stuNo;

}

public void setStuNo(int stuNo) {

this.stuNo = stuNo;

}

public String getStuName() {

return stuName;

}

public void setStuName(String stuName) {

this.stuName = stuName;

}

public int getCardID() {

return cardID;

}

public void setCardID(int cardID) {

this.cardID = cardID;

}

public int getClassID() {

return classID;

}

public void setClassID(int classID) {

this.classID = classID;

}

@Override

public String toString() {

return "Student{" +

"stuNo=" + stuNo +

", stuName='" + stuName + '\'' +

", cardID=" + cardID +

", classID=" + classID +

'}';

}

}mapper接口public interface StudentMapper {

//查询全部

List queryAll();

//新增学生

void addStudent(Student student);

}mapper.xml映射文件

PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

insert into student (stuno,stuname,cardid,classid)

values (#{stuNo},#{stuName},#{cardID},#{classID})

service接口public interface IStudentService {

List queryAll();

void addStudent(Student student);

}service实现类public class StudentServiceImpl implements IStudentService {

//mapper属性

private StudentMapper mapper;

//set注入给mapper对象赋值

public void setMapper(StudentMapper mapper) {

this.mapper = mapper;

}

@Override

public List queryAll() {

return mapper.queryAll();

}

@Override

public void addStudent(Student student) {

mapper.addStudent(student);

}

}mybatis核心配置文件

PUBLIC "-//mybatis.org//DTD Config 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-config.dtd">

在这里由于数据源对象我们是交由spring容器托管了，因此mybatsi核心配置文件中就没有environments标签了。spring配置文件

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

数据库配置文件url = jdbc:mysql://localhost:3306/Xxx?characterEncoding=utf8&useSSL=true&serverTimezone=UTC

username = Xxx

password = Xxx测试//执行查询全部，不使用service

@Test

public void test02() {

String config = "applicationContext.xml";

ApplicationContext ac = new ClassPathXmlApplicationContext(config);

//获取mapper的代理对象

StudentMapper mapper = (StudentMapper) ac.getBean("studentMapper");

List students = mapper.queryAll();

for (Student student : students) {

System.out.println("student--->"+student);

}

}

//执行增加学生，使用service

@Test

public void test03() {

String config = "applicationContext.xml";

ApplicationContext ac = new ClassPathXmlApplicationContext(config);

//获取service对象

IStudentService service = (IStudentService) ac.getBean("studentServiceImpl");

Student student = new Student();

student.setStuName("呵呵");

student.setStuNo(1111);

student.setCardID(1115);

student.setClassID(1);

service.addStudent(student);

}5、处理事务5.1 什么是事务事务是指一组sql语句的集合， 集合中有多条sql语句可能是insert ， update ，select ，delete， 我们希望这些多个sql语句都能成功，或者都失败， 这些sql语句的执行是一致的，作为一个整体执行。关于事务最经典的例子就是转账了。5.2 使用spring内部注解处理事务5.2.1 环境搭建加入事务相关依赖

org.springframework

spring-tx

5.2.5.RELEASE

案例：数据库有两张表，一张sale表，该表是商品订单信息；一张goods表，该表是商品库存信息。service类有一个业务方法buy，该方法指定要购买商品的id和数量，dao有三个方法分别是像sale表增加一条购买记录、更新goods表的库存信息、在goods表查询指定id商品是否存在。下面是两张表的记录信息sale表（初始是空表，因为还没有购买记录），id字段自增长goods表业务流程大致是这样，用户向buy方法传递两个参数，分别是goods表的id字段和购买数量nums。buy方法体中的第一个方法是向sale表增加一条记录，类似与buy(1002,20)，那么sale表应该多出来一条如下记录因为sale表id字段是自增长的，所以自动为1。先看一下buy方法的定义public void buy(Integer goodsId, Integer nums) {

//sale表新增购买记录

//更新库存

//先查询该编号的商品是否存在

Goods goods = goodsMapper.queryGoods(goodsId);

//进行判断

if (goods == null) {

//说明商品不存在

} else if (goods.getAmount() < nums) {

//说明库存不足

}

//能够进行到这里说明商品信息是合法的，可以更新库存

}首先根据用户传入的参数id和nums向sale表新增一条购买记录。即有商品卖出去了，那么我们理应更新一下库存对吧，不然怎么知道还有多少货，万一别人要买100件商品而你只有50件肯定会导致别人购买失败对吧。那么问题就就来了，当我们执行完向sale表新增记录后，就该更新库存了，我们必须要知道刚卖出去的商品是谁对吧，这个通过用户传入的id和商品表goods的id字段一一对应，所以先去数据库查询用户传入的id是否存在goods表中，若不存在应该将事务回滚，即前面向sale表增加的记录是不应该存在的；同理，若用户传入的id商品在goods表中，但是用户要求的数量大于该商品当前库存，事务也应该回滚；只有当用户传入的id商品和数量都满足条件时我们才应该更新库存并且提交事务。该介绍的都介绍完了，开始着手干吧。实体类public class Goods {

private Integer id;

private String name;

private Integer amount;

private Float price;

public Goods() {

}

public Goods(Integer id, String name, Integer amount, Float price) {

this.id = id;

this.name = name;

this.amount = amount;

this.price = price;

}

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public Integer getAmount() {

return amount;

}

public void setAmount(Integer amount) {

this.amount = amount;

}

public Float getPrice() {

return price;

}

public void setPrice(Float price) {

this.price = price;

}

@Override

public String toString() {

return "Goods{" +

"id=" + id +

", name='" + name + '\'' +

", amount=" + amount +

", price=" + price +

'}';

}

}

public class Sale {

private Integer id;

private Integer gid;

private Integer nums;

public Sale() {

}

public Sale(Integer id, Integer gid, Integer nums) {

this.id = id;

this.gid = gid;

this.nums = nums;

}

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public Integer getGid() {

return gid;

}

public void setGid(Integer gid) {

this.gid = gid;

}

public Integer getNums() {

return nums;

}

public void setNums(Integer nums) {

this.nums = nums;

}

@Override

public String toString() {

return "Sale{" +

"id=" + id +

", gid=" + gid +

", nums=" + nums +

'}';

}

}mapper接口public interface GoodsMapper {

/**

* 更新库存

* goods表示本次用户购买的商品信息

* @param goods

*/

void updateGoods(Goods goods);

//查询商品信息

Goods queryGoods(Integer id);

}

public interface SaleMapper {

//增加销售记录

void addSale(Sale sale);

}mapper.xml映射文件

update goods set amount = amount - #{amount} where id = #{id}

insert into sale (gid,nums) values (#{gid},#{nums})

service接口public interface IBuyGoodsService {

//购买商品的方法，goodsId是购买商品的编号，nums是购买商品的数量

void buy(Integer goodsId,Integer nums);

}service实现类public class BuyGoodsServiceImpl implements IBuyGoodsService {

private SaleMapper saleMapper;

private GoodsMapper goodsMapper;

//set注入赋值

public void setSaleMapper(SaleMapper saleMapper) {

this.saleMapper = saleMapper;

}

public void setGoodsMapper(GoodsMapper goodsMapper) {

this.goodsMapper = goodsMapper;

}

/**

* 购买商品方法

* goodsId表示要购买的商品编号，nums表示购买的数量

* @param goodsId

* @param nums

*/

/*

1、@Transactional定义在需要加入事务处理的方法上面

2、rollbackFor

1）当方法发生的异常属于rollbackFor，事务就会回滚

2）当方法发生的异常不属于rollbackFor，spring就会判断发生的异常是不是运行时异常，

若是运行时异常，事务就会回滚

@Transactional(

propagation = Propagation.REQUIRED,

isolation = Isolation.DEFAULT,

readOnly = false,

rollbackFor = {

NullPointerException.class,

NotEnoughException.class

}

)*/

//开发中推荐使用默认值，直接使用@Transactional注解

@Transactional

@Override

public void buy(Integer goodsId, Integer nums) {

System.out.println("buy开始...");

/*

记录销售的信息，向sale表添加记录，由于sale表id是自增长的，所以不需要设置id属性

向sale表添加一条购买记录

*/

Sale sale = new Sale();

sale.setGid(goodsId);

sale.setNums(nums);

saleMapper.addSale(sale);

//更新库存

//先查询该编号的商品是否存在

Goods goods = goodsMapper.queryGoods(goodsId);

//进行判断

if (goods == null) {

//说明商品不存在

throw new NullPointerException("编号为:"+goodsId+"商品不存在...");

} else if (goods.getAmount() < nums) {

//说明库存不足

throw new NotEnoughException("编号为:"+goodsId+"商品库存不足...");

}

//能够进行到这里说明商品信息是合法的，可以更新库存

Goods good = new Goods();

good.setId(goodsId);

good.setAmount(nums);

goodsMapper.updateGoods(good);

System.out.println("buy结束...");

}

}mybatis核心配置文件和整合mybatis一致，这里就不给出了spring配置文件也和整合部分一致，只需要在根标签beans加入以下部分即可

测试类//不使用事务测试

@Test

public void test01() {

String config = "applicationContext.xml";

ApplicationContext ac = new ClassPathXmlApplicationContext(config);

//获取service对象

IBuyGoodsService service = (IBuyGoodsService) ac.getBean("buyGoodsService");

//商品编号不存在情况

//java.lang.NullPointerException: 编号为:1003商品不存在...

//service.buy(1003,50);

//商品库存不足情况

//com.mms.exception.NotEnoughException: 编号为:1002商品库存不足...

//service.buy(1002,100);

//正常情况

service.buy(1002,10);

}5.3 使用aspectj框架处理事务aspectJ处理事务是基于配置文件形式的，别的地方都和上面一样，只需要更改service实现类的buy方法和spring核心配置文件即可。1、取消buy方法上的事务注解，因为我们现在是使用aspectJ，基于配置文件2、将spring注解形式事务开发的spring配置文件中加入的声明事务管理器的部分换成下面的配置

propagation="REQUIRED"

isolation="DEFAULT"

rollback-for="java.lang.NullPointerException,com.mms.exception.NotEnoughException"/>

测试类与前面的一样。6、开发web项目环境搭建新建maven项目，使用骨架，选用webapp加入jsp、servlet依赖

javax.servlet

javax.servlet-api

3.1.0

provided

javax.servlet.jsp

jsp-api

2.2.1-b03

provided

改造项目结构，在main下新建resources目录，并设置为类路径案例还是采用整合mybatis那个案例，这次给用户提供一个表单，用户填写用户信息，将数据存入student表中。注册页<%@ page contentType="text/html;charset=UTF-8" language="java" %>

注册页

欢迎注册

<%--

表格由table标签开始，tr表示行数，td表示列数

例如本例就是一个5行两列的表格

--%>

学号
姓名
学生证
班级

效果展示servletpublic class MySpringServlet extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

this.doPost(request,response);

}

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

//设置编码

request.setCharacterEncoding("UTF-8");

//接收参数

int stuNo = Integer.parseInt(request.getParameter("stuno"));

String stuName = request.getParameter("stuname");

int cardId = Integer.parseInt(request.getParameter("cardid"));

int classId = Integer.parseInt(request.getParameter("classid"));

/*实例化ioc容器

String config = "applicationContext.xml";

ApplicationContext ac = new ClassPathXmlApplicationContext(config);

System.out.println("ioc容器--->"+ac);

*/

//使用监听器怎么获取容器对象

WebApplicationContext ac = null;

//获取servlet上下文对象

ServletContext servletContext = getServletContext();

//使用sprng工具类获取ioc容器对象

ac = WebApplicationContextUtils.getRequiredWebApplicationContext(servletContext);

System.out.println("ioc容器--->"+ac);

//获取service对象

IStudentService service = (IStudentService) ac.getBean("studentServiceImpl");

Student student = new Student();

student.setStuNo(stuNo);

student.setStuName(stuName);

student.setCardID(cardId);

student.setClassID(classId);

service.addStudent(student);

request.getRequestDispatcher("result.jsp").forward(request,response);

}

}关于什么时候实例化ioc容器，在web.xml配置文件中加入如下约束

contextConfigLocation

classpath:applicationContext.xml

org.springframework.web.context.ContextLoaderListener

总结：希望大家共同进步，有兴趣的可以互相加个关注。发布于 2022-04-15 19:38JavaSpring程序员​赞同 90​​6 条评论​分享​喜欢​收藏​申请

Spring Framework 中文文档

Spring Framework 中文文档

Dark Theme

Spring Framework 中文文档

version 6.0.8-SNAPSHOT

Spring Framework 是一个功能强大的 Java 应用程序框架，旨在提供高效且可扩展的开发环境。它结合了轻量级的容器和依赖注入功能，提供了一种使用 POJO 进行容器配置和面向切面的编程的简单方法，以及一组用于AOP的模块。Spring 框架还支持各种移动应用开发技术，如 Android 和 iOS。此外，它还提供了对事务管理、对象/关系映射、JavaBeans、JDBC、JMS 和其他技术的支持，从而确保高效开发。

本站(springdoc.cn)中的内容来源于 spring.io ，原始版权归属于 spring.io。由 springdoc.cn 进行翻译，整理。可供个人学习、研究，未经许可，不得进行任何转载、商用或与之相关的行为。 商标声明：Spring 是 Pivotal Software, Inc. 在美国以及其他国家的商标。

如果你需要一份可离线阅读的PDF文档，可以 点击这里。

概览

历史、设计理念、反馈、入门。

核心

IoC容器、事件、资源、i18n（国际化）、

校验、数据绑定、类型转换、SpEL、AOP、AOT。

测试

Mock对象、TestContext框架、Spring MVC测试、WebTestClient。

数据访问

事务、DAO支持、JDBC、R2DBC、O/R映射、XML装载。

Web Servlet

Spring MVC、 WebSocket、 SockJS、

STOMP Messaging。

Web Reactive

Spring WebFlux、 WebClient、

WebSocket、 RSocket。

整合

REST Clients、 JMS、 JCA、 JMX、

邮件、 Tasks、 Scheduling、 缓存、 Observability。

语言

Kotlin、 Groovy、 动态语言。

附录

Spring properties。

Wiki

更新的内容、升级说明、支持的版本、额外的跨版本信息。

Version 6.0.8-SNAPSHOT

Last updated 2023-09-21 16:42:07 +0800

Spring开发 - 廖雪峰的官方网站

Spring开发 - 廖雪峰的官方网站

Index

廖雪峰的官方网站

Blog

Java教程

手写Spring

手写Tomcat

Makefile教程

Python教程

JavaScript教程

区块链教程

SQL教程

Git教程

文章

问答

More

Java教程

手写Spring

手写Tomcat

Makefile教程

Python教程

JavaScript教程

区块链教程

SQL教程

Git教程

文章

问答

Java教程

手写Spring

手写Tomcat

Makefile教程

Python教程

JavaScript教程

区块链教程

SQL教程

Git教程

文章

问答

 

Profile

Passkey

Sign Out

Sign In

English

简体中文

Index

Java教程

Java快速入门

Java简介

安装JDK

第一个Java程序

Java代码助手

使用IDE

使用IDE练习插件

Java程序基础

Java程序基本结构

变量和数据类型

整数运算

浮点数运算

布尔运算

字符和字符串

数组类型

流程控制

输入和输出

if判断

switch多重选择

while循环

do while循环

for循环

break和continue

数组操作

遍历数组

数组排序

多维数组

命令行参数

面向对象编程

面向对象基础

方法

构造方法

方法重载

继承

多态

抽象类

接口

静态字段和静态方法

包

作用域

内部类

classpath和jar

class版本

模块

Java核心类

字符串和编码

StringBuilder

StringJoiner

包装类型

JavaBean

枚举类

记录类

BigInteger

BigDecimal

常用工具类

异常处理

Java的异常

捕获异常

抛出异常

自定义异常

NullPointerException

使用断言

使用JDK Logging

使用Commons Logging

使用Log4j

使用SLF4J和Logback

反射

Class类

访问字段

调用方法

调用构造方法

获取继承关系

动态代理

注解

使用注解

定义注解

处理注解

泛型

什么是泛型

使用泛型

编写泛型

擦拭法

extends通配符

super通配符

泛型和反射

集合

Java集合简介

使用List

编写equals方法

使用Map

编写equals和hashCode

使用EnumMap

使用TreeMap

使用Properties

使用Set

使用Queue

使用PriorityQueue

使用Deque

使用Stack

使用Iterator

使用Collections

IO

File对象

InputStream

OutputStream

Filter模式

操作Zip

读取classpath资源

序列化

Reader

Writer

PrintStream和PrintWriter

使用Files

日期与时间

基本概念

Date和Calendar

LocalDateTime

ZonedDateTime

DateTimeFormatter

Instant

最佳实践

单元测试

编写JUnit测试

使用Fixture

异常测试

条件测试

参数化测试

正则表达式

正则表达式简介

匹配规则

复杂匹配规则

分组匹配

非贪婪匹配

搜索和替换

加密与安全

编码算法

哈希算法

BouncyCastle

Hmac算法

对称加密算法

口令加密算法

密钥交换算法

非对称加密算法

签名算法

数字证书

多线程

多线程基础

创建新线程

线程的状态

中断线程

守护线程

线程同步

同步方法

死锁

使用wait和notify

使用ReentrantLock

使用Condition

使用ReadWriteLock

使用StampedLock

使用Semaphore

使用Concurrent集合

使用Atomic

使用线程池

使用Future

使用CompletableFuture

使用ForkJoin

使用ThreadLocal

使用虚拟线程

Maven基础

Maven介绍

依赖管理

构建流程

使用插件

模块管理

使用mvnw

发布Artifact

网络编程

网络编程基础

TCP编程

UDP编程

发送Email

接收Email

HTTP编程

RMI远程调用

XML与JSON

XML简介

使用DOM

使用SAX

使用Jackson

使用JSON

JDBC编程

JDBC简介

JDBC查询

JDBC更新

JDBC事务

JDBC Batch

JDBC连接池

函数式编程

Lambda基础

方法引用

使用Stream

创建Stream

使用map

使用filter

使用reduce

输出集合

其他操作

设计模式

创建型模式

工厂方法

抽象工厂

生成器

原型

单例

结构型模式

适配器

桥接

组合

装饰器

外观

享元

代理

行为型模式

责任链

命令

解释器

迭代器

中介

备忘录

观察者

状态

策略

模板方法

访问者

Web开发

Web基础

Servlet入门

Servlet开发

Servlet进阶

重定向与转发

使用Session和Cookie

JSP开发

MVC开发

MVC高级开发

使用Filter

修改请求

修改响应

使用Listener

部署

Spring开发

IoC容器

IoC原理

装配Bean

使用Annotation配置

定制Bean

使用Resource

注入配置

使用条件装配

使用AOP

装配AOP

使用注解装配AOP

AOP避坑指南

访问数据库

使用JDBC

使用声明式事务

使用DAO

集成Hibernate

集成JPA

集成MyBatis

设计ORM

开发Web应用

使用Spring MVC

使用REST

集成Filter

使用Interceptor

处理CORS

国际化

异步处理

使用WebSocket

集成第三方组件

集成JavaMail

集成JMS

使用Scheduler

集成JMX

Spring Boot开发

第一个Spring Boot应用

使用开发者工具

打包Spring Boot应用

瘦身Spring Boot应用

使用Actuator

使用Profiles

使用Conditional

加载配置文件

禁用自动配置

添加Filter

集成第三方组件

集成Open API

访问Redis

集成Artemis

集成RabbitMQ

集成Kafka

Spring Cloud开发

项目架构设计

搭建项目框架

设计交易引擎

设计资产系统

设计订单系统

设计撮合引擎

设计清算系统

完成交易引擎

设计定序系统

设计API系统

设计行情系统

设计推送系统

编写UI

项目总结

关注公众号不定期领红包：

加入知识星球社群：

关注微博获取实时动态：

Spring开发

Last updated: ...

/

Reads: 12288779

Edit

什么是Spring？

Spring是一个支持快速开发Java EE应用程序的框架。它提供了一系列底层容器和基础设施，并可以和大量常用的开源框架无缝集成，可以说是开发Java EE应用程序的必备。

Spring最早是由Rod Johnson这哥们在他的《Expert One-on-One J2EE Development without EJB》一书中提出的用来取代EJB的轻量级框架。随后这哥们又开始专心开发这个基础框架，并起名为Spring Framework。

随着Spring越来越受欢迎，在Spring Framework基础上，又诞生了Spring Boot、Spring Cloud、Spring Data、Spring Security等一系列基于Spring Framework的项目。本章我们只介绍Spring Framework，即最核心的Spring框架。后续章节我们还会涉及Spring Boot、Spring Cloud等其他框架。

Spring Framework

Spring Framework主要包括几个模块：

支持IoC和AOP的容器；

支持JDBC和ORM的数据访问模块；

支持声明式事务的模块；

支持基于Servlet的MVC开发；

支持基于Reactive的Web开发；

以及集成JMS、JavaMail、JMX、缓存等其他模块。

我们会依次介绍Spring Framework的主要功能。

本教程使用的Spring版本是6.x版，如果使用Spring 5.x则需注意，两者有以下不同：

Spring 5.xSpring 6.x

JDK版本>= 1.8>= 17

Tomcat版本9.x10.x

Annotation包javax.annotationjakarta.annotation

Servlet包javax.servletjakarta.servlet

JMS包javax.jmsjakarta.jms

JavaMail包javax.mailjakarta.mail

如果使用Spring的其他版本，则需要根据需要调整代码。

Spring官网是spring.io，要注意官网有许多项目，我们这里说的Spring是指Spring Framework，可以直接从这里访问最新版以及文档，建议添加到浏览器收藏夹。

Comments

Make a comment

Sign in to

make a comment

Index

Java教程

Java快速入门

Java简介

安装JDK

第一个Java程序

Java代码助手

使用IDE

使用IDE练习插件

Java程序基础

Java程序基本结构

变量和数据类型

整数运算

浮点数运算

布尔运算

字符和字符串

数组类型

流程控制

输入和输出

if判断

switch多重选择

while循环

do while循环

for循环

break和continue

数组操作

遍历数组

数组排序

多维数组

命令行参数

面向对象编程

面向对象基础

方法

构造方法

方法重载

继承

多态

抽象类

接口

静态字段和静态方法

包

作用域

内部类

classpath和jar

class版本

模块

Java核心类

字符串和编码

StringBuilder

StringJoiner

包装类型

JavaBean

枚举类

记录类

BigInteger

BigDecimal

常用工具类

异常处理

Java的异常

捕获异常

抛出异常

自定义异常

NullPointerException

使用断言

使用JDK Logging

使用Commons Logging

使用Log4j

使用SLF4J和Logback

反射

Class类

访问字段

调用方法

调用构造方法

获取继承关系

动态代理

注解

使用注解

定义注解

处理注解

泛型

什么是泛型

使用泛型

编写泛型

擦拭法

extends通配符

super通配符

泛型和反射

集合

Java集合简介

使用List

编写equals方法

使用Map

编写equals和hashCode

使用EnumMap

使用TreeMap

使用Properties

使用Set

使用Queue

使用PriorityQueue

使用Deque

使用Stack

使用Iterator

使用Collections

IO

File对象

InputStream

OutputStream

Filter模式

操作Zip

读取classpath资源

序列化

Reader

Writer

PrintStream和PrintWriter

使用Files

日期与时间

基本概念

Date和Calendar

LocalDateTime

ZonedDateTime

DateTimeFormatter

Instant

最佳实践

单元测试

编写JUnit测试

使用Fixture

异常测试

条件测试

参数化测试

正则表达式

正则表达式简介

匹配规则

复杂匹配规则

分组匹配

非贪婪匹配

搜索和替换

加密与安全

编码算法

哈希算法

BouncyCastle

Hmac算法

对称加密算法

口令加密算法

密钥交换算法

非对称加密算法

签名算法

数字证书

多线程

多线程基础

创建新线程

线程的状态

中断线程

守护线程

线程同步

同步方法

死锁

使用wait和notify

使用ReentrantLock

使用Condition

使用ReadWriteLock

使用StampedLock

使用Semaphore

使用Concurrent集合

使用Atomic

使用线程池

使用Future

使用CompletableFuture

使用ForkJoin

使用ThreadLocal

使用虚拟线程

Maven基础

Maven介绍

依赖管理

构建流程

使用插件

模块管理

使用mvnw

发布Artifact

网络编程

网络编程基础

TCP编程

UDP编程

发送Email

接收Email

HTTP编程

RMI远程调用

XML与JSON

XML简介

使用DOM

使用SAX

使用Jackson

使用JSON

JDBC编程

JDBC简介

JDBC查询

JDBC更新

JDBC事务

JDBC Batch

JDBC连接池

函数式编程

Lambda基础

方法引用

使用Stream

创建Stream

使用map

使用filter

使用reduce

输出集合

其他操作

设计模式

创建型模式

工厂方法

抽象工厂

生成器

原型

单例

结构型模式

适配器

桥接

组合

装饰器

外观

享元

代理

行为型模式

责任链

命令

解释器

迭代器

中介

备忘录

观察者

状态

策略

模板方法

访问者

Web开发

Web基础

Servlet入门

Servlet开发

Servlet进阶

重定向与转发

使用Session和Cookie

JSP开发

MVC开发

MVC高级开发

使用Filter

修改请求

修改响应

使用Listener

部署

Spring开发

IoC容器

IoC原理

装配Bean

使用Annotation配置

定制Bean

使用Resource

注入配置

使用条件装配

使用AOP

装配AOP

使用注解装配AOP

AOP避坑指南

访问数据库

使用JDBC

使用声明式事务

使用DAO

集成Hibernate

集成JPA

集成MyBatis

设计ORM

开发Web应用

使用Spring MVC

使用REST

集成Filter

使用Interceptor

处理CORS

国际化

异步处理

使用WebSocket

集成第三方组件

集成JavaMail

集成JMS

使用Scheduler

集成JMX

Spring Boot开发

第一个Spring Boot应用

使用开发者工具

打包Spring Boot应用

瘦身Spring Boot应用

使用Actuator

使用Profiles

使用Conditional

加载配置文件

禁用自动配置

添加Filter

集成第三方组件

集成Open API

访问Redis

集成Artemis

集成RabbitMQ

集成Kafka

Spring Cloud开发

项目架构设计

搭建项目框架

设计交易引擎

设计资产系统

设计订单系统

设计撮合引擎

设计清算系统

完成交易引擎

设计定序系统

设计API系统

设计行情系统

设计推送系统

编写UI

项目总结

廖雪峰的官方网站

©Copyright 2019-2021

Powered by iTranswarp

Feedback

License

Spring Framework

ng FrameworkSkip to main contentWhy SpringOverviewMicroservicesReactiveEvent DrivenCloudWeb ApplicationsServerlessBatchLearnOverviewQuickstartGuidesBlogProjectsOverviewSpring BootSpring FrameworkSpring CloudSpring Cloud Data FlowSpring DataSpring IntegrationSpring BatchSpring SecurityView all projectsDEVELOPMENT TOOLSSpring Tools 4Spring InitializrAcademyCoursesGet CertifiedSolutionsOverviewTanzu Spring RuntimeSpring ConsultingSpring Academy For TeamsSecurity AdvisoriesCommunityOverviewEventsTeamSpring BootSpring FrameworkSpring DataSpring CloudSpring Cloud Data FlowSpring SecuritySpring Authorization ServerSpring for GraphQLSpring SessionSpring IntegrationSpring HATEOASSpring ModulithSpring REST DocsSpring AISpring BatchSpring CLISpring AMQPSpring CredHubSpring FloSpring for Apache KafkaSpring LDAPSpring for Apache PulsarSpring ShellSpring StatemachineSpring VaultSpring Web FlowSpring Web ServicesSpring Framework6.1.4OverviewLearnSupportThe Spring Framework provides a comprehensive programming and configuration model for modern Java-based enterprise applications - on any kind of deployment platform.

A key element of Spring is infrastructural support at the application level: Spring focuses on the "plumbing" of enterprise applications so that teams can focus on application-level business logic, without unnecessary ties to specific deployment environments.

Support Policy and Migration

For information about minimum requirements, guidance on upgrading from earlier versions and support policies, please check out the official Spring Framework wiki page

Features

Core technologies: dependency injection, events, resources, i18n, validation, data binding, type conversion, SpEL, AOP.

Testing: mock objects, TestContext framework, Spring MVC Test, WebTestClient.

Data Access: transactions, DAO support, JDBC, ORM, Marshalling XML.

Spring MVC and Spring WebFlux web frameworks.

Integration: remoting, JMS, JCA, JMX, email, tasks, scheduling, cache and observability.

Languages: Kotlin, Groovy, dynamic languages.

Quickstart Your ProjectBootstrap your application with Spring Initializr.Get aheadVMware offers training and certification to turbo-charge your progress.Learn moreGet supportTanzu Spring Runtime offers support and binaries for OpenJDK™, Spring, and Apache Tomcat® in one simple subscription.Learn moreUpcoming eventsCheck out all the upcoming events in the Spring community.View allWhy SpringMicroservicesReactiveEvent DrivenCloudWeb ApplicationsServerlessBatchLearnQuickstartGuidesBlogCommunityEventsTeamSolutionsTanzu Spring RuntimeSpring ConsultingSpring Academy For TeamsSpring AdvisoriesProjectsTrainingThank YouGet the Spring newsletterThank you for your interest. Someone will get back to you shortly.Copyright © 2005 - 2024 Broadcom. All Rights Reserved. The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries. Terms of Use • Privacy • Trademark Guidelines • Your California Privacy Rights • Cookie SettingsApache®, Apache Tomcat®, Apache Kafka®, Apache Cassandra™, and Apache Geode™ are trademarks or registered trademarks of the Apache Software Foundation in the United States and/or other countries. Java™, Java™ SE, Java™ EE, and OpenJDK™ are trademarks of Oracle and/or its affiliates. Kubernetes® is a registered trademark of the Linux Foundation in the United States and other countries. Linux® is the registered trademark of Linus Torvalds in the United States and other countries. Windows® and Microsoft® Azure are registered trademarks of Microsoft Corporation. “AWS” and “Amazon Web Services” are trademarks or registered trademarks of Amazon.com Inc. or its affiliates. All other trademarks and copyrights are property of their respective owners and are only mentioned for informative purposes. Other names may be trademarks of their respective owners.

Spring 教程_w3cschool

Spring 教程_w3cschool

编程入门教程

编程课程

编程实战

编程题库

在线工具

VIP会员

送会员

App下载

扫码下载编程狮APP

注册|登录

注册成功

X

W3Cschool

恭喜您成为首批注册用户

获得88经验值奖励

马上体验

入门教程

编程课程

VIP会员

Spring 教程

赞

收藏

更多文章

目录

搜索

书签

Spring 概述

Spring 体系结构

Spring 环境配置

Spring Hello World 实例

Spring IoC 容器

Spring BeanFactory 容器

Spring ApplicationContext 容器

Spring Bean 定义

Spring Bean 作用域

Spring Bean 生命周期

Spring Bean 后置处理器

Spring Bean 定义继承

Spring 依赖注入

Spring 基于构造函数的依赖注入

Spring 基于设值函数的依赖注入

Spring 注入内部 Beans

Spring 注入集合

Spring Beans 自动装配

Spring 自动装配 byName

Spring 自动装配 byType

Spring 由构造函数自动装配

Spring 基于注解的配置

Spring @Required 注解

Spring @Autowired 注解

Spring @Qualifier 注解

Spring JSR-250 注释

Spring 基于 Java 的配置

Spring 中的事件处理

Spring 中的自定义事件

Spring 框架的 AOP

Spring 中基于 AOP 的 XML架构

Spring 中基于 AOP 的 @AspectJ

Spring JDBC 框架

Spring JDBC 示例

Spring 中 SQL 的存储过程

Spring 事务管理

Spring 编程式事务管理

Spring 声明式事务管理

Spring Web MVC 框架

Spring MVC Hello World 例子

Spring MVC 表单处理例子

Spring 页面重定向例子

Spring 静态页面例子

Spring 异常处理例子

Spring 使用 Log4J 记录日志

搜索

A

A

默认

夜间

Spring 教程

阅读(6228.4k)

收藏

赞(521)

分享

手册简介

本教程是为需要详细了解 Spring 框架的体系结构和实际应用的 Java 程序员设计的。本教程将带你达到中级的专业知识水平，而你可以将自己提升至更高层次的专业知识水平。

手册说明

《Spring 教程》学前需知：在进行本教程之前，你应该对 Java 编程语言有一个很好的了解。对 Eclipse IDE 的基本了解也是必须的，因为所有的示例都是使用 Eclipse IDE 进行编译的。学习前提 本教程是为需要详细了解 Spring 框架的体系结构和实际应用的 Java 程序员设计的。本教程将带你达到中级的专业知识水平，而你可以将自己提升至更高层次的专业知识水平。适用人群 本教程是基于在 2015 年 3 月发布的 Spring 框架 4.1.6 版本编写的。Spring 框架最初是由 Rod Johnson 编写的，并且 2003 年 6 月首次在 Apache 2.0 许可下发布。Spring 框架是一个开源的 Java 平台，它为容易而快速的开发出耐用的 Java 应用程序提供了全面的基础设施。Spring的起源Spring对你的工程来说，它不需要一个以上的framework。Spring是潜在地一站式解决方案，定位于与典型应用相关的大部分基础结构。它也涉及到其他framework没有考虑到的内容。它的设计从底部帮助你编写易于测试的代码。Spring是用于测试驱动工程的理想的framework。Spring有分层的体系结构，这意味着你能选择使用它孤立的任何部分，它的架构仍然是内在稳定的。因此从你的学习中，你可得到最大的价值。例如，你可能选择仅仅使用Spring来简单化JDBC的使用，或用来管理所有的业务对象。Spring 是全面的和模块化的。Spring 致力于提供一种方法管理你的业务对象。它定位的领域是许多其他流行的framework没有的。因为诸多原因让 Spring 变得独特：当已经存在许多开放源代码（和专有）J2EEframework时，我们为什么还需要Spring Framework？可供参考的教程《Spring MVC 4.2.4.RELEASE 中文文档》《初识 Spring Security》《Spring Boot 那些事》《菜鸟学 SSH》可供参考的编程微课《Spring：学习Quartz分布式任务调度》《Spring Boot基础入门》《Spring 入门微课》推荐的书籍《Spring揭秘》《Spring技术内幕：深入解析Spring架构与设计原理》《Spring实战》

更新记录

Spring MVC Hello World 例子

06-26 15:24

Spring @Required 注解

03-07 16:49

Spring 中基于 AOP 的 XML架构

12-16 13:40

Spring ApplicationContext 容器

11-30 13:39

Spring 基于构造函数的依赖注入

09-28 13:55

Spring 环境配置

07-05 10:23

Spring 注入集合

05-21 17:45

Spring 注入内部 Beans

05-21 15:23

Spring 基于设值函数的依赖注入

05-21 15:23

Spring Bean 定义继承

05-21 15:22

多端阅读

在PC/MAC上查看《Spring 教程》

下载《Spring 教程》离线版客户端，进入客户端后通过搜索当前教程手册的名称并下载，就可查看当前离线教程文档。

在移动端查看《Spring 教程》

扫一扫或直接访问 https://m.w3cschool.cn/wkspring/

在手机APP上查看《Spring 教程》

下载w3cschool手机App端，请从各大安卓应用商店、苹果App Store搜索并下载w3cschool手机客户端，在App中搜索当前教程手册的名称查看。

返回w3cschool官网主页

扩展栏目

开发工具IDE

编程训练营

Wiki列表

分类导航

最新推荐

免费Jquery插件合集

前端学习资源汇总

微信小程序资源汇总

Smarty 教程

SEO基础知识教程

Spring 教程

热门教程

Python3 教程

Java 教程

VUE3 教程

微信小程序开发文档

鸿蒙OS开发文档

HTML 教程

C语言教程

C++ 教程

Linux 教程

SQL 教程

PHP 教程

JavaScript 教程

HTML/CSS

HTML 教程

XHTML 教程

HTML5 教程

HTML 参考手册

CSS 教程

CSS3 教程

CSS 参考手册

Less 教程

Sass 教程

JavaScript

JavaScript 教程

HTML DOM 教程

JavaScript 和 HTML DOM 参考手册

JSON 教程

AJAX 教程

jQuery 教程

ES6 中文教程

TypeScript 教程

Node.js 教程

VUE3 教程

Vue.js 2.0 教程

Vue CLI 中文教程

React 教程

AngularJS 教程

Angular13

Highcharts 教程

ECharts 教程

Axios 中文文档

前端框架

Bootstrap4 教程

vue3.0 ElementPlus 中文版教程

Element React 中文文档

Vant 中文教程

Vant3 中文教程

Vant4

后端语言

Python3 教程

Java 教程

PHP 教程

Go 教程

C语言教程

C++ 教程

Kotlin 教程

Node.js 教程

C# 教程

R语言 教程

Ruby 教程

Lua 教程

ASP.NET 教程

Julia 教程

Excel VBA 编程教程

MATLAB 教程

Rust 语言中文版

Swift 教程

开发框架

Servlet 教程

JSP 教程

Spring 教程

Hibernate 教程

MyBatis 3手册

MyBatis-Plus教程

SpringBoot 那些事

jUnit 教程

SWING 教程

Django4 中文教程

Flask 教程

FastAPI 教程

Python Tornado教程

Gin 教程

iris教程

GoFrame教程

Revel 教程

WordPress 教程

数据库

MySQL 教程

Oracle 教程

PostgreSQL 13.1 中文教程

Redis 教程

SQL 教程

MariaDB 教程

SQLite 教程

MS Access 教程

MongoDB 教程

neo4j 教程

Storm 入门教程

Spark 编程指南

移动开发

鸿蒙OS开发文档

微信小程序开发文档

Android 教程

Android SDK 上手指南

iOS 开发手册

jQuery Mobile 教程

React Native 中文文档

uni-app 中文文档

小程序云开发高级教程

小程序云开发学习指南

Flutter 中文文档

Knockout应用开发指南

服务器相关

Linux 教程

Docker 教程

Kubernetes(k8s)手册

Docker 从入门到实践

DOS 命令学习手册

Nginx 入门指南

Shell 编程范例

UNIX 入门指南

Linux就该这么学

开发工具

Visual Studio Code 教程

Sublime Text 使用手册

Atom 教程

Vim 教程

Eclipse 教程

IntelliJ-IDEA中文教程

Git 教程

SVN 教程

Apache Ant 教程

Gradle 教程

Maven 教程

通俗易懂的 Npm 入门教程

Composer 教程

Vite教程

Webpack 中文指南

Flex 教程

Grunt 教程

HBuilder 使用教程

Tableau 教程

Chrome 开发工具指南

Electron 中文文档

正则表达式

Arduino 教程

Verilog手册

大数据

Hadoop 教程

Apache Pig 教程

Apache Kafka 教程

Apache Storm 教程

impala 教程

Zookeeper 教程

SAS 教程

Moralis Web3 企业级API

云数据库OceanBase教程

软件工程

软件工程教程

设计模式

软件测试教程

UML 教程

PHP设计模式

人工智能

Midjourney中文教程

AI人工智能教程

Copyright©2021 w3cschool编程狮|闽ICP备15016281号-3|闽公网安备35020302033924号

违法和不良信息举报电话：173-0602-2364|举报邮箱：jubao@eeedong.com

在线笔记

App下载

扫描二维码

下载编程狮App

公众号

编程狮公众号

意见反馈

意见反馈

X

意见反馈：

联系方式：

提交

查看完整版笔记

保存

关闭

教程纠错

教程纠错

违规举报

X

广告等垃圾信息

不友善内容

违反法律法规的内容

不宜公开讨论的政治内容

其他

提交

Spring Framework Documentation :: Spring Framework

Spring Framework Documentation :: Spring Framework

Why Spring

Overview

Microservices

Reactive

Event

Driven

Cloud

Web

Applications

Serverless

Batch

Learn

Overview

Quickstart

Guides

Blog

Projects

Overview

Spring Boot

Spring Framework

Spring Cloud

Spring Cloud Data Flow

Spring Data

Spring Integration

Spring Batch

Spring Security

View all projects

Spring Tools 4

Spring Initializr

Academy

Courses

Get Certified

Solutions

Overview

Spring Runtime

Spring Consulting

Spring Academy For Teams

Security Advisories

Community

Overview

Events

Team

light

Spring Framework

6.1.4

Search

Overview

Core Technologies

The IoC Container

Introduction to the Spring IoC Container and Beans

Container Overview

Bean Overview

Dependencies

Dependency Injection

Dependencies and Configuration in Detail

Using depends-on

Lazy-initialized Beans

Autowiring Collaborators

Method Injection

Bean Scopes

Customizing the Nature of a Bean

Bean Definition Inheritance

Container Extension Points

Annotation-based Container Configuration

Using @Autowired

Fine-tuning Annotation-based Autowiring with @Primary

Fine-tuning Annotation-based Autowiring with Qualifiers

Using Generics as Autowiring Qualifiers

Using CustomAutowireConfigurer

Injection with @Resource

Using @Value

Using @PostConstruct and @PreDestroy

Classpath Scanning and Managed Components

Using JSR 330 Standard Annotations

Java-based Container Configuration

Basic Concepts: @Bean and @Configuration

Instantiating the Spring Container by Using AnnotationConfigApplicationContext

Using the @Bean Annotation

Using the @Configuration annotation

Composing Java-based Configurations

Environment Abstraction

Registering a LoadTimeWeaver

Additional Capabilities of the ApplicationContext

The BeanFactory API

Resources

Validation, Data Binding, and Type Conversion

Validation by Using Spring’s Validator Interface

Resolving Codes to Error Messages

Data Binding

Spring Type Conversion

Spring Field Formatting

Configuring a Global Date and Time Format

Java Bean Validation

Spring Expression Language (SpEL)

Evaluation

Expressions in Bean Definitions

Language Reference

Literal Expressions

Properties, Arrays, Lists, Maps, and Indexers

Inline Lists

Inline Maps

Array Construction

Methods

Operators

Types

Constructors

Variables

Functions

Bean References

Ternary Operator (If-Then-Else)

The Elvis Operator

Safe Navigation Operator

Collection Selection

Collection Projection

Expression Templating

Classes Used in the Examples

Aspect Oriented Programming with Spring

AOP Concepts

Spring AOP Capabilities and Goals

AOP Proxies

@AspectJ support

Enabling @AspectJ Support

Declaring an Aspect

Declaring a Pointcut

Declaring Advice

Introductions

Aspect Instantiation Models

An AOP Example

Schema-based AOP Support

Choosing which AOP Declaration Style to Use

Mixing Aspect Types

Proxying Mechanisms

Programmatic Creation of @AspectJ Proxies

Using AspectJ with Spring Applications

Further Resources

Spring AOP APIs

Pointcut API in Spring

Advice API in Spring

The Advisor API in Spring

Using the ProxyFactoryBean to Create AOP Proxies

Concise Proxy Definitions

Creating AOP Proxies Programmatically with the ProxyFactory

Manipulating Advised Objects

Using the "auto-proxy" facility

Using TargetSource Implementations

Defining New Advice Types

Null-safety

Data Buffers and Codecs

Logging

Ahead of Time Optimizations

Appendix

XML Schemas

XML Schema Authoring

Application Startup Steps

Testing

Introduction to Spring Testing

Unit Testing

Integration Testing

JDBC Testing Support

Spring TestContext Framework

Key Abstractions

Bootstrapping the TestContext Framework

TestExecutionListener Configuration

Application Events

Test Execution Events

Context Management

Context Configuration with XML resources

Context Configuration with Groovy Scripts

Context Configuration with Component Classes

Mixing XML, Groovy Scripts, and Component Classes

Configuration Configuration with Context Customizers

Context Configuration with Context Initializers

Context Configuration Inheritance

Context Configuration with Environment Profiles

Context Configuration with Test Property Sources

Context Configuration with Dynamic Property Sources

Loading a WebApplicationContext

Working with Web Mocks

Context Caching

Context Failure Threshold

Context Hierarchies

Dependency Injection of Test Fixtures

Testing Request- and Session-scoped Beans

Transaction Management

Executing SQL Scripts

Parallel Test Execution

TestContext Framework Support Classes

Ahead of Time Support for Tests

WebTestClient

MockMvc

Overview

Static Imports

Setup Choices

Setup Features

Performing Requests

Defining Expectations

Async Requests

Streaming Responses

Filter Registrations

MockMvc vs End-to-End Tests

Further Examples

HtmlUnit Integration

Why HtmlUnit Integration?

MockMvc and HtmlUnit

MockMvc and WebDriver

MockMvc and Geb

Testing Client Applications

Appendix

Annotations

Standard Annotation Support

Spring Testing Annotations

@BootstrapWith

@ContextConfiguration

@WebAppConfiguration

@ContextHierarchy

@ContextCustomizerFactories

@ActiveProfiles

@TestPropertySource

@DynamicPropertySource

@DirtiesContext

@TestExecutionListeners

@RecordApplicationEvents

@Commit

@Rollback

@BeforeTransaction

@AfterTransaction

@Sql

@SqlConfig

@SqlMergeMode

@SqlGroup

@DisabledInAotMode

Spring JUnit 4 Testing Annotations

Spring JUnit Jupiter Testing Annotations

Meta-Annotation Support for Testing

Further Resources

Data Access

Transaction Management

Advantages of the Spring Framework’s Transaction Support Model

Understanding the Spring Framework Transaction Abstraction

Synchronizing Resources with Transactions

Declarative Transaction Management

Understanding the Spring Framework’s Declarative Transaction Implementation

Example of Declarative Transaction Implementation

Rolling Back a Declarative Transaction

Configuring Different Transactional Semantics for Different Beans

Settings

Using @Transactional

Transaction Propagation

Advising Transactional Operations

Using @Transactional with AspectJ

Programmatic Transaction Management

Choosing Between Programmatic and Declarative Transaction Management

Transaction-bound Events

Application server-specific integration

Solutions to Common Problems

Further Resources

DAO Support

Data Access with JDBC

Choosing an Approach for JDBC Database Access

Package Hierarchy

Using the JDBC Core Classes to Control Basic JDBC Processing and Error Handling

Controlling Database Connections

JDBC Batch Operations

Simplifying JDBC Operations with the SimpleJdbc Classes

Modeling JDBC Operations as Java Objects

Common Problems with Parameter and Data Value Handling

Embedded Database Support

Initializing a DataSource

Data Access with R2DBC

Object Relational Mapping (ORM) Data Access

Introduction to ORM with Spring

General ORM Integration Considerations

Hibernate

JPA

Marshalling XML by Using Object-XML Mappers

Appendix

Web on Servlet Stack

Spring Web MVC

DispatcherServlet

Context Hierarchy

Special Bean Types

Web MVC Config

Servlet Config

Processing

Path Matching

Interception

Exceptions

View Resolution

Locale

Themes

Multipart Resolver

Logging

Filters

Annotated Controllers

Declaration

Mapping Requests

Handler Methods

Method Arguments

Return Values

Type Conversion

Matrix Variables

@RequestParam

@RequestHeader

@CookieValue

@ModelAttribute

@SessionAttributes

@SessionAttribute

@RequestAttribute

Redirect Attributes

Flash Attributes

Multipart

@RequestBody

HttpEntity

@ResponseBody

ResponseEntity

Jackson JSON

Model

@InitBinder

Validation

Exceptions

Controller Advice

Functional Endpoints

URI Links

Asynchronous Requests

CORS

Error Responses

Web Security

HTTP Caching

View Technologies

Thymeleaf

FreeMarker

Groovy Markup

Script Views

JSP and JSTL

RSS and Atom

PDF and Excel

Jackson

XML Marshalling

XSLT Views

MVC Config

Enable MVC Configuration

MVC Config API

Type Conversion

Validation

Interceptors

Content Types

Message Converters

View Controllers

View Resolvers

Static Resources

Default Servlet

Path Matching

Advanced Java Config

Advanced XML Config

HTTP/2

REST Clients

Testing

WebSockets

WebSocket API

SockJS Fallback

STOMP

Overview

Benefits

Enable STOMP

WebSocket Transport

Flow of Messages

Annotated Controllers

Sending Messages

Simple Broker

External Broker

Connecting to a Broker

Dots as Separators

Authentication

Token Authentication

Authorization

User Destinations

Order of Messages

Events

Interception

STOMP Client

WebSocket Scope

Performance

Monitoring

Testing

Other Web Frameworks

Web on Reactive Stack

Spring WebFlux

Overview

Reactive Core

DispatcherHandler

Annotated Controllers

@Controller

Mapping Requests

Handler Methods

Method Arguments

Return Values

Type Conversion

Matrix Variables

@RequestParam

@RequestHeader

@CookieValue

@ModelAttribute

@SessionAttributes

@SessionAttribute

@RequestAttribute

Multipart Content

@RequestBody

HttpEntity

@ResponseBody

ResponseEntity

Jackson JSON

Model

DataBinder

Validation

Exceptions

Controller Advice

Functional Endpoints

URI Links

CORS

Error Responses

Web Security

HTTP Caching

View Technologies

WebFlux Config

HTTP/2

WebClient

Configuration

retrieve()

Exchange

Request Body

Filters

Attributes

Context

Synchronous Use

Testing

HTTP Interface Client

WebSockets

Testing

RSocket

Reactive Libraries

Integration

REST Clients

JMS (Java Message Service)

Using Spring JMS

Sending a Message

Receiving a Message

Support for JCA Message Endpoints

Annotation-driven Listener Endpoints

JMS Namespace Support

JMX

Exporting Your Beans to JMX

Controlling the Management Interface of Your Beans

Controlling ObjectName Instances for Your Beans

Using JSR-160 Connectors

Accessing MBeans through Proxies

Notifications

Further Resources

Email

Task Execution and Scheduling

Cache Abstraction

Understanding the Cache Abstraction

Declarative Annotation-based Caching

JCache (JSR-107) Annotations

Declarative XML-based Caching

Configuring the Cache Storage

Plugging-in Different Back-end Caches

How can I Set the TTL/TTI/Eviction policy/XXX feature?

Observability Support

JVM Checkpoint Restore

CDS

Appendix

Language Support

Kotlin

Requirements

Extensions

Null-safety

Classes and Interfaces

Annotations

Bean Definition DSL

Web

Coroutines

Spring Projects in Kotlin

Getting Started

Resources

Apache Groovy

Dynamic Language Support

Appendix

Wiki

Search

Edit this Page

GitHub Project

Stack Overflow

Spring Framework

Spring Framework Documentation

Spring Framework Documentation

Overview

History, Design Philosophy, Feedback,

Getting Started.

Core

IoC Container, Events, Resources, i18n,

Validation, Data Binding, Type Conversion, SpEL, AOP, AOT.

Testing

Mock Objects, TestContext Framework,

Spring MVC Test, WebTestClient.

Data Access

Transactions, DAO Support,

JDBC, R2DBC, O/R Mapping, XML Marshalling.

Web Servlet

Spring MVC, WebSocket, SockJS,

STOMP Messaging.

Web Reactive

Spring WebFlux, WebClient,

WebSocket, RSocket.

Integration

REST Clients, JMS, JCA, JMX,

Email, Tasks, Scheduling, Caching, Observability, JVM Checkpoint Restore.

Languages

Kotlin, Groovy, Dynamic Languages.

Appendix

Spring properties.

Wiki

What’s New,

Upgrade Notes, Supported Versions, additional cross-version information.

Rod Johnson, Juergen Hoeller, Keith Donald, Colin Sampaleanu, Rob Harrop, Thomas Risberg,

Alef Arendsen, Darren Davison, Dmitriy Kopylenko, Mark Pollack, Thierry Templier, Erwin

Vervaet, Portia Tung, Ben Hale, Adrian Colyer, John Lewis, Costin Leau, Mark Fisher, Sam

Brannen, Ramnivas Laddad, Arjen Poutsma, Chris Beams, Tareq Abedrabbo, Andy Clement, Dave

Syer, Oliver Gierke, Rossen Stoyanchev, Phillip Webb, Rob Winch, Brian Clozel, Stephane

Nicoll, Sebastien Deleuze, Jay Bryant, Mark Paluch

Copyright © 2002 - 2024 VMware, Inc. All Rights Reserved.

Copies of this document may be made for your own use and for distribution to others,

provided that you do not charge any fee for such copies and further provided that each

copy contains this Copyright Notice, whether distributed in print or electronically.

Overview

Spring Framework

6.2.0-SNAPSHOT

6.1.5-SNAPSHOT

6.1.4current

6.0.18-SNAPSHOT

6.0.17

Related Spring Documentation

Spring Framework

Spring Cloud

Spring Cloud Build

Spring Cloud Bus

Spring Cloud Circuit Breaker

Spring Cloud Commons

Spring Cloud Config

Spring Cloud Consul

Spring Cloud Contract

Spring Cloud Function

Spring Cloud Gateway

Spring Cloud Kubernetes

Spring Cloud Netflix

Spring Cloud OpenFeign

Spring Cloud Stream

Spring Cloud Task

Spring Cloud Vault

Spring Cloud Zookeeper

Spring Data

Spring Data Cassandra

Spring Data Commons

Spring Data Couchbase

Spring Data Elasticsearch

Spring Data JPA

Spring Data KeyValue

Spring Data LDAP

Spring Data MongoDB

Spring Data Neo4j

Spring Data Redis

Spring Data JDBC & R2DBC

Spring Data REST

Spring Integration

Spring Batch

Spring Security

Spring Authorization Server

Spring LDAP

Spring Security Kerberos

Spring Session

Spring Vault

Spring AI

Spring CLI

Spring GraphQL

Spring for Apache Kafka

Spring Modulith

Spring for Apache Pulsar

Spring Shell

All Docs...

© VMware, Inc. or its affiliates. Terms of Use • Privacy • Trademark Guidelines • Thank you • Your California Privacy Rights • Cookie Settings

Apache®, Apache Tomcat®, Apache Kafka®, Apache Cassandra™, and Apache Geode™ are trademarks or registered trademarks of the Apache Software Foundation in the United States and/or other countries. Java™, Java™ SE, Java™ EE, and OpenJDK™ are trademarks of Oracle and/or its affiliates. Kubernetes® is a registered trademark of the Linux Foundation in the United States and other countries. Linux® is the registered trademark of Linus Torvalds in the United States and other countries. Windows® and Microsoft® Azure are registered trademarks of Microsoft Corporation. “AWS” and “Amazon Web Services” are trademarks or registered trademarks of Amazon.com Inc. or its affiliates. All other trademarks and copyrights are property of their respective owners and are only mentioned for informative purposes. Other names may be trademarks of their respective owners.

Search in all Spring Docs

Spring 中文网

Spring 中文网

为什么 Spring

指南

项目

Spring Boot

Spring Cloud

文档

概述

微服务

反应性

事件驱动

云

网络应用

无服务器

批

快速开始

指南

Overview

Spring Boot

Spring Framework

Spring Cloud

Spring Cloud Data Flow

Spring Data

Spring Integration

Spring Batch

Spring Security

View all projects

Development Tools

Spring Tools 4

Spring Initializr

Spring Data 文档Spring Framework 文档Spring Boot 文档Spring Cloud 文档Spring Cloud Data Flow 文档Spring Security 文档Spring for GraphQL 文档Spring Integration 文档Spring HATEOAS 文档Spring REST Docs 文档Spring Batch 文档Spring AMQP 文档Spring CredHub 文档Spring for Apache Kafka 文档Spring LDAP 文档Spring Shell 文档Spring Statemachine 文档Spring Vault 文档Spring Web Flow 文档Spring Web Services 文档

close

为什么 Spring

Overview

Microservices

Reactive

Event Driven

Cloud

Web Applications

Serverless

Batch

Learn

Overview

Quickstart

Guides

Blog

Projects

Overview

Spring Boot

Spring Framework

Spring Cloud

Spring Cloud Data Flow

Spring Data

Spring Integration

Spring Batch

Spring Security

View all projects

Development Tools

Spring Tools 4

Spring Initializr

Training

Support

Community

Overview

Events

Team

Spring 使 Java

简单化。

现代化。

富有成效。

反应性。

轻松上云。

为什么Spring

快速开始

Spring 参考文档

Spring Data文档

Spring Framework文档

Spring Boot文档

Spring Cloud文档

Spring Cloud Data Flow文档

Spring Security文档

Spring for GraphQL文档

Spring Integration文档

Spring HATEOAS文档

Spring REST Docs文档

Spring Batch文档

Spring AMQP文档

Spring CredHub文档

Spring for Apache Kafka文档

Spring LDAP文档

Spring Shell文档

Spring Statemachine文档

Spring Vault文档

Spring Web Flow文档

Spring Web Services文档

Spring 能做什么

微服务

通过可独立发展的微服务快速交付生产级功能。

反应性

Spring的异步，无阻塞体系结构意味着您可以从计算资源中获得更多收益。

云

您的代码，任何云-我们已为您覆盖。无论您使用什么平台，都可以连接并扩展您的服务。

网路应用程式

连接到任何数据存储的快速，安全和响应式Web应用程序的框架。

无服务器

极致的灵活性。按需扩展并在没有需求时扩展为零。

事件驱动

与您的企业集成。对业务事件做出反应。实时处理您的流数据。

批

自动化任务。一次适合您的离线数据处理。

@SpringBootApplication

@RestController

public class DemoApplication {

@GetMapping("/helloworld")

public String hello() {

return String.format("Hello World!");

}

}

升级您的Java™代码

和 春季靴 在您的应用中，只需几行代码就可以像老板一样开始构建服务。春季新手？试试我们的简单快速入门指南。

最初[Netflix Java]库和框架是内部构建的。我非常自豪地说，截至2019年初，我们几乎将平台移至了Spring Boot。”

Netflix高级软件工程师Taylor Wicksell

立即观看

本站内容由 Spring 中文网 翻译整理。翻译整理工作非常辛苦，转载请注明出处。捐助我们。