mvn assembly 命令 mvn scope system

策略一:

对于容器提供的（如:servlet-api-2.3等）和测试需要时的(如:junit-3.81等),可以直接在pom.xml中去掉。

maven的dependency中有一个tag是<scope>option</scope>，其option有以下几个值：

  compile， 缺省值，适用于所有阶段，会随着项目一起发布。

  provided，类似compile，期望JDK、容器或使用者会提供这个依赖。如servlet-api-2.3.jar。

  runtime， 在运行时使用，如JDBC驱动，适用运行和测试阶段。   如plexus-utils-1.1.jar

  test     只在测试时使用，用于编译和运行测试代码。不会随项目发布。如Junit-3.8.1.jar

  system， 类似provided，需要显式提供包含依赖的jar，Maven不会在Repository中查找它。

如:

<dependency>
          <groupId>servletapi</groupId>
          <artifactId>servlet-api</artifactId>
          <version>2.4</version>
<scope>provided</scope>
     </dependency>
          <dependency>
               <groupId>junit</groupId>
               <artifactId>junit</artifactId>
               <version>3.8.1</version>
<scope>test</scope>
          </dependency>

策略二:

对于第三方jar包，传递依赖到war包的，但发布时并不需要的。

如:我们项目中使用了webwork－2.2.3.jar。可以我们在打包后发现在war下的lib中多了spring-web-1.2.jar，可是我们项目并不需要这个jar啊。

第一种办法:借用<scope>provided</scope>

虽然provided的本意是指jdk或者容器提供的，只是编译中使用，但不会打到war中，但我们也可借用。

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>1.2</version>
            <scope>provided</scope>
        </dependency>

第二种办法: 使用exclusions； (效果与第一种相同)

<dependency>
            <groupId>opensymphony</groupId>
            <artifactId>webwork</artifactId>
            <version>2.2.3</version>
              <exclusions>
                    <exclusion>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-web</artifactId>
                    </exclusion>
               </exclusions>
     </dependency>

 

 

 

策略三：

对于我们公司内部开发的jar包,我们都加上<optional>true</optional>，这样可以使引用这些jar的项目不会产生传递依赖。

如:项目mycom-csa中使用了mycom-cas-client-1.0.3.jar,然而mycom-cas-client-1.0.3.jar 又使用了mycom-common-security-1.0.3.jar。所以我们在对mycom-csa打包时会把mycom-common-security-1.0.3.jar打进package中。我们当然可以参考“策略二”，但最好的方法是：可以通知开发mycom-cas-client-1.0.3.jar的同事在mycom-cas-client-1.0.3.jar的pom.xml中对dependency修改为:

<dependency>
      <groupId>com.mycom</groupId>
      <artifactId>mycom-common-security</artifactId>
      <version>1.0.3-SNAPSHOT</version>
       <optional>true</optional>
    </dependency>

添加<optional>true</optional> ，这样我们再打包时mycom-csa中就不会出现mycom-common-security-1.0.3.jar了。

 

 

-----------------------------------------------------------------------------------------------------------------------

 

 

    我们知道，maven的依赖关系是有传递性的。如：A-->B，B-->C。但有时候，项目A可能不是必需依赖C，因此需要在项目A中排除对A的依赖。在maven的依赖管理中，有两种方式可以对依赖关系进行，分别是可选依赖（Optional Dependencies）以及依赖排除（Dependency Exclusions）。

    一、可选依赖

    当一个项目A依赖另一个项目B时，项目A可能很少一部分功能用到了项目B，此时就可以在A中配置对B的可选依赖。举例来说，一个类似hibernate的项目，它支持对MySQL、Oracle等各种数据库的支持，但是在引用这个项目时，我们可能只用到其对mysql的支持，此时就可以在这个项目中配置可选依赖。

    配置可选依赖的原因：1、节约磁盘、内存等空间；2、避免license许可问题；3、避免类路径问题，等等。

    示例：

[html] 
1. <project>  
2.   ...  
3. <dependencies>  
4. <!-- declare the dependency to be set as optional -->  
5. <dependency>  
6. <groupId>sample.ProjectB</groupId>  
7. <artifactId>Project-B</artifactId>  
8. <version>1.0</version>  
9. <scope>compile</scope>  
10. <optional>true</optional> <!-- value will be true or false only -->  
11. </dependency>  
12. </dependencies>  
13. </project>

    假设以上配置是项目A的配置，即：Project-A --> Project-B。在编译项目A时，是可以正常通过的。

    如果有一个新的项目X依赖A，即：Project-X -> Project-A。此时项目X就不会依赖项目B了。如果项目X用到了涉及项目B的功能，那么就需要在pom.xml中重新配置对项目B的依赖。

    二、依赖排除

    当一个项目A依赖项目B，而项目B同时依赖项目C，如果项目A中因为各种原因不想引用项目C，在配置项目B的依赖时，可以排除对C的依赖。

    示例（假设配置的是A的pom.xml，依赖关系为：A --> B; B --> C）：

[html] 
1. <project>  
2.   ...  
3. <dependencies>  
4. <dependency>  
5. <groupId>sample.ProjectB</groupId>  
6. <artifactId>Project-B</artifactId>  
7. <version>1.0</version>  
8. <scope>compile</scope>  
9. <exclusions>  
10. <exclusion>  <!-- declare the exclusion here -->  
11. <groupId>sample.ProjectC</groupId>  
12. <artifactId>Project-C</artifactId>  
13. </exclusion>  
14. </exclusions>   
15. </dependency>  
16. </dependencies>  
17. </project>

    当然，对于多重依赖，配置也很简单，参考如下示例：

[html]  
1. Project-A  
2. > Project-B  
3. > Project-D   
4. > Project-E <! -- This dependency should be excluded -->  
5. > Project-F  
6. > Project C

    A对于E相当于有多重依赖，我们在排除对E的依赖时，只需要在配置B的依赖中进行即可：

[html] 
1. <project>  
2. <modelVersion>4.0.0</modelVersion>  
3. <groupId>sample.ProjectA</groupId>  
4. <artifactId>Project-A</artifactId>  
5. <version>1.0-SNAPSHOT</version>  
6. <packaging>jar</packaging>  
7.   ...  
8. <dependencies>  
9. <dependency>  
10. <groupId>sample.ProjectB</groupId>  
11. <artifactId>Project-B</artifactId>  
12. <version>1.0-SNAPSHOT</version>  
13. <exclusions>  
14. <exclusion>  
15. <groupId>sample.ProjectE</groupId> <!-- Exclude Project-E from Project-B -->  
16. <artifactId>Project-E</artifactId>  
17. </exclusion>  
18. </exclusions>  
19. </dependency>  
20. </dependencies>  
21. </project>  
22.