pom 配置mysql driver

转载

蓝月亮 2024-11-07 20:39:22

文章标签 pom 配置mysql driver maven java xml文件 jar 文章分类 MySQL 数据库

Maven笔记

配置本地仓库位置
配置阿里云的源
约定的项目结构
常用的命令
生命周期
安装maven插件
依赖传递
依赖冲突
依赖范围
聚合
继承

下载，环境变量配置跳过

首先设置\conf\settings.xml文件

配置本地仓库位置

<localRepository> D:/repo </localRepository>

配置阿里云的源

<mirrors>
    <mirror>
     <id>aliyunmaven</id>
     <mirrorOf>*</mirrorOf>
     <name>阿里云公共仓库</name>
     <url>https://maven.aliyun.com/repository/public</url>
    </mirror>
     <mirror>
     <id>aliyunmaven</id>
     <mirrorOf>*</mirrorOf>
     <name>阿里云谷歌仓库</name>
     <url>https://maven.aliyun.com/repository/google</url>
    </mirror>
    <mirror>
     <id>aliyunmaven</id>
     <mirrorOf>*</mirrorOf>
     <name>阿里云阿帕奇仓库</name>
     <url>https://maven.aliyun.com/repository/apache-snapshots</url>
    </mirror>
    <mirror>
     <id>aliyunmaven</id>
     <mirrorOf>*</mirrorOf>
     <name>阿里云spring仓库</name>
     <url>https://maven.aliyun.com/repository/spring</url>
    </mirror>
    <mirror>
     <id>aliyunmaven</id>
     <mirrorOf>*</mirrorOf>
     <name>阿里云spring插件仓库</name>
     <url>https://maven.aliyun.com/repository/spring-plugin</url>
    </mirror>
  </mirrors>

约定的项目结构

main
    java
        package //源码
test
    java
        package //单元测试
resources //资源

常用的命令

compile 编译
test 运行单元测试
package 打包
clean 清除target
install 安装jar包到本地仓库中

生命周期

周期	含义
clean	清理项目
default	构建项目（最核心）
site	生成项目站点

clean 的三个阶段

pre-clean 执行清理前的工作
clean 清理上一次构建生成的所有文件文件
post-clean 执行清理后的文件

default 常用的几个阶段
compile 编译
test 测试
package 打包
install 安装包到本地仓库

site 的四个阶段
pre-site 在生成项目站点前要完成的工作
site 生成项目的站点文档
post-site 在生成项目站点后要完成的工作
site-deploy 发布生成的站点到服务器上

安装maven插件

修改pom.xml文件

<build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.7.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-project-info-reports-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
        <!--绑定插件到某个执行步骤-->
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-source-plugin</artifactId>
          <version>2.4</version>
          <!--这里就是绑定source插件到package，执行package时会执行source，试过了，不知道为什么不好使-->
          <executions>
            <execution>
              <phase>package</phase>
              <goals>
                <goal>jar-no-fork</goal>
              </goals>
            </execution>
          </executions>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>

依赖传递

如果A依赖B，B依赖C，那么A也会依赖C
如果我们依赖B的时候，不希望依赖B所依赖的C，那么我们可以用如下配置排除B的依赖项依赖

<dependency>  
    <groupId>B</groupId>  
    <artifactId>B</artifactId>  
    <version>0.0.1</version>  
    <exclusions>  
        <exclusion>
            <groupId>C</groupId>  
            <artifactId>C</artifactId>  
        </exclusion>  
    </exclusions>  
</dependency>

排除B的所有依赖项

<dependency>  
    <groupId>B</groupId>  
    <artifactId>B</artifactId>  
    <version>0.0.1</version>  
    <exclusions>  
        <exclusion>
            <groupId>*</groupId>  
            <artifactId>*</artifactId>  
        </exclusion>  
    </exclusions>  
</dependency>

依赖冲突

最短路径优先
比如A依赖B，B依赖C，同时B依赖M的1.0版本，然后C又依赖M的2.0版本，那么A会遵循B的依赖，依赖的是M的1.0版本
先声明优先
比如A依赖B，A又依赖C，同时B依赖M的1.0版本，C又依赖M的2.0版本，那么在A的pom.xml文件中，对谁的依赖写在前面，A就遵循谁的依赖

依赖范围

具体看这个人的文章吧

聚合

假设有如下几个模块
chameleon-core
chameleon-simple
chameleon-common
chameleon-config-web
chameleon-web
chameleon-sso
在父项目的pom.xml文件中添加

<modules>
        <module>chameleon-core</module>
        <module>chameleon-simple</module>
        <module>chameleon-common</module>
        <module>chameleon-config-web</module>
        <module>chameleon-web</module>
        <module>chameleon-sso</module>
    </modules>

然后在执行一个build的时候就会将这些一起build了

继承

建立一个项目，pom.xml中进行如下配置，除了packaging节点，其他都是你自己起名的，注意
packaging节点改成pom

<groupId>com.chameleon</groupId>
    <artifactId>chameleon</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>

在子项目的pom.xml文件中添加如下内容，就会继承父pom了

<parent>
        <artifactId>chameleon</artifactId>
        <groupId>com.chameleon</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

将版本号提取成属性
在pom.xml的properties节点中添加随便起名的节点，我起名为junit.ver

<properties>
    <junit.ver>4.12</junit.ver>
  </properties>

然后使用该属性的时候就这样使用就可以了

<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.ver}</version>
      <scope>test</scope>
    </dependency>

dependencyManagement标签，在父项目的pom.xml文件中，添加这个标签

<dependencyManagement>
   <dependencies>
       <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <version>${junit.ver}</version>
           <scope>test</scope>
       </dependency>
       <dependency>
           <groupId>com.google.guava</groupId>
           <artifactId>guava</artifactId>
           <version>18.0</version>
       </dependency>
   </dependencies>
</dependencyManagement>

然后在子项目中引用junit的时候就不再需要声明version和scope了
需要注意的是dependencyManagement标签不会引入相关的jar，他只是对依赖的声明，当子项目需要引用dependencyManagement中声明的依赖时，需要在pom.xml中显式的声明
子项目中进行如下的声明才会真正的引用相关jar包

<dependencies>
       <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
       </dependency>
       <dependency>
           <groupId>com.google.guava</groupId>
           <artifactId>guava</artifactId>
       </dependency>
   </dependencies>

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。