一起学Spring之基础篇

本文主要讲解Spring的基础环境搭建以及演变由来，仅供学习分享使用，如有不足之处，还请指正。

什么是Spring ?

Spring是一个开源框架，用来处理业务逻辑层和其他层之间的耦合问题。因此Spring将面向接口开发的思想贯穿整个系统应用，且Spring是一个轻量级框架，所以在诞生之初，便风靡Java开发市场，得到了广泛的认可与响应。

Spring基础概念

依赖注入（DI:Dependency Injection）又叫控制反转（IoC:Inversion of Control）：将组件对象的控制权从代码本身，转移到外部容器。Spring容器也是一个IoC容器，用来管理所有的Java Bean，主要是通过BeanFactory来进行产生和管理Bean。

Spring框架搭建

1. 建立一个Java Project

Spring框架是即支持Java Project，又支持Dynamic Web Project，如下所示：

2. 导入Spring框架需要的Jar包

Spring框架搭建需要的包共6个，如下所示：

//日志包
commons-logging-1.1.1.jar
//spring核心包
spring-aop-4.0.6.RELEASE.jar
spring-beans-4.0.6.RELEASE.jar
spring-context-4.0.6.RELEASE.jar
spring-core-4.0.6.RELEASE.jar
spring-expression-4.0.6.RELEASE.jar

3. 配置Spring配置文件

对于Java Project来说，applicationContext.xml必须放在src目录，如下所示：

<?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">
     <!-- 此文件默认放置在src目录 -->
     <!-- id表示唯一标识，class表示类型，必须为全路径 -->
    <bean id="student" class="com.hex.first.Student">
        <property name="id" value="1"></property>
        <property name="name" value="hex"></property>
        <property name="age" value="20"></property>
    </bean>
</beans>

对于配置文件中的Student类，定义如下：

package com.hex.first;

/**
 * 定义一个学生类
 * @author Administrator
 *
 */
public class Student {
    
    /*
     * 学生ID
     */
    private int id;

    /*
     * 学生姓名
     */
    private String name;
    
    /**
     * 年龄
     */
    private int age;
    
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "ID="+id+",Name="+name+",Age="+age;
    }
}

4. 声明对象

对于常规声明对象和采用Spring获取对象的方式如下：

//常规New对象方法声明一个对象
Student student=new Student();
student.setId(1);
student.setName("hex");
student.setAge(20);
System.out.println(student);
//通过Spring进行注入，Spring上下文对象
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
//从Spring的IOC容器中获取id为student的bean对象
Student student01=(Student) context.getBean("student");
System.out.println(student01);

5. 测试结果

如下所示：

采用Spring方式和传统方式的区别有哪些

传统方式全部采用硬编码的方式，一旦有变动，就需要修改代码，而Spring采用注入的方式，将可变的东西放在配置文件中，便于修改。

1. 首先假设一种场景，学生有一个学习课程的需求

关于课程的接口（ICourse），定义如下：

/**
 * 定义一个课程接口
 * @author Administrator
 *
 */
public interface ICourse {
    
    /**
     * 学习
     */
    void learn();
}

分别有两个实现类：JavaCourse和HtmlCourse，代码如下：

package com.hex.first;

/**
 * 学习Java课程
 * @author Administrator
 *
 */
public class JavaCourse implements ICourse {

    @Override
    public void learn() {
        System.out.println("学习Java课程。。。");

    }

}

和

package com.hex.first;

/**
 * 学习Html课程
 * @author Administrator
 *
 */
public class HtmlCourse implements ICourse {

    @Override
    public void learn() {
        System.out.println("学习Html课程。。。");

    }

}

如果一个学生要学习这两门课程，有以下三种实现方案：

1. 第一种：原始的多态方法

在Student类中增加两个方法，分别用来学习Java和Html，如下所示：

    /**
     * 学习Java
     */
    public void learnJava(){
        ICourse course=new JavaCourse();
        course.learn();
    }
    
    /**
     * 学习Html
     */
    public void learnHtml(){
        ICourse course=new HtmlCourse();
        course.learn();
    }

调用代码如下：

//第1种，最原始的多态方法
System.out.println("第1种，最原始的多态方法:");
student.learnJava();
student.learnHtml();

备注：此方案导致学生和课程之间形成强耦合关系，假如需要增加一种学习Python语言的课程，需要增加接口的实现类（PythonCourse），修改Student类，增加learnPython方法，改动较大，或者有些学生只学其中一门课程，而另一些学生学两门课程，采用此方案会比较麻烦。

2. 第二种：采用简单工厂方法，将课程的创建抽离出来，由工厂统一管理。

在Student中增加一个学习（learn）方法：

        /**
     * 学习通过参数区分
     * @param name
     */
    public void learn(String name){
        ICourse course=CourseFactory.getCourse(name);
        course.learn();
    }

增加工厂类（CourseFactory）

package com.hex.first;

/**
 * 课程工厂
 * @author Administrator
 *
 */
public class CourseFactory {
    
    /**
     * 获取课程对象
     * @param name
     * @return
     */
    public static ICourse getCourse(String name){
        if(name.equals("java")){
            return new JavaCourse();
        }else{
            return new HtmlCourse();
        }
    }
}

然后客户端调用时只需要传字符串就行。如下所示：

//第2种，简单工厂方法
System.out.println("第2种，简单工厂方法:");
student.learn("java");
student.learn("html");

备注：此方案虽然将对象的创建剥离出来，由工厂进行管理，但是课程的类型还是硬编码的，还是不够完善。

3. 第三种：采用Spring的方式，实现对象的动态注入

在学生类中增加学习方法，参数是ICourse接口：

        /**
     * 传递接口
     * @param course
     */
    public void learn(ICourse course){
        course.learn();
    }
    

在Spring配置文件中，配置要注入的对象：

<!-- 两个对象，没有属性，不需要赋值 -->
<bean id="java" class="com.hex.first.JavaCourse"></bean>
<bean id="html" class="com.hex.first.HtmlCourse"></bean>

通过Spring来获取对象，实现动态控制：

//第3种，通过SpringIOC实现
System.out.println("第3种，通过SpringIOC实现:");
ICourse course=(ICourse)context.getBean("java");
student.learn(course);
ICourse course2=(ICourse)context.getBean("html");
student.learn(course2);

以上三种方式，均可以实现需求，至于采用哪种方案，可以依据具体实际场景而定。

备注

没有伞的孩子，必须努力奔跑！

期待一树花开，愿你叶落归来。