Spring

1、简介

spring理念：是现有的技术更加容易使用，本身是一个大杂烩。

• SSH：Struct2 + Spring + Hibernate
• SSM: SpringMVC + Spring + Mybatis

1.1、导入包

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

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

1.2、优点

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

总结：spring是一个轻量级的控制反转(IOC)和面向切面编程(AOP)的框架。

1.3、Spring组成

1.4、拓展

1.Spring Boot 构建一切

1.一个快速开发的脚手架

2.基于SpringBoot可以快速地开发单个微服务

3.约束大于配置！

2.Spring Cloud 协调一切

1.SpringCloud是基于SpringBoot实现的

3.Spring Cloud Data Flow 连接一切

学习SpringBoot的前提，需要完全掌握Spring以及SpringMVC！

2、IOC理论推导

1. UserDao
2. UserDaoImp
3. UserSevice
4. UserServiceImp

在之前，用户的需求可能会影响原来的代码。

2.1、分析实现

新建一个空白的maven项目

分析实现

我们先用我们原来的方式写一段代码 .

1、先写一个UserDao接口

public interface UserDao {
  public   void getUser();
}

2、再去写Dao的实现类

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

3、然后去写UserService的接口

public interface UserService {
    public void getUser();
}

4、最后写Service的实现类

public class UserServiceImp implements UserService{

    private UserDao userDao = new UserDaoImp();

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

5、测试一下

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

这是我们原来的方式 , 一开始大家也都是这么去写的对吧 . 那我们现在修改一下 .

把Userdao的实现类增加一个 .

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

紧接着我们要去使用MySql的话 , 我们就需要去service实现类里面修改对应的实现

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

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

在假设, 我们再增加一个Userdao的实现类 .

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

那么我们要使用Oracle , 需要去service实现类里面修改对应的实现 . 假设我们的这种需求非常大 , 这种方式就根本就不适用了, 甚至反人类对吧 , 每次变动 , 需要修改大量代码 . 这种设计的耦合性太高了, 牵一发而动全身 .

那我们如何去解决呢 ?

我们可以在需要用到他的地方 , 不去实现它 , 而是留出一个接口 , 利用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 class MyTest {
    public static void main(String[] args) {
        //用户实际调用的是业务层，dao层他们不需要接触！
        UserServiceImp userService = new UserServiceImp();
        ((UserServiceImp) userService).setUserDao(new UserDaoSqlserviceImp());
        userService.getUser();
    }
}

使用一个set。

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

• 之前是主动创建对象，控制权在程序猿手上！
• 使用set之后，程序不再具有主动性，而是变成了被动接受对象。

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