Spring复习笔记

最新推荐文章于 2023-12-21 16:49:32 发布
最新推荐文章于 2023-12-21 16:49:32 发布
阅读量130 收藏
点赞数
文章标签： spring java mvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tl1216/article/details/126456858
版权

Spring

1.Spring概述

1.1Spring是什么

Spring是分层的JavaSE/EE应用full-stack轻量级开源框架，以IoC（Inverse Of Control：反转控制）和AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层Spring MVC和持久层Spring JDBC以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE企业应用开源框架。

1.2Spring发展历程

1997 年 IBM 提出了 EJB 的思想
1998 年，SUN 制定开发标准规范 EJB1.0
1999 年，EJB1.1 发布
2001 年，EJB2.0 发布
2003 年，EJB2.1 发布
2006 年，EJB3.0 发布
Rod Johnson（Spring 之父）
Expert One-to-One J2EE Design and Development(2002)
阐述了 J2EE 使用 EJB 开发设计的优点及解决方案 Expert One-to-One J2EE Development without EJB(2004)
阐述了 J2EE 开发不使用 EJB 的解决方式（Spring 雏形）
2017 年 9 月份发布了 Spring 的版本 Spring 5.0 通用版（GA）

1.3Spring的优势

方便解耦，简化开发
通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
AOP编程的支持
通过Spring的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。
声明式事务的支持
可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，提高开发效率和质量。
方便程序的测试
可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。
方便集成各种优秀框架
Spring可以降低各种框架的使用难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的直接支持。
降低JavaEEAPI的使用难度
Spring对JavaEEAPI（如JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些API的使用难度大为降低。
Java源码是经典学习范例
Spring的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。它的源代码无意是Java技术的最佳实践的范例。

1.4Spring的体系结构

在这里插入图片描述

2.IOC的概念和作用

2.1IOC思想

  1. 获取资源的传统方式
    自己做饭：买菜、洗菜、改刀、炒菜、全过程参与、费时费力、必须清除了解资源创建整个过程全部细节且熟练掌握。
    在应用程序中的组件需要获取资料时，传统的方式是组键自动的从容器中获取所需要的资料，在这样的模式下开发的人员需要知道在具体容器中特定资源的获取方式，增加了学习成本，同时降低了开发效率

  2. 反转控制获取资源
    点外卖：下单 等 吃 省时省力 不必关心资源创建过程所有细节
    反转控制的思想完全颠覆了应用程序组件获取资源的传统方式，反转了资源获取方向，改由容器主动将资料推送给需要的组键，开发人员不需要知道容器是如何创建对象的，只需要提供资源方式即可，极大的降低了学习成本，提高了开发效率，这种行为也称称为查找的被动形式

  3. DI
    DI：Dependency Injection，翻译过来是依赖注入。
    DI 是 IOC 的另一种表述方式：即组件以一些预先定义好的方式（例如：setter 方法）接受来自于容器
    的资源注入。相对于IOC而言，这种表述更直接。
    所以结论是：IOC 就是一种反转控制的思想， 而 DI 是对 IOC 的一种具体实现

  4. IOC容器在Spring中的实现
    Spring 的 IOC 容器就是 IOC 思想的一个落地的产品实现。IOC 容器中管理的组件也叫做 bean。在创建
    bean 之前，首先需要创建 IOC 容器。Spring 提供了 IOC 容器的两种实现方式：
    ①BeanFactory
    这是 IOC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。
    ②ApplicationContext
    BeanFactory 的子接口，提供了更多高级特性。面向 Spring 的使用者，几乎所有场合都使用
    ApplicationContext 而不是底层的 BeanFactory。
    在这里插入图片描述
    在这里插入图片描述

2.2基于XML管理bean

2.2.1入门案例①创建Maven Module

①创建Maven Module

②引入依赖

<dependencies>
<!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.1</version>
</dependency>
<!-- junit测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>

依赖里的spring-content代表spring上下文，也就是spring相关的依赖都会被引入，如下图所示
在这里插入图片描述
③创建类HelloWorld

public class HelloWorld {
public void sayHello(){
System.out.println("helloworld");
}
}

④创建Spring的配置文件
在这里插入图片描述
在这里插入图片描述
⑤在Spring的配置文件中配置bean

<!--
配置HelloWorld所对应的bean，即将HelloWorld的对象交给Spring的IOC容器管理
通过bean标签配置IOC容器所管理的bean
属性：
id：设置bean的唯一标识
class：设置bean所对应类型的全类名
-->
<bean id="helloworld" class="com.atguigu.spring.bean.HelloWorld"></bean>

⑥创建测试类测试

@Test
public void testHelloWorld(){
ApplicationContext ac = new
ClassPathXmlApplicationContext("applicationContext.xml");
HelloWorld helloworld = (HelloWorld) ac.getBean("helloworld");
helloworld.sayHello();
}

在这里插入图片描述

2.2.2获取bean

①方式一：根据id获取
由于 id 属性指定了 bean 的唯一标识，所以根据 bean 标签的 id 属性可以精确获取到一个组件对象。
上个实验中我们使用的就是这种方式。
②方式二：根据类型获取

@Test
public void testHelloWorld(){
ApplicationContext ac = new
ClassPathXmlApplicationContext("applicationContext.xml");
HelloWorld bean = ac.getBean(HelloWorld.class);
bean.sayHello();
}

③方式三：根据id和类型

@Test
public void testHelloWorld(){
ApplicationContext ac = new
ClassPathXmlApplicationContext("applicationContext.xml");
HelloWorld bean = ac.getBean("helloworld", HelloWorld.class);
bean.sayHello();
}

④注意
当根据类型获取bean时，要求IOC容器中指定类型的bean有且只能有一个
当IOC容器中一共配置了两个：

<bean id="helloworldOne" class="com.atguigu.spring.bean.HelloWorld"></bean>
<bean id="helloworldTwo" class="com.atguigu.spring.bean.HelloWorld"></bean>

根据类型获取时会抛出异常：

org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean
of type 'com.atguigu.spring.bean.HelloWorld' available: expected single matching bean but
found 2: helloworldOne,helloworldTwo

⑤扩展
如果组件类实现了接口，根据接口类型可以获取 bean 吗？
可以，前提是bean唯一（多态性），子类可以转为父类的类型，所以接口的类型也可以视为实现类的类型，所以可以根据接口类型，获取实现类的bean
如果一个接口有多个实现类，这些实现类都配置了 bean，根据接口类型可以获取 bean 吗？
不行，因为bean不唯一
class属性后不可以写接口，因为接口不可实例化，bean要求可实例化
可以从生命周期的角度解释，因为spring读取xml配置文件后，第一步会对xml文件中的类实例化，如果为接口那么第一步就无法完成，所以class属性后不可以写接口
⑥结论
根据类型来获取bean时，在满足bean唯一性的前提下，其实只是看：『对象 instanceof 指定的类
型』的返回结果，只要返回的是true就可以认定为和类型匹配，能够获取到
子类instance of父类结果为true 父类instance of子类 结果为false。

2.2.3依赖注入之setter注入

①创建学生类Student

public class Student {
private Integer id;
private String name;
private Integer age;
private String sex;
public Student() {
}
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 getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
'}';
}}

②配置bean时为属性赋值

<bean id="studentOne" class="com.atguigu.spring.bean.Student">
<!-- property标签：通过组件类的setXxx()方法给组件对象设置属性 -->
<!-- name属性：指定属性名（这个属性名是getXxx()、setXxx()方法定义的，和成员变量无关）
spring会调用set方法对property的属性赋值
-->
<!-- value属性：指定属性值 -->
<property name="id" value="1001"></property>
<property name="name" value="张三"></property>
<property name="age" value="23"></property>
<property name="sex" value="男"></property>
</bean>

③测试

@Test
public void testDIBySet(){
ApplicationContext ac = new ClassPathXmlApplicationContext("spring-di.xml");
Student studentOne = ac.getBean("studentOne", Student.class);
System.out.println(studentOne);
}

2.2.4依赖注入之构造器注入

①在Student类中添加有参构造

public Student(Integer id, String name, Integer age, String sex) {
this.id = id;
this.name = name;
this.age = age;
this.sex = sex;
}

②配置bean

<bean id="studentTwo" class="com.atguigu.spring.bean.Student">
<constructor-arg value="1002"></constructor-arg>
<constructor-arg value="李四"></constructor-arg>
<constructor-arg value="33"></constructor-arg>
<constructor-arg value="女"></constructor-arg>
</bean>

注意：
constructor-arg标签还有两个属性可以进一步描述构造器参数：
index属性：指定参数所在位置的索引（从0开始）
name属性：指定参数名
③测试

@Test
public void testDIBySet(){
ApplicationContext ac = new ClassPathXmlApplicationContext("spring-di.xml");
Student studentOne = ac.getBean("studentTwo", Student.class);
System.out.println(studentOne);
}

当有两个同样数量的有参构造时
在这里插入图片描述
需要指定name
在这里插入图片描述

2.2.5特殊值处理

①字面量赋值
什么是字面量？
int a = 10;
声明一个变量a，初始化为10，此时a就不代表字母a了，而是作为一个变量的名字。当我们引用a
的时候，我们实际上拿到的值是10。
而如果a是带引号的：‘a’，那么它现在不是一个变量，它就是代表a这个字母本身，这就是字面
量。所以字面量没有引申含义，就是我们看到的这个数据本身。
个人理解：字面量就是字面意义的量，类似$().text(“<font>abc</font>”)不会对里面的文本进行解析，只是淡出把其当作普通字符串

<!-- 使用value属性给bean的属性赋值时，Spring会把value属性的值看做字面量 -->
<property name="name" value="张三"/>

②null值
![注意：
在这里插入图片描述

以上写法，为name所赋的值是字符串null】

③xml实体
在这里插入图片描述

④CDATA节
在这里插入图片描述

2.2.6为类类型属性赋值

①创建班级类Clazz

public class Clazz {
private Integer clazzId;
private String clazzName;
public Integer getClazzId() {
return clazzId;
}
public void setClazzId(Integer clazzId) {
this.clazzId = clazzId;
}
public String getClazzName() {
return clazzName;
}
public void setClazzName(String clazzName) {
this.clazzName = clazzName;
}
@Override
public String toString() {
return "Clazz{" +
"clazzId=" + clazzId +
", clazzName='" + clazzName + '\'' +
'}';
}
public Clazz() {
}
public Clazz(Integer clazzId, String clazzName) {
this.clazzId = clazzId;
this.clazzName = clazzName;
}
}

②修改Student类
在Student类中添加以下代码：

private Clazz clazz;
public Clazz getClazz() {
return clazz;
}
public void setClazz(Clazz clazz) {
this.clazz = clazz;
}

③方式一：引用外部已声明的bean
配置Clazz类型的bean：

<bean id="clazzOne" class="com.atguigu.spring.bean.Clazz">
<property name="clazzId" value="1111"></property>
<property name="clazzName" value="财源滚滚班"></property>
</bean>
为Student中的clazz属性赋值：
<bean id="studentFour" class="com.atguigu.spring.bean.Student">
<property name="id" value="1004"></property>
<property name="name" value="赵六"></property>
<property name="age" value="26"></property>
<property name="sex" value="女"></property>
<!-- ref属性：引用IOC容器中某个bean的id，将所对应的bean为属性赋值 -->
<property name="clazz" ref="clazzOne"></property>
</bean>
错误演示：
<bean id="studentFour" class="com.atguigu.spring.bean.Student">
<property name="id" value="1004"></property>
<property name="name" value="赵六"></property>
<property name="age" value="26"></property>
<property name="sex" value="女"></property>
<property name="clazz" value="clazzOne"></property>
</bean>

如果错把ref属性写成了value属性，会抛出异常： Caused by: java.lang.IllegalStateException:
Cannot convert value of type ‘java.lang.String’ to required type
‘com.atguigu.spring.bean.Clazz’ for property ‘clazz’: no matching editors or conversion
strategy found
意思是不能把String类型转换成我们要的Clazz类型，说明我们使用value属性时，Spring只把这个
属性看做一个普通的字符串，不会认为这是一个bean的id，更不会根据它去找到bean来赋值
④方式二：内部bean

<bean id="studentFour" class="com.atguigu.spring.bean.Student">
<property name="id" value="1004"></property>
<property name="name" value="赵六"></property>
<property name="age" value="26"></property>
<property name="sex" value="女"></property>
<property name="clazz" value="clazzOne"></property>
</bean>

③方式三：级联属性赋值

<bean id="studentFour" class="com.atguigu.spring.bean.Student">
<property name="id" value="1004"></property>
<property name="name" value="赵六"></property>
<property name="age" value="26"></property>
<property name="sex" value="女"></property>
<!-- 一定先引用某个bean为属性赋值，才可以使用级联方式更新属性 -->
<property name="clazz" ref="clazzOne"></property>
<property name="clazz.clazzId" value="3333"></property>
<property name="clazz.clazzName" value="最强王者班"></property>
</bean>

2.2.7为数组类型属性赋值

在这里插入图片描述

2.2.8为集合类型属性赋值

①为List集合类型属性赋值
在Clazz类中添加以下代码：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
引入集合必须加util约束

2.2.9p命名空间

在这里插入图片描述

2.2.10引入外部属性文件

首先不引入外部文件
在这里插入图片描述
创建Spring-Datasource文件 并输入相应参数
在这里插入图片描述
测试连接是否可用
在这里插入图片描述

通过引入外部文件的方式
在这里插入图片描述

2.2.11bean的作用域

在这里插入图片描述
因为bean默认是单例的，所以只能获得一个对象，但如果你想获得两个对象，也不必创建两个bean，因为bean里可以指定singleton还是prototype
在这里插入图片描述

2.2.12bean的生命周期

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

2.2.13factorybean

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

2.2.14基于xml的自动装配

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

2.3基于注解管理bean

2.3.1标记与扫描

在这里插入图片描述
在这里插入图片描述
包扫描 输入com会有提示
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

3.AOP

3.1 基于注解的AOP

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
创建切面类并配置
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

afterreturning有参有返回值，最终执行结果返回的是afterreturning的返回值
在这里插入图片描述
切入点表达式
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

三层架构

在这里插入图片描述
实体类
在这里插入图片描述
数据访问层
在这里插入图片描述
业务逻辑层
在这里插入图片描述
包扫描 输入com会有提示

对分层的xml文件导入到一个包
在这里插入图片描述
在这里插入图片描述

4.Spring Mybatis整合

在这里插入图片描述

在这里插入图片描述

tl1216
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring MVC 复习笔记.rar
10-29
**Spring MVC 概述** Spring MVC 是 Spring 框架的一部分，它是一个用于构建 Web 应用程序的轻量级、模型-视图-控制器（MVC）框架。Spring MVC 提供了处理 HTTP 请求和响应的机制，以及解耦业务逻辑和用户界面的...
spring的优势
Leon_Jinhai_Sun的博客
12-14 163
spring的优势 方便解耦，简化开发 通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。 AOP编程的支持 通过Spring的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。 声明式事务的支...
spring的设计模式----工厂模式
m0_58414041的博客
07-18 838
spring的设计模式----工厂模式spring中IoC 控制反转，底层是工厂模式。工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。工厂模式提供了一种将对象的实例化过程封装在工厂类中的方式。通过使用工厂模式，可以将对象的创建与使用代码分离，提供一种统一的接口来创建不同类型的对象。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。介绍。
设计模式——使用spring自动注入实现工厂模式
hwp_ing的博客
10-05 1542
【代码】设计模式——使用spring自动注入实现工厂模式。
Springboot：策略模式+工厂模式注入
记录点点滴滴的成长。
02-09 2215
在调试过程，一直在mapper调用查询方法时，报空指针。这块困惑了很久，最后才发现，我虽然在策略实现类上加了@Componen注解，但在使用工厂类得到对象。今天把项目中以前的代码优化了下，使用策略+工厂模式优化了下。，所以其中的mapper属性虽然有@Autowired注解，但属性实际是空的。使用的时候，在使用的类中也注入工厂就好了，用注入的工厂获取策略对象就行了。这是策略实现类里面的内容，需要用mapper用查询数据库。这是工厂，使用的时候根据id获取不同的实现类。获取具体的实现类时候，调用静态方法。
框架-Spring学习第二天（IOC）
wy19961103的博客
12-08 140
一、入门案例 前提注意： spring5 版本是用 jdk8 编写的，所以要求我们的 jdk 版本是 8 及以上。 同时 tomcat 的版本要求 8.5 及以上。 1.导入jar包 <packaging>jar</packaging> <dependencies> <dependency> &l...
Spring AOP 复习笔记.rar
10-23
**Spring AOP 知识点详解** Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架的重要组成部分，它允许程序员定义“切面”，这些切面可以封装跨越多个对象的行为，比如日志、事务管理等。AOP...
Spring-IoC 复习笔记.rar
10-23
**Spring-IoC 复习笔记** Spring 框架是 Java 开发中不可或缺的一部分，其核心特性之一就是依赖注入（Dependency Injection，简称 DI），也称为控制反转（Inversion of Control，简称 IoC）。IoC 是一种设计模式，...
Spring学习笔记.zip
09-26
Spring框架是Java开发中最常用的轻量级开源框架之一，它以其强大的依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented Programming，AOP）能力而著名。...这份笔记将是一个宝贵的自学和复习资料。
spring-实例工厂注入
12-23
关于spring-工厂注入的实例代码，可以下载学习
Spring依赖注入使用静态工厂设注入demo
03-27
Spring依赖注入使用静态工厂设注入demo。完整可运行。
基于Spring自动注入快速实现策略模式+工厂模式优化过多的if..else
最新发布
m0_74444744的博客
12-21 1987
基于Spring自动注入快速实现策略模式+工厂模式优化过多的if..else
【Spring 工厂】反转控制与依赖注入、Spring工厂创建复杂对象3种方式
萌宅鹿的技术小屋
05-23 3024
反转控制与依赖注入反转控制 与 依赖注入反转控制（IOC Inverse of Control）依赖注入 (Dependency Injection - DI)Spring工厂创建复杂对象（3种方式）什么是复杂对象1. FactoryBean 接口开发步骤细节FactoryBean的实现原理[简易版]2. 实例工厂3. 静态工厂 反转控制 与 依赖注入 反转控制（IOC Inverse of Control） 反转控制（IOC Inverse of Control)，也称为 转移控制。 控制：对于成员变量
Spring系列（二）、Spring工厂模式（依赖注入）及Spring两大核心接口
一宿君
07-15 847
2 Spring中的工厂模式 工厂模式的思想正好契合Spring IoC的设计思想：某一接口的具体具体实现类的选择权从调用类中移除，转而交给第三方决定，即借由Spring的Bean配置来实现控制，这同样也是工厂模式的思想。 工厂模式提供了一种绝佳的创建对象的方法。在工厂模式中我们并不会直接使用new来创建一个对象，而是使用一个共同的接口类来指定其实现类，这就大大降低了系统的耦合性——我们无需改变每个调用此接口的类，而直接改变实现此接口的类即可完成软件的更新迭代。 2.1 BeanFactory和Applic
Spring注入外部 工厂类Bean
lhg_55的博客
08-24 183
spring注入工厂类Bean
Spring IOC与工厂模式
热门推荐
物是人非，结局始终不美
05-06 1万+
在讲Spring IOC之前，有必要先来聊一下工厂模式（Factory Pattern）。工厂模式可将Java对象的调用者从被调用者的实现逻辑中分离出来。工厂模式是Java中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。...
Spring的IOC理解+工厂模式介绍
qq_42251944的博客
02-28 1430
概念：依赖注入。 原理：将对象的控制权交给工厂，控制权就是对象的创建权，调用者需要用到某个对象时，只需要通过工厂获取即可。 知识点： （1）反射技术。 SpringIOC创建对象时，需要利用到反射技术，用到两个主要的方法。 第一个：Class.forName()；获取到创建对象的类。 第二个：类的newInstance()；获取对象。 这样对象就被创建出来了。 （2）工厂模式。 SpringIOC创建对象是使用反射的技术，创建对象的过程是放在工厂里面的，此时我们不需要知道对象是如何创建的，
SpringIOC手动装配（注入）：构造器注入，静态工厂注入，实例化工厂注入
weixin_46281472的博客
05-31 1210
1、本篇博客的背景和目的 目前我本人正在学习SpringFramework的知识，这也是这个专栏的主题。我前面的几篇博文中，简单的认识了一下SpringFramework，记录了SpringFramework的环境搭建，记录了SpringIOC如何加载配置文件，记录了SpringIOC三种Bean对象的实例化方法。还记录了SpringIOC手动装配（注入）的方法之一：set方法注入。本篇博客我记录一下另外三个SpringIOC手动注入的方法。其实目前大部分都使用的是自动注入的方法，手动注入使用的不多。就算
Spring框架学习笔记：技术整合与核心应用
这份笔记对于深入理解Spring框架的基础概念、配置和应用非常有帮助，适合于Java开发人员作为参考或复习资料。通过阅读和实践这些内容，开发者能够更好地运用Spring进行项目开发，提升代码质量和架构设计。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值