深入了解spring

àì夳堔傛蜴生んèń 2023-07-22 05:58 27阅读 0赞

*  # Spring学习目录 #

## 一、Spring的介绍 ##

## 二、Spring常用的设计模式 ##

## 三、IOC（容器/控制反转） ##

## 四、AOP（面向切面） ##

## 五、DI（依赖注入） ##

## 一、Spring介绍 ##

Spring是一个开源的轻量级（零配置）的Java SE开发应用框架，其目的是用于简化企业级应用程序开发，一个完整的应用程序是由很多对象组成，而Spring可以创建和很好的管理这些对象，这样做可以减少我们的工作，大大提高了效率，Spring能无缝的整合其他框架，并将java中的设计模式表现的淋漓尽致。

## 二、Spring常用的设计模式 ##

1. 工厂设计模式（简单工厂和工厂方法）

2. 代理模式（动态代理跟静态代理）<持有被代理人的引用>

原理：将你想做的交给别人来做，代理人实现InvocationHandler接口，

![20200404202023867.png][]

并重写invoke方法，method.invoke(this.target,args);采用反射机制，动态获取对象

![2020040420203446.png][]代理人会有个getInstance方法，它会动态生成一个代理对象 $Proxy0，里面会生成你调用的方法

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMDM3NDc4_size_16_color_FFFFFF_t_70][]

3. CGLib动态代理(cglib会创建一个被代理人的子类，通过子类获取被代理人的引用)

用到的包：cglib.jar （全称Code Generation Library 代码生成库）

asm.jar (全称assembly，装配)

4. 工厂模式（简单工厂、工厂方法、抽象工厂）

隐藏复杂的逻辑过程，只关心结果

5. 单例模式：

保证从系统启动到系统停止，全过程只会产生一个实例

举例：配置文件：如果不是单例（如果不是一样的，则有一个会浪费，如果不一样的，我们也不知道用哪个）

直接上级领导（如果有多个领导，你也不知道到底听谁的）

特点：保证从系统启动到系统终止，全过程只会创建一个实例

当我们在应用中遇到功能性冲突的时候，需要使用单例模式

6. 委派模式（要与代理模式区分开）

特点：类似于中介的功能（委托机制）

持有被委托人的引用

只关心结果，不关心过程

为什么要用委派模式？

保证结果的多样性，对于用户来说只有一个方法

其目的就是隐藏具体的逻辑

举例：IOC容器中，有个Register（注册器）的东西（为了告诉我们的容器，在这个类被初始化的过程中，需要做很多不同的逻辑处               理，需要实现多个入围只想着，分别实现各自的功能）

总结：委派人（领导），被委派人（员工），委派人会持有被委派人的引用，委派人会拥有和被委派人一样的方法名，内部实现逻

辑其实是被委派人实现的，只是表面上看起来是委派人实现的

7. 策略模式（只关心过程，不关心结果）

特点：结果相同，过程不同，如：上海-->杭州 起点跟终点的地点是固定的，但是到达目的地的路线可以有很多种

举例：java中的Collection.sort排序，返回结果是固定的 0，-1，1

compare(Long 01,Long 02)比较；只关心比较后的结果，不关心你是怎么比较的，且结果是固定的

8. 原型模式（只关心结果，不关心过程）

特点：过程相同，但结果不同。

数据内容完全一样，但实例不同

为什么会有原型模式？

解决数据的复制问题

举例：java中的数据copy

深克隆：通过序列化跟反序列化生成新的对象，会分配新的内存空间。

浅克隆（默认）：只克隆基本数据类型跟String。

9. 模板模式：

特点：执行流程一样，但中间有些步骤不同

举例：SpringJDBC，是java规范，各个数据库厂商自己去实现它

1、加载驱动类DriverManager

2、建立连接

3、创建语句集合（标准语句集or预处理语句集，，，MySQL，Oracle）

4、执行语句集

5、拿到结果集

总结：模板模式就是有个固定的执行流程（规范），中间你可以有自己的操作，

JDBC的处理中，流程是固定，但是我们可以用MySQL，也可以用Oracle

## 三、IOC容器 ##

1.  控制反转(IOC)：通过spring来初始化和实例化（把控制权交给spring）

2.  IOC容器：存的是java bean（依赖链中的所有对象都是在ioc容器里面初始化的）

为什么要有IOC容器？

因为可以将实例化的对象保存在容器里，可以复用

3. 项目启动IOC容器初始化的步骤

1. 定位（定位查找配置文件）

2. 加载（加载查到到的配置文件）

3. 注册（将已经加载好了的配置文件解析出来，并封装成BeanDefinition（IOC容器，是一个Map））对bean的说明而已，

bean还没有真正的产生，把所有class找出来存着）

4. 初始化（从注册信息里面找，注册信息里面保存了所有的class的名字，然后通过反射创建相应的对象保存到IOC容器中）

5. 注入（在初始化的基础之上，从IOC容器中取出已经初始化了的对象，将它们之间的关系建立起来，其实就是给初始化

了的对象赋值）

BeanDefinition说明：是一个Map，保存了所有加载了的类的名字，也保存了类和类之间的关系，

## 四、DI（依赖注入即赋值） ##

Spring的依赖注入方式

1.setter

2.构造方法

3.强制赋值 @autowite private InterfaceA a

@autowite InterfaceA a； // 自动把它的实现类注入进来

@Resource（“aaa”） A b;// IOC容器中的id为aaa对象自动注入到这里

注：依赖注入不是依赖容器，而是说依赖链里的所有对象，就好比对象b继承了对象a，你注入b的同时a也会被注入进来

## 五、AOP（面向切面） ##

面向切面编程，即aop，一种编程思想，它允许程序员对横切关注点或横切典型的职责分界的行为（日志，事物）进行模块化

aop的核心构造是方面（切面），它将那些影响多个类的行为封装到可重用的模块中（有规律（规则）的程序都可以拆开）。

举例：一辆汽车，它是由多个零件组装而成，而零件之间的组装需要制定一个规则，一个标准，而这个标准就是一种思想，这就是aop的编程思想。

1. 先了解一下AOP的相关概念

*  切面（Aspect）：官方的抽象定义为“一个关注点的模块化”，这个关注点可能会横切多个对象（比如事务：多个service都需要添加事务，这时候可以把它们看成一个切面，切面是个模块化的东西，对类的共同点进行归纳：几个类都需要添加事务）
 *  连接点（Joinpoint）：规定切面中的方法调用的一些规则（对类中的方法的共同点进行归纳：类中方法都需要满足规则）
 *  通知（advice）：一旦在调用过程中，满足连接点的规则，那么就会触发通知：调用代理写的代码
 *  切入点（Pointcut）：进入切面内部的一个入口（主动调用方法）
 *  目标对象（Target Object）：被一个或多个切面所通知的对象，被代理对象的引用
 *  AOP代理（Aop Proxysss）：Spring aop 中有两种代理方式，jdk动态代理跟cglib代理

2. 通知类型（advice）：

*  前置通知（Before advice）：在某个连接点之前通知
 *  后置通知（After advice）：在某个连接点之后通知
 *  返回后通知（After return advice）：在某个连接点返回结果后通知
 *  环绕通知（Around advice）：包围一个连接点的通知，类似于servlet中的dofilter，（权限校验，一个连接点出错就断开连接链）
 *  抛出异常后通知（after throwing advice）：抛出异常后通知

3. 项目中用到的地方

Authentication 权限认证

Logging 日志

Transction Manager 事务

Lazy Loading 懒加载

Context Process 上下文处理

Error Handler 错误跟踪（捕获异常机制）

Cache 缓存

### 总结： ###

<table> 
 <tbody> 
 <tr> 
 <td> Spring思想 </td> 
 <td> 应用场景（特点） </td> 
 <td> 一句话归纳 </td> 
 </tr> 
 <tr> 
 <td> AOP </td> 
 <td> 1、Aspect Oriented Programming（面向切面编程） 2、找出多个类中有一定规律的代码，开发时拆开，运行时在合并 3、面向切面编程，即面向规则编程。 </td> 
 <td> 解耦，专人做专事 </td> 
 </tr> 
 <tr> 
 <td> OOP </td> 
 <td> 1、Object Oriented Programming（面向对象编程） 2、归纳总结生活中一切事物 </td> 
 <td> 封装、继承、多态 </td> 
 </tr> 
 <tr> 
 <td> BOP </td> 
 <td> 3、Bean Oriented Programming（面向bean编程） 4、面向Bean（普通的java类）设计程序 </td> 
 <td> 一切从Bean开始 </td> 
 </tr> 
 <tr> 
 <td> IOC </td> 
 <td> 1、Inversion of Control（控制反转） 2、将new对象的动作交给Spring管理，并由Spring（ioc容器）保存创建的对象 </td> 
 <td> 转交控制权（即控制权反转） </td> 
 </tr> 
 <tr> 
 <td> DI/DL </td> 
 <td> 1、Dependency Injection（依赖注入）/Dependency Lookup（依赖查找）2、依赖注入、依赖查找、Spring 不仅保存自己创建的对象，而且保存对象与对象之间的关系3、注入即赋值，主要三种方式：构造方法，set方法，直接赋值 </td> 
 <td> 先理清关系再赋值 </td> 
 </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
 <tr> 
 <td> 设计模式 </td> 
 <td> 应用场景（Design Patterns） </td> 
 <td> 一句话归纳 </td> 
 </tr> 
 <tr> 
 <td> 代理模式 &nbsp; proxy </td> 
 <td> 1、两个角色：执行者（代理人）、被代理人 2、对于被代理人来说，这件事是一定要做的，但是我自己又不想做或者没有时间做，找代理‘ 3、代理人必须获得被代理人的个人资料（持有被代理人的引用） </td> 
 <td> 办事要求人，所以找代理 </td> 
 </tr> 
 <tr> 
 <td> 工厂模式 &nbsp; Factory </td> 
 <td> 对于调用者来说，隐藏了复杂的逻辑处理，调用者只关心结果 2、对于工厂来说要对结果负责。保证生产出符合规范的产品 </td> 
 <td> 只对结果负责，不要三无结果 </td> 
 </tr> 
 <tr> 
 <td> 单例模式 &nbsp; Singleton </td> 
 <td> 1、保证从系统启动到系统终止，全过程只会产生一个实例 2、当我们在应用中遇到功能性冲突的时候，需要使用单例模式 </td> 
 <td> 保证独一无二 </td> 
 </tr> 
 <tr> 
 <td> 委派模式 &nbsp; Delegate </td> 
 <td> 1、两个参与角色：委托人和被委托人 2、委托人和被委托人在权利上完全平等（即实现同一个接口） 3、委托人持有被委托人的引用 4、不关心过程，只关心结果 </td> 
 <td> 干活是你的（普工） 功劳是我的（领导） </td> 
 </tr> 
 <tr> 
 <td> 策略模式 &nbsp; Strategy </td> 
 <td> 1、最终执行结果是固定的 2、执行过程和执行逻辑不一样 </td> 
 <td> 我行我素，达到目的就行 </td> 
 </tr> 
 <tr> 
 <td> 原型模式 &nbsp; Prototype </td> 
 <td> 1、首先有一个原型 2、数据内容相同，但对象实例不同（完全两个不同的内存地址）{clone克隆} </td> 
 <td> 拔出一根猴毛，吹出千万个 </td> 
 </tr> 
 <tr> 
 <td> 模板模式 </td> 
 <td> 1、执行流程固定，但中间有些步骤有细微差别 2、可实现批量生产 </td> 
 <td> 流程标准化，原料自给加 </td> 
 </tr> 
 </tbody> 
</table>

### **SpringMVC的初始化跟运行过程** ###

Servlet里面可以拿到：Request，Response，doService（请求类型，get，post）、参数

*  初始化

1.  web.xml 配置一个DispatchServlet（启动的入口）须知：实现了Awaer接口，就能得到ApplicationContext
2.  默认加载我们的IOC容器（ApplicationContext）就可以使用容器里面的对象了
3.  开始扫描springMvc的配置（扫描注解（扫描controller，requestMapper），view的配置，拦截器，转换器，视图解析器）
4.  解析成一个HandlerMapper（主要是保存了url跟具体的执行的方法（mathod）的对应关系）的List

*  用户请求的过程：

1.  从浏览器输入URL
2.  统一拦截（扫描HandlerMapper），如果是404/500/
3.  DispatchServlet接收到请求从上面初始化已经保存的数据中找到请求url对应的方法,然后调用
4.  把响应结果输出

流程图片：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMDM3NDc4_size_16_color_FFFFFF_t_70 1][]

### springMVC出现 ###

**Servlet做法**

从web.xml文件开始

在这个文件连配置了N个Servlet，一般而言一个Servlet对应一个url，以后要增加功能，增加url，每次都需要去修改配置文件，增加 Servlet配置，将导致配置膨胀，代码膨胀

MVC：视图和java逻辑分离（隔离配置）

JSP：归根结底还是一个Servlet，只不过是自动生成了HTML代码而已，JSP里面还可以写java代码<% 甚至把sql写在jsp里面了 %>

**WebWork**

增加需求，增加url，不需要频繁修改we.xml，只需要增加class就行

支持模版化开发，渐渐的把JSP退出历史舞台

freeMark（自己的语法，不能写java代码，支持标签）

**struts2:**

增加需求，增加url，不需要频繁修改we.xml，只需要增加class就行

支持模版化开发，渐渐的把JSP退出历史舞台

freeMark（自己的语法，不能写java代码，支持标签）

Model进行了一次很好的封装，可以将请求后面的参数自动转换成普通话的java对象（自动赋值）

From（提交过来的数据），Action（管理url）

一个From对应一个action（成对出现，无形中增加了代码量）

**SpringMVC出现：**

URL映射，进行了改进（基于方法，一个方法对应一个url）

Model：不强制要求（写Form），可以作为一个方法的参数（自动转换）

View的支持：能支持JSP，FreeMark，Velocity，支持任意扩展

Spring牛逼之处：制定规范，只要你实现了Spring规范

[20200404202023867.png]: /images/20230528/9b1aed2ac04e48b191d6b913fb478344.png
[2020040420203446.png]: /images/20230528/e4e95882575246b7bd260fb682e9b2ec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMDM3NDc4_size_16_color_FFFFFF_t_70]: /images/20230528/5a586ffd643e4363a0cd773a1b7c2b76.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMDM3NDc4_size_16_color_FFFFFF_t_70 1]: /images/20230528/e5c4146fe52d46a59da3798c1290a66a.png