I’ve been 6 years in Java programming language, but I admit, I never involve Hibernate framework as an ORM(Object Relational Mapping) method on my projects development stack. While Spring Framework, I’ve been using it since 2 years ago. This condition force me to do a little adaptation of this Hibernate Framework.

I often met some difficulties which is stress me so much, when the codes of the dao layer using a hibernate criteria. For a few developers who always using hibernate framework, it should be easier to use hibernate criteria, but for me, it really stress me so much.

To find a method on a dao layer work or not, sometimes it wouldn’t so effective to test it by deploying whole application just only to test one method. And I decide to use unit-test when testing dao layer methods, so I don’t need to deploy whole application.

Okay, below is the step to create a unit-test in order to test the methods on dao layer which created using Spring Framework and hibernate:

1. Create a hibernate configuration file, Spring Context file, and all those supported files, and put them onto test/resources folder just like the picture below:
2. Create a file called TestDao, and put it onto test/java folder. The codes of the files is below:

package com.mojo.maven.test;

import com.mojo.maven.dao.NewsCategoryDao;
import com.mojo.maven.dao.NewsDao;
import com.mojo.maven.model.News;
import com.mojo.maven.model.NewsCategory;
import org.apache.log4j.Logger;
import org.hibernate.SessionFactory;
import org.hibernate.classic.Session;
import org.hibernate.context.ManagedSessionContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

@ContextConfiguration(locations={"classpath*:maven1ApplicationContext-test.xml"})
public class TestDao extends AbstractTestNGSpringContextTests{
    private Logger logger = Logger.getLogger(TestDao.class);

    @Autowired
    public SessionFactory sessionFactory;
    private Session session;

    @Autowired
    private NewsDao newsDao;

    @Autowired
    private NewsCategoryDao newsCategoryDao;

    /**
     * Inisialisasi hibernate context sebelum test
     */
    @BeforeMethod
    void init() {
        logger.debug("init session factory");
        session = sessionFactory.openSession();
        ManagedSessionContext.bind(session);
    }

    /**
     * cleanup hibernate context setelah test
     */
    @AfterMethod
    void destroy() {
        logger.debug("destroy session factory");
        session.close();
        ManagedSessionContext.unbind(sessionFactory);
    }

    @Test
    public void testGetNews(){
        News news = newsDao.getById(1);
        logger.info("News ID : " + news.getId());
        logger.info("News Title : " + news.getNewsTitle());
        logger.info("News URL : " + news.getNewsUrl());
        logger.info("News Category : " + news.getNewsCategory().getCategoryName());
        logger.info("News Category Description : " + news.getNewsCategory().getCategoryDescription());
    }
}

What we have to pay attention on the class are, the class have an annotation @ContextConfiguration and extends AbstractTestNGSpringContextTests class which is provide as a base class to use it as a test class for TestNG Framework. Also on the annotation @ContextConfiguration  defined the location of the Spring Context, so the compiler can find a Spring Context file when the execution is triggered.

The next thing which have to note are 2 methods which is defined on the class, those are void init() method and void destroy() method. void init() method, given an annotation @BeforeMethod which have a function as an hibernate context initializations before all other the test method executed. While void destroy() method given an annotation @AfterMethod which have a function to close a hibernate session after all test method executed.

Well, that’s all that I can share for this time. If you feel the codes need more improvement, so go head, to make it perfect.

I’ll hope it usefull.

Josescalia

———————————————-

One day, I read, that this sentence “the quick brown fox jump over the lazy dog” contains all the character of the alphabet,  just because I’m so curious,  I thought to create a simple java application that checks whether the sentence is actually using all the letters in the alphabet or not.

The pseudo code of the application will look like this:

1. Declare the string.
2. Remove all spaces between the words from the sentence.
3. Remove duplicate character.
4. Convert the string into Character Arrays.
5. Sort the Character Arrays.
6. Loop the Character Array and print out to console.

First, I need to create a function that can remove duplicate character from a given parameter and the return of the function have to be a string. Ok, here’s the code:

    public static String removeDuplicates(String s) {
        StringBuilder noDupes = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            String si = s.substring(i, i + 1);
            if (noDupes.indexOf(si) == -1) {
                noDupes.append(si);
            }
        }
        return noDupes.toString();
    }

The function above using StringBuilder object as a container to process removing duplicate character, and the function will return the string formed by StringBuilder object. And then, I will use this function in the application. Ok, here’s the code:

import java.util.Arrays;

/**
 * Created by IntelliJ IDEA.
 * User: Josescalia
 * Date: 7/8/11
 * Time: 8:24 PM
 * To change this template use File | Settings | File Templates.
 */
public class ArrayTest {
    public static void main(String[] args) {
        //the string declaration
        String sStr = "the quick brown fox jumps over the lazy dog";
        //remove the spaces
        sStr = sStr.replace(" ", "");
        //remove the duplicate character using the function
        sStr = removeDuplicates(sStr);
        //Convert string into Character Array
        char[] a = sStr.toCharArray();
        //Sort the Array
        Arrays.sort(a);
        //let's loop and print out...is is correct, using all the character of the alphabet ????
        for (int i = 0; i < a.length; i++) {
            char c = a[i];
            System.out.print(c);
        }
        //it's true :P
    }

    public static String removeDuplicates(String s) {
        StringBuilder noDupes = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            String si = s.substring(i, i + 1);
            if (noDupes.indexOf(si) == -1) {
                noDupes.append(si);
            }
        }
        return noDupes.toString();
    }
}

Well, that’s all. Feel free to use and explore for your creations and needs.

I Hope that’s usefull

Thanks

Josescalia

A web page made up-over elements such as images, text, swift files, and others. When we want to open a web page, elements are downloaded to our computer and placed in the temporary folder of the browser we use. We can enjoy a web page perfectly after all the elements that make up the page is finished to download.

We may have a habit to visit the same website every day, especially right now, the social community era, facebook, twitter, myspace, we visit these websites just to make status, commenting a status and other activities. The same images, swift files, will be downloaded every time we visit those websites. This is actually a routine that we can make a strategy about.
Proxy is a tool that we can use to create a strategy for this routine. The proxy has the ability to store images taken from a website that we have accessed before, so the browser no longer need to download the same images from its origin. Proxies are smart enough to recognize the latest content from a website that we access, so proxy will download the latest content and storing it into a place commonly called cache.
Advertising, sometimes we are very disturbed by the ads that float on a websites that we might not want to see it, and the ads usually created using the large size of images. We also can use a proxy to block ads from a website. In addition, the proxy can also be used to block sites.

On a computer network in a company, proxies are necessary nowadays, at least use to save bandwidth and to limit the access to few websites that considered can make the employees forget about work.
The computer network administrators usually install a proxy in linux machine, and for those of you who want to install a proxy on the linux machine, please look for it on Google, there’s a lot of articles around proxy and linux machine. This time we will try to install a proxy into Windows. OK, let’s live it.

Installing Squid Proxy

1.    Download squid proxy from this link http://squid.acmeconsulting.it/download/squid-2.6.STABLE23-bin.zip.
2.    Then extract it on to C:\
3.    And then rename the squid.conf.default file on the etc folder  to squid.conf
4.    Add this line http_access allow localhost exactly under the line http_access allow localnet
5.    Then open the windows console and got to C:\Squid\sbin\, and the type:   squid.exe  -z command just like picture below:

6.    And then run squid as a windows service by typing this command on the console: squid.exe -i. And then check if the squid are installed as a window service like picture below:

7.    And then start the Squid Service.

The next step is configuring the browser in order to use the squid as web proxy, the steps are:
1.    On firefox, simply click tools and then click option, there have to be a option window appear, and in the Advanced menu, click network tab and then click setting button just like the picture below:

2.    And the on the Connection Setting window that appear after the setting button clicked, modify the connection setting just like this picture:

3.    And then browse just like we usually do, for the first time the browsing activity will look like usual,  because the squid proxy will store the contents of the web onto the cache, and later then the browser will fetch the static content from the squid cache.

Installing Adzap
To block the advertisement on the web, we need a squid plug in, which is adzapper. The problem is adzapper is a perl script that only can be execute by using perl environment. So definitely we need to install perl on our windows system. I choose Strawberry Perl as a perl platform to be installed on my windows machine. Strawberry perl can be fetch for download from this url http://strawberry-perl.googlecode.com/files/strawberry-perl-5.12.1.0.msi
After finished download the strawberry perl, then please install the strawberry pearl on your own windows machine. I have installed Strawberry Perl on C:\Web\ on my windows machine. Please pay an attention that all setting of adzapper must match to the location of your Perl installation.
And the next step is download the adzapper script from this URL: http://adzapper.sourceforge.net/scripts/squid_redirect, open the link on your browser, and after all the text/script is appeared, save the script to the C:\squid\etc\ folder and name it as squid-redirect.pl.
And the next step is configuring this adzapper plug in into the squid the we have installed before. Open the squid.conf file, this file is located on C:\Squid\etc\ folder and then add this line on the end of row of the file

redirect_program C:/Web/strawberry/perl/bin/perl.exe c:/squid/etc/squid_redirect.pl

Please make an attention that my perl installation located on C:\Web\ folder, please adjust the setting to the path of your own perl installation.
And after that, restart the proxy squid by using a window service just like the picture before, or maybe by using the command line by typing squid.exe –k reconfigure. And we have finished the adzapper script installation on squid. Now it’s time to check that the adzapper is working properly or not. Open the browser and then open the web site that you knew it have full of ads. The adzapper will block the ads juts like this picture below, and if it does, then the adzapper is working properly.

Actually there are a lot of things that we can do with squid and adzap to fill up our needs about the web-caching problems, please visit the official site of squid on http://squid-cache.org and adzapper http://adzapper.sourceforge.net/ to have a guide to maximize the both function.

Thanks

I Hope this will helpfull

Josescalia

Dear readers, this time I would like to share about how to create a JSP’s and MySQL web application. This time we will create it using easy way, means that we wouldn’t create this web application by coding java classes that we might needed to support this application. We only create JSP, yes only JSP, and of course few configuration that I hope easy enough too.
Before we start, let’s prepare a database and a table that will be one of our material of this creation. Let’s create a database and name it as “test_jsp” and for the table, the structure of the table is looked like this sketch.

or we can copy and paste sql query below:

create database test_jsp;
use test_jsp;
CREATE TABLE `identitas` (
  `NO` int(10) NOT NULL AUTO_INCREMENT,
  `NAMA` varchar(100) NOT NULL,
  `ALAMAT` varchar(255) DEFAULT NULL,
  `NO_TELP` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`NO`));

The above Sql Query is a query to create a database named as test_jsp, and creating a table named as identitas with the following field described above on the image. The please fill up the table with few necessary data, in order to make the table containing data like the picture below.

By that, one of our material for this application is created.

To do this development, actually we need or we will use a library, this library has an ability to support the creation of a web application only using jsp. The needed library is Jakarta Taglibs library.

Jakarta Taglibs is one of the open source project of Jakarta Tag Libraries which supporting a creation of a web application using JSP and without coding java classes. With the Taglibs concept means that will use this library supported API by calling it using the JSP’s tags. Since this web application using a database, so we need a library called DBTags (database tags), so please download the library here http://jakarta.apache.org/site/downloads/downloads_taglibs.html, and we will need other library which have a function as a MySQL database driver which is called as mysql-connector-java.jar, please also download this library here http://dev.mysql.com/downloads/connector/j/

After finished downloading those libraries, then please extract the both files. And the next step is preparing a web application on an Application Server or Servlet Container, for this exercise we using Tomcat as a Servlet Container.

1. Create a folder on a WebApps folder on tomcat installation directory. Let’s give a name “MySimpleJSP”. This folder will be a folder path on our web application.
2. Inside the folder is MySimpleJSP again, we make two more folders named WEB-INF and libs.
3. Copy mysql-connector-java.5.1.6.jar file (I use the connector 5.1.6 here) from the mysql connector library, and taglibs-dbtags.jar files from libraries Jakarta Tablibs which we downloaded earlier into the libs folder.
4. And also copy the taglibs-dbtags.tld file from Jakarta Taglibs library that we have extracted onto WEB-INF folder.
5. Create a file called web.xml and then save the file also in the WEB-INF folder, while the contents of the web.xml file write the following directions:

<?xml version="1.0" encoding="UTF-8"?>
<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">

      <jsp-config>
           <taglib>
               <taglib-uri>http://jakarta.apache.org/taglibs/dbtags</taglib-uri>
               <taglib-location>/WEB-INF/taglibs-dbtags.tld</taglib-location>
           </taglib>
       </jsp-config>
</web-app>

Until here, we have completed preparations for web-applications for our experiment this time. And the next step is to simply make jsp files that we need to be able to access the MySQL database we have made earlier, all jsp files which later we will create will be placed in MySimpleJSP folder or parallel with WEB-INF folder and the libs folder. Let’s create a jsp file.

The first JSP file we will create is get_identity.jsp, this file is a jsp file in charge of taking the data in the tables located on the identitas table on test_jsp database. Let’s look at the codes below get_identity.jsp file:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib uri="http://jakarta.apache.org/taglibs/dbtags" prefix="sql" %>
<html>
<head><title>My Simple JSP MYSQL Page</title></head>
<body>
<%-- Step 1) create a database connection --%>
<sql:connection id="connect">
    <sql:url>jdbc:mysql://localhost/test_jsp</sql:url>
    <sql:driver>com.mysql.jdbc.Driver</sql:driver>
    <sql:userId>root</sql:userId>
    <sql:password>admin99</sql:password>
</sql:connection>
<%--End Creating database Connection--%>

<%-- Step 2) Create a SQL query --%>
<sql:statement id="statement" conn="connect">
    <sql:query>
        SELECT * FROM identitas
    </sql:query>

    <table border="1">
        <tr>
            <th>NO</th>
            <th>NAMA</th>
            <th>ALAMAT</th>
            <th>NO TELP</th>
        </tr>
            <%--Step 2.1) Loop the result--%>
        <sql:resultSet id="data">
            <tr>
                <td><sql:getColumn position="1"/> </td>
                <td><sql:getColumn position="2"/> </td>
                <td><sql:getColumn position="3"/> </td>
                <td><sql:getColumn position="4"/> </td>
            </tr>
        </sql:resultSet>
    </table>
</sql:statement>

<%--Step 3) Close Database Connection--%>
<sql:closeConnection conn="connect"/>
</body>
</html>

Let’s make an attention the JSP’s code above:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib uri="http://jakarta.apache.org/taglibs/dbtags" prefix="sql" %>

On the second line we make a declaration tag that we shall use in this jsp file. Uri must be in line with taglib-uri which we declared in the web.xml file before. And if this web application run, the web.xml file have a responsibilities to find tags reference with sql prefix on taglibs-dbtags.tld file.

<%-- Step 1) create a database connection --%>
<sql:connection id="connect">
    <sql:url>jdbc:mysql://localhost/test_jsp</sql:url>
    <sql:driver>com.mysql.jdbc.Driver</sql:driver>
    <sql:userId>root</sql:userId>
    <sql:password>admin99</sql:password>
</sql:connection>
<%--End Creating database Connection--%>

While the above code block, we make declarations tags to connect to the mysql database that we created earlier.Please make attention each line above, the database is test_jsp then the driver is com.mysql.jdbc.Driver, and userid to connect to the mysql database is the root, and password to connect to the mysql database is admin99. My mysql database username is root and password is admin99, please adjust your database with the settings of each. Please make more attention in the code above, all of this configuration should be in block sql: connection

<%-- Step 2) Create a SQL query --%>
<sql:statement id="statement" conn="connect">
    <sql:query>
        SELECT * FROM identitas
    </sql:query>

    <table border="1">
        <tr>
            <th>NO</th>
            <th>NAMA</th>
            <th>ALAMAT</th>
            <th>NO TELP</th>
        </tr>
            <%--Step 2.1) Loop the result--%>
        <sql:resultSet id="data">
            <tr>
                <td><sql:getColumn position="1"/> </td>
                <td><sql:getColumn position="2"/> </td>
                <td><sql:getColumn position="3"/> </td>
                <td><sql:getColumn position="4"/> </td>
            </tr>
        </sql:resultSet>
    </table>
</sql:statement>

Then look at the rows of the following code, we create a block of tag sql:statement. Where in this block we write the block tag sql:query and tag sql:ResultSet, and in the block sql:ResultSet, we extract the data from the database to be displayed to the web page using tag sql:getColumn. If we try to understand the tags, the description may look like this: tag sql:query is a tag to write sql query which will be executed by the application. Then tag sql:ResultSet is a tag where the captured data from the database placed in the form to an array collection. And the last is the tag sql:getColumn is a way to extract the collection array and then sorted based on the basic view of our application web pages.

<%--Step 3) Close Database Connection--%>
<sql:closeConnection conn="connect"/>

And finally the last in this code is, that we then terminate the connection to our MySQL database.

Then after that, we can test this MySimpleJSP application by running our Tomcat and then call the get_identity.jsp files on your favorite browser pointed to the address: http://localhost:8000/MySimpleJSP/get_identity.jsp (I have configured tomcat to port 8000, please replace with the appropriate port in your tomcat configuration). If successful, it should display the web page is like this

With the appearance of the data into a web page of our JSP application, then we can describe that this exercise is successful done. For further step you can create more jsp pages, such as a jsp file to insert the data into the table, etc.

I Hope this usefull.

Thanks

Josescalia

Or this one:

This web page is standard error page produced by Apache Tomcat when our web application have some errors. These error occurred because the logic of our application had a mistake or user do some mistaken when requesting via HTTP browser.

We can change these pages into our custom page but have same function just like the page above. The advantages is we can redesign the page just like we  desired to. And other function is we could hide some error points, so the user can’t find out what’s the problem behind.

Before that, we can divide type of error that probably occurred on our web application. 1^st, caused by user fault such as accesing file that’s not exist on the server, and the 2^nd caused by error logic on our web application.

Let’s try to customize the error page that could be happen like above.

1. Creating error page caused by user:

When creating this type of error page, we can create it by adding some lines on deployment descriptor (web.xml) like this:

    <error-page>
        <error-code>404</error-code>
        <location>/404.jsp</location>
    </error-page>

On the source above, we can see clearly, if File Not Found Error occurred when user requesting via HTTP browser and the web application will automatically redirect to a 404.jsp file, and of course we have created this file before and customed like this one:

2.  Creating Error Page caused by Programming mistakes:

While configuring the error page caused by our programming mistakes, we can do it by adding these lines on deployment descriptor:

    <error-page>
        <exception-type>java.lang.NullPointerException</exception-type>
        <location>/errorpage.jsp</location>
    </error-page>

    <error-page>
        <exception-type>java.lang.NumberFormatException</exception-type>
        <location>/errorpage.jsp</location>
    </error-page>

On the example source, we can see that the error can be define one by one, such as Null Pointer Exception Error, nor Number Format Exception Error.

On the sampe source too, we can only create one jsp page to accommodate and informing the stacktrace that occurred caused by our programming mistakesl.

The source code of this jsp file is:

<%@ page import="java.io.ByteArrayOutputStream" %>
<%@ page import="java.io.PrintStream" %>
<%--
  User: Muhammad Yusuf
  Date: Aug 30, 2005
  Time: 5:56:29 PM
--%>
<%@ page isErrorPage="true" %>
<html>
<head>
    <title>JSP Error Page</title>
    <meta http-equiv="Pragma" content="no-cache">
    <style type="text/css">
        body {
            background-color: #cccccc;
            font-family: verdana, sans-serif, monospace;
            font-size: medium;
        }
    </style>
</head>

<body bgcolor=#ffffff>
<font face="Verdana">
    <center>
        <h2><font color=#DB1260>Error Page</font></h2>
    </center>
    <p> An exception was thrown: <b> <%=exception %>
        <p> With the following stack trace:
<pre>

<%
    ByteArrayOutputStream ostr = new ByteArrayOutputStream();
    exception.printStackTrace(new PrintStream(ostr));
    out.print(ostr);
%>
</pre>
        <br><a class="Verdana" href="#">Back To Main</a>

        <p>
</body>
</html>

On this source code, the occurred exception can be defined by using this tag <%=exception%> and the stack-trace that probably occurred can be print-out to the page like this:

<%
    ByteArrayOutputStream ostr = new ByteArrayOutputStream();
    exception.printStackTrace(new PrintStream(ostr));
    out.print(ostr);
%>

And here’s the final result of the 2^nd error page caused by our programming mistaken.

Or like this:

Hope this will helpfull

Menteng, 29 November 2009.

josescalia

Basically, when we download a file from a remote computer or a server, actually our computer reading byte by byte of a file that we want to download. And after all the byte read then the computer will pack it onto a file that contains perfectly same with the file that we like to download.

With this concept, let’s try to make a little experiment and this experiments will implement all the steps above, we can complete this experiment with another steps that we can gather base on our knowledge that we can find out from the above download process concept.

Let’s try to arrange the steps:

1. URL identification.

To download a file, we need a valid URL address for sure, and the path location of a file that we want to download. Example: http://www.wayofmuslim.com/ebook-islam/AlQuranDigital.zip. this have a meaning that we want to download a file named AlQuranDigital.zip from a remote computer wayofmuslim.com and the path location of this file at ebook-islam/

1. The size of file.

Each file that we want to download, have to find out the size of it. The purpose of this are we will be able to compare the bytes length that already read and stored in our local computer with the file that exist on remote computer, so we can find out whether the byte we have downloaded is corrupted or not before we can pack it up onto a file.

1. The content type of file.

This is optional, we can use this concept or not, it’s an option. But knowing the content type of a file in internet technology is the basic knowledge.

With those concept actually we can create our own application that have ability to download a file from a remote computer, yes we can, because the download concept is that simple.

Now let’s proof it by arrange a scenario based on the concept above to create our own Java Download Application. The scenario is:

1. Identifying URL.

Checking whether the supplied URL valid or not, we will use URL class that exist on Java.

1. Valid URL.

If the URL is valid, then go straight to create a HTTP Connection to check whether our computer is connected to the internet or not. And if the URL is not valid then just exit the application and show some screens out telling that the connection is not available.

1. Identifying the Content Type

If the Http Connection status is good, meaning that the host or remote computer can be contacted, the next step is identifying the content type of a file that we would like to download. In this try-it-out let’s just limit it, if the content type of a file is text/html, then we don’t have to download it. Why? The Http Status 404 (File Not Found) can be occurred on a file that we want to download, and we don’t need this html page to download to our computer rite?

1. Identifying the byte length (Content Length).

Just because we will to read byte by byte of file that we want to download, so it’s very important to store information of a byte length of the file that we want to download into a variable. And for the next usage this information can be some useful things in order to compare the byte length of downloaded byte with the length of byte that exist on remote computer, to find out whether the downloaded file corrupted or not.

1. Reading byte by byte.

This is the essential things on our try-it-out. Our application should have an ability to read byte by byte of the file that we want to download and the result of the bytes reading will put on a variable which have byte data-type. The way of bytes reading is using the looping from 0 to the content length that we have store it into a variable before.

1. Comparing local file to a remote file.

The next step is comparing the length of bytes that already read with the length of byte that stored before on a variable. If the both are not same that’s mean the downloaded file is corrupted and this byte will not be packed onto a file.

1. Pack the read bytes.

After we knew exactly that the length of read bytes is similar to byte length of remote computer, so it’s time to pack it up onto a file. Let’s just make it easier by naming the file exactly same with the name of file that exist on remote computer.

Using the above scenario, let’s try to code just like the source code below:

package org.mojo.download.agent;

import java.io.IOException;
import java.io.InputStream;
import java.io.BufferedInputStream;
import java.io.FileOutputStream;
import java.net.URL;
import java.net.MalformedURLException;
import java.net.URLConnection;

/**
 * Created by IntelliJ IDEA.
 * User: Mojo
 * Date: May 2, 2009
 * Time: 11:39:49 AM
 * To change this template use File | Settings | File Templates.
 */
public class SingleDownloadAgent {

    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("Usage : java SingleDownloadAgent <URL>" );
            return;
        } else {
            SingleDownloadAgent agent = new SingleDownloadAgent();
            try {
                doDownload(args[0]);
            } catch (IOException e) {
                System.err.println("Exception e");
            }
        }
    }
    public static void doDownload(String sURL) throws IOException {
       URL u = null;
        //try URL
        try {
            u = new URL(sURL);
        } catch (MalformedURLException ex) {
            System.err.println("Malformed URL : " + ex);
            return;
        }
        catch (IOException ex) {
            System.err.println("An Error Occured : " + ex);
            return;
        }
       //reading Connection
        URLConnection uc = null;
        try {
            uc = u.openConnection();
            //identifying connection
            uc.connect();
        } catch (IOException e) {
            System.out.println("Cannot Connect: Please Check Connection");
            return;
        }

        String contentType = uc.getContentType();
        System.out.println("contentType :" + contentType);

        int contentLength = uc.getContentLength();
        if (contentType.startsWith("text/html") || contentLength == -1) {
            throw new IOException("This is html file.");
        }

        //collecting byte in var data
        InputStream raw = uc.getInputStream();
        InputStream in = new BufferedInputStream(raw);
        byte[] data = new byte[contentLength];
        int bytesRead = 0;
        int offset = 0;
        while (offset < contentLength) {
            bytesRead = in.read(data, offset, data.length - offset);
            if (bytesRead == -1) break;
            offset += bytesRead;
        }
        in.close();

        //file corrupted
        if (offset != contentLength) {
            throw new IOException("Only read " + offset + " bytes; Expected " + contentLength + " bytes ? File Corrupted…");
        }

        //writing byte data to a file
        String filename = u.getFile();
        filename = filename.substring(filename.lastIndexOf('/') + 1);
        FileOutputStream fout = new FileOutputStream(filename);
        fout.write(data);
        fout.flush();
        fout.close();

    }
}

On the above source-code we have two methods, which is the main method and the doDownload method with sURL string as it’s parameter. Let’s discuss it line by line the above source-code:

As usual, at the beginning of the code we declare the package where this class is located and the declaration of imported class that we will need later. And then on the main method we check whether the URL parameter supplied when this class is called. Indeed, this application designed has to supply the URL parameter when this application called.

package org.mojo.download.agent;

import java.io.IOException;
import java.io.InputStream;
import java.io.BufferedInputStream;
import java.io.FileOutputStream;
import java.net.URL;
import java.net.MalformedURLException;
import java.net.URLConnection;

/**
 * Created by IntelliJ IDEA.
 * User: Mojo
 * Date: May 2, 2009
 * Time: 11:39:49 AM
 * To change this template use File | Settings | File Templates.
 */
public class SingleDownloadAgent {

    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("Usage : java SingleDownloadAgent <URL>" );
            return;
        } else {
            try {
                doDownload(args[0]);
            } catch (IOException e) {
                System.err.println("Exception e");
            }
        }
    }
………

On this main method, showed that if the URL parameter is not supplied then this application will print out the message of application usage and then directly quit. And if the URL parameter supplied then the application will continuing call the doDownload method with args[0] as it’s parameter.

Now let’s take a look at the second method which is doDownload methods:

   ………
   public static void doDownload(String sURL) throws IOException {
       URL u = null;
        //try URL
        try {
            u = new URL(sURL);
        } catch (MalformedURLException ex) {
            System.err.println("Malformed URL : " + ex);
            return;
        }
        catch (IOException ex) {
            System.err.println("An Error Occured : " + ex);
            return;
        }
    ………

On these lines we run out first scenario which is validating the URL, and we put it on a try-catch block. Why we put it on try-catch block? Because we want to know if the error occurred, where it will be happen.

…………
        //reading Connection
        URLConnection uc = null;
        try {
            uc = u.openConnection();
            //identifying connection
            uc.connect();
        } catch (IOException e) {
            System.out.println("Cannot Connect: Please Check Connection");
            return;
        }

        String contentType = uc.getContentType();
        System.out.println("contentType :" + contentType);

        int contentLength = uc.getContentLength();
        if (contentType.startsWith("text/html") || contentLength == -1) {
            throw new IOException("This is html file.");
        }
…………

And after that, on the lines above code we check the connection to host or remote computer by put it once again on try-catch block, and then the next line we find out the content type of the file that we want to download and put the information on a string variable called contentType. And then we check the content length that we want to download and put in on a integer type variable. And the next lines is continue by the branching to make a decision if the content typeof the file is type/html type, then just quit the application.

    …………
        //collecting byte in var data
        InputStream raw = uc.getInputStream();
        InputStream in = new BufferedInputStream(raw);
        byte[] data = new byte[contentLength];
        int bytesRead = 0;
        int offset = 0;
        while (offset < contentLength) {
            bytesRead = in.read(data, offset, data.length - offset);
            if (bytesRead == -1) break;
            offset += bytesRead;
        }
        in.close();

        //file corrupted
        if (offset != contentLength) {
            throw new IOException("Only read " + offset + " bytes; Expected " + contentLength + " bytes ? File Corrupted…");
        }
    …………

On the lines above, we can see the reading of byte by byte do by our application, using the open up the output-stream and then read the output stream by looping byte and using the content length as it limitation, and then put it the read result into a data variable that have byte data-type. And after the read process is finished the output-stream is closed and then we create a statement to compare the length of read bytes that stored on offset variable with the contentLength variable.

…………
        //writing byte data to a file
        String filename = u.getFile();
        filename = filename.substring(filename.lastIndexOf('/') + 1);
        FileOutputStream fout = new FileOutputStream(filename);
        fout.write(data);
        fout.flush();
        fout.close();

    }
…………

And this is the last codes that we have created, on this codes we pack up the bytes that we have read and stored into a data variable before, into a file. To naming the file, we just named as a same filename that we want to download.

That’s it, our try-it-out for this time. There’s still a lot that we can explore more from this little experiments, such as we can build a GUI as its interface, or adding some progress bar animation, etc. Please explore more of this concept to creating more perfect things.

Hope it will be useful.

Menteng, March 3^rd 2009

Josescalia.

On J2EE or J2SE project development, sometimes there’s one block which have a function to manage everything related with the database, result fetching of supplied queries was managed on this block. With this type of design, we’re easier to track if there’s an error on our java application.
For Java Developer which familiar to use database as a part of the application, doesn’t have any difficulty to create a block which have a function as a database access, and then place the block inside the architecture of the application.

When creating this database access block, there’s some way that we can use, one of them is using Spring Framework. Yes, now we will try to use Spring Framework to access database, by creating database access or more familiar as DAO Layer. And for this try-it-out we will use MySQL Database (Again….? Oh God…). First thing we have to do to try-this-out is create a table on a database on MySQL Database and complete this table with the data needed. We will name this table as web_account and containing about 10 or 20 data inside. For the field of this table, let’s just create with our desire. Or maybe we can copy-paste this below SQL Code:

CREATE TABLE `web_account` (
  `USERNAME` varchar(30) NOT NULL DEFAULT '',
  `PASSWORD` varchar(30) NOT NULL DEFAULT '',
  `CREATE_TIME` datetime DEFAULT NULL,
  `CREATE_USER` varchar(30) DEFAULT NULL,
  `UPDATE_TIME` datetime DEFAULT NULL,
  `UPDATE_USER` varchar(30) DEFAULT NULL,
  PRIMARY KEY (`USERNAME`)
);

INSERT INTO `web_account` VALUES ('admin','adminya33','2009-03-15 08:32:21','admin','2009-03-15 08:32:21','admin'),('andre','andre456','2009-03-15 08:34:53','admin','2009-03-15 08:34:53','admin'),('fitri','fitri54','2009-03-15 08:33:22','admin','2009-03-15 08:33:22','admin'),('ganteng','ganteng99','2009-03-15 08:34:21','admin','2009-03-15 08:34:21','admin'),('gerry','gerry87','2009-03-15 08:33:41','admin','2009-03-15 08:33:41','admin'),('gue','guelagi','2009-03-15 08:33:56','admin','2009-03-15 08:33:56','admin'),('hebat','hebatlah','2009-03-15 08:34:36','admin','2009-03-15 08:34:36','admin'),('heru','heur334','2009-03-15 08:32:54','admin','2009-03-15 08:32:54','admin'),('joe','joe77','2009-03-15 08:32:39','admin','2009-03-15 08:32:39','admin'),('kasep','sekap25','2009-03-15 08:33:08','admin','2009-03-15 08:33:08','admin'),('linux','linux09','2009-03-15 08:35:22','admin','2009-03-15 08:35:22','admin'),('mojo','monk123','2009-03-15 08:31:50','admin','2009-03-15 08:31:50','admin');

From the structure of the table above, we have to create a Java Class which has class properties that can represent the fields of the table above. The purpose of this class creation is this class will be the container of the data table. On usage of java code, this class will be an object variable that can be accessed as Array of Object or Single Object.

We will create this class by using simple POJO (Plain Old Java Object), below is the source code of this class:

package org.mojo.spring.entity;

import java.util.Date;

/**
 * Created by IntelliJ IDEA.
 * User: Mojo
 * Date: Mar 15, 2009
 * Time: 8:45:10 AM
 * To change this template use File | Settings | File Templates.
 */
public class WebAccount {
    private String userName;
    private String password;
    private Date createDate;
    private String createUser;
    private Date updateDate;
    private String updateUser;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    public String getCreateUser() {
        return createUser;
    }

    public void setCreateUser(String createUser) {
        this.createUser = createUser;
    }

    public Date getUpdateDate() {
        return updateDate;
    }

    public void setUpdateDate(Date updateDate) {
        this.updateDate = updateDate;
    }

    public String getUpdateUser() {
        return updateUser;
    }

    public void setUpdateUser(String updateUser) {
        this.updateUser = updateUser;
    }

    public String toString() {
        return "WebAccount{" +
                "userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", createDate=" + createDate +
                ", createUser='" + createUser + '\'' +
                ", updateDate=" + updateDate +
                ", updateUser='" + updateUser + '\'' +
                '}';
    }
}

And now we are ready to create a DAO Layer using Spring Framework, don’t forget to download the needed libraries such as Spring Library, MySQL Connector library, and common-logging library, because these libraries is needed to follow this try-it-out. The common-logging library has to include too in this try-it-out, because the Spring Framework have a very high dependencies to this library. And the MySQL Connector library is needed too, because we use MySQL Database on this try-it-out (Again… :P).

For the DAO Layer that we will create below, we just limit it on fetching how many rows data on the table (SELECT COUNT(1) ) and fetching all data (SELECT *) only. The others method such as insert, update, or delete, we can add it later. For the select count(1) method the run-down scenario is: this method will have a return data type as integer, while the select * method will have a return data type as a list. Let’s see below source code:

package org.mojo.spring.dao.JdbcDao;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementSetter;
import org.springframework.jdbc.core.RowCallbackHandler;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
import org.mojo.spring.entity.WebAccount;

import javax.sql.DataSource;
import java.util.List;
import java.util.ArrayList;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.ResultSet;

/**
 * Created by IntelliJ IDEA.
 * User: Mojo
 * Date: Mar 15, 2009
 * Time: 8:46:57 AM
 * To change this template use File | Settings | File Templates.
 */
public class WebAccountJDBCDAO extends JdbcDaoSupport {
    private DataSource ds;
    private JdbcTemplate tpl;

    public int getNumOfWebAccount() {
        logger.info("getNumOfWebAccount");
        int iRes = 0;
        ds = getDataSource();
        tpl = new JdbcTemplate(ds);
        String sQuery = "SELECT COUNT(1) from web_account";
        try {
            iRes = tpl.queryForInt(sQuery);
            logger.info("Result of getNumOfWebAccount : " + iRes);
        } catch (Exception e) {
            logger.info("Exception in getNumOfWebAccount()" + e.getMessage());
        }
        return iRes;
    }

    public List<WebAccount> getWebAccountList(boolean flagLimit, int limit) {
        final List<WebAccount> result = new ArrayList();
        final int iLimit = limit;
        ds = getDataSource();
        JdbcTemplate tpl = new JdbcTemplate(ds);
        String sQuery = "SELECT * FROM rss_feeder";

         if (flagLimit) {
            sQuery += " LIMIT ?";
        }

        class PreparedStatementHandler implements PreparedStatementSetter {
            public void setValues(PreparedStatement ps) throws SQLException {
                int n = 0;
                ps.setInt(++n, iLimit);
            }
        }

        class ServiceHandler implements RowCallbackHandler {
            public void processRow(ResultSet rs) throws SQLException {
                WebAccount wa = new WebAccount();
                wa.setUserName(rs.getString("WEB_ACCOUNT"));
                wa.setPassword(rs.getString("PASSWORD"));
                wa.setCreateDate(rs.getDate("CREATE_DATE"));
                wa.setCreateUser(rs.getString("CREATE_USER"));
                wa.setUpdateDate(rs.getDate("UPDATE_DATE"));
                wa.setUpdateUser(rs.getString("UPDATE_USER"));
                result.add(wa);
            }
        }

        if (flagLimit) {
            tpl.query(sQuery, new PreparedStatementHandler(), new ServiceHandler());
        } else {
            tpl.query(sQuery, new ServiceHandler());
        }
        return result;
    }
}

Let’s discuss above codes. On the top of the source code, there’s a declaration where this class is located, and the next lines, we just import the needed class of Spring Framework library and other Java default library.

package org.mojo.spring.dao.JdbcDao;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementSetter;
import org.springframework.jdbc.core.RowCallbackHandler;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
import org.mojo.spring.entity.WebAccount;

import javax.sql.DataSource;
import java.util.List;
import java.util.ArrayList;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.ResultSet;
………

We have named this class as WebAccountJDBDDAO class, marked by the class declaration on the next line after comment lines (I’m Using IntelliJidea as my favorite IDE). After the class declaration, we create 2 variables, ds as DataSource type and tpl as JdbcTemplate type.

………
public class WebAccountJDBCDAO extends JdbcDaoSupport {
    private DataSource ds;
    private JdbcTemplate tpl;
………

DataSources is a type of object that we picked up from javax.sql package, while the JdbcTemplate is a type of object that we picked up form Spring package, located on org.springframework.jdbc.core.JdbcTemplate. And then, let’s take look one by one the methods that exist on the codes.

Method getNumOfWebAccount:

……
 public int getNumOfWebAccount() {
        logger.info("getNumOfWebAccount");
        int iRes = 0;
        ds = getDataSource();
        tpl = new JdbcTemplate(ds);
        String sQuery = "SELECT COUNT(1) from web_account";
        try {
            iRes = tpl.queryForInt(sQuery);
            logger.info("Result of getNumOfWebAccount : " + iRes);
        } catch (Exception e) {
            logger.info("Exception in getNumOfWebAccount()" + e.getMessage());
        }
        return iRes;
    }
……

On this method we can see, the query that will be execute is only simple query which is “select count(1) from web_account”. If we execute this query on MySQL Console, the result of this query is the number of how much rows are exists on web_account table. On this method we put the result of the query into a variable iRes, this iRes variable has a integer as it’s data type. If we want to arrange the steps of this method, the steps will be seen as:

1. Create integer type variable and name it as iRes.

2. Initialize the ds variable by calling getDataSource interface.

3. Create new JdbcTemplate object and the parameter is ds.

4. Create a String variable, named as sQuery and directly fill the string by the MySQL query.

5. Execute the query on try-catch block and then put the result of the query into iRes variable.

6. Crate a return statement of the methods.

While the lines containing logger, is our way to mark the process flow, so if there’s any error occurred on the codes we can trace it easily.

And then let’s discuss the 2^nd method which is getWebAccountList method. On this method, we create 2 inner class, the purpose of this inner class creation is to make our codes look more orderly:

…….
       class PreparedStatementHandler implements PreparedStatementSetter {
            public void setValues(PreparedStatement ps) throws SQLException {
                int n = 0;
                ps.setInt(++n, iLimit);
            }
        }

     class ServiceHandler implements RowCallbackHandler {
            public void processRow(ResultSet rs) throws SQLException {
                WebAccount wa = new WebAccount();
                wa.setUserName(rs.getString("USERNAME"));
                wa.setPassword(rs.getString("PASSWORD"));
                wa.setCreateDate(rs.getDate("CREATE_TIME"));
                wa.setCreateUser(rs.getString("CREATE_USER"));
                wa.setUpdateDate(rs.getDate("UPDATE_TIME"));
                wa.setUpdateUser(rs.getString("UPDATE_USER"));
                result.add(wa);
            }
        }
…….

If we take a look on the codes of both inner classes, each of this inner class handled two important functions. The function on the first inner class handled PrepareStatement, this class implements PrepareStatementSetter belongs to Spring Framework. And the 2^nd inner class handled the localization of query result onto WebAccount object variable, this inner class implements RowcallbackHandler belongs to Spring Framework also.

On the 1^st inner class we override setValues methods that owned by the PreparedStatementHandler class as a requirement of implementation. And the 2^nd class we also have to override processRow method as a requirement of RowCallBackHandler class implementation. And then let’s take a look at the main code of the getWebAccountList method that we’ve already created before.

……
 public List<WebAccount> getWebAccountList(boolean flagLimit, int limit) {
        final List<WebAccount> result = new ArrayList();
        final int iLimit = limit;
        ds = getDataSource();
        JdbcTemplate tpl = new JdbcTemplate(ds);
        String sQuery = "SELECT * FROM rss_feeder";

         if (flagLimit) {
            sQuery += " LIMIT ?";
        }
……..
……..
……..
        if (flagLimit) {
            tpl.query(sQuery, new PreparedStatementHandler(), new ServiceHandler());
        } else {
            tpl.query(sQuery, new ServiceHandler());
        }
        return result;
    }
……

On the main code of the above method we have return value as a list and 2 parameters which is flagLimit as boolean type and limit as integer type. The steps of this method arrangement is same with the first method that we have created before on getNumOfWebAccount method, just because that we have 2 parameters on this method, so let’s create a little programming logic here, which is on branching lines. On the branching lines we create a logic if the value on flagLimit is true then the query will be added by “LIMIT ?” so the query will be “SELECT * FROM web_account limit ?”, and if the value of flagLimit is false then the query will not be change, but it still same just like the first initialization.

The dots that exist in the middle of the main codes are the codes of inner classes that we have discussed before. And then we have arrived to the code where the lines of query execute. In this lines there’s also a branch that will decide whether the code will use the inner PreparedStatementHandler class of not, the decision of this usage is depends on flagLimit variable value, go head, do your own analyze the branching codes. And the end of this method is the existence of the return statement declared as a list that represented by the result variable. That’s it, that’s how we use Spring Framework on creating DAO Layer. And the next step are we will try to use the DAO Layer in the Java Consol Application.

In order to use this DAO Layer, we have to make a Spring Framework configuration file. Ok, let’s just create this file, let’s name it as “applicationContext.xml” file, just like another article posted before which using Spring Framework also. We will place this configuration file on a config folder which is a line with the src folder on this try-it out project. Below is the source code of Spring Configuration file.

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans>
    <!--Data Source-->
    <bean id="ds" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost/java_spring"/>
        <property name="username" value="root"/>
        <property name="password" value="root99"/>
    </bean>

    <bean id="webAccountDAO" class="org.mojo.spring.dao.JdbcDao.WebAccountJdbcDAO">
        <property name="dataSource" ref="ds"/>
    </bean>
</beans>

Let’s take a look of this configuration file, the first bean that we have to create is ds, this bean is a bean which have a function to access MySQL Database, this bean use the class that belongs to Spring Framework which is DriverManagerDataSource class. And then, just because this is the Spring access block to connect to database, so we have to supply the property that related with the connection to database creation, such as username, url, password, dan driverClassName of the database that we will use and it’s property given is depends on the setting of our MySQL database settings.

And then the 2^nd bean is a bean that will represent DAO Layer that we have created above. The property that has to be filled up by this bean is dataSource property, while the reference of this bean property is ds bean that we have cerated before.

And the usage of this DAO Layer on Java Console Application, shown as the codes below:

package org.mojo.spring.application;

import org.mojo.spring.dao.JdbcDao.WebAccountJdbcDAO;
import org.mojo.spring.entity.WebAccount;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

import java.util.List;

/**
 * Created by IntelliJ IDEA.
 * User: Mojo
 * Date: Mar 15, 2009
 * Time: 11:05:55 AM
 * To change this template use File | Settings | File Templates.
 */
public class SpringReadDatabase {

    private WebAccountJdbcDAO dao = null;
    public static void main(String[] args) {
        //call SpringConfiguration File
        ApplicationContext ctx = new FileSystemXmlApplicationContext("config/applicationContext.xml");
        SpringReadDatabase app = new SpringReadDatabase();

        //call Desired bean
        app.dao = (WebAccountJdbcDAO) ctx.getBean("webAccountDAO");

        //declare Variable
        WebAccount[] waList = null;

        //getNumOfWebAccount
        int i = app.dao.getNumOfWebAccount();
        System.out.println("Num Rows : " + i);

        //getWebAccountList
        List<WebAccount> list = app.dao.getWebAccountList(false,0);

        //convert List to ObjectArray
        if (list.size() > 0) {
            waList = new WebAccount[list.size()];
            for (short j = 0; j < list.size(); j++) {
                waList[j] = list.get(j);
            }
        }

        //iterate ObjectArray to PrintOut to console
        for (int j = 0; j < waList.length; j++) {
            WebAccount webAccount = waList[j];
            System.out.println("Name : " + webAccount.getUserName());
            System.out.println("Password : " + webAccount.getPassword());
            System.out.println("FullWebAccount : " + webAccount);
        }

    }

    public void setDao(WebAccountJdbcDAO dao) {
        this.dao = dao;
    }
}

That’s it, that’s how we use the DAO Layer that we have created before by using Spring Framework in Java Console Application. To discuss this java console application, please do your own analyzing in order to get more understanding of the codes that we have created.

I hope this will helpful.

Menteng, March 15^th 2009

josescalia

As we knew, the existence of Spring Framework on Java technology is really-really help us the Java Developer, the modularity of this framework has made the enterprise java project development is easier to rebuild or modify.

We will not discuss much more about the Spring Framework here, we only will try to use the Spring Framework one of this framework feature to access property file. And of course the values of the property file to be used on our application chain later.

Let’s go directly to try this out. On Spring Framework, the usage of bean became a must, that’s why we will create an object as a representation of a bean, the scenario that we will make is every item that exist on property file will become a property of the object that that we have created. Let’s make the property file just like below:

application.properties file:

application.name=mojo
application.password=mojo123
application.url=http://localhost:8080/test_doang/test.jsp

We will put this file on config folder, a line with the src folder, just like below picture shown:

With the item of the property file, we will create a simple object of Java pojo which will represent each item that exist on the property file above. The source code of this object is below:

PropertyHolder.java file:

package org.mojo.spring.entity;
/**
 * Created by IntelliJ IDEA.
 * User: Mojo
 * Date: Mar 9, 2009
 * Time: 7:04:46 PM
 * To change this template use File | Settings | File Templates.
 */
public class PropertyHolder {
    private String name;
    private String password;
    private String url;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String toString() {
        return "PropertyHolder{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                ", url='" + url + '\'' +
                '}';
    }
}

On above source code, we create a file named PropertyHolder.java. On this file we only create 3 property of the object, because there’s only 3 item on the property file. On the usage, each property of this object will hold values that exist on the property file.

In order to make each item on the property file can be inject into each object property, we have to define the object on Spring configuration file, so when the application run, this configuration will be called at first line and finally each item on the property file can be injected into each property of the PropertyHolder object that we have created before. Below is the definition of the object that we define as a bean on spring configuration file, this file will also put on same folder with the property file location which is on config folder.

applicationContext-app.xml file:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans>

    <bean id="propertyConfigurer"          class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location" value="config/application.properties"/>
   </bean>

       <!-- Local Data Holder -->
    <bean id="propertyHolder" class="org.mojo.spring.entity.PropertyHolder">
        <property name="name" value="${application.name}"/>
        <property name="password" value="${application.password}"/>
        <property name="url" value="${application.url}"/>
    </bean>
</beans>

Basically, when an application that using Spring Framework start running, then all the bean that already configured on Spring configuration file will also called one by one, even maybe one bean will depends on another bean. On the defined bean above, we can see that we have defined two beans there, the first bean have an id called “propertyConfigurer”, this bean have a function to give information to the Spring Framework the location of the property file. While the other bean given an id as “propertyHolder”, this bean is a map of the object that we have created before. Let’s make an attention to the defined class of the second bean, and then each property that defined on the block of this defined bean, this is how we map each item of the property file to each property on the object.

Actually, this is the main focus of our try-it-out today, here’s how we access each items on the property file using Spring Framework. And if when we want to use the value of the property file items, all we need is just called the PropertyHolder object only, a line before we set the PropertyHolder object for sure. The usage example is just like below:

package org.mojo.spring.application;

import org.mojo.spring.entity.PropertyHolder;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

/**
 * Created by IntelliJ IDEA.
 * User: Mojo
 * Date: Mar 9, 2009
 * Time: 7:06:35 PM
 * To change this template use File | Settings | File Templates.
 */
public class TestReadProperty {
    private PropertyHolder holder =null;

    public void setHolder(PropertyHolder holder) {
        this.holder = holder;
    }

    public static void main(String[] args) {
        ApplicationContext context    = new FileSystemXmlApplicationContext("config/applicationContext-app.xml");
        TestReadProperty app = new TestReadProperty();
        app.setHolder((PropertyHolder) context.getBean("propertyHolder"));

        System.out.println("Name : " + app.holder.getName());
        System.out.println("Password : " + app.holder.getPassword());
        System.out.println("Url : " + app.holder.getUrl());
        System.out.println("full : " + app.holder);
    }
}

On the source code of usage example above, we can describe it just like this:

At first PropertyHolder object defined as a private variable named as holder. Then there’s a method which have a function as a setter of the holder object. And then on the main method of this sample program, we have defined an ApplicationContext as an object, this context called the Spring Framework configuration file, and then we have to define this program as an object too, in order to make all the property of the object can be called on the main method.

The next step is, set the PropertyHolder object by calling setter method of the PropertyHolder that we have made before on this example program. When this method called, then automatically Spring Framework will fill up the property of PropertyHolder object with the value of each item that exists on the property file. And the last step is we tried to print-out the value of object property that owned by PropertyHolder class to console. And don’t forget to import all the necessary class and library that needed by this example application on the top line of this example program as we seen above.

That’s it, our try-it-out today, a little try-out that using one the feature of Spring Framework that has a lot and useful feature that we can use on our development project. And if you want to try-it too, don’t forget to download the library of Spring Framework and other libraries that become dependency libraries for the Spring Framework it self

Have a nice try ….!!!

I Hope this will helpfull

Menteng, March 10, 2009

Josescalia

The unique thing of this friend activity is, he tried to rebuild this absence application by using Adobe Flex. Well, I was interested with this Adobe Flex, my interest is more to Adobe Flex ability to create a pretty GUI design. By using Adobe Flex Builder, the making of design a GUI application is just simple drag and drop. It looks like creating a GUI application in Java by using the Netbeans and its Matisse Builder plug in. Actually there’s a little disappoint of mine, when I’m using Netbeans to create a Java GUI application. Sometimes the release build of my Java GUI application is not appropriate with the design of development. After seeing this Adobe Flex, I thought I should change my presentation layer of an application especially Desktop Application by using this Adobe Flex.

For about one weeks and three days, I search reference and then try to use this Adobe Flex as a presentation layer of my created application. And indeed, I have found that I easier to use Adobe Flex as a presentation layer of my application. And its looks like that I will decide to use Adobe Flex as a presentation layer of applications that I will create in the future.

Adobe Flex supported 3 Remote Application methods, which is:

1.    RPC Method (Remote Procedure Call).

2.    HTTP Service Method (read Web Application return using XML format).

3.    Web Service Method.

From those methods, the most preferred method of mine is the second method which is HTTP Service method. Adobe Flex can read a Web Application XML formatted return value, and then the value can be inserted into components that exist on Adobe Flex framework.

And I thought, because I have searched for about one week and three days about this Adobe Flex, it has to be at least one application that I can make using this Adobe Flex framework. Hmmm…… I thought what simple application that I can make with my limited knowledge of this Adobe Flex Framework. I got an idea; I will create a simple RSS Reader application. Why should RSS Reader? I thought a RSS reader is XML formatted, so it will be easier to make, because I don’t have to design the XML format for my first simple Flex application.

And after one day in front of my laptop try to create this application, finally my First Adobe Flex project created. Here are screenshot of my Flex RSS Reader Application.

Picture-1:

Picture-2:

Let me try to describe here about the concept of my flex RSS Reader application. This RSS Reader application has 2 tabs. The first tab is RSS Reader, this is the main function of this application as it’s seen on picture-1, while the 2nd tab contains an form that have functions that can manage RSS link to be added, updated, or deleted by using this tab as it’s seen on picture -2.

On screenshot of picture-1, we can see there’s a combo box that user can choose, from what resource of the news that he would like to read. When user clicks one of the sources from the combo box, this application will try to request RSS Feeder to a link that became a value data on the combo box. After all the result of the request done, this application will automatically load the result of news items to Data Grid component on RSS List Panel, and when one of the news item on Data Grid component clicked by the user, this application will also automatically load the short description of the news to Text Area component on the Description panel. When user interest to read the full article of the news that selected, user can click Read This button. When this button clicked, then the default browser of user’s computer will show and directly open the page containing the news that he would love to read.

While on the screenshot of picture-2, is a view of RSS Entry tab, which on this tab, user can manage the sources of the RSS Reader on this application. When user wants to add a new source of RSS Feeder, he just needs to enter each text boxes on Add RSS Entry Panel and then click Add button. And when he needs to update or delete one of sources that already loaded on Data Grid on the Listed RSS Entry panel, all he needs is just click the item on the Data Grid and the application will automatically fill up the text boxes on the Edit RSS Entry panel, and then he click the update or delete button depends on what he want to do with the source item. And then we also can see on the both picture there’s an Exit button on the right top of the form. The function of this button is to close this Flex RSS Reader application.

This simple Flex RSS Reader application actually has a Back-End Application that I have created using PHP and MySQL Database. The Back-End Application will produce a web page XML Formatted result containing a list of RSS Reader sources that stored on MySQL Database table. Just because I don’t understand yet about how to use the property file on Flex Development, I do hardcode to write a link of this RSS Reader Back-End Application.  The Link of this RSS Reader Back-End Application is: http://localhost/flex_xml_lab/rss/rss_feeder.php. If you are interested of this application, then you also have to create this RSS Reader Back-End Application, and the link must be same with above Back-End Link that I have hardcode on this application.

And the XML formatted result that produced by the Back-End Application must have a pattern below:

<rss_list>
     <RSS>
        <RSS_ID>1</RSS_ID>
        <label>Detik</label>
        <data>http://rss.detik.com/index.php/detikcom</data>
     </RSS>
     <RSS>
         <RSS_ID>2</RSS_ID>
         <label>Detik Inet (local sample)</label>
         <data>http://localhost/flex_xml_lab/rss/rss_detikinet.xml</data>
     </RSS>
     <RSS>
        <RSS_ID>3</RSS_ID>
        <label>Google News (local sample)</label>
        <data>http://localhost/flex_xml_lab/rss/rss_google.xml</data>
     </RSS>
     <RSS>
        <RSS_ID>10</RSS_ID>
        <label>Detik Inet</label>
        <data>http://www.detikinet.com/feed</data>
     </RSS>
     <RSS>
         <RSS_ID>11</RSS_ID>
         <label>Antara Terkini</label>
         <data>http://www.antara.co.id/rss/news.xml</data>
     </RSS>
     <RSS>
         <RSS_ID>12</RSS_ID>
         <label>Antara Sains Dan Teknologi</label>
         <data>http://www.antara.co.id/rss/tek.xml</data>
      </RSS>
</rss_list>

On the Back-End Application, I made a table on MySQL Database named flex_project and the table name is rss_feeder, and the detail of the table shown below:

Or you also can make the table with this MySQL Syntax:

CREATE TABLE `rss_feeder` (
  `RSS_ID` int(100) NOT NULL AUTO_INCREMENT,
  `RSS_NAME` varchar(100) NOT NULL,
  `RSS_LINK` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`RSS_ID`)
);

And then, to create a Back-End Application using php, I have created a simple PHP CRUD (Create, Read, Update, and Delete) application to do select, insert, update, and delete database operation on to the table. I simplified this Back-End Application by creating only one php file. And the interaction between the database and php file can be recognized by a parameter named action for each database operation. I choose HTTP GET methods for interaction between a PHP and Flex RSS Reader Application, so the each database operation on the php file can be executed by detail below:

·      Action Read rss_feeder

http://localhost/flex_xml_lab/rss/rss_feeder.php?action=read

·      Action Insert rss_feeder

http://localhost/flex_xml_lab/rss/rss_feeder.php?action=add&rss_name=[name_of_rss_source]&rss_link=[link_of_rss]

·      Action Edit rss_reader

http://localhost/flex_xml_lab/rss/rss_feeder.php?action=add&rss_id=[id_of_rss]&rss_name=[name_of_rss_source]&rss_link=[link_of_rss]

·      Action Delete rss_reader

http://localhost/flex_xml_lab/rss/rss_feeder.php?action=delete&rss_id=[id_of_rss]

To accommodate above methods, then I created one php file only, and the source of the php file is below:

<?php
//define database paramater
define( "DATABASE_SERVER", "localhost" );
define( "DATABASE_USERNAME", "root" );
define( "DATABASE_PASSWORD", "9mtouche9" );
define( "DATABASE_NAME", "flex_project" );
$conn = mysql_connect(DATABASE_SERVER,DATABASE_USERNAME, DATABASE_PASSWORD);
mysql_select_db( DATABASE_NAME );
//define HTTP GET paramater
$action = $_GET['action'];
$return="";
//action read
if($action=="read"){
    $query = "select * from rss_feeder";
    $res = mysql_query($query);
    //return list of rss link
    $return = "<rss_list>";
         while ($result = mysql_fetch_object($res)) {
                   $return .="<RSS>
              <RSS_ID>$result->RSS_ID</RSS_ID>
              <label>$result->RSS_NAME</label>
              <data>$result->RSS_LINK</data>
              </RSS>";
         }
    $return .= "</rss_list>";
    mysql_close();
}
//action add
if($action=="add"){
    $rss_name = $_GET['rss_name'];
    $rss_link = $_GET['rss_link'];
    $query = "insert into rss_feeder(RSS_NAME,RSS_LINK) values('$rss_name','$rss_link')";
    $res = mysql_query($query);
    //$result = mysql_fetch_row($res);
    //return list of rss link
    $return = "<action_result>";
       if($res){
         $return .= "true";
       }else{
         $return .= "false";
       }
    $return .= "</action_result>";
}
//action edit
if($action=="edit"){
    $rss_id = $_GET['rss_id'];
    $rss_name = $_GET['rss_name'];
    $rss_link = $_GET['rss_link'];
    $query = "update rss_feeder set RSS_NAME='$rss_name', RSS_LINK='$rss_link' where RSS_ID='$rss_id'";
    $res = mysql_query($query);
    //$result = mysql_fetch_row($res);
    //return list of rss link
    $return = "<action_result>";
       if($res){
         $return .= "true";
       }else{
         $return .= "false";
       }
    $return .= "</action_result>";
}
//action delete
if($action=="delete"){
    $rss_id = $_GET['rss_id'];
    $query = "delete from rss_feeder where RSS_ID='$rss_id'";
    $res = mysql_query($query);
    //$result = mysql_fetch_row($res);
    //return list of rss link
    $return = "<action_result>";
       if($res){
         $return .= "true";
       }else{
         $return .= "false";
       }
    $return .= "</action_result>";
}
//print out result
print($return);
?>

On the script, indeed there’s another action instead read, another action also return XML formatted result, just because the return of another action is boolean type, so let’s just ignore it.

That’s it, a short description of this simple RSS Reader application that I have made by using Adobe Flex. I’m quite satisfied, because this Adobe Flex is so easy to design and to create a GUI application. And for the result the output of the GUI is prettier than Java Swing Application. And for the release build, Adobe Flex Builder has also owned it by using wizard, it’s really simple at least for me.

And for you, who wants to learn or maybe modified and learning together with me, below is the sources link of My First Flex Project

1.    RSS Reader Source (Zip File)

2.    PHP Back-End Application

3.    MySQL source file.

And Please feel free to rebuild and modify with your own need and desired, and don’t forget to give back your comment through this post.

Menteng, March 7^th 2009.

I hope this will helpful

Josescalia

We will not discuss a lot about what Microsoft Access can do here. On this time we will try to accessing a database that created using Microsoft Access with our beloved programming language which is Java.

Now, let’s arrange a scenario to discuss this topic:

1. Create a database file named Java_MsAccess using Microsoft Access.

2. Create a table on that database which contains fields:

• Field name: CustomerID, type Number (single).

• Field name: CustomerName, type Text (50).

• Field name: CustomerAddress, type Text (250).

• Field name: CustomerPhone, type Text (20).

1. Fill up the table with necessary data.

2. Create a DSN Data source DSN for this database.

3. Create a Java Application for accessing this database using the Data source.

For the step 1 until the step 4, we will attach a screen shot only here, because I believe that we can do these steps without written reference here.

Okay, for the 1^st step, below is the screen capture:

And for the 2nd step, below is screen capture:

And for the step 3^rd, this is how we do it:

And for the step 4th, okay for this step we will explain a little bit, so we can understand how to create a data source on windows platform for this database.

• Click start  Control Panel  Administrative Tools  Data Sources(ODBC)

• And then on ODBC Database Administrator window, click Add button and then choose Driver do Microsoft Access (*.mdb), and then click finish button.

• And then on ODBC Microsoft Access Setup window, give a name for this database JavaMsAccess, and then choose the database file by clicking select button, and find the database file that we have crated before. This is the image looks like:

And the DSN data source named by JavaMsAccess created successfully. Now we arrive to the step that we are cannot be patient to wait which is creating the Java application. Okay, here’s the process flow of our Java Application looks like:

1. Choose and initialize the driver for this ODBC data source.

2. Create a database connection to this ODBC data source.

3. Create a Statement for the SQL Queries.

4. Pick up the result of Query Statement executiom onto ResultSet

5. Printout the ResultSet.

From these scenarios, let’s implement it on to Java Code. Take a look this Java source code below:

package org.mojo.blog.Java_depth.aboutMsOffice;

import Java.sql.*;

/**
* Created by IntelliJ IDEA.<br>
* User: Mojo<br>
* Date: 08 Feb 09<br>
* Time: 22:30:08<p>
*/
public class MsAccessJava {
private static String driverName = "sun.jdbc.odbc.JdbcOdbcDriver";
private static String url = "jdbc:odbc:JavaMsAccess";
 public static void main(String[] args) {
     String sql ="SELECT * from tblCustomer";
       try {
          Class.forName(driverName);
          Connection conn = DriverManager.getConnection(url);
          System.out.println("Connection Established..");
          Statement stmt = conn.createStatement();
          ResultSet rs = stmt.executeQuery(sql);
          while (rs.next()){
             System.out.println("+------------- Detail Customer ----------------------+");
             System.out.println("Customer ID : "+ rs.getInt(1));
             System.out.println("Customer Name : "+ rs.getString(2));
             System.out.println("Customer Address : "+ rs.getString(3));
             System.out.println("Customer Phone : "+ rs.getString(4));
             System.out.println("+----------------------------------------------------+");
             System.out.println("\n");
         }
       } catch (SQLException e) {
          e.printStackTrace();
       } catch (ClassNotFoundException e) {
          e.printStackTrace();
     }
  }
}

Let’s discuss line per line the above code.

The first line is a line where this Java file located on its package. While the 3^rd line is a line where all the classes of Java.sql library has imported. And then we can see inside the program that there are two private static string variable defined which is:

………..
   private static String driverName = "sun.jdbc.odbc.JdbcOdbcDriver";
   private static String url = "jdbc:odbc:JavaMsAccess";
………..

The first variable is a driver name that we will use it later to accessing ODBC data source, while the second variable is an url of the data source that we would like to access, just remember this data source name have to equals with the data source that we have created before which is: JavaMsAccess.

And then let’s take a look the codes inside the main method. The first line on this main method is a line where we define a SQL query which we will use to access these Microsoft Access database. And then we create a try-catch block, this block is the block which all main process of the accessing process is happen. First in this block we initialize the driver that we have defined in the header of the program. And then we create a database connection and the print out the result of it’s connection.

…….
   Class.forName(driverName);
   Connection conn = DriverManager.getConnection(url);
   System.out.println("Connection Established..");
……….

The continuous steps are, create a statement, then execute the SQL Statement using the SQL query that we have defined before.

…….
     Statement stmt = conn.createStatement();
     ResultSet rs = stmt.executeQuery(sql);
……….

And the print out the result by loops the rs variable, which these ResultSet variable values had filled up before.

…….
   while (rs.next()){
        System.out.println("+----Detail Customer ------------------+");
        System.out.println("Customer ID : "+ rs.getInt(1));
        System.out.println("Customer Name : "+ rs.getString(2));
        System.out.println("Customer Address : "+ rs.getString(3));
        System.out.println("Customer Phone : "+ rs.getString(4));
        System.out.println("+--------------------------------------+");
        System.out.println("\n");
   }
…….

And then we add some catch statement to prevent error appear on runtime, and this catch is also can be use to trace the problem when error occured that can make our application cannot run properly.

If the program executed, and then the result will show just like image below – i have executed it on my favourite IDE, IntelliJidea 7.0.4