【视频笔记】Spring（狂神）

文章目录

• Spring
• 1. Spring简介
• • 介绍
  • 下载
  • 导入
  • 优点
• 2. Spring的组成和拓展
• • 七大模块
  • 缺点
• 3. IOC理论推导
• • 介绍
• 4. IOC本质
• • 逻辑
• 5. HelloSpring
• • 代码验证
  • bean
  • 概念
  • 底层源码
  • • 完整路径
  • 什么是IOC
  • 属性赋初值
  • 使用
• 6. IOC创建对象的方式
• • 是在什么地方new的？
  • 使用步骤
  • 如何使用有参构造方法
  • 总结
• 7. Spring配置说明
• • 别名
  • Bean的配置
  • import
• 8. DI ： 依赖注入环境
• • 注入方式
  • set注入
  • 可以注入的类型
  • 代码
• 9. 依赖注入之set注入
• 10. c命名和p命名空间注入
• • p命名空间
  • • 测试
  • c命名空间
• 11. Bean的作用域
• • 单例
  • 原型
  • Web里的几个
• 12. 自动装配Bean
• • 自动装配
  • 三种自动装配方式
  • 自动装配代码
  • • XML中显式
    • 自动装配
  • 总结
• 13. 注解实现自动装配
• • 注解须知
  • 注入
  • 总结
• 14. Spring注解开发
• • bean
  • 属性如何注入
  • 衍生的注解
  • 自动装配的注解
  • 作用域
  • 小结
• 15. 使用JavaConfig实现配置
• • Config类
• 16. 回顾
• 17. 静态代理模式
• • 代理模式
  • • 介绍
  • 静态代理
  • • 四大角色，分析
    • 代码
    • 代理模式的分析
    • • 好处
      • 缺点
• 18. 静态代理再理解
• • 集中管理公共业务
  • 面向切面
• 19. 动态代理详解
• • 如何改变缺点
  • 动态代理介绍
  • InvocationHandler
  • Proxy
  • 代码，动态生成代理
  • • 步骤
    • 具体操作
    • 可以写一个任意的处理类
  • 总结动态代理
• 20. AOP实现方式一
• • 什么是AOP
  • AOP在Spring的作用
  • 名词解释
  • 使用Spring实现AOP
  • Log类为例
• 21. AOP实现方式二：自定义类
• • AOP实质
  • AOP实现
  • AOP在Spring中的作用
  • 总结两种方式
• 22. 方式三：注解实现AOP
• • 配置
  • before
  • 注册
  • around
  • 执行顺序
  • 总结
• 23. 回顾MyBatis
• • 步骤
  • 回忆Mybatis
• 24. 整合MyBatis，方式一
• • 为什么要用 MyBatis - Spring
  • 配置
  • 使用
  • 总结，哪些MyBatis的部分被摒弃了
  • • 核心是
• 25. 整合MyBatis，方式二
• 26. 事务回顾
• • 事务介绍
  • 代码实现
• 27. Spring中的事务
• • 两种事务介绍
  • • 编程式事务
    • 声明式事务：AOP
  • 使用声明式事务
  • • 结合AOP，实现事务的织入
    • 配置事务本身的特性
    • 配置AOP，把配置好的事务切入进去类和方法

Spring

先把自己的目标总结在前面，尽量快的学

1. 概念
2. 注意点
3. 几个关键点

1. Spring简介 介绍

1. new的对象被简化没了
2. 什么是框架，相当于一个模版
3. 是个大杂烩

下载 导入 优点

1. 开源免费的容器（框架）
2. 轻量级、非入倾式的
3. 控制反转（IOC）、面向切面编程（AOP）
4. 支持事务的处理，整合了很多内容，大杂烩

2. Spring的组成和拓展 七大模块

1. 内核
2. AOP
3. ORM ，对象关系，映射 MyBatis
4. DAO
5. Web
6. Context
7. Spring MVC

缺点

1. 配置太繁琐

3. IOC理论推导 介绍

1. IOC是一种思想
2. 传统开发
   1. 接口+实现类
      1. Dao层
      2. 业务层
      3. 用户
   2. 三层架构
      1. 每次加一个功能要写三个层的类
3. 如何解决这个问题
   1. 设计模式 - 能不能程序不变，调用变化
   2. 设置接口，set方法
4. 前者，程序主动创建对象
5. 后者，使用set注入，程序不需要变，谁调用也不用改
6. 结论
   1. 程序员不用管理对象的创建(new)
   2. 耦合性大大降低
   3. 更专注于业务实现
7. 控制反转：控制权的问题，不交出去
   1. 只有使用权

4. IOC本质 逻辑

1. 以前的开发模式
   1. 用户访问业务层
   2. 主动权在业务层
   3. 业务层访问具体类
   4. 具体类不论怎么改，用户是不用变
   5. 主动权在业务层，业务层选择具体类
   6. 硬编码
2. 现在的开发模式，主动权在用户
   1. 用户只需要实现具体类
   2. 第三方
3. 两层的联系，现在变成了一个接口
   1. 弱化了联系

5. HelloSpring 代码验证

1. 看不到new
2. 写出一个实体类
3. XML/注解 来配置
   1. 相当于一个容器
   2. 使用Spring来创建对象
   3. 对象称为bean
4. 直接使用
   1. 对象都在Spring中管理了
   2. 直接取出来
   3. 相当于从容器取出来

bean

1. id相当于变量名
2. class相当于new的对象
3. property相当于给对象中的属性设置值

概念

1. 以上整个过程称为控制反转
2. 控制
   1. 谁来控制对象的创建：Spring
3. 反转
   1. 程序不创建对象，变为接受对象
4. 依赖注入
   1. 利用set方法来注入的
   2. set方法去掉之后就报错

底层源码

ApplicationContext context =
new ClassPathXmlApplicationContext(“xml文件名”)

1. new 的是 ClassPathXmlApplicationContext
2. 怎么变成的 ApplicationContext

完整路径

1. 继承，继承，继承，继承，继承，实现了一个接口

什么是IOC

1. 对象由Spring创建、管理、装配

属性赋初值

1. 属性名：property
2. 对象类型的值：ref
3. value：基本数据类型

使用

1. get方法就行

6. IOC创建对象的方式 是在什么地方new的？

1. 在getBean方法时候

使用步骤

1. 每写一个类就丢入xml中
   1. 属性再注入
2. 拿到容器
3. get方法

如何使用有参构造方法

1. 默认是午餐构造方法
2. 如何使用有参构造
3. 方式1，参数的位置
   1. constructor-arg
   2. index（位置）
   3. value 值
4. 方式2，参数的类型
   1. constructor-arg
   2. type
   3. value
5. 方式3，直接通过参数名
   1. constructor-arg
   2. name
   3. value

总结

1. 在配置文件初始化时
2. 对象就被初始化了

7. Spring配置说明

1. 按下<，自己弹出的

别名

1. 多个名字
2. 相当于对象的名字
3. 一样用

Bean的配置

1. id : bean的唯一标识符，相当于对象名
2. class : bean对象对应的类型
3. name ： 也是别名，和有参构造不一样
   1. 可以取多个别名
   2. 可以用分隔符，逗号、分号
4. scope ：默认是单例

import

1. 一般用于团队开发
2. 把多个配置文件导入合并为一个
3. 可以导入多个beans.xml

8. DI ： 依赖注入环境 注入方式

1. 构造器
2. set【重点】
3. 拓展方式

set注入

1. 依赖：bean对象的创建依赖于容器
2. 注入：bean对象的所有属性，由容器注入

可以注入的类型

1. 普通类型
   1. value
2. 对象类型（引用类型）
   1.
3. List
4. Map
5. Set
6. 配置类 Properties
7. 空指针

代码

1. 在类中声明这些
2. 设置set方法
3. 注入 -> 具体注入

9. 依赖注入之set注入

1. 普通注入
   1. value，
   2. 可以放在单个标签内部<内部>
   3. 也可以放在标签对，的里面
2. 对象注入
   1. ref=
   2. bean的名字
3. 数组注入
   1. property，是大大名字
   2. 在property标签的里面
   3. array
      1. 每一个是value
      2. 或者bean
4. List注入
   1. 同数组
5. Map
   1. < entry
   2. 里面是key 和 value
6. Set
   1. 只有一个value
7. null
   1. 直接< null >
8. Properties
   1. props
      1. prop
      2. key在< 里面 >
      3. value在外面
   2. driver
   3. url等

10. c命名和p命名空间注入

1. 是拓展
2. 导入一些约束，导入别的命名空间

p命名空间

1. 导入p 的 namespace
2. p:名字=值
3. 是直接注入
4. 相当于property

测试

1. 导入junit包
2. 拿到容器
3. 打点来get

c命名空间

1. 导入c 的 namespace
2. c:名字=值
3. 是构造器，相当于construct-args

11. Bean的作用域 单例

1. 不论几个Dao，只有一个Bean
2. 不论getBean几个

原型

1. 每次getBean不一样
2. 打印hashCode

Web里的几个

1. request
2. session
3. application

12. 自动装配Bean 自动装配

1. 不需要设置，也能找到
2. Spring满足Bean依赖的一种方式
3. Spring会在上下文中自动寻找并自动装配属性

三种自动装配方式

1. XML中显式
2. 在Java中显式
3. 隐式的自动装配

自动装配代码 XML中显式

1. 创建项目
   1. 三个实体类
   2. dog
      1. 有shout方法
   3. cat
      1. 有shout方法
   4. people
      1. 拥有cat和dog和name
2. XML文件
   1. 注入三个类，和类的属性
3. 测试
   1. 只需要new一次，new获取容器的东西

自动装配

1. 在bean的属性里加一个autowire
   1. byName
   2. byType
2. byName
   1. 会自动在容器里找和set名字
   2. 相同的名字
3. byType
   1. 和自己对象属性相同的

总结

1. byName
   1. 要bean的id唯一
   2. 这个bean和注入的属性名字一致
2. byType
   1. 要bean的class唯一
   2. 这个bean和注入的属性类型一致

13. 注解实现自动装配 注解须知

1. 导入约束
   1. 加一个命名空间
   2. 最后面加上4句
2. 配置上加上个支持

注入

1. 在属性的上面一行
   1. 加上@AutoWired
   2. 也可以在set方法上面一行用
   3. 甚至可以不需要set方法（因为是靠反射）
2. 科普
   1. @NUllable加在参数前
      1. 这个字段可以为null
   2. 加参数
      1. @AutoWired(null)
3. 如果自动装配的环境比较复杂 无法通过一个注解完成
   1. @Qualifier(value=“”)
   2. 名字要一致
4. @Resource
   1. 先通过id来找，名字
   2. 再通过class找，包
   3. 有多个时
      1. 指定装配
      2. (value=“名字”)

总结

1. @AutoWired和@Resource的区别
   1. 都是用来自动装配
   2. 都可以放在属性的上面一行
   3. @AutoWired通过byName
   4. @Resource
      1. 默认byName（先），找不到会用byType（后）
      2. 找不到才报错
   5. 如果不能为一对应名字
      1. 用@Qualifier

14. Spring注解开发

1. 在Spring4之后，想使用注解，必须导入AOP包
2. 注解没用时要检查AOP包
3. 使用注解要导入约束
   1. 加上支持
   2. 扫描所在包用到的注解

bean

1. 使用@Component
   1. 装配
   2. 配置文件中就不需要< bean
   3. 也相当于new了一下

属性如何注入

1. 使用@Value（“值”）
   1. 相当于< property
   2. 也可以放在set方法上面一行

衍生的注解

1. @Component有几个衍生的注解
2. 按照mvc三层架构分层
3. dao层
   1. @Repository
   2. 也相当于@Component
   3. 但是Dao层习惯用@Repository
4. service层
   1. @Service
5. controller层
   1. @Controller

自动装配的注解

上一章

作用域

1. Scope
   1. 单例 ： singleton
   2. 原型 ： prototype

小结

1. XML更加万能，维护方便
2. 注解：不是自己的类，维护不了
3. 最佳实践
   1. xml用来管理bean
   2. 注解只用来属性
   3. 使用过程只需要注意
      1. 注解支持不要忘记
      2. 否则注解不生效

15. 使用JavaConfig实现配置

1. 可以使用java配置类，来等价于xml
2. 还比xml更加灵活

Config类

1. 在类名上方加上@Configuration
2. 类里面写上get方法
   1. 加上注解@Bean，就相当于之前写的一个bean标签
      1. 方法的名字，相当于标签中的id
      2. 返回值，相当于标签中的class，就是要注入的对象
   2. 也可以扫描@ComponentScan(“包”)
3. 再去要被注入的Bean里
   1. 加上注解@Component
4. 使用，获取容器
   1. 只能通过
   2. ApplicationContext =
   3. AnnotationConfig 上下文来获取来容器
   4. 参数为Class对象
5. xml中的import标签
   1. 注解 @import(类)

16. 回顾 17. 静态代理模式 代理模式 介绍

1. 设计模式
2. 是Spring AOP的底层
3. 分为静态代理
4. 和动态代理

静态代理 四大角色，分析

1. 抽象角色
   1. 接口
2. 真实角色
   1. 被代理的角色
3. 代理角色
   1. 附属操作
4. 客户
   1. 访问代理对象的人

代码

1. 操作
   1. 租房
   2. 是一个接口
2. 真实角色
   1. 房东
   2. 实现了接口
3. 代理角色
   1. 房东作为属性
      1. 有初始化的操作
   2. 实现操作接口
      1. 调用真实角色的操作
      2. 还可以有很多别的操作
4. 客户

代理模式的分析 好处

1. 可以使真实角色更纯粹
   1. 不用关心公共业务
   2. 公共业务交给代理
2. 公共业务发生扩展时方便集中管理
3. 降低耦合

缺点

1. 一个真实角色就会产生一个代理角色
2. 开发效率低

18. 静态代理再理解 集中管理公共业务 面向切面

1. 原来是纵向的开发
   1. 一条竖线
2. 现在是从侧面横切进来一个
   1. 另外一条竖线

19. 动态代理详解 如何改变缺点

1. 通过反射
2. 动态加载一个类

动态代理介绍

1. 动态代理的底层都是反射
2. 代理类是动态生成的
3. 动态代理分为两大类
   1. 基于类
      1. cglib
   2. 基于接口
      1. JDK的动态代理
   3. 目前还有java字节码
      1. 直接用java编码
      2. javasist
4. 需要了解两个类
   1. Proxy
   2. InvocationHandler
      1. 调用处理程序

InvocationHandler

1. 是reflect（反射包）下的接口
2. 每个代理都有调用处理程序
   1. 这个类通过代理实例来生成调用处理程序
3. 在代理实例调用方法时
   1. 方法会被发送到调用处理程序
4. 只有invoke方法
   1. 参数
   2. proxy：你要代理谁
   3. method：代理他的什么方法
   4. 一些参数：一般是个固定的

Proxy

1. 静态方法（打点）可以创建动态代理类
2. 如何使用
   1. 先InvocationHandler接口
   2. 获取一个代理类
3. 方法

代码，动态生成代理 步骤

1. 实现InvocationHandler接口
   1. 处理代理实例，并返回接口
   2. 用来处理
2. 生成代理类
   1. Proxy

具体操作

1. 生成代理类
   1. 定义一个生成代理类的方法
   2. Proxy.newProxyInstance
      1. 参数1，获得反射出来对象的类加载器
      2. 参数2，new一个被代理的接口（操作）
      3. 第三个参数，实现的InvocationHandler接口
2. 在处理类中处理操作
   1. method.invoke()
      1. 参数
      2. 用invoke来执行方法（操作）
3. 加一些操作
   1. 在处理类中加一些操作
4. 在定义一个客户类，来使用
   1. 真实角色，出来
   2. 代理角色，现在没有，想办法生成
      1. 生成 代理角色的处理类
      2. 通过处理类来处理代理角色要做事
      3. 然后在通过处理类里的方法生成代理类
5. 总结具体操作
   1. 没有自己写代理类
   2. 是通过代理类的处理程序来完成

可以写一个任意的处理类

1. 可以处理任何类，属性里的实体类对象类型是Object
   1. 用setTarget来设置实体类
2. 公共方法如何加
   1. 在处理类里加一个获取方法，的方法
   2. invoke里调用该方法
      1. 获得方法

总结动态代理

1. 一个动态代理代理的是一个接口
   1. 一般是一类业务
2. 一个动态代理类代理可以多个类，只要实现了接口

20. AOP实现方式一 什么是AOP

1. 面向切面编程
   1. 加一个功能
   2. 不能改变原有的业务
2. 规范化的动态代理

AOP在Spring的作用

1. 写一个切面类

名词解释

1. 横切关注点
2. 切面
3. 通知
4. 目标
5. 代理
6. 切入点
7. 连接点
8. 五种类型的Advice对比册

使用Spring实现AOP

1. 导入包
2. 接口类
3. 实现类
4. 动态代理类-替换成Spring来使用
   1. 定义一个Log类

Log类为例

1. 实现接口，选择接口根据Advice是前置后置/环绕来决定
2. 对应实现的方法
   1. 参数
   2. method，对应要执行的目标对象的方法
   3. object，参数
   4. target，目标对象
3. before的实现方法
   1. 会在方法执行前自动调用
4. AfterReturning
   1. 执行后，拿到返回值，再执行该方法
5. 写入Resource中的xml
   1. 注册bean
      1. 三个类
      2. 实现类
      3. before
      4. after
   2. 配置aop
      1. 引入头文件，
      2. 导入aop的约束（命名空间）
   3. 切入点
      1. pointcut
      2. expression=execution()
         1. 代表插入的位置，哪个点
   4. 执行环绕
      1. advisor
      2. 引用ref了 , 上方的log
6. 测试
   1. 获取ClassPath
   2. getBean
   3. 动态代理代理的是接口

21. AOP实现方式二：自定义类 AOP实质

1. AOP就是为了将核心代码和非核心代码分离
2. 在核心代码切入非核心代码
3. 项目中体现在：完成事务和日志的记录

AOP实现

1. 自定义类
2. 绑定bean，取个别名，输入完整包路径
3. < aop:config>标签
   1. 里面加上 < aop:aspect> 标签
   2. 是切面
   3. ref就是引用
4. 如何切入
   1. 切入点：类中的一个方法
      1. 语法：五个部分
   2. < aop:before
   3. < aop:after
   4. < aop:其他

AOP在Spring中的作用

1. 允许自定义切面

总结两种方式

1. Spring的API
2. 自定义类，主要是切面定义

22. 方式三：注解实现AOP 配置

1. 方式2是在配置文件中配置
2. 现在直接在类的上面一行加一个@Aspect

before

1. 在类中的方法上面一行加上@before(“”)
2. ""中写切入点
3. execution(“”)
   1. 切入点语法

注册

1. 注册bean
2. 开启注解支持
   1. < aop:aspect-autoproxy>

around

1. 可以给定一个参数，作为连接点
2. 连接点：与切入点匹配的连接点
   1. 可以从切入点里拿到一些东西
   2. 相当于加了一层，可以在一层里在做一些处理

执行顺序

1. 环绕前最先执行
2. 方法执行前，before
3. 方法执行
4. 环绕后
5. 方法执行后，after

总结

1. AOP的三种实现方式

23. 回顾MyBatis 步骤

1. 导入jar包
   1. junit
   2. MyBatis
   3. mysql
   4. Spring相关
   5. aop
   6. MyBatis - Spring
      1. 专用于整合
      2. 使用最新的，取决于mybatis 和 Spring版本
2. 写配置文件
3. 测试

回忆Mybatis

1. 编写实体类
2. 编写核心配置文件
3. 编写接口
4. 编写Mapper
5. 测试

24. 整合MyBatis，方式一 为什么要用 MyBatis - Spring

1. MyBatis的事务很笨重
2. 可以用Spring横切

配置

1. 引入一个配置文件
2. 配置几个对象
   1. MyBatis的几个对象
3. dataSource
   1. jdbc等的配置文件
   2. 参数property有
   3. url
   4. username等
4. sqlSessionFactory
   1. 参数property有
   2. dataSourMyBatis-config.xml里的内容
5. sqlSession
   1. class是sqlSessiontemplate
   2. 没有set方法
   3. 但是有构造方法
   4. 使用构造器注入
6. 进入实现类
   1. 现在sqlSession全部换成sqlSessionTemplate
7. 把该实现类注入bean

使用

1. 只new一次
2. 用new出来的，getBean

总结，哪些MyBatis的部分被摒弃了

1. 数据源
2. sqlSessionFactory
3. sqlSessionTemplate
4. import一个MyBatis配置的的xml文件
   1. 是注册在bean里
   2. 也不需要改了
5. 多了一个实现类
   1. 只能手动写set方法
   2. 来写select等操作
   3. 注入该类

核心是

1. sqlSessionFactory
2. sqlSessionTemplate

25. 整合MyBatis，方式二

##替换掉sqlSessionTemplate的部分

1. 使用一个类
2. 继承一个类
3. get方法就可以获得sqlSession

26. 事务回顾 事务介绍

1. 要么都成功 要么都失败
2. 涉及到数据一致性 、 完整性
3. ACID原则
   1. 原子性：一堆当成一个
   2. 一致性：要么全成功
   3. 隔离性：多个业务操作同一个资源，防止数据损坏
   4. 完整性：事务提交之后，就被持久化了

代码实现

1. 整合MyBatis
2. 加入一组业务
   1. 添加一个用户
   2. 删除一个用户
3. 变成一组事务
   1. add
   2. delete，SQL语句故意写错
4. 调用方法
5. 出错，add竟然也能成功？
6. 显然这是不行的

27. Spring中的事务 两种事务介绍 编程式事务

1. 手动写try catch
2. 如果try里面出错，在catch中回滚

声明式事务：AOP

1. 横切进去的
2. 不影响代码

使用声明式事务

1. 在配置文件中加入
   1. 在bean中注入事务管理器的类
2. 使用横切的方式加入

结合AOP，实现事务的织入

1. 找一个切入点/切面 - 配置切面

配置事务本身的特性

1. 配置事务的类
   1. < tx：advice >标签
   2. namespace的约束
2. 标签内：给哪些方法配置事务
   1. 加入标签
   2. < tx:method name=“add”>
   3. < tx:method name=“*”>
3. 配置事务的传播特性
   1. 在方法的标签内加入
   2. timeout 超时
   3. 只读
      1. 不对数据库增删改
      2. 放在query里
   4. 回滚等
   5. 传播
4. 传播特性 propagation=“REQUIRED”

配置AOP，把配置好的事务切入进去类和方法

1. 切入点
2. 切入
   1. < aop:advisor
3. 没有改变源代码，直接测