初始Spring与SpringIOC容器

一、 Spring框架的基本理解

Spring框架是一款轻量级的开发框架，核心思想是IOC (控制反转) 和AOP (面向切面编程)，
为Java 应用程序开发提供组件管理服务，用于组件之间的解耦，以及简化第三方JavaEE中间件技术的使用( JMS、任务调度、缓存、ORM 框架)，是一个基础架构型的开发框架;

Spring框架包括: IOC 容器、Validation 数据校验、AOP 面向切面编程、Transaction
s事务管理、Spring JDBC、 Spring MVC框架、以及各类第三方JavaEE 中间件技术集成;

二、什么是SpringIOC?

IOC的作用是解耦，使用IOC容器管理项目组件之间的耦合关系
IOC:是Spring框架的核心思想之一，主要用于解耦。IOC是指将创建对象的控制权转移给Spring框架 根据配置文件或注解等方式，创建bean对象并管理各个bean对象之间的依赖关系。使对象之间形成松散耦合的关系，实现解耦；
控制:指的是对象创建(实例化、管理)的权力
反转:控制权交给外部环境(| Spring 框架、IoC容器)

三、Spring lOC容器的理解

（IOC容器的作用、存储形式、初始化过程）

IOC通常被理解为IOC Container容器，IOC容器其实就是一个Map,key是每个bean对象的ID,value是bean对象本身。IOC容器负责创建bean对象并管理bean的生命周期。并且根据配置好的配置文件或注解，管理IOC容器的每个bean,以及根据bean之间的依赖关系，完成bean之间的注入。

IOC容器属于Spring Core模块，用来创建和管理Bean，默认使用单例的方式将bean存储
在DefaultListableBeanFactory 类的beanDefinitionMap 中(一个ConcurrentHashMap 类
型的Map集合);

IOC容器使用ConcurrentHashMap 集合存储了BeanDefinition 对象，该对象封装了Sprin
g对一个Bean 所有配置信息,包括:类名，属性,构造方法参数，依赖，是否延迟加载，是否是
单例等配置信息;

四、Spring框架由哪些模块组成?

官方文档描述，由7个模块组成

Spring Framework 根据官方文档的描述，主要包括以下常用5个模块：

1.Core:核心模块

包括:IOC Container(loc容器)，Events(事件通知机制)、Resources(资源加载机制)、i18n(国际化)、Validation(数据校验)、Data Binding(数据绑定)、Type Conversion(类型转换)，SpEL(Spring表达式)、AOP(面向切面编程)

2.Testing:测试模块
包括:Mock 0biects(测试模拟对象)，TestContext Framework(测试框架)，Spring MVCTest(用于测试Spring Mvc)，webTestclient(用于测试 Webclient、Restful、 webflux 等);

3.Data Access:数据访问模块

包括:Transactions(事务管理)，DA0support(统一的 Data Access 0bject DA0 模式封装)，JDBc(Spring对于DC的操作封装)，0/RMapping(Spring 对于对象关系映射框架的封装，例如 Hibernate等框架)等;
4.Web Servlet:基于Servlet的Web应用开发
包括:Spring MVc( Spring 基于 MVC 模式设计封装的 Web框架)，Websocket(Spring集成 Websocket，websocket 是一个服务器与客户端双向通信的技术)等;
5.Integration:企业级系统集成模块(不同系统之间的交互集成)
包括:Remoting(spring 用于在分布式系统中进行远程服务调用的通讯框架)，IMS(Spring集成各类Java消息中间件、Java消息服务[JavaMessage Service]、例如ActiveMQ等)，Java Emai1(邮件发送)，Tasks Scheduling(任务调度);

五、Spring项目——硬编码实现解耦

SpringIOC(控制反转)：解耦

思想：高内聚，低耦合编程思想

硬编码实现解耦：

1.不要直接new对象，通过反射创建

2.将需要创建的对象独立报讯在资源文件中，动态加载

jdbc.properties配置文件:

msg1 = com.mysql.cj.jdbc.Driver
msg2 = jdbc:mysql://localhost:3306/schoolp?serverTimezone=GMT
msg3 = root
msg4 = password

1.高耦合（直接new对象）

        /** 高耦合*/
        DriverManager.registerDriver(new com.mysql.cj.jdbc.Driver());
        Connection root = DriverManager.getConnection("jdbc:mysql://localhost:3306/schoolp?serverTimezone=GMT","root","password");
        System.out.println(root);

2.中耦合（反射）

//1.加载驱动（反射）       
 Class.forName("com.mysql.cj.jdbc.Driver()");
        
//2.获取连接对象
Connection root = DriverManager.getConnection("jdbc:mysql://localhost:3306/schoolp?serverTimezone=GMT","root","password");

//3.测试
System.out.println(root);

3.低耦合

步骤：

        1.创建工具类

        2.加载文件

        3.通过key获取value

        4.获取连接

具体实现：

        //1.创建工具类
        Properties properties = new Properties();

        //2.加载文件
        InputStream inputStream = Test01.class.getClassLoader().getResourceAsStream("jdbc.properties");
        properties.load(inputStream);

        //3.通过key获取value
        String driver = properties.getProperty("msg1");
        String url = properties.getProperty("msg2");
        String name = properties.getProperty("msg3");
        String pwd = properties.getProperty("msg4");

        //4.获取连接
        Class.forName(driver);
        Connection root = DriverManager.getConnection(url, name, pwd);
        System.out.println(root);

六、创建SpringIOC容器

(1)坐标

(2)配置文件

用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 http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 注入类-->
    <bean id="student" class="com.zad.pojo.Student"/>
    <!-- 注入类 -->
    <bean id="dao" class="com.zad.dao.UserDaoImpl"/>
    <!-- 注入日期类 -->
    <bean id="date" class="java.util.Date"/>
</beans>

pom.xml：

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.27</version>
        </dependency>

    </dependencies>

dao层：

IUserDao:

public interface IUserDao {
    public void save();
}

UserDaoImpl:

public class UserDaoImpl implements IUserDao{

    @Override
    public void save() {
        System.out.println("===dao的新增方法===");
    }
}

pojo层：Student类

public class Student {
    
}

测试类：

public class Test1 {
    public static void main(String[] args) {
        //1.加载spring核心配置文件，获取spring容器对象
        BeanFactory applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        //2.获取对象
        Student student = (Student) applicationContext.getBean("student");
        System.out.println(student);

        IUserDao dao = (IUserDao) applicationContext.getBean("dao");
        dao.save();

        Date date = (Date) applicationContext.getBean("date");
        System.out.println(date);
    }
}

用 BeanFactory:

beans.properties:

dao=com.zad.dao.UserDaoImpl
service=com.zad.service.UserServiceImp

util包：BeansFactory

public class BeansFactory {

    //按照用户需求以解耦的方式创建对象
    public static Object getBean(String key)  {
        try {
            //1.创建工具类:用来读取配置文件中的键值对数据
            Properties properties = new Properties();
            //2.加载文件
            InputStream inputStream = Text01.class.getClassLoader().getResourceAsStream("beans.properties");
            properties.load(inputStream);
            //3.通过key获取value
            String classPath = properties.getProperty(key);
            return
                    Class.forName(classPath).newInstance();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return  null;


    }
}

controller层：

IUserController：

public interface IUserController {
    public void save();
}

UserControllerImpl：

public class UserControllerImpl implements IUserService {

    //高耦合
//    IUserService service = new UserServiceImp();
    //低耦合
    IUserService service = (IUserService) BeansFactory.getBean("service");

    @Override
    public void save() {
        System.out.println("===controller的新增方法===");
        service.save();

    }
}

dao:

IUserDao:

public interface IUserDao {
    public void save();
}

UserDaoImpl:

public class UserDaoImpl implements IUserDao{

    @Override
    public void save() {
        System.out.println("===dao的新增方法===");
    }
}

service:

public interface IUserService {
    public void save();
}

UserServiceImp:

public class UserServiceImp implements IUserService{
    //低耦合
    IUserDao dao = (IUserDao) BeansFactory.getBean("dao");

    @Override
    public void save() {
        System.out.println("===service的新增方法===");
        dao.save();
    }
}

测试类：

public class Text01 {
    public static void main(String[] args) {
        UserControllerImpl controller = new UserControllerImpl();
        controller.save();
    }
}

spring两大思想：

一.IOC控制反转 DI依赖注入
    IOC容器：springIOC搭建spring容器管理程序中的各个组件（class）让程序可以实现高内聚，低耦合的编程

二.AOP面向切面编程


spring环境搭建：
    1.坐标
    2.配置文件

springIOC：
    1.找到需要以解耦方式获取实例对象的类
    2.将需要spring管理的类注入spring容器
        <bean id="唯一标识" class="类"></bean>
    3.向spring容器中索取java实例（解耦）
            3.1.加载spring核心配置文件，获取spring容器对象
                ApplicationContext applicationContext =  new ClassPathXmlApplicationContext("beans.xml");
            3.2.获取对象
                Student student = (Student) applicationContext.getBean("student");

Demo02                  Demo3
beans.properties        beans.xml
key=value               id=class
BeansFactory            ApplicationContext
getBean(key)            getBean(id)

SpringIOC:
    ● IOC名词解释，作用是解耦，使用IOC容器管理项目组件之间的耦合关系
    ● IOC( Inversion of Control，中文释义：控制反转  ) 是Spring框架的核心思想之一，
        主要用于解耦。IOC是指将创建对象的控制权转移给Spring框架进行管理。由Spring框架根
        据配置文件或注解等方式，创建bean对象并管理各个bean对象之间的依赖关系。使对象之间
        形成松散耦合的关系，实现解耦；
      ○ 控制 ：指的是对象创建（实例化、管理）的权力
      ○ 反转 ：控制权交给外部环境（Spring框架、IoC容器）

关键字：
    BeanFactory（父）
    ApplicationContext（子）

        ClassPathXmlApplicationContext============>通过加载主配置文件的相对路径，获取spring容器
        FileSystemXmlApplicationContext===========>通过加载主配置文件的绝对路径，获取spring容器
        AnnotationConfigApplicationContext========>加载配置类，获取spring容器