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

NetBeans 6 milestone 7  has released and you can download it from NetBeans web site by at least two methods

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

Traditional method for downloading NetBeans 6 which is a development build is using http://www.netbeans.info/downloads/dev.php and the new installer which I am going to talk about is available at http://nbi.netbeans.org/ .
Google pack installer is somehow similar to new NetBeans installer. In one simple paragraph it allows you to customize what you need in one mega installer and then you can download your customized package to your local machine to install those components into your system.
features that new installer has and I really like them are as follow (sure you may find some there feature that I have not mentioned )

  • Download what you need by customizing the download package.

Download section.

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

Installer first round

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.

Uninstalling

  • 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.

But there are some other cool changes in NetBeans IDE, look what we have as our icon set, it remind me some of Firefox themes with fantasy icons. I hope we could see some modularity mechanism for icons which will allows NetBeans fans to develop some new icon set or use older version of icon set.
new icons

Based on NetBeans 6 Feature Plan  we will have RoR and JavaScript support in NetBeans 6 M7, so this features should be inside our downloaded IDE or in update center, lets look and see what does we have in NetBeans new project and file and also in update centers.
Yes, we have JavaScript and ROR support built-in.

Lets see what else we can find in update center that is not available for 5.5.* or in NetBeans 6 M7 out of the box.

RoR

As you can see RoR support is available in update center. 
If you are one of those RoR fans you should be happy now.

Languages

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.

Maven support

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.

jarvis

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.

Hibernate dom4j session project structure

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.