• Maven02 -学习总结&学习文档 -踩坑123


    1. maven在开发中的作用
      1.   ①自动添加第三方 jar

        在今天的 JavaEE 开发领域,有大量的第三方框架和工具可以供我们使用。要使用这些 jar 包最简单的方法就是复制粘贴到 WEB-INF/lib 目录下。但是这会导致每次创建一个新的工程就需要将 jar 包重复复制到 lib 目录下,从而造成工作区中存在大量重复的文件,让我们的工程显得很臃肿。

        而使用 Maven 后每个 jar 包本身只在本地仓库中保存一份,需要 jar 包的工程只需要以坐标的方式简单的引用一下就可以了。不仅极大的节约了存储空间,让项目更轻巧,更避免了重复文件太多而造成的混乱。

          ②解决jar 包之间的依赖关系

        jar 包往往不是孤立存在的,很多 jar 包都需要在其他 jar 包的支持下才能够正常工作,我们称之为jar 包之间的依赖关系。最典型的例子是:commons-fileupload-1.3.jar 依赖于 commons-io-2.0.1.jar,如果没有 IO 包,FileUpload 包就不能正常工作。

      2. ③获取第三方 jar

        JavaEE 开发中需要使用到的 jar 包种类繁多,几乎每个 jar 包在其本身的官网上的获取方式都不尽相同。为了查找一个 jar 包找遍互联网,身心俱疲,没有经历过的人或许体会不到这种折磨。不仅如此, 费劲心血找的 jar 包里有的时候并没有你需要的那个类,又或者又同名的类没有你要的方法——以不规范的方式获取的 jar 包也往往是不规范的。

        使用 Maven 我们可以享受到一个完全统一规范的 jar 包管理体系。你只需要在你的项目中以坐标的方式依赖一个 jar 包,Maven 就会自动从中央仓库进行下载,并同时下载这个 jar 包所依赖的其他 jar


        ——规范、完整、准确!一次性解决所有问题!


         

    2. maven的定义及标准开发流程
      1.   Maven 是Apache 软件基金会组织维护的一款自动化构建工具,专注服务于 Java 平台的项目构建和依赖管理。Maven 这个单词的本意是:专家,内行。读音是['meɪv(ə)n]或['mevn]。
      2. 构建过程的几个主要环节

        清理:删除以前的编译结果,为重新编译做好准备。

        编译:将 Java 源程序编译为字节码文件。

        测试:针对项目中的关键点进行测试,确保项目在迭代开发过程中关键点的正确性;自动调用junit程序.

        报告:在每一次测试后以标准的格式记录和展示测试结果。

        打包:将一个包含诸多文件的工程封装为一个压缩文件用于安装或部署。Java 工程对应 jar 包,Web 工程对应war 包。

        安装:在 Maven 环境下特指将打包的结果——jar 包或war ,安装到本地仓库中。

        部署:将打包的结果部署到远程仓库或将 war 包部署到服务器上运行。


         

    3. IDEA 开发maven工程 的那些坑
        1. 在总的聚合工程中使用 modules/module 标签组合,指定模块工程的相对路径即可
        2. 这样可以在idea中将所有关联的模块,放到一个页面
        3.  在总的聚合工程中使用 modules/module 标签组合,指定模块工程的相对路径即可

          <modules>
          <module>../Hello</module>
          <module>../HelloFriend</module>
          <module>../MakeFriends</module>
          </modules>
      5.强烈推荐:  使用IDEA创建maven父子工程项目
         - 父子工程中子工程为Maven的web项目
        1.  CSDN博客    https://www.cnblogs.com/tibit/p/6185704.html
        2. 统一管理所依赖 jar 包的版本 -- 自定义标签管理版本号
      1. 依赖的原则:解决 jar 包冲突

        [1] 路径最短者优先

        [2] 路径相同时先声明者优先


         

    4. maven资源站
      1.   

        我们可以到 http://mvnrepository.com/搜索需要的 jar 包的依赖信息。


    5. maven不重要的点
      1.   Web工程自动部署 ,直接编译器启动多好
    6. [尚硅谷封捷]_Maven02操作指南
      1.  完整操作 
        1.解压部署Maven核心程序
            ①检查JAVA_HOME环境变量
                C:WindowsSystem32>echo %JAVA_HOME%
                D:DevInstalljdk1.7.0_07
            ②解压Maven的核心程序
                将apache-maven-3.2.2-bin.zip解压到一个非中文无空格的目录下。例如:
                    D:DevInstallapache-maven-3.2.2
            ③配置环境变量
                M2_HOME D:DevInstallapache-maven-3.2.2
                path    D:DevInstallapache-maven-3.2.2in
            ④查看Maven版本信息验证安装是否正确
                C:WindowsSystem32>mvn -v
                Apache Maven 3.2.2 (45f7c06d68e745d05611f7fd14efb6594181933e; 2014-06-17T21:51:42+08:00)
                Maven home: D:DevInstallapache-maven-3.2.2in..
                Java version: 1.7.0_07, vendor: Oracle Corporation
                Java home: D:DevInstalljdk1.7.0_07jre
                Default locale: zh_CN, platform encoding: GBK
                OS name: "windows 7", version: "6.1", arch: "amd64", family: "windows"
        2.修改本地仓库
            ①默认本地仓库位置:~.m2
        epository
                ~表示当前用户的家目录,例如:C:Users[你当前登录系统的用户名]
            ②指定本地仓库位置的配置信息文件:apache-maven-3.2.2confsettings.xml
            ③在根标签settings下添加如下内容:<localRepository>[本地仓库路径,也就是RepMaven.zip的解压目录]</localRepository>
        3.第一个Maven工程
            ①目录结构
                Hello
                |---src
                |---|---main
                |---|---|---java
                |---|---|---resources
                |---|---test
                |---|---|---java
                |---|---|---resources
                |---pom.xml
        
            ②POM文件内容
        <?xml version="1.0" ?>
        <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.atguigu.maven</groupId>
            <artifactId>Hello</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        
            <name>Hello</name>
              
            <dependencies>
                <dependency>
                    <groupId>junit</groupId>
                    <artifactId>junit</artifactId>
                    <version>4.0</version>
                    <scope>test</scope>
                </dependency>
            </dependencies>
        </project>
            ③编写主程序代码
                在src/main/java/com/atguigu/maven目录下新建文件Hello.java,内容如下
                package com.atguigu.maven;
                public class Hello {
                    public String sayHello(String name){
                        return "Hello "+name+"!";
                    }
                }
            ④编写测试代码
                在/src/test/java/com/atguigu/maven目录下新建测试文件HelloTest.java
                package com.atguigu.maven;    
                import org.junit.Test;
                import static junit.framework.Assert.*;
                public class HelloTest {
                    @Test
                    public void testHello(){
                        Hello hello = new Hello();
                        String results = hello.sayHello("litingwei");
                        assertEquals("Hello litingwei!",results);    
                    }
                }
            ⑤运行几个基本的Maven命令前,一定要进入pom.xml文件所在的目录!
                mvn compile 编译
                mvn clean    清理
                mvn test    测试
                mvn package 打包
                ※注意:运行Maven命令时一定要进入pom.xml文件所在的目录!
            ⑥ 关于联网的问题
                1.Maven的核心程序中仅仅定义了抽象的生命周期,但是具体的工作是由特定的
        
        
        4.第二个Maven工程
            ①工程名:HelloFriend
            ②目录结构与第一个Maven工程相同
            ③POM文件
        <?xml version="1.0" ?>
        <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.atguigu.maven</groupId>
            <artifactId>HelloFriend</artifactId>
            <version>0.0.1-SNAPSHOT</version>
            <name>HelloFriend</name>
            
            <dependencies>
                <dependency>
                    <groupId>junit</groupId>
                    <artifactId>junit</artifactId>
                    <version>4.0</version>
                    <scope>test</scope>
                </dependency>        
                
                <dependency>
                    <groupId>com.atguigu.maven</groupId>
                    <artifactId>Hello</artifactId>
                    <version>0.0.1-SNAPSHOT</version>
                    <scope>compile</scope>
                </dependency>
                
            </dependencies>
        </project>
            ④主程序:在src/main/java/com/atguigu/maven目录下新建文件HelloFriend.java
                package com.atguigu.maven;    
                import com.atguigu.maven.Hello;
                public class HelloFriend {
                    public String sayHelloToFriend(String name){
                        Hello hello = new Hello();
                        String str = hello.sayHello(name)+" I am "+this.getMyName();
                        System.out.println(str);
                        return str;
                    }
                    public String getMyName(){
                        return "John";
                    }
                }
            ⑤测试程序:在/src/test/java/com/atguigu/maven目录下新建测试文件HelloFriendTest.java
                package com.atguigu.maven;    
                import static junit.framework.Assert.assertEquals;
                import org.junit.Test;
                import com.atguigu.maven.Hello;
                
                public class HelloFriendTest {
                    @Test
                    public void testHelloFriend(){
                        HelloFriend helloFriend = new HelloFriend();
                        String results = helloFriend.sayHelloToFriend("litingwei");
                        assertEquals("Hello litingwei! I am John",results);    
                    }
                }
            ⑥运行Maven命令
                mvn install    安装
        5.第三个Maven工程
            ①设置通过Maven创建的工程的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>
            ②工程坐标
                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);
                    }
                }
            ⑤添加依赖信息
                <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>
            ⑥在Eclipse环境下执行Maven命令:右击pom.xml选择run as 中的命令执行即可
        6.测试依赖的范围对传递性的影响
            ①在Hello中添加对spring-core的依赖
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-core</artifactId>
                    <version>4.0.0.RELEASE</version>
                    <scope>compile</scope>
                </dependency>
            ②在HelloFriend中查看spring-core是否被加入了运行时环境
            ③将Hello中对spring-core的依赖范围修改为test,再到HelloFriend中检查
            ④将Hello中对spring-core的依赖范围修改为provided,再到HelloFriend中检查
            ⑤结论:非compile范围的依赖不能传递,必须在有需要的工程中单独加入
        7.测试依赖原则
            ①路径最短者优先
                [1]在Hello中依赖log4j-1.2.17
                    <dependency>
                        <groupId>log4j</groupId>
                        <artifactId>log4j</artifactId>
                        <version>1.2.17</version>
                    </dependency>
        
                [2]在HelloFriend中依赖log4j-1.2.14
                    <dependency>
                        <groupId>log4j</groupId>
                        <artifactId>log4j</artifactId>
                        <version>1.2.14</version>
                    </dependency>
                [3]查看MakeFriends中自动引入的log4j是哪个版本
                
            ②路径相同时先声明者优先
                [1]创建OurFriends工程,依赖log4j-1.2.17
                [2]让MakeFriends依赖OurFriends
                [3]测试MakeFriends中,HelloFriend和OurFriends依赖的先后顺序和引入的log4j版本之间的关系
        8.创建Web工程
            ①ServletAPI依赖
                <dependency>
                    <groupId>javax.servlet</groupId>
                    <artifactId>servlet-api</artifactId>
                    <version>2.5</version>
                    <scope>provided</scope>
                </dependency>
            ②JSPAPI依赖
                <dependency>
                    <groupId>javax.servlet.jsp</groupId>
                    <artifactId>jsp-api</artifactId>
                    <version>2.1.3-b06</version>
                    <scope>provided</scope>
                </dependency>
        9.Web工程自动部署
            <build>
                <finalName>AtguiguWeb</finalName>
                <plugins>
                    <plugin>
                        <groupId>org.codehaus.cargo</groupId>
                        <artifactId>cargo-maven2-plugin</artifactId>
                        <version>1.2.3</version>
                        <configuration>
                            <container>
                                <containerId>tomcat6x</containerId>
                                <home>D:DevInstallapache-tomcat-6.0.39</home>
                            </container>
                            <configuration>
                                <type>existing</type>
                                <home>D:DevInstallapache-tomcat-6.0.39</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>
        10.继承
            ①创建Parent工程,打包方式为pom
            ②收集所有非compile范围的依赖信息,使用dependencyManagement标签统一管理
                <dependencyManagement>
                    <dependencies>
                        <dependency>
                            <groupId>junit</groupId>
                            <artifactId>junit</artifactId>
                            <version>4.9</version>
                            <scope>test</scope>
                        </dependency>
                    </dependencies>
                </dependencyManagement>
            ③在各个子工程中引用父工程
                <parent>
                    <groupId>com.atguigu.maven</groupId>
                    <artifactId>Parent</artifactId>
                    <version>0.0.1-SNAPSHOT</version>
                    
                    <!-- 以当前文件为基准查找父工程中pom.xml文件的相对路径 -->
                    <relativePath>../Parent/pom.xml</relativePath>
                </parent>
            ④删除子工程中的重复信息
                groupId
                artifactid
            ⑤在子工程中找到被父工程管理的依赖信息,删除版本号部分
            ⑥在父工程中统一修改已管理的依赖信息的版本号,看是否能够控制所有子工程
        11.聚合
            在总的聚合工程中加入如下信息
            <modules>
                <module>../Hello</module>
                <module>../HelloFriend</module>
                <module>../MakeFriends</module>
            </modules>
  • 相关阅读:
    PHP安装扩展mcrypt以及相关依赖项 【PHP安装PECL扩展的方法】
    linux设置开机自动启动
    php安装gd库
    php扩展库 说明
    把lighttpd配置为系统服务
    安装mysql5.6
    怎样当一个企业舍不得的人
    JQuery的$(document).ready(function(){})与JS的window.onload 的各自优势!
    JS中Null与Undefined的区别
    JS文本框输入限制
  • 原文地址:https://www.cnblogs.com/zhazhaacmer/p/10267855.html
Copyright © 2020-2023  润新知