{"id":70418,"date":"2017-11-14T07:00:16","date_gmt":"2017-11-14T05:00:16","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=70418"},"modified":"2023-12-11T10:27:59","modified_gmt":"2023-12-11T08:27:59","slug":"docker-java-developers-build-docker","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2017\/11\/docker-java-developers-build-docker.html","title":{"rendered":"Docker for Java Developers: Build on Docker"},"content":{"rendered":"

This article is part of our Academy Course titled Docker Tutorial for Java Developers<\/a>.<\/p>\n

In this course, we provide a series of tutorials so that you can develop your own Docker based applications. We cover a wide range of topics, from Docker over command line, to development, testing, deployment and continuous integration. With our straightforward tutorials, you will be able to get your own projects up and running in minimum time. Check it out here<\/a>!<\/em><\/p>\n

\n

Table Of Contents<\/h3>\n
\n
1. Introduction<\/a><\/dt>\n
2. Under the Magnifying Glass<\/a><\/dt>\n
3. Gradle and Docker<\/a><\/dt>\n
4. Gradle on Docker<\/a><\/dt>\n
5. Maven and Docker<\/a><\/dt>\n
6. Maven on Docker<\/a><\/dt>\n
7. Conclusions<\/a><\/dt>\n
8. What\u2019s next<\/a><\/dt>\n<\/dl>\n<\/div>\n

<\/a>1. Introduction<\/h2>\n

Over the first few parts of the tutorial we went through basics of the Docker<\/a> and the multitude of the ways to interface with it. It is time to apply the knowledge we have acquired to real-world Java projects, starting the discussion from the topic of how Docker<\/a> affects the well-established build processes and practices.<\/p>\n

Fairly speaking, the goal of this section is two-fold. First, we will take a look at how the existing build tools, namely the Apache Maven<\/a> and Gradle<\/a>, are helping to package Java applications as Docker<\/a> containers. Secondly, we will push this idea even further and learn how we could use Docker<\/a> to entirely encapsulate the build pipeline of our Java applications and produce the final Docker<\/a> images at the end.<\/p>\n

<\/a>2. Under the Magnifying Glass<\/h2>\n

To experiment with, we are going to design two simple (but nonetheless meaningful) Java web applications which would implement and expose the REST(ful) APIs<\/a> for tasks management.<\/p>\n

The first application is going to be developed on top of Spring Boot<\/a> and Spring Webflux<\/a>, using Gradle<\/a> as build and dependency management tool. In terms of versions, we will be using Spring Boot<\/a> latest milestone 2.0.0.M6<\/code>, Spring Webflux<\/a> latest release 5.0.1<\/code> and Gradle<\/a> latest release 4.3<\/code>.<\/p>\n

The second application, while functionally equivalent to the first one, will be developed on top of another popular Java framework, Dropwizard<\/a>, this time using Apache Maven<\/a> for build and dependency management. In terms of versions, we are going to bring Dropwizard<\/a> latest release 1.2.0<\/code> and Apache Maven<\/a> latest release 3.5.2<\/code>.<\/p>\n

As we mentioned, both applications would implement and expose the REST(ful) APIs<\/a> for tasks management, essentially wrapping the CRUD<\/a> (create, read, update and delete) operations.<\/p>\n

    GET     \/tasks\n    POST    \/tasks\n    DELETE  \/tasks\/{id}\n    GET     \/tasks\/{id}\n<\/pre>\n
The task itself is modeled as a persistent entity<\/a> which is going to be managed by Hibernate ORM<\/a> and stored in the MySQL<\/a> relation database.<\/p>\n
@Entity \n@Table(name = \"tasks\")\npublic class Task {\n    @Id\n    @GeneratedValue(strategy = GenerationType.IDENTITY)\n    @Column(name = \"id\")\n    private Integer id;\n    \n    @Column(name = \"title\", nullable = false, length = 255)\n    private String title;\n    \n    @Column(name = \"description\", nullable = true, columnDefinition = \"TEXT\")\n    private String description;\n    \n    \/\/ Getters and setters are omitted\n    ...\n}\n<\/pre>\n
At this point, the similarities between both applications end and each of them is going to follow its own idiomatic way of development.<\/p>\n
<\/a>3. Gradle and Docker<\/h2>\n
So the ground is set, let us begin the journey by exploring what it takes to integrate Docker<\/a> into typical Gradle<\/a> build. For this subsection you would need to have Gradle<\/a> 4.3<\/code> installed on your development machine. If you don\u2019t have it yet, please follow the installation instructions<\/a> by choosing any suggested method you prefer.<\/p>\n
In order to package a typical Spring Boot<\/a> application as a Docker<\/a> image using Gradle<\/a>\u00a0we just need to include two additional plugins in build.gradle<\/code> file:<\/p>\n