黑马程序员技术交流社区

标题: 【厦门JavaEE就业1期-每日总结】Maven [打印本页]

作者: 厦门校区 时间: 2018-7-28 17:02
标题: 【厦门JavaEE就业1期-每日总结】Maven
同学们，今天我们学习了一个新的概念--Maven，可以把它理解为jar包管理工具，Maven在开发中普遍使用，但使用并不是很难。大家在今天的学习过程中需要掌握的有：

完成Maven环境搭建
能够分清几种仓库的区别
熟练掌握常见命令
能够用Maven完成ssh项目的搭建
了解聚合和继承的区别

请同学们按照如上要求，总结你对Maven的理解

作者: Yanmo_ 时间: 2018-7-28 19:11
颜琳琳

maven是项目管理工具,管理java文件
maven配置:
1）本地仓库的配置
将maven解压后在maven的安装目录中的conf下的setting.xml中的配置本地仓库的安装路径
2）环境配置
MAVEN_HOME:I:\Maven\apache-maven-3.5.4
M2_HOME: I:\Maven\apache-maven-3.5.4
PATH: %MAVEN_HOME%\bin

dependencyManagement 管理依赖,代表谁用谁加载此依赖
dependencies 添加依赖标签

常见命令：
clean:清理tager文件夹
complie:编译源代码
install:安装到本地仓库
pakage:打包编译好的代码为jar或war

maven创建ssh工程：
1.通过创建maven项目创建war工程
2.添加ssh依赖
3.ssh工程搭建（1.创建包类ssh框架的配置 2.创建实体类 3.编写每个类的功能）
4.定义变量（定义变量是在依赖添加中相同的进行提取到一个属性标签，通过el表达式引用这个变量的值，这样做的好处是版本一旦改变，直接修改属性标签的值）
5.打包war包
创建maven工程时选pom，是以一个pom形式出现，pom代表聚合，底层有多个模块工程组成聚合，有聚合出现继承也一定会出现。
maven的聚合和继承：
创建maven工程时选pom，是以一个pom形式出现，pom代表聚合，底层有多个模块工程组成聚合，有聚合出现继承也一定会出现。
聚合和继承的区别：
聚合是多个模块工程聚合在一起，而继承则是某个模块工程要继承另一个模块的功能

作者: wahahaha 时间: 2018-7-28 19:41
maven：主要是方便我们去管理jar包的工具。
maven仓库：私服、中央仓库、本地仓库。
maven工程有3种：jar、pom、war。分别对应的是java项目、聚合项目、web项目。
修改项目编译版本：
1）build path
2）修改maven-compiler-plugin，并配置为1.7版本
生命周期：
clean compile install package
pom.xml依赖中相同的version可以抽取出来定义变量
聚合和继承是相辅相成的。通常情况下不会分开使用。

作者: doudou0606 时间: 2018-7-28 20:21
施炎生
Maven有两个重点：
1、创建SSH2工程
Maven工程类型：pom（聚合项目）、jar、war（web模块）
2、构建多模块的Maven工程

Maven是什么呢？
Maven 是一个项目管理工具，用来管理java项目。用maven构建项目，文件大小会大大压缩。Maven管理项目生命周期过程都是基于插件完成的

Maven常用命令：
Clean编译、
compile清理，将target 下的class文件清理、
install安装命令，将工程的jar发布到本地仓库、
package将java工程打成jar、war、
tomcat7：run（tomcat：run）运行项目

定义依赖jar包版本变量：
将以下标签配置到pom.xml中，在引入的依赖中把版本改为
<version>${hibernate.version}</version>
这样以后要改框架版本，直接修改property标签即可。
<properties>
<hinernate.version>5.0.7.Final</hinernate.version> <spring.version>4.2.4.RELEASE</spring.version> <struts.version>2.3.24</struts.version>
</properties>

在开发中，通常会把一个项目分成多个模块来写，而写完之后如何能作为一个项目来运行呢？就需要用到聚合。
当多个模块中需要用Junit，这时每个模块中都需要去导入依赖，可以把这个重复性工作提高父项目，这时模块就可以继承父项目内的Junit。
聚合和模块通常是一起出现的，也有特殊情况，聚合内的子模块未必和父模块是继承关系。

作者: 六道的骸6 时间: 2018-7-28 20:47
张裕
项目对象模型(POM)，可以通过一小段描述信息来管理项目的构建，报告和文档的软件项目管理工具。
Maven仓库: 存放依赖和插件的空间
中央仓库 : maven在安装的时候，自带的仓库由maven团队维护
本地仓库: maven的本地仓库，在安装maven后并不会创建，它是在第一次执行maven命令的时候才被创建
存储在本机中如果仓库中不存在所需的依赖会从中央仓库中下载并存储
私服: 私服是一种特殊的远程仓库，它是架设在局域网内的仓库服务，私服代理广域网上的远程仓库，供局域网内的 Maven用户使用。

Maven常用命令
compile：编译项目源码生成class文件
clean：将 target 下的 class 文件清空
test：执行单元测试类，执行 src/test/java 下的类
package ：将 java 工程打成 jar、war。
install：安装命令，将工程中的 jar包发布到本地仓库

坐标: 由groupId 组id artifactId 项目唯一标识符 version 版本号组成类似于一个地址指向某个点
聚合: 也可称为多模块是为了能够使用一条命令就构造多个模块
继承: 在父POM中的pom.xml配置的坐标在子类中可以继承使用减少了代码的重复

作者: 13163997058 时间: 2018-7-28 20:50
王刘锁

maven环境搭建-下载解压后配置环境变量MAVEN_HOME = maven的路径 M2_HOME = 路径
在解压后的文件夹中找到conf文件夹下的settings.xml在文件中设置本地仓库<localRepository>仓库路径</localRepository>
在eclipse中配置maven--window下的preference下installations中add添加maven解压路径然后user setting中选择maven中conf下的settings.xml,点击update setting 点击reindex点击apply点击ok
show view中找到maven下的repositories--ok--在窗口中右键第一个目录,rebulid index --完成就可以建项目了
建ssh项目注意web.xml和相关的配置文件,还有ssh相关jar包依赖要导入
本地仓库是在自己电脑上创建的仓库,远程仓库(中央仓库)是网络上的,中央仓库是阿帕奇组织的仅有一个,私服是自己公司创建的远程仓库用来自己内部使用
常用命令:clean--清除项目在maven中的class文件 compile--编译项目到maven install--发布项目 package--打包项目
聚合就是一个父级项目来管理一群子级项目,继承是和聚合同时存在的,是子级项目具有父级项目的一些配置和依赖

作者: q55w66 时间: 2018-7-28 20:57
Maven
概述
apache的开源项目，是项目管理工具，用于管理java项目
组成
项目对象模型(Project Object Model)
每个maven工程中都有一个pom.xml文件，用于定义工程所依赖的jar包、本工程的坐标、打包运行方式
依赖管理系统
maven通过坐标对项目工程所依赖的jar包统一规范管理
maven定义了一套项目生命周期
清理
初始化
编译
测试
报告
打包
部署
站点生成
一组标准集合
强调：maven工程有自己标准的工程目标结构、定义坐标有标准
maven管理项目生命周期过程都是基于插件完成的
仓库
中央仓库
远程仓库，仓库中的jar由maven团队统一维护
http://repo1.maven.org/maven2/
本地仓库
相当于缓存，工程第一次会从远程仓库下载jar包，将jar包存在本地仓库
私服
环境搭建
到maven官网下载http://maven.apache.org/download.cgi
配置本地仓库
找到apache-maven-3.3.9\conf\settings.xml
在<settings>标签下配置本地仓库所在路径
<localRepository>D:\develop\maven_local_repository</localRepository>
eclipse配置maven
配置maven安装目录
【Window】-【Preferences】-【Maven】-【Installations】
【Add...】,在Installation home配置maven路径即可
配置User Settings
【Window】-【Preferences】-【Maven】-【User Settings】
在User Settings配置apache-maven-3.3.9\conf\settings.xml
依次点击Update Settings-Reindex-Apply
重建本地仓库索引
【Window】-【Show View】-【Other...】-【Maven】-【Maven Repositories】
【Local Repositories】-【Local Repository(...)】，右键，Rebuild Index
设置编译版本
【右键】-【Maven】-【Add Plugin】
搜索compiler，选择版本，并作一定补充后，Update Project...
————————————————————————————
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-compiler-plugin</artifactId>
  <version>2.3.2</version>
  <configuration>
<source>1.8</source>
<target>1.8</target>
  </configuration>
</plugin>
配置环境变量
变量名：MAVEN_HOME
变量值：Maven根目录路径
变量名：PATH
变量值：%MAVEN_HOME%\bin
变量名：M2_HOME
变量值：Maven根目录路径
项目生命周期
分类
clean清理项目
pre-clean
clean
post-clean
default构建项目（核心）
...
validate
initialize
generate-sources
process-sources
generate-resources
process-resources
compile编译源代码
...
process-classes
generate-test-sources
process-test-sources
generate-test-resources
process-test-resources
test-compile
process-test-classes
test单元测试运行测试代码
...
prepare-package
package将编译好的代码打包
...
pre-integration-test
integration-test
post-integration-test
verify
install安装到本地Maven库
...
deploy
site生成项目站点
pre-site
site
post-site
site-deploy
注意：三套生命周期相互独立，后面的阶段依赖于前面的阶段
常见命令
compile编译(生成target目录并存放编译好的class文件)
clean清理(清理target目录下的class文件)
test执行单元测试类
package打包
install将工程的jar发布到本地仓库

作者: chenyelong 时间: 2018-7-28 21:02
陈叶隆
工程目录结构说明：
project
/src/main/java    主体程序 java源文件（不要放配置文件）
/src/main/resources  主体程序所需要的配置文件（不要放java文件）
/src/test/java    单元测试程序 java源文件
/src/test/resources 单元测试程序所用的配置文件
/target          编译输出目录
pom.xml       Maven进行工作的主要配置文件。

常用命令如下：
compile：编译
clean：清理，将target下的class文件清理
test：执行单元测试类，执行src/test/java下的类
package ：将java工程打成jar、war。
install：安装命令，将将程的jar发布到本地仓库
发布到仓库，目录按照本工程定义的坐标生成目录

在pom.xml中添加servlet-api
因为我们创建的是war工程 ,需要response 和request 等对象，而这些对象是在servlet-api中的，所以我们需要添加servlet-api ,才能保证工程正常编译。
注意：必须指定scope为provided

目录名称：为了方便的快速定位内容，模块所处的目录应当与其artifactId一致(Maven约定而不是硬性要求)，总之，模块所处的目录必须和<module>模块所处的目录</module>相一致

聚合模块减少的内容：聚合模块的内容仅仅是一个pom.xml文件，它不包含src/main/Java、src/test/java等目录，因为它只是用来帮助其它模块构建的工具，本身并没有实质的内容

作者: LittleSky 时间: 2018-7-28 21:20
常小天
Maven是一个项目管理工具。它具有自己标准的工程目录结构和定义坐标的标准。通过pom.xml，根据坐标对jar包和项目进行统一规范的管理。Maven的坐标包括三部分：一是组id，一般为项目名称；二是模块id，为子项目名称；三是版本，分为snapshot（快照版，没有正式发行）和release（正式发行版本）。Maven的jar包实体保存在仓库中，在项目中通过坐标引用。在本机中的仓库叫本地仓库，项目中使用jar包时先到本地仓库中找，如果有就直接引用。如果没有，就去网络上的远程仓库中下载并保存到本地仓库中，以供项目使用。这样的远程仓库分为两种。一种是由Maven团队自己维护的仓库，叫中央仓库。另一种是企业或个人自行搭建一个私服作为仓库对外开放提供下载，这种就叫做私服。使用Maven，我们首先要上网下载Maven的压缩包。下载完成后解压，创建（拷贝）好本地仓库后，需要在Maven的配置文件settings.xml中配置本地仓库的路径。而我们要在Eclipse中使用Maven，还需要在首选项中配置Maven和settings的目录。之后还需要重建本地仓库索引，就算完成了Maven的准备工作。接下来我们就可以在Eclipse中创建Maven工程了。

作者: rkko 时间: 2018-7-28 21:25
杜石苇
完成Maven环境搭建

设置环境变量maven_home和M2_home

能够分清几种仓库的区别
中央仓库由maven团队管理  可以由配置文件下载相应的依赖和插件
本地仓库是已经由中央仓库下载来的依赖和插件  无需联网可以使用
私服是其他公司架设的线上仓库  可以公开也可以不公开

熟练掌握常见命令
compile：编译
clean：清理，将target下的class文件清理
test：执行单元测试类，执行src/test/java下的类 @test注解  或者  使用springframework提供的单元测试

新建测试类，并在该类上加上两个注解：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath*:ApplicationContext.xml"})
package ：将java工程打成jar、war。
install：安装命令，将将程的jar发布到本地仓库

能够用Maven完成ssh项目的搭建
1 首先创建Maven war工程
2 添加SSH依赖和MYSQL依赖
3 添加spring配置文件和struts配置文件和修改web.xml配置文件
4 编写Java代码实体类映射业务层 dao层  web层 action

了解聚合和继承的区别

聚合的话是module  用IDEA可以很好的理解  IDEA创建一个工程后  new下面可以创建module  这样就是这个工程下的一个模块  多个模块不同功能可以聚合成一个项目

继承的话某个模块要继承某个模块的功能

作者: hpb199567 时间: 2018-7-28 21:26
何平波
Maven
  今天学习了Maven,Maven是一个强大的项目管理工具,为什么使用Maven呢?原本普通的动态web项目需要导入很多jar包,
形成了项目的体积大小一般都是挺大的,而Maven改变了这一个缺点,将项目工程所需要的jar包通过本地仓库,远程中央仓库,
私服的形式将jar包通过xml文件注入加载(管理jar包,把jar包从工程分离),从而减少了项目的体积大小,Maven也可以添加插件,
像tomcat服务器也可以通过xml注入加载的形式获取.
  如何搭建Maven环境呢?
1.下载Maven  www.maven.apache.org
2.配置Mavan环境变量 MAVEN_HOME  M2_HOME
3.配置仓库(联网远程仓库,不能联网本地仓库)
4.Repository 本地仓库(这个文件就是本地仓库,包含工程所需jar包)
5.eclipse配置maven Prefernce>>>Maven>>>Installaction>>>add>>>directory>>>Maven安装路径
6.eclipse配置settings.xml文件查找本地仓库 Maven>>>UserSettings>>>UserSerttings>>>Maven本地仓库sessting.xml获取到本地仓库的路径
7.重建本地仓库的索引 MaVEN repositoris>>>rebuild index
8.创建Maven工程 MavenObject>>>Group id(工程名)>>>Artifact(工程名+)>>>Version(版本号)>>>Packaging(打包方式)
9.MavenModule >>>创建Maven子工程模块
10. add Plugin  添加插件 add dependency  注入依赖的jar包

注意:Maven web 工程需要区分java文件和配置文件的放置路径
1.java resourece/src/mian/java  存放的是java源码文件
2.java resourece/src/main/resources  存放的是xml配置文件和hibernate的bean类映射文件
3.一般来说新建maven的web工程都会报错,原因是缺少web.xml文件,暂且手动将web.xml存放在src/main/webapp/WEB-INF下

作者: wpwing 时间: 2018-7-28 21:29
完成Maven环境搭建
搭建比较简单,将官网下载下来的zip包解压到要自己指定的目录;环境变量里面进行设置;
变量名:MAVEN_HOME
变量值:解压后的maven所在路径

变量名:M2_HOME
变量值:跟MAVEN_HOME相同路径

变量PATH添加一句:%MAVEN_HOME%\bin;

然后可以在命令行下使用 mvn -version进行检验,当显示出版本号即搭建成功;
------------------------------------------------
能够分清几种仓库的区别
分为中央仓库,本地仓库,私服三种
中央仓库:由maven组织管理的仓库,为maven默认的统一仓库;

本地仓库:将本地的集合了jar包的文件夹作为maven配置时获取jar包的仓库,优点就是可以断网使用;

私服:将局域网内的一台服务器作为仓库,当公司里面有自己构建的框架时,使用这个来进行全部员工的maven的jar包配置,
比本地仓库的效率高,

---------------------------------------------------------------------------

熟练掌握常见命令
clean:清除maven下该项目所有编译好的文件;
complie:编译该项目;
package:将项目打包,方便进行发布;
install:将该项目安装到maven仓库里,当我们在ide工具里面用写好一个maven的项目是,该项目是存在在该ide工具的工作空间,
只用通过install命令,才能将其配置到仓库中;
tomcat:run 使用默认的tomcat(6)运行装载该项目发布;
toncat7:run 使用后面配置的tomcat7装载该项目;
-----------------------------------------------------------------------------

能够用Maven完成ssh项目的搭建
1 导入ssh相关的jar包
2 三个配置文件struts.xml,类名.hmb.xml,web.xml
了解聚合和继承的区别
聚合:若干子模块项目包含在一个父项目里,夫项目为POM,子模块为jar;
继承:子项目继承一个父项目,继承了父项目的特性,都为POM;

作者: 许大炮 时间: 2018-7-28 21:33
许剑鸿 mavenDay01

一.maven环境变量配置
MAVEN_HOME D:\apache-maven-3.3.9
PATH %MAVEN_HOME%\bin
在cmd 下输入mvn -v 有信息输出表示maven配置正常

本地仓库配置
获取本地仓库存至硬盘某处
打开maven的安装目录中conf/ settings.xml文件，在这里配置本地仓库： <localRepository>D:\repository_ssh</localRepository>
这里的意思是配置本地仓库的目录为D:\repository_ssh

eclipse配置maven
打开eclipse,选择菜单windows-Preferences---输入maven--->Installations--add---浏览本地文件选择maven安装目录--apply
配置User Settings
打开eclipse,选择菜单windows-Preferences---输入maven-->User Settings-->选择maven陆慕下conf下的settings.xml -->Update Settings-->Reindex-->apply

重建本地仓库索引
打开eclipse--window--show view --maven--maven repositories --->点开 local repositories-->右键Local Rspository--点击Rebuild Index

二.Maven仓库
1、中央仓库
就是远程仓库，仓库中jar由专业团队（maven团队）统一维护。
中央仓库的地址：http://repo1.maven.org/maven2/
2、本地仓库
相当于缓存，工程第一次会从远程仓库（互联网）去下载jar 包，将jar包存
在本地仓库（在程序员的电脑上）。第二次不需要从远程仓库去下载。先从本地
仓库找，如果找不到才会去远程仓库找。
3、私服
在公司内部架设一台私服，其它公司架设一台仓库，对外公开

三.常用命令
compile:编译
clean:清理,将targer下的class文件清理
test:执行单元测试类,执行src/test/java下的类
package:将java工程打包成jar或war
install:安装命令,将工程的jar发布到本地仓库,目录按照本工程定义的坐标生成目录

四.聚合和继承

聚合:就是把多个模块或项目聚合到一起，我们可以建立一个专门负责聚合工作的Maven 工程。

继承:我们在项目开发的过程中，可能多个模块独立开发，但是多个模块可能依赖
相同的元素，比如说每个模块都需要Junit，使用spring的时候，其核心jar也必
须都被引入，在编译的时候，maven-compiler-plugin 插件也要被引入。这时我们
采用继承，就不用在每个子模块分别定义了。(理解成类与类之间继承就行了)
聚合和继承通常是结合使用的，但是其作用是不同的。聚合是将多个模块的
工程汇聚到一起，而继承则是指明某个模块工程要继承另一个模块功能。

作者: 滴滴eclipse启动 时间: 2018-7-28 21:37
江某人:
今天学习安装了Maven,了解了Maven的工程目录,配置连接,添加依赖
知道了 clean的作用是:清理Maven中的jar  war 之类的
            compile的作用是:编译
            install的作用是:将工程发布到本地仓库
知道了在Maven中配置ssh的配置
了解了Maven的聚合和继承

作者: 黄兴磊 时间: 2018-7-28 21:43
Maven就是apache下的开源项目，项目管理工具，管理java项目,Maven有三个仓库,本地仓库,中央仓库,私服,我们的jar一般都再本地仓库中去配置查找,如果没有,就去中央仓库,前提访问中央仓库要联网,本地仓库就相当于缓存,下载到了自己的电脑中.

2配置本地仓库在apache-maven-3.3.9\conf下的settings.xml文件中
<localRepository>写本地仓库的位置 </localRepository>中去配置

3 clean 是清理,清除class文件和jar包
   Complie 是编译文件
   Package 是将编译好了的打包成jar ,war,ear 等
   Tomcat7:run  是运行tomcat

作者: sts 时间: 2018-7-28 21:46
suhaibin
今天刚接触maven,maven作为一种管理工具,有助于项目工程开发的统一规范
在看视频的时候觉得环境搭建和使用挺简单的,但在实践的时候还是会忽略一些细节导致出现问题
maven的仓库分三种:中央仓库,本地仓库和私服
目前阶段下在不联网的时候主要使用本地仓库
maven的常用命令有:compile编译clean清理package打包install安装tomcat7:run等
聚合不等于继承,但他们通常结合使用,相辅相成,聚合是将多个模块的工程汇聚到一起,而继承则是指某个模块工程要继承另一个模块功能

作者: 小故事 时间: 2018-7-28 21:46
谢洪彬:
maven(一):
概述:项目管理工具,相比以前的java项目或者web动态项目相对而言体积容量非常小,在实际开发中使用maven来管理项目不需要导入jar包,只需要引入相应的依赖即可.而实际的jar包则是存在于maven仓库中.
maven仓库的分类:
1.中央仓库 -->由maven专业团队来管理
2.本地仓库 -->本机电脑的意思
3.私服 -->公司自己搭设的

Maven创建项目的三种格式:
Jar:资源形式存在,无需服务器(例:可以用于管理实体类)
war需要服务器,运行起来的工程
pom:顶级工程,聚合项目

maven的快速入门
1.在使用maven时还需要在电脑的系统中配置环境变量:
1. 变量名:MAVEN_HOME
1.1 变量值:maven文件的路径
2. 变量名:M2_HOME
2.1. 变量值:maven文件的路径
如果在启动tomcat时,控制台没有信息提示,则需要在
perferences-->java-->Installed JREs中的jdk修改Default_vm属性中添加这样一段代码:
-Dmaven.multiModuleProjectDirectory=$M2_HOME
2.perferences-->maven-->installations添加maven
3..在maven文件中的conf下的settings.xml配置本地仓库路径
4.perferences-->maven-->user settings中引入settings.xml文件的路径
5.在控制台找到maven Repositories下的localRepositories下的localRepository右键Rebuild index一下,重建索引,这样你就可以看到本地仓库中的所有jar包了
在maven中很多功能都是基于插件的,当我们需要引入插件或者依赖时,可以在pom.xml文件中引入
add Plugin --->引入插件
add Dependency -->引入依赖

Maven常用的命令:
clear:清空工作空间中的编译文件
compiler:编译代码
package:打包项目
tomcat:run 启动tomcat服务(默认Maven本地的tomcat)
tomcat7:run启动你自己配置的tomcat版本
聚合和继承:
集合和继承是相辅相成的,可以这么说有聚合必有继承
聚合:管理很多个项目工程,顶层工程
继承:和java中很相识,父类有的东西之类可以直接拿过来用.
关系的表现可以在相应的pom.xml文件中查看.

作者: 渣.. 时间: 2018-7-28 21:48
柯威龙

今天学习了maven . 这是一个专门用于构建和管理java项目的工具.maven比action或web的动态项目整体文件相比的话
项目规格较小.因为使用了一个叫做pom.xml用于维护项目使用的jar包.maven有中央仓库和本地仓库.中央仓库\
就是远程仓库,本地仓库相当于缓存.工程从第一次从远程仓库下载将jar包
存在本地仓库.接下去就不需要从远程仓库去进行下载,除非说本地仓库没有.
还有一个私服.一般私服就是公司内部进行架设.电脑叫做仓库.
还要记住maven通过命令对工程进行清理,编译,测试,打包,部署的一些常见
的命令例如: compile 编译 clean 清理 test 执行单元测试
package将java工程达成jar,war install 安装命令,将工程的jar发布到本地仓库
主要学习的搭建SSH继承框架工程mavenweb.

作者: 咸鱼coder 时间: 2018-7-28 21:50
万冕

maven

首先,maven是一个项目管理工具,拿来管理java项目的,里面的核心配置文件pom.xml
pom(项目对象模型)

pom.xml里面可以定义工程里所要依赖的jar包,工程的坐标(Group id,Artifact ID,version)

maven仓库分为中央仓库,是maven团队维护的仓库
本地仓库是相当于缓存,将jar包直接存在本地文件夹里,需要jar包时,会先从本地仓库查找,找不到会去中央仓库寻找

私服就是公司里自己独立开发的一个私服仓库

配置本地仓库<localRepository>D:\repository_ssh</localRepository>
配置-Dmaven.multiModuleProjectDirectory=$M2_HOME 运行时才不会报错

maven常用的命令
compile 编译
clean 清理
package 将java工程打包成jar或者war
install 安装命令,将工程jar发布到本地仓库

聚合就是将一些多个模块集合在一起组成一个新的项目
继承就是和以前一样还是可以直接拥有父类的依赖之类的东西

作者: 厦门陈强 时间: 2018-7-28 21:55
陈强
Maven的一天;
对于lib的引入,其实就是采用配置文件的形式进行引入,也就是<dependency>标签,可以称为依赖更专业.那么jar包都是从哪里引入呢,是从一个叫仓库的地方引入的,仓库中存放着我们工程所需要的那些jar包.
Maven就是一个工程的管理工具,管理的就是工程中的那些jar包.
Pom.xml(项目对象模型)是用于管理工程依赖的jar包的引入的一个配置文件.
Maven的环境变量配置:
---MAVEN_HOME:当前maven的路径
---M2_HOME:当前maven的路径
---PATH:% 当前maven的路径%bin
Maven仓库的配置(本地仓库):
---就是对settings.xml进行配置即可—(当前本地的仓库路径)
---对<localRepository>标签进行修改
---maven仓库的类型:
---中央仓库:使用中央仓库的话,要保证电脑是可以联网的.
---本地仓库:本地电脑的一个存放各种jar包的文件夹,相当于中央仓库,起的是缓存的作用
---私服:中央仓库也算是一种私服,只不过是唯一的私服
---引入的jar包在仓库中的地址,称为坐标.而坐标包含了ID和版本
在eclipse中配置maven:
Maven---installations---add(选择本地的路径)---勾选新添加的maven---User settings---关联maven中的settings.xml的配置文件即可---OK!!!
配置完成之后,建议对仓库的索引进行重建---rebuild index
工程的类型分为pom \ jar \ war----简单区别就是打包的方式不同
Pom类型的工程一般是存在于聚合工程中,而且是作为子类工程的一个依赖,所以在一个工程中一般只会有一个pom,而且一般都是父类(顶层工程)!!
Maven的三板斧!!!!---clean \ compile \ install
Install会将当前java的工程安装到仓库中,而我们运行的也是仓库中的工程为准,如果代码编写完成后没有install到仓库中,运行时就会有异常产生!!!
配置文件中可以对编译版本和依赖进行添加,maven –addplugin \ add dependency
关于maven的常用命令:
---clean:清理---将target下的class文件给清理掉
===清除.class文件的时候,也会将生成的jar文件也清理
---compile:编译,生成.class文件,并存放在target文件夹下
---package:将java工程打包成jar类型或者war类型的文件
===注意!!!执行package打包命令的时候,会自动编译java工程!!
---install:将本地的工程安装到本地的仓库中
使用maven进行SSH工程的搭建:
---添加框架所需的依赖
---建包结构
---配置文件的copy,并根据实际的环境进行修改
对于配置pom.xml的时候,依赖配置的时候,关于版本号的信息会出现很多的重复,所以可以将这些重复的版本号提取出来,进行重新的定义为一个标签,之后版本一样的就直接进行一个引用就可以了.如下:
---<properties>
<spring.version>4.2.4.RELEASE</spring.version>
</ properties >
这样子的抽取主要是针对SSH三个框架中的依赖.
聚合:就是将多个模块或者项目聚合在一起,简单的理解就是用一个maven工程管理了多个maven工程,而对于多个maven工程,我们称之为模块.
在创建的时候,对于顶层工程也就是父工程,选择的是maven project,而在创建下级工程的时候,选择的是maven module,这个时候会选择父工程也就是顶层工程是哪一个.
在父工程中的pom.xml中,会包含子模块中的信息.
继承:父子结构的project,在父工程的添加了依赖之后,子工程就相当于同时也有了这个依赖.
关于继承与聚合之间的区别:
---聚合一般是多模块开发的时候会使用到,就是将多个模块聚合到一起,方便管理和操作
---继承一般是同样要使用到的配置文件会放在父工程中,子类就继承了父类的配置,无需多次的进行导入.
---聚合关系看父工程中的pom.xml,继承关系看子工程中的pom.xml
---一般有聚合关系就会有继承关系,而有继承关系不一定会有聚合关系

作者: 5119 时间: 2018-7-28 21:56
总结
Maven是apache下的开源项目,是用来管理项目的一个工具,
1.POM(项目对象模型) 每个maven工程中都有一个pom.xml文件,定义工程所依赖jar包,本工程的坐标,打包运行方式.
2.依赖管理系统:maven通过坐标对项目工程所依赖的jar包统一管理.
3.maven有一套项目生命周期
清理、初始化、编译、测试、报告、打包、部署、站点生成
4.maven工程有自己的标准工程目录,定位坐标标准
5.maven生命周期过程都是基于插件完成的

Maven的仓库
1. 中央仓库(世界上一个中央仓库用maven团队管理)
2. 本地仓库(相当于缓存，工程第一次会从远程仓库（互联网）去下载 jar 包，将 jar 包存在本地仓库（在程序员的电脑上）)
3. 私服(在公司内部架设一台私服，其它公司架设一台仓库，对外公开。)

创建maven工程
1. 创建maven priject工程
2. Eclipse不用设置骨架,所以就把第一个勾勾,勾上
3. Group Id：项目的名称，项目名称以域名的倒序，比如：cn.itcast.mavendemo
Artifact Id：模块名称（子项目名称）
Version：模块的版本，snapshot（快照版，没有正式发行）、release（正式发行版本）
Packaging: 里面有jar war pom  代表的是文件的类型 jar就是jar文件 war就是tom文件

设置编译
1. 我们要把编译版本改为jdk1.7
<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>
    </configuration>
    </plugin>
    </plugins
  </build>
</project>

添加依赖
1. 右键---->add Dependency
2. 在框框中输入想要的jar包

常见的命令
complie  编译
clean    清理
package 将java工程打成jar  war包
install    安装命令
tomcat-run    Tomcat运行
tomacat7-run Tomcat7运行

聚合，顾名思义，就是把多个模块或项目聚合到一起，我们可以建立一个专门负责聚合工作的 Maven 工程。
继承,子类继承了父类就继承了父类里的所有pom.xml中的jar包定位

区别: 聚合和继承通常是结合使用的，但是其作用是不同的。聚合是将多个模块的工程汇聚到一起，而继承则是指明某个模块工程要继承另一个模块功能

作者: 李思贤126 时间: 2018-7-28 21:57
李思贤:今天学习了maven,是一个项目管理工具,管理java项目.
中央仓库  本地仓库  私服

1本地仓库配置
仓库拷贝到本地中,要在maven的安装目录中conf/settings.xml文件中
配置本地仓库:<localRepository>D:.....\.......</localRepository>

2eclipse配置Maven
Windows-prrferences中找到maven下的Installations
Add 选择maven安装目录

配置User Settings
Windows-prrferences中找到maven下的User Setting
找到settings.xml Apply

3重建本地仓库索引
去Window-->show View先让Maven Repositories显示出来
在Local Repositories 重建索引

4坐标
Maven对所有工程管理是基于坐标
坐标包括:
Group Id:项目名(com.itheima)
Artifact Id:模块名(子项目名称)
Version  :模块版本,snapshot(快照版:未正式发行)
   Release(正式发行版本)

目录:注意java文件和配置文件分开放;
重要文件:pom.xml(Maven进行工作的主要配置文件)

5Maven默认用JDK1.5 需要改为1.7
我们点击项目右键找到Maven中的add plugIn找到org.apache.maven.plugins.
OK后在pom.xml 2.3.2下面补充
<configuration>
    <source>1.7</source>
    <target>1.7</target>
    </configuration>
后右键工程 Uodate Project 即可更改到JDK1.7

5添加依赖
也是右键工程Maven -->add dependency

6Maven的几种常见命令
右键工程,Run-->Maven Build

Compile:编译
Clean:清理
Test:执行单元测试类
Package:打包
Install:安装命令,将工程的包发布到本地仓库

6创建war工程
创建完成后需要手动添加web.xml
在webapp下手动建WEB-INF目录
拷进去一个web.xml

添加插件进pom.xml
去资料中copy
因为是war工程,所以需要response和request,所以
需要在pom.xml配置Servlet-api

7聚合与继承
聚合和继承通常结合使用,但其作用是不同的.聚合是将多个模块的工程汇聚到一起
,继承则是指明某个模块工程要继承另一个模块功能.

作者: 张述明 时间: 2018-7-28 21:58
张述明
总结
Maven是一个项目管理项目,它包含了一个项目对象模型 (Project Object Model)，一组标准集合，一个项目生命周期，一个依赖管理系统和用来运行定义在生命周期阶段(phase)中插件目的逻辑。当你使用Maven的时候，你用一个明确定义的项目对象模型来描述你的项目，然后Maven可以应用横切的逻辑，这些逻辑来自一组共享的（或者自定义的）插件。

配置本地仓库配置
在maven 的安装目录中conf/settings.xml文件,在这里配置本地仓库:
<localRepository>D;\repository_ssh</localRepository>

maven的环境搭建主要是eclipse配置maven
其中定义工程坐标
group id:项目的名称,项目名称与域名
ArtifactID :子项目的名称
version 模块的版本    分成  snapshot  快照版 release  正式版

设置编译版本
需要在pom.xml中配置

<build>
   <plugins>
      <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>2.3.2</version>
            <configuration>
               <source>1.7</source>
               <target>1.7</target>
            </configuration>
      </plugin>
   </plugins>
</build>
然后在updateProject  就可更改成功
添加依赖
maven 右键addDependency

项目的生命周期
1.clean
2.default
3.site周期

常见的命令
1.compile 编译
2.clean 清理
3.test  执行单元测试类
4.package  将java 工程打成jar,war
5.install:安装命令将工程的jar发布到本地仓库
我们要在命令提示符下执行maven命令必须配置下面两个环境变量
MAVEN_HOME D:\apache-maven-3.3.9
PATH          %MAVEN_HOME%\bin
maven  有三个仓库  私服  中央仓库  本地仓库

ssh的工程搭建中注意在pom.xml中相同的配置可以抽取,采用了el表达式引用三个变量

聚合和继承
聚合:　如果我们想一次构建多个项目模块，那我们就需要对多个项目模块进行聚合
继承;　继承为了消除重复，我们把很多相同的配置提取出来，例如：grouptId，version等

作者: 沅瞻 时间: 2018-7-28 22:00
詹源
maven第一天
maven:管理jar包
1.项目对象模型
△pom.xml配置文件:
↓
用dependency :添加依赖jar包
2.依赖管理系统(基础核心)
3.maven定义一套项目生命周期
maven管理项目生命周期过期都是基于插件完成的
4.一组标准集合
target:工作文件夹.放jar包.class文件等

环境变量:
   MAVEN_HOME D:\apache-maven-3.3.9
   M2_HOME    D:\apache-maven-3.3.9
   PATH:  %%

maven仓库配置(maven中央仓库,本地仓库,私服)
中央仓库.本地.私服
maven工程(聚合工程)
能够自己找到依赖
常用命令:clean,compile,install,package,tomcat:run tomcat7:run
maven工程类型 pom jar  war

仓库:
1.中央仓库(特殊的远程仓库):Maven团队统一维护.
2.本地仓库:缓存.第一次会从中央仓库下载jar包.第二次使用先从本地找,找不到去中央仓库找,找到了下载
3.私服(互联网或者局域网的远程仓库):属于远程仓库,在某公司或局域网设置的私服,其他公司设置仓库,对外公开
环境搭建

下载maven压缩包.解压

解压资料中的repository_ssh.zip

在maven安装包中conf/settings.xml文件配置本地仓库:
<localRepository>(本地仓库解压路径)</localRepository>

eclipse配置Maven.
windows-Preferences-Maven-Installations-Add-Directory(输入maven安装包路径)-Apply

配置User Settings
windows-Preferences-Maven-User Settings-第二个borwte-选择Maven目录下conf-settings.xml文件-Update Settings,Reindex和Apply

重建本地仓库索引
window-show View-Maven-Maven Repositories-Local Repositories-Local Repository-Rebuild Index

SNAPSHOT:不稳定版本
release:相对稳定

<properties  >
   <hibernate.version>...
   <spring.version>4.2.4.RELEASE
   <struts.version>...(把相同的版本号(变量)提取出来到这里.便于维护)
</properties>

聚合:
随着技术发展,软件开始采用分层构架,分模块等方式进行开发.
聚合就是多个模块或项目聚合到一起.
聚合模块本身也是一个Maven工程,负责管理聚合的工作
继承:
开发过程中,多个模块可能依赖相同元素,采用继承就免去在每个子模块重复定义.

作者: Eclipse启动 时间: 2018-7-28 22:52
郑阳阳
maven的仓库:
maven的仓库相当于一个存放maven相关文件的地方,比如依赖和项目,而我们使用的时候只需要引用就行了.
仓库分为三种:
中央仓库,由maven专业团队统一维护,使用时需要联网
本地仓库,相当于缓存,工程会先从本地找jar包,找不到会去远程仓库找.
私服,适合公司内部使用.

maven常见命令:
clean 清理上一次构建生成的文件
complie 编译所有java文件生成class文件
test 运行测试代码
package 将编译好的代码打包
install 将项目安装到本地仓库

聚合和继承的区别
聚合和继承通常一起使用,聚合指很多模块工程汇聚一起,继承指某个模块工程要继承另一个模块的功能

作者: lnongge 时间: 2018-7-28 23:01
今天主要学习了mavenMaven环境搭建,maven仓库,需要掌握常见命令,和聚合和继承的区别,只需掌握用Maven完成ssh项目的搭建即可

作者: 偏离X 时间: 2018-7-28 23:07
(一) maven
maven是一个项目管理器,用来管理java项目,
版本分快照跟正式版

(二) 仓库
Maven 仓库分中央仓库本地仓库跟私服
1、中央仓库
就是远程仓库，仓库中 jar 由专业团队（maven 团队）统一维护。
2、本地仓库
相当于缓存，工程第一次会从远程仓库（互联网）去下载 jar 包，将 jar 包存
在本地仓库。第二次不需要从远程仓库去下载。先从本地
仓库找，如果找不到才会去远程仓库找。
3、私服
在公司内部架设一台私服，其它公司架设一台仓库，对外公开。

(三) 常见命令
compile 将文件编译成.class文件
clear 将项目下的.class文件都删除
package ：将 java 工程打成 jar、war。(编译是打包的前提 ,打包之前会执行编译)
install：安装命令，将将程的 jar 发布到本地仓库
(四) 聚合跟继承
聚合和继承通常是结合使用的，但是其作用是不同的。聚合是将多个模块的
工程汇聚到一起，而继承则是指明某个模块工程要继承另一个模块功能。

作者: 偏离X 时间: 2018-7-28 23:09
郭明杰
(一) maven
maven是一个项目管理器,用来管理java项目,
版本分快照跟正式版

(二) 仓库
Maven 仓库分中央仓库本地仓库跟私服
1、中央仓库
就是远程仓库，仓库中 jar 由专业团队（maven 团队）统一维护。
2、本地仓库
相当于缓存，工程第一次会从远程仓库（互联网）去下载 jar 包，将 jar 包存
在本地仓库。第二次不需要从远程仓库去下载。先从本地
仓库找，如果找不到才会去远程仓库找。
3、私服
在公司内部架设一台私服，其它公司架设一台仓库，对外公开。

(三) 常见命令
compile 将文件编译成.class文件
clear 将项目下的.class文件都删除
package ：将 java 工程打成 jar、war。(编译是打包的前提 ,打包之前会执行编译)
install：安装命令，将将程的 jar 发布到本地仓库
聚合和继承通常是结合使用的，但是其作用是不同的。聚合是将多个模块的工程汇聚到一起，而继承则是指明某个模块工程要继承另一个模块功能。

作者: 1748341437 时间: 2018-7-28 23:12
本帖最后由 1748341437 于 2018-7-29 08:45 编辑

maven总结
林瑋
今天我们又要开始写我们很久都没写了的总结了,还是熟悉的配方,还是熟悉的味道.

今天的课程主要就讲了:maven是什么?maven如何环境搭建?如何使用maven?及最后的聚合与继承的讲解;

maven是什么呢?这个不是重点了解一下就可以了,它其实就是一个项目管理工具,用来管理java项目的.maven是通过坐标来配置jar包的.maven所有工程都是基于插件,在项目根目录中有一个pom.xml它的作用就是管理坐标依赖jar包的.
maven如何环境搭建?这个很简单,你在搭建maven环境之前,首先你得有一个maven,我们则是可以到:http://maven.apache.org/download.cgi --->这个网站里下载到maven,我们今天只是测试,所有就先用老师发的maven-3.3.9版本的;有了maven我们就要理所应当的开始我们的环境搭建了:一、我们要先进行本地仓库的配置，我们要玩maven的话本地仓库自然是必不可少的，把我们的本地仓库文件放到我们任意盘符的根目录下，然后在配置到我们maven的安装目录“apache-maven-3.3.9”下的conf/settings.xml文件的<localRepository>“本地仓库目录”</localRepository>；二、我们还要进行maven的环境变量配置，它跟我们的jdk环境变量配置一样，唯一一点不同的就是它要配置两个变量 MAVEN_HOME 和 M2_HOME 它们的配置的地址都一样，而在我们path中只能配置一个MAVEN_HOME。你问我为什么要配置两个环境变量？我也不知道呀，大概是江湖规矩吧。三、在eclipse配置maven，其实呢在eclipse中配置maven也不难，就是过程有点繁琐，还可能会出一些小差错，这些我们都是可以克服的。 1）在eclipse的导航条上选择preferences，在preferences树状导航中的maven选项中找到installation，点击右侧的add添加我们的maven的安装目录“apache-maven-3.3.9”，完了之后在左侧的表中只勾选名为“apache-maven-3.3.9”这个的选项。 2）在preferences树状导航中的maven选项中找到user Settings,在第二个文本框User Settings中找到maven安装路径,完了再点击Update Settings他会把本地仓库路径加载在下面,再点击Reindex最后点Apply应用和ok;还有最重要的一点就是创建本地仓库的索引选中window中的show View找到maven中的Maven Repositories点击生成local Repositories在其中的local Repository右键选择Rebuild Index 重新创建索引; ----这样maven的环境搭建配置就算完成了.
你想测试maven到现在到底能不能用就打开命令行(黑窗口)输入:mvn -v(或:mvn -version)
接着你就是在eclipse里随心所欲的使用maven了,可以自己试着创建一下jar项目等等...
创建项目也算比较简单,就是添加依赖要注意一下,它算较为重点的.添加依赖:在项目右键选中maven再点击Add Dependency在第4个文本框中填写关键字来显示jar包;

作者: conan75 时间: 2018-7-28 23:24
陈昆明:
maven仓库分为中央仓库,本地仓库和私服,一般来说使用本地仓库和中央仓库居多,需要注意的是本地仓库需要对setting.xml进行配置
maven常见命令:compile,build,clean,install,package,tomcat7:run
maven中的聚合与继承相辅相成,一般是一起出现的,一般来说,聚合是工程与模块间的关系,继承是工程间的关系(其实这样描述也不太准确,简单来说就是你中有我,我中有你吧)

作者: Yanmo_ 时间: 2018-7-28 23:32
颜琳琳
maven是项目管理工具,管理java文件
maven配置:
1）本地仓库的配置
将maven解压后在maven的安装目录中的conf下的setting.xml中的配置本地仓库的安装路径
2）环境配置
MAVEN_HOME:I:\Maven\apache-maven-3.5.4
M2_HOME: I:\Maven\apache-maven-3.5.4
PATH: %MAVEN_HOME%\bin
maven的聚合与继承
创建maven工程时选pom，是以一个pom形式出现，pom代表聚合，底层有多个模块工程组成聚合，有聚合出现继承也一定会出现。
聚合和继承的区别：
聚合是多个模块工程聚合在一起，而继承则是某个模块工程要继承另一个模块的功能

作者: seilye 时间: 2018-7-28 23:45
叶身辉:
今天学习了maven
主要是学习了如何安装maven以及在核心配置文件settings.xml如何配置本地仓库,只要在配置文件中加上<localRepository>地址\repository_ssh</localRepository>
然后学习了在eclipse中配置maven,首先在windows-preferences设置中打开maven设置将安装地址添加到Installations,在再将settings.xml添加进去,
再打开window--showview 将maven调出来,刷新本地仓库的索引即可在项目中添加自己所需要的本地依赖
首先maven是有一个仓库的概念,官方的仓库叫中心仓库,我们本地的叫本地仓库,以及一些其他公司的仓库叫私服
然后maven还有一个继承和聚合的概念,这两个概念相辅相成,继承主要是指有一个父项目,子项目继承之后,同时可以继承父项目的一些依赖等
聚合是指有一个主项目,只有pom.xml将其他所有的模块项目配置在自己的pom.xml中
还学习了maven常用的几个命令
clean清除,compile编译,install将项目保存到本地这三个主要步奏,其他还有package打包,test测试

作者: 1748341437 时间: 2018-7-28 23:45
本帖最后由 1748341437 于 2018-7-29 08:39 编辑

发了两次....

作者: it小白001 时间: 2018-7-28 23:51
什么是Maven  Maven是Apache旗下一款开源自动化的项目管理工具，它使用java语言编写，因此Maven是一款跨平台的项目管理工具。
maven命令
Mvn compile 编译的命令
Mvn clean  清除命令，清除已经编译好的class文件，清除的是targe目录中的文件
Mvn test 测试命令，该命令会将test目录中的源码进行编译
Mvn package 打包命令，会在target目录中生成打包的文件
Mvn install 安装命令，会将打好的jar包，安装到本地仓库
Maven项目的结构
Project
  |-src
  | |-main
  | |  |-java       ——存放项目的.java源文件
  | |  |-resources ——存放项目资源文件，如spring, mybatis配置文件
  | |-test
  |    |-java       ——存放所有测试.java文件，如JUnit测试类
  |    |-resources ——测试资源文件
  |-target          ——目标文件输出位置例如.class、.jar、.war文件
  |-pom.xml          ——maven项目核心配置文件

作者: it小白001 时间: 2018-7-28 23:52
吴俊斌
什么是Maven  Maven是Apache旗下一款开源自动化的项目管理工具，它使用java语言编写，因此Maven是一款跨平台的项目管理工具。
maven命令
Mvn compile 编译的命令
Mvn clean  清除命令，清除已经编译好的class文件，清除的是targe目录中的文件
Mvn test 测试命令，该命令会将test目录中的源码进行编译
Mvn package 打包命令，会在target目录中生成打包的文件
Mvn install 安装命令，会将打好的jar包，安装到本地仓库
Maven项目的结构
Project
  |-src
  | |-main
  | |  |-java       ——存放项目的.java源文件
  | |  |-resources ——存放项目资源文件，如spring, mybatis配置文件
  | |-test
  |    |-java       ——存放所有测试.java文件，如JUnit测试类
  |    |-resources ——测试资源文件
  |-target          ——目标文件输出位置例如.class、.jar、.war文件
  |-pom.xml          ——maven项目核心配置文件

作者: 凉面要趁热吃 时间: 2018-7-28 23:59
黄进安:

什么是maven?
-一个项目管理工具,用来管理java项目和项目模块分类

maven仓库: 中央仓库,本地仓库,私服

常用的maven命令:
compile  编译
clean  清理编译后target生成的class文件或者生成的war包
package  将工程打包jar/war
tomcat7:run
install  安装命令,将工程的jar发布到本地仓库 (目录按照本工程定义的坐标生成目录)

eclipse配置maven报错添时加语句:
-Dmaven.multiModuleProjectDirectory=$M2_HOME

聚合:
可以将一个项目分成一个个maven模型板块,这些板块聚合构成完整的工程项目
继承:
把工程所需的jar包放在父工程下,每一个maven模型的板块都继承了该父工程的jar包

总结:所以聚合和继承一般都是共同存在的.

作者: finfin12 时间: 2018-7-29 00:00
张育辉
1:什么是maven
      Maven是apache下的开源项目，项目管理工具，管理java项目。如今我们构建一个项目需要用到很多第三方的类库，如写一个使用spring的Web项目就需要引入大量的jar包。一个项目Jar包的数量之多往往让我们摸不清，并且Jar包之间的关系错综复杂，一个Jar包往往又会引用其他Jar包，缺少任何一个Jar包都会导致项目编译失败。而Maven就是一款帮助程序员构建项目的工具，我们只需要告诉Maven需要哪些Jar 包，它会帮助我们下载所有的Jar，极大提升开发效率;
2:Maven仓库用来存放Maven管理的所有Jar包。分为：本地仓库和中央仓库。本地仓库,私服,Maven本地的Jar包仓库(使用本地仓库需要去xml文件中配置,指定本地仓库的地址)。中央仓库是Maven官方提供的远程仓库。
当项目编译时，Maven首先从本地仓库中寻找项目所需的Jar包，若本地仓库没有，再到Maven的中央仓库下载所需Jar包。
Maven基本命令
compile：编译
将Java源文件编译成class文件
test:测试项目
执行test目录下的测试用例
package:打包
将项目打成jar包
clean:删除target文件夹
install:安装
将当前项目放到Maven的本地仓库中。供其他项目使用
(三) 工程目录结构说明
project
   /src/main/java          主体程序 java源文件（不要放配置文件）
   /src/main/resources 主体程序所需要的配置文件（不要放java文件）
   /src/test/java             单元测试程序 java源文件
   /src/test/resources    单元测试程序所用的配置文件
   /target                      编译输出目录
pom.xml                Maven进行工作的主要配置文件。

什么是坐标:在Maven中，坐标是Jar包的唯一标识，Maven通过坐标在仓库中找到项目所需的Jar包。
Group Id：项目的名称，项目名称以域名的倒序，比如：cn.itcast.mavendemo
Artifact Id：模块名称（子项目名称）
Version：模块的版本，snapshot（快照版，没有正式发行）、release（正式发行版本）

(四) 聚合和继承的区别
什么是聚合？
将多个项目同时运行就称为聚合。
如何实现聚合？
只需在pom中作如下配置即可实现聚合：
什么是继承？
在聚合多个项目时，如果这些被聚合的项目中需要引入相同的Jar，那么可以将这些Jar写入父pom中，各个子项目继承该pom即可。子类就不需要配置jar包,
如何实现继承？
         父pom配置：将需要继承的Jar包的坐标放入标签即可。
两者的区别就是:多个项目同时同时运行在一起就是聚合,每个项目需要导入自己需要的Jar包,如果聚成了,可以使用父类的jia包;

作者: COLDER 时间: 2018-7-29 00:29
本帖最后由 COLDER 于 2018-10-18 19:17 编辑

今日总结整理:如下图片所示

智能截图 1.png (213.61 KB, 下载次数: 37)

作者: zzx835387607 时间: 2018-7-29 00:46
郑志祥

什么是maven?
是 apache 下的开源项目，项目管理工具，管理 java 项目,主要管理jar包

可视化的优点
它管理的java项目不存在包(减少内存)

为什么它不用包呢?
它是通过配置问价pom.xml文件
通过坐标 .和依赖到本地仓库找到jar包的位置
本地仓库:存放jar包的地址位置

生命周期
生命周期就是maven要去干的整个流程(活动)

maven 通过坐标对项目工程所依赖的 jar 包统一规范管理。

本地仓库的配置
打开 maven 的安装目录中 conf/ settings.xml 文件，在这里配置本地仓库：
<localRepository>D:\repository_ssh</localRepository>
注意:路径不要包含中文

为什么要将项目打包成war包?
因为将web项目弄成war包,就可以将整个项目发布到云端,
别人可以通过域名来访问你的网站.
操作:在Maven项目中run as 输入命令 package ,然后去相应的路径去寻找.

什么是聚合?
所谓聚合，顾名思义，就是把多个模块或项目聚合到一起，我们可以建立一
个专门负责聚合工作的 Maven 工程

什么是继承?
子类能继承父类中存在的所有的jar引用(或者依赖,坐标)

聚合与继承的区别
聚合和继承通常是结合使用的，但是其作用是不同的。聚合是将多个模块的
工程汇聚到一起，而继承则是指明某个模块工程要继承另一个模块功能
简单理解:
继承跟之前的理解的意思一样,之前是继承父类的所有方法,而现在是继承父类的所有的jar包的依赖引用.(亲生孩子继承父类)
聚合:(领养的孩子)

pom.xml的问题,在index.jsp中开启就报错?
解答:忘记配置Servlet--添加一个范围<scope>provided</scope>
po.xml需要引入的3个东西
1,tomcat
2.Servlet
3,maven.plugins

端口号被占用
解决:因为将一个项目启动了两次,关掉就好了

作者: 林荣彬 时间: 2018-7-29 00:52
林荣彬

1.Maven是apache下的开源项目，项目管理工具，管理java项目。

2.Maven仓库
  1.中央仓库:就是远程仓库
  2.本地仓库:相当于缓存,工程第一次会从远程仓库下载jar包,第二次不需要从远程仓库下载.
  3.私服:在公司内部架设一台私服，其它公司架设一台仓库，对外公开。

3.maven常见命令:
compile：编译
clean：清理，将target下的class文件清理
test：执行单元测试类，执行src/test/java下的类
package ：将java工程打成jar、war。
install：安装命令，将将程的jar发布到本地仓库
发布到仓库，目录按照本工程定义的坐标生成目录
tomcat7:run :运行项目

4:聚合:就是把多个模块或项目聚合到一起,建立一个专门负责聚合工作的Maven 工程。
继承:多个模块独立开发，但是多个模块可能依赖相同的元素.

5.聚合与继承的区别:
聚合和继承通常是结合使用的,其作用是不同的。聚合是将多个模块的工程汇聚到一起，继承则是指明某个模块工程要继承另一个模块功能。

作者: 黄志彬 时间: 2018-7-29 01:46
黄志彬
今天学习了maven,他是一个项目管理工具就是通过pom.xml文件的配置来获取jar包,不用自己再去手动添加jar包
通过对比可以知道有用maven和没用maven,项目的体积相差很大, maven减小了项目的体积.
maven的仓库分为三种,本地仓库(相当于本地缓存)-----私服(公司自己独立开发的)-----中央仓库(由maven团队来维护)
Web工程类型 pom jar war
常用的命令:
compile编译(编译是打包的前提)  clean 清除将target下的class文件清除
install 安装命令  将工程的jar发布到本地仓库,发布到仓库目录按照本工程定义的坐标生成目录
packge 将java工程打包成jar war tomcat:run  tomcat7:run

聚合方便管理继承把通用的东西都提取到父类里

作者: 一梦 时间: 2018-7-29 07:35
本帖最后由一梦于 2018-7-29 08:45 编辑

陈世彪:

maven第一天.jpg (269.81 KB, 下载次数: 29)

maven

maven第一天.zip

152.78 KB, 下载次数: 63

作者: 柯建程 时间: 2018-7-29 08:34
1.完成Maven环境搭建
Maven的环境搭建 :
      在我的电脑中
            1.MAVEN-HOME  maven存放位置
            2.M2-HOME maven存放位置
            3.PATH: %MAVEN-HOME%/bin;
      在maven中
            conf中的settings.xml中<localRepository>D:\repository_ssh</localRepository>
      在eclipse中
            1.在window下preferences的maven的installation和user setting 配置
2.能够分清几种仓库的区别
   三种仓库
         中央仓库:maven管理,只有一个
         本地仓库:下载的jar存放位置
         私服:公司最近定义的仓库
3.熟练掌握常见命令
   clean  清除class文件
   compile 编译元文件
   package 生成jar或war包
   install  将jar生成到本地仓库中
4.能够用Maven完成ssh项目的搭建
   1.创建maven工程包
         maven  project (父类包)
         maven  Module(子类包)
   2.对工程基于坐标管理
         Group id  保存在本地仓库名
         Artifact id 项目名
         Version  版本
         packaging  (jar) (war) (pom)
   4.增加web.xml文件
   5.配置tomcat文件
6.在pom.xml增加servlet-api 依赖范围
7.增加ssh依赖
8.增加配置文件

5.了解聚合和继承的区别
聚合:把多个模块或项目聚合到一起
继承:子类继承父类

作者: 铁木啊童臂 时间: 2018-7-29 08:44
汪志阳
今天学习了项目管理的工具Maven,maven是一个开源项目,主要是来定义
工程所依赖的jar包,和工程的坐标,打包方式.maven存放包在中央仓库,本地仓库
和私服中.学习了maven后,以后导包都是在maven的配置文件中进行配置,系统自动导入
包,要用maven就要进行配置.配置分为本地仓库的配置和eclipse的配置.
配置完后就是进行工程的创建,maven工程和web工程或者普通java工程的目录结构都不一样,
它的一个核心配置文件pom.xml,在我们进行依赖注入,系统会自动在pom.xml中生成包的信息
而且比如我们添加hibernate的核心包,hibernate包自动帮我们添加它所依赖的包.
maven常用的命令:clear(清理工作);complie(编译源代码);test(单元测试代码);package(打包编译好的代码)
打包为jar,war,pom;install(安装到本地Maven)库
接下来就是war创建web工程:
1.新建工程,定义工程坐标为web
2.手动添加web-inf及下面的web.xml文件
3.在pom.xml中注入maven,tomacat,servlet信息
4.新建测试jsp页面,部署测试tomcat7:run
测试没问题后在pom中添加ssh框架所需要的依赖,再者就是和我们之前用web项目没什么区别.
主要在于包的引入方式有别于之前的传统方式

作者: 李志勇 时间: 2018-7-29 08:49
李志勇：
Maven仓库分为3种；1、中央仓库，2、本地仓库，3、私服
clean  清除 compile  编译 package  打包 install  将jar发布到本地仓库
tomcat:run 内置tomcat运行程序 tomcat7:run  tomcat7运行程序
添加依赖
<dependencies>
  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
    <scope>provided</scope>
  </dependency>
</dependencies>
添加插件
<build>
   <plugins>
      <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>2.3.2</version>
            <configuration>
               <source>1.7</source>
               <target>1.7</target>
            </configuration>
      </plugin>
      <plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<configuration>

<port>8080</port>

<path>/</path>
</configuration>
         </plugin>
   </plugins>
</build>

作者: 李志勇 时间: 2018-7-29 08:58
李志勇：Maven仓库分为3种；1、中央仓库，2、本地仓库，3、私服
clean  清除 compile  编译 package  打包 install  将jar发布到本地仓库
tomcat:run 内置tomcat运行程序 tomcat7:run  tomcat7运行程序
添加依赖
<dependencies>
  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
    <scope>provided</scope>
  </dependency>
</dependencies>
添加插件
<build>
   <plugins>
      <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>2.3.2</version>
            <configuration>
               <source>1.7</source>
               <target>1.7</target>
            </configuration>
      </plugin>
      <plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<configuration>

<port>8080</port>

<path>/</path>
</configuration>
         </plugin>
   </plugins>
</build>

作者: w849027724 时间: 2018-7-29 08:58
吴利君
maven是一个项目管理工具，用来管理项目，他有仓库，可以用来管理jar包，使用的时候直接导入，方便程序开发，减小程序体积！
它的仓库有中央仓库，本地仓库以及私服，个人开发者需要搭建一个本地仓库，便于程序开发，
由于maven的中央仓库是国外的，国内使用最后在配置文件中添加镜像私服，比如阿里云的。
这样会加快jar包的引用。
maven的聚合很厉害，可以吧项目拆分子模块，这样便于项目的管理与模块开发！
总之maven是一个很厉害的工具！

作者: Ldddd 时间: 2018-7-29 08:59
赖镇东：
         今天学习了maven（day01），学习了下载安装maven，配置环境，总结一下今天最主要的知识点是：
1、会独立配置maven及环境（依赖文件可以拷贝）
2、创建maven下的war项目：
           1、创建maven项目，注意打包方式为war
         2、会报错，复制一个WEB.INF/web.xml至webapp文件下
         3、添加插件及导入依赖包，pom.xml(直接复制模板)
【1】插件：（1）编译方式
                     （2）更换Tomcat，设置端口号与路径
                                 （3）添加servlet-api，必须！！！指定 scope 为 provided
【2】依赖包
4、创建包结构
5、编写applicationContext.xml与struts.xml（复制模板修改参数）
【1】修改（1）切入点表达式
   （2）数据库
   （3）service的印射文件
6、开发

作者: 2902 时间: 2018-7-29 08:59

maven主要用于管理我们的jar包的开源工具

特点有一个pom.xml文件 pom.xml文件通过引用jar包的仓库(在线中央仓库,本地仓库,私服)
来替换以前在lib中的jar包,使得maven项目的文件大小大大降低,减少对空间资源的占用;

maven中常用的命令有: complie,clean,install,package,tomcat7:run

在引入依赖时有有些相同的属性,为了方便以后管理我们可以吧他们抽取出来,自定义一个变量
在标签中引用变量,这样可以做到一次定义.多次使用.

作者: Ldddd 时间: 2018-7-29 09:06
赖镇东：maven（day01）
今天学习了maven，重点我觉得就两个：
一、能独立下载配置安装maven（可以拷贝）
二、（重点）maven下创建war项目：（必须掌握，今天最重要）
      1、创建maven项目，注意打包方式为war
2、会报错，复制一个WEB.INF/web.xml至webapp文件下
3、添加插件及导入依赖包，pom.xml(直接复制模板)
【1】插件：（1）编译方式
            （2）更换Tomcat，设置端口号与路径
                                 （3）添加servlet-api，必须！！！指定 scope 为 provided
【2】依赖包
4、创建包结构
5、编写applicationContext.xml与struts.xml（复制模板修改参数）
【1】修改（1）切入点表达式
         （2）数据库
         （3）service的印射文件
6、开发
三、其它知识点了解即可，用到了再回来看

作者: 名字被人注册了 时间: 2018-7-29 09:08
刘文峰

Maven的环境搭建:下载maven的压缩包,并配置环境变量MAVEN_HONE,在path中添加一个%MAVEN_HONE%\bin,M2_HOME(该环境变量根据情况配置)
Maven的仓库:maven有中央仓库,本地仓库,私服三个仓库.中央仓库有maven的团队管理,里面主要是存放常用的jar包,本地仓库在自己电脑上,工程在第一次会从中央仓库找jar包并下载到本地仓库中,第二次开始就会先从本地仓库查找,找不到再去中央仓库;私服就是公司自己搭建的一个远程仓库.
Maven常见的几种命令:
Clean: 清除本地仓库的工程
Compile:  编译工程
Install:  将工程加载到本地仓库中
Package:  打包工程(jar,war,pom)
tomcat:run:  使用内置的tomcat6服务器
tomcat7:run:  使用tomcat7服务器
聚合和继承:聚合是指一个工程(meven project)内包含多个模块(maven module),其本身只相当于一个pom.xml文件,可以将多个模块的重复内容抽取出来,减少空间.继承是模块继承另一个模块的功能,二者通常同时使用.

作者: Do1 时间: 2018-7-29 09:30
郑泽珑

maven是一个项目对象模型（pom），主要应用其依赖管理系统实现模块化开发
maven使用：
1.配置Windows环境变量，新建一个MAVEN_HOME路径指向解压后的maven文件夹,在PATH中添加，路径指向maven中的bin文件夹，新建一个maven本地仓库，在maven文件夹下的conf文件夹中的setting.xml配置本地仓库路径
2.打开eclipse,Windows—>Preferences—>搜索输入maven—>Installations—>add—>选中maven目录添加完成后勾选—>User Settings—>User Settings标签下点击Browse找到setting.xml文件保存，这样maven就配置好了

3.新建一个maven工程
maven分为3种新建的项目类型
pom:父工程，主要用于jar包版本控制，本身没有实质内容，用于管理和提供依赖给其子工程，所有项目必须继承它，也称聚合工程，有聚合必定存在继承
war:用于发布到服务器上的工程，这些工程能够直接被用户访问
jar:顾名思义就是jar包，提供一些实用类和工具类等等，提供给其它需要的工程

作者: Nevermo 时间: 2018-7-29 11:14
许煜 maven每日总结:
完成Maven环境搭建
1 下载maven
2配置环境变量 m2_home maven_home 以及path
3修改配置文件settings.xml 配置本地仓库的位置
能够分清几种仓库的区别
1 中央仓库 ----由maven团队管理的jar包仓库
2 本地仓库 ----由自己管理的jar包仓库
3 私服 ----个人或公司自己搭建的服务器管理jar包的仓库
熟练掌握常见命令
1 编译指令compail
2 打包指令 package
3 安装指令 install
4 清除指令 clean
5 运行指令 tomcat7:run(tomcat版本7及7以上)
能够用Maven完成ssh项目的搭建
创建maven项目使用pom.xml文件管理jar包
了解聚合和继承的区别
举一下两个例子:
聚合 :将web层 service层 Controller层聚合一起 ,形成完整web项目
继承: web层,service层,Controller分别从父项目继承属于自己的依赖
我对maven的理解:maven就是一个比较智能的仓库管理系统,我们通过pom.xml配置文件控制项目需要的jar包,各个web小项目聚合成一个完整的项目,而各个web小项目又各种从父类继承各自的依赖,maven就像一个仓库管理员,统筹规划,负责进货,出货,货物分配,分区管理,集合管理.将一个完整的项目打散,又将打散的部分有规则地组装在一起.

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2