My Wiki

August 28, 2006

Moved this blog to a new site

Filed under: Uncategorized — jaikiran @ 8:10 am

Have moved this blog to http://jaitechwriteups.blogspot.com/, which provides support of custom css, which helps me in handling the code contents in my posts more elegantly. Currently, i am in the process of evaluating the same. The new blog however, does not have support for tagging the posts(or maybe i am unaware of the same). Will post here once i completely move to that blog. I have already moved all my posts from here to the new blog.

August 17, 2006

Evict collection from Hibernate second level cache

Filed under: Hibernate — jaikiran @ 3:59 pm

Hibernate allows persistent objects to be cached in its second level cache(The first level cache in Hibernate is the Session object which is ON by default). Applications can switch on the second level cache.  When a object is being retrieved by the application through Hibernate, Hibernate first checks in its Session cache and then the Second level cache to see if the object has be retrieved already. If it finds it either the Session cache or the Second level cache, it will NOT fire a query to the database.

While configuring second level cache, the object can be cached and also the collections contained in the object can be cached. Have a look at the following example:

<hibernate-mapping default-lazy="false" > 

 <class name="org.myapp.ho.Parent" table="Parent"> 

    <cache usage="read-only" /> 

    <id name="id" type="Integer" column="ID" /> 

  <set name="myChildren"> 

     <cache usage="read-only"> 

     <one-to-many class="org.myapp.ho.Child"> 

  </set> 

 </class> 

</hibernate-mapping>
<hibernate-mapping default-lazy="false" > 

   <class name="org.myapp.ho.Child" table="Child"> 
      <cache usage="read-only" /> 
      <id name="id" type="Integer" column="ID" /> 

   </class> 

</hibernate-mapping>

Note that we have used the cache setting at 3 places:

 1) The org.myapp.ho.Parent object

 2) The “myChildren” collection in the org.myapp.ho.Parent object

 3) The org.myapp.ho.Child object

When you configure a collection to be second level cached in Hibernate, it internally maintains a SEPERATE cache for these collection than the one which it uses to cache the parent objects. So in the example above, the “myChildren” will be cached separately than the org.myapp.ho.Parent object.

 There might be cases where applications would want to evict objects from the cache. If its the Session cache from which the application has to evict the object then the call to Session.evict will cascade even to collections and will evict the collection from the *Session cache*. However, if the object(and the collections contained in it) have to be evicted from the second level cache, then the application has to *explicitly* call the evictCollection method on the SessionFactory to remove the *collection* contained in the Parent object. The reason behind this is, as already mentioned, the collections are cached separately, than the parent objects, in the second level cache.

So, in our example above, if we have to evict the Parent with id 500 and its collection from the second level cache, then here’s what has to be done:

SessionFactory sf = MyUtil.getSessionFactory();

sf.evict(org.myapp.ho.Parent.class,new Integer(500)); //this will evict the Parent Object from the second level cache

sf.evictCollection(org.myapp.ho.Parent.class.getName() +  “.myChildren”, new Integer(500)); //this will evict the collection from the second level cache for the Parent with id=500

The first parameter to the evictCollection method is the ‘roleName’ of the collection. The roleName is formed as follows:

roleName = NameOfTheParentClass + “.” + NameOfTheCollectionInsideTheParent

The second parameter the evictCollection method is the id of the parent object, to which this collection belongs.

July 31, 2006

Custom reverse engineering strategy in Hibernate

Filed under: Hibernate — jaikiran @ 10:12 am

Hibernate has tools to create mapping files(hbm files) and domain model classes from database schemas(reverse engineering). <jdbcconfguration> can be used as part of ant task to do this. Hibernate creates the property names using its default reverse engineering strategy. Hibernate also, provides a way through which the user can specify his own custom reverse engineering strategy through which he can follow his own naming conventions etc…

There is a reversestrategy attribute which can be set to some custom class, which implements org.hibernate.cfg.reveng.ReverseEngineeringStrategy, in the <jdbcconfiguration>. Here’s an example:

<jdbcconfiguration configurationfile="hibernate.cfg.xml"  

    packagename="${package.name}"  

    revengfile="hibernate.reveng.xml"  

    reversestrategy="org.myapp.hibernate.tool.SampleReverseEngineeringStrategy"/>

The org.myapp.hibernate.tool.SampleReverseEngineeringStrategy is our own custom class which implements org.hibernate.cfg.reveng.ReverseEngineeringStrategy. In this example, our SampleReverseEngineeringStrategy, overrides the columnToPropertyName(TableIdentifier table, String column) method to provide a custom implementation for generating property names out of a column name. Here’s the SampleReverseEngineeringStrategy code:

package org.myapp.hibernate.tool;  

import java.util.regex.Matcher;  

import java.util.regex.Pattern;  

import org.hibernate.cfg.reveng.DelegatingReverseEngineeringStrategy;  

import org.hibernate.cfg.reveng.ReverseEngineeringStrategy;  

import org.hibernate.cfg.reveng.TableIdentifier;  

/**  

 *  

 * @author Jaikiran Pai  

 *  

 */  

public class SampleReverseEngineeringStrategy extends DelegatingReverseEngineeringStrategy {  

/**  

  * Constructor  

  *  

  * @param delegate {@link org.hibernate.cfg.reveng.ReverseEngineeringStrategy}  

  */  

 public SampleReverseEngineeringStrategy(ReverseEngineeringStrategy delegate) {  

  super(delegate);  

 }  

/**  

  * Changes the default behaviour of naming the property. <br>  

  * Does the following replacements(not neccessarily in the order) and returns the resulting  

  * {@link String} as property name  

  *  

  * <ul>  

  *  <li>Converts the first letter of the <code>column</code> to uppercase</li>  

  *  <li>Converts the letters following a '_' character to uppercase in the <code>column</code></li>  

  *  <li>Removes any underscores present from <code>column</code></li>  

  * </ul>  

  *   

  *  

  * @see org.hibernate.cfg.reveng.DelegatingReverseEngineeringStrategy  

  * @see org.hibernate.cfg.reveng.ReverseEngineeringStrategy  

  *  

  * @param table {@link TableIdentifier}  

  * @param column  

  * @return Returns the propert name after converting it appropriately  

  */  

public String columnToPropertyName(TableIdentifier table, String column) {  

    

  String replacedColumn = replaceFirstLetterToUpperCase(column);  

    

  replacedColumn = removeUnderScoresAndConvertNextLetterToUpperCase(replacedColumn);  

  if (anyReplacementsMadeToOriginalColumnName(column,replacedColumn)) {  

   return replacedColumn;  

  }  

  /*  

   * Let DelegatingReverseEngineeringStrategy handle this  

   */  

  return super.columnToPropertyName(table, column);  

    

 }  

   

 /**  

  *  

  * Returns true if the <code>originalString</code> and <code>replacedString</code> are NOT equal  

  * (meaning there was some replacement done to the original column name). Else returns false. <br/>  

  *  

  * @param originalString The original column name  

  * @param replacedString The column name after doing necessary replacements  

  * @return Returns true if the <code>originalString</code> and <code>replacedString</code> are NOT equal  

  * (meaning there was some replacement done to the original column name). Else returns false.  

  *   

  * @throws {@link NullPointerException} if <code>originalString</code> is null.  

  */  

 protected boolean anyReplacementsMadeToOriginalColumnName(String originalString, String replacedString) {  

  if (originalString.equals(replacedString)) {  

   return false;  

  }  

  return true;  

 }  

   

 /**  

  * Converts the first letter of the <code>input</code> to uppercase and  

  * returns the resultant {@link String}.<br/>  

  * <p>  

  * Ex: If the <code>input</code> is startDate then the resulting {@link String}  

  * after replacement will be StartDate  

  * </p>  

  *  

  * @param input The {@link String} whose contents have to be replaced  

  * @return Returns a {@link String} after doing the appropriate replacements  

  */  

 protected String replaceFirstLetterToUpperCase(String input) {  

  /*  

   * The pattern to match a String starting with lower case  

   */  

  final String startsWithLowerCasePattern = "^[a-z]";  

  Pattern patternForReplacingLowerCase = Pattern.compile(startsWithLowerCasePattern);  

        Matcher regexMatcher = patternForReplacingLowerCase.matcher(input);  

        /*  

         * This will hold the replaced contents  

         */  

        StringBuffer replacedContents = new StringBuffer();  

        /*  

         * Check whether the first letter starts with lowercase.  

         * If yes, change it to uppercase, else pass on the control to  

         * DelegatingReverseEngineeringStrategy  

         *  

         */  

        if (regexMatcher.find()) {  

         String firstCharacter = regexMatcher.group();  

         /*  

          * Convert it to uppercase  

          */  

         regexMatcher.appendReplacement(replacedContents,firstCharacter.toUpperCase());  

         regexMatcher.appendTail(replacedContents);  

            regexMatcher.reset();  

            /*  

             * Return the replaced contents  

             */  

   return replacedContents.toString();  

  }  

        //no replacements to do, just return the original input  

        return input;  

         

 }  

   

 /**  

  * Converts the letters following a '_' character to uppercase and also removes  

  * the '_' character from the <code>input</code> and returns the resulting {@link String}. <br/>  

  * Carries out a 2 pass strategy to do the replacements. During the first pass,  

  * replaces all the letters that immidiately follow a '_' to uppercase.  

  * <p>  

  * Ex: If the <code>input</code> is _start_Date__today_ then after the first pass of replacement, the  

  * resultant string will be _Start_Date__Today_  

  * </p>  

  * <p>  

  * This replaced {@link String} is then passed ahead for second pass (if no replacements were  

  * done during first pass, then the original {@link String} is passed). During the second pass  

  * the underscores are removed.  

  * </p>  

  * <p>  

  * Ex: If the <code>input</code> is _start_Date__today_ then after BOTH the passes the  

  * resultant string will be StartDateToday  

  * </p>  

  *  

  * @param input The {@link String} whose contents have to be replaced  

  * @return Returns a {@link String} after doing the appropriate replacements  

  */  

 protected String removeUnderScoresAndConvertNextLetterToUpperCase(String input) {  

  /*  

   * The pattern which matches a String that starts with a letter immidiately after  

   * a '_' character  

   */  

  final String stringFollowingUnderScore = "[.]*_[a-zA-Z]+";  

  Pattern patternForReplacingLowerCase = Pattern.compile(stringFollowingUnderScore);  

        Matcher regexMatcher = patternForReplacingLowerCase.matcher(input);  

        /*  

         * This will hold the replaced contents  

         */  

        StringBuffer replacedContents = new StringBuffer();  

        boolean foundAnyMatch = false;  

        while (regexMatcher.find()) {  

         foundAnyMatch = true;  

      String matchedString = regexMatcher.group();  

      /*  

       * The character immidiately following the underscore  

       * Example:  

       * If matchedString is _tMn then originalCharAfterUnderScore will be the  

       * character t  

       */  

      char originalCharAfterUnderScore = matchedString.charAt(1);  

      /*  

       * Convert the character to uppercase  

       */  

      String replacedCharAfterUnderScore = String.valueOf(originalCharAfterUnderScore).toUpperCase();  

      /*  

       * Now place this replaced character back into the matchedString  

       */  

      String replacement = matchedString.replace(originalCharAfterUnderScore,replacedCharAfterUnderScore.charAt(0));  

      /*  

       * Append this to the replacedColumn, which will be returned back to the user  

       */  

      regexMatcher.appendReplacement(replacedContents,replacement);  

    }  

        regexMatcher.appendTail(replacedContents);  

     regexMatcher.reset();  

       

     /*  

      * Now the input string has been replaced to contain uppercase letters after the underscore.  

      * Ex: If input string was "_start_Date_today" then at this point after the above processing,  

      * the replaced string will be "_Start_Date_Today"  

      * The only thing that remains now is to remove the underscores from the input string.  

      * The following statements do this part.  

      *  

      */  

     if (foundAnyMatch) {  

      return removeUnderScores(replacedContents.toString());  

  } else {  

   return removeUnderScores(input);  

  }  

       

 }  

   

 /**  

  * Removes any underscores present from <code>input</code> and returns the  

  * resulting {@link String}  

  * <p>  

  * Ex: If the <code>input</code> is _start_Date__today_ then the resulting {@link String}  

  * after replacement will be startDatetoday  

  * </p>  

  *  

  * @param input The {@link String} whose contents have to be replaced  

  * @return Returns a {@link String} after doing the appropriate replacements  

  */  

 protected String removeUnderScores(String input) {  

  /*  

   * Pattern for matching underscores  

   */  

  Pattern patternForUnderScore = Pattern.compile("[.]*_[.]*");  

  Matcher regexMatcher = patternForUnderScore.matcher(input);  

  /*  

   * This will hold the return value  

   */  

  StringBuffer returnVal = new StringBuffer();  

     boolean foundAnyMatch = false;  

     while (regexMatcher.find()) {  

      foundAnyMatch = true;  

   String matchedString = regexMatcher.group();  

   /*  

    * Remove the underscore  

    */  

   regexMatcher.appendReplacement(returnVal,"");  

     }  

     regexMatcher.appendTail(returnVal);  

     regexMatcher.reset();  

     /*  

      * If any match was found(and replaced) then return the replaced string.  

      * Else return the original input.  

      */  

     if (foundAnyMatch) {  

      return returnVal.toString();  

     }  

       

     return input;  

 }  

    

    

}

In the example above, the columnToPropertyName method is overridden to do the following:

– Creates property names that start with a Capital case(By default, Hibernate creates property names in camel-case)

– Converts the letter, that follows a ‘_’ (underscore character) to uppercase in the property name

– Removes any underscores in the property name

Ex: If the column name is start_Date_today, then the resulting property name after using the SampleReverseEngineeringStrategy would be StartDateToday.

Here’s a documentation from Hibernate about Controlling Reverse Engineering

July 25, 2006

Convert exception stacktrace to String object

Filed under: Java — jaikiran @ 12:31 pm

Usually whenever a exception occurs, we use the method printStackTrace() on the exception object to display the stacktrace. However, if the stacktrace has to be stored into a String  object then the following piece of code will prove handy:

  /**
     * Creates and returns a {@link java.lang.String} from <code>t</code>’s stacktrace 
     * @param t Throwable whose stack trace is required
     * @return String representing the stack trace of the exception
     */
    public String getStackTrace(Throwable t) {
        StringWriter stringWritter = new StringWriter();
        PrintWriter printWritter = new PrintWriter(stringWritter, true);
        t.printStackTrace(printWritter);
        printWritter.flush();
        stringWritter.flush();
 

       return stringWritter.toString();
    }

How to enable Garbage Collection (GC) logs

Filed under: Java — jaikiran @ 10:19 am

To enable GC logs, the -Xloggc:logFileName option will have to be passed when java command is being executed. Additionally if the detailed log of the GC is required, then an additional -XX:+PrintGCDetails option will have to be passed.

Example: java -Xloggc:D:/log/myLogFile.log -XX:+PrintGCDetails myProg

Lookup an EJB from a different application, deployed on the same server, in JBoss

Filed under: EJB, JBoss — jaikiran @ 7:57 am

Question:
I have a web application through which i want to access an EJB which is deployed as a separate appliaction on the same server. How do i do it?

Answer:

In the web.xml of your war(the web application through which you want to access the EJB), have the following entry:

<ejb-ref>
    <ejb-ref-name>GiveAnyNameByWhichYouWouldLikeToReferTheBeanInYourWebApp</ejb-ref-name>
    <ejb-ref-type>session</ejb-ref-type>
    <home>packageName.ClassNameOfTheHomeObjectOfTheBeanYouWantToRefer</home>
    <remote>packageName.ClassNameOfTheRemoteObjectOfTheBeanYouWantToRefer</remote>
  </ejb-ref>
 
  In the jboss-web.xml of your war, have the following entry:
 
  <ejb-ref>
    <ejb-ref-name>GiveAnyNameByWhichYouWouldLikeToReferTheBeanInYourWebApp(This should be same as the one given in the web.xml above)</ejb-ref-name>
    <jndi-name>TheJndiNametoWhichTheBeanIsBound(Example:somecontext/somejndiName)YouWillFindThisJndiNameInTheJboss.xmlOfTheEJB</jndi-name>
   </ejb-ref>
   
For more info, have a look at the dtds of web.xml (http://java.sun.com/dtd/web-app_2_3.dtd) and jboss-web.xml(http://www.jboss.org/j2ee/dtd)
 
  In your code, do the lookup as:
 
  Context ic = new InitialContext();
  Object ejbHome = ic.lookup(“java:comp/env/TheNameThatYouHadGivenInTheEJB-REF-NAMETagOfJbossWeb.xmlAbove”);

Here’s an example:

web.xml:
<ejb-ref>
    <ejb-ref-name>MyTestBean</ejb-ref-name>
    <ejb-ref-type>session</ejb-ref-type>
    <home>com.test.ejb.MyBeanHome</home>
    <remote>com.test.ejb.MyBeanRemote</remote>
  </ejb-ref>

jboss-web.xml:
 <ejb-ref>
  <ejb-ref-name>MyTestBean</ejb-ref-name>
  <jndi-name>myejb/test/MyTestBean</jndi-name>
 </ejb-ref>
 
Lookup code:

Context ic = new InitialContext();
  Object ejbHome = ic.lookup(“java:comp/env/MyTestBean”);
 

July 24, 2006

How to create a Queue/Topic in JBoss?

Filed under: JBoss, JMS — jaikiran @ 9:09 am

Queues/Topics are known as administered objects and in jboss they can be deployed through ServiceDotXml files. Let’s name our file, myapp-destination-service.xml. The contents of the file should look like:

<?xml version=”1.0″ encoding=”UTF-8″?>

<server>
   <!–My queue, named: myAppQueue –>
  <mbean code=”org.jboss.mq.server.jmx.Queue”
  name=”jboss.mq.destination:service=Queue,name=myAppQueue“>
    <depends optional-attribute-name=”DestinationManager”>jboss.mq:service=DestinationManager</depends>
  </mbean>
  
 <!– My topic, named: myAppTopic –>
  <mbean code=”org.jboss.mq.server.jmx.Topic”
  name=”jboss.mq.destination:service=Topic,name=myAppTopic“>
    <depends optional-attribute-name=”DestinationManager”>jboss.mq:service=DestinationManager</depends>
  </mbean>
  
    
  </server>

 Place this file in your %JBOSS_HOME%/server/default/deploy directory and start the server.(Note: If you are using the ‘all’ configuration or the ‘minimal’ configuration then you will have to place this file in the %JBOSS_HOME%/server/all/deploy  or %JBOSS_HOME%/server/minimal/deploy   directory, as appropriate).

The above queue/topic will be bound to the jndi name: queue/myAppQueue and topic/myAppTopic respectively.

Note:

1) The above file is meant for JBoss-3.2.3. Though there might be slight changes to later versions of JBoss, the basic configuration mechanism remains the same.

2) JBoss also comes with preconfigured queues/topics. These configurations can be found in the jbossmq-destinations-service.xml file which is present in %JBOSS_HOME%/server/default/deploy/jms directory

July 12, 2006

Create your own logging level in log4j

Filed under: Log4j — jaikiran @ 2:22 am

If you need to add your own logging level in log4j, then you can do it as follows. You will have to create your own class which will extend from Level. Here’s a sample code for the same:

MyTraceLevel.java:

package org.myapp.log;
import org.apache.log4j.Level;
/**  
 * My own {@link org.apache.log4j.Level} for logging.  
 *  
 * @author Jaikiran Pai  
 *  
 */  
public class MyTraceLevel extends Level {  
     
    /**  
     * Value of my trace level. This value is lesser than {@link org.apache.log4j.Priority#DEBUG_INT}  
     * and higher than {@link org.apache.log4j.Level#TRACE_INT}  
     */  
    public static final int MY_TRACE_INT = DEBUG_INT - 10;  
     
    /**  
     * {@link Level} representing my log level  
     */  
    public static final Level MY_TRACE = new MyTraceLevel(MY_TRACE_INT,"MY_TRACE",7);
    /**  
     * Constructor  
     *  
     * @param arg0  
     * @param arg1  
     * @param arg2  
     */  
    protected MyTraceLevel(int arg0, String arg1, int arg2) {  
        super(arg0, arg1, arg2);
    }  
     
    /**  
     * Checks whether <code>sArg</code> is "MY_TRACE" level. If yes then returns {@link MyTraceLevel#MY_TRACE},  
     * else calls {@link MyTraceLevel#toLevel(String, Level)} passing it {@link Level#DEBUG} as the defaultLevel  
     *  
     * @see Level#toLevel(java.lang.String)  
     * @see Level#toLevel(java.lang.String, org.apache.log4j.Level)  
     *  
     */  
    public static Level toLevel(String sArg) {  
        if (sArg != null && sArg.toUpperCase().equals("MY_TRACE")) {  
            return MY_TRACE;  
        }  
        return (Level) toLevel(sArg, Level.DEBUG);  
    }
    /**  
     * Checks whether <code>val</code> is {@link MyTraceLevel#MY_TRACE_INT}. If yes then returns {@link MyTraceLevel#MY_TRACE},  
     * else calls {@link MyTraceLevel#toLevel(int, Level)} passing it {@link Level#DEBUG} as the defaultLevel  
     *  
     * @see Level#toLevel(int)  
     * @see Level#toLevel(int, org.apache.log4j.Level)  
     *  
     */  
    public static Level toLevel(int val) {  
        if (val == MY_TRACE_INT) {  
            return MY_TRACE;  
        }  
        return (Level) toLevel(val, Level.DEBUG);  
    }
    /**  
     * Checks whether <code>val</code> is {@link MyTraceLevel#MY_TRACE_INT}. If yes then returns {@link MyTraceLevel#MY_TRACE},  
     * else calls {@link Level#toLevel(int, org.apache.log4j.Level)}  
     *  
     * @see Level#toLevel(int, org.apache.log4j.Level)  
     */  
    public static Level toLevel(int val, Level defaultLevel) {  
        if (val == MY_TRACE_INT) {  
            return MY_TRACE;  
        }  
        return Level.toLevel(val,defaultLevel);  
    }
    /**  
     * Checks whether <code>sArg</code> is "MY_TRACE" level. If yes then returns {@link MyTraceLevel#MY_TRACE},  
     * else calls {@link Level#toLevel(java.lang.String, org.apache.log4j.Level)}  
     *  
     * @see Level#toLevel(java.lang.String, org.apache.log4j.Level)  
     */  
    public static Level toLevel(String sArg, Level defaultLevel) {                   
    if(sArg != null && sArg.toUpperCase().equals("MY_TRACE")) {  
        return MY_TRACE;  
    }  
    return Level.toLevel(sArg,defaultLevel);  
 }  
     
}
 

Now here’s the log4j.xml configuration file:

<?xml version="1.0" encoding="UTF-8"?>            

<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">            

<!-- ===================================================================== -->            

<!-- -->            

<!-- Log4j Configuration -->            

<!-- -->            

<!-- ===================================================================== -->            

<!-- $Id: log4j.xml,v 1.13.2.8 2003/09/23 14:16:27 slaboure Exp $ -->            

<!--            

| For more configuration infromation and examples see the Jakarta Log4j            

| owebsite: http://jakarta.apache.org/log4j            

-->            

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/" debug="false">            

<!-- ================================= -->            

<!-- Preserve messages in a local file -->            

<!-- ================================= -->            

<!-- A size based rolling appender -->            

<appender name="FILE" class="org.apache.log4j.FileAppender">            

<param name="File" value="D:/log/myLogFile.log"/>            

<param name="Append" value="false"/>            

<layout class="org.apache.log4j.PatternLayout">            

<param name="ConversionPattern" value="%d{ISO8601} %-5p [%c] %m%n"/>            

</layout>            

</appender>            

<!-- ============================== -->            

<!-- Append messages to the console -->            

<!-- ============================== -->            

<appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">            

<param name="Target" value="System.out"/>            

<param name="Threshold" value="INFO"/>            

<layout class="org.apache.log4j.PatternLayout">            

<!-- The default pattern: Date Priority [Category] Messagen -->            

<param name="ConversionPattern" value="%d{ISO8601} %-5p [%c{1}] %m%n"/>            

</layout>            

</appender>            

<!-- ================ -->            

<!-- Limit categories -->            

<!-- ================ -->            

<category name="org.myapp">            

<priority value="MY_TRACE" class="org.myapp.log.MyTraceLevel" />            

<appender-ref ref="FILE"/>            

</category>            

<!-- ======================= -->            

<!-- Setup the Root category -->            

<!-- ======================= -->            

<root>            

<appender-ref ref="CONSOLE"/>            

</root>            

</log4j:configuration>            

Here’s a test program which can be used for testing whether the new log level that you introduced is being identified or not:

TestMyLogLevel.java:

package org.myapp.core;

import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.myapp.log.MyTraceLevel;

/**
 * Tests whether the new log level {@link org.myapp.log.MyTraceLevel#MY_TRACE} is working
 *
 * @author Jaikiran Pai
 *
 */
public class TestMyLogLevel {

    /**
     * Writes a log message with {@link org.myapp.log.MyTraceLevel#MY_TRACE} and another message
     * with {@link Level#DEBUG}
     *
     * @param args
     */
    public static void main(String[] args) {
        Logger logger = Logger.getLogger(TestMyLogLevel.class.getName());
        System.out.println(“Got the logger. Invoking log() method”);
        logger.log(MyTraceLevel.MY_TRACE,”Did i get into the log file?”);
        System.out.println(“Wrote the log with my trace level”);
        logger.log(Level.DEBUG ,”I am a debug message”);
        System.out.println(“Wrote the log with debug level”);
    }
}
Finally, here’s the log file that got generated:
2006-07-12 13:45:40,633 MY_TRACE [org.myapp.core.TestMyLogLevel] I am MY_TRACE log
2006-07-12 13:45:40,633 DEBUG [org.myapp.core.TestMyLogLevel] I am a debug message

Points to note:
The int value that you specify for your log level is important. Here i have defined “MY_TRACE” log level is to be higher than the DEBUG level but lower than the TRACE level provided by log4j. So whenever you have set a priority level to DEBUG on the category(in your log4j.xml file), the MY_TRACE level logs will *NOT* make it to the log file.

July 5, 2006

I get “log4j:WARN No appenders could be found for logger” message

Filed under: Log4j — jaikiran @ 7:57 am

While using log4j in your application, sometimes you might encounter the following message:

log4j:WARN No appenders could be found for logger(somePackageName.someClassName).
log4j:WARN Please initialize the log4j system properly.

The reason why you see this message is that your log4j configuration file(i.e. log4j.xml or log4j.properties) is NOT found in the classpath. Placing the log4j configuration file in the applications classpath should solve the issue. If you want to find out how log4j tries to configure itself, have a look at my earlier post :

Know how log4j tries to configure itself

July 4, 2006

Know how log4j tries to configure itself

Filed under: Log4j — jaikiran @ 2:44 am

Large number of applications use log4j for logging. Sometimes you may encounter cases where you sense that log4j is using some other configurations, other than the one that you expected it to use. You can debug the same by switching on the debug flag on log4j. Here’s how you can do it:

Add -Dlog4j.debug to the command line. log4j will output info to std. out. telling you how it tries to configure itself.

Accessing a secure EJB through a standalone java client

Filed under: EJB, JAAS — jaikiran @ 1:10 am

To access a secure resource(may be a EJB), from a standalone client, you need to do a JAAS login. Here’s an simple example which shows how to implement the same. But before going to the example, here’s the reason why we need to do a login. Consider a secured EJB “MyTestEJB”, deployed on a app server. The normal proceedure that you follow in a web-application to lookup the EJB and invoke a method on the same is as follows:

Context context = new InitialContext();
//lookup the home object
Object lookupObj = context.lookup(“MyTestEJBHomeJndiName”);
MyTestEJBHome home = (MyTestEJBHome) PortableRemoteObject.narrow(lookupObj, MyTestEJBHome.class);
//create the bean object from the home object
MyTestEJB myBean = home.create();
//invoke the method on the bean
myBean.someMethod();

In the steps above, when the method create is called on the home object, the app server internally checks whether the user who is doing this operation, is authenticated and authorised to do the same. If not, it will throw a SecurityException. The above statements will usually work in a web-application where usually you have a login page to carry out the login process.

Now, consider the case with a standalone java client which has just got a main method and which needs to invoke the secure bean. The application server will have no knowledge about which user is trying to do the operations on the bean(is he authenticated or authorised?). This is the reason why the standalone client needs to do a JAAS login, to let the application server know which user is trying to do the operation on the bean. Now lets look at the code for doing the same. Here we have a standalone java client with a main() method:

package myapp;

import javax.ejb.CreateException;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.rmi.PortableRemoteObject;
import javax.security.auth.login.LoginContext;
import javax.security.auth.login.LoginException;
import java.io.Serializable;
import java.rmi.RemoteException;

/**
*
* Stand-alone client invoking a method on a secure EJB
*
*/
public class SomeStandAloneClient {

 /**
 * Default constructor
 *
 */
 public SomeStandAloneClient() {
 
 }
 
 /**
 * Main method
 *
 * @param args Command line arguments
 */
 public static void main(String[] args) {
 
  //obtain the username and password which are passed as part of command line arguments
  String userName = args[0];
  String password = args[1];
  
  System.out.println(“Logging in user: ” + userName);
  
  /*
  * The name of the file which will contain the login configurations
  */
  final String authFile = “someFilename.someExtension”;
  
  /*
  * Set the filename above, as part of system property, so that while doing a login,
  * this file will be used to check the login configurations
  */
  System.setProperty(“java.security.auth.login.config”, authFile);
  
  /*
  * During the login process(i.e. when the login() method on the LoginContext is called),
  * the control will be transferred to a CallbackHandler. The CallbackHandler will be
  * responsible for populating the Callback object with the username and password, which
  * will be later on used by the login process
  *
  * The “MyCallbackHandler” is your own class and you can give any name to it. MyCallbackHandler
  * expects the username and password to be passed through its constructor, but this is NOT
  * mandatory when you are writing your own callback handler.
  *
  *
  */
  MyCallbackHandler handler = new MyCallbackHandler(userName,password);
  
  try {
  
   /*
   * Create a login context. Here, as the first parameter, you will specify which
   * configuration(mentioned in the “authFile” above) will be used. Here we are specifying
   * “someXYZLogin” as the configuration to be used. Note: This has to match the configuration
   * specified in the someFilename.someExtension authFile above.
   * The login context expects a CallbackHandler as the second parameter. Here we are specifying
   * the instance of MyCallbackHandler created earlier. The “handle()” method of this handler
   * will be called during the login process.
   */
   LoginContext lc = new LoginContext(“someXYZLogin”,handler);
   
   /*
   * Do the login
   */
   lc.login();
   
   System.out.println(“Successfully logged in user: ” + userName);
  
  } catch (LoginException le) {
   System.out.println(“Login failed”);
   le.printStackTrace();
   return;
  }
  
  try{
  
   /*
   * Now that the user has logged in, invoke the method on the EJB
   */
   
   Context context = new InitialContext();
   
   //lookup the home object
   Object lookupObj = context.lookup(“MyTestEJBHomeJndiName”);
   MyTestEJBHome home = (MyTestEJBHome) PortableRemoteObject.narrow(lookupObj, MyTestEJBHome.class);
   
   //create the bean object from the home object
   MyTestEJB myBean = home.create();
   
   //invoke the method on the bean
   myBean.someMethod();
   
  } catch (RemoteException re) {
   System.out.println(“Remote exception: “);
   re.printStackTrace();
   return;
  } catch (NamingException ne) {
   System.out.println(“NamingException: “);
   ne.printStackTrace();
   return;
  } catch (CreateException ce) {
   System.out.println(“CreateException: “);
   ce.printStackTrace();
   return;
  }
  
 } //end of main()

} //end of SomeStandAloneClient

Now the CallbackHandler:

package myapp;
import java.io.IOException;
import javax.security.auth.callback.Callback;
import javax.security.auth.callback.CallbackHandler;
import javax.security.auth.callback.NameCallback;
import javax.security.auth.callback.PasswordCallback;
import javax.security.auth.callback.UnsupportedCallbackException;
/**
*
* CallbackHandler which will be invoked by the login module during the login
* process of the client. This is a simple CallbackHandler which sets the username
* and password, which will be later used by the Login module for authorizing the
* subject. This class only handles NameCallback and PasswordCallback. It throws
* an UnsupportedCallbackException, if the Callback is other than the two mentioned
* above.
* The username and password are provided as input to this class through its constructor.
*
*
*/
public class MyCallbackHandler implements CallbackHandler {
 /**
 * Username which will be set in the NameCallback, when NameCallback is handled
 */
 private String username;
 
 /**
 * Password which will be set in the PasswordCallback, when PasswordCallback is handled
 */
 private String password;
 
 /**
 * Constructor
 * @param username The username
 * @param password The password
 */
 public MyCallbackHandler(String username, String password) {
 this.username = username;
 this.password = password;
 }
 
 /**
 * @param callbacks Instances of Callbacks
 * @throws IOException IOException
 * @throws UnsupportedCallbackException If Callback is other than NameCallback or PasswordCallback
 */
 public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException {
 
     for (int i = 0; i < callbacks.length; i++) {
         if (callbacks[i] instanceof NameCallback) {
             //if the Callback is for NameCallback, then set the name of the NameCallback to ‘userName’
             NameCallback nc = (NameCallback) callbacks[i];
             nc.setName(username);
            
         } else if (callbacks[i] instanceof PasswordCallback) {
             //if the Callback is for PasswordCallback, then set the name of the PasswordCallback to ‘password’
             PasswordCallback pc = (PasswordCallback) callbacks[i];
             pc.setPassword(password.toCharArray());
            
         } else {
             //if Callback is NOT NameCallback or PasswordCallback then throw UnsupportedCallbackException
             throw new UnsupportedCallbackException(callbacks[i], “Unrecognized Callback”);
         }
     }
 }
}
The file containing the login configuration(in our case “someFilename.someExtension”):
someXYZLogin{
org.jboss.security.ClientLoginModule required;
};

Remember, the someXYZLogin configuration name is the same that i provided to the constructor of the LoginContext. The contents of the above file let the LoginContext know, which class will be actually responsible for doing the login. In this case, since i am using jboss, we have specified “org.jboss.security.ClientLoginModule” as the class.Make sure that the login configuration file is under the same directory from where you will be running your client.

The command to run your client is the same that you would use to run a normal java class:

java SomeStandAloneClient someUsername somePassword

The someUsername and somePassword will be the arguments that you will pass to the main() method.

This is just a simple example. Internally, there are a lot of things, that go on as part of login. The following link has a great explanation about the same(JAAS related things are explained starting from the “An Introduction to JAAS” section in that article). I highly recommend, to go through it atleast once:

Article on Security

Blog at WordPress.com.