menembus batas impian

Archive for Oktober, 2011

How to Run GlassFish V3 as a Service on Linux Ubuntu/Debian

We already support running GlassFish V3 as a service on Solaris 10 and Windows platforms (see my blog).  I have been investigating how to provide support for automatically starting GlassFish V3 as a service on Linux.  Of course before I can hope to do that — I must be able to set it up manually.  In this blog I will take you through the manual steps needed to run GlassFish V3 as a service on Linux.

This procedure was worked out on my Linux system which happens to be Ubuntu.  Other flavors of Linux may have slightly different procedures.

One decision you need to make right up front is what Linux user should “own” GlassFish V3.  Typically root is used as the owner.  If you choose root as the user you get the advantage that you can use ports < 1024 without complex configuration changes to the system.  For this blog I used root.

Here are the steps  — the file named “glassfish” in step 4 is the simple init script which appears at the end of this blog.

1.   Install JDK 6 if needed
2 .   Have root install GlassFish like so:
——-          a.  cd /opt
——-          b.  wget
——-          c .  unzip
——-          d.  rm
3.   cd /etc/init.d
4.   cp glassfish .
5.   update-rc.d glassfish defaults
6.  OPTIONAL /etc/init.d/glassfish start
7.    OPTIONAL Make sure GlassFish is running OK
8.   reboot — you are done!

To start, stop, restart GlassFish simply run these commands:

sudo /etc/init.d/glassfish start
sudo /etc/init.d/glassfish stop
sudo /etc/init.d/glassfish restart


# glassfish init script for Linux
# Simplest possible case — no password file, one default domain
# it would be simple to add such options


case “$1” in
$GLASSFISH_HOME/bin/asadmin start-domain >/dev/null
$GLASSFISH_HOME/bin/asadmin stop-domain >/dev/null
$GLASSFISH_HOME/bin/asadmin restart-domain >/dev/null
echo “usage: $0 (start|stop|restart|help)”

from :

Menjalankan Spring HTTP Invoker di Sun JRE 6 HTTP Server

Dulu, kita sudah mencoba untuk membuat remoting service dengan menggunakan Spring Framework. Salah satu protokol yang digunakan adalah Spring HTTP Invoker. Untuk mempublish service dengan protokol ini, kita harus menggunakan servlet engine, misalnya Tomcat.

Akan tetapi, Sun Microsystem merilis Java versi 6 yang sudah dilengkapi dengan HTTP Server sederhana. Dengan memanfaatkan fitur ini, kita tidak perlu lagi menggunakan Tomcat hanya untuk mempublish service dengan HTTP Invoker. Ini akan sangat bermanfaat untuk aplikasi kecil yang ingin dipanggil oleh aplikasi lain.

Pada artikel ini, kita akan mempublish service dengan protokol HTTP Invoker pada HTTP Server yang disediakan oleh Sun JRE versi 6.

Di Netbeans, kita akan membuat tiga project, yaitu

  • remoting-shared : project ini menampung interface RemotingService, yang akan digunakan di client dan server
  • remoting-server : project ini yang akan mempublish service. Implementasi RemotingService juga ada di sini
  • remoting-client : project ini yang akan mengakses service yang dipublish remoting-server

Berikut screenshot Netbeans. Project remoting-server dan remoting-client memiliki dependensi terhadap remoting-shared.

Pertama, mari kita lihat dulu service interfacenya. Berikut adalah kode programnya.

  1. package com.artivisi.tutorial.remoting.spring.service.api;
  2. public interface RemotingService {
  3.     public String halo(String nama);
  4. }

Kode program ini berada di project remoting-shared.

Berikutnya, kita lihat dulu di sisi client. Kita cuma butuh satu class untuk menjalankan aplikasi, yaitu ClientLauncher sebagai berikut.

  1. package com.artivisi.tutorial.remoting.spring.client;
  2. public class ClientLauncher {
  3.     private static final Logger log = Logger.getLogger(ClientLauncher.class.getName());
  4.     public static void main(String[] args) {
  5.         AbstractApplicationContext ctx =
  6.                 new ClassPathXmlApplicationContext(“client-ctx.xml”, ClientLauncher.class);
  7.         ctx.registerShutdownHook();
  8.         RemotingService service = (RemotingService) ctx.getBean(“remotingService”);
  9.         String msg = service.halo(“endy”);
  10.“Pesan dari server : “+msg);
  11.     }
  12. }

ClientLauncher akan membaca client-ctx.xml yang isinya seperti ini.

  1. <?xml version=”1.0″ encoding=”UTF-8″?>
  2. <beans xmlns=”;
  3.        xmlns:xsi=”;
  4.        xsi:schemaLocation=”
  7.     <!–  proxy dengan protokol HTTP Invoker  –>
  8.     <bean id=”remotingService”
  9.     class=”org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean”>
  10.          <property name=”serviceUrl”
  11.          value=”http://localhost:9090/RemotingService”/&gt;
  12.          <property name=”serviceInterface”
  13.          value=”com.artivisi.tutorial.remoting.spring.service.api.RemotingService”/>
  14.     </bean>
  15. </beans>

Seperti kita lihat di atas, client mengakses service yang ada di komputer lokal (localhost) di port 9090, dengan nama service RemotingService.

Selanjutnya, mari kita implement project remoting-server. Di sini ada implementasi RemotingService sebagai berikut

  1. /*
  2.  * To change this template, choose Tools | Templates
  3.  * and open the template in the editor.
  4.  */
  5. package com.artivisi.tutorial.remoting.spring.service.impl;
  6. @Service(“remotingService”)
  7. public class RemotingServiceImpl implements RemotingService {
  8.     Logger log = Logger.getLogger(RemotingServiceImpl.class.getName());
  9.     public String halo(String nama) {
  10.“Terima dari client : “+nama);
  11.         return “Halo, “+nama;
  12.     }
  13. }

Kemudian ada class untuk menjalankan aplikasi di sisi server. Berikut ServerLauncher.

  1. package com.artivisi.tutorial.remoting.spring.server;
  2. public class ServerLauncher {
  3.     public static void main(String[] args) {
  4.         AbstractApplicationContext ctx =
  5.                 new ClassPathXmlApplicationContext(“server-ctx.xml”, ServerLauncher.class);
  6.         ctx.registerShutdownHook();
  7.     }
  8. }

ServerLauncher membaca file konfigurasi server-ctx.xml. Inilah isinya.

  1. <?xml version=”1.0″ encoding=”UTF-8″?>
  2. <beans xmlns=”;
  3.        xmlns:xsi=”;
  4.        xmlns:p=”;
  5.        xmlns:context=”;
  6.        xsi:schemaLocation=”
  11.     <!– menginstankan Sun HttpServer dalam JRE 6 –>
  12.     <bean class=””>
  13.         <property name=”contexts”>
  14.             <map>
  15.                 <entry key=”/RemotingService” value-ref=”remotingServiceHttpInvoker”/>
  16.             </map>
  17.         </property>
  18.         <property name=”port” value=”9090″ />
  19.     </bean>
  20. </beans>

Pada blok konfigurasi pertama, kita menginstankan Sun HttpServer yang ada di JRE 6. HttpServer ini akan berjalan di port 9090, sesuai dengan yang kita konfigurasi di sisi client. Di sana terlihat bahwa URL /RemotingService akan ditangani oleh remotingServiceHttpInvoker. Berikut konfigurasinya

  1. <!–  publish service dengan protokol HttpInvoker  –>
  2. <bean id=”remotingServiceHttpInvoker”
  3.       class=”org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter”
  4.       p:service-ref=”remotingService”
  5.       p:serviceInterface=”com.artivisi.tutorial.remoting.spring.service.api.RemotingService”
  6.  />

Selanjutnya, kita suruh Spring mendeteksi implementasi service kita secara otomatis, yaitu class yang ada anotasi @Service.

  1. <context:component-scan base-package=”com.artivisi”/>

Berikut adalah dependensi pustaka di project client.

Library untuk Project ClientLibrary untuk Project Client

Dan ini untuk di server.

Library untuk Project ServerLibrary untuk Project Server

Keseluruhan project akan terlihat seperti ini.

Struktur Folder semua ProjectStruktur Folder semua Project

Semua library dapat diambil dari distribusi Spring Framework dan Repository SpringSource.

Coba jalankan ServerLauncher, kita akan melihat log seperti ini.

  1. Jul 3, 2009 2:57:25 PM prepareRefresh
  2. INFO: Refreshing display name []; startup date [Fri Jul 03 14:57:25 WIT 2009]; root of context hierarchy
  3. Jul 3, 2009 2:57:26 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
  4. INFO: Loading XML bean definitions from class path resource [server-ctx.xml]
  5. Jul 3, 2009 2:57:26 PM obtainFreshBeanFactory
  6. INFO: Bean factory for application context []:
  7. Jul 3, 2009 2:57:26 PM preInstantiateSingletons
  8. INFO: Pre-instantiating singletons in defining beans [,remotingServiceHttpInvoker,remotingService,org.springframework.context.annotation.internalCommonAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor]; root of factory hierarchy
  9. Jul 3, 2009 2:57:27 PM afterPropertiesSet
  10. INFO: Starting HttpServer at address

Lalu jalankan ClientLauncher, inilah log yang muncul.

  1. Jul 3, 2009 2:58:12 PM prepareRefresh
  2. INFO: Refreshing display name []; startup date [Fri Jul 03 14:58:12 WIT 2009]; root of context hierarchy
  3. Jul 3, 2009 2:58:12 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
  4. INFO: Loading XML bean definitions from class path resource [client-ctx.xml]
  5. Jul 3, 2009 2:58:13 PM obtainFreshBeanFactory
  6. INFO: Bean factory for application context []:
  7. Jul 3, 2009 2:58:13 PM preInstantiateSingletons
  8. INFO: Pre-instantiating singletons in defining beans [remotingService]; root of factory hierarchy
  9. Jul 3, 2009 2:58:13 PM com.artivisi.tutorial.remoting.spring.client.ClientLauncher main
  10. INFO: Pesan dari server : Halo, endy

Setelah ClientLauncher dijalankan, di log server akan muncul informasi sebagai berikut.

  1. INFO: Terima dari client : endy

Demikianlah cara menggunakan embedded HttpServer. Selamat mencoba.

full Copy paste dari bang endy ;

maaf mumpung bisa di akses blog nya krn beberapa hari akses blog aban ga bisa, setelah bisa ya langkah aman copy paste he he

Remoting dengan Spring

Aplikasi yang kita buat, tidak hanya digunakan oleh manusia. Ada kalanya aplikasi yang kita buat akan diakses oleh aplikasi orang lain. Jadi, user atau pengguna aplikasi kita bukanlah orang, melainkan mesin. Dalam hal ini, aplikasi kita dapat disebut dengan aplikasi server yang menyediakan service bagi aplikasi client.

Bagaimana caranya agar aplikasi kita dapat digunakan oleh aplikasi lain? Caranya tentunya dengan menyediakan antarmuka yang sesuai bagi masing-masing aplikasi client. Ada banyak bahasa yang dijadikan patokan dalam komunikasi antar aplikasi. Beberapa protokol yang umum digunakan adalah:

  • RMI (khusus Java)
  • SOAP
  • Hessian
  • Burlap
  • dan masih banyak yang lainnya

Dengan cara tradisional, menyediakan antarmuka untuk masing-masing protokol ini cukup rumit. Selain harus mengerti protokolnya, kita juga harus menulis banyak kode untuk memformat data kita mengikuti aturan yang ditetapkan protokol tersebut. Kita juga harus menulis kode program agar dapat menerima data dalam protokol yang kita ingin sediakan.

Spring Framework menyediakan library pembantu bagi kita agar kita dapat menyediakan akses dalam protokol tersebut dengan mudah. Bagaimana caranya, mari kita bahas dalam artikel ini.

Sebagai contoh sederhana, misalnya kita ingin menyediakan layanan untuk mengambil data Person. Untuk menyederhakan masalah, Person hanya mengandung data nama dan email saja.

  1. package tutorial.remoting;
  2. public class Person implements {
  3.     private String name;
  4.     private String email;
  5.     public Person() {
  6.         this(“”, “”);
  7.     }
  8.     public Person(String name, String email){
  9. = name;
  10. = email;
  11.     }
  12.     public String getName(){
  13.         return name;
  14.     }
  15.     public String getEmail(){
  16.         return email;
  17.     }
  18.     public String toString(){
  19.         return name + ” : ” + email;
  20.     }
  21. }

Perhatikan bahwa kita harus mendefinisikan Person sebagai object yang Serializable. Ini penting agar object ini bisa ditransfer melalui jaringan.

Kemudian, kita sediakan interface yang mendefinisikan layanan yang ingin kita sediakan bagi aplikasi lain. Kita sebut saja interface ini sebagai PersonService.

  1. package tutorial.remoting;
  2. import java.util.List;
  3. public interface PersonService {
  4.     public Person get(int id);
  5.     public List getAllPerson();
  6. }

PersonService ini nantinya bisa kita implementasi sesuai dengan kebutuhan. Kita bisa mengambil datanya dari database, dari phonebook handphone, atau bahkan dari aplikasi lain. Agar contoh kodenya lebih sederhana, kita buat saja implementasinya dengan ArrayList. Para pembaca nanti bisa mencoba dengan implementasi lain yang lebih hi-tech seperti Hibernate atau OpenJPA.

Berikut adalah implementasi dari PersonService, kita sebut saja PersonServiceImpl.

  1. package tutorial.remoting.remote;
  2. import java.util.List;
  3. import java.util.ArrayList;
  4. import tutorial.remoting.Person;
  5. import tutorial.remoting.PersonService;
  6. public class PersonServiceImpl implements PersonService {
  7.     private List allPerson = new ArrayList();
  8.     public PersonServiceImpl(){
  9.         Person p = new Person(“Endy Muhardin”, “”);
  10.         Person p1 = new Person(“Maya Mujawati”, “”);
  11.         allPerson.add(p);
  12.         allPerson.add(p1);
  13.     }
  14.     public Person get(int id){
  15.         if (id >= allPerson.size()) return null;
  16.         return (Person) allPerson.get(id);
  17.     }
  18.     public List getAllPerson(){
  19.         return allPerson;
  20.     }
  21. }

Seperti kita lihat di atas, tidak ada yang istimewa dengan kode program di atas. Bahkan validasi untuk field id pun tidak kita sediakan. Tentu saja kalau kita berikan masukan angka 2 atau lebih pada method public Person get(int id) akan terjadi ArrayIndexOutOfBoundException.

Selesai sudah … sekarang kode tersebut dapat diakses oleh aplikasi lain.

Apa?? Saya mendengar ada suara-suara kurang puas dari penonton.. Coba lebih keras??

Bagaimana cara mengaksesnya dari aplikasi client? Nampaknya belum ada kode program apa-apa untuk menyediakan layanan webservice. Mana bisa dibilang selesai?

Ok .. baiklah, memang ada satu langkah lagi. Yaitu mempublikasikan interface tersebut agar bisa diakses orang banyak. Kita akan sediakan akses melalui tiga protokol, yaitu:

  1. RMI
  2. Hessian
  3. Burlap

Tiga protokol?? Apa tidak terlalu ambisius? Nanti saya pusing baca kode sekian banyak.

Demikian terdengar komentar dari penonton. Hmm … penonton Indonesia memang terlalu banyak protes.

Tenang saja. Kita akan gunakan Spring untuk mempublikasikan aplikasi kecil kita ini. Saya akan buktikan bahwa kodenya sedikit dan mudah dipahami. Sekarang, mari kita mulai dengan mempublikasikan protokol RMI. Di masa lalu, untuk menyediakan layanan ini, paling tidak kita harus:

  1. mengkompilasi stub
  2. mengkompilasi skeleton
  3. mengkonfigurasi Security setting
  4. menjalankan RMIRegistry
  5. mendaftarkan objek PersonServiceImpl ke RMIRegistry
  6. memberikan stub ke aplikasi client

Sekarang tidak lagi. Kita cukup mendaftarkan interface PersonService, implementasi PersonServiceImpl di konfigurasi Spring. Berikut adalah isi file remote-ctx.xml


  1. <?xml version=”1.0″ encoding=”UTF-8″ ?>
  2. <!DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN//EN” “”&gt;
  3. <beans>
  4.     <bean id=”personServiceTarget” class=”tutorial.remoting.remote.PersonServiceImpl”/>
  5.     <bean class=”org.springframework.remoting.rmi.RmiServiceExporter”>
  6.         <property name=”serviceName” value=”PersonRmiService”/>
  7.         <property name=”service” ref=”personServiceTarget”/>
  8.         <property name=”serviceInterface” value=”tutorial.remoting.PersonService”/>
  9.         <property name=”registryPort” value=”4321″/>
  10.     </bean>
  11. </beans>

Hanya dengan membaca file XML di atas, kita sudah bisa menduga apa yang terjadi. Kita mempublikasikan layanan yang didefinisikan pada interface PersonService pada port 4321 dengan nama layanan PersonRmiService. Di sisi server, layanan ini akan disediakan oleh objek personServiceTarget yang merupakan instan dari class PersonServiceImpl. Kita memanfaatkan class RmiServiceExporter yang dimiliki Spring.

Untuk menjalankan aplikasi kecil kita, buat sebuah class sederhana untuk mengaktifkan Spring Framework. Berikut adalah kode programnya.

  1. package tutorial.remoting.server;
  2. import org.springframework.context.ApplicationContext;
  3. import;
  4. public class PersonRmiService {
  5.     public static void main(String[] xx) {
  6.         ApplicationContext ctx =
  7.         new FileSystemXmlApplicationContext(“webapp/WEB-INF/remote-ctx.xml”);
  8.     }
  9. }

Silahkan jalankan class di atas. Asal classpath sudah disetting dengan benar, kita siap mengaksesnya dari client.
Kita juga akan menggunakan bantuan dari Spring Framework untuk menemukan dan menginisialisasi layanan RMI yang berada di port 4321. Berikut adalah konfigurasi Spring di sisi client.


  1. <!DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN//EN” “”&gt;
  2. <beans>
  3.     <bean id=”personServiceRmi” class=”org.springframework.remoting.rmi.RmiProxyFactoryBean”>
  4.         <property name=”serviceUrl” value=”rmi://localhost:4321/PersonRmiService”/>
  5.         <property name=”serviceInterface” value=”tutorial.remoting.PersonService”/>
  6.     </bean>
  7. </beans>

Berikut adalah kode program untuk mengakses RMI service kita.

  1. package tutorial.remoting.client;
  2. import java.util.List;
  3. import tutorial.remoting.PersonService;
  4. import org.springframework.context.ApplicationContext;
  5. import;
  6. public class Main {
  7.     public static void main(String[] args){
  8.         // initialize application context
  9.         ApplicationContext ctx = new FileSystemXmlApplicationContext(“client-ctx.xml”);
  10.         // accessing RMI service
  11.         System.out.println(“======= Accessing RMI Service ==========”);
  12.         PersonService ps1 = (PersonService) ctx.getBean(“personServiceRmi”);
  13.         List all1 = ps1.getAllPerson();
  14.         for(int i=0; i<all1.size(); i++) {
  15.             System.out.println(all1.get(i));
  16.         }
  17. }

Perhatikan konsol, dan saksikan RMI service kita sudah dieksekusi dengan sukses.

Sekarang, kita publikasikan melalui protokol Hessian dan Burlap. Protokol ini adalah hasil karya Caucho untuk mempublikasikan service di atas protokol HTTP. Hessian menggunakan format binary, sedangkan Burlap menggunakan format XML.

Karena berbasis HTTP, maka kita perlu menggunakan HTTP Server yang mendukung Java (khususnya Servlet). Kita bisa gunakan Tomcat atau Jetty. Yang jelas, kita perlu mendeklarasikan servlet untuk melayani client. Deklarasi dibuat di dalam file web.xml sebagai berikut.


  1. <?xml version=”1.0″ encoding=”ISO-8859-1″?>
  2. <!DOCTYPE web-app PUBLIC
  3.     “-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN”
  4.     “”&gt;
  5. <web-app>
  6.     <context-param>
  7.         <param-name>contextConfigLocation</param-name>
  8.         <param-value>
  9.             /WEB-INF/remote-ctx.xml
  10.         </param-value>
  11.     </context-param>
  12.     <listener>
  13.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  14.     </listener>
  15.     <servlet>
  16.         <servlet-name>remoting</servlet-name>
  17.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  18.         <load-on-startup>2</load-on-startup>
  19.     </servlet>
  20.     <servlet-mapping>
  21.         <servlet-name>remoting</servlet-name>
  22.         <url-pattern>/remoting/*</url-pattern>
  23.     </servlet-mapping>
  24.     <session-config>
  25.         <session-timeout>10</session-timeout>
  26.     </session-config>
  27. </web-app>

Kita membutuhkan satu file konfigurasi untuk mengkonfigurasi layanan Hessian dan Burlap. Berikut adalah isi file remoting-servlet.xml.


  1. <?xml version=”1.0″ encoding=”UTF-8″ ?>
  2. <!DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN//EN” “”&gt;
  3. <beans>
  4.     <bean name=”/PersonHessianService” class=”org.springframework.remoting.caucho.HessianServiceExporter”>
  5.         <property name=”service” ref=”personServiceTarget”/>
  6.         <property name=”serviceInterface” value=”tutorial.remoting.PersonService”/>
  7.     </bean>
  8.     <bean name=”/PersonBurlapService” class=”org.springframework.remoting.caucho.BurlapServiceExporter”>
  9.         <property name=”service” ref=”personServiceTarget”/>
  10.         <property name=”serviceInterface” value=”tutorial.remoting.PersonService”/>
  11.     </bean>
  12.     <bean name=”/PersonHttpInvokerService” class=”org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter”>
  13.         <property name=”service” ref=”personServiceTarget”/>
  14.         <property name=”serviceInterface” value=”tutorial.remoting.PersonService”/>
  15.     </bean>
  16. </beans>

Letakkan file remoting-servlet.xml ini di sebelah web.xml. Kita juga perlu mengikutkan file remote-ctx.xml yang kita buat untuk RMI di atas, karena deklarasi objek PersonServiceImpl ada di sana. Bila kita tidak ingin mengikutkan file ini, kita bisa memindahkan deklarasi objek tersebut ke dalam file remoting-servlet.xml.

Sekarang kita bisa mengkompilasi dan mendeploy aplikasi webnya. Untuk mengaksesnya, ubah sedikit kode program di aplikasi client menjadi sebagai berikut.

  1. package tutorial.remoting.client;
  2. import java.util.List;
  3. import tutorial.remoting.PersonService;
  4. import org.springframework.context.ApplicationContext;
  5. import;
  6. public class Main {
  7.     public static void main(String[] args){
  8.         // initialize application context
  9.         ApplicationContext ctx = new FileSystemXmlApplicationContext(“client-ctx.xml”);
  10.         // accessing RMI service
  11.         System.out.println(“======= Accessing RMI Service ==========”);
  12.         PersonService ps1 = (PersonService) ctx.getBean(“personServiceRmi”);
  13.         List all1 = ps1.getAllPerson();
  14.         for(int i=0; i<all1.size(); i++) {
  15.             System.out.println(all1.get(i));
  16.         }
  17.         // accessing Hessian Service
  18.         System.out.println(“======= Accessing Hessian Service ==========”);
  19.         PersonService ps2 = (PersonService) ctx.getBean(“personServiceHessian”);
  20.         List all2 = ps2.getAllPerson();
  21.         for(int i=0; i<all2.size(); i++) {
  22.             System.out.println(all2.get(i));
  23.         }
  24.         // accessing Burlap Service
  25.         System.out.println(“======= Accessing Burlap Service ==========”);
  26.         PersonService ps3 = (PersonService) ctx.getBean(“personServiceBurlap”);
  27.         List all3 = ps3.getAllPerson();
  28.         for(int i=0; i<all3.size(); i++) {
  29.             System.out.println(all3.get(i));
  30.         }
  31.         // accessing Http Invoker Service
  32.         System.out.println(“======= Accessing Http Invoker Service ==========”);
  33.         PersonService ps4 = (PersonService) ctx.getBean(“personServiceHttpInvoker”);
  34.         List all4 = ps4.getAllPerson();
  35.         for(int i=0; i<all4.size(); i++) {
  36.             System.out.println(all4.get(i));
  37.         }
  38.     }
  39. }

Demikian juga dengan konfigurasi Spring di sisi client. Kita perlu menambahkan beberapa objek tambahan untuk mengakses layanan di berbagai protokol tersebut. Berikut adalah isi lengkap dari client-ctx.xml.


  1. <?xml version=”1.0″ encoding=”UTF-8″ ?>
  2. <!DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN//EN” “”&gt;
  3. <beans>
  4.     <bean id=”personServiceRmi” class=”org.springframework.remoting.rmi.RmiProxyFactoryBean”>
  5.         <property name=”serviceUrl” value=”rmi://localhost:4321/PersonRmiService”/>
  6.         <property name=”serviceInterface” value=”tutorial.remoting.PersonService”/>
  7.     </bean>
  8.     <bean id=”personServiceHessian” class=”org.springframework.remoting.caucho.HessianProxyFactoryBean”>
  9.         <property name=”serviceUrl” value=”http://localhost:9090/remoting/PersonHessianService”/&gt;
  10.         <property name=”serviceInterface” value=”tutorial.remoting.PersonService”/>
  11.     </bean>
  12.     <bean id=”personServiceBurlap” class=”org.springframework.remoting.caucho.BurlapProxyFactoryBean”>
  13.         <property name=”serviceUrl” value=”http://localhost:9090/remoting/PersonBurlapService”/&gt;
  14.         <property name=”serviceInterface” value=”tutorial.remoting.PersonService”/>
  15.     </bean>
  16.     <bean id=”personServiceHttpInvoker” class=”org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean”>
  17.         <property name=”serviceUrl” value=”http://localhost:9090/remoting/PersonHttpInvokerService”/&gt;
  18.         <property name=”serviceInterface” value=”tutorial.remoting.PersonService”/>
  19.     </bean>
  20. </beans>

Aplikasi kecil kita sudah selesai. Setelah mendeploy aplikasi tersebut ke Servlet Container (Tomcat atau Jetty), kita dapat mengaksesnya melalui aplikasi client. Dengan tetap menggunakan remote-ctx.xml tanpa perubahan, selain menyediakan protokol Hessian dan Burlap, protokol RMI akan tetap tersedia.


Pembaca yang teliti akan menemukan satu protokol tambahan pada contoh di atas, yaitu HttpInvoker. Ini adalah protokol khusus yang disediakan oleh Spring.

Protokol Hessian dan Burlap tidak mendukung struktur objek secara sempurna. Dia akan mengalami kesulitan apabila objek yang kita kirim tidak sesederhana Person, misalnya memiliki List yang berisi objek lain. Agar bisa mengirim struktur objek yang sempurna, kita harus menggunakan RMI.

Tetapi sayangnya, protokol RMI kurang lazim. Dia membutuhkan port tersendiri yang mungkin saja diblok oleh administrator jaringan, sehingga tidak sefleksibel HTTP.

SpringHttpInvoker menjembatani keterbatasan ini. Kita bisa mengirim objek kompleks secara utuh di atas protokol HTTP dengan menggunakan SpringHttpInvoker.

Demikian … semoga bermanfaat.

full Copy paste dari bang endy ;

maaf mumpung bisa di akses blog nya krn beberapa hari akses blog aban ga bisa, setelah bisa ya langkah aman copy paste he he

Developing a Spring Framework MVC application step-by-step using NetBeans


This is a step-by-step guide on how to develop a Spring Framework MVC application from scratch using NetBeans. Spring is basically a technology committed to enabling you to build applications using Plain Old Java Objects (POJOs). It enables you to develop components as POJOs containing only our business logic, while the framework takes care of the many value adds you need to build enterprise applications — even in areas that you may not have considered when initially authoring the application. This objective requires a complicated framework, which conceals much difficulty from the developer. Because your business logic is abstracted from infrastructure concerns, it’s also likely to enjoy a longer existence, improving the return on investment of writing it. Business logic should change at the pace of your business; only if it is abstracted from infrastructure concerns can the impact on your code base of expected infrastructure change (such as selecting the application server) be reduced.
2)This tutorial uses the traditional XML style for configuration.

Prerequisite software:

Java SDK 1.5/1.6
NetBeans 5.0 and above
Spring Framework 2.0

For Creating Web application project using NetBeans, please do the follwoing steps:

1. Choose File > New Project (Ctrl-Shift-N) from the main menu. Under Categories select Java Web (If you are using NetBeans 6.0 or 6.1, select Web); under Projects select Web Application. Click Next.

2. In Project Name, enter SpringDemo. From the Server drop-down list, select the server you plan to work with. Leave all other settings at their defaults and click Next.

3. Select a Spring framework 2.5 checkbox. When you reach the final panel of the wizard, click Finish.

3)Download Spring Framework 2.5.1
(optional step if you are not having Netbeans 6 and above version installed in you system)

Visit the Spring official website at
To download the Spring Frame work click on “Download” link.
Then select “” link. This download contains all the dependencies required to run the spring framework.
Save the downloaded file onto your favorite directory.
Now extract the downloaded file ( into your favorite directory.
The dist directory of the spring framework contains the spring modules (modules directory) library files. We are mostly concern with these jar files. We will copy these jar files later into our development environment. These jar files are:


4)Configure web.xml

Go to the ‘springdemo/WEB-INF’ directory. Modify the minimal ‘web.xml’ file to suit our needs. We define a DispatcherServlet that is going to control where all our request are routed based on information we will enter at a later point. It also has a standard servlet-mapping entry that maps to the url patterns that we will be using. Let any url with an ‘.htm’ extension be routed to the ‘springdemo’ dispatcher.






Next, create a file called ‘springdemo-servlet.xml’ in the springdemo/WEB-INF directory. This is the file where definitions used by the DispatcherServlet should be entered. It is named based on the servlet-name from web.xml with ‘-servlet’ appended. This is a standard naming convention used in the Spring Framework.

5)Copy jars to “WEB-INF/lib”

Then, from the Spring distribution, copy spring.jar (spring-framework-2.5.1/dist/spring.jar) to the new WEB-INF/lib directory. Also copy commons-logging jars to the WEB-INF/lib directory (spring-framework-2.5.1/lib/jakarta-commons/commons-logging.jar). These jars will be deployed to the server and they are also used during the build process.
6)Configuration of database

Download “hibernate 3.0” jar from and add the jar to the WEB-INF/lib directory. Add “mysql-connector-java-5.0.3-bin” to the WEB-INF/lib directory. (optional step if you are not having Netbeans 6 and above version installed in you system)
7)Create database and tables in MySQL

Create database by name “springdemo”.

Create a table by name “user” under “springdemo” database.

“user” table consists of the following fields:

USER_ID integer
FIRST_NAME varchar(45)
LAST_NAME varchar(45)
COMPANY varchar(45)
COMMENTS varchar(200)

Since we are using hibernate we have to create a OR mapping file. The mapping file for “user” is created as an xml file by name “User.hbm” under com.simpleweb.user.bean directory under Source Packages directory.


<?xml version=”1.0″?> <!DOCTYPE hibernate-mapping PUBLIC “-//Hibernate/Hibernate Mapping DTD 2.0//EN” “”&gt; <hibernate-mapping> <class name=”com.simpleweb.user.bean.User” table=”user” lazy=”false” > <id name=”userId” column=”USER_ID” type=”java.lang.Integer”> <generator/> </id> <property name=”firstName” column=”FIRST_NAME” type=”java.lang.String” /> <property name=”lastName” column=”LAST_NAME” type=”java.lang.String” /> <property name=”company” column=”COMPANY” type=”java.lang.String” /> <property name=”comments” column=”COMMENTS” type=”java.lang.String” /> </class> </hibernate-mapping>

Configure database configurations by adding the following code in “springdemo-servlet.xml”


<!-- DataSource Property -->
<bean id="userDataSource">
	 <property name="driverClassName"><value>com.mysql.jdbc.Driver</value>
	 </property><property name="url"><value>jdbc:mysql:///springdemo</value>
	 </property><property name="username"><value>root</value></property>
	 <property name="password"><value>mysql</value></property>

 <!-- Database Property -->
<bean id="userHibernateProperties">
	 <property name="properties">
			 <prop key="">update</prop>
			 <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.query.substitutions">true 'T', false 'F'</prop>
			 <prop key="hibernate.show_sql">true</prop>
			 <prop key="hibernate.c3p0.minPoolSize">5</prop>
			 <prop key="hibernate.c3p0.maxPoolSize">20</prop>
			 <prop key="hibernate.c3p0.timeout">600</prop>
			 <prop key="hibernate.c3p0.max_statement">50</prop>
			 <prop key="hibernate.c3p0.testConnectionOnCheckout">false</prop>

   <!-- Hibernate SessionFactory -->
<bean id="userSessionFactory">
	 <property name="dataSource"><ref local="userDataSource"/></property>
	 <property name="hibernateProperties"><ref bean="userHibernateProperties" /></property>

	 <!--  OR mapping files. -->
	 <property name="mappingResources">

Copy paste :

Java: Better Interfaces via JFormattedTextField

Creating forms that provide guided input for users and validated data for applications

Mark Pendergast is an Associate Professor of Computer Information System at Florida Gulf Coast University.

Data quality and accuracy is key to success for every application. Databases full of invalid phone numbers, improperly formatted email addresses, or out of range numeric data are of no use to anyone. Java Swing interface programmers know all too well the work involved in error checking user inputs taken from vanilla JTextFields. Many probably have been tempted to implement interfaces using JFormattedTextFields, but have been put off by the complexity of masks, formatters, verifiers, abstract classes, and interfaces that are required. In this article, I explain the proper use of the JFormattedTextFieldand its related classes to create forms that provide both guided input for users and validated data for the application. The source code for a sample application and a library of reusable classes for common data entry items based on JFormattedTextField is available for download here.

JFormattedTextFields are alternatives to JTextFields that are well worth using. They differ from JTextFields in several ways:

  • First, they maintain a current “value” associated with the field as an Object. The getValue and setValue methods are provided to access it.
  • Second, they use formatter objects to control the display of the value. One formatter is used to convert the value object to a String for display when the field does not have the focus; a separate formatter is used to convert the value when it receives the focus. Therefore a field that holds currency can limit the number of decimal places shown, have a dollar sign, and have commas separating the thousands while it is not being changed, then automatically change to a form with just digits and decimals when the focus is shifted to it. A type of formatter called a MaskFormatter can provide a “type-in-the-blank” template to guide the users input. MaskFormatters are useful for data types such as phone numbers, dates, and Social Security Numbers.
  • The third, and most important difference is that when combined with InputVerifiers they can handle all the parsing, range checking, and formatting required for processing GUI form interfaces. For example, Figure 1(a) shows a JFormattedTextField used to input currency with the focus, Figure 1(b) shows the same JFormattedTextField without the focus. Table 1 compares the code required to input, convert, and validate a double value using JTextField and JFormattedTextField.

Figure 1(a)

Figure 1(b)

Table 1: Comparison of code to access JTextField and JFormattedTextField values.

Implementing a JFormattedTextField

According to the Java API:

JFormattedTextField does not do the formatting it self, rather formatting is done through an instance of JFormattedTextField.AbstractFormatter which is obtained from an instance of JFormattedTextField.AbstractFormatterFactory.

What this really means is that to make a JFormattedTextField operate you need to create an instance of an AbstractFormatterFactory. The easiest way to do this is to use a convenience class called DefaultFormatterFactory, then attach it to the JFormattedTextField. The primary purpose of the DefaultFormatterFactory is to maintain three AbstractFormatter classes for the JFormattedTextField. One abstract formatter is the default formatter, it is used if a more specific formatter cannot be found; another is the display formatter used to format the value when the JFormattedTextField does not have the focus; and the third is the edit formatter, used to format the value when the JFormattedTextField has the focus.

DefaultFormatterFactory dff =
       new DefaultFormatterFactory(defFormatter, displayFormatter, editFormatter);
JFormattedTextField tf = new JFormattedTextField(dff);


DefaultFormatterFactory dff =
new DefaultFormatterFactory(defFormatter, displayFormatter, editFormatter);
JFormattedTextField tf = new JFormattedTextField(dff);

The formatter classes are primarily responsible for providing the body for two methods, stringToValue and valueToString. stringToValue parses a String and creates an object of the proper type (Long, Double, Date, Integer, etc). valueToString takes the current value and formats it for display. AbstractFormatter classes may in turn rely on specific format classes such as DecimalFormat and SimpleDateFormat. Creating formatter classes from scratch can be a daunting task, fortunately, the standard Java API provides numerous formatter classes that can be used as is. The standard class you use is determined by the type of data you need to format. Numeric data (currencies, counts, salaries) should use the NumberFormatter class, fixed length string data should use the MaskFormatter class (social security numbers, credit card numbers, phone numbers, dates), and variable length string data will need to have a custom formatter created based on the DefautFormatter class.