j2ee开发相关工具的配置与使用

发表于   |   更新于 | 分类于 | | 阅读次数:   |   字数统计: 4,659

导入

SVN

略，待补充

Maven

maven简介

  1. 什么是maven？
      Maven是基于项目对象模型(POM)，可以通过一小段描述信息来管理项目的构建，报告和文档的软件项目管理工具。Maven是跨平台的项目管理工具。主要服务于基于Java平台的项目构建，依赖管理和项目信息管理。
    Maven主要有两个功能：

    1. 项目构建
    2. 依赖管理

  2. 什么是构建？
    构建

  3. 项目构建的3种方式

  • Eclipse
      手工操作较多，项目的构建过程都是独立的，很难一步完成。比如：编译、测试、部署等。开发时每个人的IDE配置都不同，很容易出现本地代码换个地方编译就出错

  • Ant
      Ant只是一个项目构建工具，它没有集成依赖管理。Ant在进行项目构建时，它没有对项目目录结构进行约定，需要手动指定源文件、类文件等目录地址。同时它执行task时，需要显示指定依赖的task，这样会造成大量的代码重复。

  • Maven
      Maven不仅是一个项目构建工具，更是一个项目管理工具。它在项目构建工程中，比ant更全面，更灵活。Maven在进行项目构建时，它对项目目录结构拥有约定，知道你的源代码在哪里，类文件应该放到哪里去。它拥有生命周期的概念，maven的生命周期是有顺序的，在执行后面的生命周期的任务时，不需要显示的配置前面任务的生命周期。例如执行 mvn install 就可以自动执行编译，测试，打包等构建过程

  1. maven模型
    maven模型

maven基本结构

maven的工程结构

Project
|-src
|   |-main
|   |   |-java —— 存放项目的.java文件
|   |   |-resources —— 存放项目资源文件，如spring, hibernate配置文件
|   |-test
|    |-java ——存放所有测试.java文件，如JUnit测试类
|    |-resources —— 测试资源文件
|-target —— 目标文件输出位置例如.class、.jar、.war文件
|-pom.xml ——maven项目核心配置文件

maven的命令

需要在pom.xml所在目录中执行以下命令。

Mvn compile

  执行 mvn compile命令，完成编译操作
  执行完毕后，会生成target目录，该目录中存放了编译后的字节码文件。

Mvn clean

  执行 mvn clean命令
  执行完毕后，会将target目录删除。

Mvn test

  执行 mvn test命令，完成单元测试操作
  执行完毕后，会在target目录中生成三个文件夹：surefire、surefire-reports（测试报告）、test-classes（测试的字节码文件）

Mvn package

  执行 mvn package命令，完成打包操作
  执行完毕后，会在target目录中生成一个文件，该文件可能是jar、war

Mvn install

  执行 mvn install命令，完成将打好的jar包安装到本地仓库的操作
  执行完毕后，会在本地仓库中出现安装后的jar包，方便其他工程引用

mvn clean compile命令

  cmd 中录入 mvn clean compile命令
  组合指令，先执行clean，再执行compile，通常应用于上线前执行，清除测试类

mvn clean test命令

  cmd 中录入 mvn clean test命令
  组合指令，先执行clean，再执行test，通常应用于测试环节

mvn clean package命令

  cmd 中录入 mvn clean package命令
   组合指令，先执行clean，再执行package，将项目打包，通常应用于发布前

  • 执行过程：
    清理————清空环境
    编译————编译源码
    测试————测试源码
    打包————将编译的非测试类打包

mvn clean install命令

  cmd 中录入 mvn clean install 查看仓库，当前项目被发布到仓库中
   组合指令，先执行clean，再执行install，将项目打包，通常应用于发布前

  • 执行过程：
    清理————清空环境
    编译————编译源码
    测试————测试源码
    打包————将编译的非测试类打包
    部署————将打好的包发布到资源仓库中

M2eclipse

  M2Eclipse是eclipse中的maven插件

安装配置M2Eclipse

若是版本较老的Eclipse，没有集成maven插件需要进行以下步骤：

  1. 将包中的插件复制到eclipse中的dropins目录中
  2. 在eclipse的“preference”查看eclipse中是否有maven插件
  3. 在maven—>installation中设置maven安装目录
  4. 在maven—>user setting中设置用户配置

创建maven工程的基本流程

  1. 选择new→maven→Maven Project
  2. 一直next，选择maven的工程骨架，这里我们选择quickstart。
    选择骨架
  3. 输入GroupId、ArtifactId、Version、Package信息点击finish完成。
    gav

maven核心概念

坐标

  1. 坐标的概念
      和在平面几何中坐标（x,y）可以标识平面中唯一的一点相似。在maven中坐标就是为了定位一个唯一确定的jar包。Maven世界拥有大量构建，我们需要找一个用来唯一标识一个构建的统一规范拥有了统一规范，就可以把查找工作交给机器。

  2. maven坐标的组成
    groupId:定义当前Maven组织名称
    artifactId:定义实际项目名称//如cn.itcast.maven
    version:定义当前项目的当前版本

依赖管理

  就是对项目中jar包的管理，可以在pom文件中定义jar包的GAV坐标，管理依赖。
依赖声明主要包括如下元素：

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

依赖范围

maven-依赖范围

  其中，依赖范围scope 用来控制依赖和编译，测试，运行的classpath的关系. 主要的是三种依赖关系如下：

  1. compile： 默认编译依赖范围。对于编译，测试，运行三种classpath都有效
  2. test：测试依赖范围。只对于测试classpath有效
  3. provided：已提供依赖范围。对于编译，测试的classpath都有效，但对于运行无效。因为由容器已经提供，例如servlet-api
  4. runtime:运行时提供。例如:jdbc驱动

依赖传递

  • 直接依赖和间接依赖
      若B中使用A，C中使用B，则称B是C的直接依赖，而称A是C的间接依赖。
    • C->B B->A //C直接依赖B,C间接依赖A
      maven-间接依赖

依赖范围对传递依赖的影响

maven-依赖影响

  • 左边第一列表示第一直接依赖范围
    上面第一行表示第二直接依赖范围
    中间的交叉单元格表示传递性依赖范围。

  • 总结：

    • 当第二依赖的范围是compile的时候，传递性依赖的范围与第一直接依赖的范围一致。
      • 当第二直接依赖的范围是test的时候，依赖不会得以传递。
      • 当第二依赖的范围是provided的时候，只传递第一直接依赖范围也为provided的依赖，且传递性依赖的范围同样为 provided；
      • 当第二直接依赖的范围是runtime的时候，传递性依赖的范围与第一直接依赖的范围一致，但compile例外，此时传递的依赖范围为runtime；

依赖冲突

  • 若直接与间接依赖中包含有同一个坐标不同版本的依赖，以直接依赖的版本为准（就近原则）
  • 从如下例子可以看出：
    • Maven-first工程依赖log4j-1.2.8版本, Maven-second无依赖，那么maven-third中依赖的是log4j-1.2.8
    • 若在前面的基础上，Maven-second依赖log4j-1.2.9，那么maven-third中依赖的是log4j-1.2.9
    • 若直接依赖中包含同一坐标不同版本的资源依赖，以配置文件下方的为准

可选依赖

  在依赖中添加optional选项决定此依赖是否向下传递，如果是true则不传递，如果是false就传递，默认为false。

1
2
3
4
5
6
7
8
9
<denpendencies>
    <dependency>
        <groupId>cn.itcast</groupId>
        <artifactId>maven-first</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <!-- 决定此依赖是否向下传递，true不传递，false传递 -->
        <optional>true</optional>
    </dependency>
</dependencies>

排除依赖

  排除依赖包中所包含的依赖关系，不需要添加版本号。如果在本次依赖中有一些多余的jar包也被传递依赖过来，如果想把这些jar包排除的话可以配置exclusions进行排除。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<dependency>
        <groupId>cn.itcast</groupId>
        <artifactId>maven-first</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <!-- 配置要排除的jar包 -->
        <exclusions>
        	<exclusion>
        	    <!-- 此处只需要groupId和artifactId，不需要版本号，
        	    此配置将排除所有版本 -->
        		<groupId>cn.itcast.maven</groupId>
        		<artifactId>maven-first</artifactId>
        	</exclusion>
        </exclusions>
</dependency>

生命周期

什么是生命周期？

  Maven生命周期就是为了对所有的构建过程进行抽象和统一。包括项目清理、初始化、编译、打包、测试、部署等几乎所有构建步骤。生命周期可以理解为构建工程的步骤。
  在Maven中有三套相互独立的生命周期，请注意这里说的是“三套”，而且“相互独立”，这三套生命周期分别是：

  • Clean Lifecycle： 在进行真正的构建之前进行一些清理工作。
  • Default Lifecycle： 构建的核心部分，编译，测试，打包，部署等等。
  • Site Lifecycle： 生成项目报告，站点，发布站点。

  再次强调一下它们是相互独立的，你可以仅仅调用clean来清理工作目录，仅仅调用site来生成站点。当然你也可以直接运行 mvn clean install site 运行所有这三套生命周期。

Maven三大生命周期

  1. clean：清理项目
      每套生命周期都由一组阶段(Phase)组成，我们平时在命令行输入的命令总会对应于一个特定的阶段。比如，运行mvn clean ，这个的clean是Clean生命周期的一个阶段。有Clean生命周期，也有clean阶段。Clean生命周期一共包含了三个阶段：
    • pre-clean 执行一些需要在clean之前完成的工作
    • clean 移除所有上一次构建生成的文件
    • post-clean 执行一些需要在clean之后立刻完成的工作
  •   mvn clean 中的clean就是上面的clean，在一个生命周期中，运行某个阶段的时候，它之前的所有阶段都会被运行，也就是说，mvn clean 等同于 mvn pre-clean clean ，如果我们运行 mvn post-clean ，那么 pre-clean，clean 都会被运行。这是Maven很重要的一个规则，可以大大简化命令行的输入。
  1. default:构建项目
      Default生命周期是Maven生命周期中最重要的一个，绝大部分工作都发生在这个生命周期中。这里，只解释一些比较重要和常用的阶段：
    • validate
    • initialize
    • generate-sources
    • process-sources :处理项目主资源文件。一般来说，是对src/main/resource目录的内容进行变量替换等工作后，复制到项目输出的主classpath目录中
    • generate-resources
    • process-resources 复制并处理资源文件，至目标目录，准备打包。
    • compile 编译项目的源代码。一般来说，就是编译src/main/java目录下的java文件到项目输出的主classpath目录中
    • process-classes
    • generate-test-sources
    • process-test-sources ：处理项目测试资源文件，一般来说，是对src/test/resource目录的内容进行变量替换等工作后，复制到项目输出的测试classpath目录中
    • generate-test-resources
    • process-test-resources 复制并处理资源文件，至目标测试目录。
    • test-compile 编译测试源代码。
    • process-test-classes
    • test 使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署。
    • prepare-package
    • package 接受编译好的代码，打包成可发布的格式，如 JAR 。
    • pre-integration-test
    • integration-test
    • post-integration-test
    • verify
    • install 将包安装至本地仓库，以让其它项目依赖。
    • deploy 将最终的包复制到远程的仓库，以让其它开发人员与项目共享。
  •   运行任何一个阶段的时候，它前面的所有阶段都会被运行，这也就是为什么我们运行mvn install 的时候，代码会被编译，测试，打包。此外，Maven的插件机制是完全依赖Maven的生命周期的，因此理解生命周期至关重要。
  1. site：生成项目站点
      Site生命周期：
    • pre-site 执行一些需要在生成站点文档之前完成的工作
    • site 生成项目的站点文档
    • post-site 执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
    • site-deploy 将生成的站点文档部署到特定的服务器上
  •   这里经常用到的是site阶段和site-deploy阶段，用以生成和发布Maven站点，这可是Maven相当强大的功能，Manager比较喜欢，文档及统计数据自动生成，很好看。

Maven插件

  Maven的核心仅仅定义了抽象的生命周期，具体的任务都是交由插件完成的。每个插件都能实现一个功能，每个功能就是一个插件目标。Maven的生命周期与插件目标相互绑定，以完成某个具体的构建任务。
例如compile就是插件maven-compiler-plugin的一个插件目标

Maven编译插件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!-- 在dependencies标签后 -->
<build>
    <plugins>
        <plugin>
        	<groupId>org.apache.maven.plugins</groupId>
        	<artifactId>maven-compiler-plugin</artifactId>
        	<configuration>
        	    <!-- 指定编译java1.7版本的源文件 -->
        		<source>1.7</source>
        		<target>1.7</target>
        		<encoding>UTF-8</encoding>
        	</configuration>
        </plugin>
    </plugins>
</build>

Tomcat插件

  写完以下配置后，可通过tomcat7:run 运行tomcat7（推荐，但是需要添加插件）

1
2
3
4
5
6
7
8
9
<plugin>
	<!-- 配置插件 -->
	<groupId>org.apache.tomcat.maven</groupId>
	<artifactId>tomcat7-maven-plugin</artifactId>
	<configuration>
		<port>8080</port>
		<path>/</path>
	</configuration>
</plugin>

继承

  继承是为了消除重复，可以把很多相同的配置提取出来。例如：grouptId，version等，具体步骤如下：

  1. 创建父工程（即创建一个packaging为pom的工程）
  2. 创建子工程
      创建方式有两种：
        一种是创建新工程为子工程，在创建时设置父工程的GAV。
        一种是修改原有的工程为子工程，在子工程的pom.xml文件中手动添加父工程的GAV。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    <!-- 在pom.xml中 -->
    <project ....>
        <modelVersion>4.0.0</modelVersion>
        <!-- 配置父工程gav -->
        <parent>
          <groupId>cn.itcast.maven</groupId>
          <artifactId>maven-parent</artifactId>
          <version>0.0.1-SNAPSHOT</version>
        </parent>
        <groupId>cn.itcast.maven</groupId>
        <artifactId>maven-subt</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </project>
  • 父工程可以做到的操作如下：
    1. 父工程中对依赖进行的配置，在子工程中都会继承此依赖
    2. 使用<dependencyManagement>可以管理依赖的版本号（即若子工程中有相同的依赖，可以不指定版本号，使用父工程中指定的版本号）
    3. 父工程可以使用<properties><log4j.version>1.2.9</log4j.version>...</properties>的形式定义版本号，在<dependencyManagement>中通过<version>${log4j.version}</version>的形式统一管理版本号

聚合

  聚合一般是一个工程拆分成多个模块开发，每个模块是一个独立的工程，但是要是运行时必须把所有模块聚合到一起才是一个完整的工程，此时可以使用maven的聚合工程。
例如电商项目中，包括商品模块、订单模块、用户模块等。就可以对不同的模块单独创建工程，最终在打包时，将不同的模块聚合到一起。
例如同一个项目中的表现层、业务层、持久层，也可以分层创建不同的工程，最后打包运行时，再聚合到一起。

创建聚合工程的步骤

  1. 创建聚合工程，打包方式为pom(用来放置子模块)
  2. 通过new- - - Maven Module创建子模块工程（若为表现层要将打包方式设置为war）
  3. 修改聚合工程的pom.xml文件
    1
    2
    3
    4
    5
    <!-- 在gav下添加如下内容 -->
    <modules>
        <module>模块的artifactId</module>
        ...  
    </modules>

Maven仓库管理

什么是Maven仓库？

  用来统一存储所有Maven共享构建的位置就是仓库。根据Maven坐标定义每个构建在仓库中唯一存储路径大致为：groupId/artifactId/version/artifactId-version.packaging

仓库的分类

  1. 本地仓库(每个用户只有一个本地仓库)
    ~/.m2/repository
  2. 远程仓库
    • 中央仓库：Maven默认的远程仓库，不包含版权资源http://repo1.maven.org/maven2
    • 私服：是一种特殊的远程仓库，它是架设在局域网内的仓库
      maven-仓库

私服

安装nexus

  为所有来自中央仓库的构建安装提供本地缓存。下载网站：http://nexus.sonatype.org/
  安装版本：nexus-2.7.0-06.war

  • 第一步：将下载的nexus的war包复制到tomcat下的webapps目录。
  • 第二步：启动tomcat。nexus将在c盘创建sonatype-work目录【C:\Users\当前用户\sonatype-work\nexus】。
    目录结构如下：
    maven-nexus结构1
    maven-nexus结构2

nexus的仓库简介

仓库有4种类型 :

  • group(仓库组)：一组仓库的集合
  • hosted(宿主)：配置第三方仓库 （包括公司内部私服 ）
  • proxy(代理)：私服会对中央仓库进行代理，用户连接私服，私服自动去中央仓库下载jar包或者插件
  • virtual(虚拟)：兼容Maven1 版本的jar或者插件

Nexus的仓库和仓库组介绍:

  • 3rd party: 一个策略为Release的宿主类型仓库，用来部署无法从公共仓库获得的第三方发布版本构建
  • Apache Snapshots: 一个策略为Snapshot的代理仓库，用来代理Apache Maven仓库的快照版本构建
  • Central: 代理Maven中央仓库
  • Central M1 shadow: 代理Maven1 版本 中央仓库
  • Codehaus Snapshots: 一个策略为Snapshot的代理仓库，用来代理Codehaus Maven仓库的快照版本构件
  • Releases: 一个策略为Release的宿主类型仓库，用来部署组织内部的发布版本构件
  • Snapshots: 一个策略为Snapshot的宿主类型仓库，用来部署组织内部的快照版本构件
  • Public Repositories:该仓库组将上述所有策略为Release的仓库聚合并通过一致的地址提供服务

nexus的使用

  1. 访问
    访问URL: http://localhost:8080/nexus-2.7.0-06/
    默认账号:
      用户名： admin
      密码： admin123

  2. 在本地仓库的setting.xml中配置如下(即配置所有构建均从私服下载)

    1
    2
    3
    4
    5
    6
    7
    8
    <mirrors>
       <mirror>
           <!--此处配置所有的构建均从私有仓库中下载 *代表所有，也可以写central -->
           <id>nexus</id>
           <mirrorOf>*</mirrorOf>
           <url>http://localhost:8080/nexus-2.7.0-06/content/groups/public/</url>
       </mirror>
     </mirrors>

未完待续

感谢你的阅读!