笔记内容主要整理自视频狂神说Java

文章目录

1.Spring介绍Spring理念Spring文档Spring优点 2.Spring的组成① 7大模块核心容器(Spring core)Spring上下文(Spring context)Spring面向切面编程(Spring AOP)Spring DAO模块Spring ORM模块Spring Web模块Spring MVC框架(Spring WebMVC) ② 三大思想 3.Spring IoC传统代码实现步骤优化后的代码实现流程使用Spring托管后的代码IOC本质 总结

1.Spring介绍

Spring理念

使现有技术更容易使用，本身是个技术大杂烩（融合器），整合了现有的技术框架

Spring文档

官网：https://spring.io/projects/spring-framework

官方文档：https://docs.spring.io/spring/docs/5.2.0.RELEASE/spring-framework-reference/core.html#spring-core

官方下载地址：https://repo.spring.io/release/org/springframework/spring/

GitHub：https://github.com/spring-projects/spring-framework

Spring优点

1.免费开源容器（框架）

2.轻量级的、非入侵式的框架。即本身体量小使用方便，同时引入Spring后不会对原来的项目产生任何影响

3.控制反转（IOC），面向切面编程（AOP）

4.支持事务的处理，对框架整合的支持

Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架

2.Spring的组成

① 7大模块

核心容器(Spring core)

核心容器提供spring框架的基本功能。Spring以bean的方式组织和管理Java应用中的各个组件及其关系。Spring使用BeanFactory来产生和管理Bean，它是工厂模式的实现。BeanFactory使用控制反转(IoC)模式将应用的配置和依赖性规范与实际的应用程序代码分开。BeanFactory使用依赖注入(DI)的方式提供给组件依赖。

Spring上下文(Spring context)

Spring上下文是一个配置文件，向Spring框架提供上下文信息。Spring上下文包括企业服务，如JNDI、EJB、电子邮件、国际化、校验和调度功能。

Spring面向切面编程(Spring AOP)

通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring框架中。所以，可以很容易地使 Spring框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。

Spring DAO模块

DAO模式主要目的是将持久层相关问题与一般的的业务规则和工作流隔离开来。Spring 中的DAO提供一致的方式访问数据库，不管采用何种持久化技术，Spring都提供一直的编程模型。Spring还对不同的持久层技术提供一致的DAO方式的异常层次结构。

Spring ORM模块

Spring 与所有的主要的ORM映射框架都集成的很好，包括hibernate、JDO实现、TopLink和IBatis SQL Map等。Spring为所有的这些框架提供了模板之类的辅助类，达成了一致的编程风格。

Spring Web模块

Web上下文模块建立在应用程序上下文模块之上，为基于Web的应用程序提供了上下文。Web层使用Web层框架，可选的，可以是Spring自己的MVC框架，或者提供的Web框架，如Struts、Webwork、tapestry和jsf。

Spring MVC框架(Spring WebMVC)

MVC框架是一个全功能的构建Web应用程序的MVC实现。通过策略接口，MVC框架变成为高度可配置的。Spring的MVC框架提供清晰的角色划分：控制器、验证器、命令对象、表单对象和模型对象、分发器、处理器映射和视图解析器。Spring支持多种视图技术。

② 三大思想

DI(依赖注入)(Dependency Injection)

IOC(控制反转)(Inversion of Control)

AOP(面向切面编程)(Aspect Oriented Programming)

3.Spring IoC

传统代码实现步骤

①dao层-UserDao接口

public interface UserDao{ void getUser(); }

②dao层-UserDaoImpl实现类

public class UserDaoImpl implements UserDao{ //重写接口类方法 public void getUser(){ System.out.println("获取数据"); } }

③service层-UserService业务接口

public interface UserService{ void getUser(); }

④service层-UserServiceImpl业务实现类

public class UserServiceImpl implements UserService{ //业务层所做的就是调用dao层进行操作 //调用对象写死了，没有可拓展性，用户需求一换就需要全部更改代码 private UserDao userDao = new UserDaoImpl(); public void getUser(){ userDao.getUser(); } }

⑤（实际调用时）main

public static void main(String[] args){ //用户实际调用的是业务层，不需要接触dao层 UserServiceImpl userService = new UserServiceImpl(); //调用方法 userService.getUser(); }

⑥倘若用户需求增加，需要在dao层额外另写实现类，如UserDaoMysqlImpl

public class UserDaoMysqlImpl implements UserDao{ public void getUser(){ System.out.println("Mysql获取数据"); } }

⑦此时则需要在UserServiceImpl中对之前写死的创建对象进行修改，即：

public class UserServiceImpl implements UserService{ //对此处创建的对象更改为UserDaoMysqlImpl private UserDao userDao = new UserDaoMysqlImpl(); public void getUser(){ System.out.println("获取数据"); } }

同样的，如果需求不断增加，则每次都要更改该处new的对象，无法适应用户需求的变更，代价过高

优化后的代码实现流程

其余部分不变，将Service层的业务实现类UserServiceImpl创建对象的语句进行修改：

public class UserServiceImpl implements UserService{ //更改private UserDao userDao = new UserDaoImpl(); //利用set进行动态实现值的注入 private UserDao userDao; public void setUserDao(UserDao userDao){ this.userDao = UserDao; } public void getUser(){ userDao.getUser(); } }

优化过后，在实际调用时，用户想用什么业务层功能实现，就可调用哪个业务实现类，解除了业务实现层与dao层直接的强联系，改用一个接口进行调用：

public static void main(String[] args){ UserServiceImpl userService = new UserServiceImpl(); //增加动态set注入，可直接在调用时根据需求更改new的对象，不需再到UserServiceImpl中更改创建的对象的代码 userService.setUserDao(new UserDaoMysqlImpl()); userService.getUser(); } 之前时程序主动创建对象，new对象的方法写死了，必须深入到创建对象的代码中进行修改 使用set注入后，程序变成了被动的接收对象，在调用时修改调用对象即可，不需再修改程序，架构上并没有变化，只是主动权在用户，我们可以写好每个选项让用户去选择，这种思想从本质上解决了问题，程序员不再需要管理对象的创建了，这就是控制反转IOC的思想，系统的耦合性大大降低，不再需要变更程序架构，可**专注于业务的实现*

使用Spring托管后的代码

①在resource包中添加一个配置文件ApplicationContext.xml注册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 https://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="mysqlImpl" class="com.xia.dao.UserDaoMysqlImpl"/> <bean id="oracleImpl" class="com.xia.dao.UserDaoOracleImpl"/> <!-- 此处ref的值即为之后调用的类，用户可直接在此处修改配置属性来实现不同的操作 --> <bean id="UserServiceImpl" class="com.xia.service.UserServiceImpl"> <property name = "userDao" ref = "mysqlImpl"/> </bean> <!-- ref:引用Spring容器值创建好的对象 value:具体的值，基本数据类型 --> </beans>

②更改主函数中调用的代码，不用再创建对象，直接获取Spring容器即可，要修改到xml配置文件中修改

public static void main(String[] args){ //获取Spring容器 ApplicationContext context = new ClassPathXmlApplicationContext("AppplicationContext.xml"); //拿到Spring容器后需要什么就直接get什么 UserServiceImpl userServiceImpl = (UserServiceImpl)context.getBean("UserServcieImpl"); userServiceImpl.getUser(); }

IOC本质

控制反转IOC(Inversion Of Control)是一种设计思想，依赖注入DI(Dependency Injection)是实现IOC的一种方法

在没有IOC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全写死在程序中，对象的创建由程序本身控制；控制反转之后，对象的创建转移给了第三方，（将原本相互间具有关系的强耦合对象，利用一个IOC容器作为中间件，将这几个对象连接起来进行解耦）即获得依赖对象的方式反转了

IOC是Spring框架的核心内容，使用了多种方式完美实现了IOC，可以使用XML配置，也可以使用注解

Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从IOC容器中取出想要的对象

采用XML方式配置Bean时，Bean的定义信息时和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的

总结

对象由Spring创建，对象的属性由Spring容器设置，此过程即为控制反转：

控制：传统程序的对象由程序本身控制创建；而使用Spring后则是由Spring来创建

反转：程序本身不创建对象，而是变为被动的接收对象

依赖注入：利用对象类中的set方法进行注入

IOC是一种编程思想，由主动的编程变为被动的接收，即对象由Spring创建、管理、装配