Spring--IOC容器

2023-11-16

文章目录

- Spring--IOC容器

Spring–IOC容器

一、IOC概念和底层原理

1、官方概念：

Inversion of control缩写为IOC,是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入(Dependency Injection,简称DI)，还有一种方式叫做依赖查找（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

2、什么是IOC

（1）控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理。
（2）使用IOC的目的：为了降低耦合度

3、IOC底层原理

（1） xml解析
（2）工厂模式
（3）反射：通过获取class文件，来创建该对象并操作类的属性、构造、方法等。可以在程序运行中增加操作。

4、降低耦合的历史演变

（1）原始方法：耦合度高。例如：UserDao类的路径修改了，则所有调用UserDao方法的类路径都需要修改。
在这里插入图片描述
（2）工厂模式：通过新建一个UserFactory类，统一管理UserDao的创建，再有UserService调用，这样就可解耦。例如：当UserDao类路径改变时，只需要修改UserFactory类中UserDao的路径就可以了，其他所有***Service调用UserFactory创建的UserDao引用无需做任何改变，这样就降低了耦合度。
在这里插入图片描述
（3）IOC模式：在原有工厂模式的基础上，加上xml和反射，将对象的创建和引用交给Spring来管理，做进一步的解耦。例如，当UserDao的路径改变时，只需要修改配置文件中class的值就可以了，就算程序在运行中也可以替换xml的配置文件。
第一步：配置xml文件

<bean id="" class="com.demo.UserDao" />

第二步：有service类和dao类，创建工厂类

class UserFactory {
	public static UserDao getDao(){
	//1、dom4j解析配置文件，获取值
	String classValue = class属性值；
	//2、通过反射创建对象
	Class class = Class.forName(classValue);
    return	(UserDao)class.newInstance;
}

在这里插入图片描述

二、IOC接口（Beanfactory）

1、IOC思想基于IOC容器完成，IOC容器底层就是对象工厂

2、Spring提供IOC容器实现的两种方式：（两个接口）

（1）BeanFactory：IOC容器基本实现，是Spring内部的使用接口，不建议开发人员使用。
注：*加载配置文件的时候不会创建对象，而在获取（使用）对象的时候才去创建对象。
（2）ApplicationContext：BeanFactory接口的子接口，提供了更多更强大的功能，一般由开发人员使用
注：*加载配置文件的时候就会把配置文件对象进行创建。在web项目中，将耗时费力的工作在服务器启动时完成，这样客户端直接调用就好了。
（3）ApplicationContext接口有实现类
在这里插入图片描述
ClassPathXmlApplicationContext(“bean.xml”);这里的路径是类路径（src下的路径）
FileSystemXmlApplicationContext(“C:\bean.xml”)；这里的是绝对路径

三、IOC操作Bean管理（概念）

1、什么是Bean管理

Bean管理指的是两个操作
（1）Spring创建对象，通过解析xml，反射创建对象（cla.newInstance()；）
（2）Spring注入属性

2、Bean管理操作有两种方式

（1）基于xml配置文件方式实现
（2）基于注解方式实现

四、IOC操作Bean管理（基于xml）

1、基于xml方式创建对象

<!--配置User对象创建-->
    <bean id="user" class="com.demo.spring5.User"></bean>

（1）在spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建
（2）在bean标签有很多属性，介绍常用属性
id属性：唯一标识
class属性：类的全路径
name：类似id，区别（id不能加特殊符号，name可以加特殊符号），早期为struts1提供
（3）创建对象时候，默认也是执行无参构造，完成对象创建

2、基于xml方式注入属性

（1）DI：依赖注入

就是注入属性（创建对象的基础之上完成）

第一种注入方式：使用set方法进行注入

①创建类，定义属性和对应的set方法

public class Book {

    //创建属性
    private String bname;

    private String bauthor;

    //创建属性对应的set方法
    public void setBname(String bname) {
        this.bname = bname;
    }

    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }
}

②在spring配置文件配置对象创建，配置属性注入

<bean id="book" class="com.atguigu.spring5.Book">
        <!-- 使用property完成属性注入
            name：类里面属性名称
            value：向属性注入的值 
         -->
        <property name="bname" value="老人与海"></property>
        <property name="bauthor" value="海明威"></property>
    </bean>

第二种注入方式：使用有参数的构造进行注入

①创建类，定义属性，创建属性对应的有参构造方法

public class Orders {

    private String oname;
    private String address;

    public Orders(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }
}

②在spring配置文件中进行配置

<!-- 有参数构造注入属性 -->
    <bean id="order" class="com.atguigu.spring5.Orders">
        <constructor-arg name="oname" value="鸡蛋灌饼"></constructor-arg>
        <constructor-arg name="address" value="中国"></constructor-arg>
    </bean>

第三种 p名称空间注入

使用p名称空间注入，可以简化基于xml配置方式
①添加p名称空间在配置文件中

<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">

②进行属性注入，在bean标签里面操作

<bean id="book" class="com.atguigu.spring5.Book" p:bauthor="海明威" p:bname="老人与海" />

（2）xml注入其他类型属性

第一种字面量

①null值

<property name="address">
     <null/>
 </property>

②属性值包含特殊符号

<!--属性值包含特殊符号
  1、把<>进行转义 &lt; &gt;
  2、把带特殊符号内容写到 <![CDATA[]]> 中-->
<property name="address">
    <value><![CDATA[<北京>]]></value>
</property>

第二种注入属性-外部bean

①创建两个类，service类和dao类
②在service调用dao里面的方法
③在spring配置文件中进行配置

public class UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add(){
        System.out.println("service add......");
        userDao.update();
    }
}

	<!--配置userService和userDaoImpl-->
    <bean id="userService" class="com.atguigu.spring5.service.UserService">
        <!--将userDaoImpl注入
            name属性：类里面属性名称
            ref属性：创建userDao对象bean标签的id
        -->
        <property name="userDao" ref="userDaoImpl"></property>
    </bean>
    <bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl"></bean>

测试：

@Test
    public void testAdd(){
        ApplicationContext context =
                new FileSystemXmlApplicationContext("F:\\intellij IDEA\\workspace\\springday01\\src\\bean2.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }

结果：

service add......
dao update.....

第三种注入属性-内部bead

①一对多关系：部门和员工
一个部门有多个员工，一个员工属于一个部门
②在实体类之间表示一对多关系，员工表示所属部门

public class Dept {

    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }
}

public class Emp {

    private String ename;

    private String sex;

    private Dept dept;

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }
}

③xml文件配置如下（内部bean）：

	<!-- 内部bean -->
    <bean id="emp" class="com.atguigu.spring5.bean.Emp">
        <!-- 设置两个普通属性 -->
        <property name="ename" value="迪迦"></property>
        <property name="sex" 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 testOuterBean(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
        Emp emp = context.getBean("emp", Emp.class);
        System.out.println(emp);
    }

结果：

Emp{ename='迪迦', sex='未知', dept=Dept{dname='警卫部'}}

第四种级联赋值

①外部bean级联赋值

<!-- 级联赋值 -->
    <bean id="emp" class="com.atguigu.spring5.bean.Emp">
        <!-- 设置两个普通属性 -->
        <property name="ename" value="迪迦"></property>
        <property name="sex" value="未知"></property>
        <!-- 级联赋值 -->
        <property name="dept" ref="dept"></property>
    </bean>
    <bean id="dept" class="com.atguigu.spring5.bean.Dept">
        <property name="dname" value="警卫部"></property>
    </bean>

②生成get方法赋值

	public Dept getDept() {
        return dept;
    }

<!-- 级联赋值 -->
    <bean id="emp" class="com.atguigu.spring5.bean.Emp">
        <!-- 设置两个普通属性 -->
        <property name="ename" value="迪迦"></property>
        <property name="sex" value="未知"></property>
        <!-- 级联赋值 -->
        <property name="dept" ref="dept"></property>
        <property name="dept.dname" value="技术部"></property>
    </bean>
    <bean id="dept" class="com.atguigu.spring5.bean.Dept">
        <property name="dname" value="警卫部"></property>
    </bean>

第五种xml注入集合属性

①注入数组类型属性
②注入List集合类型属性
③注入Map类型属性
④注入Set类型属性
创建类，定义数组、list、map、set类型属性，生成对应的set

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;
    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 setSets(Set<String> sets) {
        this.sets = sets;
    }
	public void test(){
        System.out.println(Arrays.toString(courses));
        System.out.println(list);
        System.out.println(maps);
        System.out.println(sets);
    }
}

在spring配置文件中进行配置

    <!--集合属性注入-->
    <bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
        <!--集合属性注入-->
        <property name="courses">
            <array>
                <value>数学</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>
    </bean>

测试

	@Test
    public void testCollection(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        Stu stu = context.getBean("stu", Stu.class);
        stu.test();
    }

输出

[数学, 英语]
[迪迦, 小迪]
{JAVA=java, PHP=php}
[MySQL, Redis]

第六种在集合中设置对象类型值

新建course类

public class Course {

    private String cname;

    public void setCname(String cname) {
        this.cname = cname;
    }
}

学生类添加多个course对象list

private List<Course> courseList;

    public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }

spring配置文件配置

	<!--注入list集合类型，值是对象-->
	</bean>
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
    </bean>
    
    <!--创建多个ecourse对象-->
    <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>

测试结果

[Course{cname='Spring5框架'}, Course{cname='MyBatis框架'}]

把集合注入抽取出来
①在spring配置文件中引入名称空间

<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"
       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">

②创建book类，添加属性List

public class Book {
    private List<String> list;

    public void setList(List<String> list) {
        this.list = list;
    }
}

③使用util标签完成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);
        System.out.println("book = " + book);
    }

结果

book = Book{list=[老人与海, 基督山伯爵, 三个火枪手]}

（3）IOC操作Bean管理XML方式（FactoryBean）

① Spring有两种类型bean，一种普通bean，另外一种工厂bean(FactoryBean)
② 普通bean：在配置文件中定义bean类型就是返回类型
③ 工厂bean：在配置文件定义bean类型可以和返回类型不一样
第一步创建类，让这个类作为工厂bean，实现接口FactoryBean
第二步实现接口里面的方法，在实现的方法中定义返回的bean类型

public class MyBean implements FactoryBean<Course> {

    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("赛罗");
        return course;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }

}

spring配置文件配置

<bean id="myBean" class="com.atguigu.spring5.factorybean.MyBean"></bean>

测试：

	@Test
    public void testFactoryBean(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
        Course myBean = context.getBean("myBean", Course.class);
        System.out.println("myBean = " + myBean);
    }

结果：

myBean = Course{cname='赛罗'}

（4）IOC操作Bean管理XML方式（bean作用域）

① 在spring里面，设置创建bean实例是单实例还是多实例
② 在spring里面，默认情况下，bean是单实例对象

<bean id="book" class="com.atguigu.spring5.collectiontype.Book" />

	@Test
    public void testCollection2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
        Book book1 = context.getBean("book", Book.class);
        Book book2 = context.getBean("book", Book.class);
        System.out.println("book1 = " + book1);
        System.out.println("book2 = " + book2);
    }

结果显示两个地址相同，都是@35a50a4c，说明是单实例

book1 = com.atguigu.spring5.collectiontype.Book@35a50a4c
book2 = com.atguigu.spring5.collectiontype.Book@35a50a4c

③如何设置单实例还是多实例
在spring配置文件bean标签里有属性（scope）用于设置单实例还是多实例
scope值：
singleton（单实例）：在加载spring配置文件时创建
prototype（多实例）：在调用getBean()创建
request（每次创建都放到request中）
session（每次创建都放到session中）

<bean id="book" class="com.atguigu.spring5.collectiontype.Book" scope="prototype"/>

结果显示两个地址不同，说明是多实例

book1 = com.atguigu.spring5.collectiontype.Book@35a50a4c
book2 = com.atguigu.spring5.collectiontype.Book@1f021e6c

（5）IOC操作Bean管理XML方式（bean生命周期）

① 生命周期：从对象创建到对象销毁的过程
② bean生命周期：
第一步通过构造器创建bean实例(无参数构造)
第二步为bean的属性设置值和对其他bean引用（调用set方法）
第三步调用bean的初始化的方法(需要进行配置初始化的方法)
第四步 bean可以使用了（对象获得）
第五步当容器关闭时候，调用bean的销毁的方法（需要进行配置销毁的方法）
③演示bean生命周期：
创建orders类

public class Orders {

    public Orders() {
        System.out.println("第一步 调用无参构造创建bean");
    }

    private String oname;

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步 调用set方法设置属性或设置bean");
    }

    /**
     * 配置初始化方法
     */
    public void initMethod(){
        System.out.println("第三步 初始化的方法");
    }

    /**
     * 配置销毁bean实例的方法
     */
    public void destoryMethod(){
        System.out.println("第五步 销毁bean实例的方法");
    }

}

配置spring.xml文件

	   <bean id="orders" class="com.atguigu.spring5.beancycle.Orders" init-method="initMethod" destroy-method="destoryMethod">
              <property name="oname" value="劳伦兹"></property>
       </bean>

测试：

	@Test
    public void testBeanCycle(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
        Orders orders = context.getBean("orders", Orders.class);
        System.out.println("第四步 获取bean实例");
        System.out.println(orders);
        ((ClassPathXmlApplicationContext)context).close();
    }

结果：

第一步 调用无参构造创建bean
第二步 调用set方法设置属性或设置bean
第三步 初始化的方法
第四步 获取bean实例
com.atguigu.spring5.beancycle.Orders@4e718207
第五步 销毁bean实例的方法

④ bean的后置处理器
第一步通过构造器创建bean实例(无参数构造)
第二步为bean的属性设置值和对其他bean引用（调用set方法）
第三步把bean实例传递bean后置处理器的方法postProcessBeforeInitialization
第四步调用bean的初始化的方法(需要进行配置初始化的方法)
第五步把bean实例传递bean后置处理器的方法postProcessAfterInitialization
第六步 bean可以使用了（对象获得）
第七步当容器关闭时候，调用bean的销毁的方法（需要进行配置销毁的方法）
⑤ 演示添加后置处理器效果
创建MyBeanPost并实现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;
    }
}

配置spring配置文件，在本配置文件中所有的bean都会执行配置处理器

<bean id="orders" class="com.atguigu.spring5.beancycle.Orders" init-method="initMethod" destroy-method="destoryMethod">
         <property name="oname" value="劳伦兹"></property>
</bean>
<bean id="myBeanPost" class="com.atguigu.spring5.beancycle.MyBeanPost"></bean>

测试结果：

第一步 调用无参构造创建bean
第二步 调用set方法设置属性或设置bean
在初始化之前执行的方法！
第三步 初始化的方法
在初始化之后执行的方法！
第四步 获取bean实例
com.atguigu.spring5.beancycle.Orders@13eb8acf
第五步 销毁bean实例的方法

（6）IOC操作Bean管理XML方式（自动装载）

①什么是自动装配

根据指定装配规则（属性名称或属性类别），Spring自动将匹配的属性值进行注入

②根据属性名自动注入

<!-- 
           bean标签属性autowire，配置自动装配
           autowire属性常用的两个值：
                     byName根据属性名称注入，注入值bean的id值和类属性名称一样，
                     byTypoe根据属性类型注入
       实现自动装配 -->
       <bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName">
<!--              <property name="dept" ref="dept"></property>-->
       </bean>

       <bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

③根据属性类别自动注入

<!--
           bean标签属性autowire，配置自动装配
           autowire属性常用的两个值：
                     byName根据属性名称注入，注入值bean的id值和类属性名称一样，
                     byTypoe根据属性类型注入
       实现自动装配 -->
       <bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType">
<!--              <property name="dept" ref="dept"></property>-->
       </bean>

       <bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

（7）IOC操作Bean管理XML方式（外部属性文件）

1、直接配置数据库信息

<!-- 直接配置连接池 -->
       <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
              <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
              <property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
              <property name="username" value="root"></property>
              <property name="password" value="123456"></property>
       </bean>

2、引入外部属性文件配置数据库的连接池

创建外部属性文件，properties格式文件，写数据库信息

prop.driverClass=com.alibaba.druid.pool.DruidDataSource
prop.url=jdbc:mysql://classhost:3306/userDb
prop.userName=root
prop.password=123456

把外部properties属性文件引入到spring的xml配置文件中
引入context名称空间

<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"
       xmlns:util="http://www.springframework.org/schema/util"
       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/util http://www.springframework.org/schema/util/spring-util.xsd
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

使用spring表达式配置数据库链接池

<!--引入外部属性文件-->
       <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>

五、IOC操作Bean管理（基于注解方式）

1、什么是注解

（1）注解是代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值…）
（2）使用注解，注解作用在类上面，方法上面，属性上面
（3）使用注解目的：简化xml配置

2、Spring针对Bean管理中创建对象提供注解

（1）@Component普通注解
（2）@Service业务层
（3）@Controller外层
（4）@Repositorydao层
上面四个注解功能是一样的，都可以用来创建bean实例

3、基于注解方式实现对象创建

第一步引入依赖
在这里插入图片描述
第二步开启组件扫描

<!-- 开启组件扫描 
            1、如果扫描多个包，多个包使用逗号隔开
            2、扫描包上层目录
       -->
       <context:component-scan base-package="com.atguigu.spring5"></context:component-scan>

第三步创建类，在类上面添加创建对象注解

//在注解里value属性值可以省略不写，
//默认值是类名称，首字母小写
//UserService -- userService
@Component(value = "userService")
public class UserService {
    
    public void add(){
        System.out.println("userService add ..........");
    }
}

第四步测试

	@Test
    public void testService(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        UserService userService = context.getBean("userService", UserService.class);
        System.out.println(userService);
        userService.add();
    }

4、开启组件扫描细节配置

		<!-- 示例1
              use-default-filters="false" 表示现在不使用默认filter，自己配置filter
              context:include-filter 设置扫描那些内容
        -->
       <context:component-scan base-package="com.atguigu.spring5" use-default-filters="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.spring5">
              <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
       </context:component-scan>

5、基于注解方式实现属性注入

（1）@Autowored：根据属性类型注入
第一步把service和dao对象创建，在service和dao类添加创建对象注解
第二步在service中注入dao对象，在service类添加dao类型属性，在属性上面使用注解

//在注解里value属性值可以省略不写，
//默认值是类名称，首字母小写
//UserService -- userService
@Service
public class UserService {

    //定义dao类型属性
    //不需要添加set方法
    //添加注入属性注解
    @Autowired
    private UserDao userDao;
    
    public void add(){
        System.out.println("userService add ..........");
        userDao.add();
    }
}

(2) @Qualifier：根据属性名称进行注入
这个@Qualifier注解的使用，和上面@Autowired一起使用

	//定义dao类型属性
    //不需要添加set方法
    //添加注入属性注解
    @Autowired
    @Qualifier(value = "userDaoImpl1")//根据名称进行注入
    private UserDao userDao;

(3) @Resource：可以根据类型注入，也可以根据名称注入

//    @Resource //根据类型进行注入
    @Resource(name = "userDaoImpl1") //根据名称进行注入
    private UserDao userDao;

（4）@Value：注入普通类型属性

	@Value(value = "abc")
    private String name;

6、完全注解开发

（1）创建配置类，替代xml配置文件

@Configuration
@ComponentScan(basePackages = {"com.atguigu"})
@PropertySource("classpath:test.properties")
public class SpringConfig {
}

（2）测试

    @Test
    public void testService2(){
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = context.getBean("userService", UserService.class);
        System.out.println(userService);
        userService.add();
    }

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Spring

Java