Spring

一、：Spring （Spring框架是由于软件开发的复杂性而创建的）

1.1、简介

Spring:春天—–>给软件行业带来了春天!
2002，首次推出了Spring框架的雏形:interface21框架!
Spring框架即以interface21框架为基础,经过重新设计,并不断丰富其内涵,于2004年3 月24日发布了1.0正式版。
Rod Johnson ,Spring Framework创始人，著名作者。很难想象Rod Johnson的学历，真的让好多人大吃一惊，他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。

spring理念: 使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的框架

SSH: Struct2+ Spring +Hibernate
SSM: SpringMVC + Spring + MyBatis

1.2：优点

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

总结：Spring就是一个轻量级的分入侵的控制反转（IOC）,面向切面编程（AOP）的框架，同时支持事务的处理。

1.3: 组成

Spring7大模块
https://www.cnblogs.com/jing99/p/11484197.html

二、IOC理论推导

先用原来的方式，写一下代码

1：UserDao接口

public interface UserDao {

    void getUser();
}

2：UserDaoImpl实现类

public class UserDaoImpl implements UserDao {

    @Override
    public void getUser() {
        System.out.println("默认获取用户的数据！");
    }
}

3：UserService业务接口

public interface UserService {

    void getUser();
}

4：UserService业务实现类

 public class UserServiceImpl implements UserService {
        private UserDao userDao = new UserDaoImpl();

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

5：测试一下；

@Test
public void test(){
   UserService service = new UserServiceImpl();
   service.getUser();
}

这里是我们原来实现代码的方式；如果我们实现多个UseDao的实现类那？？？
都去继承UserDao ,代码如下

//
public class UserDaoMysqlImpl implements UserDao {

    @Override
    public void getUser() {
        System.out.println("Mysql获取用户的数据！");
    }
}


public class UserDaoOracleImpl implements UserDao{
    @Override
    public void getUser() {
        System.out.println("Oracle获取用户的数据");
    }
}

测试：

    public static void main(String[] args) {


        UserServiceImpl userService = new UserServiceImpl();
        UserDaoMysqlImpl userDaoMysql = new UserDaoMysqlImpl();
        UserDaoOracleImpl userDaoOracle = new UserDaoOracleImpl();

        userService.getUser();
        userDaoMysql.getUser();
        userDaoOracle.getUser();
}

都去继承UserDao,那么我们对象都要去逐一的去实现，每次都要去修改这样的代码，这不是一个程序员要做的程序。
耦合性太高，不利于维护，牵一动全身。

那我们如何去解决呢 ?
我们可以在需要用到他的地方 , 不去实现它 , 而是留出一个接口 , 利用set , 我们去代码里修改下 .

  public class UserServiceImpl implements UserService {
  
    private UserDao userDao;

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

}

测试：

   public static void main(String[] args) {

        UserServiceImpl userService = new UserServiceImpl();

        userService.setUserDao(new UserDaoImpl());
        userService.getUser();

        //要想实现谁，就去调用谁。
        userService.setUserDao(new UserDaoMysqlImpl());
        userService.getUser();
		
		//要想实现谁，就去调用谁。
        userService.setUserDao(new UserDaoOracleImpl());
        userService.getUser();
}

以前所有东西都是由程序去进行控制创建 , 而现在是由我们自行控制创建对象 , 把主动权交给了调用者 . 程序不用去管怎么创建,怎么实现了 . 它只负责提供一个接口。

把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。

其实IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。

这种思想 , 从本质上解决了问题 , 我们程序员不再去管理对象的创建了 , 更多的去关注业务的实现 . 耦合性大大降低 . 这也就是IOC的原型 !

2.1、IOC本质

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

Spring容器在初始化时先读取配置文件，根据配置文件或元数据。创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

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

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

2.2、IOC是什么

什么是IOC：参考博客
https://blog.csdn.net/qq_42709262/article/details/81951402

Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。

谁控制谁，控制什么？

传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对象的创建；谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。

为何是反转，哪些方面反转了?

有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

传统程序设计下，都是主动去创建相关对象然后再组合起来：

当有了IoC/DI的容器后，在客户端类中不再主动去创建这些对象了，如图

2.3、IoC和DI是什么关系

控制反转是通过依赖注入实现的，其实它们是同一个概念的不同角度描述。通俗来说就是IoC是设计思想，DI是实现方式。

DI—Dependency Injection，即依赖注入：组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。

我们来深入分析一下：

谁依赖于谁？
当然是应用程序依赖于IoC容器；
为什么需要依赖？
应用程序需要IoC容器来提供对象需要的外部资源；
谁注入谁？
很明显是IoC容器注入应用程序某个对象，应用程序依赖的对象；
注入了什么？
就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。
IoC和DI由什么关系呢？
其实它们是同一个概念的不同角度描述，由于控制反转概念比较含糊（可能只是理解为容器控制对象这一个层面，很难让人想到谁来维护对象关系），所以2004年大师级人物Martin Fowler又给出了一个新的名字：“依赖注入”，相对IoC 而言，“依赖注入”明确描述了“被注入对象依赖IoC容器配置依赖对象”。通俗来说就是IoC是设计思想，DI是实现方式。