IOC操作 Bean管理操作（概念）
什么是Bean管理？
Bean管理就是对象的创建与注入属性的操作。在Spring中，这两个操作由Spring的Ioc容器来完成。也就是Spring的对象创建与Spring的对象属性注入。
Spring Bean管理的操作方式
- 基于xml配置文件的方式实现
- 基于注解的方式实现。
IOC操作 Bean管理操作（基于xml配置文件）
基于Xml的方式创建对象
public class User {
private String userName;
public void add() {
System.out.println("add......");
}
}
<!--1 配置User对象创建-->
<bean id="user" class="com.atguigu.spring5.User"></bean>
// 测试
public void testAdd() {
//1 加载spring配置文件
BeanFactory context =
new ClassPathXmlApplicationContext("bean1.xml");
//2 获取配置创建的对象
User user = context.getBean("user", User.class);
System.out.println(user);
user.add();
}
输出：add......
- 在Spring的配置文件中，使用bean表情，在标签中添加对应的属性，就可以完成Spring中的对象的创建。
- bean标签的属性：
- id属性：唯一标识
- class属性：需要创建的类的全限定名（包的路径）
- name属性：与id作用相同，不同的是id不可存在特殊符号，name可以，现在用的很少。
- Spring创建对象执行的也是类的默认无参构造方法。
基于Xml的方式注入属性（依赖注入）
DI:依赖注入，注入属性。是IOC的一种具体实现。需要在创建对象的基础之上。
- 使用Java原生的方法有两种对象属性注入方式：
- 第一种注入方式：set方法进行注入
- 第二中注入方式：有参构造方法。
- Spring基于Xml的注入属性的方式一：property标签
- 先使用bean标签创建对象
- 在bean标签内部使用property注入属性
- property标签注入属性的方式还是类的set方法。
详细代码如下，包括null值注入及特殊符号注入
public class Book {
private String bname;
private String bauthor;
private String address;
//创建属性对应的set方法
public void setBname(String bname) {
this.bname = bname;
}
public void setBauthor(String bauthor) {
this.bauthor = bauthor;
}
public void setAddress(String address) {
this.address = address;
}
public void testDemo() {
System.out.println(bname+"::"+bauthor+"::"+address);
}
}
<!--2 set方法注入属性-->
<bean id="book" class="com.atguigu.spring5.Book">
<!--使用property完成属性注入
name：类里面属性名称
value：向属性注入的值
-->
<property name="bname" value="天龙八部"></property>
<property name="bauthor" value="金庸"></property>
<!--null值-->
<!--<property name="address">
<null/>
</property>-->
<!--属性值包含特殊符号
1 把<>进行转义 < >
2 把带特殊符号内容写到CDATA
-->
<property name="address">
<value><![CDATA[<<南京>>]]></value>
</property>
</bean>
// 测试
@Test
public void testBook1() {
//1 加载spring配置文件
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
//2 获取配置创建的对象
Book book = context.getBean("book", Book.class);
System.out.println(book);
book.testDemo();
}
输出：天龙八部::金庸::<<南京>>
Spring基于Xml的注入属性的方式二：constructor-arg标签
- 先使用bean标签创建对象
- 在bean标签内部使用constructor-arg注入属性
- constructor-arg标签注入属性的方式是类的有参构造方法（前提是注入的属性有对应的有参构造方法）。
public class Orders {
//属性
private String oname="";
private String address;
//有参数构造
public Orders(String oname,String address) {
this.oname = oname;
this.address = address;
}
public void ordersTest() {
System.out.println(oname+"::"+address);
}
}
<!--3 有参数构造注入属性-->
<bean id="orders" class="com.atguigu.spring5.Orders">
<constructor-arg name="oname" value="电脑"></constructor-arg>
<constructor-arg name="address" value="China"></constructor-arg>
</bean>
@Test
public void testOrders() {
//1 加载spring配置文件
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
//2 获取配置创建的对象
Orders orders = context.getBean("orders", Orders.class);
System.out.println(orders);
orders.ordersTest();
}
输出：电脑::China
p名称空间注入
- 使用p名称空间注入，可以简化基于xml配置文件的方式。
- 添加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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--2 set方法注入属性-->
<bean id="book" class="com.atguigu.spring5.Book" p:bname="三国演义" p:bauthor="罗贯中"></bean>
</beans>
同上测试，输出：三国演义::罗贯中::null
相当于使用p代替了property标签。
注入属性-外部bean
- 先创建两个类，Service类和Dao类
- 在service中调用dao的方法
- 通过Spring创建这个Service并将Dao注入到这个Service
- 可以使用set或者有参构造的方式进行
public class UserService {
//创建UserDao类型属性，生成set方法
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void add() {
System.out.println("service add...............");
userDao.update();
}
}
public class UserDao {
public void update() {
System.out.println("dao update...........");
}
}
<!--1 service和dao对象创建-->
<bean id="userService" class="com.atguigu.spring5.service.UserService">
<!--注入userDao对象
name属性：类里面属性名称
ref属性：创建userDao对象bean标签id值
-->
<property name="userDao" ref="UserDao"></property>
</bean>
<bean id="UserDao" class="com.atguigu.spring5.dao.UserDao"></bean>
@Test
public void testBean1() {
//1 加载spring配置文件
ApplicationContext context =
new ClassPathXmlApplicationContext("bean2.xml");
//2 获取配置创建的对象
UserService userService = context.getBean("userService", UserService.class);
userService.add();
}
输出：
service add...............
dao update...........
注入属性-内部 bean
- 一对多关系：部门和员工，一个部门有多个员工，一个员工属于一个部门，部门是一，员工是多
- 在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示
//部门类
public class Dept {
private String dname;
public void setDname(String dname) {
this.dname = dname;
}
@Override
public String toString() {
return "Dept{" +
"dname='" + dname + '\'' +
'}';
}
}
//员工类
public class Emp {
private String ename;
private String gender;
//员工属于某一个部门，使用对象形式表示
private Dept dept;
//生成dept的get方法
public Dept getDept() {
return dept;
}
public void setDept(Dept dept) {
this.dept = dept;
}
public void setEname(String ename) {
this.ename = ename;
}
public void setGender(String gender) {
this.gender = gender;
}
public void add() {
System.out.println(ename+"::"+gender+"::"+dept);
}
}
<!--内部bean-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
<!--设置两个普通属性-->
<property name="ename" value="lucy"></property>
<property name="gender" value="女"></property>
<!--设置对象类型属性-->
<property name="dept">
<bean id="dept" class="com.atguigu.spring5.bean.Dept">
<property name="dname" value="安保部"></property>
</bean>
</property>
</bean>
@Test
public void testBean3() {
//1 加载spring配置文件
ApplicationContext context =
new ClassPathXmlApplicationContext("bean3.xml");
//2 获取配置创建的对象
Emp emp = context.getBean("emp", Emp.class);
emp.add();
}
输出：lucy::女::Dept{dname='安保部'}
注入属性-级联赋值
- 第一种写法：使用外部Bean的方式
<!--级联赋值-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
<!--设置两个普通属性-->
<property name="ename" value="lucy"></property>
<property name="gender" value="女"></property>
<!--级联赋值-->
<property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.atguigu.spring5.bean.Dept">
<property name="dname" value="财务部"></property>
</bean>
- 第二种写法：
<!--级联赋值-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
<!--设置两个普通属性-->
<property name="ename" value="lucy"></property>
<property name="gender" value="女"></property>
<!--级联赋值-->
<property name="dept" ref="dept"></property>
<property name="dept.dname" value="技术部"></property>
</bean>
<bean id="dept" class="com.atguigu.spring5.bean.Dept"></bean>
注入属性：注入集合
public class Stu {
//1 数组类型属性
private String[] courses;
//2 list集合类型属性
private List<String> list;
//3 map集合类型属性
private Map<String,String> maps;
//4 set集合类型属性
private Set<String> sets;
//学生所学多门课程
private List<Course> courseList;
public void setCourseList(List<Course> courseList) {
this.courseList = courseList;
}
public void setSets(Set<String> sets) {
this.sets = sets;
}
public void setCourses(String[] courses) {
this.courses = courses;
}
public void setList(List<String> list) {
this.list = list;
}
public void setMaps(Map<String, String> maps) {
this.maps = maps;
}
public void test() {
System.out.println(Arrays.toString(courses));
System.out.println(list);
System.out.println(maps);
System.out.println(sets);
System.out.println(courseList);
}
}
//课程类
public class Course {
private String cname; //课程名称
public void setCname(String cname) {
this.cname = cname;
}
@Override
public String toString() {
return "Course{ cname=" + cname + "}";
}
}
<!--1 集合类型属性注入-->
<bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
<!--数组类型属性注入-->
<property name="courses">
<array>
<value>java课程</value>
<value>数据库课程</value>
</array>
</property>
<!--list类型属性注入-->
<property name="list">
<list>
<value>张三</value>
<value>小三</value>
</list>
</property>
<!--map类型属性注入-->
<property name="maps">
<map>
<entry key="JAVA" value="java"></entry>
<entry key="PHP" value="php"></entry>
</map>
</property>
<!--set类型属性注入-->
<property name="sets">
<set>
<value>MySQL</value>
<value>Redis</value>
</set>
</property>
<!--注入list集合类型，值是对象,外部Bean-->
<property name="courseList">
<list>
<ref bean="course1"></ref>
<ref bean="course2"></ref>
</list>
</property>
</bean>
<!--创建多个course对象-->
<bean id="course1" class="com.atguigu.spring5.collectiontype.Course">
<property name="cname" value="Spring5框架"></property>
</bean>
<bean id="course2" class="com.atguigu.spring5.collectiontype.Course">
<property name="cname" value="MyBatis框架"></property>
</bean>
@Test
public void testCollection1() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
Stu stu = context.getBean("stu", Stu.class);
stu.test();
}
输出：
[java课程, 数据库课程]
[张三, 小三]
{JAVA=java, PHP=php}
[MySQL, Redis]
[Course{cname='Spring5框架'}, Course{cname='MyBatis框架'}]
把集合注入部分提取出来
在 spring 配置文件中引入名称空间util,同时修改xsi:schemaLocation
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
public class Book {
private List<String> list;
public void setList(List<String> list) {
this.list = list;
}
public void test() {
System.out.println(list);
}
}
<!--1 提取list集合类型属性注入-->
<util:list id="bookList">
<value>易筋经</value>
<value>九阴真经</value>
<value>九阳神功</value>
</util:list>
<!--2 提取list集合类型属性注入使用 单例-->
<bean id="book" class="com.atguigu.spring5.collectiontype.Book">
<property name="list" ref="bookList"></property>
</bean>
@Test
public void testCollection2() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean2.xml");
Book book = context.getBean("book", Book.class);
book.test();
}
输出：[易筋经, 九阴真经, 九阳神功]
基于Xml配置操作Bean管理（工厂bean）
在Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）
- 普通 bean：在配置文件中定义 bean 类型就是返回类型，也就是我们之前一直写的。
- 工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样
如何注入工厂bean
- 创建一个类，让这个类作为工厂bean，实现接口FactoryBean
- 实现接口中的方法，在实现方法中返回定义的bean的类型
public class MyBean implements FactoryBean<Course> {
//定义返回bean
@Override
public Course getObject() throws Exception {
Course course = new Course();
course.setCname("abc");
return course;
}
@Override
public Class<?> getObjectType() {
return null;
}
@Override
public boolean isSingleton() {
return false;
}
}
<!-- 定义返回工厂bean -->
<bean id="myBean" class="com.atguigu.spring5.factorybean.MyBean"></bean>
@Test
public void test3() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean3.xml");
Course course = context.getBean("myBean", Course.class);
System.out.println(course);
}
输出：Course{ cname=abc}
基于Xml配置操作Bean管理（bean的作用域）
- 在Spring中，bean的作用域指的就是你创建的bean是单例还是多例。
- 在Spring中，bean的作用域默认的是单实例对象。
- 如何设置单实例还是多实例
- 在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例
- singleton，表示是单实例对象
- prototype，表示是多实例对象
单实例验证：
<!--2 提取list集合类型属性注入使用 单例-->
<bean id="book" class="com.atguigu.spring5.collectiontype.Book">
<property name="list" ref="bookList"></property>
</bean>
@Test
public void testCollection2() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean2.xml");
Book book1 = context.getBean("book", Book.class);
Book book2 = context.getBean("book", Book.class);
// book1.test();
System.out.println(book1);
System.out.println(book2);
System.out.println(book1.equals(book2));
}
输出：
com.atguigu.spring5.collectiontype.Book@68d279ec
com.atguigu.spring5.collectiontype.Book@68d279ec
true
多实例验证：
<!--2 提取list集合类型属性注入使用 多例-->
<bean id="book" class="com.atguigu.spring5.collectiontype.Book" scope="prototype">
<property name="list" ref="bookList"></property>
</bean>
@Test
public void testCollection2() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean2.xml");
Book book1 = context.getBean("book", Book.class);
Book book2 = context.getBean("book", Book.class);
// book1.test();
System.out.println(book1);
System.out.println(book2);
System.out.println(book1.equals(book2));
}
输出：
com.atguigu.spring5.collectiontype.Book@68d279ec
com.atguigu.spring5.collectiontype.Book@258d79be
false
基于Xml配置操作Bean管理（bean的生命周期）
- 什么是生命周期
- 一个对象从创建到销毁的全过程。
- bean的生命周期
- 通过构造器创造bean实例（无参构造）
- 为bean对象的属性设置值和对其它bean的引用（调用set方法）
- 调用bean的初始化方法（需要进行相应的配置）
- bean创建成功，可以进行使用了
- 当容器关闭的时候，会调用bean的销毁方法（需要进行销毁）
- 代码演示
public class Orders {
//无参数构造
public Orders() {
System.out.println("第一步 执行无参数构造创建bean实例");
}
private String oname;
public void setOname(String oname) {
this.oname = oname;
System.out.println("第二步 调用set方法设置属性值");
}
//创建执行的初始化的方法
public void initMethod() {
System.out.println("第三步 执行初始化的方法");
}
//创建执行的销毁的方法
public void destroyMethod() {
System.out.println("第五步 执行销毁的方法");
}
}
<!-- 演示bean的生命周期 -->
<bean id="orders" class="com.atguigu.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
<property name="oname" value="手机"></property>
</bean>
@Test
public void testBean3() {
// ApplicationContext context =
// new ClassPathXmlApplicationContext("bean4.xml");
// 接口 ApplicationContext没有close()方法，需要使用其子接口的实现类ClassPathXmlApplicationContext完成
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("bean4.xml");
Orders orders = context.getBean("orders", Orders.class);
System.out.println("第四步 获取创建bean实例对象");
System.out.println(orders);
// 手动让bean实例销毁
context.close();
}
输出：
第一步 执行无参数构造创建bean实例
第二步 调用set方法设置属性值
第三步 执行初始化的方法
第四步 获取创建bean实例对象
com.atguigu.spring5.bean.Orders@3e2059ae
第五步 执行销毁的方法
- bean的后置处理器
- 通过构造器创造bean实例（无参构造）
- 为bean对象的属性设置值和对其它bean的引用（调用set方法）
- 把bean的实例传递给bean的后置处理器的方法 postProcessBeforeInitialization
- 调用bean的初始化方法（需要进行相应的配置）
- 把bean的实例传递给bean的后置处理器的方法 postProcessAfterInitialization
- bean创建成功，可以进行使用了
- 当容器关闭的时候，会调用bean的销毁方法（需要进行销毁）
- 代码演示:创建类，实现接口 BeanPostProcessor，创建后置处理器
public class MyBeanPost implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("在初始化之前执行的方法");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("在初始化之后执行的方法");
return bean;
}
}
<!--配置后置处理器，对当前配置文件所有bean实例都生效-->
<bean id="myBeanPost" class="com.atguigu.spring5.bean.MyBeanPost"></bean>
@Test
public void testBean3() {
// ApplicationContext context =
// new ClassPathXmlApplicationContext("bean4.xml");
// 接口ApplicationContext没有close()方法，需要使用其子接口的实现类ClassPathXmlApplicationContext完成
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("bean4.xml");
Orders orders = context.getBean("orders", Orders.class);
System.out.println("第四步 获取创建bean实例对象");
System.out.println(orders);
// 手动让bean实例销毁
context.close();
}
输出：
第一步 执行无参数构造创建bean实例
第二步 调用set方法设置属性值
在初始化之前执行的方法
第三步 执行初始化的方法
在初始化之后执行的方法
第四步 获取创建bean实例对象
com.atguigu.spring5.bean.Orders@275bf9b3
第五步 执行销毁的方法
基于Xml配置操作Bean管理（自动装配）
-
什么是自动装配？
- 根据指定的装配规则（属性名称或属性类型），Spring自动将匹配的属性值进行注入
-
实现自动装配
- bean标签属性autowire，配置自动装配
- autowire属性常用两个值：
- byName根据属性名称注入 ，注入值bean的id值和类属性名称一样
- byType根据属性类型注入
-
代码演示：
public class Emp {
private Dept dept;
public void setDept(Dept dept) {
this.dept = dept;
}
@Override
public String toString() {
return "Emp{ dept= " + dept +"}";
}
public void test() {
System.out.println(dept);
}
}
public class Dept {
@Override
public String toString() {
return "Dept{}";
}
}
<!-- 手动装配 -->
<bean id="emp" class="com.atguigu.spring5.autowire.Emp">
<property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>
<!-- byName根据属性名称注入 -->
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName">
</bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>
<!-- byType根据属性类型注入 -->
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType">
</bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>
@Test
public void test4() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean5.xml");
Emp emp = context.getBean("emp", Emp.class);
System.out.println(emp);
}
手动装配输出：Emp{ dept= Dept{}}
byName自动装配输出：Emp{ dept= Dept{}}
byType自动装配输出：Emp{ dept= Dept{}}
基于Xml配置操作bean管理（外部属性文件）
- 以数据库连接池德鲁伊为例
- 通过bean配置德鲁伊的连接池
<!-- 直接配置连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://127.0.0.1:3306/userDb"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
<!-- 先引入命名空间 -->
xmlns:context="http://www.springframework.org/schema/context"
// 外部配置文件
prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDb
prop.userName=root
prop.password=root
<!-- 引入外部属性文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 配置连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${prop.driverClass}"></property>
<property name="url" value="${prop.url}"></property>
<property name="username" value="${prop.userName}"></property>
<property name="password" value="${prop.password}"></property>
</bean>
@Test
public void test5() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean6.xml");
DruidDataSource dataSource = context.getBean("dataSource", DruidDataSource.class);
System.out.println(dataSource);
}
@Test
public void test5() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean6.xml");
DruidDataSource dataSource = context.getBean("dataSource", DruidDataSource.class);
System.out.println(dataSource);
}
输出：
{
CreateTime:"2021-07-20 15:31:27",
ActiveCount:0,
PoolingCount:0,
CreateCount:0,
DestroyCount:0,
CloseCount:0,
ConnectCount:0,
Connections:[
]
}
基于注解操作bean管理（基于注解方式）
- 什么是注解
- 注解是代码的特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值...)
- 使用注解方式：作用在类上面、方法上面、属性上面
- 目的：使代码更加干净易读，易于维护修改（简化xml配置）等。
- Spring 针对 Bean 管理中创建对象提供的注解（主要）：
- @Component：普通组件
- @Service：业务逻辑层
- @Controller：web层
- @Repository：持久层
上面的四个注解功能是一样的，都可以用来创建bean实例。
- 基于注解实现bean的创建
- 第一步：引入依赖
- 第二步：开启组件扫描
<!--开启组件扫描
1 如果扫描多个包，多个包使用逗号隔开
2 扫描包上层目录
-->
<context:component-scan base-package="com.atguigu"></context:component-scan>
- 第三步：创建类，在类上面添加创建对象注解
// 在注解里面 value 属性值可以省略不写，
// 默认值是类名称，首字母小写
// UserService -- userService
// @Component(value = "userService") //<bean id="userService" class=".."/>
@Service
public class UserService {
public void add() {
System.out.println("service add.......");
}
}
// 测试：
@Test
public void testService1() {
ApplicationContext context
= new ClassPathXmlApplicationContext("bean1.xml");
UserService userService = context.getBean("userService", UserService.class);
System.out.println(userService);
userService.add();
}
输出：
com.atguigu.spring5.service.UserService@12f9af83
service add.......abc
- 第四步：开启组件扫描细节配置
<!--示例 1
use-default-filters="false" 表示现在不使用默认 filter，自己配置 filter
context:include-filter ，设置扫描哪些内容
-->
<context:component-scan base-package="com.atguigu" use-defaultfilters="false">
<context:include-filter type="annotation"
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!--示例 2
下面配置扫描包所有内容
context:exclude-filter： 设置哪些内容不进行扫描
-->
<context:component-scan base-package="com.atguigu">
<context:exclude-filter type="annotation"
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
基于注解实现属性注入
- @Autowired：根据属性类型进行自动装配
- 第一步，把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解
- 第二步 在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解@Autowired
- @Qualifier：根据名称进行注入
- 需要和@Autowired一起使用
- @Resource：可以根据类型注入，可以根据名称注入
- 使用方法如上
- @Value：注入普通类型属性
- 以上都是注入外部bean对象，@Value时注入普通类型，如String、Integer等
@Repository("userDao")
public class UserDao {
public void add() {
System.out.println("dao add.....");
}
}
@Service
public class UserService {
@Value(value = "abc")
private String name;
//定义dao类型属性
@Autowired //根据类型进行注入
private UserDao userDao;
// @Autowired //根据类型进行注入
// @Qualifier(value = "userDao") //根据名称进行注入
// private UserDao userDao;
// @Resource //根据类型进行注入
// private UserDao userDao;
// @Resource(name = "userDao") //根据名称进行注入
// private UserDao userDao;
public void add() {
System.out.println("service add......." + name);
userDao.add();
}
}
<!--开启组件扫描
1 如果扫描多个包，多个包使用逗号隔开
2 扫描包上层目录
-->
<context:component-scan base-package="com.atguigu.spring5"></context:component-scan>
@Test
public void testService1() {
ApplicationContext context
= new ClassPathXmlApplicationContext("bean1.xml");
UserService userService = context.getBean("userService", UserService.class);
System.out.println(userService);
userService.add();
}
输出：放开不同的注释，测试，除UserService的地址不同，其它的都相同
com.atguigu.spring5.service.UserService@55493582
service add.......注入普通属性
dao add.....
完全注解开发
- 创建配置类，替代 xml 配置文件
@Configuration //作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.atguigu.spring5"})
public class SpringConfig {
}
@Test
public void testService2() {
//加载配置类
ApplicationContext context
= new AnnotationConfigApplicationContext(SpringConfig.class);
UserService userService = context.getBean("userService", UserService.class);
System.out.println(userService);
userService.add();
}
输出：
com.atguigu.spring5.service.UserService@55493582
service add.......abc
dao add.....
总结：
以上就是Spring 中IOC控制反转管理Bean的具体方式，虽然在以后的开发中基本不会用到了，但记录这些对于Spring Boot后续的学习很有帮助，也在此做个记录，方便后面查验。