【后端】SSM框架体系（一）

SSM框架 Spring 一、Spring相关概念 1. 初识Spring 1.1 Spring家族

官网：https://spring.io.从官网我们可以大概了解到：
- Spring能做什么：用以开发web、微服务以及分布式系统等,光这三块就已经占了JavaEE开发的九成多。
- Spring并不是单一的一个技术，而是一个大家族，可以从官网的Projects中查看其包含的所有技术。
Spring发展到今天已经形成了一种开发的生态圈,Spring提供了若干个项目,每个项目用于完成特定的功能。
- Spring已形成了完整的生态圈，也就是说我们可以完全使用Spring技术完成整个项目的构建、设计与开发。
- Spring有若干个项目，可以根据需要自行选择，把这些个项目组合起来，起了一个名称叫全家桶，如下图所示
- Spring Framework：Spring框架，是Spring中最早最核心的技术，也是所有其他技术的基础。
- SpringBoot：Spring是来简化开发，而SpringBoot是来帮助Spring在简化的基础上能更快速进行开发。
- SpringCloud：这个是用来做分布式之微服务架构的相关开发。
除了上面的这三个技术外，还有很多其他的技术，也比较流行，如SpringData,SpringSecurity等，这些都可以被应用在我们的项目中。我们今天所学习的Spring其实指的是Spring Framework。

1.2 了解Spring发展史

IBM(IT公司-国际商业机器公司)在1997年提出了EJB思想,早期的JAVAEE开发大都基于该思想。
Rod Johnson(Java和J2EE开发领域的专家)在2002年出版的Expert One-on-One J2EE Design and Development ,书中有阐述在开发中使用EJB该如何做。
Rod Johnson在2004年出版的Expert One-on-One J2EE Development without EJB ,书中提
出了比EJB思想更高效的实现方案，并且在同年将方案进行了具体的落地实现，这个实现就是
Spring1.0。
随着时间推移，版本不断更新维护，目前最新的是Spring5
- Spring1.0是纯配置文件开发
- Spring2.0为了简化开发引入了注解开发，此时是配置文件加注解的开发方式
- Spring3.0已经可以进行纯注解开发，使开发效率大幅提升
- Spring4.0根据JDK的版本升级对个别API进行了调整
- Spring5.0已经全面支持JDK8，现在Spring最新的是5系列所以建议大家把JDK安装成1.8版

2. Spring系统架构

核心层
- Core Container:核心容器，这个模块是Spring最核心的模块，其他的都需要依赖该模块
AOP层
- AOP:面向切面编程，它依赖核心层容器，目的是在不改变原有代码的前提下对其进行功能增强
- Aspects:AOP是思想，Aspects是对AOP思想的具体实现
数据层
- Data Access:数据访问，Spring全家桶中有对数据访问的具体实现技术
- Data Integration:数据集成，Spring支持整合其他的数据层解决方案，比如Mybatis
- Transactions:事务，Spring中事务管理是Spring AOP的一个具体实现，也是后期学习的重点内容
Web层
- 这一层的内容将在SpringMVC框架具体学习
Test层
- Spring主要整合了Junit来完成单元测试和集成测试

3. Spring核心概念 3.1 目前项目中的问题

要想解答这个问题，就需要先分析下目前咱们代码在编写过程中遇到的问题:
业务层需要调用数据层的方法，就需要在业务层new数据层的对象
如果数据层的实现类发生变化，那么业务层的代码也需要跟着改变，发生变更后，都需要进行编译打包和重部署
所以，现在代码在编写的过程中存在的问题是：耦合度偏高
针对这个问题，该如何解决呢?
我们就想，如果能把框中的内容给去掉，不就可以降低依赖了么，但是又会引入新的问题，去掉以后程序能运行么?
答案肯定是不行，因为bookDao没有赋值为Null，强行运行就会出空指针异常。
所以现在的问题就是，业务层不想new对象，运行的时候又需要这个对象，该咋办呢?
针对这个问题，Spring就提出了一个解决方案:
- 使用对象时，在程序中不要主动使用new产生对象，转换为由外部提供对象
这种实现思想就是Spring的一个核心概念

3.2 IOC、IOC容器、Bean、DI 3.2.1 IOC（Inversion of Control）控制反转

什么是控制反转呢？
- 使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转。
  - 业务层要用数据层的类对象，以前是自己new的
  - 现在自己不new了，交给别人[外部]来创建对象
  - 别人[外部]就反转控制了数据层对象的创建权
  - 这种思想就是控制反转
  - 别人[外部]指定是什么呢?继续往下学
Spring和IOC之间的关系是什么呢?
- Spring技术对IOC思想进行了实现
- Spring提供了一个容器，称为IOC容器，用来充当IOC思想中的"外部"
- IOC思想中的别人[外部]指的就是Spring的IOC容器
IOC容器的作用以及内部存放的是什么?
- IOC容器负责对象的创建、初始化等一系列工作，其中包含了数据层和业务层的类对象
- 被创建或被管理的对象在IOC容器中统称为Bean
- IOC容器中放的就是一个个的Bean对象
当IOC容器中创建好service和dao对象后，程序能正确执行么?
- 不行，因为service运行需要依赖dao对象
- IOC容器中虽然有service和dao对象
- 但是service对象和dao对象没有任何关系
- 需要把dao对象交给service,也就是说要绑定service和dao对象之间的关系
- 像这种在容器中建立对象与对象之间的绑定关系就要用到DI

3.2.2 DI（Dependency Injection）依赖注入

什么是依赖注入呢?
- 在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入
  - 业务层要用数据层的类对象，以前是自己new的
  - 现在自己不new了，靠别人[外部其实指的就是IOC容器]来给注入进来
  - 这种思想就是依赖注入
IOC容器中哪些bean之间要建立依赖关系呢?
- 这个需要程序员根据业务需求提前建立好关系，如业务层需要依赖数据层，service就要和dao建立依赖关系

3.2.3 总结

介绍完Spring的IOC和DI的概念后，我们会发现这两个概念的最终目标就是:充分解耦，具体实现靠:
- 使用IOC容器管理bean（IOC)
- 在IOC容器内将有依赖关系的bean进行关系绑定（DI）
- 最终结果为:使用对象时不仅可以直接从IOC容器中获取，并且获取到的bean已经绑定了所有的依赖关系.

3.3 核心概念小结

什么是IOC/DI思想?
- IOC:控制反转，控制反转的是对象的创建权
- DI:依赖注入，绑定对象与对象之间的依赖关系
什么是IOC容器?
- Spring创建了一个容器用来存放所创建的对象，这个容器就叫IOC容器
什么是Bean?
- 容器中所存放的一个个对象就叫Bean或Bean对象

二、入门案例 1. IOC入门案例 1.1 入门案例思路分析

Spring是使用容器来管理bean对象的，那么管什么?
- 主要管理项目中所使用到的类对象，比如(Service和Dao)
如何将被管理的对象告知IOC容器?
- 使用配置文件
被管理的对象交给IOC容器，要想从容器中获取对象，就先得思考如何获取到IOC容器?
- Spring框架提供相应的接口
IOC容器得到后，如何从容器中获取bean?
- 调用Spring框架提供对应接口中的方法
使用Spring导入哪些坐标?
- 用别人的东西，就需要在pom.xml添加对应的依赖

1.2 入门案例代码实现

需求分析:将BookServiceImpl和BookDaoImpl交给Spring管理，并从容器中获取对应的bean
对象进行方法调用。
1.创建Maven的java项目
2.pom.xml添加Spring的依赖jar包
3.创建BookService,BookServiceImpl,BookDao和BookDaoImpl四个类
4.resources下添加spring配置文件，并完成bean的配置
5.使用Spring提供的接口完成IOC容器的创建
6.从容器中获取对象进行方法调用

步骤1:创建Maven项目
步骤2:添加Spring的依赖jar包


 
	 
		org.springframework 	
		spring-context 
		5.2.10.RELEASE 
	 
	 
		junit 
		junit 
		4.12 
		test

步骤3:添加案例中需要的类

// 创建BookService,BookServiceImpl，BookDao和BookDaoImpl四个类
public interface BookDao { 
	public void save(); 
}
public class BookDaoImpl implements BookDao { 
	public void save() { 
		System.out.println("book dao save ..."); 
	} 
}
public interface BookService { 
	public void save(); 
}
public class BookServiceImpl implements BookService { 
	private BookDao bookDao = new BookDaoImpl(); 
	public void save() { 
		System.out.println("book service save ..."); 
		bookDao.save(); 
	} 
}

步骤4:添加spring配置文件
- resources下添加spring配置文件applicationContext.xml，并完成bean的配置
步骤5:在配置文件中完成bean的配置

步骤6:获取IOC容器
- 使用Spring提供的接口完成IOC容器的创建，创建App类，编写main方法
步骤7:从容器中获取对象进行方法调用

public class App { 
	public static void main(String[] args) { 
		//获取IOC容器 
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); 
		// BookDao bookDao = (BookDao) ctx.getBean("bookDao"); 
		// bookDao.save(); 
		BookService bookService = (BookService) ctx.getBean("bookService"); 
		bookService.save(); 
	} 
}

步骤8:运行程序
- 测试结果为：
Spring的IOC入门案例已经完成，但是在BookServiceImpl的类中依然存在BookDaoImpl对象的new操作，它们之间的耦合度还是比较高，这块该如何解决，就需要用到下面的DI:依赖注入。

2. DI入门案例 2.1 入门案例思路分析

要想实现依赖注入，必须要基于IOC管理Bean
- DI的入门案例要依赖于前面IOC的入门案例
Service中使用new形式创建的Dao对象是否保留?
- 需要删除掉，最终要使用IOC容器中的bean对象
Service中需要的Dao对象如何进入到Service中?
- 在Service中提供方法，让Spring的IOC容器可以通过该方法传入bean对象
Service与Dao间的关系如何描述?
- 使用配置文件

2.2 入门案例代码实现

需求:基于IOC入门案例，在BookServiceImpl类中删除new对象的方式，使用Spring的DI完成
Dao层的注入
1.删除业务层中使用new的方式创建的dao对象
2.在业务层提供BookDao的setter方法
3.在配置文件中添加依赖注入的配置
4.运行程序调用方法

步骤1: 去除代码中的new
- 在BookServiceImpl类中，删除业务层中使用new的方式创建的dao对象

public class BookServiceImpl implements BookService { 
	//删除业务层中使用new的方式创建的dao对象 
	private BookDao bookDao; 

	public void save() { 
		System.out.println("book service save ..."); 
		bookDao.save(); 
	} 
}

步骤2:为属性提供setter方法
- 在BookServiceImpl类中,为BookDao提供setter方法

public class BookServiceImpl implements BookService { 
	//删除业务层中使用new的方式创建的dao对象 
	private BookDao bookDao; 

	public void save() { 
		System.out.println("book service save ..."); 
		bookDao.save(); 
	}
	//提供对应的set方法 
	public void setBookDao(BookDao bookDao) { 
		this.bookDao = bookDao; 
	} 
}

步骤3:修改配置完成注入
- 在配置文件中添加依赖注入的配置
```
 
 
 
	 
	 
		 
		 
		 
	 
```
- 注意:配置中的两个bookDao的含义是不一样的
  - name="bookDao"中bookDao的作用是让Spring的IOC容器在获取到名称后，将首字母大写，前面加set找对应的setBookDao()方法进行对象注入
  - ref="bookDao"中bookDao的作用是让Spring能在IOC容器中找到id为bookDao的Bean对象给bookService进行注入
- 综上所述，对应关系如下:
步骤4:运行程序
- 运行，测试结果为：

三、IOC相关内容 1. bean基础配置 1.1 bean基础配置(id与class)

思考：
- class属性能不能写接口如BookDao的类全名呢?
  - 答案肯定是不行，因为接口是没办法创建对象的。
- 前面提过为bean设置id时，id必须唯一，但是如果由于命名习惯而产生了分歧后，该如何解决?

1.2 bean的name属性

步骤1：配置别名
- 打开spring的配置文件applicationContext.xml

步骤2:根据名称容器中获取bean对象

public class AppForName { 
	public static void main(String[] args) { 
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); 
		//此处根据bean标签的id属性和name属性的任意一个值来获取bean对象 
		BookService bookService = (BookService) ctx.getBean("service4"); 
		bookService.save(); 
	} 
}

步骤3:运行程序
- 测试结果为：
注意事项:
- bean依赖注入的ref属性指定bean，必须在容器中存在
- 如果不存在,则会报错，如下:
获取bean无论是通过id还是name获取，如果无法获取到，将抛出异常 NoSuchBeanDefinitionException

1.3 bean作用范围scope配置

1.3.1 验证IOC容器中对象是否为单例

验证思路
- 同一个bean获取两次，将对象打印到控制台，看打印出的地址值是否一致。

具体实现

创建一个AppForScope的类，在其main方法中来验证

public class AppForScope { 
	public static void main(String[] args) { 
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); 
		BookDao bookDao1 = (BookDao) ctx.getBean("bookDao"); 
		BookDao bookDao2 = (BookDao) ctx.getBean("bookDao"); 
		System.out.println(bookDao1); 
		System.out.println(bookDao2); 
	}
}

打印，观察控制台的打印结果
结论:默认情况下，Spring创建的bean对象都是单例的

获取到结论后，问题就来了，那如果我想创建出来非单例的bean对象，该如何实现呢?

1.3.2 配置bean为非单例

在Spring配置文件中，配置scope属性来实现bean的非单例创建
- 在Spring的配置文件中，修改的scope属性
- 将scope设置为singleton
- 将scope设置为prototype
结论，使用bean的scope属性可以控制bean的创建是否为单例：
- singleton默认为单例
- prototype为非单例

1.3.3 scope使用后续思考

为什么bean默认为单例?
- bean为单例的意思是在Spring的IOC容器中只会有该类的一个对象
- bean对象只有一个就避免了对象的频繁创建与销毁，达到了bean对象的复用，性能高
bean在容器中是单例的，会不会产生线程安全问题?
- 如果对象是有状态对象，即该对象有成员变量可以用来存储数据的
- 因为所有请求线程共用一个bean对象，所以会存在线程安全问题。
- 如果对象是无状态对象，即该对象没有成员变量没有进行数据存储的
- 因为方法中的局部变量在方法调用完成后会被销毁，所以不会存在线程安全问题。
哪些bean对象适合交给容器进行管理?
- 表现层对象
- 业务层对象
- 数据层对象
- 工具对象
哪些bean对象不适合交给容器进行管理?
- 封装实例的域对象，因为会引发线程安全问题，所以不适合。

1.4 bean基础配置小结

2. bean实例化

对象已经能交给Spring的IOC容器来创建了，但是容器是如何来创建对象的呢?
就需要研究下bean的实例化过程，在这块内容中主要解决两部分内容，分别是
- bean是如何创建的
- 实例化bean的三种方式，构造方法,静态工厂和实例工厂
在讲解这三种创建方式之前，我们需要先确认一件事:
bean本质上就是对象，对象在new的时候会使用构造方法完成，那创建bean也是使用构造方法完成的。
基于这个知识点出发，我们来验证spring中bean的三种创建方式

2.1 构造方法实例化

步骤1:准备需要被创建的类
- 准备一个BookDao和BookDaoImpl类

public interface BookDao { 
	public void save(); 
}

public class BookDaoImpl implements BookDao { 
	public void save() { 
		System.out.println("book dao save ..."); 
	} 
}

步骤2:将类配置到Spring容器

步骤3:编写运行程序

public class AppForInstanceBook { 
	public static void main(String[] args) { 
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); 
		BookDao bookDao = (BookDao) ctx.getBean("bookDao"); 
		bookDao.save(); 
	} 
}

步骤4:类中提供构造函数测试
- 在BookDaoImpl类中添加一个无参构造函数，并打印一句话，方便观察结果。
```
public class BookDaoImpl implements BookDao { 
	public BookDaoImpl() { 
		System.out.println("book dao constructor is running ...."); 
	}
	public void save() { 
		System.out.println("book dao save ..."); 
	} 
}
```
- 运行程序，如果控制台有打印构造函数中的输出，说明Spring容器在创建对象的时候也走的是构造函数

步骤5:将构造函数改成private测试

public class BookDaoImpl implements BookDao { 
	private BookDaoImpl() { 
		System.out.println("book dao constructor is running ...."); 
	}
	public void save() { 
		System.out.println("book dao save ..."); 
	} 
}

运行程序，能执行成功，说明内部走的依然是构造函数，能访问到类中的私有构造方法，显而易见Spring底层用的是反射

步骤6:构造函数中添加一个参数测试

public class BookDaoImpl implements BookDao { 
	private BookDaoImpl(int i) { 
		System.out.println("book dao constructor is running ...."); 
	}
	public void save() { 
		System.out.println("book dao save ..."); 
	} 
}

运行程序，
程序会报错，说明Spring底层使用的是类的无参构造方法。

2.2 静态工厂实例化 2.2.1 工厂方式创建bean

准备一个OrderDao和OrderDaoImpl类

public interface OrderDao { 
	public void save(); 
}
public class OrderDaoImpl implements OrderDao { 
	public void save() { 
		System.out.println("order dao save ..."); 
	} 
}

创建一个工厂类OrderDaoFactory并提供一个静态方法

//静态工厂创建对象 
public class OrderDaoFactory { 
	public static OrderDao getOrderDao(){ 
		return new OrderDaoImpl(); 
	} 
}

编写AppForInstanceOrder运行类，在类中通过工厂获取对象

public class AppForInstanceOrder { 
	public static void main(String[] args) { 
		//通过静态工厂创建对象 
		OrderDao orderDao = OrderDaoFactory.getOrderDao(); 
		orderDao.save(); 
	} 
}

运行后，可以查看到结果
如果代码中对象是通过上面的这种方式来创建的，如何将其交给Spring来管理呢?

2.2.2 静态工厂实例化

在spring的配置文件application.properties中添加以下内容:
- class:工厂类的类全名
- factory-mehod:具体工厂类中创建对象的方法名
- 对应关系如下图:
在AppForInstanceOrder运行类，使用从IOC容器中获取bean的方法进行运行测试

public class AppForInstanceOrder { 
	public static void main(String[] args) { 
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); 
		OrderDao orderDao = (OrderDao) ctx.getBean("orderDao"); 
		orderDao.save(); 
	} 
}

运行后，可以查看到结果
看到这，可能有人会问了，你这种方式在工厂类中不也是直接new对象的，和我自己直接new没什么太大的区别，而且静态工厂的方式反而更复杂，这种方式的意义是什么?
主要的原因是:
- 在工厂的静态方法中，我们除了new对象还可以做其他的一些业务操作，这些操作必不可少,如:

public class OrderDaoFactory { 
	public static OrderDao getOrderDao(){ 
		System.out.println("factory setup....");//模拟必要的业务操作 
		return new OrderDaoImpl(); 
	} 
}

之前new对象的方式就无法添加其他的业务内容，重新运行，查看结果:

2.3 实例工厂与FactoryBean 2.3.1 环境准备

准备一个UserDao和UserDaoImpl类

public interface UserDao { 
	public void save(); 
}
public class UserDaoImpl implements UserDao { 
	public void save() { 
		System.out.println("user dao save ..."); 
	} 
}

创建一个工厂类OrderDaoFactory并提供一个普通方法，注意此处和静态工厂的工厂类不一样的地方是方法不是静态方法

public class UserDaoFactory { 
	public UserDao getUserDao(){ 
		return new UserDaoImpl(); 
	} 
}

编写AppForInstanceUser运行类，在类中通过工厂获取对象

public class AppForInstanceUser { 
	public static void main(String[] args) { 
		//创建实例工厂对象 
		UserDaoFactory userDaoFactory = new UserDaoFactory(); 
		//通过实例工厂对象创建对象 
		UserDao userDao = userDaoFactory.getUserDao(); 
		userDao.save(); 
	}
}

运行后，可以查看到结果
对于上面这种实例工厂的方式如何交给Spring管理呢?

2.3.2 实例工厂实例化

在spring的配置文件中添加以下内容:
```
 
```
- 实例化工厂运行的顺序是:
  - 创建实例化工厂对象,对应的是第一行配置
  - 调用对象中的方法来创建bean，对应的是第二行配置
    - factory-bean:工厂的实例对象
    - factory-method:工厂对象中的具体创建对象的方法名,对应关系如下:
在AppForInstanceUser运行类，使用从IOC容器中获取bean的方法进行运行测试

public class AppForInstanceUser { 
	public static void main(String[] args) { 
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); 
		UserDao userDao = (UserDao) ctx.getBean("userDao"); 
		userDao.save(); 
	} 
}

运行后，可以查看到结果
实例工厂实例化的方式就已经介绍完了，配置的过程还是比较复杂，所以Spring为了简化这种配置方式就提供了一种叫FactoryBean的方式来简化开发。

2.3.3 FactoryBean的使用

创建一个UserDaoFactoryBean的类，实现FactoryBean接口，重写接口的方法

public class UserDaoFactoryBean implements FactoryBean { 
	//代替原始实例工厂中创建对象的方法 
	public UserDao getObject() throws Exception { 
		return new UserDaoImpl(); 
	}
	//返回所创建类的Class对象 
	public Class getObjectType() { 
		return UserDao.class; 
	} 
}

在Spring的配置文件中进行配置

AppForInstanceUser运行类不用做任何修改，直接运行
这种方式在Spring去整合其他框架的时候会被用到，所以这种方式需要大家理解掌握。查看源码会发现，FactoryBean接口其实会有三个方法，分别是:

T getObject() throws Exception; 
Class getObjectType(); 
default boolean isSingleton() { return true; }

// 方法一:getObject()，被重写后，在方法中进行对象的创建并返回
// 方法二:getObjectType(),被重写后，主要返回的是被创建类的Class对象
// 方法三:没有被重写，因为它已经给了默认值，从方法名中可以看出其作用是设置对象是否为单例，默认true，false为非单例
// 一般情况下我们都会采用单例，也就是采用默认即可。所以isSingleton()方法一般不需要进行重写。

2.4 bean实例化小结

bean是如何创建的呢? 构造方法
Spring的IOC实例化对象的三种方式分别是:
- 构造方法(常用)
- 静态工厂(了解)
- 实例工厂(了解)
  - FactoryBean(实用)
这些方式中，重点掌握构造方法和FactoryBean即可。
需要注意的一点是，构造方法在类中默认会提供，但是如果重写了构造方法，默认的就会消失，在使用的过程中需要注意，如果需要重写构造方法，最好把默认的构造方法也重写下。

【后端】SSM框架体系（一）

Java相关栏目本月热门文章