Tim's Blog

Everything happens for a reason.

0%

Spring入门笔记(一)

发表于 更新于 分类于 Valine：

Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益！

Spring简述

Spring的一个最大的目的就是使JAVA EE开发更加容易。同时，Spring之所以与Struts、Hibernate等单层框架不同，是因为Spring致力于提供一个以统一的、高效的方式构造整个应用，并且可以将单层框架以最佳的组合揉和在一起建立一个连贯的体系。可以说Spring是一个提供了更完善开发环境的一个框架，可以为POJO(Plain Old Java Object)对象提供企业级的服务

在Spring刚出生的时候，主要的负责两件事情：IOC、AOP
IOC（Inversion of Control），即“控制反转”，为什么需要控制反转？谁控制谁？为啥叫做反转？IOC究竟是做什么的？
AOP 以后再说，先从IOC容器开始，下图是Spring的几大模块：
mark
Spring DAO：Spring提供了对JDBC的操作支持：JdbcTemplate模板工具类 。

Spring ORM：Spring可以与ORM框架整合。例如Spring整合Hibernate框架，其中Spring还提供HibernateDaoSupport工具类，简化了Hibernate的操作 。

Spring WEB：Spring提供了对Struts、Springmvc的支持，支持WEB开发。与此同时Spring自身也提供了基于MVC的解决方案 。

Spring AOP：Spring提供面向切面的编程，可以给某一层提供事务管理，例如在Service层添加事物控制 。

Spring JEE：J2EE开发规范的支持，例如EJB 。

Spring Core：提供IOC容器对象的创建和处理依赖对象关系 。

Spring的helloworld

Spring的环境搭建

首先需要说明的是：Spring不仅仅是JavaEE才能用的框架，而是SE同样适用的，所以为了方便起见，我直接新建Java工程来完成Spring的HelloWorld，但是Spring需要的jar包，所以我直接使用Maven工程来演示，假设你不用maven或者想直接使用普通的Java工程来完成Spring的HelloWorld，那么点击这里 在这里可以下载到Spring核心包的源码，Jar包以及说明文档。

eclipse如何集成Spring相关的工具包在此不再赘述，我直接使用的是Spring官方集成的工具，也是eclipse，但是你可以叫做STS，下载地址在这里

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
<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.xpu.maven</groupId>
	<artifactId>SpringDemo_01</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<dependencies>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>5.0.6.RELEASE</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>5.0.6.RELEASE</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
		<dependency>
			<groupId>commons-logging</groupId>
			<artifactId>commons-logging</artifactId>
			<version>1.1.1</version>
		</dependency>
	</dependencies>
</project>

以上是Spring的HelloWorld所需的Jar包，接下来解释一下这些Jar的作用：
mark
spring-core是Spring的核心工具包
spring-cji是核心包所需的依赖包，
spring-aop：Spring的面向切面编程，提供AOP（面向切面编程）的实现
spring-beans：Spring IOC的基础实现，包含访问配置文件、创建和管理bean等
spring-context：在基础IOC功能上提供扩展服务，此外还提供许多企业级服务的支持，有邮件服务、任务调度、JNDI定位，EJB集成、远程访问、缓存以及多种视图层框架的支持
spring-expression：spring表达式语言，就像EL表达式一样的东西
commons-logging：这个是只是一个日志包，不用理会

Spring的HelloWorld

现有一个JavaBean是Students类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.xpu.bean;
public class Students {
	private int stuNo;
	private String stuName;
	private int stuAge;
	public Students() {
		super();
	}
	public Students(int stuNo, String stuName, int stuAge) {
		super();
		this.stuNo = stuNo;
		this.stuName = stuName;
		this.stuAge = stuAge;
	}
	public int getStuNo() {...}
	public void setStuNo(int stuNo) {...}
	public String getStuName() {...}
	public void setStuName(String stuName) {...}
	public int getStuAge() {...}
	public void setStuAge(int stuAge) {...}
	@Override
	public String toString() {...}
}

如果我们需要拿到这个Students类的对象的话其实很简单：
1
Students stu = new Students(1, "Tim", 20);

接下来我们使用IOC的方式来获取到Students的对象，在src（如果是maven工程的话直接在resource下新建即可）下新建一个applicationContext.xml文件，如果你已经安装了插件或者直接使用STS的话，会自动生成一些内容：
mark

1
2
3
4
5
6
7
<!-- 该文件中产生的所有对象，被Spring放入了一个称之为springIOC容器的地方 -->
<!-- id：唯一标识符 class：JavaBean的class对象 -->
<bean class="com.xpu.bean.Students" id="students">
	<property name="stuNo" value="1"></property>
	<property name="stuName" value="Tim"></property>
	<property name="stuAge" value="20"></property>
</bean>

在测试类中写如下代码：

1
2
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
Students stu = (Students) ac.getBean("students");

这样得到的Students对象与自己直接new的对象是一样的，都是Students的对象，但是这样可能看不出Spring框架的作用到底在哪里，怎么反倒变得复杂了？

从HelloWorld解释IOC

IOC 发展史

假设有一个课程接口Cource，分别有两个实现类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public interface ICource {
	void learn();
}

class JavaCource implements ICource{
	@Override
	public void learn() {
		System.out.println("学习Java");
	}
}

public class HtmlCource implements ICource{
	@Override
	public void learn() {
		System.out.println("学习HTML");
	}
}

接下来有一个学生类和简单工厂类：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class CourceFactory {
	public static ICource getCource(String type) {
		if("HtmlCource".equals(type)) {
			return new HtmlCource();
		}else{
			return new JavaCource();
		}
	}
}

public void learn(String str) {
		//通过工厂的方式获取对象
		ICource cource = CourceFactory.getCource(str);
		cource.learn();
}

这样就实现了new操作解耦合，但是本质上还是没变：因为对象还是由客户端创造的，而且这个简单工厂的局限性非常强，只能生产Cource类的对象，如何让这个工厂更强悍呢？或者说如何从根本上解决对象的管理（生产）呢？这个时候Spring诞生了，我们只需要在applicationContext.xml中配置两个具体实例就行了：
1
2
<bean id="HtmlCource" class="com.xpu.history.HtmlCource"></bean>
<bean id="JavaCource" class="com.xpu.history.JavaCource"></bean>

这样的话学生类的learn可以这样写：
1
2
3
4
5
public void learn(String str) {
	//通过Spring的IOC容器来获取课程对象
	ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
	((ICource)context.getBean(str)).learn();
}

很多人看到这个HelloWorld可能觉得并没有什么深刻的理解，接下来听我详细到来，首先我们要获得Students对象，最开始是我们自己new的Students对象，但是后来我们拿到的对象是是直接从配置文件里定义的对象，我们暂且把这个配置文件理解成IOC容器，IOC为什么叫做”控制反转”，IOC不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下：

谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对 象的创建；谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。

为何是反转，哪些方面反转了：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

用图例说明一下，传统程序设计和IOC设计，都是主动去创建相关对象然后再组合起来：
mark
IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。

IoC很好的体现了面向对象设计法则之一就是好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。这一段摘自：《谈谈对Spring IOC的理解》

IOC与DI

IOC在被改名之前叫做控制反转，但是改名之后叫做依赖注入，改名之后
似乎更加好理解了一点，不过有一句话还是经典：控制反转是目的、依赖注入是手段，它提供一种机制，将需要依赖（低层模块）对象的引用传递给被依赖（高层模块）对象，下面我们用一个示例来体现依赖注入，注入就不再解释，在上述例子中你可以理解为把对应的元素值注入到基础属性中，再把基础属性注入到对象中，于是你获得了xml文件中配置的对象，那么什么是依赖呢？

依赖注入底层是根据反射来设计的！

假设现在有一个Teacher类：

1
2
3
4
5
6
7
8
9
10
11
12
public class Teacher {
	private String teaName;
	private int teaAge;
	public String getTeaName() {...}
	public void setTeaName(String teaName) {...}
	public int getTeaAge() {...}
	public void setTeaAge(int teaAge) {...}
	public Teacher() {...}
	public Teacher(String teaName, int teaAge) {...}
	@Override
	public String toString() {...}
}

又有一个课程类，很显然课程是依赖于老师的，所以设计如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Cource {
	private String courseName;
	private int courseHour;
	private Teacher teacher;//授课老师
	public Cource() { }
	public Cource(String courseName, int courseHour, Teacher teacher) {...}
	public String getCourseName() {...}
	public void setCourseName(String courseName) {...}
	public int getCourseHour() {...}
	public void setCourseHour(int courseHour) {...}
	public Teacher getTeacher() {...}
	public void setTeacher(Teacher teacher) {...}
	@Override
	public String toString() {...}
}

在配置文件中应该这样写：
1
2
3
4
5
6
7
8
9
10
<bean id="Teacher" class="com.xpu.ioc.Teacher">
	<property name="teaName" value="Tim"></property>
	<property name="teaAge" value="35"></property>
</bean>

<bean id="Cource" class="com.xpu.ioc.Cource">
	<property name="courseName" value="Java"></property>
	<property name="courseHour" value="2"></property> 
	<property name="teacher" ref="Teacher"></property>
</bean>

这样便完成了依赖，Cource类依赖于Teacher类，所以我们在配置文件中配置ref属性为Teacher，在通过IOC容器拿到Cource类的对象的时候便会自动生成Teacher类的对象，完成Cource类对象的依赖对象！Spring的依赖注入主要有四中方式：set注入方式、静态工厂注入方式、构造方法注入方式、基于注解的方式：
1
2
3
4
5
6
7
8
9
10
<bean id="Cource" class="com.xpu.ioc.Cource>
	<!-- 使用set方法赋值 -->
	<property name="courseName" value="Java"></property> 
	<property name="courseHour" value="2"></property>
	<property name="teacher" ref="Teacher"></property>
	
	<!-- 通过构造方法赋值(name、type、index等是可选项) --> 
	<constructor-arg value="JavaScript" name="courseName"></constructor-arg>
	<constructor-arg value="3" type="int"></constructor-arg> 	<constructor-arg ref="Teacher"></constructor-arg>
</bean>

通过构造方法赋值，如果与构造方法的参数顺序不一致，则要通过type或者index或name指定，通过命名空间注入，引入P命名空间：
1
xmlns:p="http://www.springframework.org/schema/p"

1
2
<bean id="Teacher" class="com.xpu.ioc.Teacher" p:teaName="Tom" p:teaAge="23">
<bean id="Cource" class="com.xpu.ioc.Cource" p:courseName="C++" p:courseHour="5" p:teacher-ref="Teacher">

示例：注入各种集合类：
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
package com.xpu.collection;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class AllCollectionType {
	private List<String> listElement;
	private String[] arrayElement;
	private Set<String> setElement;
	private Map<String, String> mapElement;
	private Properties propsElement;
	public List<String> getListElement() {
		return listElement;
	}
	public void setListElement(List<String> listElement) {
		this.listElement = listElement;
	}
	public String[] getArrayElement() {
		return arrayElement;
	}
	public void setArrayElement(String[] arrayElement) {
		this.arrayElement = arrayElement;
	}
	public Set<String> getSetElement() {
		return setElement;
	}
	public void setSetElement(Set<String> setElement) {
		this.setElement = setElement;
	}
	public Map<String, String> getMapElement() {
		return mapElement;
	}
	public void setMapElement(Map<String, String> mapElement) {
		this.mapElement = mapElement;
	}
	public Properties getPropsElement() {
		return propsElement;
	}
	public void setPropsElement(Properties propsElement) {
		this.propsElement = propsElement;
	}
	@Override
	public String toString() {
		return "AllCollectionType [listElement=" + listElement + "\narrayElement=" + Arrays.toString(arrayElement)
				+ "\nsetElement=" + setElement + "\nmapElement=" + mapElement + "\npropsElement=" + propsElement + "]";
	}
}


set、list、数组、都有自己的标签，但是list可以混用
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
<!-- 复杂类型的赋值的写法 -->
<bean id="collection" class="com.xpu.collection.AllCollectionType">
	<property name="listElement">
		<list>
			<value>足球</value>
			<value>排球</value>
		</list>
	</property>
	<property name="arrayElement">
		<array>
			<value>111</value>
			<value>222</value>
		</array>
	</property>
	<property name="setElement">
		<set>
			<value>足球</value>
			<value>排球</value>
		</set>
	</property>
	<property name="mapElement">
		<map>
			<entry>
				<key>
					<value>foot</value>
				</key>
				<value>足球</value>
			</entry>
			<entry>
				<key>
					<value>basket</value>
				</key>
				<value>篮球</value>
			</entry>
			<entry>
				<key>
					<value>hand</value>
				</key>
				<value>排球</value>
			</entry>
		</map>
	</property>
	<property name="propsElement">
		<props>
			<prop key="foot">足球</prop>
			<prop key="hand">排球</prop>
		</props>
	</property>
</bean>

value=""方式与<value></value>方式的区别：

使用子元素<value>注入 使用value属性注入
参数值位置 写在首尾标签<value></value>之间，不加双引号 写在value属性中的至必须加上双引号
type属性 有（可选），可以通过type指定数据类型 无，但是在构造注入的时候可以使用type
参数值包含的特殊字符 两种处理方式：1、使用<![CDATA{ }]>标记；2、使用XML预定义的实体引用 一种处理方式：使用XML预定义的实体引用

给属性赋空值需要如下写法：

1
2
3
4
<!-- 赋值为null -->
<property name="name"> </null> </property>
<!-- 赋值为"" -->
<property name="name"> <value></value> </property>

在IOC容器定义bean，必须定义无参构造

IOC自动装配（只适用于引用类型，基本类型无法装配），这种方式必须满足：在当前的IOC容器中只能有一个Bean是满足要求的：

1
2
3
4
5
<!-- Course类中有一个ref属性，属性名为teacher，并且该IOC容器中恰好有一个id也是teacher -->
<bean id="Cource" class="com.xpu.ioc.Cource" autowire="byName">
    <property name="courseName" value="Java"> </property>
    <property name="courseHour" value="5"></property>
</bean>

byName：byName是自动寻找其他JavaBean的id值与该类的ref属性名一致的

byType：上面autowire的属性可以是byType,byType会自动寻找其他JavaBean的类型与该类的ref属性类型一致的

constructor：constructor会看其他的JavaBean是否与该类的构造方法参数的类型一致

在根标签设置所有类的自动装配方式：

1
default-autowire="byName"

但是字标签的优先级更高，所以灵活度很大，接下来说说自动装配的缺点： 可读性差，容易出错，不建议经常使用

使用注解定义Bean：通过注解的方式将Bean以及相应的属性值放入IOC容器

1
2
3
//<bean id="StudentDaoImpl" class="com.xpu.dao.StudentDaoImpl"></bean>
@Component("StudentDaoImpl")
public class StudentDaoImpl { ... }

在配置文件中配置：

1
2
3
4
<!-- 先加入context -->
xmlns:context="http://www.springframework.org/schema/context"
<!-- 配置扫描器，多个包使用"，"隔开 -->
<context:component-scan base-package="com.xpu.dao"></context:component-scan>

在启动的时候，扫描器会扫描在配置中的包，而且含有@Component注解的类，如果有则将Bean加入到IOC容器中

@Component的细化，在不知道使用那一层的情况下就用@Component注解：

使用场景 注解
dao层 @Repository
service层 @Service
控制器层(MVC) @Controller

结语

如果文中有错误，希望大家能够及时指出，我的邮箱是：zouchanglin@stu.xpu.cn，对了，今天是除夕，晒晒家里的年夜饭吧：
mark

  • 本文作者： Tim
  • 本文链接： https://zouchanglin.cn/1013739183.html
  • 版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！