Spring框架的概述以及Spring中基于XML的IOC配置

Spring框架的概述以及Spring中基于XML的IOC配置

Spring概述

• Spring：是分层的 Java SE/EE 应用full-stack轻量级开源框架
• spring两大核心：
  • IOC（Inverse Of Control：反转控制）
  • AOP（Aspect Oriented Programming：面向切面编程）
• spring发展历程和优势：Rod Johnson（spring之父）
• spring体系结构

程序的耦合及解耦

• 耦合：程序之间的依赖关系

  • 包括：
    • 类之间的依赖
    • 方法之间的依赖

• 解耦：降低程序之间的依赖关系

  • 实际开发中应该做到编译期不依赖，运行时才依赖。例如对于JDBC连接mysql中的”注册驱动“，假设pom.xml中没有导入mysql的包，则：

  //注册驱动①：如果采用这种方法，编译时此处就会报错，依赖于pom.xml中的配置
  DriverManager.registerDriver(new com.mysql.jdbc.Driver());
  

  //注册驱动②：如果采用这种方法，则编译时不会出错，运行时才会抛出异常
  Class.forName("com.mysql.jdbc.Driver");
  

  • 解耦思路：
    • 使用反射来创建对象，而避免使用new关键字
    • 通过读取配置文件来获取要创建的对象的全限定类名

• 曾经案例中的问题

• 工厂模式解耦（E:\JAVAworkspace\spring_factory）

  • Bean：在计算机应用中，有“可重用组件”的含义

  • JavaBean：用java语言编写的可重用组件

    • Javabean > 实体类
    • 它就是创建我们的service和dao对象的

  • 创建步骤：

    • 第一：需要一个配置文件来配置我们的service和dao

      配置的内容：唯一的标识 = 全限定类名（key=value）

      配置文件可以是xml也可以是properties

    • 第二：通过读取配置文件中配置的内容，反射创建对象

      //定义一个Properties对象
      private static Properties props;
      //使用静态代码块为Properties对象赋值
      static {
          try{
              //实例化对象
              props = new Properties();
              //获取properties文件的对象流
              InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
              props.load(in);
          }catch (Exception e){
              throw new ExceptionInInitializerError("初始化properties失败！");
          }
      }
      
      /**
       * 根据bean的名称获取bean对象（多例的）
       * @param beanName
       * @return
       */
      public static Object getBean(String beanName){
          Object bean = null;
          try{
              //通过反射方式创建对象
              String beanPath = props.getProperty(beanName);
              System.out.println(beanPath);
              bean = Class.forName(beanPath).newInstance();
          }catch (Exception e){
              e.printStackTrace();
          }
          return bean;
      }
      
      

      创建单例对象

      //定义一个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);
      }
      

IOC概念和spring中的IOC

• 控制反转（IOC）：把创建对象的权利交给框架，是spring框架的重要特征，并非面向对象编程的专用术语。它包括依赖注入（DI）和依赖查找（DL）。

  ioc作用：削减计算机程序的耦合（解除代码中的依赖关系）

  

• spring中基于XML的IOC环境搭建

  • 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.ssm.service.impl.AccountServiceImpl"></bean>
      <bean id="accountDao" class="com.ssm.dao.impl.AccountDaoImpl"></bean>
  </beans>
  

  • 获取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);//传入字节码，让方法自己去转为该类对象
  System.out.println(as);
  System.out.println(adao);
  

  • ApplicationContext的三个常用实现类

    • ClassPathXmlApplicationContext：可以加载类路径下的配置文件，要求配置文件必须在类路径下，不在的话，加载不了。（更常用）
    • FileSystemXmlApplicationContext：可以加载磁盘任意路径下的配置文件（必须有访问权限）。

    ApplicationContext ac = new FileSystemXmlApplicationContext("E:\\JAVAworkspace\\spring\\bean.xml");
    

    • AnnotationConfigApplicationContext：是用于读取注解创建容器的

• 核心容器的两个接口引发出的问题：

  • ApplicationContext：他在构建核心容器时，创建对象采取的策略是立即加载的方式，也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象。
    • 单例对象适用
  • BeanFactory：他在构建核心容器时，创建对象采取的策略是延迟加载的方式，也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象。
    • 多例对象适用

• spring对Bean的管理细节

  • 创建Bean的三种方式

    • 第一种：使用默认构造函数创建。

    在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时，采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。

    • 第二种：使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器）

    <bean id="instanceFactory" class="com.ssm.factory.InstanceFactory"></bean>
    

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

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

• bean对象的作用范围

  • bean 标签的 scope 属性：用于指定bean的作用范围，其取值如下：

    • singleton：单例的（默认值）

    • prototype：多例的

    • request：作用于web应用的请求范围

    • session：作用于web应用的会话范围

    • global—session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session

      

  • bean对象的生命周期

    • 单例对象：其生命周期和容器一样

      ​ 出生：当容器创建时出生

      ​ 活着：只要容器存在，对象就一直活着

      ​ 死亡：容器销毁，对象消亡

    • 多例对象：

      ​ 出生：当我们使用对象时spring框架为我们创建

      ​ 活着：对象只要是在使用过程就一直活着

      ​ 死亡：当对象长时间不用且没有别的对象引用时，有java垃圾回收机制销毁

依赖注入（Dependency Injection）

• IOC作用：降低程序间的耦合（依赖关系）

• 依赖关系的管理：以后都交给spring来维护

  • 在当前类需要用到其他类的对象时，由spring为我们提供，我们只需要在配置文件中说明，依赖关系之间的维护就称之为依赖注入。

• 依赖注入：

  如果是经常变化的数据，则不能使用注入

  • 能注入的数据，有三类：

    • 基本类型和String类型

    • 其他bean类型（在配置文件中或者注解配置过的bean）

    • 复杂类型/集合类型

      用于给List结构集合注入的标签：list、array、set

      用于给Map结构集合注入的标签：map、props

      结构相同，标签可以互换

  • 注入的方式，有三种：

    • 第一种：使用构造函数注入

      <bean id="accountService" class="com.ssm.service.impl.AccountServiceImpl">
          <constructor-arg name="name" value="test"></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>
      

      type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型

      index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值，索引位置从0开始

      name：用于指定给构造函数中指定名称的参数赋值

      value：用于提供基本类型和String类型的数据

      ref：用于指定其他bean类型数据，她指的就是在spring的IOC核心容器中出现过的bean对象

      优势：在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功

      弊端：改变了bean对象实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。

    • 第二种：使用set方法注入

      <!--set方法注入-->
      <bean id="accountService2" class="com.ssm.service.impl.AccountServiceImpl2">
          <property name="name" value="jinlu"></property>
          <property name="age" value="23"></property>
          <property name="birthday" ref="now"></property>
      </bean>
      

      name：用于指定注入时所调用的set方法名称

      value：用于提供基本类型和String类型的数据

      ref：用于指定其他bean类型数据，她指的就是在spring的IOC核心容器中出现过的bean对象

      优势：创建对象时没有明确的限制，可以直接使用默认构造函数

      弊端：如果有某个成员必须有值，则获取对象时有可能set方法没有执行

    • 第三种：使用注解提供