整合营销服务商

电脑端+手机端+微信端=数据同步管理

免费咨询热线：

Windows环境下jenkins实现自动化部署

Windows环境下jenkins实现自动化部署

、前言

Jenkins是一个开源软件项目，是基于Java开发的一种持续集成工具，用于监控持续重复的工作，旨在提供一个开放易用的软件平台，使软件的持续集成变成可能。本文使用Jenkins构建github上面的springboot项目，原理为jenkins从github上拉取源码，然后使用maven进行打包，最后使用java运行springboot项目打包后的jar包。

二、环境准备

2.1 本文工具版本

JDK：1.8.0_152

Maven：3.6.0

Git：2.14.1

Jenkins：2.172

2.2 安装JDK

网上已有数不清的教程，此处不再造轮子。

2.3 安装Maven

同上。

2.4 安装Git

同上+1。

三、部署Jenkins

3.1 下载Jenkins

Jenkins官网下载地址：https://jenkins.io/index.html，点击下载

在页面下方，选择你想下载的版本号和相应的平台，这里下载的版本号为2.164.2 for Windows，如下图：


下载完成后，将压缩包放到你想要的位置，然后解压。

3.2 启动Jenkins

找到解压后的文件夹，进入到jenkins.war所在的目录，按住shift键，点击鼠标左键，在弹出的菜单中找到“在此处打开Powershell窗口”。

执行命令：

java -jar jenkins.war --httpPort=8090

其中jenkins.war是你要启动的war包的名称，httpPort是启动的端口号，可以不指定，默认为8080。

不指定端口号的话，执行以下命令就行：

java -jar jenkins.war

当看到以下信息时，代表jenkins已经启动成功。启动后，不要关闭命令窗口。关闭命令窗口，服务也会停止。

3.3 访问Jenkins

打开浏览器，在地址栏输入：http://localhost:8090 即可访问jenkins。

第一次访问需要按页面提示输入密码。如果在页面上没有看到，可以去启动日志中查找。

四、安装插件

  • 在左边菜单栏点击“系统管理”。

  • 然后点击“插件管理”。

  • 点击“可选插件”

  • 在右上角过滤栏中，输入你想要安装的插件，常用的插件有以下几个：

　　　Maven Integration plugin

　　　SSH plugin

　　　Deploy to container Plugin

　　　GitLab

　　　Gitlab Hook

  • 勾选好自己要安装的插件之后，点击下面的“直接安装”按钮。

  • 然后等待安装，安装完成之后，最好手动重启一下jenkins。

五、Jenkins的配置

5.1 系统设置

回到系统管理界面，点击“系统设置”。（ps：这里系统设置只是简单地设置了一下系统管理员的邮件地址，也可以不设置，没有这个需求的可以直接跳转到 5.2 全局工具配置。）

找到Jenkins Location，配置系统管理员邮件地址

配置通知邮件，勾选“通过发送测试邮件测试配置”，在图中2所指之处，填入接受测试邮件的邮箱地址，然后点击“Test configuration”。

如果配置成功，将会收到如下的一条测试邮件：

5.2 全局工具配置

回到系统管理页面，点击“全局工具配置”，进入到全局工具配置页面，开始Maven、JDK、Git的配置。

首先配置Maven的settings.xml文件，可以使用maven默认的配置文件，也可以指定特定路径下的settings.xml文件。

然后在页面下方，找到Maven一栏，点击Maven安装。

接下来进行Maven的配置，如下图，Name可以任取，MAVEN_HOME就是上面2.2 步骤Maven的安装路径。

5.2.2 JDK的配置

找到JDK一栏，点击JDK安装。

找到Git一栏，进行Git的配置。Name同样随便起，Path to Git executable处填写git.exe文件的路径，如c:\git\git.exe。

至此，全局的Maven、JDK和Git已配置完成。

六、新建任务

回到主界面，左边菜单栏点击“新建任务”。

在新建任务页面，输入任务名称，然后点击“构建一个自由风格的软件项目”或者“构建一个Maven项目”，最后点击左下角的确定按钮，自动跳转到任务的配置页面。

6.1 任务的配置

下面开始任务的配置，总共有下面几个部分，我们分步讲解。

6.1.1 General

配置如下图：

6.1.2 源码管理

配置如下图：

这个目前我还没有用到过，等以后用到了再更新。

6.1.4 构建环境

同上。

6.1.5 构建

这里构建分以下几步进行：

  • 构建前的准备（查看端口是否被占用，若被占用，则杀死进程）
  • 打包（包括从github拉取指定分支的最新代码，执行maven的clean和package命令）
  • 启动Jar包（这里使用8090端口）

下面分步讲解：

① 点击增加构建步骤，选择执行Windows批处理命令：

附上源码：

@echo off
setlocal enabledelayedexpansion
set port=8090
for /f "tokens=1-5" %%a in ('netstat -ano ^| find ":%port%"') do (
    if "%%e%"=="" (
        set pid=%%d
    ) else (
         set pid=%%e
    )
    echo !pid!
)
if NOT "!pid!"=="" (
   taskkill /f /pid !pid!
)

② 点击增加构建步骤，选择调用顶层Maven目标：

输入以下配置：

③ 点击增加构建步骤，选择执行Windows批处理命令：

附上源码：

@echo off
set BUILD_ID=dontKillMe
start java -jar .\target\test-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev
exit

6.1.6 构建后操作

可以配置一些构建完成后要做的工作。

至此，任务配置完毕，点击左下角的保存，跳转到任务主界面。

6.2 启动任务

左边菜单栏，点击立即构建。

点击控制台输出，可以查看构建过程中的日志输出。

当看到以下信息时，表明已经构建成功。

同时弹出了一个cmd窗口，记录了SpringBoot的启动日志。


至此，使用jenkins自动化部署github项目已经大功告成，尽情享受jenkins带来的便利吧！

、jar包和war包的区别

1.1 war包

  1. war包是Java Web应用程序的一种打包方式符合Servlet标准，它是Web Archive的缩写，主要用于存储Web应用程序相关的文件，包括Java类文件、JSP、HTML、CSS、JavaScript、图片等资源文件。
  2. war包需要部署到web服务器中（Tomcat、Apache、IIS）

1.2 jar包

  1. jar包是类的归档文件，主要用于存储Java类文件和相关资源文件。它通常被用于封装Java应用程序或Java类库，方便程序的部署和发布
  2. jar包可以被JVM直接加载和运行。

1.3 主要区别：

  1. jar包主要用于存储Java类文件和相关资源文件，而war包主要用于存储Web应用程序相关的文件。
  2. jar包可以被JVM直接加载和运行，而war包需要被Web服务器加载和运行。
  3. jar包通常用于封装Java应用程序或Java类库，而war包用于封装Java Web应用程序。

二、SpringBoot使用war包启动

war包启动：需要先启动外部的Web服务器，实现Servlet3.0规范中引导应用启动类，然后将war包放入Web服务器下，Web服务器通过回调引导应用启动类方法启动应用。

2.1 Servlet3.0规范中引导应用启动的说明

  • 在Servlet容器（Tomcat、Jetty等）启动应用时，会扫描应用jar包中 ServletContainerInitializer 的实现类。
  • 框架必须在jar包的 META-INF/services 的文件夹中提供一个名为 javax.servlet.ServletContainerInitializer 的文件，文件内容要写明 ServletContainerInitializer 的实现类的全限定名。
  • 这个 ServletContainerInitializer 是一个接口，实现它的类必须实现一个方法：onStartUp
  • 可以在这个 ServletContainerInitializer 的实现类上标注 @HandlesTypes 注解，在应用启动的时候自行加载一些附加的类，这些类会以字节码的集合形式传入 onStartup 方法的第一个参数中。
public interface ServletContainerInitializer {
    void onStartup(Set<Class<?>> c, ServletContext ctx) throws ServletException;
}

2.2 SpringBootServletInitializer的作用和原理

Spirng中SpringServletContainerInitializer实现了Servlet的规范

@HandlesTypes(WebApplicationInitializer.class)
public class SpringServletContainerInitializer implements ServletContainerInitializer {
    @Override
    public void onStartup(Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
            throws ServletException {
        // SpringServletContainerInitializer会加载所有的WebApplicationInitializer类型的普通实现类

        List<WebApplicationInitializer> initializers=new LinkedList<WebApplicationInitializer>();

        if (webAppInitializerClasses !=null) {
            for (Class<?> waiClass : webAppInitializerClasses) {
                // 如果不是接口，不是抽象类
                if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) &&
                        WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
                    try {
                        // 创建该类的实例
                        initializers.add((WebApplicationInitializer) waiClass.newInstance());
                    }
                    catch (Throwable ex) {
                        throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex);
                    }
                }
            }
        }

        if (initializers.isEmpty()) {
            servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
            return;
        }

        servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath");
        AnnotationAwareOrderComparator.sort(initializers);
        // 启动Web应用onStartup方法
        for (WebApplicationInitializer initializer : initializers) {
            initializer.onStartup(servletContext);
        }
    }
}

@HandlesTypes使用BCEL的ClassParser在字节码层面读取了/WEB-INF/classes和jar中class文件的超类名和实现的接口名，判断是否与记录的注解类名相同，若相同再通过org.apache.catalina.util.Introspection类加载为Class对象保存起来,最后传入onStartup方法参数中

SpringServletContainerInitializer类上标注了@HandlesTypes(WebApplicationInitializer.class)，所以会导入WebApplicationInitializer实现类

SpringBoot中SpringBootServletInitializer是WebApplicationInitializer的抽象类,实现了onStartup方法

@Override
public void onStartup(ServletContext servletContext) throws ServletException {
    // Logger initialization is deferred in case an ordered
    // LogServletContextInitializer is being used
    this.logger=LogFactory.getLog(getClass());
    // 创建 父IOC容器
    WebApplicationContext rootAppContext=createRootApplicationContext(servletContext);
    if (rootAppContext !=null) {
        servletContext.addListener(new ContextLoaderListener(rootAppContext) {
            @Override
            public void contextInitialized(ServletContextEvent event) {
                // no-op because the application context is already initialized
            }
        });
    }
    else {
        this.logger.debug("No ContextLoaderListener registered, as " + "createRootApplicationContext() did not "
                + "return an application context");
    }
}

创建父容器

protected WebApplicationContext createRootApplicationContext(ServletContext servletContext) {
    // 使用Builder机制，前面也介绍过
    SpringApplicationBuilder builder=createSpringApplicationBuilder();
    builder.main(getClass());
    ApplicationContext parent=getExistingRootWebApplicationContext(servletContext);
    if (parent !=null) {
        this.logger.info("Root context already created (using as parent).");
        servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, null);
        builder.initializers(new ParentContextApplicationContextInitializer(parent));
    }
    // 设置Initializer
    builder.initializers(new ServletContextApplicationContextInitializer(servletContext));
    // 在这里设置了容器启动类：AnnotationConfigServletWebServerApplicationContext
    builder.contextClass(AnnotationConfigServletWebServerApplicationContext.class);
    // 【引导】多态进入子类（自己定义）的方法中
    builder=configure(builder);
    builder.listeners(new WebEnvironmentPropertySourceInitializer(servletContext));
    // builder.build()，创建SpringApplication
    SpringApplication application=builder.build();
    if (application.getAllSources().isEmpty()
            && AnnotationUtils.findAnnotation(getClass(), Configuration.class) !=null) {
        application.addPrimarySources(Collections.singleton(getClass()));
    }
    Assert.state(!application.getAllSources().isEmpty(),
            "No SpringApplication sources have been defined. Either override the "
                    + "configure method or add an @Configuration annotation");
    // Ensure error pages are registered
    if (this.registerErrorPageFilter) {
        application.addPrimarySources(Collections.singleton(ErrorPageFilterConfiguration.class));
    }
    // 启动SpringBoot应用
    return run(application);
}

所以我们只需要自定义类继承SpringBootServletInitializer并实现configure方法告诉启动类所在的位置就可以实现SpringBoot自启动了

例如：

public class MyInitializer extends SpringBootServletInitializer {
 
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      //MySpringBootApplication为SpingBoot启动类
      return application.sources(MySpringBootApplication.class);
   }
}

三、SpringBoot使用jar包启动

按照java官方文档规定，java -jar命令引导的具体启动类必须配置在MANIFEST.MF中的Main-class属性中，该值代表应用程序执行入口类也就是包含main方法的类。

从MANIFEST.MF文件内容可以看到，Main-Class这个属性定义了org.springframework.boot.loader.JarLauncher，JarLauncher就是对应Jar文件的启动器。而我们项目的启动类SpringBootDemoApplication定义在Start-Class属性中，

JarLauncher会将BOOT-INF/classes下的类文件和BOOT-INF/lib下依赖的jar加入到classpath下，然后调用META-INF/MANIFEST.MF文件Start-Class属性完成应用程序的启动。

关于 jar 官方标准说明请移步

JAR File Specification JAR (file format)

SpringBoot的jar包，会有3个文件夹：

  • BOOT-INF：存放自己编写并编译好的 .class 文件和静态资源文件、配置文件等
  • META-INF：有一个 MANIFEST.MF 的文件
  • org：spring-boot-loader 的一些 .class 文件

META-INF 下面的 MANIFEST.MF 文件，里面的内容如下：

Manifest-Version: 1.0
Spring-Boot-Classpath-Index: BOOT-INF/classpath.idx
Implementation-Title: my-small-test
Implementation-Version: 1.0-SNAPSHOT
Spring-Boot-Layers-Index: BOOT-INF/layers.idx
Start-Class: com.small.test.SpringBootDemoApplication
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Build-Jdk-Spec: 1.8
Spring-Boot-Version: 2.4.0
Created-By: Maven Jar Plugin 3.2.0
Main-Class: org.springframework.boot.loader.JarLauncher
  • 在 Start-Class 中注明了 SpringBoot 的主启动类
  • 在 Main-Class 中注明了一个类： JarLauncher
package org.springframework.boot.loader;

import java.io.IOException;
import java.util.jar.Attributes;
import java.util.jar.Manifest;
import org.springframework.boot.loader.archive.Archive;

public class JarLauncher extends ExecutableArchiveLauncher {
  private static final String DEFAULT_CLASSPATH_INDEX_LOCATION="BOOT-INF/classpath.idx";
  
  static final Archive.EntryFilter NESTED_ARCHIVE_ENTRY_FILTER;
  
  static {
    NESTED_ARCHIVE_ENTRY_FILTER=(entry -> entry.isDirectory() ? entry.getName().equals("BOOT-INF/classes/") : entry.getName().startsWith("BOOT-INF/lib/"));
  }
  
  public JarLauncher() {}
  
  protected JarLauncher(Archive archive) {
    super(archive);
  }
  
  protected ClassPathIndexFile getClassPathIndex(Archive archive) throws IOException {
    if (archive instanceof org.springframework.boot.loader.archive.ExplodedArchive) {
      String location=getClassPathIndexFileLocation(archive);
      return ClassPathIndexFile.loadIfPossible(archive.getUrl(), location);
    } 
    return super.getClassPathIndex(archive);
  }
  
  private String getClassPathIndexFileLocation(Archive archive) throws IOException {
    Manifest manifest=archive.getManifest();
    Attributes attributes=(manifest !=null) ? manifest.getMainAttributes() : null;
    String location=(attributes !=null) ? attributes.getValue("Spring-Boot-Classpath-Index") : null;
    return (location !=null) ? location : "BOOT-INF/classpath.idx";
  }
  
  protected boolean isPostProcessingClassPathArchives() {
    return false;
  }
  
  protected boolean isSearchCandidate(Archive.Entry entry) {
    return entry.getName().startsWith("BOOT-INF/");
  }
  
  protected boolean isNestedArchive(Archive.Entry entry) {
    return NESTED_ARCHIVE_ENTRY_FILTER.matches(entry);
  }
 
  public static void main(String[] args) throws Exception {
    (new JarLauncher()).launch(args);
  }
}

父类Launcher#launch

  protected void launch(String[] args) throws Exception {
    if (!isExploded())
    //3.1 注册URL协议并清除应用缓存
    JarFile.registerUrlProtocolHandler(); 
    //3.2 设置类加载路径
    ClassLoader classLoader=createClassLoader(getClassPathArchivesIterator());
    String jarMode=System.getProperty("jarmode");
    String launchClass=(jarMode !=null && !jarMode.isEmpty()) ? "org.springframework.boot.loader.jarmode.JarModeLauncher" : getMainClass();
    //3.3 执行main方法
    launch(args, launchClass, classLoader);
  }

3.1 registerUrlProtocolHandler：注册URL协议并清除应用缓存

先设置当前系统的一个变量 java.protocol.handler.pkgs，而这个变量的作用，是设置 URLStreamHandler 实现类的包路径。

之后要重置缓存，目的是清除之前启动的残留。

private static final String MANIFEST_NAME="META-INF/MANIFEST.MF";

    private static final String PROTOCOL_HANDLER="java.protocol.handler.pkgs";

    private static final String HANDLERS_PACKAGE="org.springframework.boot.loader";

    public static void registerUrlProtocolHandler() {
        String handlers=System.getProperty(PROTOCOL_HANDLER, "");
        System.setProperty(PROTOCOL_HANDLER,
                ("".equals(handlers) ? HANDLERS_PACKAGE : handlers + "|" + HANDLERS_PACKAGE));
        resetCachedUrlHandlers();
    }

    // 重置任何缓存的处理程序，以防万一已经使用了jar协议。
// 我们通过尝试设置null URLStreamHandlerFactory来重置处理程序，除了清除处理程序缓存之外，它应该没有任何效果。
    private static void resetCachedUrlHandlers() {
        try {
            URL.setURLStreamHandlerFactory(null);
        }
        catch (Error ex) {
            // Ignore
        }
    }

3.2createClassLoader：设置类加载路径

 protected ClassLoader createClassLoader(Iterator<Archive> archives) throws Exception {
    List<URL> urls=new ArrayList<>(50);
    while (archives.hasNext())
      urls.add(((Archive)archives.next()).getUrl()); 
    return createClassLoader(urls.<URL>toArray(new URL[0]));
  }
  protected ClassLoader createClassLoader(URL[] urls) throws Exception {
    return new LaunchedURLClassLoader(isExploded(), getArchive(), urls, getClass().getClassLoader());
  }

3.3 执行main方法

  protected void launch(String[] args, String launchClass, ClassLoader classLoader) throws Exception {
    Thread.currentThread().setContextClassLoader(classLoader);
    createMainMethodRunner(launchClass, args, classLoader).run();
  }
  
  protected MainMethodRunner createMainMethodRunner(String mainClass, String[] args, ClassLoader classLoader) {
    return new MainMethodRunner(mainClass, args);
  }
package org.springframework.boot.loader;

import java.lang.reflect.Method;

public class MainMethodRunner {
  private final String mainClassName;
  
  private final String[] args;
  
  public MainMethodRunner(String mainClass, String[] args) {
    this.mainClassName=mainClass;
    this.args=(args !=null) ? (String[])args.clone() : null;
  }
  
  public void run() throws Exception {
    Class<?> mainClass=Class.forName(this.mainClassName, false, Thread.currentThread().getContextClassLoader());
    //获取主启动类的main方法
    Method mainMethod=mainClass.getDeclaredMethod("main", new Class[] { String[].class });
    mainMethod.setAccessible(true);
    //执行main方法
    mainMethod.invoke((Object)null, new Object[] { this.args });
  }
}

所以 SpringBoot 应用在开发期间只需要写 main 方法，引导启动即可。

下内容纯干货，需要理论知识的请自行查询。示例均在centos7环境下测试通过。

Nginx开机自启动

准备工作

1、 已根据自己的需求正确安装并配置Nginx服务（源码方式安装）

2、 可以正常启动关闭Nginx

3、 本文假定nginx安装目录为默认的/usr/local/nginx

配置

1、 编辑配置文件

2、 配置文件如下

3、 保存配置文件并退出，可以使用service命令或systemctl命令测试服务效果

Redis开机自启动

Redis本身没有nginx那种参数式的操作方式，所以自启动的服务配置方式也不同。

准备工作

1、 源码编译方式安装好redis软件并可以正常使用（如果是在线安装的方式会自带服务，不需要通过此方式配置）

2、 Redis需要配置以后台守护方式运行

3、 本文假定常规方式安装redis，安装目录/usr/local/redis，端口6379

配置

1、 编辑配置文件

2、 文件内容如下

3、 修改脚本执行权限

4、 将脚本添加到启动项中

5、 查看启动项

6、 开启自启动

7、 更多操作

启动：/etc/init.d/redisd start

关闭：/etc/init.d/redisd stop

重启：/etc/init.d/redisd restart

注：本配置中主要使用chkconfig命令操作，更多关于此命令的介绍可参考网络资料：

https://www.cnblogs.com/tiandi/p/7170905.html

重启计算机查看redis是否已启动

Jar包开机自启动

Jar包的启动，一种是简单的我们自己写脚本启动，另外一种功能更强大的的使用第三方工具Java Service Wrapper。今天主要介绍第一种，能够满足日常需要即可。

准备工作

1、 有一个可以运行的jar包（java -jar命令可执行），运行环境已配置好

配置

1、 编写jar包启动脚本，建议通过脚本启动jar包

示例：startJar.sh内容

记得修改此脚本的权限 chmod +x start.sh

2、 将执行脚本的命令添加到系统启动文件

保存文件并退出编辑器

这里有一个很重要的操作，修改rc.local文件的执行权限：

3、 重启计算机查看java进程即可

注：以上jar包的启动方式比较简单，只能达到开机启动的目的，并不能通过命令控制其启动、关闭及重启等，如果要达到更多控制功能，参考redis开机自启动的配置即可，原理差不多。


在线咨询
上一篇：巧用 CSS 实现酷炫的充电动画
下一篇：JavaScript 函数防抖

您的项目需求

*请认真填写需求信息，我们会在24小时内与您取得联系。

推荐阅读
友情链接 长清区 莱芜 清城区 林州市 扎囊县 普格县 网站制作
Copyright © 2002-2019 雨点网络设计有限公司 版权所有   冀ICP备11025394号
联系电话：   E-mail：279303980@qq.com  
主营业务：技术文章网站建设、网站定制、技术文章营销型网站建设、技术文章网站优化、技术文章微商城制作、三级分销系统开发
电话沟通
在线客服