一、Spring的基础入门 SSM框架，对Spring框架入门讲述，傻瓜式操作的入门操作

学习目标

• 了解 spring的概念与优点
• 熟系 spring中的IOC和DI
• 掌握
  • applicationContext容器
  • 使用属性setter方法注入的实现

---

一、Spring的基础入门

软件安装环境，这里就不做叙述了

1.1 Spring的概述

Spring+SpringMVC+MyBatis框架集由Spring、MyBatis两个开源框架整合而成（SpringMVC是Spring中的部分内容）。

几个框架概述

Spring

Spring就像是整个项目中装配bean的大工厂，在配置文件中可以指定使用特定的参数去调用实体类的构造方法来实例化对象。也可以称之为项目中的粘合剂。

Spring的核心思想是IoC（控制反转），即不再需要程序员去显式地new一个对象，而是让Spring框架帮你来完成这一切。

mybatis

mybatis是对jdbc的封装，它让数据库底层操作变的透明。mybatis的操作都是围绕一个sqlSessionFactory实例展开的。mybatis通过配置文件关联到各实体类的Mapper文件，Mapper文件中配置了每个类对数据库所需进行的sql语句映射。在每次与数据库交互时，通过sqlSessionFactory拿到一个sqlSession，再执行sql命令。

SpringMVC

SpringMVC在项目中拦截用户请求，它的核心Servlet即DispatcherServlet承担中介或是前台这样的职责，将用户请求通过HandlerMapping去匹配Controller，Controller就是具体对应请求所执行的操作。SpringMVC相当于SSH框架中struts。

SSM和SSH

SSM优势：
SSM越来越轻量级配置，将注解开发发挥到极致，且ORM实现更加灵活，SQL优化更简便。
SSH优势：
而SSH较注重配置开发，其中的Hiibernate对JDBC的完整封装更面向对象，对增删改查的数据维护更自动化，但SQL优化方面较弱，且入门门槛稍高。

Spring详讲

什么是Spring？

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

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

表示层：在表示层提供了与Struts等框架的整合

业务逻辑层：在业务逻辑层可以管理事务、记录日志等

持久层：在持久层可以整合Hibernate、JdbcTemplate等技术

Spring框架的优点

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

Spring的体系结构

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

• Beans：提供了BeanFactory，Spring将管理对象称为Bean。

• Core： Spring3.0后新增的模块，是运行时查询和操作对象图。

• Context: 建立在Core和Beans模块的基础之上，它是访问定义和配置的任何对象的媒介。

• SpEl: Spring3.0后新增的模块，是运行时查询和操作对象图的强大的表达式语言。

JDBC:提供了一个JDBC的抽象层，大幅度的减少了在开发过程中对数据库操作的编码。

ORM: 对流行的对象关系映射API，包括JPA、JDO和Hibernate提供了集成层支持。

Transactions:支持对实现特殊接口以及所有POJO类的编程和声明式的事务管理。

Servlet: 也称Spring-webmvc模块，包含Spring模型—视图—控制器（MVC）和REST Web Services实现的Web程序

Web:提供了基本的Web开发集成特性，如：多文件上传、使用Servlet监听器来初始化IoC容器以及Web应用上下文。

Aop: 提供了面向切面编程实现，允许定义方法拦截器和切入点，将代码按照功能进行分离，以降低耦合性。

Aspects: 提供了与AspectJ的集成功能，AspectJ是一个功能强大且成熟的面向切面编程（AOP）框架。

Spring的下载及目录结构

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

Spring框架包
第三方依赖包

点击上面蓝体字下载就好

框架包下载后的解压目录如下：

• libs文件夹中包含JAR包和源码
• docs文件夹中包含API文档和开发规范
• Schema文件夹中包含开发所需要的schema文件

打开libs目录可以看到60个JAR文件，具体如下

后缀结尾	内容划分
RELEASE.jar	class文件JAR包
RELEASE-javadoc.jar	API文档压缩包
RELEASE-sources.jar	源文件压缩包

libs目录中有四个Spring的基础包，分别对应Spring核心容器的四个模块
spring-core-4.3.6.RELEASE.jar
包含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的表达式语言

1.2 Spring的核心容器

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

BeanFactory

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

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

上述内容中
F: /applicationContext.xml
是XML配置文件的位置

ApplicationContext

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

通过ClassPathXmlApplicationContext创建

ApplicationContext applicationContext =
                                     new ClassPathXmlApplicationContext(String configLocation);

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

通过FileSystemXmlApplicationContext创建

ApplicationContext applicationContext =
                                 new FileSystemXmlApplicationContext(String configLocation);

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

在Java项目中，会通过ClassPathXmlApplicationContext类来实例化ApplicationContext容器。而在Web项目中，ApplicationContext容器的实例化工作会交由Web服务器来完成。

Web服务器实例化ApplicationContext容器时，通常会使用ContextLoaderListener来实现，此种方式只需要在web.xml中添加如下代码：

    <context-param>
               <param-name>contextConfigLocation</param-name> 
               <param-value>
                          classpath:spring/applicationContext.xml
               </param-value>
       </context-param> 
       <listener>
               <listener-class>
                         org.springframework.web.context.ContextLoaderListener
               </listener-class>
       </listener>

1.3 Spring的入门程序

傻瓜式操作步骤

• 第一步，安装开发所需的架包
  • 在Eclipse中，创建一个名为chapter01的Web项目，将Spring的4个基础包以及commons-logging的JAR包复制到lib目录中，并发布到类路径下。

• 第二步，创建用户类
  • 在src目录下，创建一个com.itheima.ioc包，并在包中创建接口UserDao，然后在接口中定义一个say()方法。

 package com.itheima.ioc;
        public interface UserDao {
   	public void say();
        }

• 第三步，创建用户类接口
  • 在com.itheima.ioc包下，创建UserDao接口的实现类UserDaoImpl，该类需要实现接口中的say()方法，并在方法中编写一条输出语句。

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

• 第四步，配置语言标准
  • 在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-4.3.xsd"> 
             <bean id="userDao" class="com.itheima.ioc.UserDaoImpl" />
       </beans>

• 第五步，做程序测试
  • 在com.itheima.ioc包下，创建测试类TestIoC，并在类中编写main()方法。在main()方法中，需要初始化Spring容器，并加载配置文件，然后通过Spring容器获取userDao实例（即Java对象），最后调用实例中的say()方法。

package com.itheima.ioc;
        import org.springframework.context.ApplicationContext;
        import  org.springframework.context.support.ClassPathXmlApplicationContext;
        public class TestIoC {
               public static void main(String[] args) { 
 	       ApplicationContext applicationContext = 
	              new ClassPathXmlApplicationContext("applicationContext.xml"); 
                      UserDao userDao = (UserDao) applicationContext.getBean("userDao");
 	      userDao.say();
              }
       }

执行结果为

1.4 依赖注入

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

1. IOC
   在使用Spring框架之后，对象的实例不再由调用者来创建，而是由Spring容器来创建，Spring容器会负责控制程序之间的关系，而不是由调用者的程序代码直接控制。这样，控制权由应用代码转移到了Spring容器，控制权发生了反转，这就是控制反转。
2. DI
   从Spring容器的角度来看，Spring容器负责将被依赖对象赋值给调用者的成员变量，这相当于为调用者注入了它依赖的实例，这就是Spring的依赖注入。

依赖注入的傻瓜式实现方式

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

  package com.itheima.ioc;
        public interface UserService {
                 public void say();
        }

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

 package com.itheima.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. 在配置文件applicationContext.xml中，创建一个id为userService的Bean，该Bean用于实例化UserServiceImpl类的信息，并将userDao的实例注入到userService中。

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

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

package com.itheima.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();
	}
        }

执行结果

知识回顾

本章主要介绍了Spring框架入门的一些基础知识，包括Spring的概念、优点、体系结构、核心容器、依赖注入等,同时通过一个入门程序讲解了Spring的基本使用。

通过本章的学习，读者可以对Spring框架及其体系结构有一个初步的了解，能够初步的掌握Spring框架的使用，并能够理Spring框架中IoC和DI的思想，掌握属性setter方法注入的实现。