文章目录
- 容器：Ioc
- Ioc容器
- 控制反转（Ioc）
- 依赖注入
- IoC容器在Spring的实现
- 基于XML管理Bean
- 搭建环境
- 获取bean
- 依赖注入
- setter注入
- 构造器注入
- 特殊值处理
- 字面量赋值
- null值
- xml实体
- CDATA节
- 特殊类型属性注入
- 为对象类型属性赋值
- 方式一：引入外部bean
- 方式二：内部bean
- 方式三：级联属性赋值
- 为数组类型属性赋值
- 为集合类型属性赋值
- 为List集合类型属性赋值
- 为Map集合类型属性赋值
- 引用集合类型的bean
- P命名空间
- 引入外部属性文件
- bean的作用域
- bean的生命周期
- FactoryBean
- 基于xml自动装配
- 基于注解管理Bean
- 搭建子模块
- 开启组件扫描
- 使用注解定义Bean
- @Autowired注入
- @Resource注入
- Spring全注解开发
容器：Ioc
IoC 是 Inversion of Control 的简写，译为“控制反转”，它不是一门技术，而是一种设计思想，是一个重要的面向对象编程法则，能够指导我们如何设计出松耦合、更优良的程序。
Spring 通过 IoC 容器来管理所有 Java 对象的实例化和初始化，控制对象与对象之间的依赖关系。我们将由 IoC 容器管理的 Java 对象称为 Spring Bean，它与使用关键字 new 创建的 Java 对象没有任何区别。
IoC 容器是 Spring 框架中最重要的核心组件之一，它贯穿了 Spring 从诞生到成长的整个过程。
Ioc容器
控制反转（Ioc）
控制反转是一种思想。
控制反转是为了降低程序耦合度，提高程序扩展力。
控制反转，反转的是什么？
- 将对象的创建权利交出去，交给第三方容器负责。
- 将对象和对象之间关系的维护权交出去，交给第三方容器负责。
控制反转这种思想如何实现呢？
- DI（Dependency Injection）：依赖注入
依赖注入
DI（Dependency Injection）：依赖注入，依赖注入实现了控制反转的思想。
依赖注入：指Spring创建对象的过程中，将对象依赖属性通过配置进行注入
依赖注入常见的实现方式包括两种：
- 第一种：
set注入 - 第二种：
构造注入
所以结论是：IOC 就是一种控制反转的思想， 而 DI 是对IoC的一种具体实现。
Bean管理说的是：Bean对象的创建，以及Bean对象中属性的赋值（或者叫做Bean对象之间关系的维护）。
IoC容器在Spring的实现
Spring 的 IoC 容器就是 IoC思想的一个落地的产品实现。IoC容器中管理的组件也叫做 bean。在创建 bean 之前，首先需要创建IoC 容器。Spring 提供了IoC 容器的两种实现方式：
BeanFactory：这是 IoC 容器的基本实现，是 Spring 内部使用的接口。面向 Spring 本身，不提供给开发人员使用。
ApplicationContext：BeanFactory 的子接口，提供了更多高级特性。面向 Spring 的使用者，几乎所有场合都使用 ApplicationContext 而不是底层的 BeanFactory。
ApplicationContext的主要实现类
| 类型名 | 简介 |
|---|---|
| ClassPathXmlApplicationContext | 通过读取类路径下的 XML 格式的配置文件创建 IOC 容器对象 |
| FileSystemXmlApplicationContext | 通过文件系统路径读取 XML 格式的配置文件创建 IOC 容器对象 |
| ConfigurableApplicationContext | ApplicationContext 的子接口，包含一些扩展方法 refresh() 和 close() ，让 ApplicationContext 具有启动、关闭和刷新上下文的能力。 |
| WebApplicationContext | 专门为 Web 应用准备，基于 Web 环境创建 IOC 容器对象，并将对象引入存入 ServletContext 域中。 |
基于XML管理Bean
搭建环境
①搭建子模块spring6-ioc-xml
搭建方式如：spring-first
②引入配置文件
引入spring-first模块配置文件：beans.xml、log4j2.xml
③添加依赖
<dependencies>
<!--spring context依赖-->
<!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>6.0.3</version>
</dependency>
<!--junit5测试-->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.3.1</version>
</dependency>
<!--log4j2的依赖-->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.19.0</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-slf4j2-impl</artifactId>
<version>2.19.0</version>
</dependency>
</dependencies>
④引入java类
package com.gues.spring6.iocxml;
public class User {
private String name;
private Integer age;
public void run(){
System.out.println("run........");
}
}
package com.gues.spring6.iocxml;
public class TestUser {
public static void main(String[] args) {
}
}
获取bean
获取bean的方式有三种：根据id获取、根据类型获取、根据id和类型获取。
package com.gues.spring6.iocxml;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestUser {
public static void main(String[] args) {
ApplicationContext context = new
ClassPathXmlApplicationContext("bean.xml");
//根据id获取
User user = (User) context.getBean("user");
System.out.println("根据id获取bean：" + user);
//根据类型获取
User user2 = context.getBean(User.class);
System.out.println("根据类型获取bean：" + user2);
//根据id和类型获取
User user3 = context.getBean("user",User.class);
System.out.println("根据类型获取bean：" + user2);
}
}
需要注意的地方：当根据类型获取bean时，要求Ioc容器中指定类型的bean有且只能有一个。
依赖注入
setter注入
创建书籍类Book
package com.gues.spring6.iocxml.di;
public class Book {
private String bname;
private String author;
//无参构造方法
public Book() {
this.bname = bname;
this.author = author;
}
//有参构造方法
public Book(String bname, String author) {
this.bname = bname;
this.author = author;
}
//get和set方法
public String getBname() {
return bname;
}
public void setBname(String bname) {
this.bname = bname;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
//toString 方法
@Override
public String toString() {
return "Book{" +
"bname='" + bname + '\'' +
", author='" + author + '\'' +
'}';
}
/* public static void main(String[] args) {
//set 注入
Book book = new Book();
book.setBname("java");
book.setAuthor("张三");
//通过构造器注入
Book book1 = new Book("c++","李四");
}*/
}
配置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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- set 方法注入-->
<bean id="book" class="com.gues.spring6.iocxml.di.Book">
<property name="bname" value="前端开发"></property>
<property name="author" value="王武"></property>
</bean>
</beans>
测试
package com.gues.spring6.iocxml.di;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestBook {
@Test
public void testSetter(){
ApplicationContext context = new
ClassPathXmlApplicationContext("bean-di.xml");
Book book = context.getBean("book",Book.class);
System.out.println(book);
}
}
运行结果
构造器注入
在Book类中添加有参构造
//有参构造方法
public Book(String bname, String author) {
this.bname = bname;
this.author = author;
}
配置bean时为属性赋值
<!--构造器注入-->
<bean id="bookCon" class="com.gues.spring6.iocxml.di.Book">
<constructor-arg name="bname" value="java开发"></constructor-arg>
<constructor-arg name="author" value="123"></constructor-arg>
</bean>
注：constructor-arg标签还有两个属性可以进一步描述构造器参数：
index属性：指定参数所在位置的索引（从0开始）name属性：指定参数名
测试
@Test
public void testConstruct(){
ApplicationContext context = new
ClassPathXmlApplicationContext("bean-di.xml");
Book book = context.getBean("bookCon",Book.class);
System.out.println(book);
}
运行结果
特殊值处理
字面量赋值
什么是字面量？
int a = 10;
声明一个变量a，初始化为10，此时a就不代表字母a了，而是作为一个变量的名字。当我们引用a的时候，我们实际上拿到的值是10。
而如果a是带引号的：‘a’，那么它现在不是一个变量，它就是代表a这个字母本身，这就是字面量。所以字面量没有引申含义，就是我们看到的这个数据本身。
<!-- 使用value属性给bean的属性赋值时，Spring会把value属性的值看做字面量 -->
<property name="name" value="张三"/>
null值
<property name="name">
<null />
</property>
注意：
<property name="name" value="null"></property>以上写法，为name所赋的值是字符串null
xml实体
<!-- 小于号在XML文档中用来定义标签的开始，不能随便使用 -->
<!-- 解决方案一：使用XML实体来代替 -->
<property name="expression" value="a < b"/>
<!-- <代表 “<”; >代表 “>” -->
CDATA节
<property name="expression">
<!-- 解决方案二：使用CDATA节 -->
<!-- CDATA中的C代表Character，是文本、字符的含义，CDATA就表示纯文本数据 -->
<!-- XML解析器看到CDATA节就知道这里是纯文本，就不会当作XML标签或属性来解析 -->
<!-- 所以CDATA节中写什么符号都随意 -->
<value><![CDATA[a < b]]></value>
</property>
特殊类型属性注入
为对象类型属性赋值
创建部门类Dept
package com.gues.spring6.iocxml.ditest;
//部门类
public class Dept {
private String dname;
public String getDname() {
return dname;
}
public void setDname(String dname) {
this.dname = dname;
}
public void info(){
System.out.println("部门名称：" + dname);
}
}
创建员工类Emp
package com.gues.spring6.iocxml.ditest;
//员工类
public class Emp {
//对象类型属性，员工属于某个部门
private Dept dept;
private String ename;
private Integer age;
public void work(){
System.out.println(ename + "员工正在工作....." + age);
dept.info();
}
public Dept getDept() {
return dept;
}
public void setDept(Dept dept) {
this.dept = dept;
}
public String getEname() {
return ename;
}
public void setEname(String ename) {
this.ename = ename;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
配置bean
方式一：引入外部bean
<!--
第一种方式：引入外部bean
1. 创建两个对象：dept 和 emp
2. 在emp的标签里面，使用 property 引入dept的bean
-->
<bean id="dept" class="com.gues.spring6.iocxml.ditest.Dept">
<property name="dname" value="人事部"></property>
</bean>
<bean id="emp" class="com.gues.spring6.iocxml.ditest.Emp">
<!--对象类型属性注入
private Dept dept;
-->
<property name="dept" ref="dept"></property>
<!--普通属性注入-->
<property name="ename" value="张三"></property>
<property name="age" value="21"></property>
</bean>
方式二：内部bean
<!--第二种方式：内部bean注入-->
<bean id="emp2" class="com.gues.spring6.iocxml.ditest.Emp">
<!--普通属性注入-->
<property name="ename" value="mary"></property>
<property name="age" value="20"></property>
<!--内部bean-->
<property name="dept">
<bean id="dept2" class="com.gues.spring6.iocxml.ditest.Dept">
<property name="dname" value="财务部"></property>
</bean>
</property>
</bean>
方式三：级联属性赋值
<!--第三种方式 级联赋值-->
<bean id="dept3" class="com.gues.spring6.iocxml.ditest.Dept">
<property name="dname" value="技术部"></property>
</bean>
<bean id="emp3" class="com.gues.spring6.iocxml.ditest.Emp">
<property name="ename" value="jary"></property>
<property name="age" value="27"></property>
<property name="dept" ref="dept3"></property>
<property name="dept.dname" value="测试部"></property>
</bean>
为数组类型属性赋值
在emp类中加入以下代码
private String[] loves;
public String[] getLoves() {
return loves;
}
public void setLoves(String[] loves) {
this.loves = loves;
}
配置bean
<bean id="dept" class="com.gues.spring6.iocxml.ditest.Dept">
<property name="dname" value="人事部"></property>
</bean>
<bean id="emp" class="com.gues.spring6.iocxml.ditest.Emp">
<!--普通属性注入-->
<property name="ename" value="张三"></property>
<property name="age" value="21"></property>
<!--对象类型属性注入-->
<property name="dept" ref="dept"></property>
<!--数值类型属性注入-->
<property name="loves">
<array>
<value>吃饭</value>
<value>睡觉</value>
<value>敲代码</value>
</array>
</property>
</bean>
为集合类型属性赋值
为List集合类型属性赋值
在Dept类中添加以下代码
//一个部门有很多员工
private List<Emp> empList;
public List<Emp> getEmpList() {
return empList;
}
public void setEmpList(List<Emp> empList) {
this.empList = empList;
}
配置bean
<bean id="empone" class="com.gues.spring6.iocxml.ditest.Emp">
<!--普通属性注入-->
<property name="ename" value="张三"></property>
<property name="age" value="21"></property>
</bean>
<bean id="emptwo" class="com.gues.spring6.iocxml.ditest.Emp">
<!--普通属性注入-->
<property name="ename" value="李四"></property>
<property name="age" value="25"></property>
</bean>
<bean id="dept" class="com.gues.spring6.iocxml.ditest.Dept">
<property name="dname" value="技术部"></property>
<!--为List集合类型属性赋值-->
<property name="empList">
<list>
<ref bean="empone"></ref>
<ref bean="emptwo"></ref>
</list>
</property>
</bean>
若为Set集合类型属性赋值，只需要将其中的list标签改为set标签即可
为Map集合类型属性赋值
新建Student类和Teacher类
package com.gues.spring6.iocxml.dimap;
import java.util.Map;
public class Student {
private Map<String,Teacher> teacherMap;
private String sid;
private String sname;
public void run(){
System.out.println("学生编号：" + sid + "学生姓名：" + sname);
System.out.println(teacherMap);
}
public String getSid() {
return sid;
}
public void setSid(String sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public Map<String, Teacher> getTeacherMap() {
return teacherMap;
}
public void setTeacherMap(Map<String, Teacher> teacherMap) {
this.teacherMap = teacherMap;
}
@Override
public String toString() {
return "Student{" +
"teacherMap=" + teacherMap +
", sid='" + sid + '\'' +
", sname='" + sname + '\'' +
'}';
}
}
package com.gues.spring6.iocxml.dimap;
public class Teacher {
private String teacherId;
private String teacherName;
public String getTeacherId() {
return teacherId;
}
public void setTeacherId(String teacherId) {
this.teacherId = teacherId;
}
public String getTeacherName() {
return teacherName;
}
public void setTeacherName(String teacherName) {
this.teacherName = teacherName;
}
@Override
public String toString() {
return "Teacher{" +
"teacherId='" + teacherId + '\'' +
", teacherName='" + teacherName + '\'' +
'}';
}
}
配置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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--
1 创建两个对象
2 注入普通类型属性
3 在学生bean注入map集合类型属性
-->
<bean id="teacherone" class="com.gues.spring6.iocxml.dimap.Teacher">
<!--注入普通类型属性-->
<property name="teacherId" value="100"></property>
<property name="teacherName" value="西门讲师"></property>
</bean>
<bean id="teachertwo" class="com.gues.spring6.iocxml.dimap.Teacher">
<!--注入普通类型属性-->
<property name="teacherId" value="200"></property>
<property name="teacherName" value="上官讲师"></property>
</bean>
<bean id="student" class="com.gues.spring6.iocxml.dimap.Student">
<!--注入普通类型属性-->
<property name="sid" value="2000"></property>
<property name="sname" value="张三"></property>
<!--在学生bean注入map集合类型属性-->
<property name="teacherMap">
<map>
<entry>
<key>
<value>10010</value>
</key>
<ref bean="teacherone"></ref>
</entry>
<entry>
<key>
<value>10086</value>
</key>
<ref bean="teachertwo"></ref>
</entry>
</map>
</property>
</bean>
</beans>
引用集合类型的bean
<!--list集合类型的bean-->
<util:list id="students">
<ref bean="studentOne"></ref>
<ref bean="studentTwo"></ref>
<ref bean="studentThree"></ref>
</util:list>
<!--map集合类型的bean-->
<util:map id="teacherMap">
<entry>
<key>
<value>10010</value>
</key>
<ref bean="teacherOne"></ref>
</entry>
<entry>
<key>
<value>10086</value>
</key>
<ref bean="teacherTwo"></ref>
</entry>
</util:map>
<bean id="clazzTwo" class="com.gues.spring6.iocxml.dimap.Clazz">
<property name="clazzId" value="4444"></property>
<property name="clazzName" value="Javaee0222"></property>
<property name="students" ref="students"></property>
</bean>
<bean id="studentFour" class="com.gues.spring6.iocxml.dimap.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>
<property name="hobbies">
<array>
<value>抽烟</value>
<value>喝酒</value>
<value>烫头</value>
</array>
</property>
<property name="teacherMap" ref="teacherMap"></property>
</bean>
使用util:list、util:map标签必须引入相应的命名空间
<?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:util="http://www.springframework.org/schema/util" xsi:schemaLocation="http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
P命名空间
引入p命名空间
<?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:util="http://www.springframework.org/schema/util"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
引入p命名空间后，可以通过以下方式为bean的各个属性赋值
<bean id="studentSix" class="com.gues.spring6.iocxml.dimap.Student"
p:id="1006" p:name="小明" p:clazz-ref="clazzOne" p:teacherMap-ref="teacherMap"></bean>
引入外部属性文件
引入数据库相关依赖
<!-- MySQL驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.30</version>
</dependency>
<!-- 数据源 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.15</version>
</dependency>
创建外部属性文件，properties格式，定义数据信息：用户名、密码、地址等
jdbc.user=root
jdbc.password=root
jdbc.url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC
jdbc.driver=com.mysql.cj.jdbc.Driver
引入属性文件
引入 context 名称空间
<?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
http://www.springframework.org/schema/context/spring-context.xsd">
</beans>
<!-- 引入外部属性文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
注意：在使用 context:property-placeholder 元素加载外包配置文件功能前，首先需要在 XML 配置的一级标签 中添加 context 相关的约束。
配置bean
<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="url" value="${jdbc.url}"/>
<property name="driverClassName" value="${jdbc.driver}"/>
<property name="username" value="${jdbc.user}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
测试
@Test
public void testDataSource() throws SQLException {
ApplicationContext ac = new ClassPathXmlApplicationContext("spring-datasource.xml");
DataSource dataSource = ac.getBean(DataSource.class);
Connection connection = dataSource.getConnection();
System.out.println(connection);
}
bean的作用域
在Spring中可以通过配置bean标签的scope属性来指定bean的作用域范围，各取值含义参加下表：
| 取值 | 含义 | 创建对象的时机 |
|---|---|---|
| singleton（默认） | 在IOC容器中，这个bean的对象始终为单实例 | IOC容器初始化时 |
| prototype | 这个bean在IOC容器中有多个实例 | 获取bean时 |
如果是在WebApplicationContext环境下还会有另外几个作用域（但不常用）：
| 取值 | 含义 |
|---|---|
| request | 在一个请求范围内有效 |
| session | 在一个会话范围内有效 |
bean的生命周期
- bean对象创建（调用无参构造）
- 给bean对象设置相关属性
- bean的后置处理器（初始化之前）
- bean对象初始化（需在配置bean时指定初始化方法）
- bean的后置处理器（初始化之后）
- bean对象就绪可以使用
- bean对象销毁（需在配置bean时指定销毁方法）
- IOC容器关闭
FactoryBean
FactoryBean是Spring提供的一种整合第三方框架的常用机制。和普通的bean不同，配置一个FactoryBean类型的bean，在获取bean的时候得到的并不是class属性中配置的这个类的对象，而是getObject()方法的返回值。通过这种机制，Spring可以帮我们把复杂组件创建的详细过程和繁琐细节都屏蔽起来，只把最简洁的使用界面展示给我们。
将来我们整合Mybatis时，Spring就是通过FactoryBean机制来帮我们创建SqlSessionFactory对象的。
基于xml自动装配
自动装配：
根据指定的策略，在IOC容器中匹配某一个bean，自动为指定的bean中所依赖的类类型或接口类型属性赋值
场景模拟
创建类UserController
package com.gues.spring6.iocxml.auto.controller;
import com.gues.spring6.iocxml.auto.service.UserService;
public class UserController {
private UserService userService;
public void setUserService(UserService userService) {
this.userService = userService;
}
public void addUser(){
System.out.println("controller方法执行了");
userService.addUserService();
}
}
创建接口UserService
package com.gues.spring6.iocxml.auto.service;
public interface UserService {
public void addUserService();
}
创建类UserServiceImpl实现接口UserService
package com.gues.spring6.iocxml.auto.service;
import com.gues.spring6.iocxml.auto.dao.UserDao;
public class UserServiceImpl implements UserService{
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
@Override
public void addUserService() {
System.out.println("UserService方法执行了");
userDao.addUserDao();
}
}
创建接口UserDao
package com.gues.spring6.iocxml.auto.dao;
public interface UserDao {
public void addUserDao();
}
创建类UserDaoImpl实现接口UserDao
package com.gues.spring6.iocxml.auto.dao;
public class UserDaoImpl implements UserDao{
@Override
public void addUserDao() {
System.out.println("UserDao方法执行了");
}
}
配置bean
使用bean标签的autowire属性设置自动装配效果
自动装配方式：byType
byType：根据类型匹配IOC容器中的某个兼容类型的bean，为属性自动赋值
若在IOC中，没有任何一个兼容类型的bean能够为属性赋值，则该属性不装配，即值为默认值null
若在IOC中，有多个兼容类型的bean能够为属性赋值，则抛出异常NoUniqueBeanDefinitionException
<bean id="userController" class="com.gues.spring6.iocxml.auto.controller.UserController"
autowire="byType">
</bean>
<bean id="userService" class="com.gues.spring6.iocxml.auto.service.UserServiceImpl"
autowire="byType">
</bean>
<bean id="userDao" class="com.gues.spring6.iocxml.auto.dao.UserDaoImpl">
</bean>
自动装配方式：byName
byName：将自动装配的属性的属性名，作为bean的id在IOC容器中匹配相对应的bean进行赋值
测试
package com.gues.spring6.iocxml.auto;
import com.gues.spring6.iocxml.auto.controller.UserController;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestUser {
public static void main(String[] args) {
ApplicationContext context = new
ClassPathXmlApplicationContext("bean-auto.xml");
UserController userController = context.getBean("userController", UserController.class);
userController.addUser();
}
}
基于注解管理Bean
从 Java 5 开始，Java 增加了对注解（Annotation）的支持，它是代码中的一种特殊标记，可以在编译、类加载和运行时被读取，执行相应的处理。开发人员可以通过注解在不改变原有代码和逻辑的情况下，在源代码中嵌入补充信息。
Spring 从 2.5 版本开始提供了对注解技术的全面支持，我们可以使用注解来实现自动装配，简化 Spring 的 XML 配置。
Spring 通过注解实现自动装配的步骤如下：
- 引入依赖
- 开启组件扫描
- 使用注解定义 Bean
- 依赖注入
搭建子模块
-
搭建子模块spring6-ioc-annotation
-
引入配置文件 log4j2.xml
-
添加依赖
<dependencies> <!--spring context依赖--> <!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>6.0.3</version> </dependency> <!--junit5测试--> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-api</artifactId> </dependency> <!--log4j2的依赖--> <dependency> <groupId>org.apache.logging.log4j</groupId> <artifactId>log4j-core</artifactId> <version>2.19.0</version> </dependency> <dependency> <groupId>org.apache.logging.log4j</groupId> <artifactId>log4j-slf4j2-impl</artifactId> <version>2.19.0</version> </dependency> </dependencies>
开启组件扫描
Spring 默认不使用注解装配 Bean，因此我们需要在 Spring 的 XML 配置中，通过 context:component-scan 元素开启 Spring Beans的自动扫描功能。开启此功能后，Spring 会自动从扫描指定的包（base-package 属性设置）及其子包下的所有类，如果类上使用了 @Component 注解，就将该类装配到容器中。
<?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/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--开启组件扫描-->
<context:component-scan base-package="com.gues">
</context:component-scan>
</beans>
注意：在使用 context:component-scan 元素开启自动扫描功能前，首先需要在 XML 配置的一级标签 中添加 context 相关的约束。
情况一：最基本的扫描方式
<context:component-scan base-package="com.atguigu.spring6">
</context:component-scan>
情况二：指定要排除的组件
<context:component-scan base-package="com.gues.spring6">
<!-- context:exclude-filter标签：指定排除规则 -->
<!--
type：设置排除或包含的依据
type="annotation"，根据注解排除，expression中设置要排除的注解的全类名
type="assignable"，根据类型排除，expression中设置要排除的类型的全类名
-->
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
<!--<context:exclude-filter type="assignable" expression="com.gues.spring6.controller.UserController"/>-->
</context:component-scan>
情况三：仅扫描指定组件
<context:component-scan base-package="com.gues" use-default-filters="false">
<!-- context:include-filter标签：指定在原有扫描规则的基础上追加的规则 -->
<!-- use-default-filters属性：取值false表示关闭默认扫描规则 -->
<!-- 此时必须设置use-default-filters="false"，因为默认规则即扫描指定包下所有类 -->
<!--
type：设置排除或包含的依据
type="annotation"，根据注解排除，expression中设置要排除的注解的全类名
type="assignable"，根据类型排除，expression中设置要排除的类型的全类名
-->
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
<!--<context:include-filter type="assignable" expression="com.gues.spring6.controller.UserController"/>-->
</context:component-scan>
使用注解定义Bean
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 相同。 |
@Autowired注入
单独使用@Autowired注解，默认根据类型装配。【默认是byType】
查看源码：
package org.springframework.beans.factory.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
boolean required() default true;
}
源码中有两处需要注意：
第一处：该注解可以标注的地方
- 构造方法上
- 方法上
- 形参上
- 属性上
- 注解上
第二处：该注解有一个required属性，默认值是true，表示在注入的时候要求被注入的Bean必须是存在的，如果不存在则报错。如果required属性设置为false，表示注入的Bean存在或者不存在都没关系，存在的话就注入，不存在的话，也不报错。
@Resource注入
@Resource注解也可以完成属性注入。那它和@Autowired注解有什么区别？
- @Resource注解是JDK扩展包中的，也就是说属于JDK的一部分。所以该注解是标准注解，更加具有通用性。(JSR-250标准中制定的注解类型。JSR是Java规范提案。)
- @Autowired注解是Spring框架自己的。
- @Resource注解默认根据名称装配byName，未指定name时，使用属性名作为name。通过name找不到的话会自动启动通过类型byType装配。
- @Autowired注解默认根据类型装配byType，如果想根据名称装配，需要配合@Qualifier注解一起用。
- @Resource注解用在属性上、setter方法上。
- @Autowired注解用在属性上、setter方法上、构造方法上、构造方法参数上。
@Resource注解属于JDK扩展包，所以不在JDK当中，需要额外引入以下依赖：【如果是JDK8的话不需要额外引入依赖。高于JDK11或低于JDK8需要引入以下依赖。】
<dependency>
<groupId>jakarta.annotation</groupId>
<artifactId>jakarta.annotation-api</artifactId>
<version>2.1.1</version>
</dependency>
源码：
package jakarta.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(Resources.class)
public @interface Resource {
String name() default "";
String lookup() default "";
Class<?> type() default Object.class;
Resource.AuthenticationType authenticationType() default Resource.AuthenticationType.CONTAINER;
boolean shareable() default true;
String mappedName() default "";
String description() default "";
public static enum AuthenticationType {
CONTAINER,
APPLICATION;
private AuthenticationType() {
}
}
}
Spring全注解开发
全注解开发就是不再使用spring配置文件了，写一个配置类来代替配置文件。
package com.gues.spring6.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
//@ComponentScan({"com.gues.spring6.controller", "com.gues.spring6.service","com.gues.spring6.dao"})
@ComponentScan("com.gues.spring6")
public class Spring6Config {
}
测试类
@Test
public void testAllAnnotation(){
ApplicationContext context = new AnnotationConfigApplicationContext(Spring6Config.class);
UserController userController = context.getBean("userController", UserController.class);
userController.out();
logger.info("执行成功");
}
![[JAVAee]文件操作-IO](https://img-blog.csdnimg.cn/f41d09ada0ce4563ad13cc9be589b229.png)
