一起學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個，如下所示：

1 //日誌包
2 commons-logging-1.1.1.jar
3 //spring核心包
4 spring-aop-4.0.6.RELEASE.jar
5 spring-beans-4.0.6.RELEASE.jar
6 spring-context-4.0.6.RELEASE.jar
7 spring-core-4.0.6.RELEASE.jar
8 spring-expression-4.0.6.RELEASE.jar

3. 配置Spring配置文件

對於Java Project來說，applicationContext.xml必須放在src目錄，如下所示：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4 xsi:schemaLocation="http://www.springframework.org/schema/beans
 5  http://www.springframework.org/schema/beans/spring-beans.xsd">
 6      <!-- 此文件預設放置在src目錄 -->
 7      <!-- id表示唯一標識，class表示類型，必須為全路徑 -->
 8     <bean id="student" class="com.hex.first.Student">
 9         <property name="id" value="1"></property>
10         <property name="name" value="hex"></property>
11         <property name="age" value="20"></property>
12     </bean>
13 </beans>

對於配置文件中的Student類，定義如下：

 1 package com.hex.first;
 2 
 3 /**
 4  * 定義一個學生類
 5  * @author Administrator
 6  *
 7  */
 8 public class Student {
 9     
10     /*
11      * 學生ID
12      */
13     private int id;
14 
15     /*
16      * 學生姓名
17      */
18     private String name;
19     
20     /**
21      * 年齡
22      */
23     private int age;
24     
25     public int getId() {
26         return id;
27     }
28     public void setId(int id) {
29         this.id = id;
30     }
31     public String getName() {
32         return name;
33     }
34     public void setName(String name) {
35         this.name = name;
36     }
37     public int getAge() {
38         return age;
39     }
40     public void setAge(int age) {
41         this.age = age;
42     }
43     
44     @Override
45     public String toString() {
46         // TODO Auto-generated method stub
47         return "ID="+id+",Name="+name+",Age="+age;
48     }
49 }

4. 聲明對象

對於常規聲明對象和採用Spring獲取對象的方式如下：

 1 //常規New對象方法聲明一個對象
 2 Student student=new Student();
 3 student.setId(1);
 4 student.setName("hex");
 5 student.setAge(20);
 6 System.out.println(student);
 7 //通過Spring進行註入，Spring上下文對象
 8 ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
 9 //從Spring的IOC容器中獲取id為student的bean對象
10 Student student01=(Student) context.getBean("student");
11 System.out.println(student01);

5. 測試結果

如下所示：

採用Spring方式和傳統方式的區別有哪些

傳統方式全部採用硬編碼的方式，一旦有變動，就需要修改代碼，而Spring採用註入的方式，將可變的東西放在配置文件中，便於修改。

1. 首先假設一種場景，學生有一個學習課程的需求

關於課程的介面（ICourse），定義如下：

 1 /**
 2  * 定義一個課程介面
 3  * @author Administrator
 4  *
 5  */
 6 public interface ICourse {
 7     
 8     /**
 9      * 學習
10      */
11     void learn();
12 }

分別有兩個實現類：JavaCourse和HtmlCourse，代碼如下：

 1 package com.hex.first;
 2 
 3 /**
 4  * 學習Java課程
 5  * @author Administrator
 6  *
 7  */
 8 public class JavaCourse implements ICourse {
 9 
10     @Override
11     public void learn() {
12         System.out.println("學習Java課程。。。");
13 
14     }
15 
16 }

和

 1 package com.hex.first;
 2 
 3 /**
 4  * 學習Html課程
 5  * @author Administrator
 6  *
 7  */
 8 public class HtmlCourse implements ICourse {
 9 
10     @Override
11     public void learn() {
12         System.out.println("學習Html課程。。。");
13 
14     }
15 
16 }

如果一個學生要學習這兩門課程，有以下三種實現方案：

1. 第一種：原始的多態方法

在Student類中增加兩個方法，分別用來學習Java和Html，如下所示：

 1     /**
 2      * 學習Java
 3      */
 4     public void learnJava(){
 5         ICourse course=new JavaCourse();
 6         course.learn();
 7     }
 8     
 9     /**
10      * 學習Html
11      */
12     public void learnHtml(){
13         ICourse course=new HtmlCourse();
14         course.learn();
15     }

調用代碼如下：

1 //第1種，最原始的多態方法
2 System.out.println("第1種，最原始的多態方法:");
3 student.learnJava();
4 student.learnHtml();

備註：此方案導致學生和課程之間形成強耦合關係，假如需要增加一種學習Python語言的課程，需要增加介面的實現類（PythonCourse），修改Student類，增加learnPython方法，改動較大，或者有些學生只學其中一門課程，而另一些學生學兩門課程，採用此方案會比較麻煩。

2. 第二種：採用簡單工廠方法，將課程的創建抽離出來，由工廠統一管理。

在Student中增加一個學習（learn）方法：

1         /**
2      * 學習通過參數區分
3      * @param name
4      */
5     public void learn(String name){
6         ICourse course=CourseFactory.getCourse(name);
7         course.learn();
8     }

增加工廠類（CourseFactory）

 1 package com.hex.first;
 2 
 3 /**
 4  * 課程工廠
 5  * @author Administrator
 6  *
 7  */
 8 public class CourseFactory {
 9     
10     /**
11      * 獲取課程對象
12      * @param name
13      * @return
14      */
15     public static ICourse getCourse(String name){
16         if(name.equals("java")){
17             return new JavaCourse();
18         }else{
19             return new HtmlCourse();
20         }
21     }
22 }

然後客戶端調用時只需要傳字元串就行。如下所示：

1 //第2種，簡單工廠方法
2 System.out.println("第2種，簡單工廠方法:");
3 student.learn("java");
4 student.learn("html");

備註：此方案雖然將對象的創建剝離出來，由工廠進行管理，但是課程的類型還是硬編碼的，還是不夠完善。

3. 第三種：採用Spring的方式，實現對象的動態註入

在學生類中增加學習方法，參數是ICourse介面：

1         /**
2      * 傳遞介面
3      * @param course
4      */
5     public void learn(ICourse course){
6         course.learn();
7     }
8     

在Spring配置文件中，配置要註入的對象：

1 <!-- 兩個對象，沒有屬性，不需要賦值 -->
2 <bean id="java" class="com.hex.first.JavaCourse"></bean>
3 <bean id="html" class="com.hex.first.HtmlCourse"></bean>

通過Spring來獲取對象，實現動態控制：

1 //第3種，通過SpringIOC實現
2 System.out.println("第3種，通過SpringIOC實現:");
3 ICourse course=(ICourse)context.getBean("java");
4 student.learn(course);
5 ICourse course2=(ICourse)context.getBean("html");
6 student.learn(course2);

以上三種方式，均可以實現需求，至於採用哪種方案，可以依據具體實際場景而定。

備註

沒有傘的孩子，必須努力奔跑！

期待一樹花開，願你葉落歸來。