深入了解Spring

Spring学习目录
一、Spring的介绍
二、Spring常用的设计模式
三、IOC（容器/控制反转）
四、AOP（面向切面）
五、DI（依赖注入）
 

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

二、Spring常用的设计模式
1. 工厂设计模式（简单工厂和工厂方法）

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

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

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

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

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 缓存

总结：
Spring思想

应用场景（特点）

一句话归纳

AOP

1、Aspect Oriented Programming（面向切面编程）

2、找出多个类中有一定规律的代码，开发时拆开，运行时在合并

3、面向切面编程，即面向规则编程。

解耦，专人做专事

OOP

1、Object Oriented Programming（面向对象编程）

2、归纳总结生活中一切事物

封装、继承、多态

BOP

3、Bean Oriented Programming（面向bean编程）

4、面向Bean（普通的java类）设计程序

一切从Bean开始

IOC

1、Inversion of Control（控制反转）

2、将new对象的动作交给Spring管理，并由Spring（ioc容器）保存创建的对象

转交控制权（即控制权反转）

DI/DL

1、Dependency Injection（依赖注入）/Dependency Lookup（依赖查找）2、依赖注入、依赖查找、Spring 不仅保存自己创建的对象，而且保存对象与对象之间的关系3、注入即赋值，主要三种方式：构造方法，set方法，直接赋值

先理清关系再赋值

设计模式

应用场景（Design Patterns）

一句话归纳

代理模式

proxy

1、两个角色：执行者（代理人）、被代理人

2、对于被代理人来说，这件事是一定要做的，但是我自己又不想做或者没有时间做，找代理‘

3、代理人必须获得被代理人的个人资料（持有被代理人的引用）

办事要求人，所以找代理

工厂模式

Factory

对于调用者来说，隐藏了复杂的逻辑处理，调用者只关心结果

2、对于工厂来说要对结果负责。保证生产出符合规范的产品

只对结果负责，不要三无结果

单例模式

Singleton

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

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

保证独一无二

委派模式

Delegate

1、两个参与角色：委托人和被委托人

2、委托人和被委托人在权利上完全平等（即实现同一个接口）

3、委托人持有被委托人的引用

4、不关心过程，只关心结果

干活是你的（普工） 功劳是我的（领导）

策略模式

Strategy

1、最终执行结果是固定的

2、执行过程和执行逻辑不一样

我行我素，达到目的就行

原型模式

Prototype

1、首先有一个原型

2、数据内容相同，但对象实例不同（完全两个不同的内存地址）{clone克隆}

拔出一根猴毛，吹出千万个

模板模式

1、执行流程固定，但中间有些步骤有细微差别

2、可实现批量生产

流程标准化，原料自给加

SpringMVC的初始化跟运行过程
Servlet里面可以拿到：Request，Response，doService（请求类型，get，post）、参数

初始化
web.xml 配置一个DispatchServlet（启动的入口）须知：实现了Awaer接口，就能得到ApplicationContext
默认加载我们的IOC容器（ApplicationContext）就可以使用容器里面的对象了
开始扫描springMvc的配置（扫描注解（扫描controller，requestMapper），view的配置，拦截器，转换器，视图解析器）
解析成一个HandlerMapper（主要是保存了url跟具体的执行的方法（mathod）的对应关系）的List
用户请求的过程：
从浏览器输入URL
统一拦截（扫描HandlerMapper），如果是404/500/
DispatchServlet接收到请求从上面初始化已经保存的数据中找到请求url对应的方法,然后调用
把响应结果输出
流程图片：

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规范