# Spring

**Repository Path**: codermast/Spring

## Basic Information

- **Project Name**: Spring
- **Description**: Spring框架的学习
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2021-12-07
- **Last Updated**: 2022-05-25

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# ✅Spring框架学习

  本项目主要总结本人学习Spring框架的过程，其中会包含一些心得体会，和源代码练习，以及自己对某些知识点的理解，方便进行持续学习，在不断学习的路上也能及时和高效的复习回顾，总结在初次接触学习和后续复习的理解程度，能够更好地梳理知识框架体系。

## ❤️Spring简单理解

- Spring是一个开源的轻量级框架
- 主要解决的是企业级开发问题
- Spring可以被看作一个容器，是非侵入式的
- 面向切面
- IOC(Inversion of Control控制反转)和AOP(Aspect Oriented Programming面向切面编程)

## ♥️知识点总结

### 第1️⃣天
- Spring框架构建
- 基本的Dao层(数据访问层)，Service层(业务层逻辑)和用户层架构
- 将程序的耦合度降低
- 使用`Set()`方法进行注入，将程序根据业务创建对象的权力交给了用户，让用户根据需求，来创建想要的对象，程序只是被动地接受对象，将权力交给了用户。
![控制反转](image/kongzhifanzhuan.png)

🎈**个人理解**
`IOC`：控制反转，是一种设计思想，即获取依赖对象的来源改变了。从一般情况下程序主动创建所需要的业务对象，到控制反转后，将依赖对象的创建权力交给了用户，使得用户可以根据自身的需求来创建不同的对象，而不会影响到程序系统本身的架构，耦合度降低。在第一天的学习中，我们使用的是DI(依赖注入dependency injection)这种方式来实现，通过中间的Set方法来将用户主动构建的对象调用到程序中，实现了控制的反转。

`IOC的作用`:就是将原本错综复杂，耦合度高的对象，通过IOC容器降低他的耦合度，使的各部分都可以独立运行，尽量做到互不干扰，即一方异常也不会影响到其他方面，降低耦合度，能够提高维护项目和对项目现有功能扩展的便捷性。
![IOC的作用](image/jieou.png)

### 第2️⃣天
 - IOC是Spring框架的核心内容
 - IOC也可以通过XML配置Bean进行实现，Bean的定义信息和实现是分离的
 - Spring容器在初始化时先读取配置文件，将配置文件中的所有组织的对象存入容器中。
   > 注解：在Spring中，只要加载了配置文件，无论类是否获取或者调用容器内的对象，对象都会被提前定义好，只是在使用的时候，拿出来使用，并不是在使用的时候才开始构建对象。
 - 对象由Spring来进行创建管理和装配。
#### 💥xml和bean的语法
1. 声明XML配置，声明bean 

 > XML声明：Spring官方给定的格式
 ```xml
<?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="..." class="...">
      <!-- collaborators and configuration for this bean go here -->
   </bean>
   
   <bean id="..." class="...">
      <!-- collaborators and configuration for this bean go here -->
   </bean>
   <!-- more bean definitions go here -->
</beans>
 ```


2. 将配置好的XML文件加载到实际使用的类中，该context实例对象即就包含XML文件中声明好的所有bean。
```java
ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");
```

3. 实际bean声明的语法定义
> 对于主要的创建对象的方法，明天再进行记录
```xml
<bean id="petStore" class="org.springframework.samples.jpetstore.services.PetStoreServiceImpl">
        <property name="accountDao" ref="accountDao"/>
        <property name="itemDao" ref="itemDao"/>
        <!-- additional collaborators and configuration for this bean go here -->
</bean>
```
**注释说明：**

`id`:ID就是在context对象中包含的实例化当前Bean中声明的类型的对象名称，可以使用context.getBean("这里填写声明好的ID值，即可获取到对象");

`class`:就是当前bean标签所管理的类，需要填写绝对位置，即构建好的对象的类型就是当前声明的类型

`property`:对类对象属性的初始化，其中`name`为类中的属性名称，如果属性值为基本数据类型则使用`value`进行赋值，如果是其他数据类型，则就要使用`ref`进行赋值。

`bean`中的对象构建：在没有进行调用的时候，已经调用了无法参构造器，即在初始化加载阶段已经进行了对象的调用
 ![bean中的对象构建](image/bean中的对象构建.png)

**XML文件中加载其他XML**

&emsp;&emsp;在XML文件中，可以将其他XML配置文件通过`import`标签进行导入，语法如下。
> 在一个项目中，可能会分为多个模块，而多个模块会创建不同的bean.xml文件，我们导入不方便，所以可以进行导入，方便我们使用。

```xml
<beans>
    <import resource="services.xml"/>
    <import resource="resources/messageSource.xml"/>
    <import resource="/resources/themeSource.xml"/>

    <bean id="bean1" class="..."/>
    <bean id="bean2" class="..."/>
</beans>
```

&emsp;&emsp;在约定中，用户可以定义多个xml文件，但在使用过程中，将其全部导入类文件，比较繁琐，所以我们一般将所有的XML文件导入到`ApplactionXml`这一个xml中，在使用时仅需要导入这个即可。
### 第3️⃣天
 - Spring容器就可以看做一个对象池，将定义好的对象全部进行存储，然后通过Spring容器进行调用。
 - IOC创建对象的几种方式
 - 对`bean`对象做别名
#### IOC创建对象的几种方式：
1. 调用无参构造法
> 直接对属性进行赋值
```xml
<bean id="petStore" class="org.springframework.samples.jpetstore.services.PetStoreServiceImpl">
        <property name="accountDao" ref="accountDao"/>
        <property name="itemDao" ref="itemDao"/>
        <!-- additional collaborators and configuration for this bean go here -->
</bean>
```
2. 调用有参构造法
使用`constructor-arg`标签，可以进行传参操作。
- 传递引用给构造器，按照标签的顺序进行传参(不推荐使用)
```xml
 <beans>
    <bean id="beanOne" class="x.y.ThingOne">
        <constructor-arg ref="beanTwo"/>
        <constructor-arg ref="beanThree"/>
    </bean>
    
    <!--  上面传入构造器的引用对象，需要单独使用bean标签进行声明  -->
    <bean id="beanTwo" class="x.y.ThingTwo"/>

    <bean id="beanThree" class="x.y.ThingThree"/>
</beans>
```
- 通过给定数据类型，然后直接传入`value`值
```xml
<bean id="exampleBean" class="examples.ExampleBean">
    <constructor-arg type="int" value="7500000"/>
    <constructor-arg type="java.lang.String" value="42"/>
</bean>
```
- 通过给定参数列表的下标，然后传入`value`值
> 下标索引和Java中规则一致，从0开始
```xml
<bean id="exampleBean" class="examples.ExampleBean">
    <constructor-arg index="0" value="7500000"/>
    <constructor-arg index="1" value="42"/>
</bean>
```
- 通过构造器参数名称来进行传参操作，避免歧义(推荐)
> `name`为构造器参数名，`value`为传入的具体值
```xml
<bean id="exampleBean" class="examples.ExampleBean">
    <constructor-arg name="years" value="7500000"/>
    <constructor-arg name="ultimateAnswer" value="42"/>
</bean> 
```
#### 对`bean`对象做别名
> 因为在实际使用中，在创建大量对象以后，部分对象的名称可能会重复，或者很复杂，不方便我们进行调用，可以使用别名。
 1. 使用`alias`标签进行做别名
> `name`是所指定bean对象的id值，`alias`是要设定的别名的值
```xml
<alias name="fromName" alias="toName"/>
 ```
 2. 直接在`bean`标签中进行进行做别名
```xml
<bean id="bean1" class="..." name="bieming"/>
 ```
#### 第4️⃣天
##### 依赖注入
1. 构造器注入
&emsp;&emsp;通过构造器中的构造方法将以来进行注入，即对部分属性进行赋值，来控制业务逻辑的执行。
2. Set注入
&emsp;&emsp;通过Set方法进行依赖注入，本质上和构造器注入是一致的，只是将构造器中的业务拿出来到Set方法，进行单独的控制。
`依赖注入简单理解上，就是对对象的属性进行赋值`
> 依赖：Bean对象的创建依赖于容器
>
> 注入：Bean对象中的所有属性由容器来注入
3. 其他方式注入