**Maven高级 笔记2[共2篇]*

Maven高级应用

1. maven基础回顾
2. maven传统的web工程做一个数据查询操作
3. maven工程拆分与聚合的思想		//要理解其意义所在，重点
4. 把第二阶段做好的web工程修改成maven拆分与聚合的形式。
5. 私服【远程仓库】
6. 如何安装第三方jar包。【把第三方jar包安装到本地仓库，把第三方jar包安装到私服】

maven基础知识回顾

1. maven是一个项目管理工具
2. 核心功能：
	1. 依赖管理：
		* maven对项目jar包的管理过程。传统工程我们直接把jar包放置在项目中。
		* maven工程真正的jar包放置在仓库中，项目中只用放置jar包的坐标
	2. 一键构建：
		* maven自身集成了tomcat插件，可以对项目进行编译，测试，打包，安装，发布等操作。
		* maven常用命令：clean ,complie(编译),test,package,install(把包安装到本地仓库),deploy（把做好的项目直接打包上传到私服）。
		* maven三套生命周期：
			1. 清理生命周期：clean
			2. 默认生命周期：complie~install
			3. 站点生命周期
3. 仓库的种类：
	1. 本地仓库
	2.　远程仓库【私服】：公司区域网内的仓库
	3.　中央仓库【本地的环境只要可以联网就直接连上了中央仓库】
	4.　关系：　
		*　当我们启动了一个maven工程的时候，maven工程会通过pom文件中jar包的坐标去本地仓库找对应jar包。
		*　默认情况下，如果本地仓库没有对应jar包，maven工程会自动去中央仓库下载jar包到本地仓库。
		*　在公司汇总，如果本地没有对应jar包，会先从私服下载jar包。
		*　如果私服没有jar包，可以从中央仓库下载，也可以从本地上传到私服。

案例准备

1. 环境准备
	1. 创建数据库，执行建表语句和插入表语句	[可以直接复制语句，也可以直接执行数据库脚本-maven高级-资料-items.sql]
	2. 创建maven工程，补齐目录名字和对应属性；java,resources,webapp,test
	3. 找到web配置头声明，打开web.xml加入到<web-app>标签内
	4. pom.xml中导入坐标 [spring-context]			/导入了核心包，它会附带其他依赖包；
		* 导入时需要注意的地方：
			1. maven工程咬导入jar包的坐标，就必须要解决jar冲突；
			-- 解决jar包冲突的方式一：
				1. 声明优先原则：哪个jar包的坐标在靠上的位置，这个jar包就是先声明的，先声明的jar包坐标下的依赖包，可以优先进入项目中。
					* maven导入jar包中的一些概念：
						1. 直接依赖：项目中直接导入的jar包，就是该项目的直接依赖包
						2. 传递依赖：项目中没有直接导入的jar包，可以通过项目直接依赖jar包传递到项目中。
			-- 解决jar包冲突的方式二：
				2. 路径近者优先原则。直接依赖路径比传递依赖路径近，那么最终项目进入的jar包会是路径近的直接依赖包
			-- 解决jar包冲突的方式三：
				3. 直接排除法。当我们要排除某个jar包下的依赖包，在配置exclusions标签的时候，内部可以不写版本号，因此此时依赖包使用的版本和默认版本一样。
					* <exclusions>
					* <exclusion>
					* <groupId>org.springframework</groupId>
					* <artifactId>spring-core</artifactId>
					* </exclusion>
					* <exclusions>
			-- 如果高版本和低版本的包同时存在，有可能低版本的包会将高版本的包覆盖掉，可能会出问题。[有些功能无法实现]
		2. <dependencyManagenment>锁定jar包版本。  锁定版本的时候，需要重新复制一份，不能剪切。
			1. maven工程是可以分父子依赖关系的。凡是依赖别的项目后，拿到的别的项目的依赖包，都属于传递依赖。
				* 比如：当前A项目，被B项目依赖。那么我们A项目总所有jar包都会传递到B项目中。
			2. B项目开发者，如果再再B项目总导入一套ssm框架的jar包，对于B项目是直接依赖。那么直接依赖的jar包就会把我们A项目传递过去的jar包覆盖掉。为了防止以上情况的出现。我们可以把A项目中主要jar包的坐标锁住，那么其他依赖该项目的项目中，即便是有同名jar包直接依赖，也无法覆盖。 
		3. 统一管理jar包版本，方便以后维护，以后修改版本的时候，只需要修改统一管理的地方，不需要每一处做修改。

dao层编写：

1. 创建java.com.itheima.domain.Items类
	* public class Items{
	* private Integer id;
	* private String name;
	* private Double price;
	* privaete String pic;
	* private Date createtime;
	* private String detail;
	* get,set方法
	* 
	* }

2. 创建java.com.itheima.dao.ItemsDao接口
	* public interface ItemsDao{
	* public Items findById(Integer id);
	* }

3. resources.com/itheima/dao.ItemsDao.xml
	* 导入约束头部
	* <mapper namespace="com.itheima.dao.ItemsDao">
	* <select id="findById" parameterType="int" resultType="items">
	* select * from items where id=#{id}
	* </select>
	* </mapper>

4. resources根目录下创建applicationContext.xml		//dao层配置文件
	* 导入约束
	* <!--dao层配置文件开始-->
	* 
	* <!-- 配置连接池-->
	* <bean id="dateSource" class="com.alibaba.druid.pool.DruidDateSource">
	* <property name="driverClassName" value="com.alibaba.druid.pool.DruidDateSource"/>
	* <property name="url" value="jdbc:mysql:///maven"/>
	* <property name="username" value="root"/>
	* <property name="password" value="root"/>
	* </bean>
	* <!--配置生产SqlSession对象的工厂-->
	* <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
	* <property name="dateSource" ref="dataSource"/>
	* <!--扫描pojo包，给包下所有pojo对象起别名-->
	* <property name="typeAliasesPackage" value="com.itheima.domain"/>
	* </bean>
	* <!--扫描接口包路径，生成包下所有接口的代理对象，并且放入spring容器中-->
	* <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
	* <property name="basePackage" value="com.itheima.dao"/>
	* <!--dao层配置文件结束-->
5. 测试dao，创建test.java.com.itheima.test.ItemsTest:
	* public class ItemsTest{
	* @Test
	* public void findById(){
	* //获取spring容器
	* ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
	* //从容器中拿到所需的dao的代理对象
	* ItemsDao itemsDao=ac.getBean(ithemsDao.class);
	* //调用方法
	* Items items=itemsDao.findById();
	* System.out.println(items.getName());
	* }
	* }

service 层编写

* 遵从原则：
		* 自己写的类尽量使用注解
		* 框架的类尽量使用配置文件
1. 创建main.java.com.itheima.service.ItemsService接口
	* public interface ItemsService{
	* public Items findById(Integer id);
	* }
2. 创建main.java.com.itheima.service.impl.ItemsServiceImpl实现类
	* public Items findById(Integer id){
	* @Autowired
	* private ItemsDao itemsDao;
	* public Items findById(Integer id){
	* return itemsDao.findById(id);
	* }  
	* }

3. 打开applicationContext.xml
	* <!-- dao层配置文件结束-->
	* <!--service配置文件开始-->
	* <!--组件扫描配置-->
	* <context:component-scan base-package="com.itheima.service"/>
	* <!--aop面向切面编程，切面就是切入点和通知的组合-->
	* <!--配置事务管理器-->
	* <bean id="transactionManager" class="org.springframework.jdbc.datesource.DataSourceTransactionManager">
	* <property name="dateSource" ref="dateSource"/>
	* </bean>
	* <!--配置事务的通知-->
	* <tx:advice id="advice">
	* <tx:attributes>
	* <tx:method name="save*" propagation="REQUIRED"/>
	* <tx:method name="update*" propagation="REQUIRED"/>
	* <tx:method name="delete*" propagation="REQUIRED"/>
	* <tx:method name="find*" propagation="true"/>
	* //<tx:method name="*" propagation="REQUIRED"/>
	* </tx:attributes>
	* </tx:advice>
	* <!--配置切面-->
	* <aop:config>
	* <aop:pointcut id="pointcut" expression="execution(* com.itheima.service.impl.*.*(..))"/>
	* <aop：advisor advice-ref="advice" pointcut-ref="pointcut"/>
	* <aop:config>
	* <!--service配置文件结束-->

4. 测试：test.itemsTest:
	* 注释掉前面dao层的测试
	* public class ItemsTest{
	* //获取容器
	* ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
	* ItemsService itemsService =ac.getBean(ItemsService.class);
	* //调用方法
	* Items items=itemsService.findById(1);
	* System.out.println(items.getName());
	* }

WEB层编写

1. 创建main.java.com.itheima.controller.ItemsController类：
	* @Controller
	* @RequestMapping("items")
	* public class ItemsController{
	* @Autowired
	* private ItemsService itemsService;
	* @RequestMapping("/findDetail")
	* public String findDetail(Model model)
	* Items items=itemsService.findById(1);
	* model.addAttribute("",items);
	* return "";
	* }
	* }
	* //等会补上

2.resources 创建springmvc.xml
	1. 导入约束
	2. 开始：
		* <!--组件扫描-->
		* <context:component-scan base-package="com.itheima.controller"/>
		* <!--处理器映射器，处理器适配器-->
		* <mvc:annotation-driven/>
		* <!--视图解析器-->
		* <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		* <property name="prefix" value="/WEB-INF/pages/"/>
		* <property name="suffix" value=".jsp"/>
		* </bean>
		* 
		* <!--释放静态资源-->
		* <mvc:default-servlet-handler/>
		* </beans>

3.创建webapp.WEB-INF.pages.itemDatail.jsp;
	* 页面接收数据
	* 请自行编写

4. web.xml中配置
	* <!--编码过滤器-->
	* <filter>
	* <filter-name>encoding</filter-name>
	* <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
	* <init-param>
	* <param-name>encoding</param-name>
	* <param-value>UTF-8</param-value>
	* </init-param>
	* </filter>
	* <filter-mapping>
	* <filter-name>encoding</filter-name>
	* <url-pattern>/*</url-pattern>
	* </filter-mapping>
	* 
	* <!--配置spring核心监听器-->
	* <listener>
	* <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	* <！--重新指定spring配置文件的路径-->
	* <context-param>
	* <param-name>contextConfigLocation</param-name>
	* <param-value>classpath:applicationContext.xml</param-value>
	* </context-param>
	* <!--springmvc的核心servlet-->
	* <servlet>
	* <servlet-name>springmvc</servlet-name>
	* <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	* <init-param>
	* <param-name>contextConfigLocation</param-name>
	* <param-value>classpath:springmvc.xml</param-value>
	* </init-param>
	* <load-on-startup>1</load-on-startup>
	* </servlet>
	* <servlet-mapping>
	* <servelt-name>springmvc</servlet-name>
	* <url-pattern>/</url-pattern>
	* <servlet-mapping>
	* </web-app>

工程的拆分与聚合思想

1. 通过上面的案例可以看出：普通项目分三层：dao，service，controller	
	* 买家：买家要看到订单，必须要把数据库中订单查询出来。dao层的任务	系统：买家版
	* 卖家：卖家要看到订单，必须要把数据库中订单查询出来。dao层的任务	系统：卖家版
2. 思想演变：
	* 如果是一个传统的ssm框架整合的项目，我们要在每个项目中都放置一套ssm框架的jar包；
	* 如果是maven的ssm工程，有十个项目我们也只需要一套jar包。真正项目中只放置jar的坐标即可。
	* jar包内的是代码，我们写的每个层，每个项目也是代码，所谓的jar包和我们写的代码其实是一样的。
	* 一份代码可重用和一份代码复制粘贴到不同地方的区别：如果修改维护的话，可重用的只需要修改一份，而复制粘贴几个地方，就要维护几个地方。
3. maven解决代码可重用和便于维护问题上是这样解决的：[拆分与聚合]
	* maven把一个完整的项目，分成不同的独立模块，这些模块都有各自独立的坐标，哪个地方需要其中某个模块，就直接引用该模块的坐标即可。		
	* 今后如果公司开发一个新项目，我们先考虑的问题不是dao，service，utils，domain如何编写，我们要考虑的是：dao，service，utils，domain这些模块是否已经存在，如果存在直接引用。
	* 以上说的就是maven拆分的思想；
	* 我们可以把拆分零散的模块聚合到一起编写一个完整的项目，这就是maven聚合思想。

4. maven父子工程的创建
	1. 父工程可以工程也可以模块，只需要一个pom.xml
		1. 创建mvaen_day02_parent的project工程
		2. 删除掉其他东西，留着.idea，maven_day02_parent.iml,pom.xml
	2. 在该工程下创建新的项目，AId:maven_day02_dao文件，AId：maven_day02_service文件，Aid:maven_day02_web文件。
		* 在父工程的pom.xml文件下出现了三个新的标签：
			* <modules>
			* <module>maven_day02_dao</module>
			* <module>maven_day02_service</module>
			* <module>maven_day02_web</module>
			* </modules>

工程和模块的关系以及继承依赖的概念：

1. 工程和模块的区别：
	* 工程不等于完整的项目，模块也不等于完整的项目，一个完整的项目看的是代码，代码完整，就可以说这是一个完整的项目，和此项目是工程和模块没有关系；
	* 工程只能使用自己内部资源，工程天生是独立的。后天可以和其他工程或模块建立关联关系。
	* 模块天生不是独立的，模块天生是属于父工程的。模块一旦创建，所有父工程的资源都可以使用。
	* 父子工程之间，子模块天生集成父工程，可以使用父工程所有资源
	* 子模块天生是没有关系的。
2. 使用，将工程内的模块项目放到本地仓库中，在pom.xml中导入坐标，即可使用；
	* 父子工程之间不用建立关系，继承关系是先天的，不需要手动建立。
	* 平级直接的引用叫依赖。		[依赖不是先天的，依赖是需要后天建立的]

父子工程的示例：

1. 在父工程中pom.xml导入子模块的坐标；
2. 对照直接依赖传递依赖的图可以看出：
	1. dao和parent是直接依赖，作用域是compile
	2. dao和junit是传递依赖，作用域是test	[junit是在父工程中导入的junit，它的scope范围是test]
	3. 通过以上两个对照表可以知道：junit传递到dao中已经不能使用了。
	-- 总结：实际开发中，如果传递依赖丢失，表现形式就是jar包的坐标导不进去，我们的做法就是直接再导入一次。
3. 示例：
	1. 创建maven_day02_parent父工程，保留.idea,maven_day02_parent.iml,pom.xml
	2. 创建maven_day02_dao模块,补全相应的内容。
		1. 创建src.main.java.itheima.domain,补全items实体类
		2. 创建src.main.java.itheima.dao，补全itemsDao接口
		3. 创建resource.com.itheima.dao，补全ithemsDao.xml
		4. resources下创建spring.applicationContext-dao.xml,补全该配置文件 [只加入dao的部分]
	3. 创建maven_day02_service
		1. 在该模块下pom.xml导入dao模块
		2. 创建java.com.itheima.service,导入接口Itemsservice，导入impl.ItemsServiceImpl;
		3. 创建spring包，导入applicationContext-service.xml   [删除里面所有关于dao的部分]
	4. 创建maven_day02_web
		1. 在该模块下pom.xml导入service模块和dao模块
		2. 创建main.java.com.itheima.controller,补全该包下ItemsController
		3. 创建resources.log4j.properties,resources.springmvc.xml并补全
		4. 创建webapp.WEB-INF.pages.web.xml，并补全该web.xml内容
		5. 创建WEB-INF.index.jsp
		6. 发现web.xml内容中重新指定spring配置文件的路径报错：param-value标签显红色：
			* 在resources下创建一个applicationContext.xml；
			* <bean>
			* 导入约束
			* <import resource="classpath:spring/application-dao.xml">
			* <import resource="classpath:spring/applicationContext-service.xml">
			* </bean>
	5.测试：	[三种方式测试]
		1. 方式一：启动父工程的tomcat 7 的run进行访问
		2. 方式二：在Maven Projects下的maven_day02_parent下找到install双击打包安装到本地仓库，再找到maven_day02_web下的tomcat 7 下的tomcat7:run双击运行
		3. 方式三：使用本地安装的tomcat：添加tomcat，点击Edit Configurations...->Tomcat Server->Local-> 在Deployment下添加[web模块即可]，exploded是热启动，war是打包启动 -> 点击启动；
		4. 总结：三种启动方式，方式二模块下的项目需要自己安装到本地仓库，而父工程启动和导入的tomcat[方式一和方式二]不需要安装到本地仓库；


##　私服的安装和启动

1. 资料中一个是Linux的，一个是windows的，公司的私服一般在私服服务器上；
2. 步骤：
	1. 解压：
		* nexus-2.12.0-01:安装包
		* sonatype-work: 私服
	2. 打开nexus-2.12.0-01->bin->以管理员方式运行命令提示符->cd 该路径地址->
		* 输入：nexus.bat uninstall     [卸载]   
		* 或者输入：nexus.bat install   [安装]
		* 完成之后输入：nexus.bat start   [运行]
	3. 端口号为8081：路径：nexus-2.12.0-01-bundle->nexus-2.12.0-01->conf->nexus.properties中    【该配置文件下有该端口号，如果端口号被占用了，可以在该配置文件下进行修改。】
	4. 测试：打开浏览器输入：localhost:8081/nexus/#welcome     
	5. 该地址需要登录：username:admin     password:admin123		[这是默认账号密码]
	6. 登录后，点击Repositories即可查看到本地私服内的文件了。
		* Snapshots：测试版
		* Releases：发行版
		* 3rd party：第三方
		* central： 中央仓库   地址：https://repol:maven.org/maven2/
		* group:组：如果没有就从私服下，私服没有就从中央仓库下。
	7. 远程仓库[私服]的物理地址：nexus-2.12.0-01-bundle->sonatype-work-nexus-storage

私服的应用

1. 设置登录密码：
	1. 路径：apache-maven-3.5.2 ->conf ->settings.xml 
	2. 打开教案大纲复制server标签,在该server标签下添加内容：
		* <servers>
		* <server>		//登录的正式账号密码
		* <id>releases</id>
		* <username>admin</username>
		* <password>admin123</password>
		* </server>
		* <server>
		* <id>snapshots</id>		//登录的测试的账号密码
		* <username>admin</username>
		* <password>admin123</password>
		* </server>
		* </servaers>
	3. 在需要上传的模块下的pom.xml中添加该代码：
		* <distributionManagement>
		* <repository>
		* <id>releases</id>
		* <url>http://localhost:8081/nexus/content/repositories/releases/</url>
		* </repository>
		* <snapshotRepository>
		* <id>snapshots</id>
		* <url>http://localhost:8081/nexus/content/repositories/snapshots/</url>
		* </snapshotRepository>
		* </distributionMangement>
		* </project>
		* 正式对正式，测试对测试：公司中ip地址就不是localhost了，是需要改的。
2.将maven_day02_dao模块内容上传到私服：
	1. 找到intellij idea的右边Maven Projects 下的maven_day02_dao的deploy，双击运行
	2. 在nexus-2.12.0-01-bundle ->sonatype-work ->nexus ->storage ->snapshots下即可找到com的文件夹，该文件夹就是已经上传到私服的文件。
	

3. 这时候虽然已经上传成功了，但是不一定能下载成功。下载和上传的地址可能不一样；
	1. 找到资料：下载jar包的配置，复制该一串代码。找到setting.xml，在标签<profiles>下复制该代码
	2. 激活：在资料中找到该代码，复制到<profile>标签的外部的下面：
		* <activeProfiles>
		* <activeProfile>dev</activeProfile>
		* </activeProfiles>
	3. 这里的dev要与上面的配置下载地址的id的内容对应上；这里是都为dev；

4. 运行tomcat ：运行的时候，即便本地仓库中没有dao模块，但是它可以到中央仓库进行下载；

安装第三方jar包到私服

1. 安装到本地仓库：
	1. 安装第三放jar包需要找到它的坐标，fastjson-1.1.37.jar的坐标在右边的mvn.txt中。
	2. 如果安装其他的第三方jar包，将该文本的名字，版本号相应的修改即可。
2. 安装到私服：
	1. 将文本的账号粘贴到maven中setting.xml中的账号位置，参照上面：servers标签内；
	2. 参照文本；