springboot 多模块打包war

最新推荐文章于 2024-08-01 12:09:12 发布
最新推荐文章于 2024-08-01 12:09:12 发布
阅读量1.3k 收藏
点赞数
文章标签： maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Xintaiwuyanzu/article/details/120511303
版权

1、配置项目pom.xml打包方式为war包，默认为jar包

<packaging>war</packaging>

2、设置主程序

<plugins>
            <plugin>
                <artifactId>maven-war-plugin</artifactId>
                <configuration>
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.2.4.RELEASE</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <!--设置程序执行的主类-->
                    <mainClass>com.dr.archive.common.Application</mainClass>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
            </plugin>
        </plugins>

3、配置tomcat启动

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-tomcat</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <!--打包的时候可以不用包进去，别的设施会提供。事实上该依赖理论上可以参与编译，测试，运行等周期。
                相当于compile，但是打包阶段做了exclude操作-->
            <scope>provided</scope>
        </dependency>

4、启动类继承 SpringBootServletInitializer，重写configure方法

1、Application.java

 @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(Application.class);
    }

5、注意项目访问需要把静态页面放到tomcat web app 下的root中，并且项目访问需要加上项目名称（webapp下的文件名称）

6、修改自己代码中前台访问后台的页面地址 加上项目名端口等

注意打包时，不执行测试代码

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <version>3.1.2</version>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <!--打包的时候不执行测试-->
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.22.2</version>
            <configuration>
                <skipTests>true</skipTests>
            </configuration>
        </plugin>
    </plugins>
</build>

附完整代码
1、Application.java

package com.dr.archive.common;

import com.dr.archive.common.config.ArchiveConfig;
import com.dr.framework.core.orm.support.mybatis.spring.boot.autoconfigure.EnableAutoMapper;
import com.dr.framework.util.Constants;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.context.annotation.Bean;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.web.client.RestTemplate;

import java.nio.charset.StandardCharsets;


/**
 * 系统启动入口
 *
 * @author dr
 */
@SpringBootApplication(scanBasePackages = {Constants.PACKAGE_NAME, "com.dr.archive"}, scanBasePackageClasses = Application.class)
@EnableConfigurationProperties(ArchiveConfig.class)
@EnableAutoMapper(basePackages = {Constants.PACKAGE_NAME, "com.dr.archive"})
@EnableScheduling
public class Application extends SpringBootServletInitializer {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
        System.out.println("成功");
    }

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(Application.class);
    }

    /**
     * httpClient
     *
     * @return
     */
    @Bean
    public RestTemplate restTemplate() {
        SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
        requestFactory.setReadTimeout(10000);
        // 设置超时
        requestFactory.setConnectTimeout(10000);
        //利用复杂构造器可以实现超时设置，内部实际实现为 HttpClient
        RestTemplate restTemplate = new RestTemplate(requestFactory);
        for (HttpMessageConverter messageConverter : restTemplate.getMessageConverters()) {
            if (messageConverter instanceof StringHttpMessageConverter) {
                ((StringHttpMessageConverter) messageConverter).setDefaultCharset(StandardCharsets.UTF_8);
            }
        }
        return restTemplate;
    }
}
2、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>
    <parent>
        <groupId>com.dr.archive</groupId>
        <artifactId>parent</artifactId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>
    </parent>
    <artifactId>archive_commons</artifactId>
    <packaging>war</packaging>
    <repositories>
        <repository>
            <id>com.e-iceblue</id>
            <name>e-iceblue</name>
            <url>http://repo.e-iceblue.com/nexus/content/groups/public/</url>
        </repository>
    </repositories>
    <dependencies>
        <!--档案核心相关开始-->
        <dependency>
            <groupId>com.dr.archive</groupId>
            <artifactId>core</artifactId>
        </dependency>
        <dependency>
            <groupId>com.dr.archive</groupId>
            <artifactId>detection</artifactId>
        </dependency>
        <dependency>
            <groupId>com.dr.archive</groupId>
            <artifactId>storage</artifactId>
        </dependency>
        <dependency>
            <groupId>com.dr.archive</groupId>
            <artifactId>kufang</artifactId>
        </dependency>
        <dependency>
            <groupId>javax.validation</groupId>
            <artifactId>validation-api</artifactId>
            <version>2.0.1.Final</version>
        </dependency>
        <!--档案核心相关结束-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcprov-jdk15on</artifactId>
            <version>1.47</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>1.9.3</version>
        </dependency>
        <dependency>
            <groupId>com.dr.archive.fuzhou</groupId>
            <artifactId>api</artifactId>
        </dependency>
        <!--pdf相关开始-->
        <dependency>
            <groupId>org.jodconverter</groupId>
            <artifactId>jodconverter-local</artifactId>
        </dependency>
        <dependency>
            <groupId>org.jodconverter</groupId>
            <artifactId>jodconverter-spring</artifactId>
        </dependency>
        <dependency>
            <groupId>org.ofdrw</groupId>
            <artifactId>ofdrw-full</artifactId>
            <version>1.7.1</version>
            <type>pom</type>
            <exclusions>
                <exclusion>
                    <groupId>org.ofdrw</groupId>
                    <artifactId>ofdrw-converter</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>net.coobird</groupId>
            <artifactId>thumbnailator</artifactId>
            <version>[0.4, 0.5)</version>
        </dependency>
        <!--excel模板开始-->
        <dependency>
            <groupId>org.jxls</groupId>
            <artifactId>jxls</artifactId>
        </dependency>
        <dependency>
            <groupId>org.jxls</groupId>
            <artifactId>jxls-poi</artifactId>
        </dependency>
        <!--excel模板结束-->
        <dependency>
            <groupId>com.microsoft.sqlserver</groupId>
            <artifactId>mssql-jdbc</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--这个是先将word另存为xml，再根据xml嵌套数据生成word-->
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.30</version>
        </dependency>
        <!--这个可以直接根据word模板生成新的word-->
        <dependency>
            <groupId>com.deepoove</groupId>
            <artifactId>poi-tl</artifactId>
            <version>1.9.0</version>
        </dependency>
        <dependency>
            <groupId>com.itextpdf</groupId>
            <artifactId>itextpdf</artifactId>
            <version>5.4.3</version>
            <scope>compile</scope>
        </dependency>

        <!-- websocket -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>


        <!--导出word-->
        <dependency>
            <groupId>cn.afterturn</groupId>
            <artifactId>easypoi-base</artifactId>
            <version>3.0.3</version>
        </dependency>
        <dependency>
            <groupId>cn.afterturn</groupId>
            <artifactId>easypoi-web</artifactId>
            <version>3.0.3</version>
        </dependency>
        <dependency>
            <groupId>cn.afterturn</groupId>
            <artifactId>easypoi-annotation</artifactId>
            <version>3.0.3</version>
        </dependency>

        <dependency>
            <groupId>com.google.zxing</groupId>
            <artifactId>core</artifactId>
            <version>3.3.3</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-tomcat</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <!--打包的时候可以不用包进去，别的设施会提供。事实上该依赖理论上可以参与编译，测试，运行等周期。
                相当于compile，但是打包阶段做了exclude操作-->
            <scope>provided</scope>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <!--包含resources文件夹以及子文件夹下所有资源-->
                    <include>**/*.*</include>
                </includes>
            </resource>
            <resource>
                <directory>${basedir}/../web/dist</directory>
                <targetPath>static</targetPath>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <artifactId>maven-war-plugin</artifactId>
                <configuration>
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.2.4.RELEASE</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <!--设置程序执行的主类-->
                    <mainClass>com.dr.archive.common.Application</mainClass>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

3、http.js（自己项目用的，别人没用）

import axios from 'axios'
import NProgress from "nprogress";
import 'nprogress/nprogress.css';
import qs from 'qs'
import util from '../components/login/util'
import {Message} from "element-ui";

/**
 * 默认配置项
 */
const defaultCfg = {
    baseURL: 'archive_commons-1.0-SNAPSHOT/api', timeout: 5000,
    headers: {'Content-Type': 'application/x-www-form-urlencoded'},
    transformRequest(data) {
        NProgress.start()
        return qs.stringify(data)
    },
    transformResponse(data) {
        NProgress.done()
        try {
            data = JSON.parse(data)
        } catch (e) {
            data = {success: false, message: '数据格式不正确'}
        }
        return data
    }
}
let httpInstance;

/**
 * 初始化默认http客户端
 * @param base
 * @returns {AxiosInstance}
 */
export function initHttp(cfg = defaultCfg) {
    httpInstance = axios.create(cfg)
    return httpInstance;
}

/**
 * 获取默认的http客户端
 * @returns {*}
 */
export function http() {
    if (!httpInstance) {
        initHttp()
    }
    return httpInstance;
}

/**
 * 这里会被扫描到，用来初始化http请求
 * @param vue
 * @param router
 */
export default (vue, router, store) => {
    const instance = http()
    //拦截所有的请求，添加token
    instance.interceptors.request.use(config => {
        const header = config.headers
        header['$token'] = header['dauth'] = util.getToken()
        return config;
    }, err => {
        return Promise.reject(err);
    })
    instance.interceptors.response.use(
        response => {
            if (response.data.message === 'needLogin') {
                router.replace({path: 'login', query: {redirect: router.currentRoute.fullPath}})
            } else {
                return response
            }
        },
        err => {
            //routeLogin(options)
            let message = `服务器错误【${err}】`
            if (err && err.message.startsWith('timeout')) {
                message = `网络请求超时，请稍候重试！`
            }
            Message.error(message)
            return Promise.resolve({data: {success: false, message}})
        })
    store.$http = vue.prototype.$http = instance
    store.$post = vue.prototype.$post = instance.post
    store.$get = vue.prototype.$get = instance.get
    store.$router = router

    //拦截跳转，添加加载进度
    router.beforeEach((route, redirect, next) => {
        NProgress.start()
        next()
    })
    router.afterEach(() => {
        NProgress.done()
    })
}
 

IDEA创建基于springboot的多个module聚合项目，并生成war包
zhang_ming_xuan的博客
11-23 5万+
背景：最近公司在做一个基于springboot的景区管理系统，项目前期将所有的功能都做到了一个项目里，现在客户需要把前台售票和后台管理分别部署到两个域名下，本人负责拆分项目，决定使用idea创建两个project，将service和实体，dao分装成一个公用的module,两个项目共同引用，折腾之后项目可以运行但maven打包一直出错； 后来查了资料这种情况需要使用maven的多模块聚合方
springboot 打包war包
11-02
maven多模块打包成war包的例子，maven对多模块项目的管理maven多模块打包成war包的例子，maven对多模块项目的管理
SpringBoot打包war单独在Tomcat中运行
曾经蜡笔没有小新
06-04 2138
修改pom文件 <packaging>war</packaging> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web&l...
多模块Spring-boot项目如何打包成指定名字的war包？
weixin_45880725的博客
02-16 1662
简单例子告诉你如何把多模块Spring-boot项目如何打包成指定名字的war包
springboot多模块化项目打包成war文件
Gorden的博客
05-31 935
1、目录结构 2、打成war包，只需在web子项目中的pom文件中添加 <packaging>war</packaging> <build> <!-- 为war包取名 --> <finalName>separate-demo</finalName> <plugins> <plugin> <
Springboot 多模块打包 为 war
qq_38425662的博客
01-27 9252
Springboot 多模块打包   1.进入到项目的目录结构里面    目录结构      2.出现下面这个错误表示打包的项目没有主方法   3.在配置文件里面添加主方法         pom.xml里面去配置，主方法在哪个模块就在哪个模块里面的pom.xml里面去配置，并且去掉父pom.xml里         面相应的配置，这里添加的configuration->mainCla
Spring Boot 多模块 打war包和打jar包记录
隔壁有小胖的博客
06-28 973
一，对于父模块：打war包时，父模块的pom无需啥特殊处理[可以去掉 spring-boot-starter-web 中自带的tomcat]打jar包时，启用注释掉的板块，然后内嵌的tomcat不能去掉。 二、总的web模块：所有的子模块都要被依赖到，打war包时，注意在每个子模块依赖上加上war但是打jar时，不要war这句。 三、子模块罗列一个子模块例子当子模块不依赖其它子模块时，打war包 <plugin> <gro...
Spring Boot多模块项目 War方式打包（非内嵌容器部署）
qq_32334427的博客
06-17 734
1. 修改部署web模块pom 只需修改部署web模块,需要修改打包方式和spring-boot-starter-tomcat依赖scope,其他依赖模块依然使用jar方式,相关依赖会打包到war中 <packaging>war</packaging> <!-- ...... --> <dependencies> <dependency> <groupId>org.springf
基于springboot多模块项目使用maven命令打成war包放到服务器上运行的问题
weixin_33875564的博客
11-26 633
首先，大家看到这个问题，可能并不陌生，而且脑子里第一映像就是使用mava中的clear package 或者 clear install进行打包，然后在项目中的target文件夹下面找到xxx.war，将这个war包放到外置的tomcat服务器下的webapps下面，最后运行tomcat的bin文件夹下面的startup.bat命令就可以进行访问了， 起初我也是这样跟你们一样的，也这样做了，但最...
spring boot项目打包成war 并在tomcat上运行的步骤详解
JT1992413的博客
10-08 939
原文地址:http://m.blog.youkuaiyun.com/article/details?id=52515226 把spring-boot项目按照平常的web项目一样发布到tomcat容器下 一、修改打包形式 在pom.xml里设置 &amp;lt;packaging&amp;gt;war&amp;lt;/packaging&amp;gt; 二、移除嵌入式tomcat插件 在pom.xml里找到spring-boot-starte...
springboot应用打包成war包部署
02-03
springboot应用打包成war包部署
SpringBoot项目如何打包成war包，并部署在tomcat上运行
涛哥是个大帅比
03-18 6341
正常情况下，我们开发 SpringBoot 项目，由于内置了Tomcat，所以项目可以直接启动，部署到服务器的时候，直接打成 jar 包，就可以运行了。有时我们会需要打包成 war 包，放入外置的 Tomcat 中进行运行，或者使用工具idea直接启动，便于开发调试。
SpringBoot多模块构建、打包（jar、war）
Csea的博客
10-18 1040
今天自己学习了一手springboot的多模块构建，下面就简单的记录一下 首先就是项目右键新建一个Module 选择Maven 然后自己定义artifactId，最后finish 完成上面你就可以看到你的项目下新增了一个模块，如下图 项目根目录的pom下也会出现相应的modules 具体要创建多少的模块就根据实际项目的需求来进行创建，创建完毕之后就可以把之前src路径下的文件copy过去...
十、SpringBoot入门之重构项目成多模块和项目打包（JAR/WAR）
panchang199266的博客
06-30 2737
（一）将项目重构成多模块   重构成多模块流程：   第一步：更改最顶层节点的打包方式为pom ：&amp;lt;packaging&amp;gt;jar&amp;lt;/packaging&amp;gt;变成&amp;lt;packaging&amp;gt;pom&amp;lt;/packaging&amp;gt;   第二步：构建model模块   第三步：构建persistence模块，依赖model
SpringBoot 多模块项目打包（jar、war）
BUG的博客
12-01 3722
SpringBoot 多模块项目打包 开发工具为idea 多模块项目有一个或多个web子工程，负责工程的启动运行； 有jar、war选项，选择哪种打包方式会打包成哪种（web工程为启动工程，所以web工程打包成哪种即项目以哪种方式运行） 一.使用idea运行项目 : TODO:此文章不讲解配置Maven，默认已m...
Maven搭建spring boot多模块项目打jar war zip 包方式
行走在这人间正道上、为了生存、为了理想。
03-30 7189
Spring boot 父项目聚合以下模块，下图是parent.pom:其中controller是web模块，各个模块的依赖关系如下：由于spring boot 内嵌了servlet容器，而且提供了项目的java -jar启动方式，所以可以把所有模块都打为jar包形式：controller模块打jar包pom如下：打包后直接在target目录下找到cms-controller.jar，此处打开命令...
多模块打war
wuzhaosss的博客
07-28 219
多模块打war 打出来的都是各个文件 不会以jar继承的方式出现
Spring Boot应用打包成war包
最新发布
时空飞扬的专栏
08-01 244
修改 packaging 节点值为 war。Maven 工程默认打包方式为 jar，如果你的 pom.xml 中没有 packaging 节点，则需要手动设置。
springboot公共模块打包_SpringBoot 多模块项目打包（jar、war）
weixin_31487521的博客
12-23 935
SpringBoot 多模块项目打包开发工具为idea多模块项目有一个或多个web子工程，负责工程的启动运行； 有jar、war选项，选择哪种打包方式会打包成哪种(web工程为启动工程，所以web工程打包成哪种即项目以哪种方式运行)一.使用idea运行项目 :TODO:此文章不讲解配置Maven，默认已maven已可以成功打包为例-.-1.使用idea运行时，默认即为jar方式运行，找到web工程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

【这个世界会好的】

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值