精华内容
下载资源
问答
  • maven打包插件配置

    2019-09-06 11:16:57
    一、maven打包可执行jar文件,需要引入插件 <plugin> <artifactId>maven-assembly-plugin</artifactId> <configuration> <appendAssemblyId>false</appendAssemblyId> ...

    一、maven打包可执行jar文件,需要引入插件

    <plugin>
    	<artifactId>maven-assembly-plugin</artifactId>
    	<configuration>
    		<appendAssemblyId>false</appendAssemblyId>
    		<descriptorRefs>
    			<descriptorRef>jar-with-dependencies</descriptorRef>
    		</descriptorRefs>
    		<archive>
    			<manifest>
    				<!-- 此处指定main方法入口的class -->
    				<mainClass>WikipediaAnalysis</mainClass>
    			</manifest>
    		</archive>
    	</configuration>
    	<executions>
    		<execution>
    			<id>make-assembly</id>
    			<phase>package</phase>
    			<goals>
    				<goal>assembly</goal>
    			</goals>
    		</execution>
    	</executions>
    </plugin>

    二、maven打包指定本地jar包

    <plugin>
    	<groupId>org.apache.maven.plugins</groupId>
    	<artifactId>maven-jar-plugin</artifactId>
    	<configuration>
    		<archive>
    			<manifest>
    				<addClasspath>true</addClasspath>
    				<classpathPrefix>lib/</classpathPrefix>
    				<mainClass>WikipediaAnalysis</mainClass>
    			</manifest>
    		</archive>
    	</configuration>
    </plugin>
    <!-- 拷贝依赖的jar包到lib目录 -->
    <plugin>
    	<groupId>org.apache.maven.plugins</groupId>
    	<artifactId>maven-dependency-plugin</artifactId>
    	<executions>
    		<execution>
    			<id>copy</id>
    			<phase>package</phase>
    			<goals>
    				<goal>copy-dependencies</goal>
    			</goals>
    			<configuration>
    				<outputDirectory>
    					${project.build.directory}/lib
    				</outputDirectory>
    			</configuration>
    		</execution>
    	</executions>
    </plugin>
    

     

    展开全文
  • Maven打包插件maven-assembly-plugin配置

    千次阅读 2018-11-13 19:40:56
    Maven打包插件maven-shade-plugin配置在pom.xml文件中的配置新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定...


    前段时间使用maven和spring boot和同事一起构建了一个项目,最初为了调用spring boot服务,我们重新构建了一个普通的java项目(只能算是小程序吧)。但是由于这个小项目与我们主体的服务项目不在同一个项目中,管理上比较麻烦。前段时间经过重新构建,将这个调用服务的小项目作为一个模块添加到了我们整个的项目中。
    随之而来了一个新问题是这个小模块如何单独导出为一个可执行的程序,经过研究后,我们采用maven的打包插件,成功实现了功能,这个插件就是maven-assembly-plugin。(注意:本篇中使用的插件版本号为2.6)

    简单配置相关说明

    在pom.xml文件中的配置

    相关配置内容现在是这样的

    	<build>
    		<finalName>batch-invoke</finalName>
    		<!--打包可执行jar包插件 -->
    		<plugins>
    			<plugin>
    				<groupId>org.apache.maven.plugins</groupId>
    				<artifactId>maven-assembly-plugin</artifactId>
    				<executions>
    					<execution>
    						<phase>package</phase>
    						<goals>
    							<goal>single</goal>
    						</goals>
    						<configuration>
    							<archive>
    								<manifest>
    									<mainClass>com.dhc.bath.invoke.RemoteBatchInvokeMain</mainClass>
    								</manifest>
    							</archive>
    							<descriptorRefs>
    								<descriptorRef>jar-with-dependencies</descriptorRef>
    							</descriptorRefs>
    						</configuration>
    					</execution>
    				</executions>
    			</plugin>
    		</plugins>
    	</build>
    

    相关标签解释

    finaName标签内容指打包后文件名称

    <finalName>batch-invoke</finalName>
    

    groupId

    <groupId>org.apache.maven.plugins</groupId>
    

    artifactId标签为assembly插件固定写法,表示项目使用maven的assembly插件

    <artifactId>maven-assembly-plugin</artifactId>
    

    phase标签指定使用assembly插件的周期(阶段),通常为package

    <phase>package</phase>
    

    goal标签用于指定执行方式

    <goal>single</goal>
    

    mainClass标签指定jar包主程序入口

    <mainClass>com.dhc.bath.invoke.RemoteBatchInvokeMain</mainClass>
    

    descriptorRef标签定义打包方式,官方提供的格式有bin, jar-with-dependencies, src, project
    bin : 类似于默认打包,会将bin目录下的文件打到包中
    jar-with-dependencies : 会将所有依赖都解压打包到生成物中
    src :只将源码目录下的文件打包
    project : 将整个project资源打包

    <descriptorRef>jar-with-dependencies</descriptorRef>
    

    结果展示

    使用maven命令直接打包,或在eclipse中运行maven的package命令打包该项目,在项目路径的target目录中会生成两个jar包,名称分别为batch-invoke.jar和batch-invoke-jar-with-dependencies.jar
    其中batch-invoke.jar中只包含项目自身编写的类文件,不包括项目引用其他jar包的内容;batch-invoke-jar-with-dependencies.jar则包括项目自身编写的程序及引入到项目中的其他jar包的程序。
    在当前简单配置的模式下,打包成的两个jar包内容格式类似,直接将所有需要打包的程序、配置文件等放在第一层目录中,并在目录中生成META-INF文件夹及相关配置。
    由于指定了manifest标签,所以打包完成后的batch-invoke-jar-with-dependencies.jar可以直接运行

    自定义配置说明

    自定义配置文件关联

    在pom.xml文件中assembly插件相关配置下,configuration标签下的descriptors标签中配置自顶配置文件,可以配置多个配置文件,同时进行打包处理。自定义配置文件需要在descriptor标签中,使用相对路径即可。

    <configuration>
    					<!--配置描述文件路径-->
    					<descriptors> 
    						<descriptor>src/main/resources/assembly-run-jar.xml</descriptor>
    					</descriptors>
    				</configuration>
    

    自定义配置文件的设置

    <id>assembly</id>
    	<formats>
    		<format>jar</format>
    	</formats>
    	<!--是否生成和项目名相同的根目录 -->
    	<includeBaseDirectory>false</includeBaseDirectory>
    	<dependencySets>
    		<dependencySet>
    			<outputDirectory>/</outputDirectory>
    			<unpack>true</unpack>
    			<scope>runtime</scope>
    			<!--
    			<includes>
    				<include>${groupId}:${artifactId}</include>
    			</includes>
    			<excludes>
    				<exclude>${groupId}:${artifactId}</exclude>
    			</excludes>
    			-->
    		</dependencySet>
    	</dependencySets>
    

    id
    id 标识符,添加到生成文件名称的后缀符。如果指定 id 的话,生成文件名格式为 artifactId{artifactId}-{id}.${formats.format}

    formats
    打包格式,支持zip、tar、tar.gz (or tgz)、tar.bz2 (or tbz2)、jar、dir、war,可以同时指定多个打包格式

    <formats>
    	<format>tar.gz</format>
    	<format>dir</format>
    </formats>
    

    dependencySets
    用来定制工程依赖 jar 包的打包方式,核心元素如下表所示。

    元素 类型 作用
    outputDirectory String 指定包依赖目录,该目录是相对于根目录
    includes/include* List< string> 包含依赖
    excludes/exclude* List< String> 排除依赖

    fileSets
    管理一组文件的存放位置,核心元素如下表所示。

    元素 类型 作用
    outputDirectory String 指定文件集合的输出目录,该目录是相对于根目录
    includes/include* List< String> 包含文件
    excludes/exclude* List< String> 排除文件
    fileMode String 指定文件属性,使用八进制表达,分别为(User)(Group)(Other)所属属性,默认为 0644

    其他注意事项

    需要注意,指定运行主程序后,默认自动化打包生成的文件可以正常运行,但是如果使用插件自定义输出目录以后,由于插件无法自动添加目录或者文件路径的跟踪配置,有可能会导致生成的文件无法运行
    默认情况下,插件会形成两个打包文件,一个包含依赖关系的,一个不包括依赖关系文件的

    插件官方文档地址

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

    展开全文
  • Maven打包

    用于把所有依赖包打进jar中:
    pom.xml添加节点

    <build>
            <plugins>
                <plugin>
                    <artifactId>maven-assembly-plugin</artifactId>
                    <configuration>
                        <archive>
                            <manifest>
                                <mainClass>xx.xx.xxx</mainClass>
                            </manifest>
                        </archive>
                        <descriptorRefs>
                            <descriptorRef>jar-with-dependencies</descriptorRef>
                        </descriptorRefs>
                    </configuration>
                </plugin>
    
    
                <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>
    
    展开全文
  • 自定义Maven打包插件

    2020-12-21 23:28:00
    自定义Maven打包插件实战 打包业务描述:   打包时,根据需要打包的模块.json配置文件,动态打入自己需要的Controller,排除掉不需要的模块Controller类。 打包插件设计思路: 插件使用如下: 一 、先

    前言

      Maven大家都很熟悉,插件也非常丰富。比如它的打包插件maven-assembly-plugin可以根据模板配置自己想要的打包内容,但当它的模板配置无法满足自己定制化打包需求时,此时就需要我们将maven研究的更深入些,利用自定义maven插件去实现我们自己的打包逻辑。

    自定义Maven打包插件实战

    打包业务描述:

      打包时,根据需要打包的模块.json配置文件,动态打入自己需要的Controller,排除掉不需要的模块Controller类。

    打包插件设计思路:

    在这里插入图片描述

    插件使用如下:

    在这里插入图片描述

    一 、先创建Maven项目,编写pom.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <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.0</modelVersion>
    
        <groupId>org.example</groupId>
        <artifactId>pre-maven-plugin</artifactId>
        <packaging>maven-plugin</packaging>
        <version>1.0-SNAPSHOT</version>
    
        <properties>
            <maven.compiler.source>8</maven.compiler.source>
            <maven.compiler.target>8</maven.compiler.target>
            <maven.plugin.api>3.5.0</maven.plugin.api>
            <maven-plugin-annotations>3.5.2</maven-plugin-annotations>
            <reflections.version>0.9.10</reflections.version>
            <fastjson.version>1.2.58</fastjson.version>
            <lombok.version>1.18.16</lombok.version>
            <commons-io.version>2.6</commons-io.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.apache.maven</groupId>
                <artifactId>maven-plugin-api</artifactId>
                <version>${maven.plugin.api}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.maven.plugin-tools</groupId>
                <artifactId>maven-plugin-annotations</artifactId>
                <version>${maven-plugin-annotations}</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>org.reflections</groupId>
                <artifactId>reflections</artifactId>
                <version>${reflections.version}</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>${fastjson.version}</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>commons-io</groupId>
                <artifactId>commons-io</artifactId>
                <version>${commons-io.version}</version>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-plugin-plugin</artifactId>
                    <version>3.6.0</version>
                </plugin>
            </plugins>
        </build>
    
    
    </project>
    

    注意:maven插件的 packaging 必须是maven-plugin,其次是需要依赖的jar包maven-plugin-api、maven-plugin-annotations。

    二、编写插件实现类

    package mojo;
    
    import com.alibaba.fastjson.JSON;
    import dto.Module;
    import lombok.Data;
    import org.apache.commons.lang3.StringUtils;
    import org.apache.maven.plugin.AbstractMojo;
    import org.apache.maven.plugin.MojoExecutionException;
    import org.apache.maven.plugin.MojoFailureException;
    import org.apache.maven.plugins.annotations.LifecyclePhase;
    import org.apache.maven.plugins.annotations.Mojo;
    import org.apache.maven.plugins.annotations.Parameter;
    
    import java.io.File;
    import java.io.IOException;
    import java.lang.annotation.Annotation;
    import java.lang.reflect.Method;
    import java.nio.file.Files;
    import java.text.MessageFormat;
    import java.util.*;
    import util.*;
    
    /**
     * @author zkc
     * @version 1.0.0
     * @since 2020-12-21
     */
    @Mojo(name = "jwfRepackage", defaultPhase = LifecyclePhase.PACKAGE)
    @Data
    public class ZkcRepackageMojo extends AbstractMojo {
        /**
         * 应用的模块json配置文件,支持“,”逗号分隔多个应用
         */
        @Parameter(required = true)
        private String applicationModuleJson;
        /**
         * 配置应用模块json所在文件夹名称,默认application
         */
        @Parameter
        private String applicationFolderName = "application";
        /**
         * maven编译时classes路径,只读,不需要手动配置
         */
        @Parameter(defaultValue = "${project.compileClasspathElements}", readonly = true, required = true)
        private List<String> compilePath;
        /**
         * maven项目中版本号,只读,不需要手动配置
         */
        @Parameter(defaultValue = "${project.version}", readonly = true, required = true)
        private String projectVersion;
        /**
         * maven项目中artifactId,只读,不需要手动配置
         */
        @Parameter(defaultValue = "${project.artifactId}", readonly = true, required = true)
        private String artifactId;
    
    
        @Override
        public void execute() throws MojoExecutionException, MojoFailureException {
    
            long startTime = System.currentTimeMillis();
            System.out.println(MessageFormat.format("自定义分模块打包插件开始执行:[{0}]", startTime));
    
            // 解析应用模块json配置文件
            List<Module> moduleList = analysisApplicationModuleJson(StringUtils.split(applicationModuleJson, ","));
            if (CommonUtil.isCollectionEmpty(moduleList)) {
                System.out.println(MessageFormat.format("应用模块json解析为空:maven编译地址[{0}],应用模块json地址[{1}]", String.join(",", compilePath), applicationModuleJson));
                return;
            }
    
            // 自定义类加载器,加载原始jar包,过滤出非应用的模块Controller类
            String moduleJarPath = PathUtil.buildJarPath(compilePath) + PathUtil.buildJarName(artifactId, projectVersion);
            Set<String> excludeClasses = getExcludeClasses(moduleJarPath, moduleList);
            if (CommonUtil.isCollectionEmpty(excludeClasses)) {
                long endTime = System.currentTimeMillis();
                System.out.println(MessageFormat.format("自定义分模块打包插件结束执行,没有需要排除的模块Class,耗时:[{0}]毫秒", endTime - startTime));
                return;
            }
    
            // 删除无用的应用模块Controller类,重新打包
            try {
                JarUtil.delete(moduleJarPath, excludeClasses);
            } catch (Exception e) {
                System.out.println(MessageFormat.format("删除无用应用模块Controller类,重新打包失败:[{0}],[{1}]", moduleJarPath, excludeClasses));
                e.printStackTrace();
            }
    
            long endTime = System.currentTimeMillis();
            System.out.println(MessageFormat.format("自定义分模块打包插件结束执行,供排除[{0}]个非应用模块Class,耗时:[{1}]毫秒", excludeClasses.size(), endTime - startTime));
    
        }
    
        /**
         * 解析应用模块json配置文件
         *
         * @param moduleJsons 应用模块json配置地址
         * @return 返回解析后的模块集合
         */
        private List<Module> analysisApplicationModuleJson(String[] moduleJsons) {
            if (CommonUtil.isArrayEmpty(moduleJsons) || CommonUtil.isCollectionEmpty(compilePath)) {
                return null;
            }
            List<Module> moduleList = new ArrayList<>();
            Arrays.stream(moduleJsons).forEach(moduleJson -> {
                String moduleJsonPath = PathUtil.buildModuleJsonPath(compilePath, moduleJson, applicationFolderName);
                File jsonFile = new File(moduleJsonPath);
                if (!jsonFile.exists()) {
                    System.out.println(MessageFormat.format("应用模块json文件未找到:[{0}]", moduleJsonPath));
                }
                try {
                    List<Module> moduleListTemp = JSON.parseArray(new String(Files.readAllBytes(jsonFile.toPath())),
                            Module.class);
                    moduleList.addAll(moduleListTemp);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
            return moduleList;
        }
    
        /**
         * 自定义类加载器,加载原始jar包,过滤出非应用的模块Controller类
         *
         * @param moduleJarPath 原始jar包路径
         * @param moduleList    应用模块类集合
         * @return 返回需要过滤的模块类
         */
        @SuppressWarnings("unchecked")
        private Set<String> getExcludeClasses(String moduleJarPath, List<Module> moduleList) {
            Set<String> excludeClasses = new HashSet<>();
            ModuleClassLoader moduleClassLoader = new ModuleClassLoader(moduleJarPath);
            ModuleClassLoader.getModuleClassMap().forEach((className, bytes) -> {
                // 解析@ModuleController注解
                try {
                    Class clazz = moduleClassLoader.loadClass(className);
                    Annotation[] annotations = clazz.getAnnotationsByType(moduleClassLoader.loadClass(PathUtil.MODULE_CLASS));
                    for (Annotation annotation : annotations) {
                        Class aClass = annotation.getClass();
                        try {
                            Method method = aClass.getMethod(PathUtil.MODULE_METHOD);
                            String value = (String) method.invoke(annotation);
                            boolean moduleClassFlag = moduleList.stream().anyMatch(module -> Objects.equals(module.getModuleId(), value));
                            if (!moduleClassFlag) {
                                excludeClasses.add(className);
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                } catch (ClassNotFoundException e) {
                    System.out.println(MessageFormat.format("加载[{0}]类报错,因未加载对应jar包,可忽略", className));
                }
            });
            return excludeClasses;
        }
    
    }
    
    

    注意:maven插件支持注解方式和Javadoc 方式开发,本实战中使用注解方式@Mojo指定插件的目标类和插件的运行阶段。

    三、自定义类加载

    package util;
    
    import org.apache.commons.lang3.StringUtils;
    
    import java.io.*;
    import java.text.MessageFormat;
    import java.util.*;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.jar.JarEntry;
    import java.util.jar.JarFile;
    
    /**
     * @author zkc
     * @version 1.0.0
     * @since 2020-12-21
     */
    public class ModuleClassLoader extends ClassLoader {
    
        private final static Map<String, byte[]> MODULE_CLASS_MAP = new ConcurrentHashMap<>();
    
        public ModuleClassLoader(String moduleJarPath) {
            try {
                readJar(moduleJarPath);
            } catch (IOException e) {
                System.out.println(MessageFormat.format("读取jar包异常:地址[{0}]", moduleJarPath));
                e.printStackTrace();
            }
        }
    
        public static void addClass(String className, byte[] byteCode) {
            if (!MODULE_CLASS_MAP.containsKey(className)) {
                MODULE_CLASS_MAP.put(className, byteCode);
            }
        }
    
        /**
         * 遵守双亲委托规则
         *
         * @param name 类全路径
         * @return 返回类字节码对象
         */
        @Override
        protected Class<?> findClass(String name) {
            try {
                byte[] result = getClass(name);
                if (result != null) {
                    return defineClass(name, result, 0, result.length);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        private byte[] getClass(String className) {
            return MODULE_CLASS_MAP.getOrDefault(className, null);
        }
    
        private void readJar(String moduleJarPath) throws IOException {
            readJarFile(moduleJarPath);
        }
    
        private void readJarFile(String moduleJarPath) throws IOException {
            File file = new File(moduleJarPath);
            if (!file.exists()) {
                throw new FileNotFoundException();
            }
            JarFile jarFile = new JarFile(file);
            Enumeration<JarEntry> enumeration = jarFile.entries();
            while (enumeration.hasMoreElements()) {
                JarEntry jarEntry = enumeration.nextElement();
                String name = jarEntry.getName().replace("BOOT-INF/classes/", "").replace("\\", ".")
                        .replace("/", ".");
                if (isRead(name)) {
                    String className = name.replace(".class", "");
                    try (InputStream input = jarFile.getInputStream(jarEntry); ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
                        int bufferSize = 1024;
                        byte[] buffer = new byte[bufferSize];
                        int bytesNumRead;
                        while ((bytesNumRead = input.read(buffer)) != -1) {
                            baos.write(buffer, 0, bytesNumRead);
                        }
                        addClass(className, baos.toByteArray());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
        private boolean isRead(String name) {
            return StringUtils.isNotBlank(name) && name.endsWith(PathUtil.CLASS)
                    && (name.startsWith(PathUtil.COMMON_CONTROLLER) || name.startsWith(PathUtil.COMMON_ANNOTATION));
        }
    
        public static Map<String, byte[]> getModuleClassMap() {
            return MODULE_CLASS_MAP;
        }
    }
    
    
    

    注意:maven插件运行时,插件的运行环境中类加载器肯定只会加载插件本身的class信息。如果你想操作应用的类,需要自定义类加载器,通过一定的寻址逻辑找到你想加载的jar包,自行加入到插件的运行环境中。

    四、备份原始springboot的jar包,生成新jar包

    package util;
    
    import org.apache.commons.io.FileUtils;
    
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.InputStream;
    import java.text.MessageFormat;
    import java.util.Enumeration;
    import java.util.Set;
    import java.util.jar.JarEntry;
    import java.util.jar.JarFile;
    import java.util.jar.JarOutputStream;
    
    /**
     * @author zkc
     * @version 1.0.0
     * @since 2020-12-21
     */
    public class JarUtil {
    
        public static void delete(String jarName, Set<String> deletes) throws Exception {
            // 先备份原始jar包
            File oriFile = new File(jarName);
            if (!oriFile.exists()) {
                System.out.println(MessageFormat.format("排除类时,原始jar包不存在[{0}]", jarName));
                return;
            }
            // 以时间戳重命名备份文件名
            String bakJarName = jarName.substring(0, jarName.length() - 3) + System.currentTimeMillis() + PathUtil.JAR;
            File bakFile = new File(bakJarName);
            // 备份原始jar包
            FileUtils.copyFile(oriFile, bakFile);
            // 排除deletes中的class,重新打包新jar包文件
            JarFile bakJarFile = new JarFile(bakJarName);
            JarOutputStream jos = new JarOutputStream(new FileOutputStream(jarName));
            Enumeration<JarEntry> entries = bakJarFile.entries();
            while (entries.hasMoreElements()) {
                JarEntry entry = entries.nextElement();
                String name = entry.getName().replace("BOOT-INF/classes/", "").replace("\\", ".").replace("/", ".").replace(".class", "");
                if (!deletes.contains(name)) {
                    InputStream inputStream = bakJarFile.getInputStream(entry);
                    jos.putNextEntry(entry);
                    byte[] bytes = readStream(inputStream);
                    jos.write(bytes, 0, bytes.length);
                } else {
                    System.out.println(MessageFormat.format("排除非应用模块类:[{0}]", entry.getName()));
                }
            }
            // 关闭流
            jos.flush();
            jos.finish();
            jos.close();
            bakJarFile.close();
        }
    
        private static byte[] readStream(InputStream inStream) throws Exception {
            ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len = -1;
            while ((len = inStream.read(buffer)) != -1) {
                outSteam.write(buffer, 0, len);
            }
            outSteam.close();
            inStream.close();
            return outSteam.toByteArray();
        }
    
    }
    
    

    五、自定义模块注解类

    package com.zkc.web.annotation;
    
    import java.lang.annotation.*;
    
    /**
     * @author zkc
     * @version 1.0.0
     * @since 2020-12-21
     */
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Module {
    
        String moduleId();
    
        String moduleName();
    
    }
    
    

    插件运行效果

    [INFO] 
    [INFO] --- pre-maven-plugin:1.0-SNAPSHOT:jwfRepackage (default) @ web ---
    自定义分模块打包插件开始执行:[1,608,560,919,883]
    排除非应用模块类:[BOOT-INF/classes/com/zkc/web/controller/ProductController.class]
    排除非应用模块类:[BOOT-INF/classes/com/zkc/web/controller/RoleController.class]
    自定义分模块打包插件结束执行,供排除[2]个非应用模块Class,耗时:[153]毫秒
    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    

    完整代码以上传码云

    码云地址: git地址


    我的专栏

    1. 设计模式
    2. 认证授权框架实战
    3. java进阶知识
    4. maven进阶知
    5. spring进阶知识
    展开全文
  • Maven 打包插件说明

    千次阅读 2019-07-26 11:24:15
    maven打包,首先在pom文件中加上build属性,和dependencies是同级的: <build> <!--打包出来的文件名,可以不填写,有默认值--> <finalName>Test</finalName> <plugins> <!--...
  • Maven配置打包插件

    2020-11-07 15:15:08
    Maven配置打包插件 总所周知,Maven本身的打包插件不负责将依赖的jar包一并打入到jar包中。如果项目所依赖的jar包在服务器环境中提供了还好,如果服务器环境中没有提供,则比较悲惨,运行各种ClassNotFound….你们懂...
  • maven打包插件之assmebly

    2021-05-20 19:31:03
    文章目录1 assmebly1.1 assmebly简介1.2 assmebly配置1.2.1 maven配置1.2.2 maven标签1.2.2.1 configuration标签说明1.2.3 assembly.xml配置1.2.4 assembly标签1.2.4.1 id标签1.2.4.2 formats标签1.2.4.3 ...
  • maven打包插件解释

    2019-08-23 16:16:57
    <build> <finalName>Spring_boot</finalName> <plugins>...--配置jar包相关属性--> <plugin> <groupId>org.apache.maven.plugins</groupId> ...
  • Maven 打包插件的pom.xml配置

    千次阅读 2015-08-31 16:13:10
    ${projectName} org.apache.maven.plugins maven-resources-plugin true
  • Maven打包插件Assembly 1.在dubbo的provider项目(实现类项目)中pom.xml配置assembly插件信息 <build> <plugins> <!-- 指定项目的打包插件信息 --> <plugin> <artifactId...
  • Spring Boot的Maven插件(Spring Boot Maven plugin)能够以Maven的方式为应用提供Spring Boot的支持,即为Spring Boot应用提供了执行Maven操作的可能。 spring-boot-maven-plugin能够将Spring Boot应用打包为可执行...
  • maven打包配置

    2020-02-17 16:17:33
    springboot项目maven打包配置: 1,配置打包类型: <packaging>jar</packaging> 不配置<packaging>jar</packaging>,默认是jar,有war,pom,jar三种。 2,配置打包插件: <build...
  • 1.在 dubbo 的 provider 项目(实现类项目dubbo-service-impl)中 pom.xml 配置 ...-- 指定项目的打包插件信息 --> <plugin> <artifactId>maven-assembly-plugin</artifactId> <c...
  • Maven打包war包插件配置

    千次阅读 2019-04-09 10:47:58
    因网上没有找到自己需要的...1. 在pom.xml配置不同的环境ID <profiles> <profile> <!-- 本地开发环境 --> <id>dev</id> <properties> <package.environme...
  • 背景:MAVEN打jar包时 想排除某些配置文件,或者只 想某些文件夹下的文件。 <plugin> <artifactId>maven-jar-plugin</artifactId> <configuration> <archive> <...
  • Maven工作分为多个阶段,具体阶段参考:https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html ;Maven 采用了一组可靠的插件来提供它的...因此在配置插件时候就可以配置一些阶段的细节...
  • 打包插件是把class文件,配置文件打包成一个jar(war或者其他格式)的包。而且可执行jar包中包含或者不包含相应的依赖包包,当不包含相应的依赖包时,我们需要建立lib目录,且jar和lib目录在同级别目录。 2. 常见的...
  • 项目使用maven打包后一般需要进行配置或者静态资源分离,可以使用 maven-assembly-plugin插件进行资源分离。 项目结构: pom文件: <build> <plugins> <plugin> <groupId>org....
  • maven插件打包配置文件分离自动生成启动脚本(Linux + windows 启动脚本) 文章目录 目录 maven插件打包配置文件分离自动生成启动脚本(Linux + windows 启动脚本) 文章目录 前言 一、打包展示 二、...
  • maven常用插件配置

    2016-06-16 17:33:00
    -- 排除资源文件中的properties文件,不需要打到jar中,后面通过assembly插件打包到conf目录中 --><plugin> <artifactId>maven-jar-plugin</artifactId> <configuration> <ex...
  • maven-assembly-plugin打包插件配置

    千次阅读 2017-07-03 15:12:01
    maven-assembly-plugin打包插件配置
  • SpringBoot-----微服务Maven打包插件

    千次阅读 2018-10-22 14:18:27
    1、插件配置 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="...http://maven.apa
  • 指定main入口,打包的时候可以配置排哪些配置文件不打到jar包里 2、maven-dependency-plugin插件 1.需要某个特殊的 jar包,但是有不能直接通过maven依赖获取,或者说在其他环境的maven仓库内不存在,那么如何将...
  • Maven打包配置文件

    千次阅读 2016-07-09 10:37:03
    Maven使用assembly插件打包各种环境的配置文件
  • IntelliJ IDEA中maven打包配置

    万次阅读 2018-04-17 18:32:29
    IntelliJ IDEA是目前最好用的ide,里面有自带的maven插件,仅需简单的几步配置,就可以使用maven进行打包。1、编辑配置2、添加maven配置3、输入maven配置的相关信息Command line:clean validate compile ...
  • 文章目录maven打包生成可执行Jar包:maven插件 maven-jar-plugin一、在pom.xml文件中配置二、右键项目 -> Export -> JAR file,点击Next三、默认一致,设置Jar名,点击Finish四,运行Jar包 一、在pom.xml文件...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,715
精华内容 686
关键字:

maven打包插件配置