maven打包以及groovy环境的搭建

groovy与maven的基础知识不再赘述,以下只描述一些关键点

1.在maven中引入groovy依赖

例:



<properties>
        <!--在这里控制groovy 版本  -->
       <groovy.version>2.0.8</groovy.version>
       <project.build.sourceEncoding>utf8</project.build.sourceEncoding>
</properties>


<dependencies>
    <dependency>
        <groupId>org.codehaus.groovy</groupId>
        <artifactId>groovy-all</artifactId>
        <version>${groovy.version}</version>
    </dependency>
</dependencies> 

${groovy.version}是自己定义的变量,方便修改groovy版本

注意:书写groovy代码时需要建立src/main/groovy/路径,好处是很多关于groovy的插件会默认读取这个路径下的代码。

除了运行时环境,我们还需要引入groovy的编译依赖,以供mvn package时使用。
例:

            <plugin>
                <groupId>org.codehaus.gmavenplus</groupId>
                <artifactId>gmavenplus-plugin</artifactId>
                <version>1.5</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>execute</goal>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <scripts>
                        <script><![CDATA[// your script here ]]></script>
                    </scripts>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>org.codehaus.groovy</groupId>
                        <artifactId>groovy-all</artifactId>
                        <!-- any version of Groovy \>= 1.5.0 should work here -->
                         <!-- 这个变量用来控制groovy编译版本 -->
                        <version>${groovy.version}</version>
                        <scope>runtime</scope>
                    </dependency>
                </dependencies>
            </plugin>

2.方便快捷的引入本地依赖:

网上有很多方法,最常见的,但是也是最不好用的方式。
例:

<dependencies>
        <dependency>
            <groupId>com.xiaomi</groupId>
            <artifactId>MIPush_SDK_Server</artifactId>
            <version>2.2.17</version>
          <scope>system</scope>        <systemPath>${basedir}/lib/MiPush_SDK_Server_2_2_17.jar</systemPath>
        </dependency>
</dependencies>

这种方式有很多缺点,最明显的缺点就是在打包是时候通常无法把这种本地依赖打入jar包中,并且让maven的依赖引入方式变成了两种:
1.本地依赖直接引入。
2.远程下载到本地仓库的依赖引入。

下面推荐一种正确的引入本地依赖的方式:
使用org.apache.maven.plugins插件,将依赖全部加入的本地maven仓库中,这样这些本地依赖就可以像远程依赖一样的被调用了。

例:

<plugins>
  <!--本地依赖加入本地仓库插件-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-install-plugin</artifactId>
                <version>2.5.2</version>
                <executions>
                    <!--华为推送本地仓库初始化-->
                    <execution>
                        <id>oauth2</id>
                        <!--使用mvn clean时,自动把依赖添加到本地仓库中-->
                        <phase>clean</phase>
                        <configuration>
                         <!--需要加入本地仓库的文件路径-->
                            <file>${basedir}/lib/client-adapter-sdk-java-oauth2-json-0.3.12.jar</file>
                            <repositoryLayout>default</repositoryLayout>
                            <groupId>client-adapter-sdk-java-oauth2-json</groupId>
                            <artifactId>client-adapter-sdk-java-oauth2</artifactId>
                            <version>0.3.12</version>
                            <packaging>jar</packaging>
                            <generatePom>true</generatePom>
                        </configuration>
                        <goals>
                            <goal>install-file</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

</plugins>

运行 mvn clean 本地依赖就会被加入的本地仓库中了,之后的调用方法就和远程依赖相同了。

例:

        <!--华为推送相关依赖-->
        <dependency>
            <groupId>client-adapter-sdk-java-oauth2-json</groupId>
            <artifactId>client-adapter-sdk-java-oauth2</artifactId>
            <version>0.3.12</version>
        </dependency>

3.关于打包

网上有很多打包方式,都是使用插件的方式进行打包,我试了很多,最终选择了maven-assembly-plugin插件。
优势:使用灵活,功能强大,基本可以解决任何打包需求。
缺点:配置过多。

依赖引入
例:

           <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.0.0</version>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>com.rishiqing.PushCenter</mainClass>
                            <addClasspath>true</addClasspath>
                        </manifest>
                    </archive>
                    <descriptors>
   <!--这个是自定义的配置文件,可以进行更详细的参数配置-->                       <descriptor>/src/main/assembly/src.xml</descriptor>
                    </descriptors>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                          <!--指定生命周期-->
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

建立详细配置文件/src/main/assembly/src.xml
例:

<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3 http://maven.apache.org/xsd/assembly-1.1.3.xsd">
    <id>jar-with-dependencies</id>
    <formats>
        <format>jar</format>
    </formats>
    <includeBaseDirectory>false</includeBaseDirectory>
    <moduleSets>
        <moduleSet>
            <binaries>
                <unpack>false</unpack>
            </binaries>
        </moduleSet>
    </moduleSets>
    <dependencySets>
        <dependencySet>
            <unpack>false</unpack>
            <unpackOptions>
                <useDefaultExcludes>false</useDefaultExcludes>
            </unpackOptions>
        </dependencySet>
    </dependencySets>
    <fileSets>
        <fileSet>
            <directory>${project.build.outputDirectory}</directory>
        </fileSet>
    </fileSets>
</assembly>

如果需要了解这个插件的详细配置方法,可以进入官网了解

http://maven.apache.org/plugins/maven-assembly-plugin/usage.html

运行mvn clean package,会在项目/target目录中生成两个打包后的jar包
1.xxxx.jar // 不包含依赖
2.xxxx-jar-with-dependencies.jar // 包含依赖

4.关于新手对于maven标签的使用

注意标签的父子关系
例:

<dependencies>
    <dependency>
        依赖1
    </dependency>
    <dependency>
        依赖2
    </dependency>
</dependencies>


<plugins>
    <plugin>
        插件1
    </plugin>
    <plugin>
        插件2
    </plugin>
</plugins>

加入变量
例:

    <properties>
        <!--在这里控制groovy 版本  -->
        <groovy.version>2.0.8</groovy.version>
        <project.build.sourceEncoding>utf-8</project.build.sourceEncoding>
    </properties>

5.备注

1.关于maven的深入学习方向可以是研究生命周期并且书写自己的maven插件。
2.吐槽:我的这个工程是为了实现移动端推送的功能,研究了很多推送服务商,如:小米推送、极光推送、阿里推送、华为推送等,最终得出的结论是:千万不要使用华为推送!千万不要使用华为推送!千万不要使用华为推送!,重要的事情说3遍!!!

Java搭建流水线实验可以使用一些流行的开发工具和技术,例如: 1. Jenkins:Jenkins是一个开源的自动化构建工具,可以用来构建、测试和部署Java应用程序。 2. Git:Git是一个版本控制系统,可以用来管理Java应用程序的源代码。 3. MavenMaven是一个Java项目管理工具,可以自动化构建、测试和部署Java应用程序。 4. Docker:Docker是一个容器化平台,可以用来打包Java应用程序和其依赖,以便在任何地方运行。 下面是一个简单的Java流水线实验的步骤: 1. 在Jenkins中创建一个新的流水线项目,选择“Pipeline”类型。 2. 设置Git源代码管理,指定要构建的Java应用程序的Git仓库地址和分支。 3. 配置构建环境,包括Java运行时环境Maven构建工具。 4. 编写Jenkinsfile,这是一个Groovy脚本,用于定义流水线的各个阶段和步骤。例如,可以使用Maven构建步骤来编译、测试和打包Java应用程序。 5. 添加Docker构建步骤,将Java应用程序和其依赖打包成Docker镜像,以便在任何地方运行。 6. 配置流水线触发器,例如,可以选择在每次提交到Git仓库时自动触发流水线构建。 7. 启动流水线,等待构建完成。如果构建成功,可以将Docker镜像推送到Docker Hub或私有仓库中,以便在任何地方运行Java应用程序。 这样就完成了一个简单的Java流水线实验。当然,具体的实现步骤还需要根据具体的需求和环境进行调整。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值