spring 中的4个map spring的四个层

1. 概述

spring是一个分层的javaSE/EE的轻量级一站式框架

1.1 一站式框架

即有有EE开发的每一层解决方案

1.1.1 WEB层：SpringMVC

1.1.2 Service层 ：Spring的Bean管理，Spring声明式事务

1.1.3 DAO层：Spring的Jdbc模板，Spring的ORM模块

1.2 特点

1.2.1 方便解耦，简化开发

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

1.2.2 AOP编程的支持

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

1.2.3 声明式事务的支持

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

1.2.4 方便程序的测试

        可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。

例如:Spring对Junit4支持，可以通过注解方便的测试Spring程序。

1.2.5 方便集成各种优秀框架

        Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架(如Struts,Hibernate、Hessian、Quartz)等的直接支持

1.2.6 降低Java EE API的使用难度

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

2. spring环境准备

2.1 spring官网

http://spring.io/

2.2 包的下载

在官网上下载 spring-framework-4.2.4.RELEASE-dist.zip 全量包，解压之后，有三个目录

docs：Spring的开发规范和API

libs：Spring的开发的jar和源码

schema：Spring的配置文件的约束

下载spring-framework-3.0.2.RELEASE-dependencies依赖，解压之后，有很多依赖jar包，用于开发的时候引入

3. spring框架runtime图解

1. Test：整合单元测试，与Junit整合，让单元测试变得更加简单

2. Core container：核心容器也就是IOC，包含了4块，beans，core，context与spel

3. AOP：aop与aspects（是第三方的一个AOP的开发）

4. web：就是spring的web，包括SpringMVC

5. Data Access：数据访问的一块

这整个是spring的体系结构

4. 初识Spring IOC

4.1 IOC的概念

1. IOC就是spring中大名鼎鼎的控制反转，即将对象的创建权反转给（交给）Spring。

2. IOC对应着Spring的Runtime图解中的核心容器（core container）

3. IOC的实现原理：工厂 + 反射 + 配置文件来实现程序的解耦。

当我们在xml中配置一个bean的时候，会给一个id，同时给一个class，spring就可以根据这个id找到对应的class，然后通过return Class.forName(class_name).newInstance()，将对应的实例返回给外部对象使用。

4.2 通过demo来了解IOC

通过一个demo工程来了解IOC

4.2.1. 新建一个web项目

4.2.2. 引入jar包

因为我们主要是用来了解IOC，所以，我们只需要引入spring的核心包也就是core container部分的jar即可

1. 引入spring相关包

1.1 beans：spring-beans-4.2.4.RELEASE.jar、spring-beans-4.2.4.RELEASE-sources.jar

1.2 core：spring-core-4.2.4.RELEASE.jar、spring-core-4.2.4.RELEASE-sources.jar

1.3 context：spring-context-4.2.4.RELEASE.jar、spring-context-4.2.4.RELEASE-sources.jar

1.4 spel：spring-expression-4.2.4.RELEASE.jar、spring-expression-4.2.4.RELEASE-sources.jar

注意：source的jar都是源码包，引入的目的是为了便于查看源码

2. 引入日记记录的包

2.1 接口规范：com.springsource.org.apache.commons.logging-1.1.1.jar

2.2 log4j：com.springsource.org.apache.log4j-1.2.15.jar

注意：

1. 在上面下载的spring依赖包中，找到这两个包

2. 接口规范是Apache提供的一个日志记录的接口规范，具体做实现的还是log4j，所以我们需要引入这两个包

4.2.3 配置文件

1. 新建xml配置文件

在src目录下，新建一个名为applicationContext.xml的文件

注意：文件名称任意。

2. 写约束

约束怎么写了，在哪里找了，我们可以在spring的开发规范中的开发文档中docs\spring-framework-reference\html目录下，有一个叫做xsd-configuration的html文件，打开它，滚动到最下面，有一个叫做the beans schema的说明，将下面的代码，粘贴到我们的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"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="foo" class="x.y.Foo">
        <meta key="cacheName" value="foo"/>
        <property name="name" value="Rick"/>
    </bean>

</beans>

然后，修改bean标签的内容为我们项目的内容即可。

注意：spring的其他约束配置都在该文件中可以找到。

3. 配置Bean

<bean id="userDao" class="com.itcast.spring.demo1.UserDaoImpl"></bean>

4.2.4 编写测试类

操作步骤：

1. 创建Spring的工厂

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

2. 通过工厂与bean的id得到对象

UserDao bean = (UserDao)application.getBean("userDao");

3. 调用对象的方法

bean.showName();

完整的测试方法

public void demo2(){
	ApplicationContext application = new ClassPathXmlApplicationContext("applicationContext.xml");
	UserDao bean = (UserDao)application.getBean("userDao");
	bean.showName();
}

注意：spring程序的运行依赖于日志，所以我们运行前，需要复制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

5. IOC与DI

IOC：控制反转

DI：依赖注入，依赖注入的前提是要有IOC的环境，当我们的类交给spring去管理的时候，spring会将该类依赖的属性注入（设置）进去。

在传统开发模式中，当我们需要给对象设置属性值的时候，我们必须创建该类的对象，并且，如果接口中没有该属性的定义，我们接收类型也必须为该类，而不能是接口，然后调用相应的方法给属性赋值。

例如：接收对象只能是UserDaoImpl而不能是UserDao

// UserDao userDao = new UserDaoImpl();
UserDaoImpl userDao = new UserDaoImpl();
userDao.setName("张三");

在spring中，通过依赖注入，我们只需要在bean标签中通过property标签配置一下属性即可。

例如：在property标签中配置name，代码不需要做任何变化

<bean id="userDao" class="com.itcast.spring.demo1.UserDaoImpl">
    <property name="name" value="lisi"></property>
</bean>

我们在运营demo的时候，name的值就被设置进来了，这个设置的过程就叫做DI，即，Spring在帮我们创建类的实例的过程中，发现该类有一个name的属性，这叫做依赖，然后通过property的配置将name的值进来，这叫注入。

总结：DI的含义就是Spring在管理类的过程中，将类的属性设置进来，这就是DI。