• 01_Maven

    文章目录

    Maven

    • Maven是一个项目管理工具，主要有两个功能：
      • 项目构建
        • 指可以帮助我们编译项目、打包项目（可以帮助我们把自己的项目打包成一个.jar文件）、安装项目、部署项目
      • 依赖管理
        • 当我们的项目变得复杂之后，项目中的依赖越来越多，管理起来也越来越复杂，Maven可以帮助我们去管理这些依赖。

    安装Maven

    版本说明：

    • JDK：1.8
    • Maven：https://maven.apache.org/download.cgi（不要下最新版本）

    解压：

    • 证明安装成功 证明安装成功

    配置环境变量：

    • 打开高级系统设置，配置系统变量
      • 在这里插入图片描述
    • 配置环境变量
      • 在这里插入图片描述
        最后在cmd中输入mvn -v，查看当前版本

    Maven的工作流程

    传统写代码的问题：

    1. jar包反复存储，占用空间
    2. 手动管理，容易混乱

    Maven的工作流程图：

    在这里插入图片描述

    • 本地仓库：其实就是本地存放Jar包的一个路径，统一的集中式的去管理本地的所有jar包
    • 中央仓库：中央仓库其实就是Maven 提供的一个仓库，里面收录了世界上所有的开源的jar包，但是在国外，网速慢。
    • 镜像仓库：阿里等公司会去定期同步中央仓库，把中央仓库的内容同步过来。这样我们后续在下载jar包的时候，就可以让他指定去镜像仓库下载，这样下载的速度就会比较快。

    配置Maven

    • 配置settings.xml
      • 在conf文件里
      • 配置本地仓库的路径
        在这里插入图片描述
      • 配置镜像仓库
        在这里插入图片描述
      • 配置JDK的编译版本
        在这里插入图片描述

    源码：

    <settings>
	...
    <mirrors>
        <mirror>
        	<id>nexus-aliyunid>
        	<mirrorOf>centralmirrorOf>
        	<name>Nexus aliyunname>
        	<url>http://maven.aliyun.com/nexus/content/groups/publicurl>
        mirror>
    mirrors>
    ...

settings>

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

<settings>
	...
    <profiles>
        <profile>
                <id>jdk-1.8id>
                <activation>
                    <activeByDefault>trueactiveByDefault>
                    <jdk>1.8jdk>
                activation>
                <properties>
                    <maven.compiler.source>1.8maven.compiler.source>
                    <maven.compiler.target>1.8maven.compiler.target>
                    <maven.compiler.compilerVersion>1.8maven.compiler.compilerVersion>
                properties>
        profile>
    profiles>
    ...
settings>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 配置idea
      • 在Settings中搜索Maven
        在这里插入图片描述
      • Other Settings —> Settings for New Projects —> Maven
        在这里插入图片描述

    Maven的使用

    Maven工程的要求：

    1. 在项目的根路径下，有一个pom.xml文件

    2. 工程目录是如下的结构：

    • ProjectName

      • src（src里面不直接写包）
        • main
          • java（写代码的地方，指源代码的路径）
          • resources（配置文件地方，指配置文件的路径）
        • test
          • java（单元测试代码，指测试类的存放路径）
          • resources（单元测试的配置文件，指测试类需要用到的文件）

    • pom.xml（在项目的根目录下）

    eg：
    在这里插入图片描述


    怎么把一个项目转换成maven项目：

    1. 在src里面建几个包
      • src/main/java
        • mark as sources
      • src/main/resources
        • mark as resources
      • src/test/java
      • src/test/resources
    2. 创建一个pom.xml
    3. 对着pom.xml点击add as maven project

    怎么通过idea创建一个Maven项目：

    在这里插入图片描述

    • GroupId：指公司名、组织名
      • eg：com.coo1heisenberg
    • ArtifactId：项目名
      • eg：test_maven

    module和project的关系

    • project

      一个项目是IDEA开发工作的顶级组织单位。在其完成的形式中，一个项目可能代表一个完整的软件解决方案
      项目是以下内容的集合：

      • 工作成果：源代码、脚本、配置文件、文档、包等。
      • 用于开发、编译、运行和测试代码的SDK和库。
      • 在项目上下文中表示你的工作偏好设置
        • 一个项目有一个或者多个模块作为其部件

    • module

      • 模块是项目的一部分，你可以独立的编译、运行、测试和调试。
      • 模块是一种在维护公共项目配置的同事降低大型项目复杂性的方法。
      • 模块可以重复使用：如果需要，可以再多个项目中包含一个模块。

    如何用Maven导包

    1. 打开https://mvnrepository.com/。搜索要用的包，找到指定的版本
    2. 拷贝坐标
      • groupId、artifactId、version 叫做坐标，可以唯一确定一个包
    3. 只需要在 pom.xml文件中声明jar包的坐标就可以了，添加了之后点击 import changes

    eg：
    在这里插入图片描述

    如何用Maven进行项目构建

    指令介绍

    项目构建其实就是 Maven可以帮助我们去检查项目，编译项目，测试项目，打包项目，安装项目，部署项目

    在这里插入图片描述

    clean指令

    Maven指令的执行依赖于一些jar包

    • 方式一：通过cmd执行
      在这里插入图片描述
    • 方式二：通过idea自带的命令行执行
      • 得以管理员身份打开idea，否则识别不出mvn命令
        在这里插入图片描述
    • 方式三：直接使用maven的可视化插件（常用）
      在这里插入图片描述

    compile指令

    • compile是编译的意思，可以帮助我们生成一个target文件夹
    • 以后，只能在java文件夹中写代码，在resources文件夹里面，写配置文件
      • 在src/main/java中的代码，会编译到target/classes里面
      • 在src/main/java中的配置文件、其他文件，不会进入到target/classes里面
      • 在src/main/resources中的代码，会拷贝到target/classes里面
    • test文件是运行单元测试的，只会运行test文件里面java的单元测试
      • 先引入Maven中的Junit
      • Assert.assertEquals()：在单元测试里面，使用Assert断言帮我们完成自动化的检验工作
    
<dependency>
    <groupId>junitgroupId>
    <artifactId>junitartifactId>
    <version>4.12version>
    <scope>testscope>
dependency>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    package指令

    package可以帮助我们把项目打包

    • 打包的名字：artifactId-version.jar（是artifactId加上文件的版本）
    • 打包的格式：

      • jar

        • 默认的打包格式

      • war

        • 需要指定
        • 指定的格式为：
    
<packaging>jarpackaging>

    • 1
    • 2

    install指令

    • install命令可以帮助我们把package生成的jar包复制到本地仓库中
    • 需要掌握根据 groupId、artifactId 、version找本地的jar
      eg：在这里插入图片描述

    Maven的依赖管理

    如何导包

    按照上面说到的三步流程执行即可

    scope作用域

    每个依赖包都有自己作用范围
    XXX
    eg：

    在这里插入图片描述

    • test
      • 仅仅在测试包（src/test/java）路径下有效，在 src/main/java路径下失效。
    • provided
      • 在编译的时候生效，在运行的时候失效
    • runtime
      • 在编译的时候失效，在运行的时候生效
      • 最常见的是：数据库的驱动包
      • 设计原因：就是防止写代码的时候，用了MySQL特有的类，切数据库的时候不好操作
    • compile
      • 默认的作用域
      • 在编译和运行的时候都生效

    依赖传递

    • 指依赖具有传递性
    • eg：引入了commons-dbcp，而commons-dbcp又引入了commons-pool
      在这里插入图片描述

    依赖冲突

    • 当在同一个项目中，导入同一个依赖的不同的版本，就会有冲突的问题。
      在这里插入图片描述
    • 如何解决依赖冲突
      • 声明优先原则
        • 是指这同一个项目的不同的版本的jar包，声明优先仅仅指的是第二级后面的依赖，谁先在pom.xml中声明，以谁为准
        • 如果在pom.xml里，同时依赖了两个版本。是以最后一个指定的为准
      • 就近原则
        • 在进行依赖传递的时候，谁传递的次数比较少，以谁为准
        • 就近原则的优先级高于声明优先原则
      • 手动排除
        • 手动去排除传递过来的依赖

    eg：

    <dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-contextartifactId>
    <version>5.3.22version>
dependency>

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-jdbcartifactId>
    <version>5.3.13version>
dependency>

其中：
spring-context依赖了spring-beans（5.3.22） 优先！！！
spring-jdbc依赖了spring-beans（5.3.13）


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

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-jdbcartifactId>
    <version>5.3.13version>
dependency>

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-jdbcartifactId>
    <version>5.3.22version>
dependency>（优先！！！）


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

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-jdbcartifactId>
    <version>5.3.4version>

	
    <exclusions>
        <exclusion>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-beansartifactId>
        exclusion>

        <exclusion>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-coreartifactId>
        exclusion>
    exclusions>
    
dependency>


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 提取常量
      • 这个是一个避免依赖冲突的方法。是后面工作中主要推荐的做法。
      • 常量名字不要随便取

    eg：

        <properties>
		
		
        <spring.version>5.3.3spring.version>
        <mysql.version>5.1.47mysql.version>
        <druid.version>1.2.6druid.version>
    
    
    properties>


    <dependencies>



        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-jdbcartifactId>
            <version>${spring.version}version>
        dependency>


        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>${spring.version}version>
        dependency>


        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-beansartifactId>
            <version>${spring.version}version>
        dependency>


        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>${mysql.version}version>
        dependency>


        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>druidartifactId>
            <version>${druid.version}version>
        dependency>
        
    dependencies>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54

    使用Maven开发项目


    路径问题的建议：

    1. 不要用绝对路径
    2. 最好使用类加载器的方式去读文件

    切换成Maven之后，开发模式的变化：

    1. 之前需要手动下jar包，拷贝，添加到库文件；现在只用引入坐标
    2. 之前读配置文件，使用new FileInputStream()；现在读配置文件，需要用classLoader，配置文件的位置需要在src/main/resource

    eg：
    以连接池中的druid举例：

    public class druidDemo {
    public static void main(String[] args) throws Exception {
        testNormal();
    }

    private static void testNormal() throws Exception {

        Properties properties = new Properties();


        // 1. 绝对路径不要使用
        //  properties.load(new FileInputStream("druid.properties"));

        ClassLoader classLoader = druidDemo.class.getClassLoader();
        // 现在配置文件 需要用classLoader拿

        // 通过类加载器拿文件，会通过target/classes里面拿
        URL resource = classLoader.getResource("druid.properties");

        properties.load(new FileInputStream(resource.getPath()));

        // 或者
        // properties.load(classLoader.getResourceAsStream("druid.properties"));

        DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);

        Connection connection = dataSource.getConnection();

        Statement statement = connection.createStatement();

        boolean execute = statement.execute("insert into t_staff(name) values ('zs')");

        System.out.println(execute);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    
<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.0modelVersion>
    <parent>
        <groupId>com.coo1heisenberggroupId>
        <artifactId>test_mavenartifactId>
        <version>1.0-SNAPSHOTversion>
    parent>

    <artifactId>module1artifactId>

    <properties>
        <maven.compiler.source>8maven.compiler.source>
        <maven.compiler.target>8maven.compiler.target>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>

        <druid.version>1.2.6druid.version>

    properties>
    <dependencies>
        
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>druidartifactId>
            <version>${druid.version}version>
        dependency>

        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>8.0.16version>
            <scope>runtimescope>
        dependency>
    dependencies>

project>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/test?
characterEncoding=utf8&useSSL=false&serverTimezone=UTC
username=root
password=123456

    • 1
    • 2
    • 3
    • 4
    • 5

    Junit

    Junit是一个被广泛使用的测试工具，可以帮助我们运行我们指定的方法

    如何使用Junit

    • 导包
    <dependency>
    <groupId>junitgroupId>
    <artifactId>junitartifactId>
    <version>4.12version>
dependency>

    • 1
    • 2
    • 3
    • 4
    • 5

    • 使用

      • @Test
      • @After
        • 修饰的方法会在测试方法运行之后执行
        • 在每一次测试方法的前后都会运行
        • 一般用来准备数据
      • @Before
        • 修饰的方法会在测试方法运行之前执行
        • 在每一次测试方法的前后都会运行
        • 一般用来销毁数据
      • @BeforeClass
      • @AfterClass

    • 使用的注意事项：

      • @BeforeClass和@AfterClass修饰的方法必须是静态的
      • @Test注解修饰的方法必须是public、必须是void、必须没有参数
      • 测试类必须在 src/test/java 路径下
      • 测试类的命名必须叫做 XxxTest
      • 测试方法（@Test注解修饰的方法）的命名必须叫做 testXxx();

    • 使用断言语句，来完成结果的确认

    @Test
public void test1() {
    // 在单元测试里面，使用Assert 断言帮我们完成自动化的检验工作。
    Assert.assertEquals(new Integer(3), max);
}

    • 1
    • 2
    • 3
    • 4
    • 5
  • 相关阅读:
    中兴路由器、小米路由器无线信号强度对比
    691 页，41 个版块！终于有阿里大佬可以带我吃透 Spring 源码了
    Redis中间件（从搭建到弃坑）
    Linux服务搭建 -- NTP服务
    window安装ELK
    软考 - 标准化与知识产权基础知识
    使用代理对象执行实现类目标方法异常
    Java基础：通过Callable创建多线程
    React知识点系列（2）-每天10个小知识
    数据结构（5）树形结构——二叉搜索树（JAVA代码实现）
  • 原文地址：https://blog.csdn.net/weixin_43357398/article/details/136480100