maven第二天——重要概念与其它操作

一、在eclipse中建立工程

　　在day01中我们搭建了eclipse的maven环境，接下来我们开始建立maven项目

　　1.在eclipse中建立JAVA工程

　　　　file->new->maven project，勾选 create a simple project（当然也可以选择 quickstart的模板）->next

　　在上述对话框中填入坐标信息和打包方式（这里选择jar），将以下信息填入，建立工程

　　　　　　groupId：com.atguigu.maven
        ArtifactId：MakeFriends
        Package：com.atguigu.maven

　　在src/main/java中新建类com.atguigu.maven.MakeFriends （注意包与类名）

public String makeFriends(String name){
            HelloFriend friend = new HelloFriend();
            friend.sayHelloToFriend("litingwei");
            String str = "Hey,"+friend.getMyName()+" make a friend please.";
            System.out.println(str);
            return str;
        }

　　在src/test/java中新建类com.atguigu.maven.MakeFriendsTest

package com.atguigu.maven;

import static junit.framework.Assert.assertEquals;
import org.junit.Test;

public class MakeFriendsTest {
    @Test
    public void testMakeFriends() {
        MakeFriends makeFriend = new MakeFriends();
        String str = makeFriend.makeFriends("litingwei");
        assertEquals("Hey,John make a friend please.", str);
    }
}

//不要自己去以IDE的方式导入jUnit的包

　　添加依赖信息（pom.xml）

<dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.9</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.atguigu.maven</groupId>
            <artifactId>HelloFriend</artifactId>
            <version>0.0.1-SNAPSHOT</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>

//自己建一个dependcies父标签

//执行此操作时请将之前建的maven工程进行导入

　　此时maven工程会生成一个maven的依赖：

　　当然，我们的工程依赖HelloFriend，但是仓库中并没有这个依赖，直接编译将报错，我们必须先进行安装（关于安装的概念请参见day01）:

　　在HelloFriend的 pom.xml上右击->run as->maven install （控制台输出 BUILD SUCCESS即OK）

　　接下来我们可以对MakeFriends进行编译了，在pom.xml上右击->run as->maven build...(第二个)，goals中填编译命令 compile

　　//当然，这样一直安装到仓库也是比较麻烦的，一般而言我们都是项目开发完了，最后需要打包测试了，再把需要安装的都安装一下即可。

　　默认的maven工程使用的是JDK1.5，如何一劳永逸的更换JDK版本呢：（一次性的可以自己进行配置包括JDK版本和编译版本）

　　　　[1]打开settings.xml文件
　　　　[2]找到profiles标签
　　　　[3]加入如下配置

<profile>
<id>jdk-1.7</id>
<activation>
<activeByDefault>true</activeByDefault>
<jdk>1.7</jdk>
</activation>
<properties>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
<maven.compiler.compilerVersion>1.7</maven.compiler.compilerVersion>
</properties>
</profile>

　　当然，由于版本问题，可能出现识别不了JDK8的问题，解决 方案可以是更换更高的maven版本，或者更换JDK版本

　　在项目中设置编译版本：

<plugins>
        <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.0</version>
                <configuration>
                   <source>1.8</source>
                   <target>1.8</target>
                </configuration>
        </plugin>
    </plugins> 

　　2.在eclipse中建立WEB工程

　　前面的步骤是一样的，建立maven工程->勾选simple project->打包方式换为war即可完成第一步的构建

　　　　慕课网中的做法（简便）：new一个maven project ，next时选择webapp的模板即可。

　　但是呢，这个视图不是我们想要的web工程的视图，我们来对其进行调整

　　右击项目->properties->project facts

　　将动态web工程的勾暂时去掉->apply（骗eclipse说这是一个java工程）->重新勾选（目的是出现下面多出的一个链接！）

　　点击该链接进行web工程的配置

//将content directory改为图中的目录

　　ok->apply->ok后完成了

　　　　到这里呢，我们仍然发现index.jsp会报错：

The superclass "javax.servlet.http.HttpServlet" was not found on the Java Build Path

　　　　原因就是缺少了servlet的api （当然，我们可以通过eclipse的方式：add library->server runtime的方式）

　　　　但我们这里合理的方式应该是maven的方式：（回顾前一天provided范围的使用）

　　　　在pom.xml中加入如下配置：

<dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>

　　//马上就不报错了 （报错时可以查看problems视图，查看具体信息）

　　当然，我们这里再导入一下JSP的API，让JSP有良好的提示功能

　　　　在pom.xml中添加如下依赖信息：

<dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.1.3-b06</version>
            <scope>provided</scope>
        </dependency>

　　//范围必须是probided范围，compile范围将报错！（产生了jar包冲突）

 在eclipse中导入工程：

　　导入之前建立的工程需要选择导入 maven 工程（没有settings等信息，这里只认识pom.xml），导入之后就会有附带的信息：

　　之后导入就直接按照常规的import->general->existing...的JAVA形式的导入了，以后我们导入呢也是通过这种常规的方式而不通过maven的方式（没有复制工程到工作区），常规的是有的：

　　【更新】：每一个骨架都会建相应的目录结构和一些通用文件，最常用的是maven-archetype-quickstart和maven-archetype-webapp骨架。maven-archetype-quickstart骨架是用来创建一个Java Project，而maven-archetype-webapp骨架则是用来创建一个JavaWeb Project。

　　//在eclipse等插件使用这两套骨架

二、maven依赖的深入

　　day01中我们已经对依赖有了一个初步的认识，接下来我们对maven的依赖进行进一步的理解！

　　1.依赖的传递性

　　　　我们现在之前的Hello工程中加入spring-core的jar包：

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.0.0.RELEASE</version>
            <scope>compile</scope>
        </dependency>

//当然这里会自动加入spring-core的依赖 commons-logging

　　　　此时可以发现，HelloFriend和MakeFriends的maven依赖都有了这两个依赖，我们可以看看依赖的层次结构(Hierarchy)[pom.xml可以查看]：

　　

　 　最上一层是直接依赖，下面的为传递依赖（其中 MakeFriends 依赖 HelloFriend 和 Hello,；HelloFriend 依赖 Hello ）

　　这里可以发现，最底层的模块的依赖可以向上传递，当然，这里需要指出的是，只有compile范围的才能传递，其它的范围都不能传递，被认为是

　　　　给当前工程使用的。（可以使用一个最底层的专门来负责公用的依赖）

　　当依赖找不到时，是因为maven在本地仓库中没有找到（可能没有安装），远程仓库也没有找到

　　2.依赖的排除

　　　　这里可以认为是传递的反操作，也就是用于设置依赖排除的场合（一些客观的原因，不希望一些传递进来的jar包）

　　　　排除的操作：这里我们以排除commons-loggings为例

　　　　　　打开MakeFriends的pom.xml，在HelloFriend的依赖处添加排除的配置

　　　　　　　　（commons-logging是由spring-core引入，有Hello传递到HelloFriend再传递过来的）

　　　　　　把commons-logging的坐标填入即可。（这里我们不需要去仓库找，直接在commons-logging上右击->open pom）

<exclusions>
                <exclusion>
                    <groupId>commons-logging</groupId>
                    <artifactId>commons-logging</artifactId>
                </exclusion>
            </exclusions>

//会屏蔽所有版本

　　这里我们可以发现，只是MakeFriends里的commons-logging没有了，其他的地方（HelloFriend等）都还存在，也就是屏蔽只是对当前工程生效的！

　　当然，如果在HelloFriend就排除了，MakeFriends里的依赖当然也就没有了（半路就被排除了）

　　　3.依赖的原则　　　

　　　　　　作用：解决工程之间的jar包冲突问题

　　　　　　例如：MakeFriends同时收到了两个传递过来的依赖：

　　　　　　　　MakeFriends收到俩个版本的log4j，maven如何做出选择呢？

　　　　　　　　就近原则：路径最短者优先！

　　　　　　如果非要用远路径的可以显式的声明

　　　　　　　如果路径一致呢？如何做出选择呢？

　　　　　　　　先声明者优先：dependency标签的声明顺序　

　　//eclipse下添加对本地工作空间maven项目的依赖可以直接在pom.xml的dependencies中点击add添加，无需手动添加坐标信息。

　　4.统一管理依赖版本

　　　　场景：一个工程中引入了spring的4.0。0的一些jar包：（这里以Hello为例，在Hello的pom.xml中配置依赖信息）

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.0.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.0.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>4.0.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>4.0.0.RELEASE</version>
        </dependency>

　　　　如果需要修改所有的版本为4.1.1呢，逐一地修改配置文件既容易出错，又不优雅

　　　　解决方案：使用<properties>标签内使用自定义标签统一声明版本号

　　<properties>
        <atguigu-spring-version>4.0.0.RELEASE</atguigu-spring-version>
    </properties>

　　　　　　　　　在需要统一版本的位置使用 ${自定义标签名}  来引用声明的版本号

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${atguigu-spring-version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${atguigu-spring-version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${atguigu-spring-version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${atguigu-spring-version}</version>
        </dependency>

　　　　其实，从这里可以看出，properties配置自定义标签，不仅可以应用于统一声明版本号，还可以配置例如字符集等等的统一的归一化配置！

三、其它的概念

　　maven的常见工程包括：java工程、web工程、pom工程

　　继承与聚合的项目更多介绍与最佳实践请参见：http://blog.csdn.net/wanghantong/article/details/36427411

　　　day01中剩下的几个概念我们在这里进行补充：

　　1.继承的概念

　　场景：   Hello依赖的 jUnit: 4.0

　　　　　　HelloFriend依赖的 jUnit: 4.0

　　　　　　MakeFeiends依赖的 jUnit: 4.9

　　　　以此为例是由于 jUnit的范围是test范围，没有传递性，属于比较离散的，很容易造成版本问题

　　解决方案：将 jUnit 的依赖统一提取到 “父工程” 中，子工程中声明 jUint 时不指定版本，以父工程中的统一设定为准（这样修改也方便了）

　　具体操作：

　　　　>创建一个maven工程作为父工程，注意:打包方式不是jar或war，而是pom

　　　　>在子工程中声明对父工程的引用

<!-- 声明对父工程的引用 -->
    <parent>
        <groupId>com.atguigu.maven</groupId>
        <artifactId>Parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <!-- 以当前文件为基准的父工程的pom文件的相对路径 -->
        <relativePath>../Parent/pom.xml</relativePath>
    </parent>

　　　　　　//其它工程也要声明

　　　　>将子工程的坐标与父工程坐标中重复的内容删除

　　　　　　继承为了消除重复，我们把很多相同的配置提取出来，例如：grouptId，version等

　　　　　　我们将上面的配置完成后，将会出现如下警告信息：

　　　　　　Version is duplicate of parent version =也就是有重复的地方

　　　　　　我们把重复的两行删掉即可！

　　　　　　//三个文件全部去掉警告的重复信息即可

　　　　>在父工程中使用 <dependencyManagement> 统一声明管理 jUnit 的依赖

  <dependencyManagement>
      <dependencies>
          <dependency>
              <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.0</version>
            <scope>test</scope>
          </dependency>
      </dependencies>
  </dependencyManagement>

　　　　>在子工程中删除 jUnit 的版本号

　　　　　　此时在子工程中会看到警告信息：父工程中已经进行了管理，你是否要进行重写

　　　　　　我们删除三个子工程的版本号信息即可。

　　注意：配置继承后，要执行安装操作时，需要先安装父工程

　　2.聚合的概念

　　　上面的继承需要安装时，有安装的顺序要求，比较复杂

　　　　聚合的作用：一键安装

　　　　具体操作：

　　　　　　在一个总的“聚合”工程中进行配置各个参与聚合的模块——可以父工程（大部分也都是这个方式，和父工程配置在一起）

　　　　　　在Parent的pom.xml中配置：

 <!-- 配置聚合 -->
  <modules>
      <!-- 指定各个子工程的相对路径 -->
      <module>../Hello</module>
      <module>../HelloFriend</module>
      <module>../MakeFriends</module>
  </modules>

　　　　测试：这里我们把F:\maven\repository\com\atguigu\maven下已经安装的Hello,HelloFriend删掉，在父工程的pom.xml上右键执行安装

　　　　控制台的信息可以看到安装顺序：

　　//这个顺序是我们配置的依赖顺序，maven会智能的调整顺序，即使配置时依赖顺序不按依赖的写也是可以的。

四、web工程的自动部署

　　一个web工程呢我们可以通过执行打包操作，打包成war包，将war包放在tomcat的webapps下，然后启动 tomcat ,它会自动把war包解压成目录的形式，就可以通过浏览器访问了，当然，这是我们手动的操作。

　　如何通过maven操作呢，在web工程MavenWebProject（之前建立的web项目）中的pom.xml中进行配置：

<!-- web工程的自动部署配置 -->
    <build>
        <finalName>AtguiguWeb</finalName>
        <!-- 配置构建过程中使用的插件 -->
        <plugins>
            <plugin>
                <!-- cargo是专门从事启动servlet容器的组织 -->
                <groupId>org.codehaus.cargo</groupId>
                <artifactId>cargo-maven2-plugin</artifactId>
                <version>1.2.3</version>
                <configuration>
                    <!-- 配置当前容器的位置 -->
                    <container>
                        <containerId>tomcat7x</containerId>
                        <home>F:\tomcat\apache-tomcat-7.0.75</home>
                    </container>
                    <configuration>
                        <type>existing</type>
                        <home>F:\tomcat\apache-tomcat-7.0.75</home>
                        <!-- 如果Tomcat端口为默认值8080则不必设置该属性 -->
                    <!--     <properties>
                            <cargo.servlet.port>8989</cargo.servlet.port>
                        </properties> -->
                    </configuration>
                </configuration>
                <!-- 配置插件在什么情况下执行 -->
                <executions>
                    <execution>
                        <id>cargo-run</id>
                        <!-- 生命周期的阶段 -->
                        <phase>install</phase>
                        <goals>
                            <goal>run</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

　　然后执行 run as->maven build...->goals:deploy（可以同时运行多个，使用空格分隔即可 clean compile）

　　测试：在浏览器中输入http://localhost:8080/AtguiguWeb/就可以正常访问了

　　//日志信息乱码这里暂且不讨论（在命令行正常显示）

　　但是这里不方便停止：

　　这里eclipse中按ctrl+c不管用，即使按了红框也不行（可以试试按了再启动tomcat也会报端口被占用的问题）

　　　　这里停止方式可以是：在命令行进入项目的路径（先进盘 cd，再进目录），再执行部署操作J（mvn deploy），

　　　　再在命令行按ctrl+c进行停止（报错暂时不管）

　　可以发现这种方式比较复杂，我们还是比较习惯在eclipse中操作（右键run on server）（不推荐这种在命令行中的操作）

五、查找依赖信息的网址

　　http://mvnrepository.com/

　　　　在ide中可以直接点击dependcies的add，选择搜索框可以搜索到坐标，并可以点击属性进行版本，范围等属性的具体配置