{"id":510,"date":"2016-10-01T13:57:47","date_gmt":"2016-10-01T05:57:47","guid":{"rendered":"https:\/\/www.techcoil.com\/blog\/?p=510"},"modified":"2018-09-04T23:50:33","modified_gmt":"2018-09-04T15:50:33","slug":"how-to-manually-create-the-jar-file-for-running-your-java-application","status":"publish","type":"post","link":"https:\/\/www.techcoil.com\/blog\/how-to-manually-create-the-jar-file-for-running-your-java-application\/","title":{"rendered":"How to manually create the jar file for running your Java application"},"content":{"rendered":"

Advances in software engineering had shortened the time needed to build an application from scratch. For instance with Spring Boot<\/a>, I can easily build my own web API backed by a web server of my choice into a single jar file. By running that jar file, I can start a process that responds to HTTP requests directed at my customized endpoints.<\/p>\n

However, not knowing how that jar file is formed and read by the Java Virtual Machine can cloud our understanding of application development with Java. To help understand Java application development better, I described how to manually create a jar file for running a Java application.<\/p>\n

Defining a sample scenario<\/h2>\n

As the topic of this post is to document the process of manually preparing an executable jar file, I shall define a simple scenario for my Java application. <\/p>\n

Let's suppose that I want to build a Java application that downloads Techcoil's robots.txt and saves it in the same directory where my Java application resides in. <\/p>\n

To fulfil this requirement, I refer to my previous post on how to send HTTP GET request with Java without using any external libraries<\/a> to derive the following Java source file:<\/p>\n

\r\nimport java.io.ByteArrayOutputStream;\r\nimport java.io.IOException;\r\nimport java.io.PrintWriter;\r\nimport java.net.HttpURLConnection;\r\nimport java.net.URL;\r\nimport java.util.Scanner;\r\n\r\npublic class TechcoilRobotTxtDownloader {\r\n\r\n\tpublic static void main(String[] args) {\r\n\t\t\r\n\t\tByteArrayOutputStream responseBodyBaos = null;\r\n                Scanner httpResponseBodyScanner = null;\r\n                try {\r\n                    \/\/ Define server endpoint\r\n                    URL robotsUrl = new URL("http:\/\/www.techcoil.com\/robots.txt");\r\n                    HttpURLConnection urlConnection = (HttpURLConnection) robotsUrl.openConnection(); \r\n \r\n                    httpResponseBodyScanner = new Scanner(urlConnection.getInputStream());\r\n \r\n                    \/\/ Use a ByteArrayOutputStream to store the contents of the HTTP response body\r\n                    responseBodyBaos = new ByteArrayOutputStream();\r\n                    while(httpResponseBodyScanner.hasNextLine()) {\r\n                        responseBodyBaos.write(httpResponseBodyScanner.nextLine().getBytes());\r\n                    }\r\n                    responseBodyBaos.close();\r\n                    httpResponseBodyScanner.close();\r\n \r\n                    \/\/ Verify contents of robots.txt\r\n                    String robotsContent = responseBodyBaos.toString();\r\n                    if (robotsContent.trim().equals("Sitemap: http:\/\/www.techcoil.com\/sitemap-index.xml")) {\r\n                        System.out.println("Able to retrieve robots.txt from server. Server is running fine.");\r\n                \r\n                        \/\/ Save the robots content to file in the same directory\r\n                        PrintWriter printWriter = new PrintWriter("techcoil-robot.txt");\r\n                        printWriter.println(robotsContent);\r\n                        printWriter.flush();\r\n                        printWriter.close();\r\n                \r\n                    }\r\n                    else {\r\n                        System.out.println("Not able to retrive robots.txt from server.");\r\n                    }\r\n \r\n                } catch(IOException ioException) {\r\n                    System.out.println("IOException occurred while contacting server.");\r\n                    ioException.printStackTrace();\r\n                } finally {\r\n                    if (responseBodyBaos != null) {\r\n            \t        try {\r\n                                responseBodyBaos.close();\r\n            \t        } catch (IOException ioe) {\r\n            \t\t        System.out.println("Error while closing response body stream");\r\n            \t        }\r\n                    }\r\n                    if (httpResponseBodyScanner != null) {\r\n                        httpResponseBodyScanner.close();\r\n                    }\r\n                }\r\n\r\n\t}\r\n\r\n}\r\n<\/pre>\n
I added the block that utilized an instance of java.io.PrintWriter to write the contents of Techcoil's robots.txt. With that, I had created an Java application that can be run by the Java Virtual Machine. <\/p>\n
Running your Java application that is not contained in a jar file<\/h2>\n
To get a runnable Java application, we will first need to get the Java Compiler to compile TechcoilRobotTxtDownloader.java<\/code>:<\/p>\n
\r\njavac TechcoilRobotTxtDownloader.java\r\n<\/pre>\n
Once the Java compiler completed its job, we will get TechcoilRobotTxtDownloader.class<\/code> in the same directory where TechcoilRobotTxtDownloader.java<\/code> is located at. TechcoilRobotTxtDownloader.class<\/code> is our runnable Java application.<\/p>\n
To run our Java application, we will then run the following command:<\/p>\n
\r\njava TechcoilRobotTxtDownloader\r\n<\/pre>\n
Noticed that we do not specify the .class<\/code> extension in the input parameter to our java<\/code> executable. This will tell the Java Virtual Machine to look inside of TechcoilRobotTxtDownloader.class<\/code> and run the static main<\/code> method. <\/p>\n
So in short, we will need to provide the Java Virtual Machine with a .class file that contains a static main<\/code> method that contains the codes that will do what we wanted to do.<\/p>\n
Understanding how the Java Virtual Machine run your Java application which is contained in a jar file<\/h2>\n
Before going into the command to prepare the jar file, it is beneficial to understand how the Java Virtual Machine runs your Java application.<\/p>\n
By passing the name of the class (TechcoilRobotTxtDownloader) to the java<\/code> executable, the java<\/code> executable will be able to understand that there is a TechcoilRobotTxtDownloader.class<\/code> that it can find in the current directory. That is straightforward.<\/p>\n
In the case where our Java application is contained within a jar file, we have to make sure that our jar file contains a minimal file structure as follows:<\/p>\n
\r\nnameOfJar.jar\r\n|-- TechcoilRobotTxtDownloader.class\r\n|-- META-INF\r\n|   |-- MANIFEST.MF\r\n<\/pre>\n
With that, whenever the java<\/code> executable receives a .jar<\/code> file, it will look into the META-INF<\/code> directory inside the .jar file for a MANIFEST.MF<\/code> file. The MANIFEST.MF<\/code> will need to contain a directive to tell java<\/code> executable where to find the class that contains a static main<\/code> method to run. The META-INF<\/code> directory and MANIFEST.MF<\/code> file have to named as such, they cannot be give other names.<\/p>\n
Creating the manifest file that tells the java executable where to find the class that contains the static main method<\/h2>\n
To create a manifest file that tells the java executable where to find the class that contains the static main method, I run the following command in my shell, inside of the directory that contains TechcoilRobotTxtDownloader.class<\/code>:<\/p>\n
\r\nnano MANIFEST.MF\r\n<\/pre>\n
I then added the following line:<\/p>\n
\r\nMain-Class: TechcoilRobotTxtDownloader\r\n<\/pre>\n
and saved the changes.<\/p>\n
The Main-Class<\/code> directive tells the java executable to find TechcoilRobotTxtDownloader.class<\/code>, which contains the static main<\/code> method, in the same directory as the META-INF<\/code> directory. With this information, the java executable will then be able to know that I want to run TechcoilRobotTxtDownloader.class<\/code> that is contained within the jar file.<\/p>\n
Creating the executable jar file for running your Java application<\/h2>\n
After I had created MANIFEST.MF<\/code>, I then continued on to create the jar file. The JDK contains the jar<\/code> executable for us create jar files.<\/p>\n
To create the jar file, I run the following command in my terminal:<\/p>\n
\r\njar cvfm TechcoilRobotTxtDownloader.jar MANIFEST.MF TechcoilRobotTxtDownloader.class\r\n<\/pre>\n
The first input parameter contains four instructions for the jar<\/code> executable:<\/p>\n