NetBeans 6 M7 released. There are some cool features available and cool modules in UC.

• Traditional setup file for separate packs
• using new NetBeans installer which allows you to customize your package before you download it.

• Download what you need by customizing the download package.

.

• From bundle that you have download you may not install all of them at the same time.

When you choose to install glassfish you have option to select its path, ports, and default JDK which are important options.

• You are allowed to uninstall some of components when you do not need them by running the installer again.

• Installer register any component that you install into other components (Application server, mobility features,....).
• Tight integration with windows add or remove programs.
• And many other features that I do not noticed yet.
  

	As you can see RoR support is available in update center.  If you are one of those RoR fans you should be happy now.
	Ok, there are tens of new language support based on new common scripting language support. Support for this languages is in several levels, from syntax highlight to code completion. you can try one that you need and if you find it useful you can vote for this future. NetBeans development team will value community inputs.
	There are some other good module which i have selected to be installed. As you can see Maven support is there too.

OK, what that really amazed me about new modules for NetBeans IDE is Jasper Report Visual designer, Its really cool to see a report designer for jasper report integrated into NetBeans.

I know that it has some basic integration but it is the initial release of this really cool module. here are some images of Jasper report designer integrated into NetBeans.

the project home page is https://jarvis.dev.java.net/ credits goes to developer of this really required module.

NetBeans 6 release is as amazing as NetBeans 5 release was.

Hibernate dynamic mapping and Dom4J enabled sessions

Hibernate from version 3.0? provide a very useful feature for people who develop application frameworks. Indeed this feature allows you to work directly with XML documents and elements which represent entities.
Imagine that you have an application or an SDK which help users to manipulate data from different RDBMSs. Hibernate provide rich configuration facilities which help you configure  Hibernate dynamically in term of adding mapping data or other configuration artifacts that usually stores in hibernate.cfg.xml or equal properties files.

As we are planning to use Hibernate dynamic mapping and Dom4J entity mode i am going to blog about it during my evaluation.
OK, Hibernate provide 3 kinds of entity mode

• POJO
• DOM4J
• MAP

Default mode sets to be POJO as it is most commonly used mode. This modes tell session how it should handle entities. We can configure a session to use any of this modes when we need that mode, but we can configure it in hibernate configuration file for by adding a property like

 <property name="default_entity_mode">dom4j</property>

To hibernate.cfg.xml . but for our sample we will create a session with dom4j entity mode. you can find a complete sample for this blog entry here . Make sure that you read readme file in project folder before you go toward executing it. For this sample I used Netbeans 6.0 M6 (which really rules) and Hibernate 3.2.1 . I wont tell steps to create project, XML file or ... but just actions and core required for hibernate side. you can see project structure in the following  image.



As you can see it is a basic ant based project.
Let me give you content of each file and explain about it as much as i could. First of all lets see what we have in hibernate.cfg.xml

 <?xml version='1.0' encoding='utf-8'?> <!DOCTYPE hibernate-configuration
 PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
 "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
 <hibernate-configuration>
     <session-factory >
         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
         <property name="hibernate.connection.url">jdbc:mysql://localhost/hiberDynamic</property>
         <property name="hibernate.connection.username">root</property>
         <property name="hibernate.connection.password">root</property>
         <property name="hibernate.c3p0.min_size">5</property>
         <property name="hibernate.c3p0.max_size">20</property>
         <property name="hibernate.c3p0.timeout">300</property>
         <property name="hibernate.c3p0.max_statements">50</property>
         <property name="hibernate.c3p0.idle_test_period">3000</property>
         <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
         <!--<property name="default_entity_mode">dom4j</property> -->
         <mapping resource="dynamic/Student.hbm.xml"/>
     </session-factory>
 </hibernate-configuration>

The configuration file is a simple and traditional hibernate configuration file with pooling enabled and  dialect sets to MySQL ones.
We have one mapping file which is named student.hbm.xml so we include it into the configuration file. If you do not have MySQL around then use Derby which is included into NetBeans ;-) .

 Log4J configuration is another traditional one, as you see
 log4j.appender.stdout=org.apache.log4j.FileAppender
 log4j.appender.stdout.File=messages_dynamic.log
 log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
 log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
 log4j.rootLogger=WARN, stdout
 

We used a file appender which send formatted log entry into a file named messages_dynamic.log in project root directory. next file which we are going to take a look is Student.hbm.xml  it is our mapping file, where we define the student as a dynamic entity.

 <?xml version="1.0"?>
 <!DOCTYPE hibernate-mapping PUBLIC
 "-//Hibernate/Hibernate Mapping DTD//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 
 <hibernate-mapping>
     <class  entity-name="Student" table="Student">
         <id name="id" column="STUDENT_ID" type="long">
             <generator class="native"/>
         </id>
         <property  name="name" type= "string"  column="STUDENT_NAME"/>
         <property name="lastName" type="string" column="STUDENT_LAST_NAME" />
     </class>
 </hibernate-mapping>
 

As you  can see there is just one change in  mapping file, we have entity-name attribute instead of class attribute. You should know that can have both class and entity-name attribute so an entity could be dynamic or mapped to a concrete class.

Next step is looking at our HibernateUtil which is known to the community for Hibernate booting and  hibernate instance management.
here is its code:

 
 package persistence;
 import org.hibernate.*;
 import org.hibernate.cfg.*;
 
 public class HibernateUtil {
   
     private static SessionFactory sessionFactory;
     static {
         try {
             sessionFactory = new Configuration().configure().buildSessionFactory();
        } catch (Throwable ex) {
             throw new ExceptionInInitializerError(ex);
         }
     }
    
     public static SessionFactory getSessionFactory() {
         return sessionFactory;
     }
     public static void shutdown() {
        
         getSessionFactory().close();
     }
 }
 

Noting extra here. lets look at last part in which we try to use dom4j session to manipulate our data.

 package dynamic;
 import java.util.*;
 import org.hibernate.EntityMode;
 import org.hibernate.Query;
 import org.hibernate.Session;
 import org.hibernate.Transaction;
 import persistence.HibernateUtil;
 import org.dom4j.*;
 
 
 public class DynamicMapping {
    
     public static void main(String[] args) {
         Session session = HibernateUtil.getSessionFactory().openSession().getSession(EntityMode.DOM4J);
         Transaction tx = session.beginTransaction();
 Query deleteQuery = session.createQuery("delete from Student");
 deleteQuery.executeUpdate();
 tx.commit();
 
 tx = session.beginTransaction();
         //create some some student and save them
         {
             Element anStudent = DocumentHelper.createElement("Student");
             Element nameElement = DocumentHelper.createElement("name");
             nameElement.setText("Alice");
            
             Element lastNameElement = DocumentHelper.createElement("lastName");
             lastNameElement.setText("Cooper");
            
             anStudent.add(nameElement);
             anStudent.add(lastNameElement);
             session.save(anStudent);
         }
         {
             Element anStudent = DocumentHelper.createElement("Student");
             Element nameElement = DocumentHelper.createElement("name");
             nameElement.setText("Lea");
            
             Element lastNameElement = DocumentHelper.createElement("lastName");
             lastNameElement.setText("Connor");
            
             anStudent.add(nameElement);
             anStudent.add(lastNameElement);
             session.save(anStudent);
         }
        
         tx.commit();
         //List all student
         Query q = session.createQuery("from Student ");
        
         List students = q.list();
         org.dom4j.Element el = (org.dom4j.Element)students.get(0);
         System.out.println(el.getText());
         for (Iterator it = students.iterator(); it.hasNext();) {
             org.dom4j.Element student = (org.dom4j.Element)it.next();
            
            
             System.out.println("Printing an Student details: ");
            
             for ( Iterator i = student.elementIterator(); i.hasNext(); ) {
                 Element element = (Element) i.next();
                 System.out.println( element.getName()+":  "+ element.getText());
             }
         }
         //retrieve an student, update and save it
        
         q = session.createQuery("from Student where  name =:studentName ");
         q.setParameter("studentName", "Alice");
         Element alice = (Element) q.uniqueResult();
        
         alice.element("name").setText("No Alice any more");
         tx=session.beginTransaction();
         session.save(alice);
         tx.commit();
        
         session.close();
         HibernateUtil.shutdown();
     }
 }
 

In the begging we create a session with dom4j entity mode. so it will return Dom4J elements as our entities. in next two blocks i have create two students one is Alice Cooper and the other is John connor  (what does this name remind you? ;-) . we simply ask our session to save them as we do for usual POJO mode. Session know what to do with dom4j elements as it is configured as a DOM4J session.
In Second block we query our table and retrieve all entities into a list, but this list is not a list of Student POJOs instead it is a list of DOM4J elements. so we need to do some XML processing when we want to extract our entity properties. you can learn more about DOM4J at Here .

Next step we retrieve a single row, edit and save it into our database, Its all simple DOM4J operation which you should use over some elements to manipulate your data.

Build file that i used contains two target that we will use during this project. first one is hbm2ddl which will create our database structure and the second one is run target which will execute our main class. it is not required to include build file here  you can download the sample and check it yourself. make sure you look at readme file before digging into execution of application.

In next few days I will try to do a simple benchmark for some simple CRUD operation to have a basic clue about DOM4J entity mode in our environment.

Jonas Joins to Netbeans supported application servers

1. Sun java application server (Glassfish)
2. JBoss application server
3. Tomcat servlet container
4. WebLogic application server
5. JonAs application server

• Starting and stopping the server
• Java and JSP debugging
• Generating the default server specific deployment descriptors
• Deploying, undeploying the Web, EJB and EAR modules
• Browsing the deployed WAR, EJB and EAR modules

Netbeans 5.5 and Jdeveloper 10.1.3.1 both sounds very good...

Netbeans 5.5 and Jdeveloper 10.1.3.1 which one ?
Both Jdeveloper and Netbeans that i am talking about them are in beta and developer preview stage.
Netbeans as an Opensource IDE has its own fast growing user community.

Netbeans 5.5 beta 2 let features include :

• develop and deploy on tomcat / Glassfish and Jboss out of the box.
• As core features it has many code generation facilitis which can help to bootstrap an application ,it has code generation for CMPs , session facades ,ws client stub....
• Having an almost first class profiler , first class J2me development pack
• New c/c++ development pack
• good support for SVN and CVS
• very good Swing designer
• developer collaboration module
• Heavy support of SUN by giving the source codes for some of its extra pack

which Made NetBeans a good choice for developers.

One of the packs that donated by sun· is Enterprise pack , Enterprise pack features in brief are as follow :

• UML 2 compliant modeler
• visual BPEL
• visual WSDL designer
• xml visual tools for xml schema declaration ...
• facilities to develop web service and apply security on them.

• Oracle have much more code generation falsities that Netbeans .
• visual ESB modeling allows you to assemble you ESB component visually (its ESB is not JBI compliant)
• visual WSDL designer
• visual xml development tools
• good swing designer and data binding using oracle ADF
• good JSF / Struts support , indeed Jdeveloper JSF support with its ADF faces is brilliant.
• WYSIWYG for HTML and jsp pages with support of third party jsf libraries like Myfaces.
• first class database development facilities ( for oracle database mostly).
• Only you can use oracle server suite as development server there is no support for other application servers.
• No support for c/c++ development (AFAIK).
• built-in profiler
• very powerful web page generation which can bootstrap a data driven web page design.
• UML modeler (1.4 compliant)
• very rich set of facilities for Web service development
• ...

I think JDeveloper (for now) is ahead of NetBeans as it provide much more facilities for developers , but for later version we can not tell anything because NetBeans people are unpredictable , as they prove their credibility by release of NetBeans 5.

What you have read is my opinion which might be biased. we never can say that one IDE is 100% better than another , it is just context oriented and the users view point. but one thing is completely obvious that JDeveloper and NetBeans both are going to provide rich facilities for SOA. NetBeans by means of· Enterprise pack and using glassfish with integrated BPMS from intalio and· what it has acquired from seebyond.
and oracle with its SOA suite and JDeveloper , both are going to make choice harder for developers.

Develop web application with netbeans ,seam and Glassfish

In this two part series I will try to show you how easily you can  build applications using NetBeans 5.5 based on  seam , facelets , jsf and new EJB 3 standard.

I will not discuss any of framework in details as you can find detailed information about each of them in their homepage and some other articles.
I want just show , How you can use NetBeans with some leading frameworks to build your web based applications. I will not discuss NetBeans specific tasks in details .
I will more focus on leveraging this stuff together using NetBeans IDE.

What you will need to follow  this series :

• NetBeans enterprise edition 5.5 , you will need Glassfish or JBoss to continue with this series. check and make sure that your NetBeans has application server bundled otherwise get a copy of glassfish from its website.
• seam 1.0.1 GA  or newer.

seam distribution contain Facelets too , but i strongly suggest you get Facelets distribution separately and take a look at its samples and very good documentation. indeed both Facelets and seam has very good documentation.

In this entry I will introduce each of this frameworks in very brief  to make the series stand alone , and i will show you how to setup the development environment and we will go with first part which is developing seam layer codes.

JBoss seam is created to leverage maximum possible feature of Java EE 5 standards like JSF and EJB3.
seam , seamlessly integrate EJB3 as a backend with JSF as presentation , meanwhile provide management of long running process
by using JBPM . and give you ability to focus on your business logic rather than silly data providing stuff. By leveraging Facelets helps you to do even more with seam and JSF.

To name its features I can say:

• Lesser XML, More Annotation. (please do not blame me for naming annotation and XML in one line :-))
• it let you go with your business logic rather thinking and resolving some common issue like user conversation state.
• seam has a more flexible context model , it has 8 context , by means of this context you can manage your application more effective. for example a business process live in business process context .
• Accessing each component in entire seam context with one unique name.
• Managing workplaces and conversations .
• It easily will let you develop Portlet by providing a Portlet context . we will discuss this item in latter parts

With many more features.

But about JSF , JSF is  a web framework , it is  Standard and  Developed under JSR 127.
Some of JSF features are as follow:

•  User interface framework
•  Server-side UI components
•  Event model , something like desktop applications event model , but very reduced.
•  Component state
•  Renderers , Render Kits , for example ADF faces has a telnet render which make it possible to render a ADF faces application for a  telnet client.
•  Validation
•  Type conversion
•  Internationalization

about Facelets , we will discuss more in next articles , but for now you should know that Facelets bring some view related enhancement and features to JSF community .
To name some of features :

• Facelets make it possible to develop your entire web pages using your favorite page designer like Dream weaver or Microsoft FrontPage. to achieve this feature it introduce a new attribute, jsfc ,that make it possible to change each html element  to a JSF equal component. it is similar to Tapestry 's jwcid attribute. So you can use all binding and event handling stuff of JSF and availability and ease of use of html WYSIWYG.
• Facelets provide a template-ing  features like Velocity's for JSF . it allows you to test JSF views out of container.
• Some decoration features like what tile bring to struts community and SiteMesh ,generally, to all java based web application.

lets start the job of creating simplest sample ;) .

I assume that you download seam and extract it in seam_home Also your NetBeans 5.5 is running and an application server capable of  containing ejb3 (Glassfish) is configured with your IDE.

for sake of simplicity we make one   Library in our NetBeans IDE to make our job easier. as you know each library could contain some jar files, etc...
 

Create a library name it seam and add the following jar files to it , the first
seam_home\jboss-seam.jar
seam_home\jboss-seam-ui.jar
seam_home\hibernate-all.jar
seam_home\thirdparty-all.jar

add seam library  to Registeration-EJBModule and Registeration-WebModule

Switch to runtime view (CTRL+5).Extend database node  , if you have no database created in your embedded derby  then create a database and create a table with following  characteristics
Table Name: users
Fields :

after you create this table , create a new enterprise application project by going to , file>new project>enterprise application
name it Registeration. make sure that you have selected the Java EE 5 as j2ee version.

go to project view (CTRL+1) And select Registeration-ejbModule , right click on it and select CMP entity bean from database...
Now you should be able to select the JDBC connection that you have made in above step and give it a package name.
click next and select users table from left column and add it to right column.
click finish.
That's it , you have your CMP ready to go.

• what we need to add to the CMP bean class in addition to its created structure
• another constructor with all the CMP  fields.
• some annotation for getters , to help us in validation

final shape of users CMP will be like :

package cmps;

import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

import org.hibernate.validator.Length;
import org.hibernate.validator.NotNull;
import org.jboss.seam.annotations.Name;
import org.jboss.seam.annotations.Scope;
/**
 *
 * @author Masoud Kalali
 */
@Entity
@Name("user")
@Scope(org.jboss.seam.ScopeType.SESSION)
@Table(name="users")
public class Users implements Serializable{
   private static final long serialVersionUID = 1881413500711441951L;
    private String username;

    private String password;

    private String name;
    
    /** Creates a new instance of Users */
    public Users() {
    }

    
    public  Users(String name, String password, String username)
 {
this.name = name;
this.password = password;
this.username = username;
}
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "username", nullable = false)
     @Length(min=5, max=15) 
    public String getUsername() {
        return this.username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Column(name = "password", nullable = false)
     @Length(min=5, max=15) 
    public String getPassword() {
        return this.password;
    }

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

    @Column(name = "name", nullable = false)
     @Length(min=5, max=15) 
    public String getName() {
        return this.name;
    }

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

we are finished with our POJO EJB :-) , now lets go and handle web layer stuff , from now we are working with seam view layer and JSF , I will talk about Facelets later in other articles of this series.

as I said in sample scenario we have just one action , so we can use a  managed bean or plain java object or whatever that is useable here as action listener or use a stateless session bean (using session bean is what JBoss offer) so we will use a stateless session bean to implement our action listener , it will also helps you to see how an stateless session bean is implemented in java EE 5.
so create a session bean by using , file > new > session bean , now you can select session bean type to be stateless , and change the package name to be sbeans
click finish  , editor will open up and show you the stateless seasion bean class.   
change the class body , in a way that final class looks like :

import cmps.Users;
import java.util.List;

import javax.ejb.Stateless;
import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.hibernate.validator.Valid;
import org.jboss.seam.annotations.Factory;


import org.jboss.seam.annotations.IfInvalid;
import org.jboss.seam.annotations.In;
import org.jboss.seam.annotations.Name;
import org.jboss.seam.annotations.Outcome;
import org.jboss.seam.annotations.datamodel.DataModel;
import org.jboss.seam.core.FacesMessages;
import org.jboss.seam.ejb.SeamInterceptor;

@Stateless
@Name("")
public class ActionBean implements sbeans.ActionLocal
{
   
   @IfInvalid(outcome=Outcome.REDISPLAY)
   public String ()
   {
      List existing = em.createQuery("select username from User where username=:username")
         .setParameter("username", user.getUsername())
         .getResultList();
      if (existing.size()==0)
      {
         em.persist(user);
         return "success";
      }
      else
      {
         FacesMessages.instance().add("User #{user.username} already exists");
         return "success";
      }
   }

}

package sbeans;


/**
 * This is the business interface for Action enterprise bean.
 */
public interface ActionLocal {
      public String ();
}

Now right click in the editor and add 4 new navigation case , these cases will handle navigating from one view to another.

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
<%@ taglib prefix="s" uri="http://jboss.com/products/seam/taglib"%>
<html>
<head>
<title> New User</title>
</head>
<body>
<f:view>
<h:form>
<table border="0">
              <s:validateAll>
<tr>
<td>Username</td>
<td><h:inputText id="username" value="#{user.username}" required="true" /></td>
<td>      <h:message for="username"/>       </td>
</tr>
<tr>
<td>Real Name</td>
<td><h:inputText  id="name" value="#{user.name}" required="true" /></td>
<td>      <h:message for="name"/>       </td>
</tr>
<tr>
<td>Password</td>
<td><h:inputSecret id="password" value="#{user.password}"  required="true" /></td>
<td>      <h:message for="password"/>       </td>
</tr>
          </s:validateAll>
</table>
<h:messages globalOnly="true"/>
<h:commandButton type="submit" value="" action="#{.}"/>
</h:form>
</f:view>
</body>
</html>

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
<html>
<head>
<title>Successfully ed New User</title>
</head>
<body>
<f:view>
Welcome, <h:outputText value="#{user.name}"/>,
you are successfully ed as <h:outputText value="#{user.username}"/>.
</f:view>
</body>
</html>

Now we are almost finished with JSf files , there are some changes that we should make in web.xml and faces-config.xml.first open web.xml and add the following lines to it.make sure the you add them directly inside <web-app> node.

 <context-param>
		<description>
		</description>
		<param-name>org.jboss.seam.core.init.jndiPattern</param-name>
		<param-value>java:comp/env/registration/#{ejbName}/local</param-value>
</context-param>

<listener>
	<listener-class>org.jboss.seam.servlet.SeamListener</listener-class>
</listener>

<ejb-local-ref>
	<ejb-ref-name>registration/RegisterActionBean/local</ejb-ref-name>
	<ejb-ref-type>Session</ejb-ref-type>
	<local>sbeans.RegisterActionLocal</local>
<	ejb-link>RegisterActionBean</ejb-link>
</ejb-local-ref>

<lifecycle> <phase-listener>org.jboss.seam.jsf.SeamPhaseListener</phase-listener> </lifecycle>

You can check whether it applied or not by switching to runtime view and checking your Users table data . you can find complete explanation of jsp/java codes in Seam tutorial chapter 1 at : http://docs.jboss.com/seam/1.0.0.GA/reference/en/html/tutorial.html

Step by Step toward a jms sample in NetBeans and yes GlassFish. part 2 : Remote Client

...
  Context ctx = new InitialContext();
...

• provider url , for glassfish in iiop format it is : iiop://127.0.0.1:3700
We can use a key like Context.PROVIDER_URL to put its value into hashtable , also we may use java.naming.provider.url String to put value of this parameter into HashTable . this parameter is vendor dependent.

• initial context factory , for glassfish it is : com.sun.appserv.naming.S1ASCtxFactory
This is another important parameter that we must set before we can access a JNDI Tree , indeed it is totaly vendor dependent because each vendor has its own implementation for its JNDI access. This factory will create the context object along with the url that you put into the hashtable. we may use Context.INITIAL_CONTEXT_FACTORY or "java.naming.factory.initial" string as a key to put this value into the hashtable

• glassfish_home/lib/appserv-rt.jar
• glassfish_home/lib/javaee.jar
• glassfish_home/lib/install/applications/jmsra/jmsra.jar
• glassfish_home/lib/install/applications/jmsra/imqbroker.jar
• glassfish_home/imq/lib/imq.jar
• glassfish_home/lib/appserv-admin.jar
• glassfish_home/imq/lib/jms.jar

public class JmsClient {
    Context ctx;
    public JmsClient() {
        Hashtable properties = new Hashtable(2);
        properties.put(Context.PROVIDER_URL,"iiop://127.0.0.1:3700");
        properties.put(Context.INITIAL_CONTEXT_FACTORY,"com.sun.appserv.naming.S1ASCtxFactory");
        try {
            ctx = new InitialContext(properties);
        } catch (NamingException ex) {
            ex.printStackTrace();
        }
    }
   public Object lookup(String name){
        try {
            return ctx.lookup(name);
        } catch (NamingException ex) {
            ex.printStackTrace();
        }
        return null;
    }

    public static void main(String[] args) {
        JmsClient client = new JmsClient();
        try{
            ConnectionFactory     connectionFactory = (ConnectionFactory)client.lookup("jms/tConnectionFactory");
            Queue     queue = (Queue)client.lookup("jms/tQueue");
            javax.jms.Connection  connection = connectionFactory.createConnection();
            javax.jms.Session        session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
            MessageProducer messageProducer = session.createProducer(queue);
            for(int i=0;i<5;i++) {
                TextMessage message = session.createTextMessage("It is a message from main class "+  ": "+ i);
                System.out.println( "It come from main class:"+ message.getText());
                messageProducer.send(message);
            }
        } catch(Exception ex){
            ex.printStackTrace();
        }
    }
}

• we create a ConnectionFactory by looking it up in the jndi by using our context and dummy lookup(...) method.
• we create a Queue by looking it up in the jndi by using our context and dummy lookup(...) method.
• Then we create a connection using that ConnectionFactory
• we obtain a Session (jms Session) using our connection
• we made the messageproducer which is our tools to send message to that Queue ,
• in a loop we create and sent 5 text message to the queue.

Step by Step toward a jms sample in NetBeans and yes GlassFish

• A JMS implementation that is configured with our server , it can be done using embedded servers that are shipped with application servers or using remote / local MQ servers.
  GlassFish uses Sun message Queue , which is going to be available under the same license that GlassFish is provided. You can find more information about open source version at : http://mq.dev.java.net
• You also need to setup a Queue and a connection factory in your application server.*
• you should Create an MDB , and then implement the onMessage() method in way that you like.

• use GlassFish server web based administration console
• use GlassFish command line console
• using NetBeans 5.5 , yes NetBeans provide you some wizard thingy to make JMS / JDBC resources from withing NetBeans and then registering them to Application server.

• Run The IDE and go to runtime tab , expand server node and start the GlassFish instance.
• right click on GlassFish node and select view admin console
• login to admin console ,In left side navigation panel , expand the resources and expand JMS resources
• click on connection factories and from main frame click on new button , fill in the values as following ones
• JNDI Name: jms/tConnectionFactory
• Type: javax.jmsConnectionFactory **
• Description: some description here
• give it a name like : tConnectionFactory
• Click OK button
** in JMS 1.1 we can use same factory for both publish/subscribe and point-to-point messaging
• now we need to create a queue to be our messages destination, click on destination resources from main frame click on new and fill in the values as following ones
• JNDI Name: jms/tQueue
• Type: javax.JMS.Queue
• Description: some description here
• give it a name like : tQueue
• Click Save button

• EJB Name : TMDB
• package : mdbs
• Mapped Name : jms/tQueue***

  @Resource
    private MessageDrivenContext mdc;
    public void onMessage(Message message) {
     
        TextMessage msg = null;
        try {
            if (message instanceof TextMessage) {
                msg = (TextMessage) message;
System.out.println("A Message received in TMDB: " +
                        msg.getText());
            } else {
               System.out.println("Message of wrong type: " +
                        message.getClass().getName());
                
            }
        } catch (JMSException e) {
            e.printStackTrace();
            mdc.setRollbackOnly();
        } catch (Throwable te) {
            te.printStackTrace();
        }
    }

<%@page contentType="text/html"%>

<%@page pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">
<html>
    <head>

        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Page</title>

    </head>
    <body>
<center>        
<form action="sendMessage">
            <table  cellspacing="20" >

                <tbody>
                    <tr>
                        <td>Enter some message: </td>
                        <td><input type="text" name="message" value="Enter your message here" width="30" /></td>

                    </tr>
                </tbody>
            </table>
            
                <input type="submit" value="Send The message" name="send" />

            </center>
        </form>
    </body>
</html>

1. Right click on web application node and select New > Servlet...
2. change its Name to sendMessage give it a package name and click finish
3. change the processRequest(..) method body as following list

 protected void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        //start the jms stuff

        try{
            Context ctx = new InitialContext();
            ConnectionFactory     connectionFactory = (ConnectionFactory)ctx.lookup("jms/tConnectionFactory");
            Queue     queue = (Queue)ctx.lookup("jms/tQueue");
            javax.jms.Connection  connection = connectionFactory.createConnection();
            javax.jms.Session        session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
            MessageProducer messageProducer = session.createProducer(queue);
            TextMessage message = session.createTextMessage();
            message.setText(request.getParameter("message"));
            System.out.println( "It come from Servlet:"+ message.getText());
            messageProducer.send(message);

//message sent , it was all
            
            //show what we have done in this servlet
            out.println("<html>");
            out.println("<head>");
            out.println("<title>Servlet sendMessage</title>");
            out.println("</head>");
            out.println("<body>");
            out.println("<center>");
            out.print("Servlet Send this message <h2>"+request.getParameter("message") + "</h2>  to this Queue : <h2>"+queue.getQueueName()+"</h2>");
            out.println("</center>");
            out.println("</body>");
            out.println("</html>");
            
        } catch(Exception ex){
            ex.printStackTrace();
        }
        
        out.close();
    }

A New Module for Netbeans IDE , an statistical CVS Reporter...

1. Customizable filters
2. History table
3. Statistical charts
4. HTML reports
5. CSV (Comma delimited) reports

1. Both panels which are lied in north section should be converted into a wizard , so you start a wizard and it helps you to prepare a report step by step
2. CVS setup dialog should be converted to NetBeans Standard CVS setup dialog
3. It should be able to read CVS profiles that you have made in your NetBeans IDE. Like some other articles , blog posts ,... That contain an integration issue this plugin need more integration ;-)
4. Configuration files should be NetBeans standard configuration
5. Tasks , should be converted to NetBeans standard Tasks
6. Nor original software nor this plugin contain a progress bar , I think it should have some indicator that tell it is processing , even for very small portion of time
7. Change i18n to comply with NetBeans i18n standards

1. SVN (Subversion) support
2. CVS SSH support
3. More statistical charts
4. XML reports
5. Also I thought about using JFree Chart instead of Charts that created by the software author , Jfree Chart has much more advanced charting engine and it gives user more feature to build better software , but it will make the module bigger in download size

A Simple Netbeans Module , a Gmail Checker...

This work is licensed under a Creative Commons License.