Spring框架（一）————IOC（控制反转）

Spring框架

1. Spring框架的概述

• Spring是一个开放源代码的设计层面框架，它解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。
• 它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 JavaEE 应用程序开发提供集成的框架。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。
• Spring的核心是控制反转（IOC）和面向切面（AOP）。

IOC：控制反转，将创建对象的过程交给spring进行管理

AOP：面向切面编程，在不修改源代码的情况之下进行代码功能的增强

2. Spring框架的优点

• 方便解耦，简化开发，Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给Spring管理，这也是IOC的作用。
• AOP编程的支持，Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能。
• 声明式事务的支持，只需要通过配置就可以完成对事务的管理，而无需手动编程。
• 方便程序的测试，Spring对Junit4支持，可以通过注解方便的测试Spring程序。
• 方便集成各种优秀框架，Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts2、Hibernate、MyBatis等）的直接支持。
• 降低JavaEE API的使用难度，Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail等），都提供了封装，使这些API应用难度大大降低。

3.Spring中的Hello World

• 创建maven工程，导入坐标依赖

• <dependencies>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>5.0.2.RELEASE</version>
      </dependency>
      <dependency>
          <groupId>commons-logging</groupId>
          <artifactId>commons-logging</artifactId>
          <version>1.2</version>
      </dependency>
      <dependency>
          <groupId>log4j</groupId>
          <artifactId>log4j</artifactId>
          <version>1.2.12</version>
      </dependency>
      <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.12</version>
          <scope>test</scope>
      </dependency>
  </dependencies>
  

• 编写demo，编写具体的实现方法

• package com.qcby;
  public class Demo {
       
      public void hello() {
       
          System.out.println("hello world");
      }
  }
  

• 编写Spring核心的配置文件，在resources目录下创建applicationContext.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">
    	 <!--IOC管理bean-->
      <!--id:类的唯一标识符 class:类的全路径名-->
      <bean id="demo" class="com.qcby.Demo"/>
  </beans>    
  

• 编写测试方法。

• package com.qcby;
  
  import com.config.SpringConfig;
  import org.junit.Test;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  
  public class DemoTest {
       
      //传统写法
      @Test
      public void run(){
       
          Demo userService = new Demo();
          userService.hello();
      }
      //spring写法
      @Test
      public void run_spring(){
       
          //创建spring工厂,加载配置文件
          ApplicationContext ac = new ClassPathXmlApplicationContext("application.xml");
          //获取bean对象
          //这里的getBean后的demo是配置文件中bean的Id,getBean是通过反射来创建对象的
          Demo demo = (Demo) ac.getBean("demo");
          //调用方法
          demo.hello();
      }
  }
  
  

  注意：

  传统方法和Spring创建对象的结果一致

  getBean()是通过反射来创建对象

  

4.Spring IOC容器

我们从上面的Hello World中可以发现，我们把创建对象的权利交给了Spring来完成，这就是IOC

1. 什么是IOC

• IOC – Inverse of Control，控制反转，将对象的创建权力反转给Spring框架！

• 在java当中一个类想要使用另一个类的方法，就必须在这个类当中创建这个类的对象。

  试想：如果有A，B，C三个类，在A类中创建B类对象，B类中创建了C类的对象，如果其中B类出现问题，那么会导致其他类出现问题，这就是耦合度高带来的问题

  控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。

  Spring 将创建对象的权利给了IOC，在IOC当中创建了ABC三个对象，那么我们我们其他的类只需要调用集合， 大大的解决了程序耦合性的问题。

2. IOC容器的底层原理

• IOC的实现，依赖于以下3门技术

① dom4j解析xml文档；

② 工厂模式；

③ 采用反射设计模式创建对象

首先我们需要了解什么是工厂模式？

在当前情况之下A类想要调用B类就必须自己在自己的内部新建B类的对象，这样的耦合度太高，那我们如何降低耦合度的呢？

通过一个工厂类，工厂类中通过方法来返回不同类的对象，A类调用工厂类生成B的对象，来实现A类中调用B类的方法

那么上边提到的三种技术如何实现IOC的呢？

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

<!--class后面跟类的全限定名-->
<bean id="demo" class="com.qcby.Demo" />              

第二步：创建工厂类

public class DemoFactory {
   
    //利用dom4j得到name所对应的value值
   public static Dem