一、Spring介绍

1.1 Spring简介

Spring是一个开源框架，为简化企业级开发而生。它以IOC（控制反转）和AOP（面向切面）为思想内核，提供了控制层SpringMVC、数据层SpringData、服务层事务管理等众多技术，并可以整合众多第三方框架。

Spring将很多复杂的代码变得优雅简洁，有效的降低代码的耦合度，极大的方便项目的后期维护、升级和扩展。

Spring官网地址：Spring | Home

1.2 Spring体系结构

Spring框架根据不同的功能被划分成了多个模块，这些模块可以满足一切企业级应用开发的需求，在开发过程中可以根据需求有选择性地使用所需要的模块。

Core Container：Spring核心模块，任何功能的使用都离不开该模块，是其他模块建立的基础。

Data Access/Integration：该模块提供了数据持久化的相应功能。

Web：该模块提供了web开发的相应功能。

AOP：提供了面向切面编程实现

Aspects：提供与AspectJ框架的集成，该框架是一个面向切面编程框架。

Instrumentation：提供了类工具的支持和类加载器的实现，可以在特定的应用服务器中使用。

Messaging：为Spring框架集成一些基础的报文传送应用

Test：提供与测试框架的集成

二、Spring IOC

2.1 控制反转思想

IOC(Inversion of Control) ：程序将创建对象的权利交给框架。

之前在开发过程中，对象实例的创建是由调用者管理的，代码如下：

public interface StudentDao {
  // 根据id查询学生
  Student findById(int id);
}
public class StudentDaoImpl implements StudentDao{
  @Override
  public Student findById(int id) {
    // 模拟从数据库查找出学生
    return new Student(1,"张三","北京");
   }
}
public class StudentService {
  public Student findStudentById(int id){
    // 此处就是调用者在创建对象
    StudentDao studentDao = new StudentDaoImpl();
    return studentDao.findById(1);
   }
}

这种写法有两个缺点：

浪费资源：StudentService调用方法时即会创建一个对象，如果不断调用方法则会创建大量StudentDao对象。
代码耦合度高：假设随着开发，我们创建了StudentDao另一个更加完善的实现类StudentDaoImpl2，如果在StudentService中想使用StudentDaoImpl2，则必须修改源码。

而IOC思想是将创建对象的权利交给框架，框架会帮助我们创建对象，分配对象的使用，控制权由程序代码转移到了框架中，控制权发生了反转，这就是Spring的IOC思想。而IOC思想可以完美的解决以上两个问题。

2.2 Spring实现IOC

接下来我们使用Spring实现IOC，Spring内部也有一个容器用来管理对象。

1、创建Maven工程，引入依赖

<dependencies>
        <!--spring核心依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.13</version>
        </dependency>
        <!--单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

2、创建POJO类、dao层接口和实现类

public class Student {
  private int id;
  private String name;
  private String address;
    // 省略getter/setter/构造方法/tostring
}
public interface StudentDao {
  // 根据id查询学生
  Student findById(int id);
}
public class StudentDaoImpl implements StudentDao{
  @Override
  public Student findById(int id) {
    // 模拟从数据库查找出学生
    return new Student(1,"张三","南京市");
   }
}

3、在resources编写xml配置文件bean.xml ，配置文件中配置需要Spring帮我们创建的对象。

<?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">
    <!--spring会读取该配置文件的信息将对象加载到spring容器中，注意class一定是接口的实现类。-->
    <bean id="studentDao" class="com.zj.dao.StudentDaoImpl"></bean>
</beans>

4、测试

@Test
    public void test1(){
        //创建spring容器
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        //从容器获取对象
        StudentDao studentDao1 = (StudentDao) context.getBean("studentDao");
        StudentDao studentDao2 = (StudentDao) context.getBean("studentDao");
        System.out.println(studentDao1.hashCode());
        System.out.println(studentDao2.hashCode());
        System.out.println(studentDao1.findById(1));
    }

hashcode值相同说明spring容器中只存在一个StudentDao的实例。

2.3 Spring容器类型

容器接口

BeanFactory：BeanFactory是Spring容器中的顶层接口，它可以对Bean对象进行管理。
ApplicationContext：ApplicationContext是BeanFactory的子接口。它除了继承 BeanFactory的所有功能外，还添加了对国际化、资源访问、事件传播等方面的良好支持。

ApplicationContext有以下三个常用实现类：

容器实现类

ClassPathXmlApplicationContext：该类可以从项目中读取配置文件

ApplicationContext context = new FileSystemXmlApplicationContext("bean.xml");

FileSystemXmlApplicationContext：该类从磁盘中读取配置文件

ApplicationContext context = new FileSystemXmlApplicationContext("D:\\Java\\code\\learnSpringIOC\\src\\main\\resources\\bean.xml");

AnnotationConfigApplicationContext：使用该类不读取配置文件，而是会读取注解

2.4 对象的创建方式

Spring会帮助我们创建bean，那么它底层是调用什么方法进行创建的呢？

使用构造方法

Spring默认通过反射机制使用类的空参构造方法创建bean，但是一般类会默认存在一个空参构造，只要自定义一个有参构造，那么无参构造就不会生效：

// 假如类没有空参构造方法，将无法完成bean的创建
public class StudentDaoImpl implements StudentDao{
  public StudentDaoImpl(int a){}
  @Override
  public Student findById(int id) {
    // 模拟根据id查询学生
    return new Student(1,"张三","北京");
   }
}

使用工厂类的方法

除了使用空参构造创建对象之外，Spring还可以调用工厂类的方法创建bean：

1、创建工厂类，工厂类提供创建对象的方法

public class StudentDaoFactory {
  public StudentDao getStudentDao(){
    return new StudentDaoImpl(1);
   }
}

2、在配置文件中配置创建bean的方式为工厂方式。

<!--  id：工厂对象的id，class：工厂类  -->
<bean id="studentDaoFactory" class="com.zj.dao.StudentDaoFactory"></bean>
<!--  id：bean对象的id，factory-bean：工厂对象的id，factory-method：工厂方法 -->
<bean id="studentDao" factory-bean="studentDaoFactory" factory-method="getStudentDao"></bean>

3、测试

@Test
    public void test2() {
        //创建spring容器
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        StudentDao studentDao = (StudentDao) context.getBean("studentDao");
        Student student = studentDao.findById(1);
        System.out.println(student);
    }

使用工厂类的静态方法

Spring可以调用工厂类的静态方法创建bean：

1、创建工厂类，工厂提供创建对象的静态方法。

public class StudentDaoFactory2 {
  public static StudentDao getStudentDao2() {
    return new StudentDaoImpl();
   }
}

2、在配置文件中配置创建bean的方式为工厂静态方法。

<!--静态方法的调用不需要创建对象-->
    <!-- id:bean的id  class:工厂全类名 factory-method:工厂静态方法  -->
    <bean id="studentDao" class="com.zj.factory.StudentDaoFactory2" factory-method="getStudentDao2"></bean>

2.5 对象的创建策略

Spring通过配置<bean>中的scope属性设置对象的创建策略，共有五种创建策略：

1、singleton：单例，默认策略。整个项目只会创建一个对象，通过<bean>中的lazy-init属性可以设置单例对象的创建时机：

lazy-init="false"(默认)：立即创建，在容器启动时会创建配置文件中的所有Bean对象。

lazy-init="true"：延迟创建，第一次使用Bean对象时才会创建。

配置单例策略：

<?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="studentDao" class="com.zj.dao.StudentDaoImpl"/>
</beans>

测试单例策略：

public class StudentDaoImpl implements StudentDao {
    public StudentDaoImpl() {
        System.out.println("StudentDaoImpl对象创建了");
    }
}
public class TestSpringContainer {
    @Test
    public void test1(){
        //创建spring容器
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    }
}

2、prototype：多例，每次从容器中获取时都会创建对象。

<!-- 配置多例策略 -->
<bean id="studentDao"   class="com.zj.dao.StudentDaoImpl" scope="prototype"></bean>

3、request：每次请求创建一个对象，只在web环境有效。

4、session：每次会话创建一个对象，只在web环境有效。

5、gloabal-session：一次集群环境的会话创建一个对象，只在web环境有效。

2.6 对象的销毁时机

对象的创建策略不同，销毁时机也不同：

singleton：对象随着容器的销毁而销毁。
prototype：使用JAVA垃圾回收机制销毁对象。
request：当处理请求结束，bean实例将被销毁。
session：当HTTP Session最终被废弃的时候，bean也会被销毁掉。
gloabal-session：集群环境下的session销毁，bean实例也将被销毁。

2.7 生命周期方法

Bean对象的生命周期包含创建——使用——销毁，Spring可以配置Bean对象在创建和销毁时自动执行的方法：

1、定义生命周期方法

package com.zj.dao;
public class StudentDaoImpl implements StudentDao {
    // 创建时自动执行的方法
    public void init(){
        System.out.println("创建StudentDaoImpl！！！");
    }
    // 销毁时自动执行的方法
    public void destroy(){
        System.out.println("销毁StudentDaoImpl！！！");
    }
}

2、配置生命周期方法

<?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">
    <!-- init-method:创建对象时执行的方法  destroy-method:销毁对象时执行的方法  -->
    <bean id="studentDao" class="com.zj.dao.StudentDaoImpl" scope="singleton"
          init-method="init" destroy-method="destroy"></bean>
</beans>

3、测试

package com.zj.dao;
import com.zj.pojo.Student;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestSpringContainer {
    @Test
    public void test1(){
        //创建spring容器，单例模式下默认启动容器时创建对象
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
      //销毁Spring容器，ClassPathXmlApplicationContext才有销毁容器的方法
        context.close();
    }
}

2.8 获取Bean对象的方式

Spring有多种获取容器中对象的方式：

通过id/name获取

配置文件

<bean name="studentDao" class="com.zj.dao.StudentDaoImpl"/>

2、获取对象

StudentDao studentDao = (StudentDao) context.getBean("studentDao");

通过类型获取

1、配置文件

<bean name="studentDao" class="com.zj.dao.StudentDaoImpl"/>

2、获取对象

StudentDaoImpl bean = context.getBean(StudentDaoImpl.class);

可以看到使用类型获取不需要强转。但是如果一个接口存在多个实现类的话不能使用该方式获取对象。因为spring容器不知道要获取哪个对象的实现类。

通过类型+id/name获取

虽然使用类型获取不需要强转，但如果在容器中有一个接口的多个实现类对象，则获取时会报错，此时需要使用类型+id/name获取

1、配置文件

<bean name="studentDaoImpl1" class="com.zj.dao.StudentDaoImpl"></bean>
    <bean name="studentDaoImpl2" class="com.zj.dao.StudentDaoImpl2"></bean>

2、获取对象

StudentDaoImpl studentDaoImpl1 = context.getBean("studentDaoImpl1", StudentDaoImpl.class);
 StudentDaoImpl2 studentDaoImpl2 = context.getBean("studentDaoImpl2", StudentDaoImpl2.class);

项目管理与SSM框架 Spring5（一）

一、Spring介绍

1.1 Spring简介

1.2 Spring体系结构

二、Spring IOC

2.1 控制反转思想

2.2 Spring实现IOC

2.3 Spring容器类型

容器接口

容器实现类

2.4 对象的创建方式

使用构造方法

使用工厂类的方法

使用工厂类的静态方法

2.5 对象的创建策略

2.6 对象的销毁时机

2.7 生命周期方法

2.8 获取Bean对象的方式

通过id/name获取

通过类型获取

通过类型+id/name获取

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

项目管理与SSM框架 Spring5（一）

一、Spring介绍

1.1 Spring简介

1.2 Spring体系结构

二、Spring IOC

2.1 控制反转思想

2.2 Spring实现IOC

2.3 Spring容器类型

容器接口

容器实现类

2.4 对象的创建方式

使用构造方法

使用工厂类的方法

使用工厂类的静态方法

2.5 对象的创建策略

2.6 对象的销毁时机

2.7 生命周期方法

2.8 获取Bean对象的方式

通过id/name获取

通过类型获取

通过类型+id/name获取

热门文章

最新文章

相关课程

相关电子书

相关实验场景