我們項目中用到的jar包可以通過依賴的方式引入，構建項目的時候從Maven倉庫下載即可。

1. 依賴配置
依賴可以聲明如下：

1. <project>
2. ...
3. <dependencies>
4. <dependency>
5. <groupId>group-a</groupId>
6. <artifactId>artifact-a</artifactId>
7. <version>1.0</version>
8. <exclusions>
9. <exclusion>
10. <groupId>group-c</groupId>
11. <artifactId>excluded-artifact</artifactId>
12. </exclusion>
13. </exclusions>
14. </dependency>
15. <dependency>
16. <groupId>group-a</groupId>
17. <artifactId>artifact-b</artifactId>
18. <version>1.0</version>
19. <type>bar</type>
20. <scope>runtime</scope>
21. </dependency>
22. </dependencies>
23. </project>

我們在Maven實戰(二)中就遇到了依賴的概念，項目中測試需要依賴junit jar包，依賴配置如下：

1. <dependencies>
2. <dependency>
3. <groupId>junit</groupId>
4. <artifactId>junit</artifactId>
5. <version>3.8.1</version>
6. <scope>test</scope>
7. </dependency>
8. </dependencies>

依賴會包含基本的groupId, artifactId,version等元素，根元素project下的dependencies可以包含一個或者多個dependency元素，以聲明一個或者多個依賴。
下面詳細講解每個依賴可以包含的元素：

groupId,artifactId和version：依賴的基本坐標，對於任何一個依賴來說，基本坐標是最重要的，Maven根據坐標才能找到需要的依賴

type: 依賴的類型，對應於項目坐標定義的packaging。大部分情況下，該元素不必聲明，其默認值是jar

scope: 依賴的範圍，下面會進行詳解

optional: 標記依賴是否可選

exclusions: 用來排除傳遞性依賴，下面會進行詳解

大部分依賴聲明只包含基本坐標。

2. 依賴範圍

Maven在編譯主代碼的時候需要使用一套classpath,在編譯和執行測試的時候會使用另一套classpath,實際運行項目的時候，又會使用一套classpath。

依賴範圍就是用來控制依賴與這三種classpath(編譯classpath、測試classpath、運行classpath)的關系，Maven有以下幾種依賴範圍：

compile: 編譯依賴範圍。如果沒有指定，就會默認使用該依賴範圍。使用此依賴範圍的Maven依賴，對於編譯、測試、運行三種classpath都有效。

test: 測試依賴範圍。使用此依賴範圍的Maven依賴，只對於測試classpath有效，在編譯主代碼或者運行項目的使用時將無法使用此類依賴。典型的例子就是JUnit，它只有在編譯測試代碼及運行測試的時候才需要。

provided: 已提供依賴範圍。使用此依賴範圍的Maven依賴，對於編譯和測試classpath有效，但在運行時無效。典型的例子是servlet-api，編譯和測試項目的時候需要該依賴，但在運行項目的時候，由於容器已經提供，就不需要Maven重復地引入一遍。

runtime: 運行時依賴範圍。使用此依賴範圍的Maven依賴，對於測試和運行classpath有效，但在編譯主代碼時無效。典型的例子是JDBC驅動實現，項目主代碼的編譯只需要JDK提供的JDBC接口，只有在執行測試或者運行項目的時候才需要實現上述接口的具體JDBC驅動。

system: 系統依賴範圍。該依賴與三種classpath的關系，和provided依賴範圍完全一致。但是，使用system範圍依賴時必須通過systemPath元素顯式地指定依賴文件的路徑。由於此類依賴不是通過Maven倉庫解析的，而且往往與本機系統綁定，可能造成構建的不可移植，因此應該謹慎使用。systemPath元素可以引用環境變量，如：

1. <dependency>
2. <groupId>javax.sql</groupId>
3. <artifactId>jdbc-stdext</artifactId>
4. <version>2.0</version>
5. <scope></scope>
6. <systemPath>${java.home}/lib/rt.jar</systemPath>
7. </dependency>

import(Maven 2.0.9及以上): 導入依賴範圍。該依賴範圍不會對三種classpath產生實際的影響，稍後會介紹到。

3. 傳遞性依賴

下面我們看一個簡單的項目，讀者可從附件中下載源碼

POM.xml配置如下：

1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
3. <modelVersion>4.0.0</modelVersion>
5. <groupId>com.mycompany.app</groupId>
6. <artifactId>my-app-simple</artifactId>
7. <version>0.0.1-SNAPSHOT</version>
8. <packaging>jar</packaging>
10. <name>my-app-simple</name>
11. <url>http://maven.apache.org</url>
13. <properties>
14. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
15. </properties>
17. <dependencies>
18. <dependency>
19. <groupId>junit</groupId>
20. <artifactId>junit</artifactId>
21. <version>3.8.1</version>
22. <scope>test</scope>
23. </dependency>
25. <dependency>
26. <groupId>org.springframework</groupId>
27. <artifactId>spring-core</artifactId>
28. <version>2.5.6</version>
29. </dependency>
30. </dependencies>
31. </project>

我們可以看到此項目引入依賴junit和spring-core，我們可以在Maven倉庫中查找spring-core構件，如圖：

點擊POM我們會看到該文件包含了一個commons-logging依賴：

1. <dependency>
2. <groupId>commons-logging</groupId>
3. <artifactId>commons-logging</artifactId>
4. <version>1.1.1</version>
5. </dependency>

那麽該依賴會傳遞到當前項目中，這就是依賴的傳遞性，打開項目查看Maven dependencies:

4. 可選依賴

有時候我們不想讓依賴傳遞，那麽可配置該依賴為可選依賴，將元素optional設置為true即可,例如：

1. <dependency>
2. <groupId>commons-logging</groupId>
3. <artifactId>commons-logging</artifactId>
4. <version>1.1.1</version>
5. <optional>true<optional>
6. </dependency>

那麽依賴該項目的另以項目將不會得到此依賴的傳遞

5. 排除依賴

當我們引入第三方jar包的時候，難免會引入傳遞性依賴，有些時候這是好事，然而有些時候我們不需要其中的一些傳遞性依賴

比如上例中的項目，我們不想引入傳遞性依賴commons-logging，我們可以使用exclusions元素聲明排除依賴，exclusions可以包含一個或者多個exclusion子元素，因此可以排除一個或者多個傳遞性依賴。需要註意的是，聲明exclusions的時候只需要groupId和artifactId，而不需要version元素，這是因為只需要groupId和artifactId就能唯一定位依賴圖中的某個依賴。換句話說，Maven解析後的依賴中，不可能出現groupId和artifactId相同，但是version不同的兩個依賴。

如下是一個排除依賴的例子：

1. <dependency>
2. <groupId>org.springframework</groupId>
3. <artifactId>spring-core</artifactId>
4. <version>2.5.6</version>
5. <exclusions>
6. <exclusion>
7. <groupId>commons-logging</groupId>
8. <artifactId>commons-logging</artifactId>
9. </exclusion>
10. </exclusions>
11. </dependency>

5. 依賴歸類

如果我們項目中用到很多關於Spring Framework的依賴，它們分別是org.springframework:spring-core:2.5.6, org.springframework:spring-beans:2.5.6,org.springframework:spring-context:2.5.6,它們都是來自同一項目的不同模塊。因此，所有這些依賴的版本都是相同的，而且可以預見，如果將來需要升級Spring Framework，這些依賴的版本會一起升級。因此，我們應該在一個唯一的地方定義版本，並且在dependency聲明引用這一版本，這一在Spring Framework升級的時候只需要修改一處即可。

1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
3. <modelVersion>4.0.0</modelVersion>
5. <groupId>com.mycompany.app</groupId>
6. <artifactId>my-app-simple</artifactId>
7. <version>0.0.1-SNAPSHOT</version>
8. <packaging>jar</packaging>
9. <name>my-app-simple</name>
10. <properties>
11. <springframework.version>2.5.6</springframework.version>
12. </properties>
14. <dependencies>
15. <dependency>
16. <groupId>junit</groupId>
17. <artifactId>junit</artifactId>
18. <version>3.8.1</version>
19. <scope>test</scope>
20. </dependency>
22. <dependency>
23. <groupId>org.springframework</groupId>
24. <artifactId>spring-core</artifactId>
25. <version>${springframework.version}</version>
26. </dependency>
27. <dependency>
28. <groupId>org.springframework</groupId>
29. <artifactId>spring-beans</artifactId>
30. <version>${springframework.version}</version>
31. </dependency>
32. </dependencies>
33. </project>

6. 在Eclipse中管理依賴

安裝好m2eclipse之後（第2課有詳細講解）就可以用eclipse來管理依賴。

如圖，在該項目的pom.xml中點擊Dependency Hierarchy可以看到依賴樹:

點擊Dependencies可以添加新的依賴，點擊選擇一個依賴，點擊remove可以刪除，點擊Add可以新增一個依賴，如圖：

如下圖，搜素org.springframework（此處是從Maven中心倉庫進行搜索），選擇你想要的模塊和版本，點擊OK即可：

maven入門（8）maven的依賴管理