精华内容
下载资源
问答
  • maven 添加tomcat依赖
    千次阅读
    2017-03-16 15:42:00

     https://my.oschina.net/angel243/blog/178554

    转载于:https://www.cnblogs.com/linbo3168/p/6559860.html

    更多相关内容
  • 于是去导入了包 <dependency> <groupId>javax.servlet</groupId> <artifactId>jsp-api</artifactId> <version>2.0</version> </dependency> 然后光荣的爆红了...

    起因

    最近在开发一个小项目,在jsp页面使用pageContext发现pageContext下没有方法。于是去导入了包

    <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>jsp-api</artifactId>
          <version>2.0</version>
    </dependency>
    

    然后光荣的爆红了error

    解决

    这个错误很有意思,它是由于pom导入的依赖和tomcat服务器lib中的依赖冲突导致。
    可以使用 <scope>provided</scope>解决

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

    scope的解释

    provided表示在build,test阶段都有依赖,在runtime时并不输出依赖关系而是由容器提供,例如web war包都不包括servlet-api.jar,而是由tomcat等容器来提供
    引用自 https://blog.csdn.net/pengpengzhou/article/details/81743567

    补充

    展开全文
  • Maven导入Tomcat7插件

    2020-04-08 09:30:49
    pom.xml配置 <!--tomcat插件--> <plugin> <groupId>org.apache.tomcat.maven</groupId> <!-- tomcat7的插件, 不同tomcat版本这个也不一样 --> ...

    pom.xml配置

    <!--tomcat插件-->
                <plugin>
                    <groupId>org.apache.tomcat.maven</groupId>
                    <!-- tomcat7的插件, 不同tomcat版本这个也不一样 -->
                    <artifactId>tomcat7-maven-plugin</artifactId>
                    <version>2.1</version>
                    <configuration>
                        <!-- 通过maven tomcat7:run运行项目时,访问项目的端口号 -->
                        <port>80</port>
                        <!-- 项目访问路径  本例:localhost:9090,  如果配置的aa, 则访问路径为localhost:9090/aa-->
                        <path>/travel</path>
                    </configuration>
                </plugin>
    
            </plugins>
        </build>
    

    pom.xml核心核心配置

    <?xml version="1.0" encoding="UTF-8"?>
    
    <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>cn.itcast</groupId>
      <artifactId>travel</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>war</packaging>
        <dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>3.8.1</version>
                <scope>test</scope>
            </dependency>
            <!--servlet-->
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>3.1.0</version>
                <scope>provided</scope>
            </dependency>
    
    
            <!--mysql驱动-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.26</version>
                <scope>compile</scope>
            </dependency>
            <!--druid连接池-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.0.9</version>
            </dependency>
            <!--jdbcTemplate-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>4.1.2.RELEASE</version>
                <scope>compile</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>4.1.2.RELEASE</version>
                <scope>compile</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>4.1.2.RELEASE</version>
                <scope>compile</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>4.1.2.RELEASE</version>
                <scope>compile</scope>
            </dependency>
            <dependency>
                <groupId>commons-logging</groupId>
                <artifactId>commons-logging</artifactId>
                <version>1.1.1</version>
                <scope>compile</scope>
            </dependency>
            <!--beanUtils-->
            <dependency>
                <groupId>commons-beanutils</groupId>
                <artifactId>commons-beanutils</artifactId>
                <version>1.9.2</version>
                <scope>compile</scope>
            </dependency>
            <!--jackson-->
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>2.3.3</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-core</artifactId>
                <version>2.3.3</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-annotations</artifactId>
                <version>2.3.3</version>
            </dependency>
    
    
            <!--javaMail-->
            <dependency>
                <groupId>javax.mail</groupId>
                <artifactId>javax.mail-api</artifactId>
                <version>1.5.6</version>
            </dependency>
            <dependency>
                <groupId>com.sun.mail</groupId>
                <artifactId>javax.mail</artifactId>
                <version>1.5.3</version>
            </dependency>
            <!--jedis-->
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>2.7.0</version>
            </dependency>
    
        </dependencies>
    
    
        <build>
            <!--maven插件-->
            <plugins>
                <!--jdk编译插件-->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                        <encoding>utf-8</encoding>
                    </configuration>
                </plugin>
                <!--tomcat插件-->
                <plugin>
                    <groupId>org.apache.tomcat.maven</groupId>
                    <!-- tomcat7的插件, 不同tomcat版本这个也不一样 -->
                    <artifactId>tomcat7-maven-plugin</artifactId>
                    <version>2.1</version>
                    <configuration>
                        <!-- 通过maven tomcat7:run运行项目时,访问项目的端口号 -->
                        <port>80</port>
                        <!-- 项目访问路径  本例:localhost:9090,  如果配置的aa, 则访问路径为localhost:9090/aa-->
                        <path>/travel</path>
                    </configuration>
                </plugin>
    
            </plugins>
        </build>
    </project>
    
    展开全文
  • 或者比如 a.class使用b.class, a依赖b类 1.4 为了改进项目的开发和管理,maven应运而生 maven可实现以下作用: (1)maven可以管理jar文件 (2)自动下载jar和他的文档,源代码 (3)管理jar直接的依赖, a.jar需要b....

    1、背景

    1.1 软件是一个工程

            我们在日常生活常能听到工程这个词,像桥梁工程、道路工程、南水北调工程等等。

            工程说简单点就是各个行业的从业人员通过总结规律或者方法,以最短的时间和人力、物力来做出高效可靠的东西。我们也就能理解桥梁工程,其实就是人们通过经验的总结和各种研究得出来的、用来修建桥梁时所采用的高效的方法,当然这种方法是可复用的。我们将这种作工程的思想应用到软件上,于是就产生了一软件工程。

            软件工程:为了能够实现软件的流水线式生产,在设计和构建软件时能够有一种规范和工程化的方法,人们便提出了软件工程概念。

    1.2 完成一个java项目,需要做的工作

    (1)分析项目要做什么,知道项目有哪些组成部分。

    (2)设计项目,通过哪些步骤,使用哪些技术.需要多少人,多长的时间.

    (3)组建团队,招人, 购置设备,服务器, 软件,笔记本..

    (4)开发人员写代码。开发人员需要测试自己写代码。重复多次的工作.

    (5)测试人员,测试项目功能是否符合要求.测试开发人员提交代码-如果测试有问题-需要开发人员修改--再提交代码给测试--测试人员再测试代码-如果还有问题-再交给开发人员-开发人员再提交-再测试直到-测试代码通过.  (多次重复的工作.

    1.3 在没有maven之前,开发一个java项目会遇到的问题

    (1)很多模块,模块之间有关系, 手工管理关系,比较繁琐

    (2)需要很多第三方功能,需要很多jar文件,需要手工从网络中获取各个jar

    (3)需要管理jar的版本, 你需要的是mysgl .5.1.5.jar 那不能给一个mysql.4.0.jar

    (4)管理jar文件之间的依赖, 你的项目要使用a.jar需要使用b.jar里面的类.必须首先获取到b.jar才可以,然后才能使用a.jar.

    说明:a.jar需要b:jar这个关系叫做依赖, 或者你的项目中要使用mysql的驱动, 也可以叫做项目依赖mysql驱动。或者比如 a.class使用b.class, a依赖b类

    1.4 为了改进项目的开发和管理,maven应运而生

    maven可实现以下作用:

    (1)maven可以管理jar文件

    (2)自动下载jar和他的文档,源代码

    (3)管理jar直接的依赖, a.jar需要b.jar , maven会自动下载b.jar

    (4)管理你需要的jar版本

    (5)编译程序,把Java编译为class  (构建)

    (6)测试代码是否正确.  (构建)

    (7)将你编写的类打包,形成jar文件,或者war文件  (构建)

    (8)帮你部署项目  (构建)

    总结:maven帮忙完成费时费力又麻烦的重复性工作,程序员就可以专心写功能型代码了。

    2、maven 构建  项目的构建       

       构建是面向过程的,就是一些步骤,完成项目代码的编译,测试,运行,打包,部署等等.maven支持的构建包括有:

    (1)清理, 把之前项目编译的东西删除掉,为新的编译代码做准备。

    (2)编译, 把程序源代码编译为执行代码, 批量将.Java文件变成.class文件, maven可以同时把成千上百的.java文件编译为.class.(传统的javac一次只能编译一个文件)

    编译方法:maven工程所在的根目录下,启动cmd(直接windows文件目录那里输入cmd),然后输入命令 mvn compile

    (3)测试, maven可以执行测试程序代码,验证你的功能是否正确。maven同时批量执行多个测试代码,同时测试很多功能(传统的测试一次只能测试一个类,那要测试多久才能测试完啊)

    (4)报告, 生成测试结果的文件, 告知测试是否通过。

    (5)打包, 把你的项目中所有的class文件,配置文件等所有资源放到一个压缩文件中。这个压缩文件就是项目的结果文件,通常Java程序,压缩文件是Jar扩展名的.对于web应用,压缩文件扩展名是.war

    (6)安装, 把(5)中生成的文件jar, war安装到本机仓库中

    (7)部署, 把程序安装好可以执行。  (一般不用maven部署)

    说明:开发中主要做1-6,不用maven部署,maven部署更复杂

    3、maven的安装和配置

    (1)从maven的官网下载maven的安装包apache-maven-x.x.x-bin.zip

    (2)解压安装包,解压到一个目录,非中文目录.

                子目录bin :里面有maven执行程序,主要是mvn.cmd

                子目录conf :里面有maven工具本身的配置文件settings .xml

    (3)配置环境变量在系统的环境变量中,指定一个M2_HOME的名称, 指定它的值是maven工具安装目录,(bin之前的目录)

    M2 HOME=安装目录  。再把M2_HOME加入到path之中,在所有路径之前加入%M2_HOME%\bin;4)验证,新的命令行中,执行mvn-v

    4、maven 核心概念 (maven中的术语)

    (1)POM    Project Object Module   项目对象模型

        一个文件名,名称是pom.xml,该文件控制maven构建项目的过程,管理jar依赖

    (2)约定的目录结构

        maven项目的目录和文件位置都是有规定的,不能随便乱放

    (3)坐标(gav)

        Maven把任何一个插件都作为仓库中的一个项目进行管理,用一组(三个)向量组成的坐标来表示。坐标在仓库中可以唯一定位一个Maven项目。

    groupld:组织名,通常是公司或组织域名倒序+项目名

    artifactld:模块名,通常是工程名

    version:版本号

           需要特别指出的是,项目在仓库中的位置是由坐标来决定的、groupld, artifactid和version决定项目在仓库中的路径(groupId对应的包路径/模块名/版本号/jar包), artifactid和version决定jar包的名称。

        进入POM.xml文件,对坐标进行配置。

    (4)依赖管理

        用于管理项目中可以使用的jar文件

    (5)仓库管理(了解即可)

        资源存放的位置

    (6)生命周期(了解即可)

         maven构建项目的过程,就是生命周期。即完成清理、编译,测试,运行、打包等

    (7)插件和目标(了解即可)

        执行maven构建的相关命令时,比如清理,编译、打包等命令,实际是插件在运作。插件就是Maven的功能类。

    (8)继承

         和java继承类似,由父及子

    (9)聚合

            将多个项目汇总到一起

    4.1、maven工程约定的目录结构

    每一个maven项目在磁盘中都是一个文件夹(就相当于是IDEA项目的文件夹)

    JAVA工程名

    src
    main
    java各种包程序的包和包中的java文件
    resourcesjava程序需要的配置文件
    test放置测试程序的代码和配置文件(如果要求测试,允许没有测试文件)
    java各种包测试程序要使用的包和包中的java文件
    resources测试java程序需要的配置文件
    pom.xml maven的核心文件(maven启动后就通过这个文件了解该做什么)

    target

    (maven自动生成的

    结果目录)

    当对src中的java文件进行编译以后,maven自动生成这个文件夹用于存放编译后的class文件

    4.2 编译方法

         进入maven工程的根目录(pom.xml文件所在的位置),启动cmd(直接windows文件目录那里输入cmd),然后输入命令 mvn compile。就会编译main中的所有java文件,并自动在根目录新建一个target文件夹,将编译好的.class文件放入此文件夹。第一次编译,maven会下载一堆插件。

    疑问1 第一次执行时,为什么要下载那些插件

         maven工具执行的操作是通过很多特定功能的插件(java类--jar文件)来完成的,因此需要网上下载相关插件。

    疑问2 下载的插件存放到哪里了.

    默认仓库(本机仓库) :C:\Users\ (登录操作系统的用户名) Administrator\.m2\repository

    修改本地仓库方法(如果不想放在c盘):

          进入maven安装目录/conf/settings.xml(为了安全,先备份),然后进入settings.xml,找到<localRepository>xxx</localRepository>标签,将标签挪到注释外面,将里面的值改成新目录地址(比如F:/apache-maven-3.6.3)即可,注意,文件里面是 \ ,但是maven标签里面是 /,注意该斜杠方向。

    说明:maven默认是从中央仓库下载插件。中央仓库地址就在官网

    4.3 仓库

    (1)仓库是什么:仓库是存放东西的, 存放maven本身需要使用的jar包,和我们项目需要使用的jar包

          ① maven本身需要使用的插件(各种jar)

          ② 项目使用的Jar(第三方的工具),比如mysql,spring等jar包

    (2)仓库的分类

    ① 本地仓库,

           指个人计算机上的文件夹,存放各种jar

    ② 远程仓库, 在互联网上的,使用网络才能使用的仓库

        Ⅰ  中央仓库,最权威的,所有的开发人员都共享使用的一个集中的仓库(因此压力很大),中央仓库地址: https://repo.maven.apache.org

        Ⅱ  中央仓库的镜像:中央仓库的备份,在各大洲,重要的城市都是镜像.(为了缓解中央仓库的压力)

    说明:当我们项目需要jar包时,maven会先找各大洲maven的镜像,都找不到再去中央仓库

        Ⅲ 私服,在公司内部,局域网中使用的仓库,不对外使用。

    (3)仓库的使用

        开发人员需要使用mysql驱动,maven会首先查找本地仓库——>私服(如果有私服)——>各大洲的镜像——>中央仓库

    说明:maven全程自动完成。找到jar包以后,都会自动备份到私服和本地仓库。下次即可直接在本地访问。

    4.4 pom文件  Project Object Model

        pom文件即Project Object Model项目对象模型。Maven把一个项目的结构和内容抽象成一个模型,在xml文件中进行声明,以方便进行构建和描述, pom.xml是Maven的灵魂。所以, maven环境搭建好之后,所有的学习和操作都是关于pom.xml的。

    (1)pom.xml 概述

    modelVeisionMaven模型的版本
    坐标

    groupId

    (互联网唯一)

    组织id,一般是公司域名的倒写(互联网上域名唯一,所以倒写也唯一),格式可以为:
    1.域名倒写。 例如:com.baidu
    2.域名倒写+项目名。 例如:com.baidu.appolo
    groupId、artifactId、version三个元素生成了一个Maven项目的坐标,在互联网众多的Maven项目中可以唯一定位到某一个项目。坐标也决定将来项目在仓库中的路径及名称(groupId对应的包路径/模块名/版本号/jar包

    artifactId

    (公司内部唯一)

    项目名称,也是模块名称,对应groupId中项目的子项目
    version项目的版本号。如果项目还在开发中,是不稳定版本,通常在版本后代-SNAPSHOT
    version使用三位数字标识,例如1.1.0
    packaging(打包)项目打包的类型,可以是jar、war、rar、ear、pom,默认是jar
    dependencies和dependency(依赖)Maven的一个重要作用就是管理jar包,为了一个项目可以构建或运行,项目中不可避免的,会依赖很多其他的jar包,在Maven中,这些jar就被称,为依赖,使用标签dependency来配置。而这种依赖的配置正是通过坐标来定位的,由此我们也不难看出, maven把所有的jar包也都视为项目存在了。
    properties(配置属性)properties用来定义一些配置属性,例如project.build.sourceEncoding,可以设置为UTF-8,防止中文乱码,也可定义相关构建版本号,便于日后统一升级

    build(构建)

    配置插件

    build表示与构建相关的配置,例如设置编译插件的jdk版本。

    插件可以在自己的项目中设置,最常使用的是maven编译插件。设置项目使用的jdk版本时通过编译插件指定。pom.xml文件<build>中设置。

    (2)坐标:唯一值, 在互联网中唯一标识一个项目的

    <groupId>公司域名的倒写</groupId>

    <artifactId>自定义项目名称</artifactId>

    <version>自定版本号</version>

    (3)packaging 

    项目的打包类型:pom、jar(默认)、war(web应用)

    packing默认是jar类型,

    <packaging>pom</packaging>   --------->   父类型都为pom类型 (springcloud父项目)

    <packaging>jar</packaging>      --------->   内部调用或者是作服务使用

    <packaging>war</packaging>    --------->   需要部署的项目

    扩展:pom(没有java代码,也不执行java代码,只是为了聚合工程传递依赖)

    所有的父级项目的packaging都为pom,作为父级项目,还有一个重要的属性,那就是modules,通过modules标签将项目的所有子项目引用进来,在build父级项目时,会根据子模块的相互依赖关系整理一个build顺序,然后依次build

    <project>
      <packaging>pom</packaging>
       <modules>
          <module>abcd-business</module><!-- pom -->
          <module>abcd-sms</module><!-- pom -->
       </modules>
    </project>

    各个module里面依赖的项目中,子项目pom里面依赖的jar,和war最终都会被maven管理好。

    (4)依赖    相当于java代码中的import

        即在pom.xml文件中,添加 <dependencies>  标签(一般添加在properties标签下面),粘贴搜索到的插件的jar包的坐标。下面以mysql jar包,log(日志)jar包,junit单元测试jar包为例。添加成功后,会在本地仓库中,找到对应的文件夹

    <dependencies>

    <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.22</version>
    </dependency>

    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
    </dependency>

    </dependencies>

    扩展:IDEA中查看依赖关系小技巧,在IDEA中,进入pom.xml配置文件,右键—Diagrams  即可看到图表版依赖关系

    扩展:<dependencyManagement> 

          其通常用在项目中对顶层的父POM中,它能让其所有子项目引用一个依赖而不用显式的列出版本号。此外,dependencyManagement 只是声明依赖,并不实现引入(像极了接口),子项目如果不声明依赖,则不会从父项目中继承下来。

    提供作用:子模块继承之后,可以锁定版本+子module不用写groupId和version。 

    注意:子模块如果不写,就用父项目的版本,子模块写了,就用自己的版本

    <dependencyManagement>
        <dependencies>
          <!--spring boot 2.2.2-->
          <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.2.2.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
          </dependency>

    (5)properties 

    ① 设置Maven的常用属性

    进入pom.xml   找到properties标签

    <properties>

    <project.build. sourceEncoding>UTF-8</project. build. sourceEncoding> //<!--maven构建项目使用的是utf-8 ,避免中文的乱码-->

    <maven. compiler. source>1.8</maven. compiler.source> //<!--编译java代码使用的jdk版本-->

    <maven. compiler.target>1.8</maven. compiler.target> //<!--你的java项目应该运行在什么样的idk版本-->

    </properties>

    一般应用场景:一般在父项目中写好常用版本号属性,就可以对子项目进行统一管理(需要子项目通过parent标签引入该父项目)

    ② Maven的全局变量设置

    • 自定义属性

        Ⅰ  在<properties>通过自定义标签声明变量(标签名就是变量名)

        Ⅱ  在pom.xml文件中的其他位置,使用${标签名}使用变量的值

    说明:自定义全局变量一般是定义,依赖的版本号,当你的项目中要使用多个相同的版本号,先使用全局变量,定义,再使用${标签名}使用属性值。

    exp:spring框架中,很多依赖的jar包都是同一个版本号,如果修改的话,一个一个改很麻烦,改掉了还会导致项目不成功。因此可以在<properties>中自定义属性,然后在<dependency>中使用这个自定义属性

    <properties>   //在properties标签中自定义<spring.version>属性

    ....

        <spring.version>5.2.0</spring.version>

    </properties>

    <dependency>  //在依赖中,直接调用spring.version属性的值,这样改动properties中的属性值,就可以修改所有依赖里面的属性值

    ....

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

    </dependency>

    特别说明:如果子项目的某个依赖中A的某个内部依赖B(A依赖B),父项目也用了B,子项目中的B版本和父项目的B版本不一致,可以在properties中专门写B的版本,这样父子项目B依赖都会统一。

    (6)build: maven在进行项目的构建时的配置信息,例如编译java代码使用的jdk版本

    扩展: 资源搜索方法

    手动搜索资源的地址:https://mvnrepository.com(ps:谷歌浏览器才能打开),使用groupId或者artifactId作为搜索条件

    4.5 Maven的生命周期,Maven的命令,Maven的插件

    (1)生命周期

       就是Maven构建项目的过程,即清理,编译,测试,报告,打包,安装,部署

    (2)Maven的命令

        Maven通过使用命令,完成项目的生命周期的执行(即通过命令完成清理,编译,测试,报告,打包,安装,部署)

    (3)Maven的插件

    Maven命令执行时,真正完成功能的是插件,插件就是一些jar文件,即一些类。

    (4)单元测试  junit,junit是一个专门测试的框架(工具),用于测试类中的方法

               junit测试内容:测试的是类中的方法,每一个方法都是独立测试的。 类中的方法 是测试的基本单位(单元)

               maven借助单元测试,批量的测试类中的大量方法是否符合预期的。

    • junit 使用步骤:

    Ⅰ  在pom.xml加入单元测试依赖。 仓库里面去搜,用使用人数最多的就是了

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
    </dependency>

    Ⅱ  在maven项目中的  src/test/java 目录下,创建测试程序。

    Ⅲ  推荐的创建类和方法的提示:

    ①  测试类的名称 是:Test + 测试的类名

    ②  测试的方法名称 是:test + 方法名称

    exp:

    @Test    //必须要用测试注解

    public class TestHelloMaven{

        public void testAdd(){

            方法体;

        }

    }

    说明:

    ①  其中testAdd叫做测试方法,它的定义规则  

    ②  方法是public的,必须的

    ③  方法没有返回值,必须的

    ④  方法名称是自定义的,推荐是test+方法名称

    ⑤  方法上方加入@Test注解

    exp:测试  某工程/src./main/java/com/Huhaha   下的 HelloMaven.java 中的 public void add()方法

    在 Maven工程的test目录创建测试类的测试文件,注意包名,路径一致    某工程/src/test/java/com/Huhaha 创建测试类

    将测试类按建议规则命名:TestHelloMaven.java

    package com.Huhaha;  //测试类的路径

    import org.junit.Assert;  //导入测试包

    import org.junit.Test;

    public  class TestHelloMaven{

        @Test

        public void testAdd(){

        HelloMaven hello = new HelloMaven(); //构造测试类HelloMaven的对象hello

        int res = hello.add(10,20);  //对象来调用将要测试的方法add()

    //assertEquals(期望值,实际值),测试的类方法,如果测试通过,即两个值相等证明正确的。不通过就抛异常

        Assert.assertEquals(30,res);

        }

    }

    4.6 Maven的命令

    (1)清理 mvn clean 。 

        清理之前编译时,生成的target目录。

    操作步骤:

    打开cmd,转到项目根目录下(pom.xml)所在位置。  输入 mvn clean

    (2)编译主程序文件  mvn compile

    编译main/java/目录下的java为class文件,同时把class拷贝到target/classes目录下面

    把main/resources目录下的所有文件,都拷贝到target/classes目录下

    操作步骤

    打开cmd,转到项目根目录下(pom.xml)所在位置。  输入 mvn compile

    (3)编译测试文件 mvn test-compile

        编译test./java/目录下的class文件,并将其拷贝到target\test-classes\包  下面

    操作步骤:

    打开cmd,转到项目根目录下(pom.xml)所在位置。  输入 mvn test-compile

    (4)测试 mvn test 测试(会生成一个目录surefire-reports,保存测试结果)

       执行测试文件

       执行mvn test的时候,会把前面的清理-编译主程序-编译测试程序 三个环节都执行一遍。测试完成可以直接在cmd中看到报告,同时在target/surefire-reports生成一个txt测试报告

    操作步骤:

    打开cmd,转到项目根目录下(pom.xml)所在位置。  输入 mvn test

    测试完成,会直接在cmde中看到报告。

    (5)打包主程序  mvn package

    编译、编译测试、测试、并且按照pom.xml配置(即以配置文件中的坐标为依据命名,建立类的相关性)把主程序=打包成jar包或war包,并存放在target目录下

    jar文件中只包含 src/main中的所有内容,不包含测试文件

    操作步骤:

    打开cmd,转到项目根目录下(pom.xml)所在位置。  输入 mvn package

    (6)安装 mvn install

        安装主程序(会把本工程打包,并且按照本工程坐标保存到本地仓库中)

        安装以后,公司的其他程序员都可以用这个jar包了(将打包好的jar包从target文件夹保存到本地仓库,并做好相关配置)

    存放路径:groupId对应的包路径/模块名/版本号/jar包)

    比如:repository/com/Huhaha(groupId)/ch01-maven(模块名)/1.0-SNAPSHOT(版本号)/ch01-maven-1.0-SNAPSHOT.jar

    操作步骤:

    打开cmd,转到项目根目录下(pom.xml)所在位置。  输入 mvn install

    特别注意:执行mvn命令某个步骤的时候,都会把这个命令之前的所有命令都执行一遍。比如执行mvn install,会把前面的1-5步骤都自动执行了

    4.7 配置插件

            Maven中,实际完成上面项目构建的都是Maven插件,插件可以在自己的项目中设置。最常使用的是maven编译插件。设置项目使用的jdk版本时通过编译插件指定。pom.xml文件<build>中设置。

    操作步骤:

    进入 pom.xml   一般在最后,开始写build标签

    <!--控制配置maven构建项目的参数设置,设置jdk的版本-->

    <build>

        <!--配置插件-->

        <plugins>      // 配置具体的多个插件

            <plugin>

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

                <artifactId>maven-compiler-plugink/artifactId>  //  <!--插件的名称-->

                <version>3.8.1</version>  //  <!--插件的版本-->

                <configuration>  //   <!--配置插件的信息->

                        <source>1.8</source>      //告诉maven我们的写的代码是在jdk1.8上编译

                        <target>1.8</target>   //告诉Maven此项目在jdk1.8的运行环境上运行

                    </configuration>

                </plugin>

            </plugins>

    </build>

    特别说明:plugin标签的内容都是直接从Maven的官网上复制来的,不用专门记忆。(直接百度 Maven 插件 进Maven官网即可找到)

    5、IDEA中使用Maven  (重点)

    5.1 IDEA中配置Maven

    IDEA中内置了Maven,但内置Maven配置不方便。都用自己下载的Maven。因此首先要在IDEA中设置我们自己的Maven

    设置步骤:

    进入 IDEA的两个目录设置,一个是 File-Settings(对当前工程有效) ,另一个是 File-Other Settings-Settings for NewProject(对以后的新建工程有效)。两个目录配置方法一模一样(这里以当前工程设置为例)

    Step1:设置Maven安装目录

    File-Settings-Build,Execution,Deployment-build tools-Maven

    Step2:进入Build Tools —Maven—Runner

    vm Options: -DarchetypeCatalog=internal  

    说明:Maven项目创建时,Maven会自动联网去外网下载模板文件,而且比较大,又是外网。效率就非常低。加入这个代码,可以让Maven不下载模板文件,创建项目就会非常快。(有的IDEA版本加了这个会报错,删掉就是了)

    JRE:选择jdk的版本

    5.3 IDEA中创建基于Maven的项目

    5.3.1 IDEA中创建JavaSE项目

    Step1:选择一个空工程并命名maven-course (便于以后添加不同技术的模块)

    New-Project-EmptyProject

    step2:使用模板创建项目

    Project Seetings 点击+(Add)-New Module   在Module中 选择左侧的Maven

    选择好自己的jdk版本,然后打钩使用模板,接着选择quickstart模板(比较靠后的模板)。这个模板用于创建普通的java项目

    最后

    项目创建完成

    说明: quick-start模板没有recourses文件夹,需要我们手动创建

    创建步骤:

    step1:点击main文件夹,右键 New-Directory   将文件夹取名Recourses(此时还只是普通文件夹)

    step2: 把recourses文件夹变成项目配置文件夹

    recourses文件夹 右键 Mark Directory as Resources Root

    IDEA中的Maven模块说明:

    5.3.2  IDEA中创建JavaWeb项目

    step1:仿照上面JavaSe的创建方法 New-Module-Maven (只是和javaSE用的模板不同而已)

    选择:maven-archetype-webapp模板

    step2:取项目名字,设置项目坐标(仿照前面的javase步骤)

    创建完成。

    step3:补充缺失目录。main下面补充java(设置为Sources Root),补充recourses(设置为Resources root)

    step4:(如果要做测试):补充test目录,test目录下再补充java(设置为Test Sources Root),补充recourses(设置为Test Resources root)

    step5 加入serlvet和jsp的依赖(听说serlvet和jsp已过时)

    step6 写serlvet代码,或jsp代码

    step7 配置Tomcat服务器

    (1)选择Edit Configuration

    (2)选择 Local 

    (3)取名字,并选择好端口号,然后进入部署页面(deployment)

    (4)deployment页面部署项目

    (5)给项目取名

    (6)启动Tomcat

    (7)通过本机浏览器,去访问页面

    5.4 IDEA中导入别人的maven项目

        选择IDEA主窗口右上角的工程结构,选择"+" ,Import Module,选择Module文件夹所在的目录(整个maven项目所在的根目录),点击“ok”,再次向IDEA确认是导入Maven项目,finish

    然后,在依赖界面(dependency),选择导入项目的JDK版本

    6、依赖管理

    (1) 依赖的范围

           依赖范围在<dependency>标签下用<scope>的值标签标识,表示依赖使用的范围,也就是在Maven构建项目的哪些阶段有效。

    <scope>标签的值有:compile、test、provided、默认采用compile(不写<scope>标签,就是默认<scope>compile</scope>标签)

    compile

    所有阶段都有效

    test

    只在测试阶段有效

    provided

    编译,测试有效。不参与打包

    对主程序是否有效
    对测试程序是否有效
    是否参与打包
    是否参与部署
    说明项目生成的jar包或者war包里面有个lib文件,专门放依赖的jar包项目生成jar包或者war包里,没有lib文件夹。依赖的其他jar包只在编译、测试的时候使用,但最终都不参与项目的打包

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>

        <scope>test</scope>   //说明junit只在测试时,这个依赖有效
    </dependency>

    <dependency>

    <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>

        <scope>provided</scope>   // 说明编译、测试时会使用,但生成项目的时候,不用这个jar包(Tomcat服务器都会再带serlvet类)
    </dependency>

    (2)排除传递的某些依赖  <exclusions>

           在mavenB项目中引入mavenA项目依赖,A项目中又有多个A相关的依赖,通过依赖传递,会将mavenA中的jar包传递进来,如果B中不需要A中的某个依赖(jar包)就可以使用以下标签

    <exclusions>
        <exclusion>
        <groupId></groupId>
        <artifactId></artifactId>
        </exclusion>
    </exclusions>

    exp:

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
      <exclusions>
        <exclusion>
          <artifactId>commons-logging</artifactId>
          <groupId>commons-logging</groupId>
        </exclusion>
      </exclusions>
    </dependency>

    简便方法:

    ① 进入图表版依赖关系

         在IDEA中,进入pom.xml配置文件,右键—Diagrams  即可看到图表版依赖关系

    ② 选中不想要的依赖,右键—exclude

        

    7、资源插件

    (1)背景

            没有使用resources的时候,Maven执行编译代码时,会把src/main/resources目录中的文件直接拷贝到target/classes目录中。对于在src/main/java目录下的非java文件,都不会处理,不会将其拷贝到target/classes目录中去。

            但实际开发中,比如使用mybatis框架的时候,我们需要把一些文件放在src/main/java中,而且在执行java程序时,需要用这些文件,即需要将其拷贝到target/classes目录中去。此时就需要在pom.xml中的<build>标签加入<resources>,告诉maven该怎么拷贝

    (2)配置方法

    <build>

        <resources>

            <resource>

                <directory>src/main/java</directory> <!--要拷贝文件所在的目录-->

                <includes>   <!--该目录下的后缀名为.properties,.xml文件都会被拷贝-->

                    <include>**/*.properties</include>  

                    <include>**/*.xml</include> 

                </includes>

                <filtering>false</filtering>  //  <false指不启用过滤器, *.property已经过滤后缀名了-->

             </resource>

        </resources>

    </build>

    展开全文
  • maven添加tomcat插件

    万次阅读 多人点赞 2018-10-12 17:39:20
    由于maven添加tomcat插件有效的解决了没有本地服务器的囧态,有必要学一下~~~也可以用来装X嘛 pom.xml添加如下代码 &lt;build&gt; &lt;plugins&gt; &lt;!-- tomcat插件控制 --&...
  • Tomcat 10 用 javax.servlet 会出现 ***Servlet不是Servlet <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>4.0.1...
  • maventomcat的使用

    2016-12-29 10:39:09
    在eclipse中使用maventomcat插件进行打包,打成war包,需要在pom.xml文件中有如下配置,这是对maven安装tomcat插件,这与传统的打包然后部署的区别在于:传统的是在本地安装了tomcat,然后把项目部署到本地进行了运行,而...
  • 用了很多网上的方法都没有解决,最后看到此文章: 解决方法:将idea自带maven替换成本地的最后刷新maven
  • tomcat源码导入maven项目
  • maven插入tomcat7报错
  • 问题阐述:idea-java-maven项目, pom.xml文件添加了tomcat依赖后,右栏maven插件列表却显示不出tomcat插件图标. 1.maven依赖没反应过来,点击刷新一下即可。 2.如果不是上面的原因,很有可能是插件编译的依赖没有...
  • 不要tomcat容器也能运行,maven这插件也太强了把,记录一下; 自动添加(老师教的绝活传授给大家) 右击maven项目--->Maven--->Add Plugin---->如图 pom.xml里边就有了这些配置 也可以手动配一下访问端口 ...
  • idea实现eclipse多项目依赖存放于同一个工作空间下,tortoise svn配置,tomcat启动配置成功,实现svn代码提交更新,打jar包和war包
  • Intelij导入maven项目并部署到tomcat emmmm我觉着最最有用的不是导入,,是部署tomcat 最后两步最最最重要,导入项目后一定要点击desploy在target目录下生成一个war包,,不然会出死亡404 1.导入一个maven项目 (1)...
  • idea+maven+tomcat 项目部署 (详细)

    千次阅读 2019-10-19 01:09:39
    Maven 学习目标: 能够了解Maven的作用(了解) 能够理解Maven仓库的作用(了解) 能够理解Maven的坐标概念(了解) 能够掌握Maven的安装(掌握) 能够掌握IDEA配置本地Maven(掌握) ...能够掌握依赖引入的...
  • 原因&解决办法 1、路径错误问题 maven安装路径、setting....tomcat的配置一定要在plugins标签里面 4、骨架创建问题 如果是骨架创建maven并且有pluginManagement标签,将其删除即可 以上就是idea解决tomca.
  • 把local repository路径下内容全部删除,重新导入maven 问题2 pom.xml中 <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>...
  • Maven 整合 Tomcat

    2020-04-10 21:01:50
    Maven 整合 Tomcat。 我们在日常开发 WEB 中,一般会用到 Tomcat WEB 容器。使用前要做大量配置。...我们只需要在项目的 pom.xml 中导入 Tomcat 插件的坐标即可。 <build> <pluginManagement> ...
  • 面试题--maventomcat

    2021-11-05 11:44:06
    面试题--maventomcatMaven1、什么是maven?2、maven能为我们解决什么问题?3、说说maven有什么优缺点?5、什么是Maven的坐标?6、讲一下maven的生命周期7、说说你熟悉哪些maven命令?8、如何解决依赖传递引起的...
  • IDEA 导入使用maven导入web、jsp及设置Tomcat中文编码
  • 博主今天新建一个maven的module,想要访问网页,按照在pom池中加入插件的方法 但是,我的本地插件包里没有tomcat,于是我找到这个插件,需要先下载这个插件! 具体方法: 在你的项目的module的pom池中加入 <...
  • IDEA使用Maven集成Tomcat插件运行项目

    千次阅读 2020-05-31 16:55:26
    Maven Tomcat插件现在主要有两个版本,tomcat-maven-plugin和tomcat7-maven-plugin,使用方式基本相同。...一、Maven引入依赖: <build> <plugins> <plugin> <groupId>org.apache.tomcat.ma
  • 一,下载tomcat源码,选择tomcat-8.5.55版本 ...2.3 在tomcat源码的解压包下创建home目录,把源码中的con目录和logs目录剪切到其中(其他新建的目录如图),另外新建maven的pom.xml文件。 po...
  • 如何在IDEA中用maven启动Tomcat

    千次阅读 2020-07-26 15:21:08
    如何在IDEA中用maven启动Tomcat 对于自学党来说,maven的配置很是复杂,并且网上没有很完整的配置文章,导致大家在配置时出现了很多错误,浪费了不少时间,所以我写了一篇文章来教学,如何在IDEA中用maven启动tomcat...
  • 1.最初在tomcat上部署web应用的方式,是通过mavenmaven-compiler-plugin插件先打成war包,再将war包复制到tomcat的webapps目录下。 2.后来用上了tomcat7-maven-plugin插件,可以直接在maven上编译,打包,部署一...
  • IDEA中在maven项目中添加tomcat插件

    万次阅读 2019-08-10 13:07:01
    IDEA中在maven项目中添加tomcat插件 ...再在pom.xml文件中添加tomcat插件,注意导入依赖的位置是在< plugins>< /plugins>标签中 <!-- 加入tomcat插件--> <plugin> <...
  • 主要介绍了在IDEA中将Echarts引入web两种方式(使用js文件和maven依赖导入),本文通过图文并茂的形式给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • 文章目录IDEA配置Maven+Tomcat构建Web项目配置conf目录下的settings文件使用Maven...Maven是一个项目架构管理工具( Maven主要服务于基于Java平台的项目构建,依赖管理和项目信息管理),可以通过一小段描述信息来管理
  • 第一个还好,基本上都是通过.sh文件来看的,但第二个如果直接通过文本打开java文件就有点痛苦了,可能小伙伴看的时候就在想,要是能在idea中打开tomcat源码学习多好,今天我们就一起把tomcat源码导入到idea中。...
  • maven自动部署到tomcat9

    2022-04-06 11:51:20
    1.maven的自动部署功能可以很方便的将maven工程自动部署到远程tomcat服务器 第一步:配置 Tomcat 访问权限 首先,我们需要先打开 Tomcat 的 manager 功能,找到 conf 文件夹下的 tomcat-users.xml文件中的 <...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,150
精华内容 11,660
关键字:

maven导入tomcat依赖