Spring IOC基于配置文件实现

Spring IOC基于配置文件实现

1. spring的优势
   • 方便解耦，简化开发
   • AOP编程的支持
   • 声明式事务的支持
   • 方便程序的测试
   • 方便集成各种优秀框架
   • 降低JavaEE API的使用难度
   • Java源码是经典学习范例

---

1. 程序的耦合
   • 耦合：程序间的依赖关系
     • 包括：
       • 类之间的依赖
       • 方法间的依赖
   • 解耦：降低程序间的依赖关系
   • 实际开发中：
     • 应该做到：编译期不依赖，运行时才依赖
   • 解决的思路：
     • 第一步：使用反射来创建对象，而避免使用new关键字，例如：

     //注册jdbc驱动
     //DriverManager.registerDriver(new com.mysql.jdbc.Driver());
     Class.forName("com.mysql.jdbc.Driver");//写死了
     

     • 第二步：通过读取配置文件来获取要创建的对象的全限定类名

---

1. 一个创建Bean对象的工厂
   • Bean：在计算机英语中，有可重用组件的含义。
   • JavaBean：用java语言编写的可重用组件
   • javabean >> 实体类(远大于)
   • 他就是创建我们的service和dao对象
   • 第一个：需要一个配置文件来配置我们的service和dao
     • 配置的内容：唯一标识 = 全限定类名(key = value)
   • 第二个：通过读取配置文件中配置的内容，反射创建对象
   • 我的配置文件可以是xml也可以时properties

public class BeanFactory {
    //定义一个Properties对象
    private static Properties props;

    //定义一个Map,用于存放我们要创建的对象。我们把它称之为容器
    private static Map<String,Object> beans;

    //使用静态代码块为Properties对象赋值
    static {
        try {
            //实例化对象
            props = new Properties();
            //获取properties文件的流对象
            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(in);
            //实例化容器
            beans = new HashMap<String,Object>();
            //取出配置文件中所有的Key
            Enumeration keys = props.keys();
            //遍历枚举
            while (keys.hasMoreElements()){
                //取出每个Key
                String key = keys.nextElement().toString();
                //根据key获取value
                String beanPath = props.getProperty(key);
                //反射创建对象
                Object value = Class.forName(beanPath).newInstance();//此时类时单例的
                //把key和value存入容器中
                beans.put(key,value);
            }
        }catch(Exception e){
            throw new ExceptionInInitializerError("初始化properties失败！");
        }
    }

    /**
     * 根据bean的名称获取对象
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName){
        return beans.get(beanName);
    }
}

---

控制反转

1. 概念
   • 控制反转(Inversion of Control，英文缩写为IoC)把创建对象的权力交给框架，是框架的重要特征，并非面向对象变成的专用术语，它包括依赖注入(Dependency Injection，简称DI)和依赖查找(Dependency Lookup)
2. 明确IOC作用：
   • 削减计算机程序的耦合(解除我们代码中的依赖关系)，只能降低耦合。

使用spring的IOC解决程序耦合

1. bean.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">

    <!--把对象的创建交给spring来管理-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>

    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"></bean>
</beans>

2. 获取spring的IOC核心容器，并根据id获取对象

//1.获取核心容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//2.根据id获取Bean对象,以下两种方式都可以
IAccountService as  = (IAccountService)ac.getBean("accountService");
IAccountDao adao = ac.getBean("accountDao",IAccountDao.class);

3. ApplicationContext的三个实现类
   • ClassPathXmlApplicationContext：可以加载类路径下的配置文件，要求配置文件必须在类路径下，不在的话，无法加载(更常用)
   • FileSystemXmlApplicationContext：可以加载磁盘任意路径下的配置文件(必须有访问权限)
   • AnnotationConfigApplicationContext：它是用于读取注解创建容器的
4. 核心容器的接口引发出的问题：
   • ApplicationContext：单例对象适用，实际开发中采用此接口
     • 它在构建核心容器时，创建对象采取的策略是采用立即加载的方式，也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象
   • BeanFactory：多例对象适用
     • 它在构建核心容器时，创建对象采取的是策略是采用延迟加载的方式，也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象

spring对bean的管理细节

1. 创建bean的三种方式
   • 第一种：使用默认构造函数创建
     • 在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。
   • 第二种：使用普通工厂中的方法创建对象(使用某个类中的方法创建对象，并存入spring容器)

     <!--创建工厂的bean对象-->
     <bean id="instanceFactory" class="com.itheima.factory.InstanceFactory"></bean>
     <!--根据工厂去生产一个需要的bean对象-->
     <bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>
     

   • 第三种：使用静态工厂中的静态方法创建对象(使用某个类中的静态方法创建对象并存入spring容器)

     <bean id="accountService" class="com.itheima.factory.StaticFactory" factory-method="getAccountService"></bean>
     

   • 第二种和第三种方法主要生成那些jar包中无法修改的方法创建的bean对象
2. bean对象的作用范围
   • bean的作用范围调整
     • bean标签的scope属性：
       • 作用：用于指定bean的作用范围
       • 取值：
         • singleton：单例(默认值)
         • prototype：多例
         • request：作用于web应用的请求范围
         • session：作用于web应用的会话范围
         • global-session：作用于集群环境的会话范围(全局会话范围)，当不是集群环境时，他就是session
3. bean对象的生命周期
   • 单例对象
     • 出生：当容器创建时对象出生
     • 活着：只要容器还在，对象一直活着
     • 死亡：容器销毁，对象消亡
     • 总结：单例对象的生命周期和容器相同

       <!--指定init-method和destory-method的方法-->
       <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"
       scope="prototype" init-method="init" destroy-method="destroy"></bean>
       

   • 多例对象
     • 出生：当使用对象时spring框架为我们创建
     • 活着：对象在使用过程中一直活着。
     • 死亡：当对象长时间不用且没有别的对象引用时，由JVM的GC回收

依赖注入

1. IOC作用：
   • 降低程序间的耦合(依赖关系)
2. 依赖关系的管理：
   • 以后都交给了spring来维护
3. 在当前类中需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件中说明
4. 依赖关系的维护：
   • 称之为依赖注入
5. 依赖注入：
   • 能注入的类型：有三类
     • 基本类型和String
     • 其他的bean类型(在配置文件中或者注解配置过的bean)
     • 复杂类型/集合类型
   • 注入的方式：有三种
     • 第一种：使用构造函数，在类中提供所有属性的构造函数
     • 第二种：使用set方法提供，在类中提供所有属性的set方法
     • 第三种：使用注解提供

   <!--构造函数注入
       使用的标签:constructor-arg
       标签出现的位置：bean标签的内部
       标签中的属性
           tyep:用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或者某些参数的类型
           index:用于只当要注入的数据给构造函数中指定索引位置的参数赋值，索引的位置是从0开始
           name:用于指定给构造函数中指定名称的参数赋值
           value:用于提供基本类型和String类型的数据
           ref:用于指定其他的bean类型数据，它指的就是在spring的IOC核心容器中出现的bean对象
       优势：
           在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功
       弊端：
           改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供
   -->
   <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
       <constructor-arg name="name" value="泰斯特"></constructor-arg>
       <constructor-arg name="age" value="18"></constructor-arg>
       <constructor-arg name="birthday" ref="now"></constructor-arg>
   </bean>
   
   <!-- 配置一个日期对象 -->
   <bean id="now" class="java.util.Date"></bean>
   
   <!-- set方法注入                更常用的方式
       涉及的标签：property
       出现的位置：bean标签的内部
       标签的属性
           name：用于指定注入时所调用的set方法名称
           value：用于提供基本类型和String类型的数据
           ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
       优势：
           创建对象时没有明确的限制，可以直接使用默认构造函数
       弊端：
           如果有某个成员必须有值，则获取对象是有可能set方法没有执行。
   -->
   <bean id="accountService2" class="com.itheima.service.impl.AccountServiceImpl2">
       <property name="name" value="TEST" ></property>
       <property name="age" value="21"></property>
       <property name="birthday" ref="now"></property>
   </bean>
   
   
   <!-- 复杂类型的注入/集合类型的注入
       用于给List结构集合注入的标签：
           list array set
       用于个Map结构集合注入的标签:
           map  props
       结构相同，标签可以互换
   -->
   <bean id="accountService3" class="com.itheima.service.impl.AccountServiceImpl3">
       <property name="myStrs">
           <set>
               <value>AAA</value>
               <value>BBB</value>
               <value>CCC</value>
           </set>
       </property>
   
       <property name="myList">
           <array>
               <value>AAA</value>
               <value>BBB</value>
               <value>CCC</value>
           </array>
       </property>
   
       <property name="mySet">
           <list>
               <value>AAA</value>
               <value>BBB</value>
               <value>CCC</value>
           </list>
       </property>
   
       <property name="myMap">
           <props>
               <prop key="testC">ccc</prop>
               <prop key="testD">ddd</prop>
           </props>
       </property>
   
       <property name="myProps">
           <map>
               <entry key="testA" value="aaa"></entry>
               <entry key="testB">
                   <value>BBB</value>
               </entry>
           </map>
       </property>
   </bean>