Spring 基于 XML 的 IOC

<?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属性: 对象的唯一标识，根据这个唯一标识，就可以从核心容器中获取对象
            class属性: 对象所属的实现类的全限定名
            scope属性: 对象的范围
                 1. singleton 单例（默认）
                 2. prototype 多例
            lazy-init: 配置懒加载，核心容器创建的时候是否创建出该类对象
            init-method: 配置类的对象初始化的时候，要调用哪个方法
            destroy-method: 配置这个类的对象销毁的时候，要调用哪个方法
            单例模式下(默认没有开启懒加载)，由核心容器进行管理的对象什么时候创建什么时候销毁?
            1. 核心容器创建的时候，会创建出它所配置的所有类的对象
            2. 核心容器销毁的时候，它里面的对象才会被销毁

            多例模式下，由spring管理的对象什么时候创建什么时候销毁
            1. 当核心容器调用getBean(id)的时候，创建对象
            2. 垃圾回收机制才能销毁这个对象
    -->
    <bean class=""
          id=""
          scope="prototype" lazy-init="false"
          init-method="init"
          destroy-method="destroy"></bean>
</beans>

Spring工厂详解
工厂类继承关系

• BeanFactory
  • ApplicationContext
    • FileSystemXmlApplicationContext xml方式 它是从磁盘路径上加载配置文件
    • ClassPathXmlApplicationContext xml方式 它是从类的根路径下加载配置文件
    • AnnotationConfigApplicationContext 注解方式的

两者的区别:

• ApplicationContext加载方式是框架启动时就开始创建所有单例的bean,存到了容器里面

  • 非懒加载: 在核心容器创建的时候，创建出所有的bean对象，存到核心容器中
  • 懒加载: 第一次调用getBean()的时候，创建出bean对象，存到核心容器中

• BeanFactory加载方式是用到bean时再加载(目前已经被废弃)

  • 懒加载: 第一次调用getBean()的时候，创建出bean对象，存到核心容器中

• ApplicationContext是BeanFactory的子接口，子接口的功能肯定比父接口更强大

实例化Bean的三种方式

方式一: 无参构造方法方式
需要实例化的类，提供无参构造方法

<bean class="" id=""></bean>

方式二: 静态工厂方式
需要额外提供工厂类 ， 工厂方法是静态方法

	<!--
        配置使用静态工厂实例化Bean
        id就是创建的这个对象的唯一标识
        class就是要调用的那个静态工厂的全限定名
        factory-method就是要调用的那个静态工厂中的方法名
    -->
<bean id="dataSource" class=""
      factory-method="getDataSource"></bean>

方式三:实例工厂实例化Bean的方法

<!--
  配置实例工厂实例化Bean
  第一步: 配置实例工厂对象
  第二步: 配置bean对象
  factory-bean 表示要调用哪个实例工厂对象
  factory-method 表示要调用实例工厂对象的哪个方法
-->
<bean id="druidUtil" class=""></bean>
<bean id="dataSource" factory-bean="druidUtil" 
	  factory-method="getDataSource"></bean>

依赖注入
依赖注入全称是 dependency Injection 翻译过来是依赖注入.其实就是如果spring核心容器管理的某一个类中存在属性，需要spring核心容器在创建该类实例的时候，顺便给这个对象里面的属性进行赋值。 这就是依赖注入。

XML依赖注入实现

1. 构造方法方式注入

public class UserServiceImpl implements UserService{
    private UserDao userDao;

    public UserServiceImpl() {
    }
    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public String getName() {
        return userDao.getName();
    }
}

<?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">
    <!--
        它里面的userDao属性要进行赋值
    -->
    <bean id="userService" class="com.it.service.impl.UserServiceImpl">
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
    </bean>

    <bean id="userDao" class="com.it.dao.impl.UserDaoImpl"></bean>
</beans>

2. set方法方式的注入
   注入对象类型(重点)

public class UserServiceImpl implements UserService{
    private UserDao userDao;
   
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public String getName() {
        return userDao.getName();
    }
}

    <!--
        它里面的userDao属性要进行赋值
    -->
    <bean id="userService" class="com.it.service.impl.UserServiceImpl">
        <!--set方法注入-->
        <property name="userDao" ref="userDao"></property>
    </bean>


    <bean id="userDao" class="com.it.dao.impl.UserDaoImpl"></bean>

注入数组类型(了解一下)

public class UserDaoImpl implements UserDao{
    private String[] stringArray;
    public void setStringArray(String[] stringArray) {
        this.stringArray = stringArray;
    }
    @Override
    public String getName() {
        System.out.println("数组stringArray:" + Arrays.toString(stringArray));
        //模拟调用数据库方法获取name
        return "奥巴马";
    }
}

<bean id="userDao" class="com.it.dao.impl.UserDaoImpl">
    <!--注入数组-->
    <property name="stringArray">
        <array>
            <value>hello1</value>
            <value>hello2</value>
            <value>hello3</value>
            <value>hello4</value>
        </array>
     </property>
        <!--注入map-->
    <property name="map">
        <map>
            <entry key="username" value="aobama"></entry>
            <entry key="pwd" value="123456"></entry>
            <entry key="address" value="召唤师峡谷"></entry>
        </map>
    </property>
    
</bean>

注入简单类型数据：

public class UserDaoImpl implements UserDao{
    private String username;
    private Integer age;

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Override
    public String getName() {
        System.out.println("年龄是:" + age);
        //模拟调用数据库方法获取name
        return username;
    }
}

<bean id="userDao" class="com.it.dao.impl.UserDaoImpl">
    <!--set方法注入-->
    <property name="age" value="28"></property>
    <property name="username" value="奥巴马"></property>
</bean>

3. P名称空间注入
   其实底层也是调用set方法，只是写法有点不同

• 提供属性的set方法
• 在spring.xml引入p命名空间xmlns:p="http://www.springframework.org/schema/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:context="http://www.springframework.org/schema/context" 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 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
</beans>

使用

<!--
        它里面的userDao属性要进行赋值
    -->
<bean id="userService" class="com.it.service.impl.UserServiceImpl" p:userDao-ref="userDao">
    <!--构造函数方式注入-->
    <!--<constructor-arg name="userDao" ref="userDao"></constructor-arg>-->
    <!--set方法注入-->
    <!--<property name="userDao" ref="userDao"></property>-->
</bean>


<bean id="userDao" class="com.it.dao.impl.UserDaoImpl"
      p:age="28"
      p:username="奥巴马">
</bean>