Spring 入门

声明：本教程均在Spring4.0.4版本中实现

目前Java EE主流的轻量级开发框架有SSH(Struts+spring+Hibernate)和SSM(Spring+Sprng MVC+Mybatis),从中可以看出，无论是SSH还是SSM，Spring在Java开发中有着重要的作用。

Spring以IoC、AOP维主要思想，它是一个“一站式”框架，即在 Java EE的三层架构，即表现层（Web层）、业务逻辑层（Service层）、数据访问层（DAO）层中，每一层均提供了不同的解决技术。

当使用Spring框架时，必须使用Spring Core Container（即Spring容器），它是Spring的核心机制，主要由org.springframework.core、org.springframework.beans、org.springframework.context、prg.springframework.expression四个包及其子包组成，主要提供Spring IoC容器支持。

一 Maven依赖

本教程全都基于Maven管理工具来构建基于 Spring 框架的应用，因此基础Maven依赖主要包括三个spring-core、spring-context、spring-beans

<!-- spring-core -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>4.0.4.RELEASE</version>
</dependency>
<!-- spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.0.4.RELEASE</version>
</dependency>
<!-- Spring-beans -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>4.0.4.RELEASE</version>
</dependency>

二 Spring Bean概念

Spring 核心容器像是一个超级大工厂，所有的Java对象都会成为 Spring 核心容器的管理对象，Spring把容器中的一切管理对象成为Bean。

Spring容器中的Bean和Java Bean不同，它不需要像 Java Bean 那样遵守一些规范，Spring对Bean没有任何的要求。在 Spring 中，一切 Java 对象，都是Bean。

下面我们先创建一个简单的 Java 类

package org.crazyit.app.service;

public class Axe {
    public String chop() {
        return "使用斧头劈柴";
    }
}

接着我们在创建一个 Person 类，在 Person 类的 useAxe() 方法中使用 Axe 对象的 chop() 方法，这样 Person 对象就依赖于 Axe对象。

package org.crazyit.app.service;

public class Person {
    private Axe axe;zhong

    public void setAxe(Axe axe) {
        this.axe = axe;
    }

    public void useAxe() {
        System.out.println("我打算去砍点柴火！");
        // 调用 axe 的 chop() 方法
        // 表明 Person 对象依赖于 axe 对象
        System.out.print(axe.chop());
    }
}

我们创建好 Java 类后，如何让它们成为Spring Bean，这就要通过XML配置文件或者注解来让 Spring 管理这些 Bean，该配置文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!--  Spring 配置文件的根元素没使用spring-beans-4.0.xsd 语义约束-->
<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">
    <!--配置名为person的Bean，其实现类为org.crazyit.app.service.Person-->
    <bean id="person" class="org.crazyit.app.service.Person">
        <!--控制调用setAxe()方法，将容器的名为axe的Bean作为参数传入-->
        <property name="axe" ref="axe" />
    </bean>
    <!--配置名为axe的Bean，其实现类为org.crazyit.app.service.Axe-->
    <bean id="axe" class="org.crazyit.app.service.Axe" />
    <!--配置名为win的Bean，其实现类为javax.swing.JFrame-->
    <bean id="win" class="javax.swing.JFrame" />
    <!--配置名为date的Bean，其实现类为java.util.Date-->
    <bean id="date" class="java.util.Date" />
</beans>

该配置文件的根元素维<bean.../>,它包括多个<bean.../>元素，每个<bean.../>元素定义一个Bean，上面的配置文件共定义了四个Bean，其中两个为我们自定义的 Java 类，后面两个使用了 JDK 标准库中的类，这和前面说的 Spring中,一切 Java 对象皆可为 Bean一致。

我们通过如下元素来将 Java 类变为 Bean，

<!--配置名为axe的Bean，其实现类为org.crazyit.app.service.Axe-->
<bean id="axe" class="org.crazyit.app.service.Axe" />

其中 id 属性为该 Bean 指定了唯一标志，class 属性指定该Bean要实现哪个类，这个类可以是任何 Java 类：自定义类和标准库类都可以。

<!--配置名为person的Bean，其实现类为org.crazyit.app.service.Person-->
<bean id="person" class="org.crazyit.app.service.Person">
    <!--控制调用setAxe()方法，将容器的名为axe的Bean作为参数传入-->
    <property name="axe" ref="axe" />
</bean>

<bean.../> 元素还可以包含多个 <property.../> 子元素。它用来设置该 Bean 的属性的值，通过调用setter方法来实现，name 属性指定要设置哪个属性的值，ref或value属性决定使用什么内容来作为参数：

1. ref 表示使用容器中的某个 Bean 来作为 setter 的参数；
2. value 指明使用内置对象及其包装类来作为setter参数

底层浅析：

1.<bean.../> 元素默认以反射方式来调用该类的无参构造函数创建 Bean； 其实现方式类似如下代码，以 id 为 person 的Bean为例：

String idStr = ...; // 解析<bean.../>元素的id属性得到该字符串值“person”
string classStr = ...; //解析<bean.../>元素的 class 属性得到该字符串值“org.crazyit.app.service.Person”
class clazz = Class.forName(classStr);
Object obj = class.newInstance();
// container 代表 Spring 容器
container.put(idStr, obj);

2. <property.../>也是通过反射机制来调用对象的 setter 方法来实现的，实现方式如下，以 id 为 person 的Bean为例：

String nameStr = ...; // 解析<property .../>元素的name属性，得到该属性值“axe”
String refStr = ...; //解析<property.../>元素的ref属性得到字符串“axe”
String setterName = "set" + nameStr.substring(0, 1).toUpperCase() + nameStr.substring(1); //生成要调用的setter方法名
//获取容器中名为refStr的Bean，
Object paramBean = container.get(refStr);
Method setter = clazz.getMethos(setterName, paramBean,getClass());
setter.incoke(obj, paramBean)

三 访问 Bean

我们在xml配置文件中配置好Bean和它们的相关依赖后，我们需要通过Spring容器来访问容器中的Bean。ApplicationContext是Spring容器最常用的接口，他有两个实现类：

1. ClassPathXmlApplicationContext：该类从类加载路径下搜索配置文件，并根据配置文件来创建Spring容器；
2. FileSystemXmlApplicationContext：该类从文件系统的相对路径或者绝对路径下去搜索配置文件；

对于应用程序，类加载路径总是不变的，因此通常用ClassPathXmlApplicationContext来创建Spring容器 。代码如下：

package lee;

import org.crazyit.app.service.Person;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BeanTest {
    public static void main(String[] args) {
        //创建Spring容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
        //获取id为person的Bean
        Person p = ctx.getBean("person", Person.class);
        // 调用useAxe() 方法
        p.useAxe();
    }
}

通过Spring容器来获取Bean对象主要由两个方法：

1. Object getBean(String id): 根据容器中Bean的id来获取Bean，该方法需要强制类型转换。
2. T getBean(String id, Class <T> requiredType):根据容器中Bean的id来获取Bean，该方法无需进行强制类型转换。