1.什么是Spring？

Spring是分层的JavaSE/EE full-stack 轻量级开源框架，以IoC（Inverse of Control 控制反转）和AOP（Aspect Oriented Programming 面向切面编程）为内核，使用基本的JavaBean来完成以前只可能由EJB完成的工作，取代了EJB的臃肿、低效的开发模式。

1.1 spring中的三层架构

在实际开发中，通常服务器端在采用三层体系架构，分别为表示层(Web)、业务逻辑层(Service)、持久层(Dao)， Spring对每一层都提供了技术支持。

image

1.2 spring的优点

Spring具有简单、可测试和松耦合等特点。Spring不仅可以用于服务器端开发，也可以应用于任何Java应用的开发中。

1.方便解耦，简化开发

通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成
的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代
码，可以更专注于上层的应用。

2.AOP编程的支持

通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过
AOP轻松应付。

3.声明事物的支持

在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管
理，提高开发效率和质量。

4.方便程序的测试

可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随
手可做的事情。例如：Spring对Junit4支持，可以通过注解方便的测试Spring程序。

5.方便集成各种优秀框架

Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种
优秀框架（如myBatis,Hibernate、Dubbo、ElasticSerach）等的直接支持。

6.降低Java EE API的使用难度

Spring对很多难用的Java EE API（如JDBC，JavaMail，远程调用等）提供了一个薄薄的封装层，通过
Spring的简易封装，这些Java EE API的使用难度大为降低。

1.3Spring的体系结构

Spring框架采用的是分层架构，它一系列的功能要素被分成20个模块。

image

1.Core Container(核心容器)

Beans 提供了BeanFactory，Spring将管理对象称为Bean。
Core 提供了Spring框架的基本组成部分，包括IoC和DI功能。
Context 建立在Core和Beans模块的基础之上，它是访问定义和配置的任何对象的媒介。
SpEL Spring3.0后新增的模块，是运行时查询和操作对象图的强大的表达式语言。

2.Data Access/Integration(数据访问/集成)

JDBC 提供了一个JDBC的抽象层，大幅度的减少了在开发过程中对数据库操作的编码。
ORM 对流行的对象关系映射API，包括JPA、JDO和Hibernate提供了集成层支持。
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是一个功能强大且成熟的面向切面编程（AOP）框架。
Instrumentation

提供了类工具的支持和类加载器的实现，可以在特定的应用服务器中使用。
Messaging

Spring4.0以后新增的模块，它提供了对消息传递体系结构和协议的支持。
Test

提供了对单元测试和集成测试的支持。

1.4 Spring的下载及目录结构

Spring开发所需的jar包分为两个部分:Spring框架包和第三方依赖包。

1.Spring框架包

下载地址：http://repo.spring.io/simple/libs-release-local/org/springframework/spring/4.3.6.RELEASE/

下载后的解压目录如下：

image

docs

docs文件夹中包含API文档和开发规范

libs

文件夹中包含JAR包和源码

Schema

文件夹中包含开发所需要的schema文件

在libs目录中有四个Spring的基础包，分别对应Spring核心容器的四个模块。

spring-core-4.3.6.RELEASE.jar
包含Spring框架的核心工具类，Spring其它组件都要用到这个包里的类。
spring-beans-4.3.6.RELEASE.jar
所有应用都要用到的JAR包，它包含访问配置文件、创建和管理Bean以及进行控制反转或者依赖注入操作相关的所有类。
spring-context-4.3.6.RELEASE.jar
提供了在基础IoC功能上的扩展服务，还提供了许多企业级服务的支持
spring-expression-4.3.6.RELEASE.jar
定义了Spring的表达式语言。

2.第三方依赖包

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

下载地址：http://commons.apache.org/proper/commons-logging/download_logging.cgi

1.2 Spring的核心容器

Spring容器会负责控制程序之间的关系，而不是由程序代码直接控制。Spring为我们提供了两种核心容器，分别为BeanFactory和ApplicationContext，本节将对这两种核心容器进行简单介绍。

1. BeanFactory

创建BeanFactory实例时，需要提供Spring所管理容器的详细配置信息，这些信息通常采用XML文件形式来管理，其加载配置信息的语法如下：

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

2.ApplicationContext

ApplicationContext是BeanFactory的子接口，是另一种常用的Spring核心容器。它由org.springframework.context.ApplicationContext接口定义，不仅包含了BeanFactory的所有功能，还添加了对国际化、资源访问、事件传播等方面的支持。创建ApplicationContext接口实例，通常采用两种方法，具体如下：

a.通过ClassPathXmlApplicationContext创建

ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");

ClassPathXmlApplicationContext会从类路径classPath中寻找指定的XML配置文件，找到并装载完成ApplicationContext的实例化工作。

b.通过FileSystemXmlApplicationContext创建

ApplicationContext context = new FileSystemXmlApplicationContext("D:/Users/Administrator/workspace_huanqiu/TestService/src/application.xml");

FileSystemXmlApplicationContext会从指定的文件系统路径（绝对路径）中寻找指定的XML配置文件，找到并装载完成ApplicationContext的实例化工作。

创建Spring容器后，就可以获取Spring容器中的Bean。Spring获取Bean的实例通常采用以下两种方法：

Object getBean(String name);

根据容器中Bean的id或name来获取指定的Bean，获取之后需要进行强制类型转换。
<T> T getBean(Class<T> requiredType);

根据类的类型来获取Bean的实例。由于此方法为泛型方法，因此在获取Bean之后不需要进行强制类型转换。

1.3Spring的入门程序

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

image

2.在src目录下，创建一个com.qingchuan.dao包，并在包中创建接口UserDao，然后在接口中定义一个say()方法。

package com.qingchuan.dao;

public interface UserDao {

    public void say() ;
}

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

package com.qingchuan.dao;

public class UserDaoImpl implements UserDao {

    @Override
    public void say() {
        System.out.println("user dao say");
    }

}

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="com.qingchuan.dao.UserDaoImpl">
    </bean>
</beans>

5.在com.qingchuan包下，创建测试类TestIoC，并在类中编写main()方法。在main()方法中，需要初始化Spring容器，并加载配置文件，然后通过Spring容器获取userDao实例（即Java对象）

package com.qingchuan;

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

import com.qingchuan.dao.UserDao;
import com.qingchuan.dao.UserDaoImpl;

public class TestIoc {

    public static void main(String[] args) {

        
        //1.使用 ClassPathXmlApplicationContext 获取context
        //ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        
        // 2. 使用FileSystemXmlApplicationContext 获取context
        ApplicationContext context = new FileSystemXmlApplicationContext("D:/Users/Administrator/workspace_huanqiu/TestService/src/application.xml");
        
        // 1.通过id 获取bean
        //UserDao userDao = (UserDao) context.getBean("userdao");
        
        // 2.通过 类名 获取bean
        UserDao userDao = context.getBean(UserDaoImpl.class);
        userDao.say();
    }

}

1.4 依赖注入

DI的全称是Dependency Injection，中文称之为依赖注入。它与控制反转（IoC）的含义相同，只不过这两个称呼是从两个角度描述的同一个概念。

IoC

在使用Spring框架之后，对象的实例不再由调用者来创建，而是由Spring容器来创建，Spring容器会负责控制程序之间的关系，而不是由调用者的程序代码直接控制。这样，控制权由应用代码转移到了Spring容器，控制权发生了反转，这就是控制反转。

DI

从Spring容器的角度来看，Spring容器负责将被依赖对象赋值给调用者的成员变量，这相当于为调用者注入了它依赖的实例，这就是Spring的依赖注入。

依赖注入的实现方式

1.在com.qingchuan.service包中，创建接口UserService，在接口中编写一个say()方法。

package com.qingchuan.service;

public interface UserService {

    public void say();
}

2.在com.qingchuan.service包中，创建UserService接口的实现类UserServiceImpl，在类中声明userDao属性，并添加属性的setter方法。

package com.qingchuan.service;

import com.qingchuan.dao.UserDao;

public class UserServiceImpl implements UserService {

    private UserDao userdao;    
    public void setUserdao(UserDao userdao) {
        this.userdao = userdao;
    }
    @Override
    public void say() {
         userdao.say();
    }
}

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

<?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="com.qingchuan.dao.UserDaoImpl">
    </bean>
    <bean id="userservice" class="com.qingchuan.service.UserServiceImpl">
        <property name="userdao" ref="userdao"></property>
    </bean>
</beans>

4.在com.qingchuan包中，创建测试类TestDI，来对程序进行测试。

package com.qingchuan;

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

import com.qingchuan.service.UserService;
import com.qingchuan.service.UserServiceImpl;

public class TestDi {

    public static void main(String[] args) {
        
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");

        UserService userService = context.getBean(UserServiceImpl.class);       
        userService.say();
    }
}

什么是Spring

1.什么是Spring？

1.1 spring中的三层架构

1.2 spring的优点

1.方便解耦，简化开发

2.AOP编程的支持

3.声明事物的支持

4.方便程序的测试

5.方便集成各种优秀框架

6.降低Java EE API的使用难度

1.3Spring的体系结构

1.Core Container(核心容器)

2.Data Access/Integration(数据访问/集成)

3.Web

4.其他模块

1.4 Spring的下载及目录结构

1.Spring框架包

2.第三方依赖包

1.2 Spring的核心容器

1. BeanFactory

2.ApplicationContext

a.通过ClassPathXmlApplicationContext创建

b.通过FileSystemXmlApplicationContext创建

1.3Spring的入门程序

1.4 依赖注入

IoC

DI

推荐阅读更多精彩内容