01 Spring简介与IOC推导

学自B站，遇见狂神

1、Spring

1.1、简介

• Spring：春天----->给软件行业带来了春天！
• Rod Johnson，Spring Framework创始人，著名作者。很难想象Rod Johnson的学历，真的让好多人大吃一惊，他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。
• Spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架
• Spring是一个轻量级的IoC和AOP容器框架。是为Java应用程序提供基础性服务的一套框架，目的是用于简化企业应用程序的开发，它使得开发者只需要关心业务需求。常见的配置方式有三种：基于XML的配置、基于注解的配置、基于Java的配置。

官网：https://spring.io/projects/spring-framework

官方下载地址：https://repo.spring.io/release/org/springframringework/spring/

GitHub：https://github.com/spring-projects/spring-framework/releases

sping说明书：4.3.9

Maven：

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>

1.2、优点

• Spring是一个开源的免费的框架（容器）
• Spring是一个轻量级的、非入侵式的框架
• 控制反转（IOC），面向切面编程（AOP）
• 支持事务的处理，对框架整合的支持！

总结一句话：Spring就是一个轻量级的控制反转（IOC）和面向切面编程

1.3、组成

主要由以下几个模块组成：

• Spring Core：核心类库，提供IOC服务；

• Spring Context：提供框架式的Bean访问方式，以及企业级功能（JNDI、定时任务等）；

• Spring AOP：AOP服务；

• Spring DAO：对JDBC的抽象，简化了数据访问异常的处理； Spring ORM：对现有的ORM框架的支持；

• Spring Web：提供了基本的面向Web的综合特性，例如多方文件上传；

• Spring MVC：提供面向Web应用的Model-View-Controller实现

1.4、拓展

在Spring的官网有这个介绍：现代化的Java开发！说白了就是基于Spring开发

• SpringBoot
  • 一个快速开发的脚手架。
  • 基于SpringBoot可以快速的开发单个微服务。
  • 约定大于配置！
• SpringCloud
  • SpringCloud是基于SpringBoot实现的。

现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring及SpringMVC！承上启下的作用！

2、IOC理论推导

2.1、程序

• maven新建一个项目：spring-study

• 删除src目录作为总项目

• 配置项目依赖，pom.xml

• 新建一个子模块spring-01-Ioc

<!--总项目的pom.xml-->
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!--父工程-->
    <groupId>com.wu</groupId>
    <artifactId>spring-study</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>spring-01-Ioc1</module>
        <module>spring-02-hellospring</module>
        <module>spring-03-Ioc2</module>
        <module>spring-04-di</module>
        <module>spring-05-Autowired</module>
        <module>spring-06-anno</module>
        <module>spring-08-proxy</module>
        <module>spring-07-appconfig</module>
        <module>spring-09-aop</module>
        <module>spring-10-mybatis</module>
        <module>spring-11-transaction</module>
    </modules>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.2</version>
            <scope>compile</scope>
        </dependency>

    </dependencies>

</project>

• spring的配置文件：beans.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--使用Spring来创建对象，在Spring中这些都成为bean
       类型 变量名 = new 类型();
       Hello hello = new Hello();

       id = 变量名
       class = new 的对象
       property 相当于给对象中的属性赋值
       -->
    <bean id="userDao" class="com.wu.dao.UserDaoImpl"/>
    <bean id="mysqlImpl" class="com.wu.dao.UserDaoMysqlImpl"/>
    <bean id="userSrviceImpl" class="com.wu.service.UserServiceImpl">
        <!--property name="userDao" ref="mysqlImpl"-->
        <property name="userDao" ref="userDao"/>
    </bean>

</beans>

• dao层

  //UserDao接口
  package com.wu.dao;
  
  public interface UserDao {
      void getUser();
  }
  

  //UserDao接口的实现类：UserDaoImpl.class
  package com.wu.dao;
  public class UserDaoImpl implements UserDao {
  
      public void getUser() {
          System.out.println("获取用户的数据");
      }
  }
  

  //UserDao接口的实现类：UserDaoMysqlImpl.class
  package com.wu.dao;
  
  public class UserDaoMysqlImpl  implements UserDao{
  
      public void getUser() {
          System.out.println("获取mysql的数据");
      }
  }
  

• service层

//service层的接口，用户不需要关心dao层，只关心service，通过service层管理底层的业务逻辑
package com.wu.service;

import com.wu.dao.UserDaoMysqlImpl;

public interface UserService {
    void getUser();
}

//service层的接口实现类：UserDaoMysqlImpl.class
package com.wu.service;
import com.wu.dao.UserDao;
import com.wu.dao.UserDaoImpl;
import com.wu.dao.UserDaoMysqlImpl;

public class UserServiceImpl implements UserService {
	//没用set实现控制反转之前
    //private UserDao userDao = new UserDaoImpl();
    //private UserDao userDao = new UserDaoMysqlImpl();
    
    //setUserDao方法实现控制反转
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void getUser() {
        userDao.getUser();
    }
}

• 测试类：Mytest.class

  import com.wu.dao.UserDaoMysqlImpl;
  import com.wu.service.UserService;
  import com.wu.service.UserServiceImpl;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  
  public class Mytest {
      
      //推导IOC理论
      public static void main(String[] args) {
          UserService userService = new UserServiceImpl();
          ((UserServiceImpl) userService).setUserDao(new UserDaoMysqlImpl());
         userService.getUser();
      }
     //下面是Spring的IOC容器管理实例和配置实例实现的
  	/*
  	 public static void main(String[] args) {
          ApplicationContext context =  new ClassPathXmlApplicationContext("beans.xml");
          UserServiceImpl userService =(UserServiceImpl)context.getBean("userSrviceImpl");
          //getBean();方法中的参数是beans.xml对应的id属性的值，即变量名
          userService.getUser();
      }
  	*/
  
  

2.2、IOC推导

• 我们不用set方式实现控制反转，那么用户在调service层时，我们需要在service层new不同的dao层对象实现确定实现哪一个功能。

• 使用setUserDao方法实现控制反转后service层只需要被动接受dao层的对象即可，管理dao层的对象掌握在了用户手里，service层不用管dao层具体实例的创建。
  
  

1. UserDao接口
2. UserDaoImpl实现类
3. UserService业务接口
4. UserServiceImpl业务实现类

在我们之间的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改原来的代码！如果程序代码量十分大，修改一次的成本十分昂贵！

我们使用一个Set接口实现，已经发生了革命性的变化！

private UserDao userDao;

//利用set进行动态实现值的注入
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}

• 之前，程序是主动创建对象！控制权在程序员手上！
• 使用了set注入后，程序不在具有主动性，而是变成了被动的接收对象!

这种思想，从本质上解决了问题，我们程序员不用再去管理对象的创建了。系统的耦合性大大降低，可以更加专注的在业务的实现上！这是IOC的原型！

2.3、IOC本质

• 控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

  采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合 为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

  总之，控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

• IOC的实现------工厂模式

  将对象交给容器管理，需要在spring配置文件配置相应的bean，以及设置相关的属性，让spring容器来生成类的实例对象以及管理对象。在spring容器启动的时候，pring会把你在配置文件中配置的bean都初始化好，然后在调用的时候，把它已经初始化好的那些bean分配给你需要调用这些bean的类（假设这个类是class A），分配的方法就是调用A的setter方法来注入，而不需要你在A里面new这些bean了。