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 把<>进行转义 &lt; &gt;
        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名称空间属性
      image.png
<?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">

image.png

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

  1. 创建一个类,让这个类作为工厂bean,实现接口FactoryBean
  2. 实现接口中的方法,在实现方法中返回定义的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的创建
  • 第一步:引入依赖
  • image.png
  • 第二步:开启组件扫描
<!--开启组件扫描
 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后续的学习很有帮助,也在此做个记录,方便后面查验。

Q.E.D.


空有烟霞之志,叹无水云之身。