使用Dockerfile部署springboot打包jar包

Posted 2023-04-25 逆梦

1、docker下载JDK1.8镜像

docker pull java:8

2、进行需要编译的镜像文件目录编写Dockerfile文件

#依赖的父镜像
FROM java:8
#作者
MAINTAINER docker-admin
#jar包添加到镜像中
ADD xxl-job-admin-2.1.2.jar xxl-job-admin.jar
#容器暴露的端口 即jar程序在容器中运行的端口
EXPOSE 8080
#容器启动之后要执行的命令
ENTRYPOINT ["java","-jar","-Dspring.datasource.url=jdbc:mysql://mysql-server:3306/xxl_job?Unicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai","xxl-job-admin.jar"]

3、打包docker镜像

docker build -t xxl_job_admin:1.0 .  #后面要跟 . 表示当前目录

打包成功。查看编译镜像文件。

docker images

3、启动docker镜像

docker run -d --privileged=true -p 8080:8080 --name xxl-job-admin --link mysql-server xxl_job_admin:1.0  # --link mysql-server 表示容器互联  需要指定mysql容器，不然连接不上数据库

 

容器启动成功。。。。

4、查看容器日志

查看启动的容器实例ID：docker ps 

查看容器的启动日志：docker logs 实例ID

容器启动成功。页面访问后端连接地址成功！！

Docker——使用Dockerfile构建SpringBoot项目（打包 & 部署 & 运行）

1.开篇

我们都知道SpringBoot项目在完成之后，可以进行打包，打包的方式一般有两种：jar、war。

听大牛讲授：未来jar包的方式将会是主流，因为越来越多的开发模式都转成了前后端分离这种技术，也就是说，我们后端开发工程师面对的全是Java后端代码，一个jar包不会出现任何的前端页面代码，我们需要交付给前端H5工程师的只是RESTful接口，他们拿到这些接口去测试就可以了。

那么war包这种形式，更多的就是采用jsp页面实现，讲jsp与Java代码耦合到一起，也就是说前后端都混在了一起，这种开发模式在效率、性能上自然比不上前后端分离的这种模式。

所以这里使用Dockerfile构建SpringBoot项目，我只做了将SpringBoot项目打jar包的步骤，war包我就不再做了。

---

2.案例详解

2.1 SpringBoot代码部分

首先是pom依赖，可以添加这个 <packaging>jar</packaging>，不添加也没事，默认就是打jar包。

    <dependencies>

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

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

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>

        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.*</include>
                </includes>
            </resource>
        </resources>
    </build>

下面分别是核心配置文件、实体类、mapper接口/映射文件、service、controller。

server.port=8001
server.servlet.context-path=/springboot-docker

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://192.168.40.130:3306/db01?useUnicode=true&characterEncoding=utf8&useSSL=false
spring.datasource.username=root
spring.datasource.password=12345678

package com.szh.springboot.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 *
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserInfo implements Serializable {

    private static final long serialVersionUID = -791207650334505838L;
    private Integer id;
    private String name;
    private Integer age;

}

package com.szh.springboot.mapper;

import com.szh.springboot.domain.UserInfo;
import org.apache.ibatis.annotations.Param;

/**
 *
 */
public interface UserInfoMapper {

    UserInfo selectByPrimaryKey(@Param("id") Integer id);
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.szh.springboot.mapper.UserInfoMapper">
    <!-- 使用insert、update、delete、select标签编写sql语句 -->

    <resultMap id="BaseResultMap" type="com.szh.springboot.domain.UserInfo">
        <id column="id" property="id" jdbcType="INTEGER"/>
        <result column="name" property="name" jdbcType="VARCHAR"/>
        <result column="age" property="age" jdbcType="INTEGER"/>
    </resultMap>

    <sql id="Base_Column_List">
        id, name, age
    </sql>

    <select id="selectByPrimaryKey" resultMap="BaseResultMap">
        select <include refid="Base_Column_List"/>
        from userinfo
        where id=#{id}
    </select>

</mapper>

package com.szh.springboot.service;

import com.szh.springboot.domain.UserInfo;

/**
 *
 */
public interface UserInfoService {

    UserInfo queryByPrimaryKey(Integer id);
}

package com.szh.springboot.service.impl;

import com.szh.springboot.domain.UserInfo;
import com.szh.springboot.mapper.UserInfoMapper;
import com.szh.springboot.service.UserInfoService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 *
 */
@Service
public class UserInfoServiceImpl implements UserInfoService {

    @Resource
    private UserInfoMapper userInfoMapper;

    @Override
    public UserInfo queryByPrimaryKey(Integer id) {
        return userInfoMapper.selectByPrimaryKey(id);
    }
}

package com.szh.springboot.controller;

import com.szh.springboot.service.UserInfoService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 *
 */
@RestController
public class UserInfoController {

    @Resource
    private UserInfoService userInfoService;

    @GetMapping(value = "/queryUser/{id}")
    public Object queryUser(@PathVariable("id") Integer id) {
        System.out.println("SpringBoot项目打jar包部署Docker成功！！！");
        return userInfoService.queryByPrimaryKey(id);
    }
}

以上就是SpringBoot项目的全部后端代码，因为这里的数据库我采用的是：docker中mysql镜像运行生产的容器实例，所以，要想测试，这里首先将docker服务启动、mysql镜像启动。

2.2 Docker实操部分

上面我已经将mysql镜像启动，对应的mysql容器实例也已经跑起来了，之后我使用Navicat工具连接上docker中的mysql，同时完成建库、建表等操作。

此时我们的mysql启动了，数据也添加了，可以先启动一下这个SpringBoot项目，看看运行能否成功，见下图：👇👇👇

成功之后，我们进行打包操作。

 maven打包操作，这里直接package就不再多说了。

打包完成之后，我在根目录下创建了一个 springboot-for-docker 目录，专门存放打包后的jar包以及Dockerfile文件。

rz 命令直接将打好的jar包上传到linux，然后编写Dockerfile。

我们这里打包是jar，所以基础镜像肯定是 jdk；如果是war包，则基础镜像就是tomcat。ADD这里将该jar包复制并且构建、同时重命名为 app.jar；对外暴露的端口号对应application.properties核心配置文件中的 server.port；最后的ENTRYPOINT、CMD表示容器启动时需要运行的命令。

Dockerfile文件编写完成，下面就是docker build以该文件为基础构建新的镜像。因为当前构建的目录就是Dockerfile所在的目录，所以命令中的 -f Dockerfile 可以省略，-t 表示新构建镜像的名称，最后的 . 表示当前目录。

构建完成，docker images即可查看。

最后一步docker run运行，这里docker映射该springboot项目的端口号为8001，-d 这里后台启动。

启动完成，docker ps 可以看到当前正在运行的容器实例，一个是前面提到的mysql，另一个是springboot项目。

此时就可以到浏览器中访问，这里不再是localhost，而是虚拟机的ip。

访问一次之后，可以使用 docker logs -f 查看指定容器的日志信息，在其中能够看到这里打印出了 controller 请求中System.out.println的那句话。

至此，使用Dockerfile构建SpringBoot项目（打包 + 部署 + 运行）就全部完成了！！！