Spring的基本应用

Spring的基本应用

Spring概述

什么是Spring

Spring是由Rod Johnson组织和开发的一个分层的Java SE/EE full-stack(一站式)轻量级开源框架，它以IoC(Inversion of Control，控制反转)和AOP(Aspect Oriented Programming，面向切面编程)为内核，使用基本的JavaBean来完成以前只可能由EJB(Enterprise Java Beans，Java企业Bean)完成的工作，取代了EJB的臃肿、低效的开发模式。
Spring致力于Java EE应用各层的解决方案，在表现层它提供了Spring MVC以及与Struts框架的整合功能；在业务逻辑层可以管理事务、记录日志等；在持久层可以整合MyBatis、Hibernate、JdbcTemplate等技术。因此，可以说Spring是企业应用开发很好的“一站式”选择。虽然Spring贯穿于表现层、业务逻辑层和持久层，但它并不想取代那些已有的框架，而是以高度的开发性与它们进行无缝整合。

Spring框架的优点

Spring具有简单、可测试和松耦合等特点，从这个角度出发，Spring不仅可以用于服务器端开发，也可以应用于任何Java应用的开发中。
优点总结：
1、非侵入式设计
Spring是一种非侵入式框架，它可以使应用程序代码对框架的依赖最小化。
2、方便解耦、简化开发
Spring就是一个大工厂，可以将所有对象的创建和依赖关系的维护工作都交给Spring容器管理，大大地降低了组件之间的耦合性。
3、支持AOP
Spring提供了对AOP的支持，它允许将一些通用任务，如安全、事务、日志等进行集中式处理，从而提高了程序复用性。
4、支持声明事务处理
只需要通过配置就可以完成对事务的管理，无需手动编程。
5、方便程序的测试
Spring提供了对Junit4的支持，可以通过注解方便地测试Spring程序。
6、方便集成各种优秀地框架
Spring不排斥各种优秀地开源框架，其内部提供了对各种优秀框架（如Struts、Hibernate、MyBatis、Quartz等）的直接支持。
7、降低Java EE API的使用难度
Spring对JavaEE开发中非常难用的API（如JDBC、JavaMail等），都提供了封装，使这些API应用的难度大大降低。

Spring的体系结构

Spring框架采用的是分层架构，它一系列的功能要素被分成20个模块，这些模块大体分为Core Container、Data Access/Intergeration、Web、AOP(Aspect Oriented Programming)、InStrumentation、Messaging和Test。

1、Core Container(核心容器)
Spring的核心容器是其他模块建立的基础，它主要由Beans模块、Core模块、Context模块、Context-support模块和SpEL（Spring Expression Language，Spring表达式语言）模块组成，
Beans模块：提供了BeanFactory，是工厂模式的经典实现，Spring将管理对象称为Bean。
Core核心模块：提供了Spring框架的基本组成部分，包括IoC和DI功能。
Context上下文模块：建立在Core和Beans模块的基础上，它是访问定义和配置的任何对象的媒介。其中ApplicationContext接口是上下文模块的焦点。
Context-support模块：提供了对第三方库嵌入Spring应用的集成支持，比如缓存(EhCache、Guava、JCache)、邮件服务(JavaMail)、任务调度(CommonJ、Quartz)和模板引擎(FreeMarker、JasperReports、速率)。
SpEL模块：是Spring3.0后新增的模块，它提供了Spring Expression Language支持，是运行时查询和操作对象图的强大的表达式语言。
2、Data Access/Integration(数据访问/集成)
数据访问/集成层包括JDBC、ORM、OXM、JMS和Transactions模块
JDBC模块：提供了一个JDBC的抽象层，大幅度地减少了在开发过程中对数据库操作地编码。
ORM模块：对流行的对象关系映射API，包括JPA、JDO和Hibermate提供了集成层支持。
OXM模块：提供了一个支持对象/XML映射的抽象层实现，如JAXB、Castor、XMLBeans、JiBX和XStream。
JMS模块：指Java消息传递服务，包括使用和产生信息的特性，自4.1版本后支持与Spring-message模块的集成。
Transactions事务模块：支持对实现特殊接口以及所有POJO类的编程和声明式的事务管理。
3、Web
WebSocket模块：Spring4.0以后新增的模块，它提供了WebSocket和SockJS的实现，以及对STOMP的支持。
Servlet模块：也称为Spring-webmvc模块，包括了Spring的模型——视图——控制器(MVC)和REST Web Services实现的Web应用程序。
Web模块：提供了基本的Web开发集成特性，例如：多文件上传功能、使用Servlet监听器来初始化IoC容器以及Web应用上下文。
Portlet模块：提供了在Portlet环境中使用MVC实现，类似Servlet模块的功能。
4、其他模块
AOP模块：提供了面向切面编程实现，允许定义方法拦截器和切入点，将代码按照功能进行分离，以降低耦合性。
Aspects模块：提供了与AspectJ的集成工具，AspectJ是一个功能强大且成熟的面向切面编程框架。
Messaging模块：Spring4.0以后新增的模块，它提供了对消息传递体系结构和协议的支持。
Test模块：提供了对单元测试和集成测试的支持。

Spring的下载及目录结构

Spring开发所需的JAR包分为两部分

1.Spring框架包

这里使用的是Spring4.3.6。
Spring4.3.6版本的框架包
https://repo.spring.io/ui/api/v1/download?repoKey=libs-release-local&path=org%252Fspringframework%252Fspring%252F4.3.6.RELEASE%252Fspring-framework-4.3.6.RELEASE-dist.zip


docs目录中包含Spring的API文档和开发规范
libs目录中包含开发需要的JAR包和源码
schema目录中包含开发所需的schema文件，这些文件中定义了Spring相关配置文件的约束
打开lib可以看到60个JAR文件

lib目录中的JAR包分为三类，其中以RELEASE.jar结尾的是Spring框架class文件的JAP包；以RELESE-javadoc.jar结尾的是Spring框架API文档的压缩包；以RELESE-sources.jar结尾的是Spring框架源文件的压缩包。整个Spring框架由20个模块组成，该目录下Spring为每个模块都提供了这三类压缩包。
目录中有四个Spring的基础包，它们分别对应Spring核心容器的四个模块
spring-core-4.3.6.RELEASE.jar
包含Spring框架基本的核心工具类，Spring其他组件都有用到这个包里的类，是其他组件的基本核心。
spring-beans-4.3.6.RELEASE.jar
所有应用都要用到的JAR包，它包含访问配置文件、创建和管理Bean以及进行IoC或者DI操作相关的所有类。
spring-context-4.3.6.RELEASE.jar
Spring提供了在基础IoC功能上的扩展服务，还提供了许多企业级服务的支持。
spring-expression-4.3.6.RELEASE.jar
定义了Spring的表达式语言。

第三方依赖包

在使用Spring开发时，除了要使用自带的JAR包外，Spring的核心容器还需要依赖commons.logging的JAR包。

刚开始学习时，只需要将Spring的4个基础包以及commons-logging-1.2.jar引入项目即可。

Spring的核心容器

BeanFactory

BeanFactory由org.springframework.beans.facytory.BeanFactory接口定义，是基础类型的IoC容器，它提供了完整的IoC服务支持。简单来说，BeanFactory就是一个管理Bean的工厂，它主要负责初始化各种Bean，并调用它们的生命周期方法。
BeanFactory接口提供了几个实现类，其中最常用的是org.springframework.beans.factory.xml.XmlBeanFactory，该类会根据XML配置文件中的定义来装配Bean。
创建BeanFactory实例时，需要提供了Spring所管理容器的详细配置信息，这些信息通常采用XML文件形式来管理。

BeanFactory beanFactory=new XmlBeanFactory(new FileSystemResource("F:/applicationContext.xml"));

这种加载方式在实际开发中不多用，了解即可。

ApplicationContext

ApplicationContext是BeanFactory的子接口，也被称为应用上下文，是另一种常用的Spring核心容器。它由org.springframework.context.ApplicationContext接口定义，不仅包含了BeanFactory的所有功能，还添加了对国际化、资源访问、事件传播等方面的支持。
创建ApplicationContext接口实例，通常采用两种方法。
1、通过ClassPathXmlApplicationContext创建
ClassPathXmlApplicationContext会从类路径classPath中寻找指定的XML配置文件，找到并装载完成ApplicationContext的实例化工作

ApplicationContext applicationContext=new ClassPathXmlApplicationContext(String configLocation)

上述代码中，configLocation参数用于指定Spring配置文件的名称和位置。如果其值为"applicationContext.xml"，则Spring会去类路径中查找名称为applicationContext.xml的配置文件。
2、通过FileSystemXmlApplicationContext创建
FileSystemXmlApplicationContext会从指定的文件系统路径(绝对路径)中寻找指定的XML配置文件，找到并装配完成ApplicationContext的实例化工作

ApplicationContext applicationContext=new FileSystemXmlApplicationContext(String configLocation)

与ClassPathXmlApplicationContext有所不同的是，在读取Spring的配置文件时，FileSystemXmlApplicationContext不再从类路径中读取配置文件，而是通过参数指定配置文件的位置。如果在参数中写的不是绝对路径，那么方法调用的时候，会默认使用绝对路径来找。这种采用绝对路径的方式，会导致程序的灵活性变差，所有这个方法一般不推荐使用。
在使用Spring框架时，可以通过实例化其中任何一个类来创建ApplicationContext容器。通常在Java项目中，会采用通过ClassPathXmlApplicationContext类来实例化ApplicationContext容器的方式，而在Web项目中，ApplicationContext容器的实例化工作会交由Web服务器来完成。Web服务器实例化ApplicationContext容器时，通常会使用基于ContextLoaderListener实现的方式，此种方法只需要在web.xml中添加代码

<!-- 指定Spring配置文件的位置，多个配置文件时，以逗号分隔 -->
<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>
		classpath:spring/applicationContext.xml
	</param-value>
</context-param>
<!-- 指定以ContextLoaderListener方式启动Spring容器 -->
<listener>
	<listener-class>
		org.springframework.web.context.ContextLoaderListener
	</listener-class>
</listener>

创建Spring容器后，就可以获取Spring容器中的Bean。Spring获取Bean的实例通常采用以下两种方法。
Object getBean(String name)：根据容器中Bean的id或name来获取指定的Bean，获取之后需要进行强制类型转换。
<T>T getBean(Class<T>requiredType)：根据类的类型来获取Bean的实例。由于此方法为泛型方法，因此在获取Bean之后不需要进行强制类型转换。
注：BeanFactory和ApplicationContext两种容器都是通过XML配置文件加载Bean的。二者的区别在于，如果Bean的某一个属性没有注入，使用BeanFactory加载后，在第一次使用getBean()方法时会抛出异常，而ApplicationContext则会在初始化时自检，这样有利于检查所依赖的属性是否注入。因此，在实际开发中，通常都优先选择使用Application，而只有在系统资源较少时，才考虑使用BeanFactory。

Spring的入门程序

1）在Eclipse中，创建一个名为chapter01的Web项目，将Spring的4个基础包以及commons-logging的JAR包复制lib目录中，并发布到类路径下


2）在src目录下，创建一个ioc包，并在包中创建接口UserDao，然后在接口中定义一个say()方法
UserDao.java

package ioc;

public interface UserDao {
	public void say();
}

3）在ioc包下，创建UserDao接口的实现类UserDaoImpl，该类需要实现接口中的say()方法，并在方法中编写一条输出语句。
UserDaoImpl.java

package ioc;

public class UserDaoImpl implements UserDao{
	public void say(){
		System.out.println("userDao say hello World!");
	}
}

4）在src目录下，创建Spring的配置文件applicationContext.xml，并在配置文件中创建一个id为userDao的Bean

<?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
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="userDao" class="ioc.UserDaoImpl"/>
</beans>

上述2-5行是Spring的约束配置。该配置可以在Spring帮助文档中找到。
第6行表示在Spring容器中创建一个id为userDao的Bean实例，其中class属性用于指定需要实例化Bean的类。
注：Spring配置文件名称可以自定义，通常在实际开发中，都会将配置文件命名为applicationContext.xml(有时也会命名为beans.xml)。
5）在ioc包下，创建测试类TestIoC，在其main()方法中初始化Spring容器，并加载配置文件，然后通过Spring容器获取userDao实例，最后调用实例中的say()方法。
TestloC.java

package ioc;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;;

public class TestloC {
	public static void main(String[] args){
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
		UserDao userDao=(UserDao)applicationContext.getBean("userDao");
		userDao.say();
	}
}

依赖注入

依赖注入的概念

依赖注入(Dependency Injection，简称DI)与控制反转(IoC)的含义相同，只不过这两个称呼是从两个角度描述的同一个概念。
当某个Java对象（调用者）需要调用另一个Java对象（被调用者，即被依赖对象）时，在传统模式下，调用者通常会采用"new 被调用者"的代码方式来创建对象，这种方式会导致调用者与被调用者之间的耦合性增加，不利于后期项目的升级和维护。
在使用Spring框架之后，对象的实例不再由调用者来创建，而是由Spring容器来创建，Spring容器会负责控制程序之间的关系，而不是由调用者的程序代码直接控制。这样，控制权由应用代码转移到了Spring容器，控制权发生了反转，这就是控制反转。
从Spring容器的角度来看，Spring容器负责将被依赖对象赋值给调用者的成员变量，这相当于为调用者注入了它依赖的实例，这就是Spring的依赖注入。

依赖注入的实现方式

依赖注入的作用就是在使用Spring框架创建对象时，动态地将其所依赖地对象注入Bean组件中，其实现方式通常有两种，一种是属性setter方法注入，另一种是构造方法注入
属性setter方法注入：指Spring容器使用setter方法注入被依赖的实例。通过调用无参构造器或无参静态工厂方法实例化Bean后，调用该Bean的setter方法，即可实现基于setter方法的依赖注入。
构造方法注入：指Spring容器使用构造方法注入被依赖打实例。基于构造方法的依赖注入通过调用带参数的构造方法来实习，每个参数代表一个依赖。
下面以属性setter方法注入的方式演示。
1）在ioc包中，创建接口UserService，在接口中编写一个say()方法。

package ioc;

public interface UserService {
	public void say();
}

2）在ioc包中，创建UserService接口的实现类UserServiceImpl，在类中声明userDao属性，并添加属性的setter方法
UserServiceImpl.java

package ioc;

public class UserServiceImpl implements UserService{
	private UserDao userDao;
	public void setUserDao(UserDao userDao){
		this.userDao=userDao;
	}
	public void say(){
		this.userDao.say();
		System.out.println("userService say hello World!");
	}
}

3）在配置文件中，创建一个id为userService的Bean，该Bean用于实例化UserServiceImpl类的信息，并将userDao的实例注入到userService中

	<bean id="userService" class="ioc.UserServiceImpl">
    	<property name="userDao" ref="userDao"/>
    </bean>

<proerty>是<bean>元素的子元素，它用于调用Bean示例中的setUserDao()方法完成属性赋值，从而实现依赖注入。其name属性表示Bean实例中的相应属性名，ref属性用于指定其属性值。
4）ioc包中，创建测试类TestDI，来对程序进行测试
TestDI.java

package ioc;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestDI {
	public static void main(String[] args){
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
		UserService userService=(UserService) applicationContext.getBean("userService");
		userService.say();
	}
}