IOC容器：

（1）IOC底层原理

1.什么是IOC

（1）控制反转，把对象的创建和对象之间的调用过程，交给Spring进行管理

（2）目的：为了耦合度降低

2.IOC底层原理

（1）xml解析、工厂模式、反射(通过得到你类的字节码文件操作类中的所有内容)

（2）IOC接口（BeanFactory）

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

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

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

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

（2）ApplicationContext：BeanFaxtory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用

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

（3）ApplicationContext接口中的实现类

FileSystemXmlApplicationContext：表示使用盘符路径（例:“C://spring_dome/com/yxm/bean.xml”）

ClassPathXmlApplicationContext：表示使用类路径即src下的xml文件（例：“bean.xml”）

（3）IOC操作 Bean管理

（Bean：是java中的任何一种对象：javabean/service/action/数据源/dao等）

1.什么是Bean管理（指两个操作）：

（1）Spring创建对象

（2）Spring注入属性

2.Bean管理操作的两种方式

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

1.基于xml方式创建对象

（1）在spring配置文件中，使用bean标签，标签中添加对应属性，实现对象创建

（2）bean标签中的常用属性

*id属性：唯一标识

*class属性：类全路径（包类路径）

*name属性（了解）：与id功能相同，且可以添加特殊符号.例：name=“/user”

(3)创建对象时，默认执行无参构造方法完成对象创建

2.基于xml方式注入属性

（1）DI：依赖注入（注入属性）：

DI是IOC中的一种具体实现表示依赖注入

（2）第一种注入方式：使用set方法注入

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

public class Book {
    //创建属性
    private String bookName;
    private String bookAuthor;
    //创建set方法
    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public void setBookAuthor(String bookAuthor) {
        this.bookAuthor = bookAuthor;
    }
}

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

    <!--1.配置Book对象的创建-->
    <!--2.set方法注入属性-->
    <bean id="book" class="com.yxm.spring5.Book">
        <!--使用property完成属性注入
            name:类里面属性的名称
            value:向属性注入的值
        -->
        <property name="bookName" value="西游记"></property>
        <property name="bookAuthor" value="吴承恩"></property>
    </bean>

（3）第二种注入方式：使用有参构造进行注入

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

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

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

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

<!--3有参构造注入属性-->
<bean id="orders" class="com.yxm.spring5.Orders">
    <!--使用constructor-arg完成属性注入
        name:类里面属性的名称
        value:向属性注入的值-->
    <constructor-arg name="orderName" value="篮球"></constructor-arg>
    <constructor-arg name="address" value="济南市"></constructor-arg>
</bean>

（4）p名称空间注入

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

​ 第一步添加p名称空间注入在配置文件中

​ 第二步 进行属性注入，在bean标签中操作

<!--简化set方法注入属性-->
<bean id="book" class="com.yxm.spring5.Book" p:bookName="红楼梦" p:bookAuthor="曹雪芹"></bean>

（5）IOC操作 Bean管理（xml注入其他类型属性）

​ 1.字面量：（通过定义直接赋值或通过property，constructor-arg设定的固定值）

​ （1）null值

<!--null值-->
<property name="address" >
    <null/>
</property>

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

<!--属性值包含特殊符号
    1.进行转译（&lt;&gt;）
    2.把带特殊符号内容写到CDATA中
-->
<property name="address">
    <value><![CDATA[<<济南>>]]></value>
</property>

​ 2.注入属性-外部Bean

​ （1）创建两个类service类和dao类

​ （2）在service调用dao中的方法

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

​ （3）在spring配置文件中进行配置

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

​ 3.注入属性-内部Bean和级联赋值

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

​ 一个部门有多个员工，一个员工属于一个部门

​ 部门是一，员工是多

​ （2）在实体类中表示一对多得关系 员工表示所属部门，使用对象类型属性进行表示

//部门类
public class Dept {
   
    private String deptName;

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }
}

//员工类
public class Emp {
    private String empName;
    private String empSex;
    //员工属于某一个部门，使用对象形式表示
    private Dept dept;

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

    public void setEmpName(String empName) {
        this.empName = empName;
    }

    public void setEmpSex(String empSex) {
        this.empSex = empSex;
    }
}

​ （3）在spring配置文件中进行配置

<!--内部bean-->
<bean id="emp" class="com.yxm.spring5.bean.Emp">
    <!--先设置两个普通属性-->
    <property name="empName" value="yuan"></property>
    <property name="empSex" value="男"></property>
    <!--对象属性属性-->
    <property name="dept" >
        <bean id="dept" class="com.yxm.spring5.bean.Dept">
            <property name="deptName" value="财务部"></property>
        </bean>
    </property>
</bean>

​ （4）注入属性-级联赋值

​ 第一种写法

<!--级联赋值-->
<bean id="emp" class="com.yxm.spring5.bean.Emp">
    <!--先设置两个普通属性-->
    <property name="empName" value="yuan"></property>
    <property name="empSex" value="男"></property>
    <!--级联赋值-->
    <property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.yxm.spring5.bean.Dept">
    <property name="deptName" value="运营"></property>
</bean>

​ 第二种写法

<!--级联赋值-->
<bean id="emp" class="com.yxm.spring5.bean.Emp">
    <!--先设置两个普通属性-->
    <property name="empName" value="yuan"></property>
    <property name="empSex" value="男"></property>
    <!--级联赋值-->
    <property name="dept" ref="dept"></property>
    <property name="dept.deptName" value="技术部"></property>
</bean>
<bean id="dept" class="com.yxm.spring5.bean.Dept">
    <property name="deptName" value="运营"></property>
</bean>

​ 4.IOC操作 Bean 管理（xml注入集合属性）

​ （1）注入数组类型属性

​ （2）注入List集合类型属性

​ （3）注入Map集合类型属性

​ *1创建类，定义数组、List、map、set类型属性，生成对应set方法

public class Stu {
    //1.数组类型属性
    private String[] courses;

    //2.List集合类型属性
    private List<String> list;

    //3.map集合类型属性
    private Map<String, String> map;

    //4.set集合类型属性
    private Set<String> sets;

    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 setMap(Map<String, String> map) {
        this.map = map;
    }
}

​ *2在spring配置文件进行配置

<!--1 集合类型属性注入-->
<bean id="stu" class="com.yxm.spring5.collectiontype.Stu">
    <!--数组类型属性注入-->
    <property name="courses">
        <array>
            <value>计算机组成原理</value>
            <value>数据库</value>
        </array>
    </property>
    <!--List类型属性注入-->
    <property name="list">
        <list>
            <value>袁新铭</value>
            <value>yuan</value>
        </list>
    </property>
    <!--map类型属性注入-->
    <property name="map">
        <map>
            <entry key="JAVA" value="java"></entry>
            <entry key="Python" value="p"></entry>
        </map>
    </property>
    <!--set类型属性注入-->
    <property name="sets">
        <set>
            <value>MySQL</value>
            <value>Redis</value>
        </set>
    </property>
</bean>

​ (4)在集合里面设置对象类型值

​ 第一步

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

​ 第二步

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

​ (5)把集合注入部分提取出来

​ *1在spring配置文件中引入名称空间util

​ *2使用util标签完成list集合注入提取

<!--提取list集合类型属性注入-->
<util:list id="bookList">
    <value>英语</value>
    <value>数学</value>
    <value>语文</value>
</util:list>

<!--使用提取的部分-->
<bean id="book" class="com.yxm.spring5.collectiontype.Book">
    <property name="list" ref="bookList"></property>
</bean>

3.IOC操作Bean管理（FactoryBean）工厂bean

1.Spring有两种类型的bean，一种普通bean，另一种FactoryBean（工厂bean）

2.普通Bean：你在配置文件的bean标签里面定义的class里面的bean类型，返回的就是什么类型

3.工厂bean：定义的类型与返回的类型可以不一样

​ 第一步 创建类，让这个类作为工厂bean，实现接口FactoryBean

​ 第二步 实现接口中的方法，在实现的方法中定义返回方法中定义返回的bean类型

public class MyFactoryBean implements FactoryBean<Course> {

    //定义返回bean
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCourseName("yyy");
        return course;
    }

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

    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}
//测试类
    @Test
    public void testCollectionMyFactoryBean(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");

        Course course = context.getBean("myFactoryBean", Course.class);

        System.out.println(course);
    }
//配置文件
    <bean id="myFactoryBean" class="com.yxm.spring5.factorybeandome.MyFactoryBean">
    </bean>

4.IOC操作Bean管理（bean作用域）

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

2.在Spring里，在默认情况下bean为单实例对象

补充：单例：（堆内存中只开辟出一个内存空间）

​ 多例：（堆内存中对应对象开辟内存空间））

3.设置单实例、多实例

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

（2）scope属性值
第一个值 默认值，singleton，表示单实例对象

第二个值 prototype，表示多实例对象

（3）singleton和prototype区别

*singleton单实例prototype多实例

*设置scope值为singleton时，加载spring配置文件时就会创建单实例对象

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

scope其他值：

Request：表示一次请求

session：表示一次会话

5.IOC操作Bean管理（bean的生命周期）

1.生命周期

​ （1）从对象创建到对象销毁的过程

2.bean的生命周期

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

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

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

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

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

3.bean生命周期演示

public class Orders {
    
    private String ordersName;
    public void setOrdersName(String ordersName) {
        this.ordersName = ordersName;
        System.out.println("第二步 调用set方法设置属性值");
    } 
    //无参构造
    public Orders() {
        System.out.println("第一步 执行无参构造创建bean实例");
    }
    
    //创建执行的初始化的方法
    public void initMethod(){
        System.out.println("第三步 执行初始化的方法");
    }
    //创建执行销毁的方法
    public void destroyMethod(){
        System.out.println("第五步 执行销毁的方法");
    }
}

<bean id="orders" class="com.yxm.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
    <property name="ordersName" value="电脑"></property>
</bean>

测试代码
@Test
public void testOrdersBean(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");

    Orders orders = context.getBean("orders", Orders.class);

    System.out.println("第四步 获取创建bean实例对象");
    System.out.println(orders);

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

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

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

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

​ （3）把bean实例传递给bean后置处理器的方法（postProcessBeforeInitialization）

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

​ （5）把bean实例传递给bean后置处理器的方法（postProcessAfterInitialization）

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

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

5.添加后置处理器的效果

（1）创建类，实现接口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.yxm.spring5.bean.MyBeanPost"></bean>

6.IOC操作Bean管理（xml自动装配）

1.什么是自动装配

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

2.自动装配的过程

根据属性名称进行注入

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

根据属性类型进行注入

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

7.IOC操作Bean管理（外部属性文件）

1.直接配置数据库信息

（1）配置德鲁伊连接池

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

<!--直接配置连接池-->
    <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/stu"></property>
        <property name="username" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>

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

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

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

*引入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">

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

（2）基于注解方式实现

1.什么是注解：

（1）注解式代码中的特殊标记，格式：@注解名称（属性名称=属性值,属性名称=属性值…）

（2）使用注解，注解可以作用在类上面，方法上面，属性上面

（3）使用注解的作用：简化xml配置

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

（1）@Component

（2）@Service：一般用于业务逻辑层

（3）@Controller：一般用于web层

（4）@Repository：一般用于dao层持久层

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

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

第一步 引入依赖spring-aop.jar

第二步 开启组件扫描

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

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

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

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

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

<!--实例1
    use-default-filters="false"表示现在不使用默认filter，自己配置filter
    context:include-filter ,设置扫描那些内容
    解释：现在只扫描com.yxm包下面为Controller注解的类
-->
<context:component-scan base-package="com.yxm" use-default-filters="false">
    <context:include-filter type="annotation" 
                            expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

<!--实例二
    下面配置表示扫描包所有内容
    context:exclude-filter：设置那些内容不进行扫描
-->
<context:component-scan base-package="com.yxm">
    <context:exclude-filter type="annotation" 
                            expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

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

（1）@Autowired：根据属性类型进行自动配置

第一步 把service和dao对象创建，在service和dao类添加创建对象注解

第二步 在service注入dao对象，在service类添加到类型属性，在属性上面使用注解

@Service
public class UserService {

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

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

（2）@Qualifier：根据属性名称进行注入

@Qualifier注解的使用要和@Autowired一起使用

一个接口可能有多个实现类，此时使用@Autowired只能指定一个类型不能准确到哪一个实现类而@Qualifier可以通过名称去进行注入

@Service
public class UserService {

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


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

（3）@Resource：可以根据类型注入，也可以通过属性名称进行注入

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

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

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

6.纯注解开发

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

@Configuration //作为配置类，代替xml配置文件
@ComponentScan(basePackages = {"com.yxm"})
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();
}