Spring基础学习笔记(一)--IOC控制反转

 

1. Spring 概述
   1. Spring 简介
      Spring是一个开源的轻量级应用开发框架，其目的是简化企业级应用程序开发，降低开发者的开发难度
      简化开发：spring对常用的api做了封装比如 jdbc ,使用spring封装的jdbc访问数据库，就不用考虑获取链接，关闭连接等等，极大的简化了代码
      Spring还提供了IOC和AOP应用，可以将组件的耦合度降至最低，便于后期维护
      Spring为系统提供了一个整体的解决方案，开发者可以利用它本身提供的功能外，还可以与第三方框架进行整合
      Spring的本质就是管理系统中的对象，即创建对象和维护对象之间的关系
   2. Spring 架构
      Spring的7个核心模块，组成Spring框架的每个模块都可以单独存在，或者与其他一个或多个模块联合实现，每个模块功能如下:
      1. Spring Core ：主要组件是 BeanFactory ，创建 JavaBean 的工厂，使用控制反转（IOC ） 模式，将应用程序的配置和依赖性规范与实际的应用程序代码分开。
      2. Spring AOP ：集成了面向切面的编程功能（ AOP 把一个业务流程分成几部分，例如权限检查、业务处理、日志记录，每个部分单独处理，然后把它们组装成完整的业务流程。每个部分被称为切面），可以将声明性事物管理集成到应用程序中。
      3. Spring context：一个核心配置文件，为Spring框架提供上下文信息。
      4. Spring dao：Spring操作数据库的模块。
      5. Spring ORM：
         Spring 集成了各种 orm （ object relationship mapping 对象关系映射）框架的模块，集成 mybatis
      6. Spring web：
         集成各种优秀的 web 层框架的模块（ Struts 、Springmvc）
      7. Spring web mvc：Spring web层框架
2. Spring IOC 控制反转
   1. 什么是控制反转

      IOC (Inversion of Control) 控制反转

      所谓的控制反转，就是指将对象的创建，对象的存储(map)，对象的管理(依赖查找，依赖注入)交给了Spring容器管理

      Spring容器就是Spring中的一个核心模块用于管理对象(Spring core)

      之前我们创建对象时，通常是利用 new 关键字创建一个对象

      Hello hello = new Hello () // 创建对象

      hello . sayHi () // 调用对象中的方法

       

      但是由于 new 对象 会提高代码之间的耦合性

      所谓的耦合指的是在软件开发中，在层与层之间产生了某种紧密的关系，这种关系可能会导致，在我们修改或者是替换某一层时会影响其他层，像这种情况我们就称之为层与层之间产生了耦合

      由于耦合可能会导致我们在修改某一层时影响到其他层，而这严重违反了我们对软件进行分层的最初设计-- 软件各层之间应该互相独立，互不干扰，在修改或者是替换某一层时，能做到不影响其他层

      //而使用Spring框架，对象的创建可以交给Spring来做 
      
      Hello hello = (Hello)ac.getBean("Hello"); 
      //从Spring容器 中获取bean对象，而不是自己new 
      hello.sayHi; //调用方法

       

   2. IOC 入门案例
      1. 创建 maven 项目 springframework 创建简单的 maven 项目即可
      2. 在 pom.xml 中 引入 Spring 相关依赖 jar 包，引入 junit.jar

             <dependencies>
                 <!-- spring -->
                 <dependency>
                     <groupId>org.springframework</groupId>
                     <artifactId>spring-webmvc</artifactId>
                     <version>5.2.7.RELEASE</version>
                 </dependency>
                 <!-- junit -->
                 <dependency>
                     <groupId>junit</groupId>
                     <artifactId>junit</artifactId>
                     <version>4.12</version>
                     <scope>test</scope>
                 </dependency>
             </dependencies>

      3. 创建 Spring 核心配置文件 -applicationContext.xml 配置文件中beans 里面指定，当前文件可以写哪些指令

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

      4. 创建实体类 - Hello ，将 Hello 对象的创建交给 Spring 管理

         package com.zb.pojo;
         
         public class Hello {
             public void sayHello(){
                 System.out.println("今天是7.27号");
             }
         }
         
         
         <?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是唯一标识可以起任意名字 一般为类名首字母小写 class：对象的全路径-->
             <bean id="hello" class="com.zb.pojo.Hello"></bean>
         </beans>

      5. 创建测试类 获取对象

         public class TestIOC {
             @Test
             public void getHello(){
                 //1.加载spring的配置文件(启动spring框架)
                 ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
                 //2.从spring容器中获取bean对象 通过id
                 Hello hello=(Hello) context.getBean("hello");
                 hello.sayHello();
             }
         }

   3. IOC小结

      这就是springIOC -- 控制反转，之前我们自己new对象 User u =new User()

      而现在，编程由一个初始化的xml配置文件来创建，也就是由spring容器来创建

      Hello hello = (Hello) ac.getBean("hello");

      当程序运行后，spring开始工作，会加载整个xml核心配置文件，读取到<bean>获取到class属性，取class属性中的值，利用反射创建对象，一个bean就是一个对象,对象可以有多个，多个对象存放到map中，id相当于map中的key值，因此id能重复
3. Bean 对象的单例多例

   1. 对象的单例和多例概述:
      在Spring容器中管理的Bean对象的作用域，可以通过scope属性或用相关注解指定其作用域
      Spring作用域有5种，singleton，prototype，request，session， global-session
      最常用的是 singleton（单例）或 prototype（多例）
      singleton：单实例， 是默认值，这个作用域标识的对象具备全局唯一性，当把一个bean定义设置scope为singleton时，那么SpringIOC容器只会创建该bean定义的唯一实例，也就是说，整个SpringIOC容器种只会创建当前类的唯一 一个对象，singleton负责对象的创建，初始化，销毁。
      prototype：多实例，这个作用域标识的对象每次获取都会创建新的对象。当把一个bean定义设置scope为prototype作用域时，SpringIOC容器会在每一次获取当前bean时，都会产生一个新的bean实例，相当于new操作， prototype只负责对象的创建和初始化，不负责销毁。
   2. 为什么用单实例或多实例？
      之所以用单实例，在没有线程安全问题的前提下，没有必要为每个请求都创建一个对象，这样即浪费CPU又浪费内存  
      之所以用多实例，是为了防止并发问题，即一个请求改变了对象的 状态(例如改变了成员变量)，此时对象又处理另一个请求，而之前请求对象状态的改变导致了对象对另一个请求做了错误的处理   
      用单例和多例的标准只有一个：当对象含有可改变状态(在实际应用种状态会改变)时使用多实例，否则单实例
   3. 在spring种配置单例或多例的方法

      指定scope属性 
      <bean id="hello" scope="prototype" class="com.zb.pojo.Hello"></bean> 
      <bean id="hello" scope="singleton" class="com.zb.pojo.Hello"></bean>

   4. 单例设计模式补充
      单例：单一实例，在某个时刻， 可以获取到的同一个类的对象有且仅有一个
      单例设计模式，有懒汉式和饿汉式两种实现模式

      饿汉式单例模式：其工作特性为“程序运行初期就已经创建了该类的实例，随时都可以获取实例”

      public class King { 
          private static King king = new King(); 
          private King(){ 
          }
          public static King getInstance(){ 
              return king; 
          } 
      }

      懒汉式单例模式：其工作特性为“程序调用时才会创建对象，不到逼不得已不会创建对象”

      public class King { 
          private static King king; 
          private King(){ 
      
          }
          public static King getInstance(){ 
              if (king == null){ 
                  king = new King(); 
              }
              return king; 
          } 
      }

   理论上来讲，懒汉式的单例模式可以省一部分资源消耗，例如程序运行了30分钟后才获取对象，则30分钟之前是不需要创建对象的，但是这种优势也是理论上的优势，在实际应用中，差异表现不明显

   在Spring管理对象时，我们可以配置lazy-init属性，设置是否为懒汉式的单例 true为懒汉 false为饿汉

    

   <bean id="hello" scope="singleton" lazy-init="true" class="com.zb.pojo.Hello"></bean>