开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> (一)Spring中IOC相关知识 -> 正文阅读

[Java知识库](一)Spring中IOC相关知识

一、入门案例

1.下载spring5

5. 创建spring配置文件，在配置文件中配置创建的对象

?Spring提供IOC容器实现两种方式（两个接口）

1.BeanFactory

2.ApplicationContext

四、IOC操作Bean管理????????????????????????????????????????????????????????????????

1.什么是Bean管理？

2.Bean管理操作

①基于xml配置文件方式实现 —— 创建对象、注入属性

1.准备工作 —— 创建类，定义数组、list、map、set类型属性，生成对应的set方法

（1）在spring配置文件中引入名称空间util

（2）使用util标签完成list集合注入提取

?编辑🐟🐟🐟FactoryBean

工厂bean（FactoryBean）演示

4.bean的后置处理器，bean的生命周期共有7步

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

②基于注解方式实现 —— 创建对象、注入属性

1.什么是注解？

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

一、入门案例

1.下载spring5

方式一：

https://download.csdn.net/download/m0_52982868/85629960

方式二（直接去官网下载）：

?Spring | Home?

https://repo.spring.io/simple/libs-release-local/org/springframework/spring/

下载后解压：

2.打开idea，创建普通Java工程

3. 导入spring5相关jar包

?基本包?

4.创建普通的类，在类中创建普通方法

package com.atguigu.spring5;

public class User {
    public void add(){
        System.out.println("add........");
    }
}

5. 创建spring配置文件，在配置文件中配置创建的对象

Spring配置文件使用xml格式

在src下创建bean1.xml

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

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

6.编写测试代码

package com.atguigu.spring5.testdemo;

import com.atguigu.spring5.User;
import javafx.application.Application;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring5 {
    @Test
    public void testAdd(){
        //1.加载spring的配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        //2.获取配置创建的对象
        User user = context.getBean("user", User.class);
        //user为自己在xml配置文件中取的id的值
        System.out.println(user);
        user.add();
    }
}

二、IOC（概念及原理）

1.什么是IOC

控制反转（Inversion of Control），是面向对象编程中的一种设计原则

把对象创建和对象之间的调用过程，交给spring进行管理，

2.使用IOC的目的

降低计算机代码之间的耦合度。

3.IOC底层原理

xml解析、工厂模式、反射

?原始方式

?工厂模式

最终的目的是降低耦合度，但是工厂模式并没有将耦合度降到最低

?IOC过程

🐟第一步：xml配置文件，配置创建的对象

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

进一步降低耦合度?

三、IOC接口

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

?Spring提供IOC容器实现两种方式（两个接口）

都可以进行IOC容器基本实现

1.BeanFactory

IOC容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用

加载配置文件时不会创建对象，在获取（使用）对象时创建对象

2.ApplicationContext

BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用

加载配置文件时候就会把在配置文件对象进行创建

四、IOC操作Bean管理????????????????????????????????????????????????????????????????

1.什么是Bean管理？

Bean管理的两个操作：

①Spring创建对象

②Spring注入属性

2.Bean管理操作

①基于xml配置文件方式实现 —— 创建对象、注入属性

Ⅰ、创建对象

在spring配置文件中添加bean标签，在标签中添加对应的属性，就可以实现对象的创建
bean标签中的属性

id：唯一标识
class：类的全路径（包类路径）

创建对象时，默认也是执行无参构造方法，完成对象的创建

Ⅱ、注入属性

（1）DI：依赖注入，就是注入属性?

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

①原始方式

package com.atguigu.spring5;

public class Book {
    private String bname;

    public void setBname(String bname) {
        this.bname = bname;
    }

    public static void main(String[] args) {
        Book book = new Book();
        book.setBname("asd");
    }
}

②使用set方法进行属性注入

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

package com.atguigu.spring5;

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;
    }
}

2. 在spring配置文件中配置对象创建，配置属性注入

<!--   2.set方法注入属性   -->
    <bean id="book" class="com.atguigu.spring5.Book">
<!--    使用property完成属性注入
        name：类里面属性的名称
        value：向属性中注入的值
 -->
        <property name="bname" value="asd"></property>
        <property name="bauthor" value="abab"></property>
    </bean>

?测试：

public void testDemo(){
    System.out.println(bname + ":" + bauthor);
}

@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();

注入方式二：?有参构造注入

①原始方式

//有参构造注入
public Book(String bname) {
    this.bname = bname;
}
public static void main(String[] args) {
    Book book = new Book("asd");
}

②使用有参构造注入

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

package com.atguigu.spring5;

public class Orders {
    private String oname;
    private String address;

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

2. 在spring配置文件中进行配置

<bean id="orders" class="com.atguigu.spring5.Orders">
    <constructor-arg name="oname" value="电脑"></constructor-arg>
    <constructor-arg name="address" value="China"></constructor-arg>
</bean>

（2）P名称空间注入

使用P名称空间注入，可以简化基于xml配置方式

添加p名称空间在配置文件中

进行属性注入，在bean标签中进行操作

    <!--   2.set方法注入属性   -->
        <bean id="book" class="com.atguigu.spring5.Book" p:bname="abcd" p:bauthor="adad"></bean>

🐟 xml注入其它类型属性

1.字面量

（1）null值

（2）属性值包含特殊符号

将特殊符号进行转义

将特殊符号内容写到CDATA中

2.注入属性——外部bean

①创建两个类：service dao

package com.atguigu.spring5.service;

import com.atguigu.spring5.dao.UserDao;
import com.atguigu.spring5.dao.UserDaoImpl;

public class UserService {
    public void add(){
        System.out.println("service add............");
        
    }
}

package com.atguigu.spring5.dao;

public interface UserDao {
    public void update();
}

package com.atguigu.spring5.dao;

public class UserDaoImpl implements UserDao{

    @Override
    public void update() {
        System.out.println("dao update.........");
    }
}

②在service调用dao中的方法

package com.atguigu.spring5.service;

import com.atguigu.spring5.dao.UserDao;
import com.atguigu.spring5.dao.UserDaoImpl;

public class UserService {
    public void add(){
        System.out.println("service add............");

        //原始方式
        //创建UserDao对象
        UserDao userDao = new UserDaoImpl();
        userDao.update();
    }
}

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

<?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.service和dao对象创建  -->
    <bean id="userService" class="com.atguigu.spring5.service.UserService">
        <!--  注入userDao对象
              name属性值：类里面属性的名称
              ref属性：创建userDao对象bean标签的id值
           -->
        <property name="userDao" ref="userDaoImpl"></property>
    </bean>
    <bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl"></bean>
<!--  2.service和dao对象创建  -->

</beans>

?测试

public class testBean {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");

        UserService userService = context.getBean("userService",UserService.class);

        userService.add();
    }
}

3.注入属性——内部bean和级联赋值?

?内部bean

（1）一对多关系：部门 —— 员工

部门类：

package com.atguigu.spring5.bean;

public class Dept {
    private String dname;

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

员工类

package com.atguigu.spring5.bean;

//员工类
public class Emp {
    private String ename;
    private String gender;


    //员工属于某一个部门，使用对象形式进行表示
    private  Dept dept;

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

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }
    
    public void add(){
        System.out.println(ename + ":" + gender + ":" + dept);
    }
}

（2）在实体类之间表示一对多的关系

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

<!--  内部bean  -->
    <bean id="emp" class="com.atguigu.spring5.bean.Emp">
<!--    设置两个普通属性    -->
        <property name="ename" value="tom"></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>
</beans>

测试

@Test
public void test1(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
    Emp emp = context.getBean("emp", Emp.class);
    emp.add();
}

?级联赋值

（1）方式一

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--  级联赋值  -->
    <bean id="emp" class="com.atguigu.spring5.bean.Emp">
        <!--    设置两个普通属性    -->
        <property name="ename" value="tom"></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>
</beans>

（2）方式二：需要生成dept中各属性的get方法

<?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">
    <!--  级联赋值  -->
    <bean id="emp" class="com.atguigu.spring5.bean.Emp">
        <!--    设置两个普通属性    -->
        <property name="ename" value="tom"></property>
        <property name="gender" value="女"></property>
        <!--  级联赋值  -->
        <property name="dept" ref="dept"></property>
        <property name="dept.dname" value="技术部"></property>
        <!--    向dept对象中设置dname的值    -->
    </bean>

    <bean id="dept" class="com.atguigu.spring5.bean.Dept">
        <property name="dname" value="经理"></property>
    </bean>
</beans>

🐟🐟 xml注入集合类型属性?

1.准备工作 —— 创建类，定义数组、list、map、set类型属性，生成对应的set方法

package com.atguigu.spring5.collectiontype;

import java.util.List;
import java.util.Map;
import java.util.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 setSets(Set<String> sets) {
        this.sets = sets;
    }

    //生成set方法
    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;
    }
}

2.注入属性

<?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">
    
    <!--   集合类型属性的注入  -->
    <bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
        <!--  数组类型属性的注入  -->
        <property name="courses">
            <!-- 使用array或者list标签 -->
            <array>
                <value>Java课程</value>
                <value>软件工程</value>
                <value>数据库</value>
                <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>
</beans>

3.测试

在Stu类中创建测试方法

    public void test(){
        System.out.println(Arrays.toString(courses));
        System.out.println(list);
        System.out.println(maps);
        System.out.println(sets);
    }

编写测试类

package com.atguigu.spring5.testDemo;

import com.atguigu.spring5.collectiontype.Stu;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

}

运行结果

🐟🐟?在集合里面设置对象类型值

创建course类

package com.atguigu.spring5.collectiontype;

public class Course {
    private String cname;//课程名称

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

    @Override
    public String toString() {
        return "Course{" +
                "cname='" + cname + '\'' +
                '}';
    }
}

在Stu类中加入属性courseList并生成其set方法

        <!--  注入list集合类型，值是对象  -->
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>

<!--  创建多个course对象  -->
    <bean id="course1" class="com.atguigu.spring5.collectiontype.Course">
        <property name="cname" value="Spring课程"></property>
    </bean>
    <bean id="course2" class="com.atguigu.spring5.collectiontype.Course">
        <property name="cname" value="MyBatis课程"></property>
    </bean>

🐟🐟把集合注入部分提取出来

（1）在spring配置文件中引入名称空间util

<?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"
       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">
</beans>

（2）使用util标签完成list集合注入提取

<!--  1.提取list集合类型属性的注入  -->
<util:list id="bookList">
    <value>C++</value>
    <value>数字电路逻辑设计</value>
    <value>Java疯狂讲义</value>
</util:list>
<!--  2.提取list集合类型属性的注入使用  -->
<bean id="book" class="com.atguigu.spring5.collectiontype.Book">
    <property name="list" ref="bookList"></property>
</bean>

测试：?

🐟🐟🐟FactoryBean

Spring有两种类型的bean：普通bean、工厂bean（FactoryBean）

普通bean：在配置文件中定义的bean的类型就是返回类型
工厂bean（FactoryBean）：在配置文件中定义的bean类型可以和返回类型不一样

工厂bean（FactoryBean）演示

1.创建类，让这个类作为工厂bean，实现接口FactoryBean

2.实现接口中的方法，在实现的方法中定义返回的bean类型

package com.atguigu.spring5.factorybean;

import com.atguigu.spring5.collectiontype.Course;
import org.springframework.beans.factory.FactoryBean;

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 FactoryBean.super.isSingleton();
    }
}

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


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

    </bean>
</beans>

🐟🐟🐟🐟bean作用域

在Spring中，可以设置创建bean实例是单实例还是多实例

默认情况下，bean是单实例对象

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

由图可见，输出地址相同，因此默认是单实例对象

如何设置单实例&多实例？

在spring配置文件bean标签里有属性（scope）用于设置单实例还是多实例

scope属性值：

?默认值：singleton —— 单实例对象
prototype —— 多实例对象
request —— 一次请求
session —— 一次会话

singleton与prototype的区别：

singleton是单实例，prototype是多实例
设置scope值是singleton时，加载spring配置文件时就会创建单实例对象
设置scope值是prototype时，不是在加载spring配置文件时创建对象，在调用getBean方法时创建多实例对象

?🐟🐟🐟🐟🐟bean的生命周期

1.什么是生命周期

从对象创建到对象销毁的过程

?2.bean的生命周期

（1）通过构造器创建bean实例（无参数构造）

（2）为bean的属性设置值和对其它bean的引用（调用set方法）

（3）调用bean的初始化的方法（需要进行配置）

（4）bean可以使用了（对象被获取）

（5）当容器关闭时，调用bean的销毁方法（需要进行配置销毁的方法）

3.演示bean的生命周期

package com.atguigu.spring5.bean;

public class Orders {
    
    //无参构造器
    public Orders() {
        System.out.println("1.执行无参构造，创建bean实例");
    }

    private String oname;
    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("2.调用set方法设置属性的值");
    }
    
    //创建执行的初始化的方法,需要配置到bean.xml中
    public void initMethod(){
        System.out.println("3.执行初始化的方法");
    }

    //创建执行的销毁的方法,需要配置到bean.xml中
    public void destroyMethod(){
        System.out.println("5.执行销毁的方法");
    }
}

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

    
    <bean id="orders" class="com.atguigu.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="oname" value="手机" ></property>
    </bean>
</beans>

@Test
    public void test4(){
//        ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");

        Orders orders = context.getBean("orders", Orders.class);
        System.out.println("4.获取创建的bean实例对象");
        System.out.println(orders);

        //手动让bean实例销毁
        context.close();
    }

注意！！！！！！

单例可以实现销毁的方法
多例的销毁在一个完整的会话过程中?

4.bean的后置处理器，bean的生命周期共有7步

（1）通过构造器创建bean实例（无参数构造）

（2）为bean的属性设置值和对其它bean的引用（调用set方法）

（3）把bean的实例传递备案后置处理器的方法

postProcessBeforeInitialization（）

（4）调用bean的初始化的方法（需要进行配置）

（5）把bean的实例传递备案后置处理器的方法

postProcessAfterInitialization（）

（6）bean可以使用了（对象被获取）

（7）当容器关闭时，调用bean的销毁方法（需要进行配置销毁的方法）

5. 演示添加后置处理器效果

创建类，实现接口BeanPostProcessor，创建后置处理器

BeanPostProcessor中的两个方法

package com.atguigu.spring5.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.lang.Nullable;

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 id="myBeanPost" class="com.atguigu.spring5.bean.MyBeanPost"></bean>

?🐟🐟🐟🐟🐟🐟xml自动装配

1.什么是自动装配

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

2.演示自动装配过程

手动装配方式：

package com.atguigu.spring5.autowire;

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);
    }
}

package com.atguigu.spring5.autowire;

public class Dept {
    @Override
    public String toString() {
        return "Dept{}";
    }


}

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

    <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>
</beans>

@Test
    public void test5(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean5.xml");
        Emp emp = context.getBean("emp", Emp.class);
        System.out.println(emp);
    }

自动装配方式：?

baen标签属性autowire，配置自动装配

auto wire中有两个常用属性值?：

byName：根据属性名称注入 —— 注入值bean的id值和类属性名称一样
byType：根据属性类型注入 —— 相同类型的beam不能定义多个

?🐟🐟🐟🐟🐟🐟🐟外部属性文件

1.直接配置数据库信息

（1）配置德鲁伊连接池

（2）引入德鲁伊连接池依赖（jar包）

<!--  直接配置连接池  -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <!--  驱动名称  -->
        <property name="driverClassName" value="com.mysql.cj.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.? ? 引入外部属性文件配置数据库连接池

（1）创建外部属性文件，properties格式文件，存储数据库信息

（2）把外部properties属性文件引入到spring配置文件中

引入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: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/util/spring-context.xsd">

    <!--  直接配置连接池  -->
<!--    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">-->
<!--        &lt;!&ndash;  驱动名称  &ndash;&gt;-->
<!--        <property name="driverClassName" value="com.mysql.cj.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>-->

    <!--  引入外部属性文件配置数据库连接池  -->

    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

    <!--  配置连接池  -->
        <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>
</beans>

②基于注解方式实现 —— 创建对象、注入属性

1.什么是注解？

注解是代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值......）
注解可以作用在类、属性、方法上
使用注解的目的是：简化xml配置?

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

以下四个注解功能是一样的，都可以用来创建bean实例

@Component
@Service
@Controller
@Repository

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

①引入aop依赖

②开启组件扫描

use-default-filters=“false” ：不使用默认的filter
context:include-filter type=“annotation” expression=“org.springframework.stereotypr.Controller”? ：设置扫描哪些内容（扫描带Controller注解的类）
context:exclude-filter type=“annotation” ?expression=“org.springframework.stereotypr.Controller” ：设置不扫描哪些内容，在不加use-default-filters=“false”时使用（不扫描带Controller注解的类）

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

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

③创建类，在类的上面添加创建对象的注解


import org.springframework.stereotype.Component;

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

4. 基于注解方式实现属性注入

Ⅰ @Autowired

根据属性类型进行自动注入

①创建dao和service的对象，在service和dao类添加创建对象的注解

import org.springframework.stereotype.Service;


@Service
public class UserService {
    public void add(){
        System.out.println("service add.......");
    }
}





import org.springframework.stereotype.Repository;

@Repository
public class UserDaoImpl implements UserDao{
    @Override
    public void add() {
        System.out.println("dao add......");
    }
}

②在service注入dao对象，在service类中添加dao类型属性，在属性上面使用注解

import com.atguigu.spring5.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

//在注解里面的value属性值可以省略不写
//默认值是类名称的首字母小写
//@Component(value = "userService")  //<bean id="userService" class="...">
@Service
public class UserService {

    //定义dao类型属性
    //不需要添加set方法
    @Autowired
    private UserDao userDao;

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

③测试

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

Ⅱ @Qualifier

根据属性名称进行注入

使用时和@Autowired一起使用

Ⅲ @Resource

可以根据类型注入，也可以根据名称注入

注意：Resource是javax扩展包中的注解

Ⅳ @Value

注入普通类型属性

5.完全注解开发

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

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration  //把当前类作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.atguigu"})
public class SpringConfig {
}

（2）编写测试类

@Test
    public void test1(){
        //加载配置类
        ApplicationContext context
                = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = context.getBean("userService",UserService.class);
        System.out.println(userService);
        userService.add();
    }