springboot - DevOps - Spring Boot自动部署到WebLogic - 个人文章

前言

想想，如果Spring Boot的项目在本地IDEA可以直接通过内嵌tomcat的jar运行，而只要往GitHub上提交代码，就能自动帮你打包成war包部署在项目组的WebLogic服务器上，该减少多少非开发的工作量。这也是DevOps中很重要的一环。本文档就是针对该设想，做出技术上的尝试。首先申明这纯属技术上的尝试研究，不会主动应用在客户的生产环境架构中。

当我接触了Spring Boot，就果断抛弃了Spring MVC。一则我们可以通过各种IDEA非常简单的生成一个Spring Boot的项目，不像Spring MVC还有麻烦的XML配置文件；二则因为Spring Boot内嵌Tomcat，本地运行时直接运行启动类就行了，不需要再准备一个Tomcat 服务器，打War包部署。但同时也遇到了其他的问题：

本地运行启动类时根据POM文件，是将其打包成Jar 包运行，无法直接部署在外部服务器上。
Spring Boot部署在Tomcat上容易，而在重量级服务器上，例如WebLogic上就不那么友好了。而且一些企业应用中服务器还不一定是最新版本的，部署上去会遇到兼容性问题。

我所在的项目使用的服务器就是WebLogic 11g，在受益于Spring Boot开发的灵活性与多元性同时，又浪费了很多无效的时间在解决WebLogic上部署的问题：添加weblogic.xml文件，Jar包冲突等等。最近周末业余时间我做了一些尝试，简单实现了以上的需求，现在进入正题吧。

需要准备的基本配置很简单：GitHub账号，Jenkins和WebLogic 11g服务器就够了。如果是企业内网，访问公网的Maven中央仓库，可能还需要Nexus搭建Maven私服。内网的具体方案本文档会讨论，但考虑到保密，不会引用具体的实践操作。

War包分析

上文说到，Spring Boot项目我本地是直接运行Jar包，而部署在WebLogic上的是War包。Jar包和War包的结构有什么关联和区别呢？这里我新建了一个最简单的Spring Boot项目，分别生成了Jar和可以部署在WebLogic上的War包：

1、jar包结构

 .
    
    ├── BOOT-INF
    
    │   ├── classes
    
    │   │   ├── application.properties
    
    │   │   └── com
    
    │   │       └── kerry
    
    │   │           └── springbootdemo
    
    │   │               ├── DemoController.class
    
    │   │               └── SpringbootDemoApplication.class
    
    │   └── lib
    
    │       ├── classmate-1.3.4.jar
    
    │       ├── hibernate-validator-6.0.13.Final.jar
    
    │       ├── jackson-annotations-2.9.0.jar
    
    │       ├── jackson-core-2.9.7.jar
    
    │       ├── jackson-databind-2.9.7.jar
    
    │       ├── jackson-datatype-jdk8-2.9.7.jar
    
    │       ├── jackson-datatype-jsr310-2.9.7.jar
    
    │       ├── jackson-module-parameter-names-2.9.7.jar
    
    │       ├── javax.annotation-api-1.3.2.jar
    
    │       ├── jboss-logging-3.3.2.Final.jar
    
    │       ├── jul-to-slf4j-1.7.25.jar
    
    │       ├── log4j-api-2.10.0.jar
    
    │       ├── log4j-to-slf4j-2.10.0.jar
    
    │       ├── logback-classic-1.2.3.jar
    
    │       ├── logback-core-1.2.3.jar
    
    │       ├── slf4j-api-1.7.25.jar
    
    │       ├── snakeyaml-1.19.jar
    
    │       ├── spring-aop-5.0.10.RELEASE.jar
    
    │       ├── spring-beans-5.0.10.RELEASE.jar
    
    │       ├── spring-boot-2.0.6.RELEASE.jar
    
    │       ├── spring-boot-autoconfigure-2.0.6.RELEASE.jar
    
    │       ├── spring-boot-starter-2.0.6.RELEASE.jar
    
    │       ├── spring-boot-starter-json-2.0.6.RELEASE.jar
    
    │       ├── spring-boot-starter-logging-2.0.6.RELEASE.jar
    
    │       ├── spring-boot-starter-tomcat-2.0.6.RELEASE.jar
    
    │       ├── spring-boot-starter-web-2.0.6.RELEASE.jar
    
    │       ├── spring-context-5.0.10.RELEASE.jar
    
    │       ├── spring-core-5.0.10.RELEASE.jar
    
    │       ├── spring-expression-5.0.10.RELEASE.jar
    
    │       ├── spring-jcl-5.0.10.RELEASE.jar
    
    │       ├── spring-web-5.0.10.RELEASE.jar
    
    │       ├── spring-webmvc-5.0.10.RELEASE.jar
    
    │       ├── tomcat-embed-core-8.5.34.jar
    
    │       ├── tomcat-embed-el-8.5.34.jar
    
    │       ├── tomcat-embed-websocket-8.5.34.jar
    
    │       └── validation-api-2.0.1.Final.jar
    
    ├── META-INF
    
    │   ├── MANIFEST.MF
    
    │   └── maven
    
    │       └── com.kerry
    
    │           └── springboot-demo
    
    │               ├── pom.properties
    
    │               └── pom.xml
    
    └── org
    
        └── springframework
    
            └── boot
    
                └── loader
    
                    ├── archive
    
                    │   ├── Archive.class
    
                    │   ├── Archive$Entry.class
    
                    │   ├── Archive$EntryFilter.class
    
                    │   ├── ExplodedArchive$1.class
    
                    │   ├── ExplodedArchive.class
    
                    │   ├── ExplodedArchive$FileEntry.class
    
                    │   ├── ExplodedArchive$FileEntryIterator.class
    
                    │   ├── ExplodedArchiveFileEntryIteratorEntryComparator.class
    
                    │   ├── JarFileArchive.class
    
                    │   ├── JarFileArchive$EntryIterator.class
    
                    │   └── JarFileArchive$JarFileEntry.class
    
                    ├── data
    
                    │   ├── RandomAccessData.class
    
                    │   ├── RandomAccessDataFile$1.class
    
                    │   ├── RandomAccessDataFile.class
    
                    │   ├── RandomAccessDataFile$DataInputStream.class
    
                    │   └── RandomAccessDataFile$FileAccess.class
    
                    ├── ExecutableArchiveLauncher.class
    
                    ├── jar
    
                    │   ├── AsciiBytes.class
    
                    │   ├── Bytes.class
    
                    │   ├── CentralDirectoryEndRecord.class
    
                    │   ├── CentralDirectoryFileHeader.class
    
                    │   ├── CentralDirectoryParser.class
    
                    │   ├── CentralDirectoryVisitor.class
    
                    │   ├── FileHeader.class
    
                    │   ├── Handler.class
    
                    │   ├── JarEntry.class
    
                    │   ├── JarEntryFilter.class
    
                    │   ├── JarFile$1.class
    
                    │   ├── JarFile$2.class
    
                    │   ├── JarFile.class
    
                    │   ├── JarFileEntries$1.class
    
                    │   ├── JarFileEntries.class
    
                    │   ├── JarFileEntries$EntryIterator.class
    
                    │   ├── JarFile$JarFileType.class
    
                    │   ├── JarURLConnection$1.class
    
                    │   ├── JarURLConnection.class
    
                    │   ├── JarURLConnection$JarEntryName.class
    
                    │   ├── StringSequence.class
    
                    │   └── ZipInflaterInputStream.class
    
                    ├── JarLauncher.class
    
                    ├── LaunchedURLClassLoader.class
    
                    ├── LaunchedURLClassLoader$UseFastConnectionExceptionsEnumeration.class
    
                    ├── Launcher.class
    
                    ├── MainMethodRunner.class
    
                    ├── PropertiesLauncher$1.class
    
                    ├── PropertiesLauncher$ArchiveEntryFilter.class
    
                    ├── PropertiesLauncher.class
    
                    ├── PropertiesLauncher$PrefixMatchingArchiveFilter.class
    
                    ├── util
    
                    │   └── SystemPropertyUtils.class
    
                    └── WarLauncher.class

2、War包结构

 .
    
    └── WEB-INF
    
        ├── classes
    
        │   ├── application.properties
    
        │   └── com
    
        │       └── kerry
    
        │           └── springbootdemo
    
        │               ├── DemoController.class
    
        │               └── SpringbootDemoApplication.class
    
        ├── lib
    
        │   ├── aopalliance-1.0.jar
    
        │   ├── classmate-1.0.0.jar
    
        │   ├── dfutil-11.2.0.1.0.jar
    
        │   ├── fastjson-1.2.4.0.jar
    
        │   ├── hibernate-validator-5.0.3.Final.jar
    
        │   ├── jackson-annotations-2.3.5.jar
    
        │   ├── jackson-core-2.3.5.jar
    
        │   ├── jackson-databind-2.3.5.jar
    
        │   ├── jboss-logging-3.1.1.GA.jar
    
        │   ├── jcl-over-slf4j-1.7.11.jar
    
        │   ├── joda-time-2.3.jar
    
        │   ├── jul-to-slf4j-1.7.11.jar
    
        │   ├── log4j-over-slf4j-1.7.11.jar
    
        │   ├── logback-classic-1.1.3.jar
    
        │   ├── logback-core-1.1.3.jar
    
        │   ├── mpaas-sso-oam-1.0.0.jar
    
        │   ├── oamasdk-api-11.1.1.5.0.jar
    
        │   ├── ojdbc6-11.2.0.1.0.jar
    
        │   ├── query-0.0.30-SNAPSHOT.jar
    
        │   ├── slf4j-api-1.7.11.jar
    
        │   ├── snakeyaml-1.13.jar
    
        │   ├── spring-aop-4.2.5.RELEASE.jar
    
        │   ├── spring-beans-4.2.5.RELEASE.jar
    
        │   ├── spring-boot-1.1.12.RELEASE.jar
    
        │   ├── spring-boot-autoconfigure-1.1.12.RELEASE.jar
    
        │   ├── spring-boot-legacy-1.0.2.RELEASE.jar
    
        │   ├── spring-boot-starter-1.1.12.RELEASE.jar
    
        │   ├── spring-boot-starter-logging-1.1.12.RELEASE.jar
    
        │   ├── spring-boot-starter-web-1.1.12.RELEASE.jar
    
        │   ├── spring-context-4.2.5.RELEASE.jar
    
        │   ├── spring-core-4.2.5.RELEASE.jar
    
        │   ├── spring-expression-4.2.5.RELEASE.jar
    
        │   ├── spring-web-4.2.5.RELEASE.jar
    
        │   ├── spring-webmvc-4.2.5.RELEASE.jar
    
        │   └── validation-api-1.1.0.Final.jar
    
        ├── weblogic.xml
    
        └── web.xml

通过解剖 Jar包和War包的结构，我们很容易看出，War包所需要的无非就三个部分：

classes文件夹：存放了编译后的Java代码
lib文件夹：运行在服务器上时依赖的Jar包
web.xml、weblogic.xml：web.xml是War包中必须，而weblogic.xml则是部署在WebLogic服务器上需要的。

那么如果我们要自己生成War包，就需要生成这三个部分：

classes文件夹，可以很明显看到Jar包结构中也有一样的文件夹，而且class文件的数量也一样。那么我们得出，可以从Jar包中直接获取第一部分--classes文件夹。（除了启动类的class，后续会主要讲解）
lib文件夹在Jar包结构中也能找到，但是Jar包路径中lib文件夹下依赖的Jar包太多了，和War包路径中lib文件夹对应不起来。而实际上Spring Boot项目生成的War包中依赖的Jar包基本上是固定的那些，而且为了适用于WebLogic 11g，对于一些Jar包的版本是有要求的。所以我这里使用自己准备的lib文件夹。
web.xml和weblogic.xml，在参考了同事写的文章之后（如何优雅的在weblogic上部署spring-boot）。发现可以自己生成这两个配置文件，只需要修改对应项目的路径和名称就行。我这里粘贴同事使用的两个文件的模板，具体业务系统中只需要替换掉对应的变量{application-class}和{context-root}即可：

web.xml模板（添加了公司倚天项目）

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>{application-class}</param-value>
    </context-param>

    <listener>
        <listener-class>org.springframework.boot.legacy.context.web.SpringBootContextLoaderListener</listener-class>
    </listener>

    <filter>
        <filter-name>MpaasFilter</filter-name>
        <filter-class>com.definesys.mpaas.query.filter.J2EEServletFilter</filter-class>
        <init-param>
             <param-name>userHeaderName</param-name><!-- store user identify -->
             <param-value>oam_remote_user</param-value>
        </init-param>
    </filter>

    <filter-mapping>
        <filter-name>MpaasFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <servlet>
        <servlet-name>appServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextAttribute</param-name>
            <param-value>org.springframework.web.context.WebApplicationContext.ROOT</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>appServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

weblogic.xml模板

<?xml version="1.0" encoding="UTF-8"?>
<wls:weblogic-web-app
        xmlns:wls="http://xmlns.oracle.com/weblogic/weblogic-web-app"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="
        http://xmlns.oracle.com/weblogic/weblogic-web-app
        http://xmlns.oracle.com/weblogic/weblogic-web-app/1.4/weblogic-web-app.xsd">
    <wls:context-root>/{context-root}</wls:context-root>
    <wls:container-descriptor>
        <wls:prefer-application-packages>
            <wls:package-name>org.slf4j.*</wls:package-name>
            <wls:package-name>org.springframework.*</wls:package-name>
        </wls:prefer-application-packages>
    </wls:container-descriptor>
</wls:weblogic-web-app>

Jenkins环境搭建

DevOps开发模式中最受欢迎的开源工具除了Docker，就是Jenkins了。我们使用Jenkins的作用主要包括：从GitHub上拉取源代码，装载实现自动打包部署的脚本，和提供可视化界面让用户简单操作。

安装Jenkins

Jenkins的安装方法很多，我是直接下载Jenkins的War，部署在Tomcat上运行。从Jenkins官网 https://jenkins.io/download/ 下载Jenkins.war，放在Tomcat的 webapps目录下，重启Tomcat。

登入http://localhost:8080/jenkins，进入Jenkins初始化页面，第一次启动时间可能有点长，耐心等待。进入成功后会看到如下画面，按提示路径打开密码文件，输入密码（页面中有提示密码所在位置）：

获得，输入密码后，点击右下角的Continue 按钮，jenkins开始安装，短暂时间后，会弹出如下界面，选择安装的插件

一般推荐使用官方推荐默认安装的插件，确定后，进入插件下载安装页面，等待下载安装…

登录成功后会让你设置密码

设置密码，登录进去后即进入Jenkins主页面

环境配置

点击左上侧系统管理，进入Jenkins基本系统设置。我们先配置“全局工具配置”:

主要是配置 JDK、Git、Maven ，配置本地安装的路径，如果本地尚未安装请先自行安装。

接下来配置“系统配置”：
此处只讲配置GitHub Servers，主要用于通过Webhooks 自动构建发布项目。在系统配置页面找到GitHub Servers，如下图：

勾上 Specify another hook URL for GitHub configuration ，它会默认生成一个地址，ip 是内网ip，我这里是使用自己的github，所以把ip 改成外网ip了，端口建议和jenkins端口保持一致。
登录个人githup网站，选择一个项目，在Settings中的webhooks中点击 Add Webhook （我这里的页面是已经配置了一个）

这里我们配置Payload URL,即GitHub Servers中生成的地址。然后选择触发事件，案例中是选择了push事件，即没当github收到新的push都会告知jenkins. 然后点击保存即可。（ps:保存后页面上可能有红色叹号，只要地址正确即可，可忽略，触发一次后即显示正常。）

创建任务

在首页点击“New任务”，新建一个任务，选择 maven项目。如果选项中没有，说明Jenkins没有安装对应的插件，可以在“系统管理-插件管理-可选插件”中搜索 Pipeline Maven Integration 或者 Maven Integration plugin，安装对应的插件。

创建的任务中，我需要将具体的业务字段通过参数传入，并配置从GitHub上拉取代码，执行打包部署的脚本。

保存后，点击运行该任务，就能从日志中看到运行结果

Shell脚本

根据我们在Jenkins上任务的配置来看，在执行该任务时需要传入参数并运行脚本。从第二章War结构中我们分析出来，如果要生成可部署的War包，需要三个部分：classes文件夹、lib文件夹、web.xml和weblogic.xml。所以该脚本要做的事情就分为以下一个步骤：

将GitHub下载下来的项目代码编译，获取classes文件夹。
提取classes文件夹中启动类的class文件夹，替换成可以在weblogic上部署的class文件。（我的方案是准备一个干净的可以在WebLogic上部署的Spring Boot项目模板，通过传入项目名称的方式，专门生成对应项目的启动类class文件用于替换）
准备web.xml、weblogic.xml模板文件，对对应变量进行替换。
准备lib文件夹。
将classes、lib、web.xml、weblogic.xml按照对应目录结构生成War包。
使用wlst.sh部署War包到指定WebLogic服务器。

这里列出我写的打包的Shell脚本，具体的部署脚本请参考（如何优雅的在weblogic上部署spring-boot）

#!/bin/bash

v_job_name=$1
v_project_name=$2
v_startup_name=$3
v_startup_path=$4
v_df_startup_path=$5
v_application_template=$6

echo 'shell begin --------------------------------------------------'
#打jar包
cd /root/.jenkins/workspace/${v_job_name}/${v_project_name}/
mvn clean  package
cd /u01/devops
echo 'git代码生成jar包'

#生成job目录
rm -rf package/${v_job_name}
mkdir package/${v_job_name}
mkdir package/${v_job_name}/jar package/${v_job_name}/temp package/${v_job_name}/war package/${v_job_name}/war/WEB-INF


#获取jar包，复制到jar文件夹  --package
v_jar_path=`find /root/.jenkins/workspace/${v_job_name}/${v_project_name}/target -name ${v_project_name}"*.jar"`
v_jar_name=`basename ${v_jar_path}`
cp $v_jar_path package/${v_job_name}/jar
#解压jar
cd package/${v_job_name}/jar
jar -xvf ${v_jar_name}
cd ../../../
#获取class目录
v_jar_class=`find package/${v_job_name}/jar -name classes -type d`
echo '获取jar包中classes'

#生成启动类
#找到 启动类模板
v_startup_java=`find startup/springboot-weblogic-template/ -name "SpringbootWeblogicTemplateApplication.java"`
v_startup_java_addr=`dirname ${v_startup_java}`
#替换启动类
cp ${v_application_template} ${v_startup_java}
#替换启动类中参数
sed -i "s/"SpringbootWeblogicTemplateApplication"/"${v_startup_name}"/g" ${v_startup_java}
sed -i "s/"devops.weblogic.springbootweblogictemplate"/"${v_startup_path}"/g" ${v_startup_java}
sed -i "s/"devops.weblogic"/"${v_df_startup_path}"/g" ${v_startup_java}
mv $v_startup_java $v_startup_java_addr"/"${v_startup_name}".java"
#编译
cd startup/springboot-weblogic-template
mvn clean compile
cd ../../
#找到 启动类.class
v_startup_class=`find startup/springboot-weblogic-template -name ${v_startup_name}".class"`
rm -f startup/target/${v_startup_name}".class"
cp $v_startup_class startup/target/
#还原 启动类.java
rm -f ${v_startup_java_addr}"/"${v_startup_name}".java"
cp /u01/devops/startup/applicationTemplate/SpringbootWeblogicTemplateApplication.java $v_startup_java_addr
echo '生成启动类的class文件'

#获取web.xml、weblogic.xml
cp template/web.xml package/${v_job_name}/temp/web.xml
cp template/weblogic.xml package/${v_job_name}/temp/weblogic.xml
sed -i "s/{context-root}/${v_project_name}/g" package/${v_job_name}/temp/weblogic.xml
sed -i "s/{application-class}/${v_startup_path}"."${v_startup_name}/g" package/${v_job_name}/temp/web.xml
echo '替换web.xml、weblogic.xml'

#替换war包中clsss/、lib/、web.xml、weblogic.xml
cp -rf $v_jar_class package/${v_job_name}/war/WEB-INF/
cp -rf template/lib package/${v_job_name}/war/WEB-INF/
cp package/${v_job_name}/temp/web.xml package/${v_job_name}/war/WEB-INF/
cp package/${v_job_name}/temp/weblogic.xml package/${v_job_name}/war/WEB-INF/
#替换启动类
v_war_startup_class=`find package/${v_job_name}/war -name ${v_startup_name}".class"`
rm -f $v_startup_class
cp startup/target/${v_startup_name}".class" $v_war_startup_class

#生成war包
cd package/${v_job_name}/war
jar -cvfM0 ${v_startup_name}.war .
echo '生成war包'

tree

echo 'shell end --------------------------------------------------'

备注说明

lib文件夹

前文说到，打包时lib文件是自己准备的，主要是选择低一点版本的Spring Boot依赖Jar等。你也可以根据具体项目增加或调整lib中的Jar包。例如：

因为使用了aop才新增了aopalliance-1.0.jar和aspectjweaver-1.8.13.jar
因为使用了jwt才新增了jjwt-0.6.0.jar和java-jwt-3.1.0.jar，并将jackson-annotations-2.3.5.jar、jackson-core-2.3.5.jar、jackson-databind-2.3.5.jar升到了jackson-annotations-2.5.0.jar、jackson-core-2.5.0.jar、jackson-databind-2.5.0.jar。

├── aopalliance-1.0.jar
├── aspectjweaver-1.8.13.jar
├── classmate-1.0.0.jar
├── commons-codec-1.6.jar
├── commons-fileupload-1.2.1.jar
├── fastjson-1.2.4.0.jar
├── hibernate-validator-5.0.3.Final.jar
├── jackson-annotations-2.5.0.jar
├── jackson-core-2.5.0.jar
├── jackson-databind-2.5.0.jar
├── java-jwt-3.1.0.jar
├── jboss-logging-3.1.1.GA.jar
├── jcl-over-slf4j-1.7.11.jar
├── jjwt-0.6.0.jar
├── joda-time-2.3.jar
├── jul-to-slf4j-1.7.11.jar
├── log4j-over-slf4j-1.7.11.jar
├── logback-classic-1.1.3.jar
├── logback-core-1.1.3.jar
├── mpaas-sso-oam-1.0.0.jar
├── oamasdk-api-11.1.1.5.0.jar
├── ojdbc6-11.2.0.1.0.jar
├── query-0.0.30-SNAPSHOT.jar
├── restutil-1.jar
├── slf4j-api-1.7.11.jar
├── snakeyaml-1.13.jar
├── spring-aop-4.2.5.RELEASE.jar
├── spring-beans-4.2.5.RELEASE.jar
├── spring-boot-1.1.12.RELEASE.jar
├── spring-boot-autoconfigure-1.1.12.RELEASE.jar
├── spring-boot-legacy-1.0.2.RELEASE.jar
├── spring-boot-starter-1.1.12.RELEASE.jar
├── spring-boot-starter-logging-1.1.12.RELEASE.jar
├── spring-boot-starter-web-1.1.12.RELEASE.jar
├── spring-context-4.2.5.RELEASE.jar
├── spring-core-4.2.5.RELEASE.jar
├── spring-expression-4.2.5.RELEASE.jar
├── spring-web-4.2.5.RELEASE.jar
├── spring-webmvc-4.2.5.RELEASE.jar
└── validation-api-1.1.0.Final.jar

启动类模板

我在Jenkins的传入参数中，是有设置启动类模板选项的，虽然大部分部署在WebLogic的启动类都是这样：

package devops.weblogic.springbootweblogictemplate;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.context.web.SpringBootServletInitializer;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.WebApplicationInitializer;

@EnableAutoConfiguration
@Configuration
@ComponentScan
public class SpringbootWeblogicTemplateApplication extends SpringBootServletInitializer implements WebApplicationInitializer {

        public static void main(String[] args) {
                SpringApplication.run(SpringbootWeblogicTemplateApplication.class, args);
        }

        @Override
        protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
                return builder.sources(SpringbootWeblogicTemplateApplication.class).showBanner(false);
        }
}

但是有些代码中启动类要有其他的设置。例如：有文件上传的程序需要部署在WebLogic上时，spring-boot自带的org.springframework.web.multipart.MultipartFile
和Multipart产生冲突，这时需要在申明Bean：

package devops.weblogic.springbootweblogictemplate;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.web.MultipartAutoConfiguration;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.context.web.SpringBootServletInitializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.multipart.MultipartResolver;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;

@EnableAutoConfiguration(exclude = {MultipartAutoConfiguration.class})
@Configuration
@ComponentScan(basePackages = {"devops.weblogic", "com.definesys.mpaas"})
public class SpringbootWeblogicTemplateApplication extends SpringBootServletInitializer implements WebApplicationInitializer {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootWeblogicTemplateApplication.class, args);
    }

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(SpringbootWeblogicTemplateApplication.class).showBanner(false);
    }


    @Bean(name = "multipartResolver")
    public MultipartResolver multipartResolver() {
        CommonsMultipartResolver resolver = new CommonsMultipartResolver();
        resolver.setDefaultEncoding("UTF-8");
        resolver.setResolveLazily(true);
        resolver.setMaxInMemorySize(409600);
        resolver.setMaxUploadSize(50 * 1024 * 1024);
        return resolver;
    }

}

内网问题

内网下Jenkins的安装，主要问题在于Jenkins插件如何离线安装？网上有很多不靠谱的方法，亲身实践，最好的方法是；在外网装一个Jenkins，在线安装好你需要的所有插件，然后将插件所在目录（/root/.jenkins/plugins）拷贝到内网。重启Jenkins就能离线运行拷贝过来的插件了。
内网如何通过GitHub代码中的POM文件拉取Jar包？企业内网统一开放一个可访问外网的端口，搭建Nexus私服。自动部署的所有Maven项目都从Nexus私服中拉取Jar包

DevOps - Spring Boot自动部署到WebLogic

前言

War包分析

Jenkins环境搭建

安装Jenkins

环境配置

创建任务

Shell脚本

备注说明

lib文件夹

启动类模板

内网问题

KerryWu

引用和评论

Java开发搭配Groovy

AES 加密和解密demo

一个用JavaScript生成思维导图(mindmap)的github repo

Thymeleaf的使用

Spring Boot起步，CRUD、错误处理与宝塔部署

实现 Angular 程序处理进度条

Spring boot连接Minio实现文件的上传以及下载