Spring全面详解

—————版本Spring5.x—————

——编译器IntelliJ IDEA 2020.2.3 ——

<-- 该文章有点老旧，停止了更新，请查看Spring5最新文章，目前已经书写完成 -->

Spring5全面详解

它会持续更新，你所看到的不是最终版本。

如果感觉有帮助的话，请点个赞再走吧。

---

Spring框架
　　Spring的概念及理解
　　Spring的下载方法
　　Spring的入门案例

　　IOC容器
　　　　* IOC底层原理(1)
　　　　* IOC底层原理(2)
　　　　* IOC操作Bean管理(概念 )
　　　　* IOC操作Bean管理(基于 xml )
　　　　* IOC操作Bean管理(基于 注解 )

1. Spring的概念

1. Spring是一个轻量级，开源的JavaEE框架.
2. Spring可以解决企业应用开发的复杂性，可以更方便的去开发。
3. Spring有两个核心部分，一个是IOC一个是Aop
4. Spring框架的相关特点

可能对于IOC和Aop不是很理解，这里稍微提一下大概

IOC: 控制反转，把创建对象交给Spring处理，说白了就是Spring来帮我们创建对象。
Aop: 面向切面, 不修改源代码进行功能修改。

Spring相关的特点(引用上面第四部分)

• 方便解耦，简化开发。
• Aop编程支持。
• 方便程序测试。
• 方便和其他框架进行整合。
• 降低JavaAPI的使用难度。(对很多东西做了封装。如JDBC等等)
• 方便进行事务操作。

---

我们现在开始做一个小案例，做之前需要下载Spring框架。

Spring的官方是 spring.io
进入到官方后，鼠标放到上方的Projects之后，有一个Spring Framework选项，单击进入。点击右侧的LEARN，下载对应版本，GA为稳定版，SNAPSHOT是快照版。推荐选择稳定版，这里我选择的是5.3.1GA

更详细的步骤:
第一步

第二步

第三步

第四步,这一步是历史版本查看。

下载点击Github的图标

之后





进入到这里之后，点击所下载的版本。

如果实在是懒得去官方下载，我把资源上传到网盘，请去网盘下载:

链接：https://pan.baidu.com/s/1ic6k-DejBy95KjLhsBD-cw
提取码：qqli

至此，下载完成。

Spring入门案例

我们现在只做测试，所以打开idea，创建一个普通的Java项目工程就可以了。
因为这是Spring…所以肯定有一些基础吧。如何创建工程的图我就不放了。大家应该都会。

1.导入Spring5相关的一些jar包。

在spring目录 libs里有一些jar包。如图

不难发现都有一些规律，从上到下都是aop，aspects，beans，context。.jar的肯定是这个jar包，不用考虑， -javadov.jar 是文档， -sources.jar 是源码。这里做一下介绍。

下图是spring5的模块

然后模块中的Core Container部分，这是他的组成部分在里面的结构中，Test是测试， Core是核心部分，Beans一样，他们对应的是IOC核心部分。 Context上下文，Expression表示他呢个表达式。他的Web部分和Data部分。


我们只做最基础的，需要的最少是这核心部分的四个包。

Beans,Core,Context,Expression。
如下图所示。

但是我们还需要一个额外的包，commons-logging日志jar包。
它不属于spring目录的jar包，但是放心。我以及帮你们下载好了，百度网盘链接为:

链接：https://pan.baidu.com/s/1LP4FFAomqSm-GUu6-8UbyQ
提取码：0uvk

最终我们需要这五个jar包

在idea中导入jar包。新建一个libs目录

把jar包复制到libs目录下。

把jar包导入项目工程中


然后点击ok。完成。

我们做这样的一个功能，用spring的方式来创建一个对象。

我们原始方式可能需要这样来创建对象

class Person{
	public void eat(){
		System.out.println("人可以吃东西");
	}	
}

public class xxx {
	public static void main(String[] args){
		Person person = new Person();
		person.eat();
		// 这个大家一定很熟悉了，他会调用Person类里面的eat方法。从而输出 人可以吃东西
	}
}

使用spring创建对象
1.创建spring配置文件，在配置文件配置创建的对象。
（1）配置文件是使用xml格式来创建的。
创建xml配置文件过程。在src目录下。

我们在src下创建一个包，包名你们自己起，然后在包里建一个Person类。代码如下

配置xml文件

解释一下，通过bean标签就可以完成对象创建的配置。这是spring中一个比较固定的写法，id其实就是给他起一个名称，这个名称随便，但是一般都要见名知意。class是路径，我们把包下 的路径加上类给他写上去就好，比如我这里写的是: com.spring5.Person

进行测试代码编写.他只是在测试中用，后面不会实际写到。后面我们要通过web层进行调用现在只是为了测试写这个代码。

首先我们创建了一个包，用于专门的测试，叫junit，包里有一个测试类。Test。ps：别忘记导入Junit包，下面我将详细解释。

　　因为我们是配置文件创建对象，所以第一步毋庸置疑，肯定是要获取配置文件的。没有错吧。这里使用ApplicationContext context = new ClassPathXmlApplicationContext(“文件路径”);来获取配置文件。因为我的xml文件是直接在src下的，可以直接获取，如果不在，请加上路径。并且就是FileSystemXmlApplicationContext了。
　　接下来我们在第二步，获取配置文件中创建的对象。context.getBean();这个方法，里面有两个参数。第一个是你在xml里配置的id的名字。也可以称为别名。第二个是转换。（别忘了导入Person类）然后使用Person person来接受这个类。最后调用方法输出如下。

希望你们可以动手试试，有什么问题可以随时联系我。

---

IOC容器

1. IOC概念和原理（1）

　　1.1 什么是IOC：
　　　　(1) 控制反转，把对象的创建和对象之间调用的过程，都交给Spring进行管理。
　　1.2 使用IOC的目的:
　　　　(1) 为了耦合度降低。
　　1.3 刚刚做的入门的案例，就是IOC实现

　　2.1 IOC底层原理
　　　　(1) xml解析, 工厂模式, 反射
在了解底层原理之前，我们先来谈一谈耦合度的问题。 看以下代码
Ps:请务必看代码里的注释。

// 为了方便，我就不拆开写了。大家明白就好。这里我写两个类，一个student，一个person
class Student {
	public void study (){
 		System.out.println("学生学习");
	}
}

class Person{
    public void sleep(){
		System.out.println("睡觉");
    }
}
/* 如果我们想要在Student类里调用Person的sleep方法。我们按最基本的方法来调用。
无非是在Student里new出来Person。*/

class Student(){
    Person person = new Person();
    person.sleep();
}

在上面的代码中。虽然完成了需求，但是你们有没有发现这样耦合度特别的高。如果Person里发生了改动，呢么基本上你这儿也要对他进行改动。于是我们尽可能的对他进行解耦。 这里不得不提出一个设计模式， 工厂设计模式

// 一样的两个类。
class Student {
    public void study(){
		System.out.println("学习");
	}
}

class Person{
	public void sleep(){
		System.out.println("睡觉");
    }
}
// 什么是工程设计模式，我们在这里提供一个工厂类。专门来给他返回一个对象。 如:
class Factory {
	public static Person getPerson(){
		return new Person();
    }
}

// 呢么如果我们把工厂类写出来，我们是不是可以在后面这样用。
class Student(){
	// 因为工厂类里，getPerson方法是静态修饰过的，可以直接通过类 + 方法名调用。
	// 这一部分是基础。大家应该都懂。我在这里说一下。
    Person person = Factory.getPerson();
    person.sleep();
}

综上所述，我们可以大幅度的降低类与类之间的耦合关系，但是类与类之间一定是存在耦合关系的，我们的目的只是尽可能上限的降低他们的耦合度，工厂依然不是降低到最低限度的设计模式，我们可以把它进一步降低。
于是，我们就可以使用IOC来对他进行解耦。
IOC除了用到了工程设计模之外，还用到了我之前提到的xml配置文件，和反射。

IOC过程

• xml配置文件，配置创建的对象。(如果不会，请回过头去看入门案例。)
• 第二步，创建工厂类，在工程类里，对xml解析，和反射的使用。 直接上代码。

// xml
<bean id="person" class="com.spring.Person"></bean>

// 老样子，Student，Person, 工厂类Factory
class Student{
	public void study(){
		System.out.println("学习");
	}
}
class Person{
	public void sleep(){
		System.out.println("睡觉");
	}
}
// 重点
class Factory{
	// 为了方便，使用静态方法
	public static Person getPerson(){
		// 1. String classValues = class属性值; 这一部分可以通过xml解析获得.
		
		// 2. 通过反射来把他的对象创建 (反射就是得到类的字节码文件) 
		// Class class = Class.forName(classValues);
			
		// 3. 创建对象。
		// return (Person)class.newInstance();
	}
}

他虽然最终也是工厂模式，但是他进一步对耦合度降低了，因为，你获取的是xml的class配置，路径发生改变后，只需要改动一个地方。就可以了，而不需要全部改动。耦合度进一步降低。

IOC底层原理(2)

它主要使用工厂模式来实现的一个过程。

IOC接口

之前我们说，IOC是什么，它是一个容器。你需要基于这个容器来完成，容器是什么，其实可以理解成对象工厂。
IOC的思想基于IOC容器来完成，IOC底层就是对象工厂。
Spring提供了两种IOC容器的实现方式:

两个重要的接口。

(1)BeanFactoy

IOC容器最基本的实现方式。是它本身自己用的。内置接口。他是Spring自带的一个接口。不提供给我们这些开发人员进行使用。但是你也可以用。

(2)ApplicationContext

它是BeanFactoy接口的一个子接口。这个接口中比BeanFactoy接口中提供了更多更强大的功能。一般面向开发人员进行使用。

但是他们两个还是有区别的:
　　BeanFactoy 有个特点，在加载配置文件的时候，他不会帮你把里面的对象创建。只会加载配置文件，当你在获取或者使用的时候才回去创建对象。
　　ApplicationContext 跟BeanFactoy完全不一样，他在加载配置文件的时候就会把你在配置文件中的呢个对象进行创建。

ApplicationContext的一些实现类

这两个比较重要, FileSystemXmlApplicationContext 是文件的全路径，ClassPathXmlApplicationContext是Src目录下的文件名称和上面案例代码一样。可以回去看看。

2. IOC操作Bean管理-概念

1.什么是Bean管理。(Bean管理指的是两个操作)
　　(1) Spring创建对象
　　(2) Spring注入属性

详解,这里用代码来做解释，一定要看注释。

// 我们的老规矩，一个Student类，一个Person类。
class Student {
	// 创建属性
	private String name;
	// 如果我想实现，在Spring创建对象的过程中，给name，赋值。应该怎么做。
	// 如果换做以前，我们是不是要使用set方法来做到。但是现在，使用Spring注入即可。
	// 这个也就是Bean管理重复的两个工作，
	// 1. 创建对象， 2 给属性赋值。 
	
	public void study(){
		System.out.println("学习");
	}
}

综上所述，应该大家都可以明白什么是Bean管理了吧。
Bean管理操作有两种方式可以做到。

• 第一种方式是基于xml配置文件方式来实现。
• 第二种基于注解的方式来实现。

基于xml配置文件的方式来实现

• 基于XML创建对象。至于创建对象的过程，请你回去看一下Spring的入门案例,麻烦了。

• 在Bean标签中还有很多的属性，介绍常用的属性。

• 1.id属性。
  * 类似于给你的对象起一个标识，可以通过这个标识，来得到你这个对象。

• 2.class属性
  * 类全路径(包+类名)

• 3.name属性(了解)
  * 你不用id，用name也可以做到id的效果，而且他们之间的区别是 id 不能加特殊符号，name可以。比如(/-*)。

• 在创建对象的时候，默认也是去执行呢个无参数的构造方法。

上代码举例一下。注意注释.

// Student类即可
class Student {
	private String name;

	// 无参构造和有参构造
	public Student(String name){
		this.name = name;
	}
	// 如果此时不写无参构造，就会报错。因为他回去找空参构造。而你并没有，并且写了一个有参构造。系统就不会给你分配空构造器。
	// 就会报出NoSuchMethodException错误。没有无参构造。
	public Student(){}

	public void study(){
		System.out.println("学习");
	}
}

基于XML方式来注入属性

1. DI：依赖注入。就是注入属性。

第一种是通过set方法注入。第二种则可以通过构造器有参注入。

来， 上代码会更直观一点。

第一种。set方法注入

// 注意注释。 依然是一个Student类，别问，问就是我就是Student！
class Student{
	// 这里我们给他创建属性。
	private String name;
	
	// 我们现在想在它的name里设置一个值，怎么做呢。我们原始一点，属性是不是有它的get/set方法。
	// 我们 在这里生成set方法即可。
	public void setName(String name) {
		// 就是如此，没什么问题吧！但我们没有在学基础，这是Spring框架。
		this.name = name;
	}
	
	// 或者这样注入
	public Student(String name){
		this.name = name;
	}

	public static void main(String[] args) {
		Student student = new Student();
		student.setName("张三");
		// 这种方式很简单，也很原始。
	}
}

通过spring来配置。首先我们需要配置文件。

<bean id="Student" class="路径.Student">
<!-- 我们是在对象里注入属性，所以我们肯定要在bean里面去操作。-->
<!-- 使用property完成属性的注入-->
	<!-- name就是你的属性名称， 就是你类里面的属性名称。value就是你要注入的呢个值-->
	<property name="name" value="张三"></property>
</bean>

这样写可能会很散乱。我们来给他总结一下，写到一块。

// 因为这是java的代码块。 老样子，Student类
class Student{
	priavte String name;
	priavte String gender;

	// set方法。必须要有
	public void setName(String name){
		this.name = name;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	// 方便查看结果
	public void a(){
		System.out.println("name:" + this.name + ", gender: " + this.gender);
	}
}


// xml代码配置 假设xml叫 xmlDemo
<bean id="student" class="xxx.Student">
	<property id="name" value="张三"></property>
	<property id="gender" value="男"></property>
</bean>
// 这样是不是会更好理解一些。至此已经诸如完成/

// 测试
@Test
public void test(){
	// 加载配置文件
	ApplicationContext context = new ClassPathXmlApplicatonContext("xmlDemo.xml");
	// 获取在配置文件中创建的对象
	Student student = context.getBean("student", Student.class);
	// 调用方法
	student.a();
	// 控制台打印输出 name: 张三 gender: 男
}

---

---

它会持续更新，你所看到的不是最终版本。