快速学习Spring

Spring 简介

Spring 是一个开源的轻量级、非侵入式的 JavaEE 框架，它为企业级 Java 应用提供了全面的基础设施支持。Spring 的设计目标是简化企业应用的开发，并解决 Java 开发中常见的复杂性和低效率问题。

Spring常用依赖

<dependencies><!-- Spring 核心容器，包括 ApplicationContext 等 --><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.3.14</version> <!-- 替换为您需要的版本号 --></dependency><!-- Spring AOP 相关依赖 --><dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>5.3.14</version> <!-- 替换为您需要的版本号 --></dependency><!-- Spring 对 JDBC 的支持 --><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.3.14</version> <!-- 替换为您需要的版本号 --></dependency><!-- Spring 对事务的支持 --><dependency><groupId>org.springframework</groupId><artifactId>spring-tx</artifactId><version>5.3.14</version> <!-- 替换为您需要的版本号 --></dependency>
</dependencies>

Spring 优点

1. IoC 容器：Spring 的核心是一个 IoC（Inversion of Control，控制反转）容器，它负责管理应用中的组件（Bean），并通过依赖注入将它们装配在一起。这种方式降低了类之间的耦合度，使得代码更易于维护和测试。
2. AOP 支持：Spring 提供了 AOP（Aspect-Oriented Programming，面向切面编程）的支持，可以方便地实现横切关注点的功能，如事务管理、日志记录等，从而提高代码的模块化和可重用性。
3. 事务管理：Spring 提供了强大且灵活的事务管理支持，可以通过声明式事务或编程式事务来管理数据库事务，确保数据操作的一致性和可靠性。
4. 数据访问：Spring 提供了对 JDBC、ORM（如 Hibernate、MyBatis）、NoSQL 数据库（如 MongoDB、Redis）等数据访问技术的集成支持，简化了数据访问层的开发。
5. MVC 框架：Spring MVC 是一个基于前端控制器模式的 Web MVC 框架，提供了灵活的配置和强大的扩展性，帮助开发者构建响应式和可扩展的 Web 应用程序。
6. 集成支持：Spring 提供了对各种第三方框架和技术的集成支持，如 JMS、JMX、Quartz 等，使得整合其他技术变得更加简单。
7. 测试支持：Spring 提供了测试类和测试环境的支持，可以轻松编写单元测试、集成测试和端到端测试，帮助开发者保持代码质量和可靠性。

一、第一个Spring项目

1.1 创建项目工程

首先我们使用IDEA开发工具或Eclipse去创建一个名为 “first-spring”的maven项目。

1.2 导入依赖

在pom.xml中导入依赖

    <dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.3.14</version></dependency></dependencies>

1.3 编写代码 

在java包下创建一个名为pojo实体类包中创建一个 User类

public class User {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +'}';}
}

1.4 创建Spring文件

在resources包下创建spring文件，名为 application-context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"></beans>

1.4.1 bean标签

bean 标签就是用来创建 Java对象的。

属性有

id: 就是对象的唯一名字

class: 是对象类具体的位置

<property>: property 标签是bean中的设置属性，可以将特定的值或引用注入到bean的属性中。 

    <bean id="user" class="com.na.pojo.User"><property name="name" value="香菜的开发日记"/></bean>

以上就是通过bean去创建了一个User对象，并且为name 赋特定的值。

 1.5 运行测试

创建一个名为 MyTest的类。

public class MyTest {public static void main(String[] args) {// 获取 Spring 的上下文对象ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application-context.xml");// 在Spring当中去寻找对象// getBean("user") user就是我们在xml文件中 bean标签的 id属性值User user = (User) applicationContext.getBean("user");System.out.println(user.toString());}
}

二、依赖注入

在依赖注入中，不必创建对象，但必须描述如何创建它们。

通常依赖主义可以捅咕哦三种方式完成。即：

2.1 构造函数注入

2.1.1 更新User类

在User类代码中添加一个有参构造方法

public class User {private String name;public User(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +'}';}
}

2.1.2 更新application-context

编写application-context.xml 文件

2.1.3 根据下标设置

constructor-arg 构造函数标签

参数:

index 下标数值

value 具体内容值

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 根据下标参数设置值 --><bean id="user" class="com.na.pojo.User"><constructor-arg index="0" value="香菜的开发日记"/></bean></beans>

2.1.4 根据参数名设置

constructor-arg 构造函数标签

参数:

name 参数名称

value 具体内容值 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 根据参数名字设置 --><bean id="user" class="com.na.pojo.User"><constructor-arg name="name" value="香菜的开发日记"/></bean></beans>

2.1.5 根据参数类型设置

constructor-arg 构造函数标签

参数:

type 参数类型

value 具体内容值 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 根据参数类型设置 --><bean id="user" class="com.na.pojo.User"><constructor-arg type="java.lang.String" value="香菜的开发日记"/></bean></beans>

 2.1.5 运行测试

public class MyTest {public static void main(String[] args) {// 获取 Spring 的上下文对象ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application-context.xml");// 在Spring当中去寻找对象// getBean("user") user就是我们在xml文件中 bean标签的 id属性值User user = (User) applicationContext.getBean("user");System.out.println(user.toString());}
}

2.2 setter注入

setter注入，要求属性要有set方法。

2.2.1 编写实体类

在pojo包中创建Address实体类

public class Address {private String address;private String phone;public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}public String getPhone() {return phone;}public void setPhone(String phone) {this.phone = phone;}@Overridepublic String toString() {return "Address{" +"address='" + address + '\'' +", phone='" + phone + '\'' +'}';}
}

在创建User实体类

public class User {private String name;private Address address;public User(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Address getAddress() {return address;}public void setAddress(Address address) {this.address = address;}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +", address=" + address +'}';}
}

 2.2.2 为User中的name进行值注入

在application-context.xml 文件进行编写bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 为User实体中的name进行注入值 --><bean id="user" class="com.na.pojo.User"><property name="name" value="香菜"/></bean></beans>

 2.2.3 为User实体中的address进行注入

因为User实体中的address 是Address类型的，那就是说我们还需要创建一个Address的bean对象。 在与User的bean对象进行一个引用。

property 标签当中有一个 ref属性， ref属性就是去引用其他bean对象。

用法:

<property ref="引用bean的id值"/>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!-- Address实体对象 --><bean id="address" class="com.na.pojo.Address"><property name="phone" value="123456789"/><property name="address" value="黑龙江"/></bean><!-- User实体对象 --><bean id="user" class="com.na.pojo.User"><property name="name" value="小明"/><!-- 引用Address实体对象--><property name="address" ref="address"/></bean>
</beans>

2.2.4 运行测试 

public class MyTest {public static void main(String[] args) {// 获取 Spring 的上下文对象ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application-context.xml");User user = (User) applicationContext.getBean("user");System.out.println(user.toString());}
}

2.2.5 数组注入 

 创建一个Books实体

public class Books {private String[] books;public String[] getBooks() {return books;}public void setBooks(String[] books) {this.books = books;}@Overridepublic String toString() {return "Books{" +"books=" + Arrays.toString(books) +'}';}
}

在application-context.xml 文件中为Books创建bean对象并且注入值

array 数组注入标签

配合value标签来使用

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="books" class="com.na.pojo.Books"><property name="books"><!-- 为数组注入值 --><array><value>Java编程思想</value><value>数据结构与算法分析</value></array></property></bean>
</beans>

运行测试

public class MyArrayTest {public static void main(String[] args) {ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("application-context.xml");Books books = (Books) applicationContext.getBean("books");System.out.println(books.toString());}
}

2.2.6 List注入

创建一个Musics实体类

public class Musics {private List<String> musics;public List<String> getMusics() {return musics;}public void setMusics(List<String> musics) {this.musics = musics;}@Overridepublic String toString() {return "Musics{" +"musics=" + musics +'}';}
}

在application-context.xml 文件中为Musics创建bean对象。

list 标签

配合value标签使用

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="musics" class="com.na.pojo.Musics"><property name="musics"><list><value>The Hardest Part</value><value>Energy</value></list></property></bean></beans>

运行测试

public class MyArrayTest {public static void main(String[] args) {ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application-context.xml");Books books = (Books) applicationContext.getBean("books");System.out.println(books.toString());}
}

2.3 接口注入

在 service 包中创建一个 UserDao 和 UserService

public class UserDao {public void getUserById() {System.out.println("我是测试用户数据-1");}
}

public class UserService{private UserDao userDao;public UserService(UserDao userDao) {this.userDao = userDao;}public void setUserDao(UserDao userDao) {this.userDao = userDao;}public void getUserById(){userDao.getUserById();}
}

在application-context.xml文件中编写bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="userDao" class="com.na.service.UserDao"/><bean id="userService" class="com.na.service.UserService"><property name="userDao" ref="userDao"/></bean></beans>

运行测试

public class MyUserTest {public static void main(String[] args) {UserDao userDao = new UserDao();UserService userService = new UserService();userService.setUserDao(userDao);userService.getUserById();}
}

如何区分构造函数注入和setter注入 

构造函数注入	setter注入
没有部分注入	有部分注入
不会覆盖setter 属性	会覆盖setter 属性
任意修改都会创建一个新实例	任意修改不会创建一个新实例
使用与设置很多属性	使用与设置少量属性

三、c命名空间和p命名空间

这个例子还是使用上面service中的代码

3.1 c命名空间

使用构造函数注入的方式，通过在 XML 配置文件中直接指定构造函数参数的值或引用。下面是一个示例：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:c="http://www.springframework.org/schema/c"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="userDao" class="com.na.service.UserDao"/><bean id="userService" class="com.na.service.UserService" c:userDao-ref="userDao"/></beans>

3.2 p命名空间 

使用属性注入的方式，通过在 XML 配置文件中指定属性的值或引用。下面是一个示例：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:c="http://www.springframework.org/schema/c"xmlns:p="http://www.springframework.org/schema/p"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="userDao" class="com.na.service.UserDao"/><bean id="userService" class="com.na.service.UserService" p:userDao-ref="userDao"/></beans>

四、Bean自动装配

4.1 在xml中进行配置

在 XML 配置文件中，可以使用 <bean> 标签来配置 Bean 的自动装配方式。

4.1.1 默认的自动装配方式（no）：通过 autowire 属性将自动装配设置为 no，即不进行自动装配。

<bean id="userService" class="com.na.service.UserService" autowire="no"><!-- 手动配置依赖注入 -->
</bean>

4.1.2 按名称自动装配（byName）

通过 autowire 属性将自动装配设置为 byName，Spring 会根据 Bean 的名称自动匹配并进行装配。

<bean id="userDao" class="com.na.service.UserDao"/><bean id="userService" class="com.na.service.UserService" autowire="byName"><!-- userDao 将会自动注入 -->
</bean>

4.1.3 按类型自动装配（byType）

通过 autowire 属性将自动装配设置为 byName，Spring 会根据 Bean 的名称自动匹配并进行装配。

<bean id="userService" class="com.na.service.UserService" autowire="byType"><!-- userDao 将会自动注入 -->
</bean><bean id="userDaO" class="com.na.service.UserDao" />

 4.1.4 构造函数自动装配（constructor）：通过 autowire 属性将自动装配设置为 constructor，Spring 会根据构造函数的参数类型自动查找并进行装配。

<bean id="userService" class="com.na.service.UserService" autowire="constructor"><!-- 构造函数参数将会自动注入 -->
</bean><bean id="userDaO" class="com.na.service.UserDao" />

4.2 在java中进行配置

4.3 隐示进行bean配置

未完待续