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™ codeWith 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">
@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配置文件中进行了以下声明
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依赖。
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 环境搭建导入相关依赖：
重点是注意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
//新增学生
void addStudent(Student student);
}mapper.xml映射文件
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
select * from student
insert into student (stuno,stuname,cardid,classid)
values (#{stuNo},#{stuName},#{cardID},#{classID})
service接口public interface IStudentService {
List
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
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">
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
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 环境搭建加入事务相关依赖
案例：数据库有两张表，一张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}
select * from goods 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依赖 改造项目结构，在main下新建resources目录，并设置为类路径案例还是采用整合mybatis那个案例，这次给用户提供一个表单，用户填写用户信息，将数据存入student表中。注册页<%@ page contentType="text/html;charset=UTF-8" language="java" %>
欢迎注册
效果展示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配置文件中加入如下约束
总结：希望大家共同进步，有兴趣的可以互相加个关注。发布于 2022-04-15 19:38JavaSpring程序员赞同 906 条评论分享喜欢收藏申请
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
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
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 中文网 翻译整理。翻译整理工作非常辛苦，转载请注明出处。捐助我们。