第五章坐标和依赖

最新推荐文章于 2024-05-28 09:25:21 发布

choubaxiang3303

最新推荐文章于 2024-05-28 09:25:21 发布

阅读量161

点赞数

文章标签： java runtime 数据库

原文链接：https://my.oschina.net/u/1415012/blog/507921

版权

###5.1 何为Maven坐标### Maven的世界中拥有数量庞大的构件，也就是平常用的jar、war包，就像在三维坐标系中一个坐标值（x,y,z）可以唯一的确定一个点的位置信息，Maven中的构件也需要一个坐标来标识它们。在我们开发Maven项目的时候，需要为其定义适当的坐标，这是Maven强制要求的。在这个基础上，其他Maven项目才能应用该项目生成的构件。 ###5.2 坐标详解### Maven坐标为各种构件引入了秩序，任何一个构件都必须明确定义自己的坐标，而一组Maven坐标是通过一些元素定义的，它们是groupId,artifactId,version,packaging,class-sifer。下面是一组坐标定义:

<groupId>com.mycompany.app</groupId>  
  <artifactId>my-app</artifactId>  
  <packaging>jar</packaging>  
<version>0.0.1-SNAPSHOT</version>

下面讲解一下各个坐标元素：

groupId：定义当前Maven项目隶属的实际项目。首先，Maven项目和实际项目不一定是一对一的关系。比如SpringFrameWork这一实际项目，其对应的Maven项目会有很多，如spring-core,spring-context等。这是由于Maven中模块的概念，因此，一个实际项目往往会被划分成很多模块。其次，groupId不应该对应项目隶属的组织或公司。原因很简单，一个组织下会有很多实际项目，如果groupId只定义到组织级别，而后面我们会看到，artifactId只能定义Maven项目（模块），那么实际项目这个层次将难以定义。最后，groupId的表示方式与Java包名的表达方式类似，通常与域名反向一一对应。
artifactId: 该元素定义当前实际项目中的一个Maven项目（模块），推荐的做法是使用实际项目名称作为artifactId的前缀。比如上例中的my-app。
version: 该元素定义Maven项目当前的版本
packaging：定义Maven项目打包的方式，首先，打包方式通常与所生成构件的文件扩展名对应，如上例中的packaging为jar,最终的文件名为my-app-0.0.1-SNAPSHOT.jar。也可以打包成war, ear等。当不定义packaging的时候，Maven 会使用默认值jar。 web项目一般都用war
classifier: 该元素用来帮助定义构建输出的一些附件。附属构件与主构件对应，如上例中的主构件为my-app-0.0.1-SNAPSHOT.jar,该项目可能还会通过一些插件生成如my-app-0.0.1-SNAPSHOT-javadoc.jar,my-app-0.0.1-SNAPSHOT-sources.jar, 这样附属构件也就拥有了自己唯一的坐标
不能直接定义项目的 classifer,因为附属构件不是项目直接默认生成的，而是由附加的插件帮助生成的，Maven 的classifier的作用例子:
classifier的用途在于:
1. maven download javadoc / sources 架包的时候
2. 引入依赖的时候，通常引入依赖我们只需要：

<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>3.1.2.RELEASE</version> 
</dependency>

但是有些架包还是比较特殊的:
比如 JSON-lib ，我利用 sonatype的 jar 搜素引擎搜索发现,JSON-lib的jar提供了两个版本的SDK,如图:
输入图片说明
这个时候就必须使用classifier属性指定了：

<dependency>
   <groupId>net.sf.json-lib</groupId>
   <artifactId>json-lib</artifactId>
   <version>2.4</version>
   <classifier>jdk15</classifier> 
</dependency>

如果不定义classifier的话就maven就会报错说找不到 jar 文件。 ###5.3 account-email### 工程总布局如图：
输入图片说明 ####5.3.1 account-email的POM####

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.my.account</groupId>
  <artifactId>account-email</artifactId>
  <version>1.0.0-SNAPSHOT</version>
  
  <properties>
    <springversion>4.2.1.RELEASE</springversion>
   </properties>
  
  <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${springversion}</version>
            <!--classifier>RELEASE</classifier-->
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${springversion}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${springversion}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${springversion}</version>
        </dependency>
        <dependency>
            <groupId>javax.mail</groupId>
            <artifactId>mail</artifactId>
            <version>1.4.7</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.9</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.icegreen</groupId>
            <artifactId>greenmail</artifactId>
            <version>1.4.1</version>
            <scope>test</scope>
        </dependency>
  </dependencies>
    
</project>

####5.3.2 account-email的主代码####

package com.learn.mvn.account.email;

public class AccountEmailException  extends Exception
{
    private static final long serialVersionUID = -4817386460334501672L;

    public AccountEmailException( String message )
    {
        super( message );
    }

    public AccountEmailException( String message, Throwable throwable )
    {
        super( message, throwable );
    }
}

package com.learn.mvn.account.email;

public interface AccountEmailService 
{
	void sendMail(String to, String subject, String htmlText )
	throws AccountEmailException;
}

package com.learn.mvn.account.email;

import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;

import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;

public class AccountEmailServiceImpl implements AccountEmailService
{
	private JavaMailSender javaMailSender;
	private String systemEmail;

	public JavaMailSender getJavaMailSender() {
		return javaMailSender;
	}

	public void setJavaMailSender(JavaMailSender javaMailSender) {
		this.javaMailSender = javaMailSender;
	}

	public String getSystemEmail() {
		return systemEmail;
	}

	public void setSystemEmail(String systemEmail) {
		this.systemEmail = systemEmail;
	}

	public void sendMail(String to, String subject, String htmlText) 
			throws AccountEmailException
	{
		try 
		{
			MimeMessage msg = javaMailSender.createMimeMessage();
			MimeMessageHelper msgHelper = new MimeMessageHelper(msg);
			
			msgHelper.setFrom(systemEmail);
			msgHelper.setTo(to);
			msgHelper.setSubject(subject);
			msgHelper.setText(htmlText, true);
			
			javaMailSender.send(msg);
		} 
		catch (MessagingException e) 
		{
			throw new AccountEmailException("Failed to send email.", e);
		}
	}
}

Spring的配置文件account-email.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans
 xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-2.5.xsd">
 
 <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
   <property name="location" value="classpath:email.properties" />
 </bean>
 
 <bean id="javaMailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">  
       <property name="host" >  
        <value>${email.host}</value>  
       </property>  
       <property name="port" >  
        <value>${email.port}</value>  
       </property>  
       <property name="protocol">  
        <value>${email.protocol}</value>  
       </property>  
       <property name="username">  
        <value>${email.username}</value>  
       </property>  
       <property name="password">  
        <value>${email.password}</value>  
       </property>  
       <!-- SMTP服务器验证 -->  
       <property name="javaMailProperties">  
           <props>  
               <!-- 验证身份 -->  
               <prop key="mail.${email.protocol}.auth">${email.auth}</prop>  
          </props>  
       </property>  
   </bean>  
     
   <bean id="accountEmailService" class="com.learn.mvn.account.email.AccountEmailServiceImpl">  
    <property name="javaMailSender" ref="javaMailSender" />
    <property name="systemEmail" value="${email.systemEmail}" />
   </bean>  
 
</beans>

####5.3.3 account-email的测试代码####

package com.learn.mvn.account.email;

import static org.junit.Assert.*;

import javax.mail.Message;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.icegreen.greenmail.util.GreenMail;
import com.icegreen.greenmail.util.GreenMailUtil;
import com.icegreen.greenmail.util.ServerSetup;

public class AccountEmailServiceTest 
{
	private GreenMail greenMail;

    private ApplicationContext applicationContext;

    /**
     * 启动邮件服务器
     * 
     * @throws Exception
     * @return void
     */
    @Before
    public void setUp() throws Exception {
        greenMail = new GreenMail(ServerSetup.SMTP);
        greenMail.setUser("test1234@163.com", "test1234");
        greenMail.start();
    }

    /**
     * Test method for
     */
    @Test
    public void testSendEmail() throws Exception {
        applicationContext = new ClassPathXmlApplicationContext("account-email.xml");
        AccountEmailService accountEmailService = (AccountEmailService) applicationContext.getBean("accountEmailService");
        String subject = "Test Subject";
        String htmlText = "<h3> Test </h3>";

        accountEmailService.sendMail("test1234@163.com", subject, htmlText);

        greenMail.waitForIncomingEmail(2000, 1);
        Message[] msgs = greenMail.getReceivedMessages();
        assertEquals(1, msgs.length);
        assertEquals(subject, msgs[0].getSubject());
        assertEquals(htmlText, GreenMailUtil.getBody(msgs[0]).trim());
    }

    /**
     * 关闭邮件服务器
     * 
     * @throws Exception
     * @return void
     */
    @After
    public void tearDown() throws Exception {
        greenMail.stop();
    }
}

email.properties文件：

email.protocol=smtp
email.host=localhost
email.port=25
email.username=test1234@163.com
email.password=test1234
email.auth=true
email.systemEmail=test1234@163.com

运行mvn clean test执行测试:

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running com.learn.mvn.account.email.AccountEmailServiceTest
SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further detail
s.
九月 18, 2015 12:20:11 上午 org.springframework.context.support.ClassPathXmlAppl
icationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationCont
ext@220711: startup date [Fri Sep 18 00:20:11 CST 2015]; root of context hierarc
hy
九月 18, 2015 12:20:11 上午 org.springframework.beans.factory.xml.XmlBeanDefinit
ionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [account-email.xml]
九月 18, 2015 12:20:11 上午 org.springframework.beans.factory.config.PropertyPla
ceholderConfigurer loadProperties
信息: Loading properties file from class path resource [email.properties]
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.991 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 4.984 s
[INFO] Finished at: 2015-09-18T00:20:11+08:00
[INFO] Final Memory: 12M/29M
[INFO] ------------------------------------------------------------------------

###5.4 依赖的配置### 依赖可以声明如下：

<project>  
  ...  
  <dependencies>  
    <dependency>  
      <groupId>group-a</groupId>  
      <artifactId>artifact-a</artifactId>  
      <version>1.0</version>  
      <exclusions>  
        <exclusion>  
          <groupId>group-c</groupId>  
          <artifactId>excluded-artifact</artifactId>  
        </exclusion>  
      </exclusions>  
    </dependency>  
    <dependency>  
      <groupId>group-a</groupId>  
      <artifactId>artifact-b</artifactId>  
      <version>1.0</version>  
      <type>bar</type>  
      <scope>runtime</scope>  
    </dependency>  
  </dependencies>  
</project>

依赖会包含基本的groupId, artifactId,version等元素，根元素project下的dependencies可以包含一个或者多个dependency元素，以声明一个或者多个依赖。
下面详细讲解每个依赖可以包含的元素：
groupId,artifactId和version：依赖的基本坐标，对于任何一个依赖来说，基本坐标是最重要的，Maven根据坐标才能找到需要的依赖。
type: 依赖的类型，对应于项目坐标定义的packaging。大部分情况下，该元素不必声明，其默认值是jar。
scope: 依赖的范围，下面会进行详解。
optional: 标记依赖是否可选。
exclusions: 用来排除传递性依赖，下面会进行详解。
大部分依赖声明只包含基本坐标。 ###5.5 依赖范围### 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元素可以引用环境变量，如：

<dependency>  
    <groupId>javax.sql</groupId>  
    <artifactId>jdbc-stdext</artifactId>  
    <version>2.0</version>  
    <scope></scope>  
    <systemPath>${java.home}/lib/rt.jar</systemPath>  
</dependency>

import(Maven 2.0.9及以上): 导入依赖范围。该依赖范围不会对三种classpath产生实际的影响。 ###5.6 传递性依赖### ####5.6.1 何为传递性依赖#### account-mail有一个compile范围的spring-core依赖，spring-core有一个compile范围的commons-logging依赖，那么commons-logging就会成为account-mail的compile范围依赖。即A-->C B-->A ==>B-->C（这种依赖是基于compile这个范围进行传递）。 ####5.6.2 传递性依赖和依赖范围#### 接依赖范围为test,第二直接依赖范围是compile的时候，依赖范围就是test。
当第二直接依赖范围是compile,传递性依赖的范围与第一直接依赖相同。当第二直接依赖为test,依赖不会得以传递。
当第二直接依赖范围是provided,只传递第一直接依赖也为provided.且传递性依赖范围同样为provided。
当第二直接以来范围是runtime,传递性依赖的范围与第一直接依赖相同，当compile例外，此时传递性依赖的范围为runtime。 ###5.7 依赖调节### maven引入的传递性依赖机制，一方面大大简化和方便了依赖声明，另一方面大部分情况下我们只需要关心项目直接依赖的是什么，而不用考虑这些依赖会引入什么传递性依赖。但有时候，当传递依赖造成问题的时候，我们需要清楚地知道该传递性依赖是从哪条依赖路径引入的。
maven依赖调解的两个原则。（1）第一原则是：路径最近者优先。（2）第二原则是：第一声明者优先。在依赖路径长度相等的前提下，在pom依赖声明的顺序决定了谁会解析使用，顺序最靠前的那个依赖优胜。
A->B->C->X(1.0)、A->D->X(2.0)，X(1.0)的路径为3，而X(2.0)的路径为2，因此X(2.0)会被解析。
A->B->Y(1.0)、A->C->Y(2.0)，对应路径长度相等的，在POM中依赖声明的顺序决定谁会被解析。 ###5.8 可选依赖### 假设有这样一个依赖关系，项目A依赖于项目B，项目B依赖于项目X和Y，B对于X和Y的依赖都是可选依赖：A->B,B->X(可选),B->Y(可选）。根据传递性依赖的定义，如果所有这三个依赖的范围都是compile，那么X,Y 就是A的compile范围传递性依赖。然而，由于这里X,Y是可选依赖，依赖不会得以传递。换句话说，X,Y将不会对A有任何影响。项目B的依赖声明见代码清单。关于可选依赖需要说明的一点就是，在理想情况下，是不应该使用可选依赖的。

<project>
   <modelVerion>4.0</modelVersion>
   <groupId>com.learn.mvn</groupId>
   <artifactId>project-B</artifactId>
   <version>1.0</version>
   <dependencies>
       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <version>5.1.10</version>
           <optional>true</optional>
       </dependency>
       <dependency>
           <groupId>postgresql</groupId>
           <artifactId>postagresql</artifactId>
           <version>8.4-701.jdbc3</version>
           <optional>true</optional>
       </dependency>
   </dependencies>
</project>

因此当项目A依赖项目B的时候，如果实际使用基于Mysql数据库，那么在项目A中需要显示的声明mysql-connection-java依赖。
最后，关于可选依赖需要说明的一点是，在理想的情况下，是不应该使用可选依赖的。前面我们可以看到，使用可选依赖的原因是某一个项目实现了多个特性，在面向对象设计中，有个单一职责性原则，意指一个类应该只有一项职责，而不是糅合太多的功能。这个原则在规划maven项目的时候也同样适用。在上面的例子中，更好的做法是为mysql和postgresql分别创建一个maven项目，基于同样的groupId分配不同的artifactId。 ###5.9 最佳实践### ####5.9.1 排除依赖#### 传递性依赖给项目隐式地引入了很多依赖，这极大地简化了项目的依赖管理，但是有时候这种特性也会带来问题。比如，当前项目有一个第三方依赖，而这个第三方依赖由于某些原因依赖了另外一个类库的SNAPSHOT的版本，那么这个SNAPSHOT就会成为当前项目的传递性依赖，而SNAPSHOT的不稳定性会影响到当前项目。这时需要排除该SNAPSHOT，并且在当前项目中声明该类库某个正式发布版本。

<project>
   <modelVerion>4.0</modelVersion>
   <groupId>com.learn.mvn</groupId>
   <artifactId>project-a</artifactId>
   <version>1.0.0</version>
   <dependencies>
       <dependency>
           <groupId>com.juvenxu.mvnbook</groupId>
           <artifactId>project-b</artifactId>
           <version>1.0.0</version>
           <exclusions>
             <exclusion>
                 <groupId>com.juvencu.mvnbook</groupId>
                 <artifactId>project-c</artifactId>
             </exclusion>
           </exclusions>
       </dependency>
       <dependency>
          <groupId>com.juvencu.mvnbook</groupId>
          <artifactId>project-c</artifactId>          
          <version>1.1.0</version>
       </dependency>
   </dependencies>
</project>

代码中，项目A依赖于项目B，但是由于一些原因，不想引入传递性依赖C，而是自己显示地声明对于项目C1.1.0版本的依赖。代码中使用exclusions元素声明排除依赖，exclusions可以包含一个或者多个exclusion子元素。
需要注意的是，声明exclusion的时候只需要groupId,artifactId就能唯一定义某个依赖。 ####5.9.2 归类依赖#### 通过<properties>元素来定义。通过${变量名}来引用声明一个常量信息，所有用到的地方都用这个常量

   <properties>
    <springversion>2.5.6</springversion>
    <junitversion>2.5.6</junitversion>
   </properties>

在依赖使用的时候只需要：<version>${springversion}</version> ####5.9.3 优化依赖#### maven会自动解析所有项目的直接依赖和传递性依赖，并且根据规则正确判断每个依赖的范围。对于一些依赖冲突，也能进行调节，以确保任何一个构件只有唯一的版本在依赖中存在。在这些工作之后，最后得到的那些依赖被称为解析依赖。运行下面两条命令分别可以查看当前项目的已解析依赖。
mvn dependency:list
mvn dependency:tree
使用mvn dependency:list和mvn dependency:tree可以帮助我们详细了解项目中所有依赖的具体信息。在此基础上，还有dependency:analyze工具可以帮助分析当前项目的依赖，但是该工具只会分析编译主代码和测试代码所需要用到的依赖，一些执行测试和运行时需要的依赖它就发现不了。

转载于:https://my.oschina.net/u/1415012/blog/507921

choubaxiang3303

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第五章坐标和依赖

###5.1 何为Maven坐标### Maven的世界中拥有数量庞大的构件，也就是平常用的jar、war包，就像在三维坐标系中一个坐标值（x,y,z）可以唯一的确定一个点的位置信息，Maven中的构件也需要一个坐标来标识它们。在我们开发Maven项目的时候，需要为其定义适当的坐标，这是M...
复制链接

扫一扫