Spring入门第一讲——Spring框架的快速入门

Spring入门第一讲——Spring框架的快速入门
Spring的概述

 什么是Spring？

我们可以从度娘上看到这样有关Spring的介绍：

说得更加详细一点，Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为J2EE应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring的核心是控制反转（IoC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EEfull-stack（一站式）轻量级开源框架。
为什么说Spring是一个一站式的轻量级开源框架呢？EE开发可分成三层架构，针对JavaEE的三层结构，每一层Spring都提供了不同的解决技术。

从对Spring的简要介绍中，我们知道了Spring的核心有两部分：
- IoC：即控制反转。举例来说，在之前的操作中，比方说有一个类，我们想要调用类里面的方法（不是静态方法），就要创建该类的对象，使用对象调用方法来实现。但对于Spring来说，Spring创建对象的过程，不是在代码里面实现的，而是交给Spring来进行配置实现的；
- AOP：即面向切面编程。之前，讲Struts2框架的拦截器时，我们就已稍微讲了一下，在Spring后续的学习过程中，我们会着重来讲它，但是本文并不会过多阐述它。
为什么学习Spring？

在度娘上查看有关Spring的介绍时，我们可以找到如下一系列Spring的优点，这就是我们要学习Spring框架的原因。

Spring的快速入门

 Spring的版本

需要说明的是，本系列入门Spring的教程使用的版本是spring-framework-4.2.4.RELEASE。

IoC概述

 什么是IoC？

IoC即Inversion of Control，反应过来就是控制反转。啥是控制反转啊？控制反转指的就是将对象的创建权反转给（交给）了Spring，其作用是实现了程序的解耦合。也可这样解释：获取对象的方式变了，对象创建的控制权不是"使用者"，而是"框架"或者"容器"。用更通俗的话来说，IoC就是指对象的创建，并不是在代码中用new操作new出来的，而是通过Spring进行配置创建的。

Spring的IoC的底层实现原理

这里先给出结论：Spring的IoC的底层实现原理是工厂设计模式+反射+XML配置文件。 就拿持久层（也即dao层，data access object，数据访问对象）的开发来说，官方推荐做法是先创建一个接口，然后再创建接口对应的实现类。所以，这里，我会以dao层的开发为例来证明Spring的IoC的底层实现原理就是工厂设计模式+反射+XML配置文件。
首先，创建一个Userdao接口。
```
public interface UserDao {
	public void add();
}
1
2
3
```
然后，再创建Userdao接口的一个实现类（UserDaoImpl.java）。
```
public class UserDaoImpl implements UserDao {
    public void add() {
	    balabala......
    }
}
1
2
3
4
5
```
接着，我们在service层中调用dao层，核心代码如下：
```
// 接口 实例变量 = new 实现类
UserDao dao = new UserDaoImpl();
dao.add();
1
2
3
```
这时我们便可发现一个缺点：service层和dao层耦合度太高了，即接口和实现类有耦合（它俩之间的联系过于紧密），一旦切换底层实现类，那么就需要修改源代码，这真的不是一个好的程序设计，好的程序设计应当满足OCP原则（也即开闭原则），即在尽量不修改程序源代码的基础上对程序进行扩展。说到这里，我就不得不稍微讲一下面向对象设计的七大原则了，它不必强记，重在理解。

出现的这个问题该如何解决呢？解决方法是使用工厂设计模式进行解耦合操作。所以，我们需要创建一个工厂类，在工厂类中提供一个方法，返回实现类的对象。
```
public class BeanFactory {
    // 提供返回实现类对象的方法
    public static UserDao getUserDao() {
        return new UserDaoImpl();
    }
}
1
2
3
4
5
6
```
这样，在service层中调用dao层的核心代码就变为了下面的样子。
```
UserDao dao = BeanFactory.getUserDao();
dao.add();
1
2
```
如若这样做，会发现又产生了一个缺点：现在接口和实现类之间是没有耦合了，但是service层和工厂类耦合了。如果真正想实现程序之间的解耦合，那么就需要使用到工厂设计模式+反射+XML配置文件了。所以，我们这里提供一个XML配置文件，并且该配置文件中有如下配置信息。
```
1
```
然后再来创建一个工厂类，在工厂类中提供一个返回实现类对象的方法，但并不是直接new实现类，而是使用SAX解析配置文件，根据标签bean中的id属性值得到对应的class属性值，使用反射创建实现类对象。
```
public class BeanFactory {
    public static Object getBean(String id) {
        // 1.使用SAX解析得到配置文件内容
        // 直接根据id值userDao得到class属性值
        String classvalue = "class属性值";
        // 2.使用反射得到对象
        Class clazz = Class.forName(classvalue);
        UserDaoImpl userDaoImpl = (UserDaoImpl)lazz.newInstance();
        return userDaoImpl;
    }
}
1
2
3
4
5
6
7
8
9
10
11
```
以上就是Spring的IoC的底层实现原理。

Spring的IoC入门

 下载Spring的开发包

Spring的官网是https://spring.io/，Spring的开发包的下载地址是https://repo.spring.io/libs-release-local/org/springframework/spring/，上面说过，我下载的是spring-framework-4.2.4.RELEASE这个版本的Spring。解压缩之后，可发现Spring开发包的目录结构如下。

创建web项目，引入Spring的开发包

首先创建一个动态web项目，例如spring_demo01，然后导入Spring框架相关依赖jar包，要导入哪些jar包呢？这是一个问题。

由于我们只是初次入门Spring，所以也只是使用到了Spring的基本功能，从上图红框框中的部分可知，我们需要使用到下面的这4个jar包。

除此之外，还要导入Spring支持的日志jar包，也就是下面两个jar包。

关于以上两个jar包，我稍微做一下解释，com.springsource.org.apache.commons.logging-1.1.1.jar它里面都是一些接口，有接口，那当然要有实现类了，恰好，com.springsource.org.apache.log4j-1.2.15.jar里面就是那些接口的实现类。使用Log4j，我们可以查看到当前运行程序中对象创建的过程，也可以看到更详细的信息，Log4j适合使用在程序调试中。
导入完日志相关的jar包之后，我们还要导入日志记录文件，即在src目录下引入Log4j的配置文件（log4j.properties），该文件内容如下：
```
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###
# error warn info debug trace
log4j.rootLogger= info, stdout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
```
对以上日志记录文件，我会粗略讲解一下。

从上图可知，log4j.rootLogger就是用于设置日志的输出级别，那么日志的输出级别有几种呢？有如下5种。

创建接口和实现类

首先，在src目录下创建一个com.meimeixia.spring.demo01包，并在该包下创建一个名为UserDao的接口。
```
package com.meimeixia.spring.demo01;

/**
 * 用户管理的dao层的接口
 * @author liayun
 *
 */
public interface UserDao {

	public void save();
	
}
1
2
3
4
5
6
7
8
9
10
11
12
```
然后，在com.meimeixia.spring.demo01包下创建UserDao接口的一个实现类——UserDaoImpl.java。
```
package com.meimeixia.spring.demo01;

/**
 * 用户管理的dao层接口的实现类
 * @author liayun
 *
 */
public class UserDaoImpl implements UserDao {

	@Override
	public void save() {
		System.out.println("UserDaoImpl中的save方法执行了......");
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
```
将实现类交给Spring管理

首先，我们需要创建Spring的配置文件，Spring配置文件的名称和位置没有固定要求，一般建议把该文件放到src目录下面，名称可随便写，官方建议写成applicationContext.xml。然后我们还需要在配置文件中引入约束，Spring学习阶段的约束是schema约束。那么问题来了，这个约束又该怎么写呢？可参考docsspring-framework-referencehtml目录下的xsd-configuration.html文件，在其内容最后面找到如下内容。

将其复制黏贴到配置文件applicationContext.xml中，这样applicationContext.xml文件的内容就是下面的样子了。
```
        

1
2
3
4
5
6
7
8
```
最后，咱还要将实现类交给Spring来管理，即在配置文件中配置对象的创建。
```
        
	
	
	

1
2
3
4
5
6
7
8
9
10
11
```
编写测试类

我们要在Spring中写代码来实现获取applicationContext.xml文件中配置的对象，这段代码不要求大家重点掌握，只是用在测试中而已。这段代码主要用来解析Spring配置文件得到对象，但这个过程不需要我们写代码来实现了，Spring已经封装了一个对象来帮我们进行了这些操作，这个对象叫ApplicationContext，它就能实现这个功能。于是，我们需要在com.meimeixia.spring.demo01包下创建一个SpringDemo01的单元测试类。
```
package com.meimeixia.spring.demo01;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

/**
 * Spring的入门
 * @author liayun
 *
 */
public class SpringDemo01 {
	
	/*
	 * 传统方式的调用
	 */
	@Test
	public void demo01() {
		UserDao userDao = new UserDaoImpl();
		userDao.save();
	}
	
	/*
	 * Spring的方式的调用
	 */
	@Test
	public void demo02() {
		//先要创建Spring的工厂
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");// classpath就是类路径，src目录下的文件最终要编译到类路径下
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		userDao.save();
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
```
然后，运行以上demo02单元测试方法，Eclipse控制台就会打印如下内容。

Spring IoC和DI的区别

IoC上面我已经讲过了，它指的就是将对象的创建权反转给（交给）了Spring。那DI又是什么鬼呢？DI，即Dependency Injection，翻译过来就是依赖注入，它指的就是Spring在管理某个类的时候会将该类依赖的属性注入（设置）进来，也就是说在创建对象的过程中，向类里面的属性中设置值。注意：依赖注入不能单独存在，须在控制反转基础之上完成，用更通俗点的话来说，就是注入类里面的属性值，不能直接注入，须创建类的对象再完成注入。
你还记得在面向对象设计的时候，类和类之间有几种关系吗？有3种，它们分别是：
- 依赖，由于下图中B类的方法用到了A类，所以此时就可以说B类依赖于A类；
- 继承（is a），这种关系我们应该是见的要吐了；
- 聚合（has a），它有松散和紧密之分。例如，球队得有一个守门员，即使这个球队没有了这个守门员，它也还是一个球队，所以它是松散的；人得有一个脑袋，此时它就是紧密的。
说了这么多，咱就通过一个案例来看看DI在程序的体现。现在，我们想要给UserDaoImpl这个实现类里面的某一个属性（例如String类型的name）设置值，该咋怎呢？首先，将UserDaoImpl这个实现类修改成下面这个样子。
```
package com.meimeixia.spring.demo01;

/**
 * 用户管理的dao层接口的实现类
 * @author liayun
 *
 */
public class UserDaoImpl implements UserDao {
	
	private String name;
	
	//提供set方法
	public void setName(String name) {
		this.name = name;
	}

	@Override
	public void save() {
		System.out.println("UserDaoImpl中的save方法执行了......" + name);
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
```
如果使用传统的方式来为UserDaoImpl实现类的name属性设置值，那么SpringDemo01单元测试类中的demo01方法就应该写成下面这个样子。
```
package com.meimeixia.spring.demo01;

import org.junit.Test;

/**
 * Spring的入门
 * @author liayun
 *
 */
public class SpringDemo01 {
	
	/*
	 * 传统方式的调用
	 */
	@Test
	public void demo01() {
		/*
		 * 我想给这个类里面的某一个属性设置值，挺麻烦的！
		 * 
		 * 1. 不能面向接口编程了
		 * 2. 你还得手动调用set方法，也得去改变程序的源代码
		 */
		UserDaoImpl userDao = new UserDaoImpl();
		userDao.setName("李二");
		userDao.save();
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
```
这样写，就有两个缺点，一是不能面向接口编程了，二是咱还得手动调用对象的set方法，这必然就涉及到要改变程序的源代码了，这是我们不能接受的！
如果使用了依赖注入，即在applicationContext.xml文件中为配置好的UserDaoImpl实现类的name属性注入一个值，那么情况就完全不同了，以上两个缺点也就不复存在了。
```
        
	
	
		
		
	
	

1
2
3
4
5
6
7
8
9
10
11
12
13
14
```
此时，SpringDemo01单元测试类中的demo02方法依然不变，如下。
```
package com.meimeixia.spring.demo01;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

/**
 * Spring的入门
 * @author liayun
 *
 */
public class SpringDemo01 {
	
	/*
	 * 传统方式的调用
	 */
	@Test
	public void demo01() {		
		/*
		 * 我想给这个类里面的某一个属性设置值，挺麻烦的！
		 * 
		 * 1. 不能面向接口编程了
		 * 2. 你还得手动调用set方法，也得去改变程序的源代码
		 */
		UserDaoImpl userDao = new UserDaoImpl();
		userDao.setName("李二");
		userDao.save();
	}
	
	/*
	 * Spring的方式的调用
	 */
	@Test
	public void demo02() {
		//先要创建Spring的工厂
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		userDao.save();
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
```
运行以上demo02单元测试方法，Eclipse控制台就会打印出如下内容。

Spring的工厂类

 Spring工厂类的结构图

从上图可以看出ApplicationContext（接口）继承自BeanFactory（接口）。

BeanFactory：老版本的工厂类

BeanFactory是老版本的工厂类，稍微了解一下就好，这个类在实际开发中我们并不需要用到。需要说明的一点是，它只有在调用getBean方法的时候，才会生成Spring所管理的类的实例。

ApplicationContext：新版本的工厂类

ApplicationContext是新版本的工厂类，它在加载配置文件的时候，就会将Spring所管理的类都实例化。ApplicationContext这个接口有两个实现类，如下图所示。

ClassPathXmlApplicationContext这个实现类前面用过了，下面咱就来用一下FileSystemXmlApplicationContext这个实现类。首先，拷贝一份applicationContext.xml文件到C盘下，其内容做一点点修改。

然后，在SpringDemo01单元测试类中编写如下一个demo03方法。
```
package com.meimeixia.spring.demo01;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

/**
 * Spring的入门
 * @author liayun
 *
 */
public class SpringDemo01 {
	
	/*
	 * 传统方式的调用
	 */
	@Test
	public void demo01() {	
		/*
		 * 我想给这个类里面的某一个属性设置值，挺麻烦的！
		 * 
		 * 1. 不能面向接口编程了
		 * 2. 你还得手动调用set方法，也得去改变程序的源代码
		 */
		UserDaoImpl userDao = new UserDaoImpl();
		userDao.setName("李二");
		userDao.save();
	}
	
	/*
	 * Spring的方式的调用
	 */
	@Test
	public void demo02() {
		//先要创建Spring的工厂
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		userDao.save();
	}
	
	/*
	 * 加载磁盘上的配置文件
	 */
	@Test
	public void demo03() {
		//先要创建Spring的工厂
		ApplicationContext applicationContext = new FileSystemXmlApplicationContext("C:\applicationContext.xml");
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		userDao.save();
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
```
最后，运行以上demo03单元测试方法，Eclipse控制台就会打印出如下内容。
相关阅读:
使用HBuilderX将vue或H5项目打包app
游戏心理学Day20
springboot+vue基于Spark的共享单车数据存储系统的设计与实现【内含源码+文档+部署教程】
深度学习之神经网络是如何自行学习的？
DGIOT平台基本功能介绍——物模型及指令通道相关部分介绍
 传输层 TCP主要特点和TCP连接
 精品基于Uniapp+SSM实现的公园植物介绍APP
数据结构学习笔记——树的存储结构以及树、森林与二叉树之间的转换
 C++ MFC窗口与WPF 窗口的相互嵌套
 第8章函数探幽
原文地址：https://blog.csdn.net/m0_67393157/article/details/126516499

Spring的概述

什么是Spring？

为什么学习Spring？

Spring的快速入门

Spring的版本

IoC概述

什么是IoC？

Spring的IoC的底层实现原理

Spring的IoC入门

下载Spring的开发包

创建web项目，引入Spring的开发包

创建接口和实现类

将实现类交给Spring管理

编写测试类

Spring IoC和DI的区别

Spring的工厂类

Spring工厂类的结构图

BeanFactory：老版本的工厂类

ApplicationContext：新版本的工厂类