Handling file upload With JSP

On web application, sometimes we need an interface that user can use to upload file to a server. Uploading file is an activity to add or copying file to a computer system with move a file that located on a local computer to a remote computer. We often meet the uploading file system on a web application. For example, web-mail application, web-mail application use file upload system as a feature for user who wants send an email with the attachment.

On java web application, uploading file has its own process, because, the concept of uploading file is different and little bit complicated. Even though there’s a lot java library that can make us creating File upload system easily, but there’s still plenty of developer who make their own File Upload system mechanism.

And now we will try to handle File Upload system on java. in order to make this File Upload system easier to understand, we will try it on jsp’s. We will also use the java library in this project. The libraries are common-file-upload released by Apache Foundation on their jakarta-common project. Please download this common-file-upload library here. And we also need another library, which is common-io library, this library is also from jakarta-common-project, please download the library here.

Now we go straight to the scenario of this file upload system:

  1. User open a form on our web application, and there’s a field that user have to fill to upload a file.

  2. The upload file will be handled by a process, and the file that uploaded by user will be located in a folder on our web application, the name of the folder is /file_uploaded.

  3. This /file_uploaded folder located on {app-serv}/webapps/{appl-context}/ where the {app-serv} is an installation folder of your application server (Tomcat, Jboss, Glassfish, etc) and {app-context} is our web application installation folder

For your next future development, please try to located the file that user uploaded not into a folder that located in app-context, but please located outside your {app-serv}.

Base on above scenario, that’s mean we will need a form with a standard html form with the enc-type is multipart/form-data. Why should be multipart/form-data? Because only this type of form can carry the data not only characters, but also can carry the data as a file. At the process, actually, the form will change the uploaded file into a byte-stream that will be carried through TCP/IP ports.

Unfortunately this blog didn’t allow us to write some html code, so please just download the source of the project here. After you’ve download, let’s discuss this form_upload.html file. As you can see, that on a line <form action=”process_upload.jsp” method=”post” enctype=”multipart/form-data”> there’s a sentence enctype=”multipart/form-data”, this is the things that makes a different between this file and others standard html form, this kind of form which can carry the file onto a remote/server computer.

On that line too, we can see the process of file will go thru and handled by process_upload.jsp. This process_upload.jsp file have a duty to receive a file sent by file_upload.html and then process the uploaded file by put it onto destination folder.

Now, let’s see the code on process_upload.jsp file:

<%@ page import="org.apache.commons.fileupload.DiskFileUpload" %>
<%@ page import="org.apache.commons.fileupload.FileItem" %>
<%@ page import="org.apache.commons.fileupload.FileUpload" %>
<%@ page import="java.io.File" %>
<%@ page import="java.util.Iterator" %>
<%@ page import="java.util.List" %>
<%
    String test="";
    File savedFile = null;
    boolean isMultipart = FileUpload.isMultipartContent(request);
    if (!isMultipart) {
        System.out.println(" Form Is not Multipart...!!!");
        return;
    }
    DiskFileUpload upload = new DiskFileUpload();
        List items = null;
        try {
            items = upload.parseRequest(request);
        } catch (Exception e) {
            System.out.println("Exception = " + e.getMessage());
        }

        Iterator itr = items.iterator();
        while (itr.hasNext()) {
            FileItem item = (FileItem) itr.next();
               if (item.isFormField()){
                 test = request.getParameter("test");
              }else{
                File fullFile = new File(item.getName());
                System.out.println("Full File : " + fullFile);

                String sPath = getServletConfig().getServletContext().getRealPath("/file_uploaded");
                System.out.println("Path of saved =" + sPath);

                File savedFile = new File(sPath, fullFile.getName());

                try {
                    item.write(savedFile);
                } catch (Exception e) {
                    System.out.println("Error Happen when saving the file :" + e.getMessage());
                }
            }
......

Lets’ discuss above code :

<%@ page import="org.apache.commons.fileupload.DiskFileUpload" %>
<%@ page import="org.apache.commons.fileupload.FileItem" %>
<%@ page import="org.apache.commons.fileupload.FileUpload" %>
<%@ page import="java.io.File" %>
<%@ page import="java.util.Iterator" %>
<%@ page import="java.util.List" %>

These lines is lines about how jsp can import the classes the might be needed later. Also in these lines, we can see the library of common-file-upload belongs to apache imported, there’s also another lines to import another java which is: java.io.File, java.util.Iterator, dan java.util.List.

And the next lines is

     String test="";
     File savedFile = null;
     boolean isMultipart = FileUpload.isMultipartContent(request);
    if (!isMultipart) {
        System.out.println(" Form Bukan Multipart...!!!");
        return;
    }

In these lines, we can see that there’s a variable named test which is String type, savedFile which is File type, and isMutipart as a boolean type, those variable directly initialized, to check whether the sender form is multipart/form-data type or not. If the sender form is not multipart type, then the process just ended by adding code return; on a lines, after print out information that the sender form is not multipart type.

If the form is multipart type so the process will continue with these lines below:

       DiskFileUpload upload = new DiskFileUpload();
        List items = null;
        try {
            items = upload.parseRequest(request);
        } catch (Exception e) {
            System.out.println("Exception = " + e.getMessage());
        }

On these lines, there’s a new instantiated object mentioned as a variable which is named as upload. And there’s another variable declaration, named items with List type, but this variable filled with the null value. And then, there’s a try-catch block, with the statement try to parse the request that sent by the sender form and then the result of the parse filled in items variable that declared before. If process failed when parsing the request from the sender form, the code will pint out the Exception.

And then the next lines is:

    Iterator itr = items.iterator();
        while (itr.hasNext()) {
            FileItem item = (FileItem) itr.next();
        if (item.isFormField()){
                 test = request.getParameter("test");
              }else{
                File fullFile = new File(item.getName());
                System.out.println("File Lengkap : " + fullFile);

                String sPath = getServletConfig().getServletContext().getRealPath("/file_uploaded");
                System.out.println("Lokasi penyimpanan file =" + sPath);

           savedFile = new File(sPath, fullFile.getName());

                try {
                    item.write(savedFile);
                } catch (Exception e) {
                    System.out.println("Ada Kesalahan ketika menyimpan File :" + e.getMessage());
                }
            }
        }

Ok, this part is little bit difficult to explain, but let’s try to explain it. On the first line, there’s a initialize of Iterator object named as itr variable, which is the value directly filled by iterating items variable which had FileItem as a type and processed. And then this item variable checked, if item is field form so the test variable that declared above, filled by the value which is taken from sender form which is not a file.

And the opposite of above process, if item is not a field form, and we can assume directly that the item is a file that needs to upload. So, let’s take the file by creating new object with File type and named the variable as fullFile, and then fill the value of this variable by taking the item name. Next we’ll try to print-out to find out what file sent by form.

And then we create new variable here called sPath with String the string as a type, this variable is made in order to define the location of the uploaded file will be saved.

In these lines we can see that the uploaded file will be saved on a folder called file_uploaded which is located on our web app installation. After we define the location of the saved file, now we do the processing of save file.

The next lines, there’s an object variable with File type called savedFile that we declared before, the value of this object variable filled by creating new File object that arrange based on file location(sPath) and the name of file fullFile.getName().

After this object is created, then we try to write new file by calling write methods that owned by item variable which FileItem type. And don’t forget to put the code on try-catch block to catch the error that could be happen if the file cannot be saved on the destination folder.

To try out the source that maybe you have download, just copy the whole source of the project to your {app-serv}/webapps/. Where {app-serv} is a folder where your Application Server or Your Servlet Container such as Tomcat installed. No need to compile here, cos the source only contains jsp’s and the library that needed. These source files is put and arranged in the correct location, so you just need to copy into your webapps folder and the restart your Application Server/Servlet Container.

Thnks

I Hope this Will Helpfull

Josescalia

Advertisements

Saya, Ijasah, dan Kembali Kuliah

Ada kejanggalan ketika saya kembali memasuki dunia kuliah. Saya kembali mengambil kuliah setelah sebelumnya gagal mencapai gelar sarjana S1. Dulu saya kuliah di STKIP PGRI Jakarta kampus A, sekarang UNINDRA (Universitas Indraprasta) namanya. Saya ambil jurusan Bahasa dan Sastra Indonesia. Saya gagal waktu itu karena ketika dulu ingin memasuki skripsi saya diwajibkan untuk ikut PPL (Pengalaman Pendidikan Lapangan) sebagai suatu syarat untuk bisa Sidang Skripsi dan mendapatkan Ijasah Akta IV (Ijasah untuk mengajar). Untuk ikut PPL itu saya tidak bisa karena saya sedang asyik menjadi seorang karyawan kantoran yang sehari-harinya duduk didepan komputer untuk meng-arange suatu file midi guna dijadikan ringtone. Saya terlalu asyik dan amat menyukai pekerjaan saya, sehingga saya memutuskan untuk berhenti kuliah saja, padahal hanya tinggal PPL dan Skripsi.

Seiring dengan perjalanan saya menjadi karyawan, saya di promosikan untuk menjadi seorang System Analyst dan Java Programmer di perusahaan tempat saya bekerja. Saya ambil saja karena menurut saya, kita kerja harus punya kemajuan jangan cuma stuck di tempat yang itu-itu saja. Promosi yang jatuh ke tangan saya bukan tanpa sebab. Atasan saya sebelumnya memang sudah tahu bahwa saya sudah bisa me-mrogram dan melakukan pekerjaan IT lainnya sejak lama. Jadilah saya seorang System Analyst dan Java Programmer tanpa IJASAH.

Saya tahu ada kelemahan pada saya. Bahwa saya tidak mempunyai selembar surat sakti yang saya sebut IJASAH. Oleh karena itu, tanpa pikir panjang saya melanjutkan kuliah lagi dan saya berniat kali ini saya harus lulus, tidak boleh tidak lulus, meski cuma D3, tapi masih lebih baik daripada kuliah tapi tidak pernah punya IJASAH sama sekali. Kali ini saya ambil jurusan Manajemen Informatika di Bina Sarana Informatika.

Hari pertama masuk kuliah saya ragu, dan mungkin sedikit grogi, bagaimana tidak, usia saya genap 29 tahun saat itu dan saya mau tidak mau harus bercampur dengan teman-teman yang usianya lebih muda 6 hingga 10 tahun dari saya. Saya sudah beristri dan mempunyai seorang anak perempuan yang sangat cantik (Thnks God…!!). Dan teman-teman kuliah saya masih asyik ber-romansa menjalani masa pacarannya.

Awalnya saya ingin keep my personality. Tapi akhirnya saya jujur kepada teman-teman kuliah saya tentang saya sebenarnya ketika mereka bertanya. Most of them tertarik pada pekerjaan saya, karena dosen-dosen dikampus sering kali menceritakan betapa enaknya jadi seorang programmer.

Pada perkuliahan yang berjalan, saya nyaris tidak punya kesulitan menghadapi kembali materi kuliah yang diberikan dosen, terutama mata kuliah – mata kuliah yang berhubungan dengan IT. Bahkan terkadang saya sering menjumpai asisten-asisten dosen yang menghindar dari pertanyaan-pertanyaan saya seputar materi kuliah. Padahal saya memang bertanya karena saya tidak tahu atau saya tidak mengerti bukan bertanya untuk menguji kemampuan seorang dosen atau asisten dosen. Saya bukan tipe orang yang suka menguji orang lain. Buat saya tidak ada untungnya. Misal ketika belajar PASCAL memang saya tidak tahu syntaxnya, saya pasti tanya karena saya memang tidak pernah tahu pascal, saya mengerti logika programnya tapi syntaxnya saya tidak tahu, itulah yang saya tanyakan. Salam buat AssDos-ku (Endah) yang manis. He..he.he.he…

Ok, let’s talk about my college friend. Ada sekitar 20-an teman yang biasa saya habiskan jam-jam sebelum dan sesudah kuliah untuk hang-out bersamanya. Main futsal, belajar bareng, jalan-jalan, dan diskusi, serta debat kusir, itulah yang sering saya lakukan diluar jam-jam kuliah. Buat saya kegiatan seperti itu mampu membuat saya fresh dari rutinitas pekerjaan yang tiap hari selalu saya lakukan. Sebagian besar dari mereka juga sudah bekerja, ada Aris yang teknisi listrik, ada Ari yang seorang Data Entry, ada Eka seorang operator mesin industri di sebuah pabrik di Jak-Tim, ada juga Lidya seorang Resepsionis di pusat pertokoan elite Jakarta. Yang terakhir saya sebutkan adalah satu-satunya perempuan yang mau hang-out bersama saya dan teman-teman saya yang lain. Dan masih banyak lagi yang lain.

Lantas apa yang janggal dari permulaan kalimat di atas, saya tidak tahu, kalo janggal kemudian saya tahu bukan janggal namanya, tapi jelas. Yang pasti Saya, Ijasah dan Kembali Kuliah adalah satu hal yang janggal, yang saya tidak pernah tahu sebabnya kenapa saya bilang janggal.


Menteng 29, Juni 2008

Josescalia

Adding Log4J on a Java Web Application

Logs on a web application make us easier to trace a flow of a process. Log is also become a tools for us to trace an error that might be happen on our web application, so we can trace where’s exactly the error happen by monitoring the stopped process. What kind of method or function that might be created based on wrong logic, or maybe other mistaken that we created when we arrange the code.

On java programming language, there’s a few library that we can use to adding log. Some of those libraries become a standard production of a web application. Practically, log made their own record file, this file is created in order to write all the process that we feel so important to tracing a data flow. Log recording on web application usually separated by the web application that we’ve made in order to make easier for us to trace data flow in each web application.

This time, we will try to add log on our web application, using the library that released by the Apache Foundation which is Log4J library. Just because we will need this library, so please download this library here, while in this sample project I will use log4j library version 1.2.8. if you want to use the latest library, go a head. And I will also use a Servlet Container Apache Tomcat 5.5 that I use very often to create a web application.

The important things that we have to understand when the Tomcat is started is Tomcat will read all the web application setting through a file called web.xml that exist on WEB-INF directory on each our web application folder. And all the libraries that we use in our web application, have to be put on WEB-INF/lib folder at each web application that we have made.

The scenario of adding log4j on a web application, based on understanding of a Servlet Container behavior above is: running out a servlet that containing a method to set the log4j. Just because the Tomcat will read web.xml file, so this log4j calling method will be placed in this web.xml, this calling method is a servlet that will run on the first load of tomcat. And don’t forget to put the libraries of this log 4j on a WEB-INF/lib folder on our web application.

Ok, let’s create a servlet that have a function to set this log4j platform. below is the source code of the servlet, let’s name this servlet with Log4JInitServlet name. Thise servlet is an extends of HttpServlet class, so we can override few methods belongs to HttpServlet class. 

 

package org.mojo.app.web.servlet;

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;

import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class Log4JInitServlet extends HttpServlet{
    static Logger logger = Logger.getLogger(Log4JInitServlet.class.getName());
 public void init(ServletConfig sc) throws ServletException {
        super.init(sc);
        ServletContext context = getServletContext();
        //find out where this web application is located on machine and print it out
        String sPath = context.getRealPath("/");
        System.out.println("Application Path :" + sPath);

        //finding log4j configuration file on web.xml
        String sLogConfigFile = getInitParameter("log4j-init-file");
        System.out.println("LogConfig: " + sLogConfigFile);

        //configuring Log4J System using PropertyConfigurator Class
        PropertyConfigurator.configure(sLogConfigFile);
        logger.info("Logger has been initialized...");
    }

    public void destroy() {
        super.destroy();
        logger.info("Destroy");
    }

    protected void doPost(HttpServletRequest req, HttpServletResponse res)
       throws ServletException, IOException {
        logger.info("doPost()");
    }

    protected void doGet(HttpServletRequest req, HttpServletResponse res)
        throws ServletException, IOException {
        logger.info("doGet()");
    }
}

Let’s discuss code above before we go to the next step.

package org.mojo.app.web.servlet;

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;

import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

In this block we describe the package of this servlet located, we also import some classes that we might be need it later. And then we will create codes to define this class and also static variable logger as a Logger that we will use. Here’s the code:

public class Log4JInitServlet extends HttpServlet {
    static Logger logger = Logger.getLogger(Log4JInitServlet.class.getName());
    ........

}

And then, we create a method that overriding a method from HttpServlet class which is Init method, on it’s super class this method have a public as it’s modifier access, and also have a parameter, and last but not least, it’s has a ServletException.throws. below is the code of the method.

public void init(ServletConfig sc) throws ServletException {
    .........
}

In this method we will put the setting of log4j configuration for our web application, and now let’s see the screen-shot of the code:

  super.init(sc);
  ServletContext context = getServletContext();
  //find out where this web application is located on machine and print it out
  String sPath = context.getRealPath("/");
  System.out.println("Application Path :" + sPath);

On the first line we call the method that inherited from the HttpServlet class, and then the second line of the code we define a variable named context which has a ServletContext as a\it’s data type, the third line is comments,. And then the fourth lines, we define a variable called String sPath that it’s value directly filled with the value that we took from the real-path of the context variable that we have define before, in order to print out to the console. Actually this lines is an option whether to use it or not, because the essence of this line is to figure out where is our web application located.

OK let’s take a look of the next code:

   //finding log4j configuration file on web.xml
   String sLogConfigFile = getInitParameter("log4j-init-file");
   System.out.println("LogConfig: " + sLogConfigFile);

   //configuring Log4J System using PropertyConfigurator Class
   PropertyConfigurator.configure(sLogConfigFile);
   logger.info("Logger has been initialized...");

On the first line there’s a comment tell us that the lines below will searching the configuration file on web.xml. It’s seen on the second line, we declare a variable called sLogConfigFile and the value direcly filled by the value that we took from a servlet parameter that we will configure later on web.xml file, the name of the parameter is “log4j-init-file”. Later on the web.xml file, we will add a lines like this <param name>log4j-init-file</param name>, and below of these line, we will add one line again contain <param value>…..</param value> where the blanks is value of the log4j-init-file parameter.

On the next lines there’s a comment too, that the meaning of the comment is about “Configuring the Log4J System by using propertyConfigurer”. In the code practically, to configure this log4j, we just call a method named configure that owned by PropertyConfigurator class. If the configuration configured successfully, then we just call the instance of log4j library with calling the method named info and fill the parameter with “Logger has beed initialized” string.

It’s highly need to remember that if this string is printed out on the log file, mean that we configured the log for our web application successfully, so for other method we only just call this info method. And also for other class that we will make later. We just call this info method to entering to the log which point we want to record. But don’t forget to declare the log variable first and located in the header of the class just like the sample shows us.

Practically, the log that we made will have two log records. The first one is containing normal log, and the second log is contains error log of the data flow. To call error method in order to fill out the error log, same as we call info method, but change the word info and replaced with the word error.

Besides that, in this servlet we also override another three method of the HttpServlet class whis is : do doPost, doGet, and destroy method, but I think I don’t have to explain this three methods, because these methods id not too important to explain in the relation of configuring this log4j platform. these method is also an option whether we will use or not.

By this explanation, we have finished creating a servlet that contains a method configuring the log4J platform for our web application. now let’s move out by look at the source code of the web.xml file below. This file we the guide of the tomcat Servlet Container in order to run out our web application.

<web-app xmlns="http://java.sun.com/xml/ns/javaee"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
          http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
           version="2.5">

    <servlet>
        <servlet-name>Log4JInitServlet</servlet-name>
        <servlet-class>org.mojo.app.web.servlet.Log4JInitServlet</servlet-class>
        <init-param>
            <description>This param and value is set to define where is configuration located</description>
            <param-name>log4j-init-file</param-name>
            <param-value>/java/mojo/web_app/macam-macam/config/macam-macam_log4j.properties</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

We can see on the web.xml source code above, that there’s a servlet configured on our web application, the servlet’s name is Log4JInitServlet. If we see on the <servlet>………</servlet> block, there’s a class call, which is Log4JInitServlet Servlet class that exist on org.mojo.app.web.servlet package, This is where the location of the servlet that we just made. This servlet declaration on this web.xml file has params, named log4j-init-file that we’ve created on the servlet, and we also can see that params has a value which is /java/mojo/web_app/macam-macam/config/macam-macam_log4j.properties. This servlet will also run automatically on the first time when the Tomcat boot up, marked by <load-on-startup>1</load-on-startup> blocks.

Please see on the param value line, there’s something that we should deeply understand here, related with the Tomcat behaviour. If Tomcat installed on our windows system on C:\Web\Tomcat_5.5, then the root of Tomcat will be start from that folder, while the system root will start from the C:\ drive. The relation with this param value is , if we use the “/” character on the first characted on the param value just like above , that means macam-macam_log4j.properties file will have to be put on path: C:\Java\mojo\web_app\macam-macam\config\.That is one of the Tomcat behaviour, if we use “/ ” on the first character of param value on the web.xml file, then Tomcat will start to read from system root. How about if we didn’t use the “/” character, Tomcat will start to read from the path instalation of Tomcat it self which is C:\Web\Tomcat_5.5.

Then the next step is, we will create a log 4j property file. To create this file we have to follow the API of this Log4j, here’s the log4j propery file.

# For the general syntax of property based configuration files see the
# documentation of org.apache.log4j.PropertyConfigurator.
# The root category uses two appenders called A1 and R. Since no priority is
# specified, the root category assumes the default priority for root
# which is DEBUG in log4j. The root category is the only category that
# has a default priority. All other categories need not be assigned a
# priority in which case they inherit their priority from the
# hierarchy.

#log4j.rootCategory=, R
# Root logger set to DEBUG using the A2 appender defined above.

log4j.rootLogger=, R, E, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

# Pattern to output the caller's file name and line number.
log4j.appender.stdout.layout.ConversionPattern=%d %5p [%F:%L] - %m%n

# R is the RollingFileAppender that outputs to a rolling log
# file called web_app.log.
log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=/java/mojo/web_app/macam-macam/logs/macam-macam.log
log4j.appender.R.Threshold=DEBUG

# Define a pattern layout for the file.
# For more information on conversion characters (i.e. d,p,t,c,l,m,n)
# please see the PatternLayout class of the Log4j API.
log4j.appender.R.layout=org.apache.log4j.PatternLayout

#log4j.appender.R.layout.ConversionPattern=%d [%c{1}] %-5p - %m%n
log4j.appender.R.layout.ConversionPattern=%d [%F:%L] %-5p - %m%n

# Set the max size of the file and the number of backup files
log4j.appender.R.MaxFileSize=2MB
log4j.appender.R.MaxBackupIndex=9

################################## Define Error File Log #########################################
# E is the ErrorFileAppender that outputs to a rolling log
# file called web_err.log.
log4j.appender.E=org.apache.log4j.RollingFileAppender
log4j.appender.E.File=/java/mojo/web_app/macam-macam/logs/macam-macam_err.log
log4j.appender.E.Threshold=ERROR

# Define a pattern layout for the file.
# For more information on conversion characters (i.e. d,p,t,c,l,m,n)
# please see the PatternLayout class of the Log4j API.

log4j.appender.E.layout=org.apache.log4j.PatternLayout
#log4j.appender.E.layout.ConversionPattern=%d [%c{1}] %-5p - %m%n
log4j.appender.E.layout.ConversionPattern=%d [%F:%L] %-5p - %m%n

# Set the max size of the file and the number of backup files
log4j.appender.E.MaxFileSize=100KB
log4j.appender.E.MaxBackupIndex=9

We will not discuss line by line of this log4j property file. I think it’s enough for us to focus on this line log4j.appender.R.File=/java/mojo/web_app/macam-macam/logs/macam-macam.log. This line is line where the logger will create a log called macam-macam.log. And we should focus on this line too log4j.appender.E.File=/java/mojo/web_app/macam-macam/logs/macam-macam_err.log. This line is a definition where we initialize the log for error.

As a last reference of deployment for this project, copy the log4j library on to your web application. Put this log4j library on your WEB-INF/lib folder, and then place the Servlet Class that we’ve created on the correct package. And then copy the log4j property file to correct location as it declared on the web.xml file. Don’t forget to create log folder where the logger will produce log files based on log4j property file.

That’s it, our discussion, go try with your own creativity, and i’m waiting here for your feed back of this article.

 

 

Hope this will helfull

 

Menteng, June 15th, 2008

 

Josescalia

Membuat Menu Console Generator untuk aplikasi JAVA Console

Menu console pada Java, biasanya sering kali digunakan untuk untuk membuat aplikasi Java yang berjalan diatas console. Menu ini dipakai untuk menjalankan suatu bagian dari aplikasi yang kita buat, seperti menu baca data (Read Data), menu tulis data (Write Data), menu keluar aplikasi (Exit Application/Program) dan menu yang lain sesuai fungsi dengan aplikasi Java yang kita buat.

Jika kita sering membuat aplikasi console, dan aplikasi tersebut mempunyai banyak kegunaan, maka kita pasti menggunakan menu untuk memilih penggunaan fungsi aplikasi tersebut. Jika kita sering membuat aplikasi console, alangkah baiknya jika kita punya satu kelas yang bisa secara otomatis meng-generate menu, sehingga kita tidak perlu membuat menu lagi pada setiap aplikasi console yang kita buat. Kita tinggal pakai/import saja kelas itu dan pakai method-nya.

Kali ini kita akan mencoba membuat Menu Console Generator untuk mewujudkan ide diatas. Skenario dari Menu Console Generator ini adalah :

  1. Menu Console Generator ini akan mencetak pada layar console, menu-menu apa saja yang ingin kita tampilkan. Itu artinya kita akan membutuhkan parameter pada method utama dari Menu Console Generator ini. Karena menu yang ingin ditampilkan bisa lebih dari satu, maka kita harus buat parameternya ini berupa Array, boleh Array of String, boleh juga Array of Object. Kita tentukan saja sekarang bahwa parameter pertama untuk Menu Console Generator ini adalah Array of String saja. Tapi jika ingin membuat Array of Object pun silahkan, semua terserah anda.

  2. Saat menu console tampil maka user akan memilih salah satu menu tersebut dengan mengetikkan kode menu, dari sini kita bisa ambil kesimpulan, method utama Menu Console Generator ini harus mengembalikan suatu nilai (return) yang berupa String, untuk kemudian nilai kembaliannya itu bisa diproses pada aplikasi selanjutnya. Jika anda ingin membuat nilai kembaliannya berupa Integer, silahkan saja, bebas, tidak ada larangan. Kita menjadikan String sebagai nilai kembalian dari method ini karena menu console kan bisa saja tidak berupa angka, tapi bisa juga berupa karakter huruf dan lain-lain.

  3. Ketika user mengetikkan kode menu, Menu Console Generator kita ini akan membacanya sebagai sebuah InputStream dan memasukkannya ke dalam sebuah variabel dan kemudian variabelnya itu yang akan menjadi nilai kembalian.

Berdasarkan skenario tsb kita bisa langsung membuat kelas Menu Console Generator ini. Dibawah ini adalah file MenuConsoleGenerator dengan syntax-syntax di dalamnya :


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class MenuConsoleGenerator {
public static String menuConsoleGenerator(String[] menuTemp){
String sMenu ="";
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Menu ");
for (int i = 0; i < menuTemp.length; i++) {
String s = menuTemp[i];
System.out.println(s);
}

System.out.print("Type Code Of Menu : ");
try {
sMenu = in.readLine();
} catch (IOException e) {
System.out.println("Error : " + e);
}
return sMenu;
}
}

Kita akan bahas satu demi satu Code diatas.

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

Baris ini adalah code dimana kita meng-import package standar java.io.* yang nantinya akan kita butuhkan, yaitu BufferedReader, InputStreamReader dan IOException.

public class MenuConsoleGenerator {
......
}

Ini adalah kelas utama dari Menu Console Generator yang akan kita buat. Ingat : jika kita membuat kelas seperi diatas, maka nama file java-nya harus sama dengan nama kelas yang kita buat yaitu MenuConsoleGenerator.java. Dan nantinya didalamnya akan diisi oleh syntax-syntax selanjutnya.

Selanjutnya kita akan membuat satu method statis yang menjadi inti dari kelas ini. Yaitu:

public static String menuConsoleGenerator(String[] menuTemp){
......
}

Di sini kita dapat melihat bahwa method statis ini mengembalikan nilai String : public static String sebagai return value-nya dan membutuhkan String Array sebagai parameternya : (String[] menuTemp).

String sMenu ="";
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
System.out.println(" Menu ");

Pada baris ini kita menginisialisasi sebuah variabel bernama sMenu dan mengisinya dengan string empty (“”) untuk menghindari Exception JavaNullPointer variabel sMenu ini. Kemudian kita menginisialisasi object BufferedReader menjadi sebuah variabel bernama in. Lalu variabel in ini harus kita jadikan sebuah objeck baru dengan cara memanggil konstruktornya dengan perintah new, dan konstruktor BufferedReader ini juga mempunyai parameter yang berupa object Reader, langsung saja parameter ini kita isi dengan object baru berupa InputStreamReader yang juga punya parameter berupa InputStream. Dimana InputStream kita langsung masukkan saja dengan Input-an dari system dengan memasukan System.in sebagai isian parameternya. Kemudian baris selanjutnya kita mencetak ke layar console string “Menu” dengan menuliskan syntax System.out.println(“menu”);

Selanjutnya kita akan mencetak ke layar console menu-menu yang berasal dari parameter String Array dengan cara me-looping satu demi satu array tsb untuk kemudian menggunakan System.out.println, sebagai methode pencetakannya ke layar console. Berikut syntax-nya:

for (int i = 0; i < menuTemp.length; i++) {
String s = menuTemp[i];
System.out.println(s);
}

Setelah itu kita meminta user untuk mengetikan kode menu dengan menuliskan di layar konsole System.out.println(“Type Code Of Menu”); kemudian kita akan menangkap inputan dari user, dan memasukkannya kedalam variable String sMenu yang sebelumnya sudah kita inisialisai dengan tidak lupa menempatkannnya ke dalam blok try-catch yang memungkinkan program untuk mencegah user tidak salah mengetikkan kode, seperti syntax berikut:

try {
sMenu = in.readLine();
}catch (IOException e) {
System.out.println("Error : " + e);
}

Kemudian yang terakhir adalah kita membuat statement kembalian dari fungsi menuConsoleGenerator yang baru saja kita buat dengan syntax:

return sMenu;

Sampai disini kita telah selesai membuat method statis dalam kelas MenuConsoleGenerator yang bernama menuConsoleGenerator.

Nah sekarang kita tinggal mencoba kelas ini. Terserah bagaimana cara anda mencoba kelas ini. Tapi disini kita akan mencobanya dengan cara membuat aplikasi sederhana yang method utamanya memanggil kelas ini untuk kemudian memakai method menuConsoleGenerator sebagai percobaan dalam mengetes Menu Console Generator yang baru saja kita buat. Dibawah ini source code lengkap contoh aplikasi yang memanggil kelas MenuConsoleGenerator dan menggunakan method statis menuConsoleGenerator yang kita buat tadi

public class GunakanMenu {

private static String showMenu() {
String[] tempMenu = {"1. read", "2. write", "3. EXIT"};
String sResult = "";
sResult = MenuConsoleGenerator.menuConsoleGenerator(tempMenu);
return sResult;
}

public static void main(String[] args) {
String comand = "";
do {
comand = showMenu();
if (comand.equals("1")) {
System.out.println("Anda Ketik SATU / Bisa letakkan Method untuk di proses disini");
} else if (comand.equals("2")) {
System.out.println("Anda Ketik DUA / Bisa letakkan Method untuk di proses disini ");
}
} while (!comand.equals("3"));

{
System.out.println("Anda Ingin Keluar");
}
}
}

Terima Kasih
Semoga Bermanfaat

Josescalia

IDE, Produktifitas Java Developer dan Sedikit Tutorial Menggunakan IDE

IDE atau Integrated Development Editor jadi salah satu bagian penting untuk seorang developer aplikasi yang sehari-harinya diserbu oleh pekerjaan yang mempunyai deadline super ketat dan tingginya tingkat kesulitan aplikasi. Speed of Programming menjadi suatu skill yang sangat dibutuhkan oleh developer aplikasi pada suasana pekerjaan yang seperti ini.

IDE dengan fitur-fitur canggih menjadi incaran para developer sebagai suatu tools dalam melaksanakan pekerjaannya sehari-hari. Fitur-fitur canggih itulah yang nantinya akan sangat membantu developer dalam mengejar deadline super ketat. Beberapa IDE yang menawarkan fitur yang mampu meng-generate source code secara otomatis, fitur yang dapat membuat element lain yang masih ada hubungannya dengan pengerjaan suatu pembuatan aplikasi terintegrasi, atau fitur yang dapat me-roll-back code-code sebelumnya sebagai akibat kesalahan yang dibuat oleh developer, dan fitur-fitur canggih lainnya.

Pada Java Development ada beberapa IDE yang memang paling sering digunakan oleh developer aplikasi Java dengan kelebihannya masing-masing. Eclipse IDE yang gratis dengan segudang plugin yang dapat membuat element-element lain yang masih ada hubungannya dengan pekerjaan dapat terintegrasi dengan baik dengan Eclipse itu sendiri. NetBeans yang juga gratis dipilih oleh sebagian besar developer Java yang sering berkecimpung dengan pengerjaan aplikasi Java GUI karena GUI builder matisse-nya yang memang punya keunggulan tersendiri dalam membuat aplikasi Java GUI, baik yang menggunakan Java AWT ataupun Java Swing.

Saya sendiri memilih menggunakan IntelliJidea yang merupakan produk dari JetBrain yang sayangnya tidak gratis :((. Meski saya termasuk developer yang deadline pekerjaan tidak selalu ketat seperti yang kita bicarakan diatas. Tapi saya sangat menyukai IDE dengan fitur canggih. Hingga saat ini saya masih memakai versi illegal-nya IntelliJidea (versi crack), Semoga Tuhan memberikan saya sedikit rejeki berlebih yang nantinya bisa saya pakai untuk membeli lisensinya IntelliJidea :D.(I Love That IDE….!!!)

Tapi saya juga sering menggunakan IDE lain seperti NetBeans untuk coding sebuah pekerjaan Application Development yang deadlinenya masih bisa saya handle. Parahnya teman-teman saya satu perusahaan di Malaysia tidak menggunakan IDE buat untuk Java Development, mereka hanya menggunakan Edit Plus, suatu software seperti notepad yang menawarkan beberapa kelebihan di banding notepad dan parahnya lagi EditPlus juga tidak gratis :O.

Dari pada panjang lebar kita bicara soal IDE dan produktifitas developer sehubungan dengan penggunaan IDE tsb. Lebih baik kita coba lagi membuat aplikasi Java yang lain. Kali ini saya ingin anda membaca percobaan kita ini bukan di blog ini, tapi pada format pdf yang linknya nanti bisa anda download dibawah. Saya cuma khawatir siapa tahu anda bosen melihat tampilan blog ini yang tidak berubah dan tetap standar. Setelah anda baca dan coba praktekan sendiri cobalah sedikit kasih komentar pada blog saya ini. Mudah-mudahan nantinya akan dapat membuat saya jadi tambah semangat nulisnya he..he.he.he…

Percobaan kita kali ini berjudul Membuat Aplikasi J2EE menggunakan IDE IntelliJidea dan jboss sebagai application server-nya. Silahkan download pdf-nya disini, dan selamat mencoba.

Terima Kasih,

Semoga Bermanfaat

josescalia