使用Java后端操作Docker的详细教程_Java

一、为什么要用后端程序操作docker

docker 是现代开发和部署流程中不可或缺的一部分。它简化了应用程序的环境配置、打包和分发，使得在不同机器上运行相同的应用变得更加轻松和一致。本文将详细介绍如何使用命令行工具（cmd）操控 docker 来配置环境。

实现后端操作docker，可以用来实现云端ide、一键环境搭建、多人协作环境、互动编程教学、可视化部署和管理等等功能。是docker从服务器走向客户端的必经之路。

二、安装docker

1、安装docker

我写过一份详细的博客，请移步：docker的基本概念、安装步骤以及一些简单的用法_docker_代码网

2、启动docker

安装完成后，启动 docker desktop，并确保其正常运行。可以在 cmd 中通过以下命令来验证：

docker --version

三、使用java后端操作docker

1、构建docker镜像并生成容器

这一步的目的是通过docker根据本地目录中的dockerflie文件、代码、和其他配置数据文件生成新的镜像，并生成容器。

一个简单的dockerfile示例：

# 使用官方python运行时作为父镜像
from python:3.8-slim
 
# 设置工作目录
workdir /app
 
# 将当前目录内容复制到位于/app中的容器中
copy . /app
 
# 安装requirements.txt中指定的任何所需包
run pip install --no-cache-dir -r requirements.txt
 
# 使端口80可供此容器外的环境使用
expose 80
 
# 定义环境变量
env name world
 
# 在容器启动时运行app.py
cmd ["python", "app.py"]

其中0419test是构建镜像的tag名。

注意修改工作目录，将其改为你实际的文件夹目录。

    public void buildimageandcontainer(){
        try {
            // 设置第一个命令：构建docker镜像
            processbuilder buildprocessbuilder = new processbuilder("docker", "build", "-t", "test0419", ".");
 
            // 设置工作目录为 "e:\\code\\docker\\test"
            buildprocessbuilder.directory(new file("e:\\code\\docker\\test"));
 
            // 启动构建镜像的命令并等待其完成
            process buildprocess = buildprocessbuilder.start();
            buildprocess.waitfor();
 
            // 读取并打印出构建镜像的输出
            printprocessoutput(buildprocess);
 
            // 检查构建是否成功
            if (buildprocess.exitvalue() == 0) {
                // 设置第二个命令：运行docker容器
                processbuilder runprocessbuilder = new processbuilder("docker", "run", "-v", "e:/code/docker/test:/app", "-p", "80:80", "test0419");
 
                // 启动运行容器的命令
                process runprocess = runprocessbuilder.start();
 
                // 读取并打印出运行容器的输出
                printprocessoutput(runprocess);
 
                // 可以在这里等待容器运行的进程结束，或者根据需要进行其他操作
                // runprocess.waitfor();
            } else {
                system.out.println("docker image build failed.");
            }
        } catch (ioexception | interruptedexception e) {
            system.out.println(e);
            e.printstacktrace();
        }
    }
 
    // 输出打印内容的私有方法
    private static string printprocessoutput(process process) throws ioexception {
        string output;
        string errorinfo;
        // 读取并打印标准输出
        output = readandprint(process.getinputstream(), "");
        // 读取并打印标准错误
        errorinfo = readandprint(process.geterrorstream(), "");
        return output+errorinfo;
    }
    private static string readandprint(inputstream inputstream, string prefix) throws ioexception {
        stringbuilder output = new stringbuilder();
        try (bufferedreader reader = new bufferedreader(new inputstreamreader(inputstream))) {
            string line;
            while ((line = reader.readline()) != null) {
                output.append(prefix).append(line).append(system.lineseparator());
                system.out.println(prefix + line); // 同时打印到控制台
            }
        }
        return output.tostring();
    }

2、执行完毕后删除容器和镜像

删除容器和镜像，释放资源，一般在容器执行完代码之后运行。

    // 删除容器和镜像
    public string deletecontainerandimage(string imagename){
        // 定义一个线程池用于执行删除操作
        executorservice executorservice = executors.newfixedthreadpool(2);
 
        // 异步获取容器 id 列表并删除容器
        executorservice.submit(() -> {
            try {
                list<string> containerids = new arraylist<>();
                string command = "docker ps -a -q --filter ancestor=" + imagename;
                processbuilder processbuilder = new processbuilder(command.split(" "));
                process process = processbuilder.start();
 
                bufferedreader reader = new bufferedreader(new inputstreamreader(process.getinputstream()));
                string line;
                while ((line = reader.readline()) != null) {
                    containerids.add(line.trim());
                }
 
                int exitcode = process.waitfor();
                if (exitcode != 0) {
                    system.err.println("command executed with error. exit code: " + exitcode);
                    return ;
                }
 
                // 删除容器
                for (string containerid : containerids) {
                    string deletecontainercommand = "docker rm -f " + containerid;
                    executecommand(deletecontainercommand);
                }
 
            } catch (ioexception | interruptedexception e) {
                e.printstacktrace();
            }
        });
 
        // 异步删除镜像
        executorservice.submit(() -> {
            // 等待容器被删除
            try {
                timeunit.seconds.sleep(5); // 等待5秒，可以根据实际情况调整
                // 同样，如果你使用的是docker，可以使用以下命令：
                string deleteimagecommand = "docker rmi " + imagename;
                executecommand(deleteimagecommand);
            } catch (interruptedexception e) {
                e.printstacktrace();
            }
        });
 
        // 关闭线程池
        executorservice.shutdown();
 
        return "镜像与容器已删除";
    }
 
    // 用来执行cmd命令的方法
    private void executecommand(string command) {
        try {
            // 使用processbuilder执行命令
            processbuilder processbuilder = new processbuilder(command.split(" "));
            process process = processbuilder.start();
 
            // 调用已有的方法来打印输出
            printprocessoutput(process);
 
            // 等待进程结束
            int exitcode = process.waitfor();
            if (exitcode != 0) {
                // 处理非零退出码，可能表示命令执行出错
                system.err.println("command executed with error. exit code: " + exitcode);
            }
        } catch (ioexception e) {
            // 处理命令执行过程中可能遇到的io异常
            e.printstacktrace();
        } catch (interruptedexception e) {
            // 如果waitfor()方法被中断，重新设置中断状态并处理
            thread.currentthread().interrupt();
            e.printstacktrace();
        } catch (exception e) {
            // 处理命令字符串分割可能出现的异常
            e.printstacktrace();
        }
    }

3、在此基础上开发其他功能

在生成与删除之间，就可以自由添加和微调其中的部分步骤，比如删除dockerfile中的cmd ["python", "app.py"]，让容器持续化后台运行，这样就可以通过宿主机与容器的文件映射关系修改代码内容，然后择机运行代码了；又比如创建一个满足需求的镜像，然后只创建和删除容器来节省服务器资源等等。