# SpringStudy
**Repository Path**: hehehehe111/spring-study
## Basic Information
- **Project Name**: SpringStudy
- **Description**: SpringStudy
- **Primary Language**: Java
- **License**: GPL-3.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No
## Statistics
- **Stars**: 0
- **Forks**: 1
- **Created**: 2021-03-24
- **Last Updated**: 2022-06-18
## Categories & Tags
**Categories**: Uncategorized
**Tags**: None
## README
# SpringStudy
#### 介绍
SpringStudy
# 1、Spring
## 1.1、简介
- Spring
## 1.2、优点
- Spring是一个开源免费容器
- Spring是一个轻量级的，非入侵式的框架
- 控制反转（IOC）、面向切面编程（AOP）
- 支持事务的处理，对框架整合的支持
总结：Spring就是一个轻量级的控制反转和面向切面编程的框架
## 1.3、组成
## 1.4、拓展
- SpringBoot
- 一个快速开发的脚手架
- 基于SpringBoot可以快速开发单个微服务
- 约定大于配置
- Spring Cloud
- 基于SpringBoot实现的
# IOC理论推导
1. UserDao接口
2. UserDaoImpl实现类
3. UserService业务接口
4. UserServiceImpl业务实现类
在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据需求更改代码，代码量十分大，修改一次成本昂贵。
我们使用一个Set接口实现
这种思想，从本质上解决了问题，程序员不用再去管理对象的创建了
## **IOC本质**
# 3、HelloSpring
# 4、IOC创建对象的方式
1. 使用无参构造创建对象，默认！
2. 假设使用有参构造创建对象
1. 下标赋值
```xml
```
2. 通过类型创建
```xml
```
3. 直接通过参数名
```xml
```
总结：在配置文件加载的时候，容器中管理的对象就已经初始化了！
# 5、Spring配置
## 5.1、别名
```xml
```
## 5.2、Bean的配置
## 5.3、import
# 6、DI（Dependency Injection）依赖注入
## 6.1、构造器注入
前面说过了
## 6.2、set方式注入【重点】
- 依赖注入：Set注入
- 依赖：bean对象的创建依赖于容器
- 注入：bean对象中的所有属性，由容器来注入
【环境搭建】
1. 复杂类型
```java
package com.hxz.pojo;
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
```
2. 真实测试对象
```java
public class Student {
private String name;
private Address address;
private String[] books;
private List hobbies;
private Map card;
private Set games;
private Properties info;
private String wife;
}
```
3. beans.xml
```xml
```
4. 测试类
```java
import com.hxz.pojo.Student;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
@Test
public void test11121() {
ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
Student student = (Student) ac.getBean("student");
System.out.println(student.getName());
}
}
```
完善注入信息
```xml
红楼梦
西游记
水浒传
三国演义
听歌
看电影
敲代码
LOL
COC
BOB
111
男
哈哈
```
## 6.3、拓展方式注入
```xml
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
```
## 6.4、Bean作用域
# 7、Bean的自动装配
- 自动装配是Spring满足bean依赖的一种方式！
- Spring会再上下文中自动寻找，并自动给bean装配属性
再spring中有三种装配方式
1. 再xml中显示的配置
2. 再java中显示配置
3. 隐式的自动装配【重要】
## 7.1、测试
环境搭建：一个人有两只中午
## 7.2、ByName自动装配
```xml
```
## 7.3、ByType
```xml
```
## 7.4、使用注解开发
**@Autowired**
直接再属性上使用即可，也可以再set方法上使用
使用Autowired我们可以不用编写set方法了，前提是你这个自动装配的属性再IOC容器中存在，且符合名字ByName
# 8、使用注解开发
在Spring4之后，要使用注解开发，必须要保证aop的包导入了。
使用注解需要导入context约束，增加注解的支持
```xml
```
1. bean
2. 属性如何注入
```java
package com.hxz.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
//等价于在注册了个bean
@Component
public class User {
@Value("哈哈")
public String name;
}
```
3. 衍生的注解
@Component有几个衍生的注解，我们在web开发中，会按照mvc三层架构分层
- dao 【@Repository】
- service 【@Service】
- controller 【@Controller】
这四个注解的功能都是一样的，都是代表将某个类注册到Spring中，装配Bean
4. 自动装配
```md
@Autowired：自动装配通过类型、名字
如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value="xxx")
@Nullable：字段标记了这个注解，说明这个字段可以为空
@Resource：自动装配通过名字、类型
```
5. 作用域
```java
@Scope("prototype")
```
6. 小结
xml与注解：
- xml更加万能，适用于任何场合，维护简单方便
- 注解不是自己的类用不了，维护相对复杂
最佳实践：
- xml用来管理bean
- 注解只负责完成属性的注入
- 我们在使用的过程中，只需要注意一个问题：必须让注解生效，就需要开启注解的支持
# 9、使用Java的方式配置Spring
我们现在要完全不适应spring的xml配置，全权交给java。
JavaConfig是Spring4的一个子项目，在spring4之后，变成了一个核心功能。
实体类
配置
测试
# 10、代理模式
为什么要学习代理模式？因为这就是SpringAOP的底层！【SpringAOP和SpringMVC】
代理模式的分类：
- 静态代理
- 动态代理
## 10.1、静态代理
角色分析：
- 抽象角色：一般会使用接口或者抽象类来解决
- 真实角色：被代理的角色
- 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
- 客户：访问代理对象的人
代码步骤：
1. 接口
```java
package com.hxz.demo01;
//租房
public interface Rent {
public void rent();
}
```
2. 真实角色
```java
package com.hxz.demo01;
//房东
public class Host implements Rent{
public void rent() {
System.out.println("RENTRENTRENT");
}
}
```
3. 代理角色
```java
package com.hxz.demo01;
public class Proxy implements Rent{
private Host host;
public Proxy() {
}
public Proxy(Host host) {
this.host = host;
}
public void rent() {
seeHouse();
host.rent();
hetong();
fare();
}
//看房
public void seeHouse() {
System.out.println("中介带你去看房！");
}
//签合同
public void hetong() {
System.out.println("签租赁合同！");
}
//收中介费
public void fare() {
System.out.println("收中介费！");
}
}
```
4. 客户端访问代理角色
```java
package com.hxz.demo01;
public class Client {
public static void main(String[] args) {
//房东要租房子
Host host = new Host();
//代理，中介德邦房东租房子，但是你，代理觉得一般会有一些附属操作
Proxy proxy = new Proxy(host);
//你不用面对房东，直接找中介租房即可
proxy.rent();
}
}
```
代理模式的好处：
- 可以使真实角色的操作更加纯粹，不用去专注一些公共的业务。
- 公共业务九交给了代理角色，实现了业务的分工。
- 公共业务发生拓展的时候，方便几种管理。
缺点：
- 一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率低。
## 10.2、加深理解
## 10.3、动态代理
- 动态代理和静态代理角色一样
- 动态代理的代理类使动态生成的，不是我们直接写好的
- 动态代理分为两大类：基于接口的动态代理、基于类的动态代理
- 基于接口：JDK动态代理
- 基于类的：cglib
- java字节码实现：javasist
需要了解两个类：Proxy、InvocationHandler：调用处理程序
动态代理的好处：
- 可以使真实角色的操作更加纯粹，不用去专注一些公共的业务。
- 公共业务九交给了代理角色，实现了业务的分工。
- 公共业务发生拓展的时候，方便几种管理。
- 一个动态代理类代理的是一个接口，一般是对应的一类业务。
- 一个动态代理类可以代理多个类，只要是实现了同一个接口的情况
# 11、AOP
## 11.1、什么是AOP
## 11.2、AOP在Spring中的作用
## 11.3、使用spring实现aop
【重点】：使用AOP需导入依赖包
```xml
org.aspectj
aspectjweaver
1.9.4
```
方式一：使用Spring的API接口【Spring接口】
方式二：使用自定义类来实现AOP【切面定义】
方式三：使用注解来实现AOP
# 12、整合Mybatis
步骤：
1. 导入相关jar包
1. junit
2. mybatis
3. mysql数据库
4. spring
5. aop
6. mybatis-spring
2. 编写配置文件
3. 测试
## 12.1、回忆Mybatis
1. 编写实体类
2. 编写核心配置文件
3. 编写接口
4. 编写Mapper.xml
5. 测试
## 12.2、Mybatis-Spring
1. 编写数据源
2. sqlSessionFactory
3. sqlSessionTemplate
4. 需要给接口加实现类【多余】
5. 将自己写的实现类注入到spring中
6. 测试使用
# 13、声明式事务
## 13.1、回顾事务
- 把一组事务当成一个事务来做，要么都成功，要么都失败
- 事务在开发中十分重要，涉及数据的一致性问题
- 确保完整性和一致性
事务的ACID原则
- 原子性
- 一致性
- 隔离性
- 多个事务，可能操作同一个资源，防止数据损坏
- 持久性
- 事务一旦提交，无论系统发生什么问题，结果都不会发生影响，被持久化写到存储器中。
## 13.2、spring中的事务管理
- 声明式事务：AOP
- 编程式事务：需要在代码中管理事务
思考：
为什么需要事务
- 如果不配置事务，可能存在数据提交不一致的情况下
- 如果不在spring中配置声明式事务，就要在代码中手动配置
- 涉及到数据的完整性和一致性 重要！