42、spring的核心模块

学习目标：

1、了解Spring的架构

2、了解Spring的核心模块

3、掌握Spring容器的概念

学习过程：

一、Spring的核心模块   

Spring由7个核心模块，各个模块可以独立存在，也可以联合使用。入下图：

1、Spring Core：核心容器提供了Spring的基本功能。核心容器的核心功能是用Ioc容器来管理类的依赖关系．Spring采用的模式是调用者不理会被调用者的实例的创建，由Spring容器负责被调用者实例的创建和维护，需要时注入给调用者。这是目前最优秀的解耦模式。

2、Spring AOP：Spring的AOP模块提供了面向切面编程的支持。SpringAOP采用的是纯Java实现。Spring AOP采用基于代理的AOP实现方案，AOP代理由Ioc容器负责生成、管理，依赖关系也一并由Ioc容器管理，尽管如此，Spring Ioc容器并不依赖于AOP，这样我们可以自由选择是否使用AOP。

3、Spring ORM：提供了与多个第三方持久层框架的良好整合。

4、Spring DAO： Spring进一步简化DAO开发步骤，能以一致的方式使用数据库访问技术，用统一的方式调用事务管理，避免具体的实现侵入业务逻辑层的代码中。

5、Spring Context：它是一个配置文件，为Spring提供上下文信息，提供了框架式的对象访问方法。Context为Spring提供了一些服务支持，如对国际化(i18n)、电子邮件、校验和调度功能。

6、Spring Web：提供了基础的针对Web开发的集成特性，例如多方文件上传，利用Servlet listeners进行IoC容器初始化和针对Web的applicationContext.

7、Spring MVC：提供了Web应用的MVC实现。Spring的MVC框架并不是仅仅提供一种传统的实现，它提供了一种清晰的分离模型，在领域模型代码和web form之间。并且，还可以借助Spring框架的其他特性

  一般Spring Core和Spring Context都是必须导入的，其他可以根据自己的需要进行选择。

二、搭建spring环境

相信上一节你就给spring的诸多概念搞到你头晕了，这里我们先关注一个spring其实就是一个容器，使用IOC的方式管理所有的组件的，组件之间是有关系，使用DI方式描述组件之间的关系，这节课我们就通过编码的方式让大家好好理解一下这些概念。

1、导包

spring需要的包比较多，这里就暂时不用管每个包有什么作用了，我们使用meaven管理这些包。

<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.javadayup</groupId>
	<artifactId>springday01</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>springday01</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<spring.version>4.3.2.RELEASE</spring.version>
		<slf4j.version>1.7.12</slf4j.version>
		<logback.version>1.1.2</logback.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>
		
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${slf4j.version}</version>
			<type>jar</type>
			<scope>compile</scope>
		</dependency>
		<dependency>
			<groupId>ch.qos.logback</groupId>
			<artifactId>logback-core</artifactId>
			<version>${logback.version}</version>
			<type>jar</type>
		</dependency>
		<dependency>
			<groupId>ch.qos.logback</groupId>
			<artifactId>logback-classic</artifactId>
			<version>${logback.version}</version>
			<type>jar</type>
		</dependency>
				<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>
		
	</dependencies>
</project>

2、配置文件

spring需要一个配置文件，配置所有的组件以及组件之间的关系，我们这里就在src下面建立一个xml的配置文件，文件名称可以任意取名，这里就先取applicationContext.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" xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

三、依赖注入的多种方式

只有一个根元素beans，每一个组件称为一个bean，所以等会我们就要声明bean组件了。

现在我们先定义一个简单类，这个类包含了一些简单的属性和方法，这个类就是一个组件，以前我们需要使用这个组件，当然需要先构造这个类的对象，现在要使用IOC的方式，把所有的组件通过spring容器管理起来，所以我们现在需要的是在spring的配置文件中配置这个组件，交给spring容器管理这个组件。

1、新建两个简单类作为组件，Teacher类的代码如下：

public class Teacher {
	private int id;
	private String name;
	
	public Teacher(){
		
	}
	
	public Teacher(int id,String name){
		this.id=id;
		this.name=name;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

User类代码如下；

public class User {
	private String username;
	private String password;

	private List<String> likes;// 爱好
	private Set<String> subjects;// 科目
	private Map<String, Double> achievements;// 成绩

	private Teacher teacher;//

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public List<String> getLikes() {
		return likes;
	}

	public void setLikes(List<String> likes) {
		this.likes = likes;
	}

	public Set<String> getSubjects() {
		return subjects;
	}

	public void setSubjects(Set<String> subjects) {
		this.subjects = subjects;
	}

	public Map<String, Double> getAchievements() {
		return achievements;
	}

	public void setAchievements(Map<String, Double> achievements) {
		this.achievements = achievements;
	}

	public Teacher getTeacher() {
		return teacher;
	}

	public void setTeacher(Teacher teacher) {
		this.teacher = teacher;
	}
}

2、在配置文件中配置这个组件

（1)使用构造方法注入

	<!-- 使用构造方法注入 -->
	<bean id="teacher" class="com.pojo.Teacher">
		<constructor-arg>
			<value>1</value>
		</constructor-arg>
		<constructor-arg>
			<value>张老师</value>
		</constructor-arg>
	</bean>

（2）使用属性注入，需要该属性提供一个set方法，因为在注入时会调用set方法

	<!-- 属性注入 set方法 -->
	<bean name="user" class="com.pojo.User">
		<!-- 基本属性注入 -->
		<property name="username" value="张三"></property>
		<property name="password">
			<value>123</value>
		</property>

		<!-- List -->
		<property name="likes">
			<list>
				<value>体育</value>
				<value>读书</value>
			</list>
		</property>

		<!-- set -->
		<property name="subjects">
			<set>
				<value>语文</value>
				<value>数学</value>
				<value>语文</value>
			</set>
		</property>

		<!-- map -->
		<property name="achievements">
			<map>
				<entry key="语文">
					<value>99</value>
				</entry>
				<entry key="数学" value="59"></entry>
			</map>
		</property>

		<!-- 对象注入 -->
		<property name="teacher" ref="teacher">
		</property>

	</bean>

3、测试

写一个main方法从spring容器中获得这两个组件对象，然后打印出来看看，发现所有的注入的属性值都是有效，测试代码如下：

public class Run {
	public static void main(String[] args) {

		// 1、加载spring容器,
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

		Teacher teacher = (Teacher) context.getBean("teacher");
		System.out.println(teacher.getId());
		System.out.println(teacher.getName());

		User user = (User) context.getBean("user");
		System.out.println(user.getUsername());
		Map<String, Double> map = user.getAchievements();
		System.out.println(map.get("语文"));

		System.out.println(user.getTeacher().getName());

	}
}