-
-
-
4.1 Spring IoC / DI 实现步骤
我们总结下，组件交给Spring IoC容器管理，并且获取和使用的基本步骤！
-
配置元数据（配置）
配置元数据，既是编写交给SpringIoC容器管理组件的信息，配置方式有三种。
基于 XML 的配置元数据的基本结构：
<bean id="..." [1] class="..." [2]> <!-- collaborators and configuration for this bean go here --> </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/beans https://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="..." [1] class="..." [2]> <!-- collaborators and configuration for this bean go here --> </bean> <bean id="..." class="..."> <!-- collaborators and configuration for this bean go here --> </bean> <!-- more bean definitions go here --> </beans>
Spring IoC 容器管理一个或多个组件。这些 组件是使用你提供给容器的配置元数据（例如，以 XML
<bean/>定义的形式）创建的。<bean /> 标签 == 组件信息声明
-
id属性是标识单个 Bean 定义的字符串。 -
class属性定义 Bean 的类型并使用完全限定的类名。
-
-
实例化IoC容器
提供给
ApplicationContext构造函数的位置路径是资源字符串地址，允许容器从各种外部资源（如本地文件系统、JavaCLASSPATH等）加载配置元数据。我们应该选择一个合适的容器实现类，进行IoC容器的实例化工作：
//实例化ioc容器,读取外部配置文件,最终会在容器内进行ioc和di动作 ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml"); -
获取Bean（组件）
ApplicationContext是一个高级工厂的接口，能够维护不同 bean 及其依赖项的注册表。通过使用方法T getBean(String name, Class<T> requiredType)，您可以检索 bean 的实例。允许读取 Bean 定义并访问它们，如以下示例所示：
//创建ioc容器对象，指定配置文件，ioc也开始实例组件对象 ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml"); //获取ioc容器的组件对象 PetStoreService service = context.getBean("petStore", PetStoreService.class); //使用组件对象 List<String> userList = service.getUsernameList(); -
4.2 基于XML配置方式组件管理
4.2.1 实验一： 组件（Bean）信息声明配置（IoC）
-
目标
Spring IoC 容器管理一个或多个 bean。这些 Bean 是使用您提供给容器的配置元数据创建的（例如，以 XML
<bean/>定义的形式）。我们学习，如何通过定义XML配置文件，声明组件类信息，交给 Spring 的 IoC 容器进行组件管理！
-
思路
-
准备项目
-
创建maven工程（spring-ioc-xml-01）
-
导入SpringIoC相关依赖
pom.xml
<dependencies> <!--spring context依赖--> <!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>6.0.6</version> </dependency> <!--junit5测试--> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-api</artifactId> <version>5.3.1</version> </dependency> </dependencies>
-
-
基于无参数构造函数
当通过构造函数方法创建一个 bean（组件对象） 时，所有普通类都可以由 Spring 使用并与之兼容。也就是说，正在开发的类不需要实现任何特定的接口或以特定的方式进行编码。只需指定 Bean 类信息就足够了。但是，默认情况下，我们需要一个默认（空）构造函数。
-
准备组件类
package com.atguigu.ioc;
-
-
public class HappyComponent { //默认包含无参数构造函数 public void doWork() { System.out.println("HappyComponent.doWork"); } } ``` 2. xml配置文件编写 创建携带spring约束的xml配置文件  编写配置文件： 文件：resources/spring-bean-01.xml ```java <!-- 实验一 [重要]创建bean --> <bean id="happyComponent" class="com.atguigu.ioc.HappyComponent"/> ``` - bean标签：通过配置bean标签告诉IOC容器需要创建对象的组件信息 - id属性：bean的唯一标识,方便后期获取Bean！ - class属性：组件类的全限定符！ - 注意：要求当前组件类必须包含无参数构造函数！ -
基于静态工厂方法实例化
除了使用构造函数实例化对象，还有一类是通过工厂模式实例化对象。接下来我们讲解如何定义使用静态工厂方法创建Bean的配置 ！
-
准备组件类
public class ClientService { private static ClientService clientService = new ClientService(); private ClientService() {}public static ClientService createInstance() { return clientService; } } ```-
xml配置文件编写
文件：resources/spring-bean-01.xml
<bean id="clientService" class="examples.ClientService" factory-method="createInstance"/>
-
class属性：指定工厂类的全限定符！
-
factory-method: 指定静态工厂方法，注意，该方法必须是static方法。
-
-
-
基于实例工厂方法实例化
接下来我们讲解下如何定义使用实例工厂方法创建Bean的配置 ！
-
准备组建类
public class DefaultServiceLocator {private static ClientServiceImplclientService = new ClientServiceImpl(); public ClientService createClientServiceInstance() { return clientService; } } ```-
xml配置文件编写
文件：resources/spring-bean-01.xml
<!-- 将工厂类进行ioc配置 --> <bean id="serviceLocator" class="examples.DefaultServiceLocator"> </bean> <!-- 根据工厂对象的实例工厂方法进行实例化组件对象 --> <bean id="clientService" factory-bean="serviceLocator" factory-method="createClientServiceInstance"/>
-
factory-bean属性：指定当前容器中工厂Bean 的名称。
-
factory-method: 指定实例工厂方法名。注意，实例方法必须是非static的！
-
-
-
4.2.2 实验二： 组件（Bean）依赖注入配置（DI）
-
目标
通过配置文件,实现IoC容器中Bean之间的引用（依赖注入DI配置）。
主要涉及注入场景：基于构造函数的依赖注入和基于 Setter 的依赖注入。
-
基于构造函数的依赖注入（单个构造参数）
-
介绍
基于构造函数的 DI 是通过容器调用具有多个参数的构造函数来完成的，每个参数表示一个依赖项。
下面的示例演示一个只能通过构造函数注入进行依赖项注入的类！
-
准备组件类
public class UserDao { }
-
-
public class UserService { private UserDao userDao; public UserService(UserDao userDao) { this.userDao = userDao; } } ``` 3. 编写配置文件 文件：resources/spring-02.xml ```xml <beans> <!-- 引用类bean声明 --> <bean id="userService" class="x.y.UserService"> <!-- 构造函数引用 --> <constructor-arg ref="userDao"/> </bean> <!-- 被引用类bean声明 --> <bean id="userDao" class="x.y.UserDao"/> </beans> ``` - constructor-arg标签：可以引用构造参数 ref引用其他bean的标识。 -
基于构造函数的依赖注入（多构造参数解析）
-
介绍
基于构造函数的 DI 是通过容器调用具有多个参数的构造函数来完成的，每个参数表示一个依赖项。
下面的示例演示通过构造函数注入多个参数，参数包含其他bean和基本数据类型！
-
准备组件类
public class UserDao { }
-
-
基于Setter方法依赖注入
-
介绍
开发中，除了构造函数注入（DI）更多的使用的Setter方法进行注入！
下面的示例演示一个只能使用纯 setter 注入进行依赖项注入的类。
-
准备组件类
public Class MovieFinder{ } public class SimpleMovieLister { private MovieFinder movieFinder; private String movieName; public void setMovieFinder(MovieFinder movieFinder) { this.movieFinder = movieFinder; } public void setMovieName(String movieName){ this.movieName = movieName; } // business logic that actually uses the injected MovieFinder is omitted... } -
编写配置文件
<bean id="simpleMovieLister" class="examples.SimpleMovieLister"> <!-- setter方法，注入movieFinder对象的标识id name = 属性名 ref = 引用bean的id值 --> <property name="movieFinder" ref="movieFinder" /> <!-- setter方法，注入基本数据类型movieName name = 属性名 value= 基本类型值 --> <property name="movieName" value="消失的她"/> </bean> <bean id="movieFinder" class="examples.MovieFinder"/>
-
property标签： 可以给setter方法对应的属性赋值
-
property 标签： name属性代表set方法标识、ref代表引用bean的标识id、value属性代表基本属性值
-
-
-
总结：
依赖注入（DI）包含引用类型和基本数据类型，同时注入的方式也有多种！主流的注入方式为setter方法注入和构造函数注入，两种注入语法都需要掌握！
需要特别注意：引用其他bean，使用ref属性。直接注入基本类型值，使用value属性。
4.2.3 实验三： IoC容器创建和使用
-
介绍
上面的实验只是讲解了如何在XML格式的配置文件编写IoC和DI配置！
想要配置文件中声明组件类信息真正的进行实例化成Bean对象和形成Bean之间的引用关系，我们需要声明IoC容器对象，读取配置文件，实例化组件和关系维护的过程都是在IoC容器中实现的！
-
容器实例化
//方式1:实例化并且指定配置文件 //参数：String...locations 传入一个或者多个配置文件 ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml"); //方式2:先实例化，再指定配置文件，最后刷新容器触发Bean实例化动作 [springmvc源码和contextLoadListener源码方式] ApplicationContext context = new ClassPathXmlApplicationContext(); //设置配置配置文件,方法参数为可变参数,可以设置一个或者多个配置 iocContainer1.setConfigLocations("services.xml", "daos.xml"); //后配置的文件,需要调用refresh方法,触发刷新配置 iocContainer1.refresh(); -
Bean对象读取
//方式1: 根据id获取 //没有指定类型,返回为Object,需要类型转化! HappyComponent happyComponent = (HappyComponent) iocContainer.getBean("bean的id标识"); //使用组件对象 happyComponent.doWork(); //方式2: 根据类型获取 //根据类型获取,但是要求,同类型(当前类,或者之类,或者接口的实现类)只能有一个对象交给IoC容器管理 //配置两个或者以上出现: org.springframework.beans.factory.NoUniqueBeanDefinitionException 问题 HappyComponent happyComponent = iocContainer.getBean(HappyComponent.class); happyComponent.doWork(); //方式3: 根据id和类型获取 HappyComponent happyComponent = iocContainer.getBean("bean的id标识", HappyComponent.class); happyComponent.doWork(); 根据类型来获取bean时，在满足bean唯一性的前提下，其实只是看：『对象 instanceof 指定的类型』的返回结果， 只要返回的是true就可以认定为和类型匹配，能够获取到。 -
4.2.4 实验四： 高级特性：组件（Bean）作用域和周期方法配置
-
组件周期方法配置
-
周期方法概念
我们可以在组件类中定义方法，然后当IoC容器实例化和销毁组件对象的时候进行调用！这两个方法我们成为生命周期方法！
类似于Servlet的init/destroy方法,我们可以在周期方法完成初始化和释放资源等工作。
-
周期方法声明
public class BeanOne { //周期方法要求： 方法命名随意，但是要求方法必须是 public void 无形参列表 public void init() { // 初始化逻辑 } } public class BeanTwo { public void cleanup() { // 释放资源逻辑 } } -
周期方法配置
<beans> <bean id="beanOne" class="examples.BeanOne" init-method="init" /> <bean id="beanTwo" class="examples.BeanTwo" destroy-method="cleanup" /> </beans>
-
-
组件作用域配置
-
Bean作用域概念
<bean标签声明Bean，只是将Bean的信息配置给SpringIoC容器！在IoC容器中，这些
<bean标签对应的信息转成Spring内部BeanDefinition对象，BeanDefinition对象内，包含定义的信息（id,class,属性等等）！这意味着，
BeanDefinition与类概念一样，SpringIoC容器可以可以根据BeanDefinition对象反射创建多个Bean对象实例。具体创建多少个Bean的实例对象，由Bean的作用域Scope属性指定！
-
作用域可选值
取值 含义 创建对象的时机 默认值 singleton 在 IOC 容器中，这个 bean 的对象始终为单实例 IOC 容器初始化时 是 prototype 这个 bean 在 IOC 容器中有多个实例 获取 bean 时 否 如果是在WebApplicationContext环境下还会有另外两个作用域（但不常用）： 取值 含义 创建对象的时机 默认值 ------- ---------- ------- --- request 请求范围内有效的实例 每次请求 否 session 会话范围内有效的实例 每次会话 否 -
作用域配置
配置scope范围
<!--bean的作用域 准备两个引用关系的组件类即可！！ --> <!-- scope属性：取值singleton（默认值），bean在IOC容器中只有一个实例，IOC容器初始化时创建对象 --> <!-- scope属性：取值prototype，bean在IOC容器中可以有多个实例，getBean()时创建对象 --> <bean id="happyMachine8" scope="prototype" class="com.atguigu.ioc.HappyMachine"> <property name="machineName" value="happyMachine"/> </bean> <bean id="happyComponent8" scope="singleton" class="com.atguigu.ioc.HappyComponent"> <property name="componentName" value="happyComponent"/> </bean>
-
作用域测试
@Test public void testExperiment08() { ApplicationContext iocContainer = new ClassPathXmlApplicationContext("配置文件名"); HappyMachine bean = iocContainer.getBean(HappyMachine.class); HappyMachine bean1 = iocContainer.getBean(HappyMachine.class); //多例对比 false System.out.println(bean == bean1); HappyComponent bean2 = iocContainer.getBean(HappyComponent.class); HappyComponent bean3 = iocContainer.getBean(HappyComponent.class); //单例对比 true System.out.println(bean2 == bean3); }
-
-
4.2.5 实验五： 高级特性：FactoryBean特性和使用
-
FactoryBean简介
FactoryBean接口是Spring IoC容器实例化逻辑的可插拔性点。用于配置复杂的Bean对象，可以将创建过程存储在
FactoryBean的getObject方法！FactoryBean<T>接口提供三种方法：-
T getObject():返回此工厂创建的对象的实例。该返回值会被存储到IoC容器！
-
boolean isSingleton():如果此
FactoryBean返回单例，则返回true，否则返回false。此方法的默认实现返回true（注意，lombok插件使用，可能影响效果）。 -
Class<?> getObjectType(): 返回getObject()方法返回的对象类型，如果事先不知道类型，则返回null。
-
-
FactoryBean使用场景
-
代理类的创建
-
第三方框架整合
-
复杂对象实例化等
-
-
Factorybean应用
-
准备FactoryBean实现类
// 实现FactoryBean接口时需要指定泛型 // 泛型类型就是当前工厂要生产的对象的类型 public class HappyFactoryBean implements FactoryBean<HappyMachine> { private String machineName; public String getMachineName() { return machineName; } public void setMachineName(String machineName) { this.machineName = machineName; } @Override public HappyMachine getObject() throws Exception { // 方法内部模拟创建、设置一个对象的复杂过程 HappyMachine happyMachine = new HappyMachine(); happyMachine.setMachineName(this.machineName); return happyMachine; } @Override public Class<?> getObjectType() { // 返回要生产的对象的类型 return HappyMachine.class; } } -
配置FactoryBean实现类
<!-- FactoryBean机制 --> <!-- 这个bean标签中class属性指定的是HappyFactoryBean，但是将来从这里获取的bean是HappyMachine对象 --> <bean id="happyMachine7" class="com.atguigu.ioc.HappyFactoryBean"> <!-- property标签仍然可以用来通过setXxx()方法给属性赋值 --> <property name="machineName" value="iceCreamMachine"/> </bean>
-
测试读取FactoryBean和FactoryBean.getObject对象
@Test public void testExperiment07() { ApplicationContext iocContainer = new ClassPathXmlApplicationContext("spring-bean-07.xml"); //注意: 直接根据声明FactoryBean的id,获取的是getObject方法返回的对象 HappyMachine happyMachine = iocContainer.getBean("happyMachine7",HappyMachine.class); System.out.println("happyMachine = " + happyMachine); //如果想要获取FactoryBean对象, 直接在id前添加&符号即可! &happyMachine7 这是一种固定的约束 Object bean = iocContainer.getBean("&happyMachine7"); System.out.println("bean = " + bean); }
-
-
FactoryBean和BeanFactory区别
**FactoryBean **是 Spring 中一种特殊的 bean，可以在 getObject() 工厂方法自定义的逻辑创建Bean！是一种能够生产其他 Bean 的 Bean。FactoryBean 在容器启动时被创建，而在实际使用时则是通过调用 getObject() 方法来得到其所生产的 Bean。因此，FactoryBean 可以自定义任何所需的初始化逻辑，生产出一些定制化的 bean。
一般情况下，整合第三方框架，都是通过定义FactoryBean实现！！！
BeanFactory 是 Spring 框架的基础，其作为一个顶级接口定义了容器的基本行为，例如管理 bean 的生命周期、配置文件的加载和解析、bean 的装配和依赖注入等。BeanFactory 接口提供了访问 bean 的方式，例如 getBean() 方法获取指定的 bean 实例。它可以从不同的来源（例如 Mysql 数据库、XML 文件、Java 配置类等）获取 bean 定义，并将其转换为 bean 实例。同时，BeanFactory 还包含很多子类（例如，ApplicationContext 接口）提供了额外的强大功能。
总的来说，FactoryBean 和 BeanFactory 的区别主要在于前者是用于创建 bean 的接口，它提供了更加灵活的初始化定制功能，而后者是用于管理 bean 的框架基础接口，提供了基本的容器功能和 bean 生命周期管理。
-
public class UserService { private UserDao userDao; private int age; private String name; public UserService(int age , String name ,UserDao userDao) { this.userDao = userDao; this.age = age; this.name = name; } } ``` 3. 编写配置文件 ```xml <!-- 场景1: 多参数，可以按照相应构造函数的顺序注入数据 --> <beans> <bean id="userService" class="x.y.UserService"> <!-- value直接注入基本类型值 --> <constructor-arg value="18"/> <constructor-arg value="赵伟风"/> <constructor-arg ref="userDao"/> </bean> <!-- 被引用类bean声明 --> <bean id="userDao" class="x.y.UserDao"/> </beans><!-- 场景2: 多参数，可以按照相应构造函数的名称注入数据 --> <beans> <bean id="userService" class="x.y.UserService"> <!-- value直接注入基本类型值 --> <constructor-arg name="name" value="赵伟风"/> <constructor-arg name="userDao" ref="userDao"/> <constructor-arg name="age" value="18"/> </bean> <!-- 被引用类bean声明 --> <bean id="userDao" class="x.y.UserDao"/> </beans> <!-- 场景2: 多参数，可以按照相应构造函数的角标注入数据 index从0开始 构造函数(0,1,2....) --> <beans> <bean id="userService" class="x.y.UserService"> <!-- value直接注入基本类型值 --> <constructor-arg index="1" value="赵伟风"/> <constructor-arg index="2" ref="userDao"/> <constructor-arg index="0" value="18"/> </bean> <!-- 被引用类bean声明 --> <bean id="userDao" class="x.y.UserDao"/> </beans> ``` - constructor-arg标签：指定构造参数和对应的值 - constructor-arg标签：name属性指定参数名、index属性指定参数角标、value属性指定普通属性值
4.2.6 实验六： 基于XML方式整合三层架构组件
-
需求分析
搭建一个三层架构案例，模拟查询全部学生（学生表）信息，持久层使用JdbcTemplate和Druid技术，使用XML方式进行组件管理！
-
数据库准备
create database studb; use studb; CREATE TABLE students ( id INT PRIMARY KEY, name VARCHAR(50) NOT NULL, gender VARCHAR(10) NOT NULL, age INT, class VARCHAR(50) ); INSERT INTO students (id, name, gender, age, class) VALUES (1, '张三', '男', 20, '高中一班'), (2, '李四', '男', 19, '高中二班'), (3, '王五', '女', 18, '高中一班'), (4, '赵六', '女', 20, '高中三班'), (5, '刘七', '男', 19, '高中二班'), (6, '陈八', '女', 18, '高中一班'), (7, '杨九', '男', 20, '高中三班'), (8, '吴十', '男', 19, '高中二班');
-
项目准备
-
项目创建
spring-xml-practice-02
-
依赖导入
<dependencies> <!--spring context依赖--> <!--当你引入SpringContext依赖之后，表示将Spring的基础依赖引入了--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>6.0.6</version> </dependency> <!-- 数据库驱动和连接池--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.25</version> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.2.8</version> </dependency> <!-- spring-jdbc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>6.0.6</version> </dependency> </dependencies>
-
实体类准备
public class Student { private Integer id; private String name; private String gender; private Integer age; private String classes; 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 String getGender() { return gender; } public void setGender(String gender) { this.gender = gender; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } public String getClasses() { return classes; } public void setClasses(String classes) { this.classes = classes; } @Override public String toString() { return "Student{" + "id=" + id + ", name='" + name + '\'' + ", gender='" + gender + '\'' + ", age=" + age + ", classes='" + classes + '\'' + '}'; } }
-
-
JdbcTemplate技术讲解
为了在特定领域帮助我们简化代码，Spring 封装了很多 『Template』形式的模板类。例如：RedisTemplate、RestTemplate 等等，包括我们今天要学习的 JdbcTemplate。 jdbc.properties 提取数据库连接信息
atguigu.url=jdbc:mysql://localhost:3306/studb atguigu.driver=com.mysql.cj.jdbc.Driver atguigu.username=root atguigu.password=root
springioc配置文件
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" 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">
-
<!-- 导入外部属性文件 --> <context:property-placeholder location="classpath:jdbc.properties" /> <!-- 配置数据源 --> <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="url" value="${atguigu.url}"/> <property name="driverClassName" value="${atguigu.driver}"/> <property name="username" value="${atguigu.username}"/> <property name="password" value="${atguigu.password}"/> </bean> <!-- 配置 JdbcTemplate --> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <!-- 装配数据源 --> <property name="dataSource" ref="druidDataSource"/> </bean> </beans> ``` 基于jdbcTemplate的CRUD使用 ```java public class JdbcTemplateTest {/** * 使用jdbcTemplate进行DML动作 */ @Test public void testDML(){ ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-ioc.xml"); JdbcTemplate jdbcTemplate = applicationContext.getBean(JdbcTemplate.class); //TODO 执行插入一条学员数据 String sql = "insert into students (id,name,gender,age,class) values (?,?,?,?,?);"; /* 参数1: sql语句 参数2: 可变参数,占位符的值 */ int rows = jdbcTemplate.update(sql, 9,"十一", "男", 18, "二年三班"); System.out.println("rows = " + rows); }/** * 查询单条实体对象 * public class Student { * private Integer id; * private String name; * private String gender; * private Integer age; * private String classes; */ @Test public void testDQLForPojo(){ String sql = "select id , name , age , gender , class as classes from students where id = ? ;"; ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-ioc.xml"); JdbcTemplate jdbcTemplate = applicationContext.getBean(JdbcTemplate.class); //根据id查询 Student student = jdbcTemplate.queryForObject(sql, (rs, rowNum) -> { //自己处理结果映射 Student stu = new Student(); stu.setId(rs.getInt("id")); stu.setName(rs.getString("name")); stu.setAge(rs.getInt("age")); stu.setGender(rs.getString("gender")); stu.setClasses(rs.getString("classes")); return stu; }, 2); System.out.println("student = " + student); }/** * 查询实体类集合 */ @Test public void testDQLForListPojo(){ String sql = "select id , name , age , gender , class as classes from students ;"; ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-ioc.xml"); JdbcTemplate jdbcTemplate = applicationContext.getBean(JdbcTemplate.class); /* query可以返回集合! BeanPropertyRowMapper就是封装好RowMapper的实现,要求属性名和列名相同即可 */ List<Student> studentList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Student.class)); System.out.println("studentList = " + studentList); } } ``` -
三层架构搭建和实现
-
持久层
//接口 public interface StudentDao { /** * 查询全部学生数据 * @return */ List<Student> queryAll(); } //实现类 public class StudentDaoImpl implements StudentDao { private JdbcTemplate jdbcTemplate; public void setJdbcTemplate(JdbcTemplate jdbcTemplate) { this.jdbcTemplate = jdbcTemplate; } /** * 查询全部学生数据 * @return */ @Override public List<Student> queryAll() { String sql = "select id , name , age , gender , class as classes from students ;"; /* query可以返回集合! BeanPropertyRowMapper就是封装好RowMapper的实现,要求属性名和列名相同即可 */ List<Student> studentList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Student.class)); return studentList; } } -
业务层
//接口 public interface StudentService { /** * 查询全部学员业务 * @return */ List<Student> findAll(); } //实现类 public class StudentServiceImpl implements StudentService { private StudentDao studentDao; public void setStudentDao(StudentDao studentDao) { this.studentDao = studentDao; } /** * 查询全部学员业务 * @return */ @Override public List<Student> findAll() { List<Student> studentList = studentDao.queryAll(); return studentList; } } -
表述层
public class StudentController { private StudentService studentService; public void setStudentService(StudentService studentService) { this.studentService = studentService; } public void findAll(){ List<Student> studentList = studentService.findAll(); System.out.println("studentList = " + studentList); } }
-
-
三层架构IoC配置
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" 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">
-
<!-- 导入外部属性文件 --> <context:property-placeholder location="classpath:jdbc.properties" /> <!-- 配置数据源 --> <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="url" value="${atguigu.url}"/> <property name="driverClassName" value="${atguigu.driver}"/> <property name="username" value="${atguigu.username}"/> <property name="password" value="${atguigu.password}"/> </bean> <!-- 配置 JdbcTemplate --> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <!-- 装配数据源 --> <property name="dataSource" ref="druidDataSource"/> </bean><bean id="studentDao" class="com.atguigu.dao.impl.StudentDaoImpl"> <property name="jdbcTemplate" ref="jdbcTemplate" /> </bean> <bean id="studentService" class="com.atguigu.service.impl.StudentServiceImpl"> <property name="studentDao" ref="studentDao" /> </bean> <bean id="studentController" class="com.atguigu.controller.StudentController"> <property name="studentService" ref="studentService" /> </bean> </beans> ```
-
运行测试
public class ControllerTest { @Test public void testRun(){ ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-ioc.xml"); StudentController studentController = applicationContext.getBean(StudentController.class); studentController.findAll(); } } -
XMLIoC方式问题总结
-
注入的属性必须添加setter方法、代码结构乱！
-
配置文件和Java代码分离、编写不是很方便！
-
XML配置文件解析效率低
-
-
4.3 基于 注解 方式管理 Bean
4.3.1 实验一： Bean注解标记和扫描 (IoC)
-
注解理解
和 XML 配置文件一样，注解本身并不能执行，注解本身仅仅只是做一个标记，具体的功能是框架检测到注解标记的位置，然后针对这个位置按照注解标记的功能来执行具体操作。
本质上：所有一切的操作都是 Java 代码来完成的，XML 和注解只是告诉框架中的 Java 代码如何执行。
举例：元旦联欢会要布置教室，蓝色的地方贴上元旦快乐四个字，红色的地方贴上拉花，黄色的地方贴上气球。
班长做了所有标记，同学们来完成具体工作。墙上的标记相当于我们在代码中使用的注解，后面同学们做的工作，相当于框架的具体操作。
-
扫描理解
Spring 为了知道程序员在哪些地方标记了什么注解，就需要通过扫描的方式，来进行检测。然后根据注解进行后续操作。
-
准备Spring项目和组件
-
准备项目pom.xml
<dependencies> <!--spring context依赖--> <!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>6.0.6</version> </dependency> <!--junit5测试--> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-api</artifactId> <version>5.3.1</version> </dependency> </dependencies>
-
准备组件类
普通组件
/** * projectName: com.atguigu.components * * description: 普通的组件 */ public class CommonComponent { } Controller组件
/** * projectName: com.atguigu.components * * description: controller类型组件 */ public class XxxController { } Service组件
/** * projectName: com.atguigu.components * * description: service类型组件 */ public class XxxService { } Dao组件
/** * projectName: com.atguigu.components * * description: dao类型组件 */ public class XxxDao { }
-
-
组件添加标记注解
-
组件标记注解和区别
Spring 提供了以下多个注解，这些注解可以直接标注在 Java 类上，将它们定义成 Spring Bean。
注解 说明 @Component 该注解用于描述 Spring 中的 Bean，它是一个泛化的概念，仅仅表示容器中的一个组件（Bean），并且可以作用在应用的任何层次，例如 Service 层、Dao 层等。 使用时只需将该注解标注在相应类上即可。 @Repository 该注解用于将数据访问层（Dao 层）的类标识为 Spring 中的 Bean，其功能与 @Component 相同。 @Service 该注解通常作用在业务层（Service 层），用于将业务层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。 @Controller 该注解通常作用在控制层（如SpringMVC 的 Controller），用于将控制层的类标识为 Spring 中的 Bean，其功能与 @Component 相同。 通过查看源码我们得知，@Controller、@Service、@Repository这三个注解只是在@Component注解的基础上起了三个新的名字。 对于Spring使用IOC容器管理这些组件来说没有区别，也就是语法层面没有区别。所以@Controller、@Service、@Repository这三个注解只是给开发人员看的，让我们能够便于分辨组件的作用。
注意：虽然它们本质上一样，但是为了代码的可读性、程序结构严谨！我们肯定不能随便胡乱标记。
-
使用注解标记
普通组件
/** * projectName: com.atguigu.components * * description: 普通的组件 */ @Component public class CommonComponent { } Controller组件
/** * projectName: com.atguigu.components * * description: controller类型组件 */ @Controller public class XxxController { } Service组件
/** * projectName: com.atguigu.components * * description: service类型组件 */ @Service public class XxxService { } Dao组件
/** * projectName: com.atguigu.components * * description: dao类型组件 */ @Repository public class XxxDao { }
-
-
配置文件确定扫描范围
情况1：基本扫描配置
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" 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"> <!-- 配置自动扫描的包 --> <!-- 1.包要精准,提高性能! 2.会扫描指定的包和子包内容 3.多个包可以使用,分割 例如: com.atguigu.controller,com.atguigu.service等 --> <context:component-scan base-package="com.atguigu.components"/> </beans>
情况2：指定排除组件
<!-- 情况三：指定不扫描的组件 --> <context:component-scan base-package="com.atguigu.components"> <!-- context:exclude-filter标签：指定排除规则 --> <!-- type属性：指定根据什么来进行排除，annotation取值表示根据注解来排除 --> <!-- expression属性：指定排除规则的表达式，对于注解来说指定全类名即可 --> <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/> </context:component-scan>
情况3：指定扫描组件
<!-- 情况四：仅扫描指定的组件 --> <!-- 仅扫描 = 关闭默认规则 + 追加规则 --> <!-- use-default-filters属性：取值false表示关闭默认扫描规则 --> <context:component-scan base-package="com.atguigu.ioc.components" use-default-filters="false"> <!-- context:include-filter标签：指定在原有扫描规则的基础上追加的规则 --> <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/> </context:component-scan>
-
组件BeanName问题
在我们使用 XML 方式管理 bean 的时候，每个 bean 都有一个唯一标识——id 属性的值，便于在其他地方引用。现在使用注解后，每个组件仍然应该有一个唯一标识。
默认情况：
类名首字母小写就是 bean 的 id。例如：SoldierController 类对应的 bean 的 id 就是 soldierController。
使用value属性指定：
@Controller(value = "tianDog") public class SoldierController { }当注解中只设置一个属性时，value属性的属性名可以省略：
@Service("smallDog") public class SoldierService { } -
总结
-
注解方式IoC只是标记哪些类要被Spring管理
-
最终，我们还需要XML方式或者后面讲解Java配置类方式指定注解生效的包
-
现阶段配置方式为 注解 （标记）+ XML（扫描）
-
-
4.3.2 实验二： 组件（Bean）作用域和周期方法注解
-
组件周期方法配置
-
周期方法概念
我们可以在组件类中定义方法，然后当IoC容器实例化和销毁组件对象的时候进行调用！这两个方法我们成为生命周期方法！
类似于Servlet的init/destroy方法,我们可以在周期方法完成初始化和释放资源等工作。
-
周期方法声明
public class BeanOne { //周期方法要求： 方法命名随意，但是要求方法必须是 public void 无形参列表 @PostConstruct //注解制指定初始化方法 public void init() { // 初始化逻辑 } } public class BeanTwo { @PreDestroy //注解指定销毁方法 public void cleanup() { // 释放资源逻辑 } }
-
-
组件作用域配置
-
Bean作用域概念
<bean标签声明Bean，只是将Bean的信息配置给SpringIoC容器！在IoC容器中，这些
<bean标签对应的信息转成Spring内部BeanDefinition对象，BeanDefinition对象内，包含定义的信息（id,class,属性等等）！这意味着，
BeanDefinition与类概念一样，SpringIoC容器可以可以根据BeanDefinition对象反射创建多个Bean对象实例。具体创建多少个Bean的实例对象，由Bean的作用域Scope属性指定！
-
作用域可选值
取值 含义 创建对象的时机 默认值 singleton 在 IOC 容器中，这个 bean 的对象始终为单实例 IOC 容器初始化时 是 prototype 这个 bean 在 IOC 容器中有多个实例 获取 bean 时 否 如果是在WebApplicationContext环境下还会有另外两个作用域（但不常用）： 取值 含义 创建对象的时机 默认值 ------- ---------- ------- --- request 请求范围内有效的实例 每次请求 否 session 会话范围内有效的实例 每次会话 否 -
作用域配置
@Scope(scopeName = ConfigurableBeanFactory.SCOPE_SINGLETON) //单例,默认值 @Scope(scopeName = ConfigurableBeanFactory.SCOPE_PROTOTYPE) //多例 二选一 public class BeanOne { //周期方法要求： 方法命名随意，但是要求方法必须是 public void 无形参列表 @PostConstruct //注解制指定初始化方法 public void init() { // 初始化逻辑 } }
-
-
4.3.3 实验三： Bean属性赋值：引用类型自动装配 (DI)
-
设定场景
-
SoldierController 需要 SoldierService
-
SoldierService 需要 SoldierDao 同时在各个组件中声明要调用的方法。
-
SoldierController中声明方法
import org.springframework.stereotype.Controller; @Controller(value = "tianDog") public class SoldierController { private SoldierService soldierService; public void getMessage() { soldierService.getMessage(); } } -
SoldierService中声明方法
@Service("smallDog") public class SoldierService { private SoldierDao soldierDao; public void getMessage() { soldierDao.getMessage(); } } -
SoldierDao中声明方法
@Repository public class SoldierDao { public void getMessage() { System.out.print("I am a soldier"); } }
-
-
自动装配实现
-
前提
参与自动装配的组件（需要装配、被装配）全部都必须在IoC容器中。
注意：不区分IoC的方式！XML和注解都可以！
-
@Autowired注解
在成员变量上直接标记@Autowired注解即可，不需要提供setXxx()方法。以后我们在项目中的正式用法就是这样。
-
给Controller装配Service
@Controller(value = "tianDog") public class SoldierController { @Autowired private SoldierService soldierService; public void getMessage() { soldierService.getMessage(); } } -
给Service装配Dao
@Service("smallDog") public class SoldierService { @Autowired private SoldierDao soldierDao; public void getMessage() { soldierDao.getMessage(); } }
-
-
4.3.4 实验四： Bean属性赋值：基本类型属性赋值 (DI)
@Value通常用于注入外部化属性声明外部配置
application.properties
catalog.name=MovieCatalog
xml引入外部配置
<!-- 引入外部配置文件--> <context:property-placeholder location="application.properties" />
@Value注解读取配置
package com.atguigu.components; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Component; /** * projectName: com.atguigu.components * * description: 普通的组件 */ @Component public class CommonComponent { /** * 情况1: ${key} 取外部配置key对应的值! * 情况2: ${key:defaultValue} 没有key,可以给与默认值 */ @Value("${catalog:hahaha}") private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } } catalog
4.3.5 实验五： 基于注解+XML方式整合三层架构组件
-
需求分析
搭建一个三层架构案例，模拟查询全部学生（学生表）信息，持久层使用JdbcTemplate和Druid技术，使用XML+注解方式进行组件管理！
-
数据库准备
create database studb; use studb; CREATE TABLE students ( id INT PRIMARY KEY, name VARCHAR(50) NOT NULL, gender VARCHAR(10) NOT NULL, age INT, class VARCHAR(50) ); INSERT INTO students (id, name, gender, age, class) VALUES (1, '张三', '男', 20, '高中一班'), (2, '李四', '男', 19, '高中二班'), (3, '王五', '女', 18, '高中一班'), (4, '赵六', '女', 20, '高中三班'), (5, '刘七', '男', 19, '高中二班'), (6, '陈八', '女', 18, '高中一班'), (7, '杨九', '男', 20, '高中三班'), (8, '吴十', '男', 19, '高中二班');
-
项目准备
-
项目创建
spring-annotation-practice-04
-
依赖导入
<dependencies> <!--spring context依赖--> <!--当你引入SpringContext依赖之后，表示将Spring的基础依赖引入了--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>6.0.6</version> </dependency> <!-- 数据库驱动和连接池--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.25</version> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.2.8</version> </dependency> <dependency> <groupId>jakarta.annotation</groupId> <artifactId>jakarta.annotation-api</artifactId> <version>2.1.1</version> </dependency> <!-- spring-jdbc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>6.0.6</version> </dependency> </dependencies>
-
实体类准备
public class Student { private Integer id; private String name; private String gender; private Integer age; private String classes; 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 String getGender() { return gender; } public void setGender(String gender) { this.gender = gender; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } public String getClasses() { return classes; } public void setClasses(String classes) { this.classes = classes; } @Override public String toString() { return "Student{" + "id=" + id + ", name='" + name + '\'' + ", gender='" + gender + '\'' + ", age=" + age + ", classes='" + classes + '\'' + '}'; } }
-
-
三层架构搭建和实现
-
持久层
//接口 public interface StudentDao { /** * 查询全部学生数据 * @return */ List<Student> queryAll(); } //实现类 @Repository public class StudentDaoImpl implements StudentDao { @Autowired private JdbcTemplate jdbcTemplate; /** * 查询全部学生数据 * @return */ @Override public List<Student> queryAll() { String sql = "select id , name , age , gender , class as classes from students ;"; /* query可以返回集合! BeanPropertyRowMapper就是封装好RowMapper的实现,要求属性名和列名相同即可 */ List<Student> studentList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Student.class)); return studentList; } } -
业务层
//接口 public interface StudentService { /** * 查询全部学员业务 * @return */ List<Student> findAll(); } //实现类 @Service public class StudentServiceImpl implements StudentService { @Autowired private StudentDao studentDao; /** * 查询全部学员业务 * @return */ @Override public List<Student> findAll() { List<Student> studentList = studentDao.queryAll(); return studentList; } } -
表述层
@Controller public class StudentController { @Autowired private StudentService studentService; public void findAll(){ List<Student> studentList = studentService.findAll(); System.out.println("studentList = " + studentList); } }
-
-
三层架构IoC配置
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" 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">
-
<!-- 导入外部属性文件 --> <context:property-placeholder location="classpath:jdbc.properties" /> <!-- 配置数据源 --> <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="url" value="${atguigu.url}"/> <property name="driverClassName" value="${atguigu.driver}"/> <property name="username" value="${atguigu.username}"/> <property name="password" value="${atguigu.password}"/> </bean> <bean class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="druidDataSource" /> </bean> <!-- 扫描Ioc/DI注解 --> <context:component-scan base-package="com.atguigu.dao,com.atguigu.service,com.atguigu.controller" /> </beans> ``` -
运行测试
public class ControllerTest { @Test public void testRun(){ ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-ioc.xml"); StudentController studentController = applicationContext.getBean(StudentController.class); studentController.findAll(); } } -
注解+XML IoC方式问题总结
-
自定义类可以使用注解方式，但是第三方依赖的类依然使用XML方式！
-
XML格式解析效率低！
-
-
@Autowired注解细节
-
标记位置
-
成员变量
这是最主要的使用方式！
与xml进行bean ref引用不同，他不需要有set方法！
@Service("smallDog") public class SoldierService { @Autowired private SoldierDao soldierDao; public void getMessage() { soldierDao.getMessage(); } } -
构造器
@Controller(value = "tianDog") public class SoldierController { private SoldierService soldierService; @Autowired public SoldierController(SoldierService soldierService) { this.soldierService = soldierService; } …… -
setXxx()方法
@Controller(value = "tianDog") public class SoldierController { private SoldierService soldierService; @Autowired public void setSoldierService(SoldierService soldierService) { this.soldierService = soldierService; } ……
-
-
工作流程
-
首先根据所需要的组件类型到 IOC 容器中查找
-
能够找到唯一的 bean：直接执行装配
-
如果完全找不到匹配这个类型的 bean：装配失败
-
和所需类型匹配的 bean 不止一个
-
没有 @Qualifier 注解：根据 @Autowired 标记位置成员变量的变量名作为 bean 的 id 进行匹配
-
能够找到：执行装配
-
找不到：装配失败
-
-
使用 @Qualifier 注解：根据 @Qualifier 注解中指定的名称作为 bean 的id进行匹配
-
能够找到：执行装配
-
找不到：装配失败
-
-
-
@Controller(value = "tianDog") public class SoldierController { @Autowired @Qualifier(value = "maomiService222") // 根据面向接口编程思想，使用接口类型引入Service组件 private ISoldierService soldierService; -
-
-
佛系装配
给 @Autowired 注解设置 required = false 属性表示：能装就装，装不上就不装。但是实际开发时，基本上所有需要装配组件的地方都是必须装配的，用不上这个属性
@Controller(value = "tianDog") public class SoldierController { // 给@Autowired注解设置required = false属性表示：能装就装，装不上就不装 @Autowired(required = false) private ISoldierService soldierService; -
扩展JSR-250注解@Resource
-
理解JSR系列注解
JSR（Java Specification Requests）是Java平台标准化进程中的一种技术规范，而JSR注解是其中一部分重要的内容。按照JSR的分类以及注解语义的不同，可以将JSR注解分为不同的系列，主要有以下几个系列：
-
JSR-175: 这个JSR是Java SE 5引入的，是Java注解最早的规范化版本，Java SE 5后的版本中都包含该JSR中定义的注解。主要包括以下几种标准注解：
-
@Deprecated: 标识一个程序元素（如类、方法或字段）已过时，并且在将来的版本中可能会被删除。 -
@Override: 标识一个方法重写了父类中的方法。 -
@SuppressWarnings: 抑制编译时产生的警告消息。 -
@SafeVarargs: 标识一个有安全性警告的可变参数方法。 -
@FunctionalInterface: 标识一个接口只有一个抽象方法，可以作为lambda表达式的目标。
-
JSR-250: 这个JSR主要用于在Java EE 5中定义一些支持注解。该JSR主要定义了一些用于进行对象管理的注解，包括：
-
@Resource: 标识一个需要注入的资源，是实现Java EE组件之间依赖关系的一种方式。 -
@PostConstruct: 标识一个方法作为初始化方法。 -
@PreDestroy: 标识一个方法作为销毁方法。 -
@Resource.AuthenticationType: 标识注入的资源的身份验证类型。 -
@Resource.AuthenticationType: 标识注入的资源的默认名称。
-
JSR-269: 这个JSR主要是Java SE 6中引入的一种支持编译时元数据处理的框架，即使用注解来处理Java源文件。该JSR定义了一些可以用注解标记的注解处理器，用于生成一些元数据，常用的注解有：
-
@SupportedAnnotationTypes: 标识注解处理器所处理的注解类型。 -
@SupportedSourceVersion: 标识注解处理器支持的Java源码版本。
-
JSR-330: 该JSR主要为Java应用程序定义了一个依赖注入的标准，即Java依赖注入标准（javax.inject）。在此规范中定义了多种注解，包括：
-
@Named: 标识一个被依赖注入的组件的名称。 -
@Inject: 标识一个需要被注入的依赖组件。 -
@Singleton: 标识一个组件的生命周期只有一个唯一的实例。
-
JSR-250: 这个JSR主要是Java EE 5中定义一些支持注解。该JSR包含了一些支持注解，可以用于对Java EE组件进行管理，包括：
-
@RolesAllowed: 标识授权角色 -
@PermitAll: 标识一个活动无需进行身份验证。 -
@DenyAll: 标识不提供针对该方法的访问控制。 -
@DeclareRoles: 声明安全角色。 但是你要理解JSR是Java提供的技术规范，也就是说，他只是规定了注解和注解的含义，JSR并不是直接提供特定的实现，而是提供标准和指导方针，由第三方框架（Spring）和库来实现和提供对应的功能。
-
-
JSR-250 @Resource注解
@Resource注解也可以完成属性注入。那它和@Autowired注解有什么区别？
-
@Resource注解是JDK扩展包中的，也就是说属于JDK的一部分。所以该注解是标准注解，更加具有通用性。(JSR-250标准中制定的注解类型。JSR是Java规范提案。)
-
@Autowired注解是Spring框架自己的。
-
@Resource注解默认根据Bean名称装配，未指定name时，使用属性名作为name。通过name找不到的话会自动启动通过类型装配。
-
@Autowired注解默认根据类型装配，如果想根据名称装配，需要配合@Qualifier注解一起用。
-
@Resource注解用在属性上、setter方法上。
-
@Autowired注解用在属性上、setter方法上、构造方法上、构造方法参数上。 @Resource注解属于JDK扩展包，所以不在JDK当中，需要额外引入以下依赖：【高于JDK11或低于JDK8需要引入以下依赖】
<dependency> <groupId>jakarta.annotation</groupId> <artifactId>jakarta.annotation-api</artifactId> <version>2.1.1</version> </dependency>
-
-
@Resource使用
@Controller public class XxxController { /** * 1. 如果没有指定name,先根据属性名查找IoC中组件xxxService * 2. 如果没有指定name,并且属性名没有对应的组件,会根据属性类型查找 * 3. 可以指定name名称查找! @Resource(name='test') == @Autowired + @Qualifier(value='test') */ @Resource private XxxService xxxService; //@Resource(name = "指定beanName") //private XxxService xxxService; public void show(){ System.out.println("XxxController.show"); xxxService.show(); } }
-
-
扫一扫
09-16
1159
1159
07-19
753
753
05-25
414
414
10-06
369
369
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
