Jimmy's Blog

One of the comment in JSON ME tutorial (http://jimmod.com/blog/2010/03/java-me-j2me-json-implementation-tutorialsample/) asking about how to parse this kind of JSON :

{\”api_status\”: \”OK\”,\”threads\”: [{\"tid\": \"2\",\"title\": \"First Title\" }, { \"tid\": \"4\", \"title\": \"this is 2nd Title\"}]}
 <a href="http://jimmod.com/blog/2011/09/java-me-j2me-json-implementation-for-array-object/#more-246" class="more-link">(continue reading...)</a>

ISO 8583 Tutorial article

• Introduction for Beginners
• Build and Parse ISO Message using JPOS library
• ????

In the beginning

OK after my article about ISO 8583 let’s go deeper into programming using Java + JPOS library.

Quote from JPOS website:

jPOS is a Java® platform-based, mission-critical, ISO-8583 based financial transaction library/framework that can be customized and extended in order to implement financial interchanges.

So first thing to do is download JPOS from it website.

Then we setup our development environment by creating Java Project using your favorites IDE. Add to the project all jar in JPOS library.
Here’s my Eclipse  package explorer looks like.
(continue reading…)

I’m checking Echo2 framework these couple days and try to make a simple game just to get to know the framework better.
Since I’m not a JavaScript expert it’s good to know that there’s framework that I can use to create AJAX web app with desktop feel easily.
The game is about re-ordering number by moving number to the empty space. It’s simple and fun, this sample is hardcoded to only support 3×3 size.

I assume you know Java, JSP, Servlet basics.
Download Echo 2 from : Echo2 Website
I personally use Eclipse for my IDE.

Step by step:
(continue reading…)

It’s been a while since I write an article, personal and work have been taken my time much lately.

What I will write is not a new things, maybe a lot of article already write this kind of feature. But yesterday I see this kind of project request in freelancer.com so I decide to create a simple sample and write an article about it.

Java Mobile (J2ME) application have a capability to send or receive SMS, but the phone need to support JSR-120 (Wireless Messaging API – WMA 1.0) or JSR-205 (WMA 2.0)
How to check if the phone is supporting this? Easy way if the phone’s brand website. For example for Nokia E72 we can see the technical specifications at http://developer.nokia.com/Devices/Device_specifications/E72/
If your phone doesn’t have WMA library the application will prompt error (the error can be different from one phone to another)
(continue reading…)

JSON is one of the most popular format used for communicating between (Java ME) J2ME client and App Server. Strangely it’s hard to find JSON implementation sample in J2ME. So I decide to write a sample.

(continue reading…)

Often we want to make sure that only 1 instance our application running.
Because something terrible could happen when more than 1 instance running (for example the whole server would exploded and that would make you fired )

Nevertheless what the reason, one of the way to make this happen is by creating a lock file as a sign that an instance is currently running.
So you application will have this flow: (continue reading…)

Okay, finally you decide it’s time to create a unit testing for your project (after a long ad hoc programming life :p).
When you create a sample unit testing, it’s all seem so simple.. you fascinate by the junit easiness, how it can do reflection and make it simple.

When you want to create a real unit testing for your project, you realize that a ‘real’ method is not like just adding 2 int argument and return a result. It’s more complex and using interface as parameter is common…
Now a thought cross your mind “do I have to create all stupid classes to implement all the interface I need?”, you starting to think that creating unit testing is really waste of time & you don’t want to do it anymore :p

It’s time mock object framework come to rescue… before you fall to the darkness of untested code
There’re several mock object framework like jMock, easymock, etc

Here’s an example creatin HttpMethod mock-object with jMock 2 & JUnit 3

[sourcecode language='java']
public class sampleJMockTest extends MockObjectTestCase {
public void testCreateHTTPMethod() {
final HttpMethod httpMethod = mock(HttpMethod.class);
checking(new Expectations() {
{
allowing(httpMethod).getResponseBodyAsString();
will(returnValue(”sample response”));
}
});
SomeObject someObject = new SomeObject();
someObject.someMethod(httpMethod);
}
}[/sourcecode]
This sample will create an instance of HttpMethod (which is an interface) and when this mock object’s ‘getResponseBodyAsString’ method called it’ll return “sample response”.
So now we can easily create all interface implementation we need.Of course there’re more in jMock than just this simple feature, check it more at jMock Cookbook

Why do we need a library for logger? doesn’t System.out.println help us enough?
When you try log4j you wouldn’t use System.out.println ever again… (Ok.. you will still used it.. occasionally :p)

What do you need? of course you need to download log4j first , get it at log4j download page
And open your favorite Java IDE.

import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
/**
*
* @author jimmy
*/
public class SampleLog4j {

private final static Logger LOGGER = Logger.getLogger(SampleLog4j.class);

public static void main(String[] args) {
PropertyConfigurator.configure(”log4j.properties”);
LOGGER.trace(”Level trace”);
LOGGER.debug(”Level debug”);
LOGGER.info(”Level info”);
LOGGER.warn(”Level warn”);
LOGGER.fatal(”Level fatal”);
}

}

This program will read file log4j.properties in the folder for log4j configuration.
Example of log4j.properties:

### file appender
log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.File=sample.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ISO8601} — %p %C(%M):%L — %m%n
### console appender
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{ISO8601} — %p %C(%M):%L — %m%nlog4j.rootLogger=debug, console
# uncomment the line below if you want log output to file
# log4j.rootLogger=debug, file

And it’ll produce output:

2007-11-15 18:19:09,812 — DEBUG testing.SampleLog4j(main):26 — Level debug
2007-11-15 18:19:09,828 — INFO testing.SampleLog4j(main):27 — Level info
2007-11-15 18:19:09,828 — WARN testing.SampleLog4j(main):28 — Level warn
2007-11-15 18:19:09,828 — FATAL testing.SampleLog4j(main):29 — Level fatal

Why the log “Level trace” doesn’t logged, because we set the log level only to debug.
You should learn the configuration. There are 2 appender, 1 will log to console and other will log to a file.

Now why shouldn’t I used standard System.out.println?

• You can’t set the level of log with println only
• You will end up delete/comment the log using println
• It won’t be that easy to create log to file with different filename daily (daily-rolling)
• I wonder how your println can print class name, line number easily
• … you can add more after you try it

For those who already experienced in Java Programming should already familiar with the concept of String constant pool.

String s1 = “jim”;
String s2 = “jim”;
System.out.println(s1==s2); // true.

Object s2 is the same object with s1. But if you create using new operator:

String s1 = “jim”;
String s2 = new String(”jim”);
System.out.println(s1==s2); //false.

It will allocate new Object instead getting from String constant pool.
Another sample:

String s1 = “jim”;
String s2 = “j”+”im”;
String s3 = “j”;
String im = “im”;
s3+= im;
System.out.println(s1==s2); //true.
System.out.println(s1==s3); //false.

Concatenation during runtime will create new String Object.
Sample if using final modifier:

final String s1 = “j”;
final String s2 = “im”;
String jim = “jim”;
System.out.println(s1+s2 == jim); // returns true: Constant expression.

String s3 = “j”;
String s4 = “im”;
System.out.println(s3 + s4 == jim); // returns false: Not a constant expression.

Concatenation of 2 final String is a Constant.

Although is not necessary for us programmer to know about the detail of JVM implementation about String Constant Pool. Some would say “I’m not stupid, I used equals to check equality of Strings. And I don’t really care how JVM in my OS implemented the damn Constant Pool”. But for me knowing this knowledge is something great, and somehow I think it will help me in the future

More information about this : JLS – Lexical Structure

• Literal strings within the same class (§8) in the same package (§7) represent references to the same String object (§4.3.1).
• Literal strings within different classes in the same package represent references to the same String object.
• Literal strings within different classes in different packages likewise represent references to the same String object.
• Strings computed by constant expressions (§15.28) are computed at compile time and then treated as if they were literals.
• Strings computed by concatenation at run time are newly created and therefore distinct.