美文网首页
maven学习笔记（总）

maven学习笔记（总）

作者: Ernest_Chou | 来源:发表于2018-11-22 22:09 被阅读0次

    maven

    一、maven基础

    1. maven的核心

    • 依赖管理：对jar包管理的过程
    • 项目构建：项目在编码完成后，对项目进行编译、测试、打包、部署

    2. maven安装、配置本地仓库

    2.1. maven下载安装
    • Maven 下载地址：http://maven.apache.org/download.cgi
    • 解压到本地磁盘（目录不能有空格）
    • 设置 Maven 环境变量
      • 必须先安装jdk，配置JAVA_HOME
      • 新建系统变量 MAVEN_HOME，变量值：E:\Maven\apache-maven-3.3.9
      • 编辑系统变量 Path，添加变量值：;%MAVEN_HOME%\bin
      • 查看maven版本信息，验证是否已成功安装
        • 执行mvn -v
        • 查询maven版本信息
    2.2. 配置本地仓库
    2.2.1. 仓库类型：

    ​ 本地仓库（local）、远程仓库（remote（私服））、中央仓库（central（Maven 社区维护））

    2.2.2. 配置本地仓库
    • 解压jar包压缩包到本地磁盘
    • 配置本地仓库路径，修改默认位置，在 %MAVEN_HOME%\conf 目录中的 Maven 的 settings.xml文件中配置<localRepository>路径。
      配置本地仓库路径

    3. maven项目标准目录结构

    maven项目目录结构1 maven项目目录结构2

    4. maven的常用命令：

    dos窗口进入项目pox.xml所在目录，执行命令：mvn tomcat:run

    4.1. maven 常用命令
      1. clean：清除项目根目录下target文件夹内所有内容
      2. compile:编译，将项目中的java文件编译为class文件
      3. test:单元测试，将项目根目录下src/java目录下的单元测试类都会执行
        单元测试类名要求：***Test.java
      4. package：打包
        web project ==>war包
        java project ==>jar包
        将项目打包，打包项目根目录下target 目录
      5. install：安装
        本地多个项目公用一个jar包，打包到本地仓库
    4.2. maven项目的生命周期
      1. CleanLifeCycle:清理生命周期：clean
      2. defaultLifeCycle：默认生命周期：compile、test、package、install、deploy
      3. siteLifeCycle:站点生命周期：site

    • 三套生命周期相互独立，互不影响。
      在一套生命周期内，执行后面的命令，前面操作会自动执行。


      maven的生命周期，项目构建过程
    4.3 概念模型
    maven概念模型

    5. maven整合web项目

    5.1. 配置maven插件
    5.1.1 新版的eclipse自带maven插件
    5.1.2 配置maven程序
    eclipse配置maven插件
    5.1.3 配置userSetting
    配置userSetting
    5.1.4 构建索引

    注意配置本地仓库地址


    构建maven索引
    5.2. maven整合Servlet
    5.2.1 创建maven项目
    1.选择创建maven项目 2.选择项目原型 3.maven项目信息
    5.2.2 创建好web项目产生的错误

      1. web.xml缺失


        补加缺失web.xml
      1. jdk编译版本为1.5，在pom.xml中添加插件
     <!-- 添加项目jdk编译插件 -->
  <build>
    <plugins>
        <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>
    </plugins>
  </build>

      1. 创建一个Servlet,servlet编译报错，原因：缺失servlet-api-**.jar包


        缺失jar包

      1. 查找依赖


        查找jar包
    5.3. 依赖的范围

    添加依赖范围：默认是compile
    provided:运行部署到tomcat不再需要。

    • 问题:如果将servlet-api.jar设置为compile，打包之后包含servlet-api.jar,war包部署到tomcat后跟tomcat中存在的servlet-api.jar包冲突。导致运行失败。

      与tomcat中jar包冲突

    • 解决：修改依赖范围

    修改依赖范围
    • 依赖作用范围
    依赖范围 对于编译classpath有效 对于测试classpath有效 对于运行时classpath有效 例子
    compile Y Y Y spring-corer
    test - Y - Junit
    provided Y Y - servlet-api
    runtime - Y Y JDBC驱动
    system Y Y - 本地的，Maven仓库之外的类库
    • 总结:如果使用到tomcat自带jar包，将项目中依赖作用范围设置为：provided
    provided范围的jar包
    5.4 运行、调试项目
    maven手动命令 添加调试
    5.5 maven整合struts2
    5.5.1 通过工具生成web.xml及添加编译jdk版本
    通过工具生成web.xml 自己添加插件 搜索插件 
    <build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.7.0</version>
            <!-- 手动设置详细信息 -->
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
    </plugins>
  </build>
    5.5.2 添加struts2的依赖

    添加核心包，自动添加其他依赖包

    5.5.3 创建struts.xml
    5.5.4 创建action类继承ActionSupport类
    5.5.5 在web.xml中配置Struts2框架核心过滤器
      <!-- 配置Struts2框架核心过滤器 -->

  <filter>
    <filter-name>struts</filter-name>
    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>struts</filter-name>
    <url-pattern>/*</url-pattern> <!-- .action或者空白结尾的会经过过滤器 -->
  </filter-mapping>
    5.5.6 编写action中的方法
    //url http://localhost:8080/maven-struts2/customerAction_test.action
  public String test() throws Exception {
      System.out.println("成功进入CustomerAction中的test方法");
      return SUCCESS;
  }
    5.5.7 在struts.xml中配置action
    <package name="demo" namespace="/" extends="struts-default">
      <action name="customerAction_*" class="com.zhougl.web.action.CustomerAction" method="{1}">
          <result name="success">/index.jsp</result>
      </action>
  </package>

    二、Maven实战

    1.传递依赖冲突解决

    1.1Maven自己调解原则
    1.1.1 第一声明优先原则

    谁先定义就用谁优先传递依赖

    第一声明优先原则.图一
    第一声明优先原则.图二
    1.1.2 路径近者优先原则

    直接依赖级别高于传递依赖。

    路径近者优先.图一 路径近者优先.图二
    1.2 排除依赖
    排除依赖操作
    排除依赖
    1.3 版本锁定（推荐使用）
    版本锁定
    1.4 配置文件中的属性引用

    在配置文件中定义属性，使用ognl表达式引用属性值

    定义属性 引用属性值

    2. ssh配置文件加载过程

    ssh配置加载流程

    3.通过maven整合ssh框架

    3.1 ssh框架所需要的jar包
    3.1.1 主要jar包及关系
    • struts2-spring-plugin
    • spring-orm
    • aspectjweaver
    • hibernate-core
    • hibernate-c3p0
    依赖 简述
    struts2-spring-plugin(2.5.12) Spring集成Struts2所需包，此系列包会帮你下载struts2和spring(4.1.6)相关基础jar包,加一个struts2-spring-plugin(2.5.12).jar包。（所以，加入这个依赖之后，maven会帮你下载struts2和spring基础包，自己不用再添加加Struts2和spring的依赖了。而我又添加了spring-context-4.3.10.RELEASE的原因下面细说。）
    spring-context(4.3.10) 会帮你下载spring基础jar包： （加此依赖的原因：可能是因为hibernate5，版本过高与spring.4.1.6不兼容吧，出现java.lang.NoClassDefFoundError: org/springframework/core/ResolvableTypeProvider异常，spring在4.2版本新加了一个公共接口ResolvableTypeProvider，在使用spring-orm中的hibernate5相关类需要用到此接口。所以spring用4.2之后的新版本。添加不同版本的dependency，后面添加的会无效）
    spring-orm Spring集成Hibernate所需包，内中包含spring使用hibernate所需相关类。
    aspectjweaver.jar SpringAop所依赖的包，spring AoP就是用aspectj来实现的，是依赖关系！AspectJ是动态代理的一种实现！spring默认使用的就是AspectJ来实现的动态代理。
    spring-aspects spring-aspects直接依赖于aspectjweaver.jar,所以引入该包统一版本
    hibernate-core Hibernate核心包。hibernate5与hibernate4相比，区别不少（使用需谨慎！）
    hibernate-c3p0 配置Mysql-c3p0数据源和连接池所需包
    3.1.2 pom.xml最终配置
    <!-- 属性 -->
  <!-- struts的版本 ==> spring的版本4.3.13  ==> hibernate的版本 -->
  <properties>
    <!-- 统一源码的编码方式 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!-- 统一各个框架版本 -->
    <struts.version>2.5.10</struts.version>
    <spring.version>4.3.10.RELEASE</spring.version>
    <hebernate.version>5.1.7.Final</hebernate.version>
  </properties>
  
  <build>
    <plugins>
        <!-- 统一源代码编译输出的JDK版本 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.7.0</version>
            <!-- 设置详细信息 -->
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
    </plugins>
  </build>
   <!-- 版本锁定：指定项目中依赖的版本 -->
  <dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency> 
    </dependencies>
  </dependencyManagement>
  
  <dependencies>
    <!-- Struts2和Spring整合依赖 包含struts2和spring基础包  -->
    <!-- 包含Spring 核心依赖 Spring web依赖 Struts2 核心依赖  -->
    <dependency>
        <groupId>org.apache.struts</groupId>
        <artifactId>struts2-spring-plugin</artifactId>
        <version>${struts.version}</version>
    </dependency>
    <!-- spring基础jar包  4.2之后的新版本支持hibernate5  -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!-- Spring web依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!-- Spring整合ORM框架依赖 Spring集成Hibernate所需包 -->
    <dependency> 
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!-- SpringAop所依赖的包 -->
    <!-- <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.10</version>
    </dependency> -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!-- Hibernate核心包 -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>${hebernate.version}</version>
    </dependency>
    <!-- 连接池 -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-c3p0</artifactId>
        <version>${hebernate.version}</version>
    </dependency>
    <!-- oracle驱动 -->
    <dependency>
        <groupId>com.oracle</groupId>
        <artifactId>ojdbc6</artifactId>
        <version>11.2.0</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    3.2 搭建struts2环境
    3.2.1 创建struts2配置文件：struts.xml
    3.2.2 在web.xml中配置struts2的核心过滤器
    <!-- 配置struts核心过滤器 -->
  <filter>
    <filter-name>struts</filter-name>
        <!-- 高版本路径 -->
    <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
    <!-- 低版本路径 -->
    <!-- <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class> -->
  </filter>
  <filter-mapping>
    <filter-name>struts</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
    3.3 搭建spring环境
    3.3.1 创建spring配置文件：applicationContext.xml
    3.3.2 在web.xml中配置监听器：ContextLoaderListener 
     <!-- 配置spring监听器 ：默认加载WEB-INF/applicationContext.xml -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!-- 通过上下文参数指定spring配置文件路径 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
    3.4 搭建Hibernate环境
    3.4.1 创建Hibernate核心配置文件
    <?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<!-- Generated by MyEclipse Hibernate Tools.                   -->
<hibernate-configuration>

    <session-factory>
        <property name="dialect">org.hibernate.dialect.Oracle10gDialect</property>
        <!-- 配置在控制台显示SQL语句 -->
        <property name="show_sql">true</property>
        <!-- 配置对输出的SQL语句进行格式化 -->
        <property name="format_sql">true</property>
        <property name="hbm2ddl.auto">none</property>
        <property name="myeclipse.connection.profile">ehrp</property>
        <property name="connection.url">jdbc:oracle:thin:@192.168.0.134:1521/ehrp</property>
        <property name="connection.username">user_developer</property>
        <property name="connection.password">user_developer</property>
        <property name="connection.driver_class">oracle.jdbc.OracleDriver</property>
    </session-factory>

</hibernate-configuration>
    3.5 struts2跟spring整合

    整合要点：action对象创建，交给spring创建

    3.5.1 创建action类
    3.5.2 将action对象配置到spring文件中
    <!-- 配置action 必须配置scope为多实例 --> 
    <bean id="customerAction" class="com.zhougl.web.action.CustomerAction" scope="prototype">
    
    </bean>
    3.5.3 在struts.xml中的action节点中class属性配置为spring工厂中action对象bean的id
    <package name="demo" namespace="/" extends="struts-default">
        <!-- class为spring中action对象bean的id method="{1}"代表是第一个“*”-->
        <action name="customerAction_*" class="customerAction" method="{1}">
            <result name="success">/index.jsp</result>
        </action>
    </package>
    3.6 spring跟hibernate整合

    整合要点：

    3.6.1 数据源DataSource交给spring
    <!-- 加载属性值  classpath只有spring配置才有-->
  <context:property-placeholder location="classpath:db.properties"/>
  <!-- 配置DataSource -->
  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
      <property name="driverClass" value="${jdbc.driverClass}"></property>
      <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
      <property name="user" value="${jdbc.user}"></property><!-- 通过ognl表达式来取值是，${user}在linux下取的是用户名 ${userName}在window下取的是计算机名，都会报错-->
      <property name="password" value="${jdbc.password}"></property>
  </bean>
    3.6.2 SessionFactory对象交给spring创建
    <!-- 配置sessionFactory -->
  <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
      <property name="dataSource" ref="dataSource"></property>
      <property name="configLocations" value="classpath:hibernate.cfg.xml"></property>
  </bean>

    去掉hibernate.cfg.xml中数据库配置信息

    3.6.3 事务管理
      1. 配置事务框架：PlatformTransactionManager接口

      • 1.1. jdbc:DataSourceTransactionManager

      • 1.2. Hibernate:HibernateTransactionManager

          <!-- xml方式管理事务 start-->
    <!-- 配置通知：具体增强逻辑 -->
    <tx:advice id="txAdvice">
        <tx:attributes>
            <!-- 匹配业务类中方法名称 -->
            <tx:method name="save*"/>
            <tx:method name="delete*"/>
            <tx:method name="update*"/>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>
    <!-- 配置aop -->
    <aop:config>
        <!-- 配置切点:具体哪些方法要增强（真正被增强的方法） -->
        <aop:pointcut expression="execution(* com.zhougl.service.*.*(..))" id="cut"/>
        <!-- 配置切入点
            * org.ssh.service.*+.*(..)
                *：表示方法的作用域，*表示所有
                org.ssh.service.*：表示org.ssh.service下的任何包
                org.ssh.service.*+：表示org.ssh.service下的任何包及其子包
                *(..)：*表示任何方法，(..)表示方法的任何参数
         -->
        <!-- 配置切面：将增强逻辑作用到切点（通知+切点） -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="cut"/>
    </aop:config>
    <!-- xml方式管理事务 end-->
      • 1.3. 注解方式管理事务
      <!-- 注解方式管理事务 start -->
  <!-- 1.开启注解驱动，2.在service类或者方法上使用注解@Transactional -->
  <tx:annotation-driven transaction-manager="transactionManager"/>
  <!-- 注解方式管理事务 end -->
    3.7 需求

    在地址栏输入action请求http://localhost:8080/maven-ssh/phoneUserAction_findOne.action?phoneUserId=1，action-service-dao。完成客户需求。

    3.8 具体实现
    3.8.1. 创建客户实体类、映射文件、将映射文件引入hibernate核心配置文件中
    3.8.2. 创建action、service、dao。完成注入。
      1. 在类中添加属性生成set 方法
    //serviceImpl
private PhoneUserDao phoneUserDao;

  public void setPhoneUserDao(PhoneUserDao phoneUserDao) {
      this.phoneUserDao = phoneUserDao;
  }
//action
private PhoneUserService phoneUserService;

  public void setPhoneUserService(PhoneUserService phoneUserService) {
      this.phoneUserService = phoneUserService;
  }
      1. 在spring配置文件中完成注入
      <!-- 配置dao对象 -->
    <bean id="phoneUserDao" class="com.zhougl.web.dao.impl.PhoneUserDaoImpl">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    <!-- 配置service对象 -->
    <bean id="phoneUserService" class="com.zhougl.web.service.impl.PhoneUserServiceImpl">
        <property name="phoneUserDao" ref="phoneUserDao"></property>
    </bean>
    <!-- 配置action 必须配置scope为多实例 --> 
    <bean id="phoneUserAction" class="com.zhougl.web.action.PhoneUserAction" scope="prototype">
        <property name="phoneUserService" ref="phoneUserService"></property>
    </bean>
      1. 在struts.xml配置action，配置结果视图
    <struts>
    <package name="demo" namespace="/" extends="struts-default" strict-method-invocation="false">
        <!-- class为spring中action对象bean的id -->
        <action name="phoneUserAction_*" class="phoneUserAction" method="{1}" >
            <result name="success">/index.jsp</result>
        </action>
    </package>
</struts>
      1. 新版本jar包可能产生的问题：

      • 4.1. struts从2.3.X升级到2.5.18中遇到的问题及解决办法

        • 方法不能访问的问题，需要在每个action配置文件中加上strict-method-invocation="false"：
        <!-- Struts2在2.5版本后添加strict-method-invocation(严格方法访问)，默认为true，不能使用动态方法调用功能，故需设为false -->
<package name="demo" namespace="/" extends="struts-default" strict-method-invocation="false">

        或者全局配置<constant name="struts.enable.DynamicMethodInvocation" value="true" />

        并修改配置文件头部为2.5版本的：

        <!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
    "http://struts.apache.org/dtds/struts-2.5.dtd">

        • 4.2. web.xml中把org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter改为org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter

        • 4.3. jdk版本需要1.7+

        • 4.4. 如果提交表单出现404，需要将表单提交的路径改成使用basepath作位前缀：

          String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
      1. maven build默认运行的tomcat版本为6.0，会产生如下错误：
       Servlet.service() for servlet jsp threw exception
 org.apache.jasper.JasperException: Unable to compile class for JSP:

    解决：maven指定tomcat版本 maven build 命令改为tomcat7：run

    ```xml
<!-- pom.xml中添加tomcat7插件 -->
        <plugin>
          <groupId>org.apache.tomcat.maven</groupId>
          <artifactId>tomcat7-maven-plugin</artifactId>
          <version>2.2</version>
        </plugin>
```
      1. 总结
        1. 页面提交参数，在服务端action接收参数 参
        2. 调用业务层方法-->dao的方法-->DB 调
        3. 将返回的数据存值栈 存
        4. 配置结果视图 ，跳转页面 转

    4.通过maven对项目进行拆分、聚合

    对现在已有maven ssh项目进行拆分，拆分思路：将dao层的代码、已经配置好的文件全体提取出来到一个表现上独立的工程中。同样service、action拆分。

      1. ssh-parent:(父工程)
      2. ssh-dao:(子模块)
      3. ssh-service
      4. ssh-web
      5. 拆分完成后，对拆分后的项目进行聚合，提出概念父工程。
    4.1 创建父工程
    创建父工程1 创建父工程2

    创建好父工程目录结构：只有pom.xml，父工程不进行编码：

      1. 项目需要的依赖的信息，在父工程中定义，子模块继承过程。
      2. 将各个子模块聚合到一起。
    父工程目录结构 
    <!-- 属性 -->
  <!-- struts的版本 ==> spring的版本4.3.13  ==> hibernate的版本 -->
  <properties>
    <!-- 统一源码的编码方式 -->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!-- 统一各个框架版本 -->
    <struts.version>2.5.10</struts.version>
    <spring.version>4.3.10.RELEASE</spring.version>
    <hebernate.version>5.1.7.Final</hebernate.version>
  </properties>
    
  
  <build>
    <plugins>
        <!-- 统一源代码编译输出的JDK版本 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.7.0</version>
            <!-- 设置详细信息 -->
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
        <!-- 集成Tomcat插件 -->
        <plugin>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.2</version>
            <!-- <configuration>
                <path>/${project.artifactId}</path>
            </configuration> -->
        </plugin>
        <!-- <plugin>
          <groupId>org.apache.tomcat.maven</groupId>
          <artifactId>tomcat8-maven-plugin</artifactId>
          <version>3.0-r1655215</version>
        </plugin> -->
        
        <!-- 打包时跳过单元测试 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.19.1</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>

    </plugins>
  </build>
   <!-- 版本锁定：指定项目中依赖的版本 -->
  <dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency> 
    </dependencies>
  </dependencyManagement>
  
  <dependencies>
    <!-- Struts2和Spring整合依赖 包含struts2和spring基础包  -->
    <!-- 包含Spring 核心依赖 Spring web依赖 Struts2 核心依赖  -->
    <dependency>
        <groupId>org.apache.struts</groupId>
        <artifactId>struts2-spring-plugin</artifactId>
        <version>${struts.version}</version>
    </dependency>
    <!-- spring基础jar包  4.2之后的新版本支持hibernate5  -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!-- Spring web依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!-- Spring整合ORM框架依赖 Spring集成Hibernate所需包 -->
    <dependency> 
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!-- SpringAop所依赖的包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!-- Hibernate核心包 -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>${hebernate.version}</version>
    </dependency>
    <!-- 连接池 -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-c3p0</artifactId>
        <version>${hebernate.version}</version>
    </dependency>
    <!-- oracle驱动 -->
    <dependency>
        <groupId>com.oracle</groupId>
        <artifactId>ojdbc6</artifactId>
        <version>11.2.0</version>
    </dependency>

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

    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.5</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.0</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>2.7</version>
    </dependency>
  </dependencies>
    4.2 将创建好的父工程发布到本地仓库

    maven install

    忘记此步骤，将来service、dao工程发布到本地仓库，发布的service、dao工程会报错。

    补救措施：将父工程发布到本地仓库。

    4.3 创建子模块ssh-dao

    ssh-dao负责数据访问层：包含dao相关代码&配置文件

    创建子模块ssh-dao-1 创建子模块ssh-dao-2 子模块拆分ssh-dao目录结构

    将spring的配置文件进行拆分

    • applicationContext-basic.xml：项目基础信息
    • applicationContext-dao.xml：dao层bean对象
    4.4 创建子模块ssh-service
    创建子模块maven-ssh-service-1

    在service工程pom.xml添加ssh-dao依赖

    4.5 创建子模块ssh-web
    创建子模块maven-ssh-web-1 子模块maven-ssh-web目录结构

    修改spring配置：

    <!-- 通过上下文参数指定spring配置文件路径 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath*:spring/applicationContext-*.xml</param-value>
  </context-param>

    在ssh-web项目中添加service工程依赖。

    4.6 运行方式

    maven方式：

    方式1：运行父工程。父工程将各个子模块聚合到一起。将ssh-web打war包发布到tomcat

    方式2：直接运行web工程。

    其他方式：

    部署到tomcat

    f访问地址：http://localhost:8080/maven-ssh-web/phoneUserAction_findOne.action?phoneUserId=1

    4.6 单元测试
    4.6.1. 批量加载spring配置文件
      1. classpath:applicationContext-*.xml加载本项目配置文件
      1. classpath*:spring/applicationContext-*.xml既要加载本项目中配置文件，还要加载jar包中配置文件
      @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring/applicationContext-*.xml")
public class PhoneUserDaoTest {
    @Autowired
    private PhoneUserDao phoneUserDao;
    
    @Test
    public void testFindOne() {
        this.phoneUserDao.findOne("1");
    }

}

      public class PhoneUserServiceTest {

    @Test
    public void testFindOne() {
        ClassPathXmlApplicationContext context =new ClassPathXmlApplicationContext("classpath*:spring/applicationContext-*xml");
        PhoneUserService phoneUserService = (PhoneUserService) context.getBean("phoneUserService");
        phoneUserService.findOne("1");
    }

}
    4.6.2. 依赖范围
    依赖范围

    A：ssh-service工程

    B：ssh-dao工程

    C：单元测试

    总结：当项目中需要的某一个依赖没有传递过来，在自己工程中添加对应依赖。

    5.私服

    5.1 私服安装

      1. 下载安装包nexus-2.12.0-01-bundle.zip

      2. 加压到本地磁盘

      3. 使用管理员权限打开dos,执行安装命令nexus install安装私服(bin目录下)

      4. 启动服务nexus start

      5. 找到私服访问url:http:localhost:8081/nexus/#welcome

        登录：admin/admin123

    5.2 私服仓库类型
    • hosted:宿主仓库

    存放本公司开发的jar包。正式发行版（releases）、测试版（snapshots）、第三方(存在版权问题的-oracle)

    • Proxy：代理仓库

    代理中央仓库、Apache下载测试版本jar包

    • Group：组仓库

    讲了连接组仓库。包含hosted:宿主仓库，Proxy：代理仓库

    5.3 上传jar包到私服上
    5.3.1. 在maven目录下conf/setting.xml认证：配置用户名密码
    上传私服-配置认证
    5.3.2. 在将要上传的项目的pom.xml配置jar包上传路径
    上传私服-配置项目pom.xml
    5.3.3. 执行命令发布项目到私服（上传）

    maven build deploy

    5.4 从私服下载jar包到本地仓库
    5.4.1. 在maven目录下conf/setting.xml，配置模板
    配置模板
    5.4.2. 激活模板<activeProfiles>

    6. 总结

      1. 使用maven整合ssh框架
      2. 拆分maven工程
        • a) 将每一层代码&配置文件全部提取到一个独立的工程
        • b)
      3. 私服

    7. Maven的好处

      1. 不再拷贝jar包。项目不需要存放jar包。导致项目源代码小。
      2. 使用maven开发的工程，如果环境统一导入别的maven的项目不会报错。
      3. 代码耦合度进一步降低
      4. 方便项目进行升级
      5. 节省人力成本

    相关文章

      网友评论

          本文标题：maven学习笔记（总）

          本文链接：https://www.haomeiwen.com/subject/dgwrqqtx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|maven学习笔记（总）|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！