maven

最新推荐文章于 2020-06-08 21:16:50 发布

wel1

最新推荐文章于 2020-06-08 21:16:50 发布

阅读量414

点赞数

分类专栏： TOOLS 文章标签： maven

本文链接：https://blog.csdn.net/xingzhishen/article/details/78207988

版权

TOOLS 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

一、 Introduction

Apache Maven是一款项目管理工具，通过项目对象模型POM，以描述信息来管理java项目的构建。Maven提供了开发人员构建一个完整的生命周期框架，使用maven可以自动完成项目的基础工具建设。可以设置按标准在非常短的时间里完成配置工作，使得开发更轻松，同时还可以创建报表，检查，构建和测试自动化设置。总之，maven简化和标准化了项目建设过程。优点主要表现在这两点：依赖管理和项目的一键构建。

依赖管理，相比传统的项目文件，由maven管理的项目文件所占空间要小的多，原因是maven采用依赖机制自动下载必需的依赖库，即jar包，并可以保持版本升级。也就是说传统项目中的jar包文件从项目文件系统中分离出来放到一个仓库管理。具体做法是在pom.xml文件中声明依赖jar文件的坐标，当maven编译或者构建，jar包会自动下载，并放到maven本地仓库。

项目的构建就是项目从编码到部署的整个过程，大致包括编码、编译、测试、运行、打包和部署。传统的，如果手头只有项目的源码的情况下将项目运行起来，那么需要将项目导入eclipse或myeclipse中，再导入tomcat，然后运行tomcat来运行项目，相比之下，采用maven只需要一条cmd命令就可以运行它。因为，Maven本身集成编译器、tomcat插件等，那么使用maven可以脱离独立的项目开发工具、tomcat文件，而直接一键执行从编译到部署等过程。补充，在tomcat下，传统的项目的部署是将war包放入tomcat文件系统的webapp文件夹下。

此外，maven还具跨平台，在window、linux上使用，和遵循模块规范开发有利于提高效率，降低维护成本等优点。

Maven的概念模型

二、 Maven的安装配置

首先，下载maven软件，请从maven.apache.org官网下载比较新的maven版本，如3.x.x的。然后，直接将下载的压缩包解压到一个空的名字里没有中文没有空格的文件夹里面。在解压的文件中，conf文件夹下有一个settings.xml文件，是maven软件的核心配置文件。Maven使用纯java开发，在window下运行maven，需要配置环境变量。

Maven配置环境变量，maven3.3.x以上版本需要使用jdk1.7以上的版本。配置环境变量的目的是在bin目录中运行mvn命令。

步骤是：

1，安装配置了jdk1.7以上的版本

2，在环境变量中添加变量名：MAVEN_HOME，变量值是mavne软件解压的目录：如E:\maven\apache-maven-3.3.9-bin\apache-maven-3.3.9

3，把MAVEN_HOME添加到系统变量path的变量值里，格式为%MAVEN_HOME%\bin;注意分号，因为要使用maven解压文件夹的bin文件里面的东西，所以是\bin

4，验证maven是否安装成功，在dos窗口输入：mvn -v。注意-v前的空格。

三、 Maven仓库

Java项目需要很多jar文件，而maven是不依赖编程的编译软件，如eclipse而使用编译插件完成编译，也不需要单独使用tomcat服务器而使用tomcat服务器类的插件运行项目，那么这就需要maven能够连网下载所需的这些jar文件或者辅助插件等，但是在没有网络的情况下，maven依然可以使用这些文件，因为maven拥有本地仓库，可以从仓库中取用这些文件。Maven的仓库功能也是它的一大特色，优点。

Maven的仓库分为3中，本地仓库，中央仓库和远程仓库。

1. 本地仓库

通俗的讲，就是本地的一个文件夹，用来存放maven运行项目所需的文件。默认情况下，maven的本地仓库为.m2的目录文件夹。如：c:users\{your username}\.m2当运行maven时会自动生成这个.m2的文件夹，里面有一个叫repository的文件夹，再里面有一些相关的文件夹和文件。本地仓库，由自己维护，可以在maven的核心配置文件settings.xml中更新本地仓库的位置。

例子：

<localRepository>E:\maven\repository</localRepository>

2. 远程仓库

如果项目中使用的文件中，本地仓库没有，那么可从远程仓库中获取，通俗叫做私服，通常由公司维护的仓库来尝试获取，如果获得就下载到本地仓库。

如果私服中没有，那么可以设置继续访问中央仓库，同样，如果获取到文件，就下载到私服中。

3. 中央仓库

如果本地仓库中没有需要的文件，又没有私服的话，那么还可以通过网路直接从中央仓库获取，如果获得就下载到本地仓库。中央仓库有apache的maven团队维护。中央仓库中包含庞大的资源，可以不用担心找不到资源。

四、 Maven的目录结构

创建maven管理的java工程，一般要使用符合maven管理的工程文件的目录结构。在工程文件夹下有src文件夹和pom.xml文件。

Src下main和test文件夹；main下java文件夹中方java代码，resources文件夹下放配置文件；test下java文件夹放java测试代码。

Maven的目录结构是固定的，不能随意更改。

五、 Maven的常用命令

1. 使用maven命令时，以mvn开头，空格加上命令词。常用命令

clean	清理编译的文件
compile	编译(main)主目录的文件
test	编译并运行test目录的代码
package	打包
install	把项目发布到本地仓库，主要用于将java项目打成jar包。对于install web项目的意义不大。
tomcat:run	一键启动
deploy	将war包或者jar包发布到私服

如：mvn tomcat:run

2. Maven命令的生命周期

使用maven命令首先要进到项目文件夹里面。Maven的主要命令：compile、test、package、install的执行有一定的顺序。而且，按照compile、test、package、instal的先后顺序，越往后周期越长，比如，如果执行test命令，那么会依次执行compile、test命令，如果执行package命令，需要依次执行compile、package、install。这个执行顺序就是maven命令的生命周期。

Maven的生命周期可分为3种，clean命令有单独的生命周期，称为clean生命周期；上述其他5个常用命令，称为default生命周期；另外有一个site命令，称其为site生命周期，site命令不常用。

Maven命令与命令生命周期的关系是互不影响性。即3种不同的生命周期的命令可以同时执行。如mvn clean package。

六、 Maven入门程序

在eclipse中使用maven构建项目。

首先需要在eclipse中安装M2e插件。Eclipse mar.2自带了M2e插件，不需要安装。但是mar.2集成的是maven3.3.3版本，如果需要更换使用的maven版本，需要配置，步骤是：eclipse软件中>>preferences>>maven>>installations>>add>>选择解压的maven文件包>>finished>>选择需要的版本>>ok。

然后，需要修改默认的本地仓库。步骤是：eclipse软件中>>preferences>>maven>>UserSettings，其中，配置settings.xml文件和local repository的正确位置。配置好settings.xml文件的位置，会自动关联settings.xml中配置的本地仓库的位置。

准备就绪，使用maven构建项目的步骤：

1. 新建一个maven项目

2. 在创建项目的面板中，勾选create a simple project(skip archetype selection)。选择跳过骨架选择，否则如果使用骨架选择则创建的项目的目录结构是不齐全的。

3. 下一步，填写坐标。坐标是提供给别人以便找到项目。不论什么项目，web或者java项目，都需要填写坐标。

Group Id：表示组的名字，如com.公司名，com.组织名。

Artiact Id：项目名。

Version：项目的版本，eclipse会自动填写x.x.x-SNAPSHOT的版本号。SANPSHOT，意为快照，即非正式版。

Packaging：打包方式，请按需选择。Jar，jave工程；war，web工程；pom，项目对象模型，父工程，也就是大型项目中各个模块都隶属的工程。

Name：可选项，无实质作用。表示给项目的名字。

Description：可选项，无实质作用。对项目的描述。

4. 新创建的maven项目中没有web.xml文件，需要手动创建处理红×。在src文件夹下的main文件夹下的webapp文件夹中创建WEB-INF文件夹，然后复制一份web.xml文件到WEB-INF文件夹。每次创建maven管理的web项目都要手动处理这个问题。

5. 处理编译版本。新创建的maven项目默认使用jdk1.5的编译器，如果要更新编译期版本，在pom.xml中添加如下配置代码：

<build>

              <!-- 配置了很多插件 -->

              <plugins>

                     <plugin>

                            <groupId>org.apache.maven.plugins</groupId>

                            <artifactId>maven-compiler-plugin</artifactId>

                            <version>3.5.1</version> 

                            <configuration>

                                   <source>1.7</source>

                                   <target>1.7</target>

                                   <encoding>UTF-8</encoding>

                            </configuration>

                     </plugin>

              </plugins>

       </build>

当修改完编译器版本后，项目爆出红×。请右击项目>>选择maven>>Update Project。

6. 创建一个servlet

创建了servlet后会有很多报错，原因是没有jar包以及web.xml配置问题。

某些新版的eclipse中可能没有web.xml报错的问题。如果有，请在web.xml中删除重复的约束文件代码。

添加jar包，在pom.xml文件中，添加如下配置代码：

<dependencies>

              <dependency>

                     <groupId>junit</groupId>

                     <artifactId>junit</artifactId>

                     <version>4.9</version>

                     <scope>test</scope>

              </dependency>

              <dependency>

                     <groupId>javax.servlet</groupId>

                     <artifactId>servlet-api</artifactId>

                     <version>3.0</version>

                     <scope>provided</scope>

              </dependency>

              <dependency>

                     <groupId>javax.servlet</groupId>

                     <artifactId>jsp-api</artifactId>

                     <version>2.0</version>

                     <scope>provided</scope>

              </dependency>         

</dependencies>

注意上述的依赖文件在本地仓库中是否存在。否则报misssing文件的错误。如果missing，请添加jar包到本地仓库或者做访问私服或中央仓库的配置。

配置好pom.xml后，更新maven项目。请右击项目>>选择maven>>Update Project。

关于添加jar包，也就是添加依赖时，如果不知道依赖包的坐标，即上述配置文件中<dependency></dependency>中的内容。由2种方式查询，1，从网上搜索，网址：search.maven.org或者mvnrepository.com。在网站中搜索需要的关键字后，选择好，打开会看到网站提供的maven的坐标，即可复制2，在本地重建索引，以索引的方式添加依赖，详细方法见下述第七中关于手动添加依赖的介绍。

7. 在eclipse中运行maven项目

项目上右键>>选择run as >>maven build …>>Goals中填写tomcat:run>>run。然后到浏览器访问这个servlet，查看是否成功。

七、 Maven整合struts2开发

Maven整合struts2主要使用的是maven的依赖管理功能，即将框架需要使用的jar包放到项目外部的仓库。以struts2为例，可以举一反三使用maven整合ssh\ssm等。

整合struts2步骤：

1. 新建一个maven项目

2. 在创建项目的面板中，勾选create a simple project(skip archetype selection)。选择跳过骨架选择，否则如果使用骨架选择则创建的项目的目录结构是不齐全的。

3. 下一步，填写坐标。坐标是提供给别人以便找到项目。不论什么项目，web或者java项目，都需要填写坐标。

Group Id：表示组的名字，如com.公司名，com.组织名。

Artiact Id：项目名。

Version：项目的版本，eclipse会自动填写x.x.x-SNAPSHOT的版本号。SANPSHOT，意为快照，即非正式版。

Packaging：打包方式，请按需选择。Jar，jave工程；war，web工程；pom，项目对象模型，父工程，也就是大型项目中各个模块都隶属的工程。

Name：可选项，无实质作用。表示给项目的名字。

Description：可选项，无实质作用。对项目的描述。

5. 处理编译版本。新创建的maven项目默认使用jdk1.5的编译器，如果要更新编译期版本，在pom.xml中添加如下配置代码：

<build>

              <!-- 配置了很多插件 -->

              <plugins>

                     <plugin>

                            <groupId>org.apache.maven.plugins</groupId>

                            <artifactId>maven-compiler-plugin</artifactId>

                            <version>3.5.1</version> 

                            <configuration>

                                   <source>1.7</source>

                                   <target>1.7</target>

                                   <encoding>UTF-8</encoding>

                            </configuration>

                     </plugin>

              </plugins>

       </build>

当修改完编译器版本后，项目爆出红×。请右击项目>>选择maven>>Update Project。

6. 创建一个用于测试的jsp文件

7. 添加servlet、jsp的依赖文件

手动添加依赖关系的方法：

首先创建添加maven仓库的索引：window>>show view>>mavenRepositories>>在maven Repositories面板>>点开localrepositories，右击>>rebuild index。

然后添加依赖关系：右击pom.xml(或者在pom.xml上右击或者选择pom.xml文件中的Dependencies)>>maven>>AddDependency>>enter groupId…>>填写要创建的依赖文件的名字，根据索引选择要的文件。选择依赖域scope。

关于依赖域（依赖范围）：

依赖属性	作用范围
compile	默认项，编译时，测试时，运行时，打包时
provided	编译时，测试时。
runtime	比如数据库驱动包，编译时不作用，作用于：测试时，运行时，打包时
test	仅测试时

特别注意：tomcat本身自带了servlet和jsp的jar包，对于本地仓库的这两个jar包，请将其作用范围设定为provided，否则运行tomcat时与tomcat的jar包冲突而报错。

test属性仅适用于用于测试的jar包，如junit等。

8. 依赖文件添加完毕后，创建action类

例子：

public class CustomerAction extends ActionSupport{

   private LongcustId;

   public String findCustById(){

      System.out.println("前端来的id是："+custId);

      return SUCCESS;

   }

   public Long getCustId() {

      return custId;

   }

   public voidsetCustId(Long custId){

      this.custId =custId;

   } 

}

9. 在src/main/resources文件中创建配置struts.xml文件

例子：

<?xmlversion="1.0"encoding="UTF-8"?>

<!DOCTYPEstrutsPUBLIC

    "-//ApacheSoftware Foundation//DTD Struts Configuration 2.3//EN"

    "http://struts.apache.org/dtds/struts-2.3.dtd">

<struts>

   <constantname="struts.action.extension"value="action"></constant>



   <!-- 通用package -->

   <packagename="customer"namespace="/"extends="struts-default">

      <actionname="CustomerAction_*"class="com.haha.test.CustomerAction"  method="{1}">

         <resultname="success">/struts.jsp</result>

      </action>

   </package>

</struts>

10. 运行测试

右键项目>>maven>>run as maven build…>>Goals填写tomcat:run>>run

如果结果报错，原因是tomcat提供的servlet和jsp的jar包与本地仓库提供的jar包冲突。解决办法：修改依赖关系中servlet和jsp的依赖域为：provided。

八、 Maven修改在eclipse使用tomcat运行项目的配置

在eclipse中运行maven项目，tomcat:run。会采用默认的配置。

修改tomcat配置的方法：右键项目>>maven>>Add Plugin>>EntergroudId…>>填写tomcat，选择最下面的一个1.1版本的。完成后在pom.xml文件中会多出来一段配置文件。

         <plugin>

            <groupId>org.codehaus.mojo</groupId>

            <artifactId>tomcat-maven-plugin</artifactId>

            <version>1.1</version>

         </plugin>

通过修改上述配置文件信息来修改服务器相关配置。如：

         <plugin>

            <groupId>org.codehaus.mojo</groupId>

            <artifactId>tomcat-maven-plugin</artifactId>

            <version>1.1</version>

            <configuration>

                <port>8282</port>

                <path>/struts2</path>

            </configuration>

         </plugin>

如果在add plugin中填写的是tomcat7，则运行项目是请在Goals中填写tomcat7:run来运行项目。

关于maven在debug模式下没有进入源码问题的处理：

首先使用debug模式，设置断点>>右键项目>>debug as>>maven build…>>goals>>填写tomcat7:run。

如果进入debug界面后没有进入源码，点击edit source lookup path…>>javeproject>>选择对应的项目>>ok。如果仍然没有进入源码，右键项目>>debug as>>runconfigurations>>source>>add 对应的项目>>ok。

九、 Maven整合ssh

整合的原理主要是添加依赖。

整合步骤：

1. 新建一个maven项目，创建的具体步骤见上述介绍。

2. 添加web.xml文件

3. 添加依赖关系

在pom.xml中添加servlet、jsp、struts-core、spring-struts、spring-context、

由于maven具有依赖传递的特征，对于ssm\ssh框架等需要多个jar包的情况，只有添加了框架中的核心包就会自动添加有依赖关系的包。

在上述添加spring的相关包时，比如先添加的spring-struts-plugin选择的是2.3.24，这其中依赖传递了spring-beans3.0.5，当添加spring-context时，选择的是spring-context的4.2.4的包，其中依赖包含了spring-beans的4.2.4，这就产生了同一个依赖文件的版本的冲突。

解决依赖版本冲突的几个方法：

首先需要明白maven在根据pom文件选择jar时遵循的4个原则，排名不分先后，

1) 路径近者优先原则，即如果两个jar文件相对于maven都是来自依赖关系，则相对于maven它们的路径是一样的，这时如果手动添加一个这个jar文件，则手动添加的这个jar文件相对于那两个冲突的文件具有更近的路径，那么冲突消失。

2) 第一声明者首先原则，就是说在没有最近路径的前提下，谁在前面声明就使用谁里面的依赖传递文件。前两种原则统称为调节原则。

3) 排除原则，就是排除掉不想使用版本，在不需要使用的版本的依赖关系中，声明如下代码：

      <exclusions>

          <exclusion>

             <groupId>org.springframework</groupId>

             <artifactId>spring-beans</artifactId>

          </exclusion>

      </exclusions>

4) 版本锁定原则，即在pom.xml的靠前位置锁定需要依赖传递的版本。使用如下代码：

  <dependencyManagement>

  <dependencies>

      <dependency>

          <groupId>org.springframework</groupId>

          <artifactId>spring-beans</artifactId>

          <version>4.2.4.RELEASE</version>

      </dependency>

  </dependencies>

  </dependencyManagement>

比较上述四种解决冲突的方法，在后续的维护上版本锁定具有更大的灵活性，所以推荐使用版本锁定方法。为了进一步优化代码，那么在版本锁定方法中，可以将版本号以变量的形式表示，那么，如果需要更改锁定的版本号，只要修改变量就可以了。代码例子如下：

  <properties>

  <!-- 自定义一个标签 -->

  <spring.version>4.2.4.RELEASE</spring.version>

  </properties>

  <dependencyManagement>

  <dependencies>

      <dependency>

          <groupId>org.springframework</groupId>

          <artifactId>spring-beans</artifactId>

          <version>${spring.version}</version>

      </dependency>

      <dependency>

          <groupId>org.springframework</groupId>

          <artifactId>spring-context</artifactId>

          <version>${spring.version}</version>

      </dependency>

  </dependencies>

  </dependencyManagement>

4. 准备数据库环境

在mysql中创建一个数据库。

5. 创建实体类

使用hibernate，需要创建实体类的对象映射文件，为了保持实体类与映射文件在编译后能够存放在一个文件夹下，可以在src/main/resources目录下复制实体的包，然后，在复制的包里创建映射文件。

6. 在src/main/resources文件中创建struts.xml等ssh需要的配置文件

struts.xml，hiberbate.cfg.xml，applicationContext.xml。

7. 创建dao层，service层

创建dao和service层类的时候注意在applicationContext.xml中装配bean。

期间，可以使用junit测试一下dao层与数据库连接是否可以运行。选中要测试的dao实现类，右键新建一个junitTestCase，注意选择source folder为src/test/java。测试例子：

public class CustomerDaoImplTest {

   @Test

   public voidtest() {

      ApplicationContext ac =newClassPathXmlApplicationContext("classpath:applicationContext.xml");

      CustomerDao customerDao = (CustomerDao)ac.getBean("customerDao");

      Customer c = customerDao.findById(1L);

      System.out.println("-----------------"+c.getCustName());

   }

}

8. 创建action类，并配置到spring的bean。

9. 测试

十、使用maven的分模块开发

一般，比较大的项目，都分模块开发，就是按照功能或者内容分成不同的单元开发，如使用3层的划分模块开发，又如一个商城系统可以分为用户模块，商品展示模块，购物车模块，订单支付模块，后台模块等。Maven的分模块开发，采用以父工程统一模块工程的方式，就是各个模块以父工程为基础，在父工程的基础上开发。

Maven3层分模块开发的步骤：

1. 创建一个父工程，使用maven创建工程的过程与上述常见单独的工程略有不同。

在aritifact id中给工程命名为表示这是父工程的标识，如mavenSsh-parent。另外，packaging打包方式选择为pom。创建好后，打开父工程可见里面有一个src文件夹包含一个空的site文件夹，另还有一个空的pom.xml文件。这是因为父工程不处理具体的业务，而是为处理业务服务，以便各个模块可以整合为一起，父工程的服务主要体现在：统一的依赖管理，就是各模块jar包的配置都放于主工程的pom.xml文件中。

父工程pom.xml文件例子：

<projectxmlns="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.0http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <groupId>com.maven.ssh</groupId>

  <artifactId>mavenSsh-parent</artifactId>

  <version>0.0.1-SNAPSHOT</version>

  <packaging>pom</packaging>

  <!-- 属性 -->

   <properties>

      <spring.version>4.2.4.RELEASE</spring.version>

      <hibernate.version>5.0.7.Final</hibernate.version>

      <struts.version>2.3.24</struts.version>

   </properties>



   <!-- 锁定版本，struts2-2.3.24、spring4.2.4、hibernate5.0.7 -->

   <dependencyManagement>

      <dependencies>

         <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context</artifactId>

            <version>${spring.version}</version>

         </dependency>

         <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-aspects</artifactId>

            <version>${spring.version}</version>

         </dependency>

         <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-orm</artifactId>

            <version>${spring.version}</version>

         </dependency>

         <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-test</artifactId>

            <version>${spring.version}</version>

         </dependency>

         <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-web</artifactId>

            <version>${spring.version}</version>

         </dependency>

         <dependency>

            <groupId>org.hibernate</groupId>

            <artifactId>hibernate-core</artifactId>

            <version>${hibernate.version}</version>

         </dependency>

         <dependency>

            <groupId>org.apache.struts</groupId>

            <artifactId>struts2-core</artifactId>

            <version>${struts.version}</version>

         </dependency>

         <dependency>

            <groupId>org.apache.struts</groupId>

            <artifactId>struts2-spring-plugin</artifactId>

            <version>${struts.version}</version>

         </dependency>

      </dependencies>

   </dependencyManagement>

   <!-- 依赖管理 -->

   <dependencies>

      <!-- spring-->

      <dependency>

         <groupId>org.springframework</groupId>

         <artifactId>spring-context</artifactId>

      </dependency>

      <dependency>

         <groupId>org.springframework</groupId>

         <artifactId>spring-aspects</artifactId>

      </dependency>

      <dependency>

         <groupId>org.springframework</groupId>

         <artifactId>spring-orm</artifactId>

      </dependency>

      <dependency>

         <groupId>org.springframework</groupId>

         <artifactId>spring-test</artifactId>

      </dependency>

      <dependency>

         <groupId>org.springframework</groupId>

         <artifactId>spring-web</artifactId>

      </dependency>

      <!-- hibernate-->

      <dependency>

         <groupId>org.hibernate</groupId>

         <artifactId>hibernate-core</artifactId>

      </dependency>



      <!-- 数据库驱动 -->

      <dependency>

         <groupId>mysql</groupId>

         <artifactId>mysql-connector-java</artifactId>

         <version>5.1.6</version>

         <scope>runtime</scope>

      </dependency>

      <!-- c3p0-->



      <dependency>

         <groupId>c3p0</groupId>

         <artifactId>c3p0</artifactId>

         <version>0.9.1.2</version>

      </dependency>

      <!-- 导入 struts2 -->

      <dependency>

         <groupId>org.apache.struts</groupId>

         <artifactId>struts2-core</artifactId>

      </dependency>

      <dependency>

         <groupId>org.apache.struts</groupId>

         <artifactId>struts2-spring-plugin</artifactId>

      </dependency>



      <!-- servletjsp -->

      <dependency>

         <groupId>javax.servlet</groupId>

         <artifactId>servlet-api</artifactId>

         <version>2.5</version>

         <scope>provided</scope>

      </dependency>

      <dependency>

         <groupId>javax.servlet</groupId>

         <artifactId>jsp-api</artifactId>

         <version>2.0</version>

         <scope>provided</scope>

      </dependency>

      <!-- 日志 -->

      <dependency>

         <groupId>org.slf4j</groupId>

         <artifactId>slf4j-log4j12</artifactId>

         <version>1.7.2</version>

      </dependency>

      <!-- jstl-->

      <dependency>

         <groupId>javax.servlet</groupId>

         <artifactId>jstl</artifactId>

         <version>1.2</version>

      </dependency>

   </dependencies>



   <build>

      <plugins>

         <!-- 设置编译版本为1.7 -->

         <plugin>

            <groupId>org.apache.maven.plugins</groupId>

            <artifactId>maven-compiler-plugin</artifactId>

            <configuration>

                <source>1.7</source>

                <target>1.7</target>

                <encoding>UTF-8</encoding>

            </configuration>

         </plugin>



         <!-- maven内置的tomcat6插件 -->

         <plugin>

            <groupId>org.codehaus.mojo</groupId>

            <artifactId>tomcat-maven-plugin</artifactId>

            <version>1.1</version>

            <configuration>

                <!-- 可以灵活配置工程路径 -->

                <path>/ssh</path>

                <!-- 可以灵活配置端口号 -->

                <port>8080</port>

            </configuration>

         </plugin>



      </plugins>

   </build>

</project>

注意：父工程pom文件中没有配置junit的jar包依赖。

为了便于子模块使用父工程，将父工程发布到本地仓库。方法：右击父工程项目>>run as>>maven build…>>Goals>>填写install>>run。如果，在发布父工程的时候，已经先创建了其他子模块，如entity或者dao等，则这些子模块会一同发布到本地仓库。

2. 创建entity实体类子模块

右键项目，new一个maven module，同样选择跳过骨架，注意确定子模块对应的父工程，然后选择将子模块打包为jar文件。在eclipse软件中会出现一个新建的maven项目。在父工程的pom.xml文件中自动生成父工程对子工程的从属关系声明。

   <modules>

      <module>ssh-module</module>

      <module>ssh-entity</module>

   </modules>

创建entity的包和类。如果是修改原来的项目为maven管理，可以复制粘贴原来的文件到子模块。

为了便于子模块使用本模块，将本模块发布到本地仓库。方法：右击本模块项目>>run as>>maven build…>>Goals>>填写install>>run。如果，在发布父工程的时候，已经先创建了本模块，则本子模块会一同发布到本地仓库。

3. 创建dao层子模块

同样右键项目，new一个maven module，同样选择跳过骨架，注意确定子模块对应的父工程，然后选择将子模块打包为jar文件。

如果本模块使用了其他模块，需要在本模块的pom.xml文件中添加对于其他模块的依赖，前提是要依赖的模块以jar的方式发布到本地仓库。比如dao层使用了entity层的类。添加依赖关系的方式同添加其他jar文件的方式。由于同一个父工程的子模块都在同一个工作空间，所以，在子模块的maven dependencies库中，被添加的依赖文件以工程文件的形式出现而不是jar包的形式。如果将依赖文件的子模块工程close掉，则以jar包的形式出现。

然后创建dao层的包和接口、类，以及相关的配置文件。注意给配置文件的命名与其他子模块的区分以避免命名冲突，如applicationContext.xml文件可以命名为applicationContext-dao.xml。

使用junit测试，略。

4. 创建service层子模块

同样右键项目，new一个maven module，同样选择跳过骨架，注意确定子模块对应的父工程，然后选择将子模块打包为jar文件。

如果本模块使用了其他模块，需要在本模块的pom.xml文件中添加对于其他模块的依赖，前提是要依赖的模块以jar的方式发布到本地仓库。比如：由于service层调用了dao层的文件，所以，需要在service层中建立对于dao模块的依赖关系，在建立依赖关系前，需要将dao模块发布到本地仓库。

然后创建service层的包和接口、类，以及相关的配置文件。

可以使用junit对service模块进行测试，测试时发现，报错，原因是没有引入junit的依赖，然而，由于service依赖了dao，而dao中已经依赖了junit，根据依赖传递的原理，service应该可以建立对于dao的依赖的，可是，由于在dao中对于junit的依赖范围（也就是作用域）设置为test，test的作用范围只限于测试时，在编译时是没有用的，所以，只要更改dao中junit的作用范围为compile就可以了。一般也可以直接添加直属于service的junit的jar包依赖。测试时，注意在传递applicationContext.xml文件时，传入dao层的spring配置文件，即applicationContext-dao.xml。

例子：

public class CustomerServiceImplTest {

   @Test

   public voidtest() {

      ApplicationContext ac =newClassPathXmlApplicationContext("classpath:applicationContext-service.xml","classpath:applicationContext-dao.xml");

      CustomerService customerService = (CustomerService)ac.getBean("customerService");

      Customer c = customerService.findById(1L);

      System.out.println("-----------------"+c.getCustName());

   }

}

如果采用通配符的方式获取spring配置文件，例子如下：

其中classpath*，表示可以从jar包中获取配置文件。

public class CustomerServiceImplTest {

   @Test

   public voidtest() {

      ApplicationContext ac =newClassPathXmlApplicationContext("classpath*:applicationContext-*.xml");

      CustomerService customerService = (CustomerService)ac.getBean("customerService");

      Customer c = customerService.findById(1L);

      System.out.println("-----------------"+c.getCustName());

   }

}

关于依赖范围对依赖传递的影响关系参见下图：

总之，依赖范围在依赖传递下可能会产生一定变化的依赖范围。请注意设置。

最后，为了便于子模块使用本模块，将本模块发布到本地仓库。方法：右击本模块项目>>run as>>maven build…>>Goals>>填写install>>run。如果，在发布父工程的时候，已经先创建了本模块，则本子模块会一同发布到本地仓库。一般发布service模块的时候，将模块内的测试文件都注释掉以节省时间。

5. 创建web层的action

同样右键项目，new一个maven module，同样选择跳过骨架，注意确定子模块对应的父工程，然后选择将子模块打包为war文件。注意请选择打包为war文件。

如果本模块使用了其他模块，需要在本模块的pom.xml文件中添加对于其他模块的依赖，前提是要依赖的模块以jar的方式发布到本地仓库。比如：由于action类调用了service层的文件，所以，需要在web层模块中建立对于dao模块的依赖关系，在建立依赖关系前，需要将service模块发布到本地仓库。如果在添加依赖前，被依赖的模块已经close project，那么，可能在添加依赖的时候，不会出现相关提示，那么可以通过在maven repositories面板的本地仓库中rebuild index来实现。

创建action类和相关配置文件。注意配置web.xml，特别是关于spring的监听，请看一下例子：

注意对于文件位置的配置：classpath*:applicationContext-*.xml

<?xmlversion="1.0"encoding="UTF-8"?>

<web-appxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns="http://xmlns.jcp.org/xml/ns/javaee"xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaeehttp://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"id="WebApp_ID"version="3.1">

  <welcome-file-list>

    <welcome-file>index.html</welcome-file>

    <welcome-file>index.htm</welcome-file>

    <welcome-file>index.jsp</welcome-file>

    <welcome-file>default.html</welcome-file>

    <welcome-file>default.htm</welcome-file>

    <welcome-file>default.jsp</welcome-file>

  </welcome-file-list>

  <listener>

      <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

  </listener>

  <context-param>

      <param-name>contextConfigLocation</param-name>

      <param-value>classpath*:applicationContext-*.xml</param-value>

  </context-param>

  <filter>

      <filter-name>struts2</filter-name>

      <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>

  </filter>

  <filter-mapping>

      <filter-name>struts2</filter-name>

      <url-pattern>/*</url-pattern>

  </filter-mapping>

</web-app>

最后在web模块中，使用tomcat:run测试。

也可以在父工程中使用tomcat:run测试。使用父工程测试，称之为聚合。

十一、 Maven私服

1. 下载私服的文件介绍

在项目开发中，团队开发分别使用单独的电脑，为了便于团队开发的方便，可以将单独开发的模块放到私服上。私服nexus，需要通过软件来搭建。

首先下载，然后解压到和maven软件一个文件夹下。在解压的文件夹中，sonatype-work文件夹放的是仓库的文件，其中用来放上传到私服的文件。nexus-2.x.x里面放的是运行nexus私服的软件。其中，bin文件夹放的是命令文件，conf文件夹放的是配置文件，在conf文件夹中，有一个nexus.properties文件，nexus是b/s（浏览器服务器）架构的，这个文件中提供了私服的访问地址，如http://localhost:8081/nexus。

lib文件夹中放的是nexus依赖的jar包，logs放的是日志文件，temp放的是临时文件。

2. 安装私服nexus

然后通过cmd命令安装nexus。进入cmd命令后，然后cd到nexus的bin文件夹，然后执行nexus.bat install。安装后通过查看电脑》》管理》》服务有没有安装成功。安装成功后，可以通过cmd命令启动私服，同样要cd到bin文件夹，然后执行nexus.bat start。如果启动失败，可以在nexus的bin\jsw\conf\wrapper.conf的文件夹中将第15行，wrapper.java.command=java，其中的java修改为jave.exe文件所在的位置。如：wrapper.java.command= C:\ProgramFiles\Java\jdk1.7.0_51\bin\java.exe。启动后，可以根据conf文件夹中的nexus.properties中的路径访问私服，如：http://localhost:8081/nexus。

3. 私服页面介绍

打开页面，会看到一个类似使用easyUI制作的网站。进一步访问私服，需要点击右上角的login登录，默认的用户名和密码分别是admin和admin123。

面板介绍：

点击views/repositories下面的repositories显示出私服包括的仓库的类型。

私服包括4中仓库类型，如下标所述

Virtul	虚拟仓库，没有任何作用，几乎不会用到。
Proxy	代理仓库，这个仓库代理了apache sanpshots，即apache非正式的jar包，代理的另一个是central，即中央仓库。
Hosted	宿主仓库，或者本地仓库。这个仓库包括3rd party，releases，snapshots。个人使用创建的maven项目是一般是snapshot的，那么，当个人的snapshot版本的maven项目上传到私服后，就放在宿主仓库的snapshots库中。如果当创建的maven项目是realease的，如spring的一些jar包，那么，这个realease版本的maven项目上传到私服后，就放在releases库中。3rd party，是第三方库，第三方公司开发的项目会放到这个库。
Group	当需要从私服上下载文件时，如果不知道文件的版本，而不能确定从那个库中下载时，就可以从group库中下载。

4. 私服的使用

以将dao模块放到私服，service模块从私服下载使用dao模块为例使用maven。

步骤：

1) 将dao模块上传到私服。

首先需要在dao模块的pom.xml文件中配置上传的私服的路径。配置路径的代码的例子：

  <distributionManagement>

  <repository>

      <id>releases</id>

   <url>http://localhost:8081/nexus/content/repositories/releases/</url>

  </repository>

  <snapshotRepository>

      <id>snapshots</id>

   <url>http://localhost:8081/nexus/content/repositories/snapshots/</url>

  </snapshotRepository>

  </distributionManagement>

为了加强安全管理，当开发人员向私服上传文件时需要设置用户名和密码才能上传，而且设置的用户名和密码要和login私服的用户名和密码一致。配置上传用户和密码的步骤：打开maven的settings.xml文件>>在sever标签中>>

<server>

        <id>release</id>

        <username>admin</username>

          <password>admin123</password>

</server>

<server>

        <id>snapshots</id>

        <username>admin</username>

          <password>admin123</password>

</server>

上述配置表示对于访问release仓库需要的用户名和密码，以及访问snapshots仓库需要的用户名和密码，其中的id可以在私服的访问网站上看到。配置完毕后，可以发布dao模块到私服。右键dao模块项目>>run as>>maven build…>>Goals>>deploy

上传完毕后，service模块可以下载私服上的dao的jar包，需要在maven的settings.xml文件中配置：找到profile标签>>做如下配置：

<profiles>

<profile>  

       <!--profile的id-->

    <id>dev</id>  

    <repositories>  

      <repository> 

              <!--仓库id，repositories可以配置多个仓库，保证id不重复-->

       <id>nexus</id>  

              <!--仓库地址，即nexus仓库组的地址-->

       <url>http://localhost:8081/nexus/content/groups/public/</url>  

              <!--是否下载releases构件-->

        <releases>  

         <enabled>true</enabled>  

        </releases>  

              <!--是否下载snapshots构件-->

        <snapshots>  

          <enabled>true</enabled>  

        </snapshots>  

      </repository>  

    </repositories> 

        <pluginRepositories> 

          <!-- 插件仓库，maven的运行依赖插件，也需要从私服下载插件 -->

       <pluginRepository> 

             <!-- 插件仓库的id不允许重复，如果重复后边配置会覆盖前边 -->

            <id>public</id> 

            <name>PublicRepositories</name> 

           <url>http://localhost:8081/nexus/content/groups/public/</url> 

       </pluginRepository> 

   </pluginRepositories> 

 </profile>

</profiles>

配置好profiles标签后，还需要激活profiles。如下：

  <activeProfiles>

   <activeProfile>dev</activeProfile>

  </activeProfiles>

设置完后，如果是做测试，可以删除本地仓库的dao模块，然后update一下service模块。查看maven dependencies的jar检查是否成功。也可以通过查看maven console面板查看是否成功，如果看到很多downloading行，则表示成功。

注意：当dao层做过修改后，再次上传到私服后，为了保证各个模块之间的协调合并，特别是在截至日期附近，做过修改后，更新dao模块的版本号，例子代码如下：

  <artifactId>ssh-dao</artifactId>

  <version>0.0.2-SNAPSHOT</version>

然后，将更新的版本号告知相关模块组，以确保相关模块组可以下载到最新的模块，从而保证项目整体的协调一致。

wel1

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
maven

一、 IntroductionApache Maven是一款项目管理工具，通过项目对象模型POM，以描述信息来管理java项目的构建。Maven提供了开发人员构建一个完整的生命周期框架，使用maven可以自动完成项目的基础工具建设。可以设置按标准在非常短的时间里完成配置工作，使得开发更轻松，同时还可以创建报表，检查，构建和测试自动化设置。总之，maven简化和标准化了项目建设过程。...
复制链接

扫一扫

专栏目录