Jianfeng Tian

Initialising in Grails Service

2011-11-03T10:27:00.000Z

Attributes can be initialised from config in grails service by implementing the Spring InitializingBean interface. In the afterPropertiesSet method, set the attributes.

class SomeService implements InitializingBean {
def grailsApplication
private static String TOKEN

void afterPropertiesSet() {
TOKEN = grailsApplication.config.token
println this
}

def someMethod() {
println TOKEN
println this
}
}

In unit and integration test, the afterPropertiesSet method has to be called otherwise the TOKEN won't be set. But noticeably, in unit test, the instances printed out by 'println this' are different, although grails service by default is a singleton implementation; but in integration test, the instance from 'println this' is the same.

In unit test:

@Before
void setUp() {
service.afterPropertiesSet()
}
}

In integration test:

private static service

@BeforeClass
static void fixtureSetUp() {
service.afterPropertiesSet()
}

Grails Service Singleton

2011-10-22T09:50:00.000+01:00

Jeff Brown explained Grails singleton service in Nabble. Below is his description.

"If your service has an instance variable (that is state) and you don't want that state to be shared by multiple concurrent users of the service, then you don't want that service to be a singleton. If a service is a singleton then every user of that service is sharing the same copy of the service. If a service is request scoped then a new instance is created for every http request. If a service is sessions scoped then the service will be kept around and reused for the entire user session (each user session has their own copy). "

Cannot get property 'config' on null object in Grails Integration Test

2011-10-20T17:52:00.000+01:00

Class someService {

def grailsApplication

def someMethod() {

def attribute = grailsApplication.config.someAttribute
return attribute
}
}

When running integration test,

Class someServiceTests {

@Test
void testSomeMethod() {
def service = new SomeService()
def attribute = service.someMethod()
}
}

It will complain that:

"java.lang.NullPointerException: Cannot get property 'config' on null object"

The way around this is, in the integration test, add the following line:

service.grailsApplication = new DefaultGrailsApplication()

Mock grailsApplication and config in Unit Test

2011-09-15T15:48:00.002+01:00

grailsApplication can be injected in controller before 2.0.0, and it is still the case for 2.0.0

Before grails 2.0.0, you can only access your config in the service by calling ConfigurationHolder.config. But now with Grails 2.0.0, grailsApplication can be injected in service.

In unit test, we should do the following, so that the grailsApplication and config is mocked properly.

service.grailsApplication = [config.config]

controller.grailsApplication = [config: config]

Specify your own environment in Grails

2011-09-12T11:53:00.000+01:00

environments {

foo {

settings = 'bar'

}

To specify your environment:

grails -Dgrails.env=foo

Proxy setting

2011-06-08T12:00:00.000+01:00

If you are behind firewall, and your application need internet connection, then put the following code in your ~/.bash_profile

JAVA_OPTS="-Dhttp.proxyHost=yourProxyFileName -Dhttp.proxyPort=8080"
export JAVA_OPTS

Then refresh the console using:

. ~/.bash_profile

Reload External Config File Dynamically

2011-02-10T17:34:00.000Z

If the grails application's Config.groovy file is changed, the war file has to be regenerated to reflect the changes, and the war has to be redeployed onto the server. This process normally involves:

1. Generate the grails application war file.
2. Go to the tomcat manager console
3. Click "Undeploy" to remove the application's context.
4. Upload the newly generated war to the ${tomcat}/webapps directory

Adding an external config file (like the code below) in the Config.groovy file does allow not to re-generate the war file. It does allow you to define sensible configuration info (e.g. username, password, access allowed users, etc.) in an external file rather than packed within the generated war file.

grails.config.locations = [ "file:${userHome}/.grails/CoursePackApp/${appName}-config.groovy"]

However the web application doesn't load the changes in the external config file automatically, thus the application has to be stopped and re-started. This process normally involves:

1. Go to the tomcat manager console
2. Click "stop" to stop the application
3. Click "start" to start the application, so that the application can pick up the changes in the external config file.

To avoid the above hassle (i.e. regenerating the war file, restarting the application) every time we change the .

In the grails-app/conf/Config.groovy file, add:

grails.config.locations = ["file:${userHome}/.grails/YourPath/${appName}-config.groovy"]

On the server, create the external file at:

/userHome/.grails/YourPath/CoursePackApp-config.groovy

In a controller which is the entry point to the application (i.e. Login Controller), add the code below. Thus every time this controller action is accessed, the external config is re-loaded.

// Courtesy IntelliGrape http://bit.ly/aHZRjZ

// access external config file

def config = ConfigurationHolder.config
def locations = config.grails.config.locations

locations.each {
 String configFileName = it.split("file:")[1]
 config.merge(new ConfigSlurper().parse(new File(configFileName).text))
}

Mocking Command Object in Grails

2010-11-25T15:09:00.002Z

Class PersonCommand {
  String firstname
  String lastname

  static constraints = {
    firstname(blank: false)
    lastname(blank: false)
  }
}

Class PersonController {
  def save {PersonCommand cmd ->
    if (cmd.hasErrors()) {
      ...
    }
    else {
      render (view: 'confirm', model: [person: cmd])
    }
  }
}

Create an instance of that command object and pass it to the action. Below also shows the way to pass on a map of parameters to construct the command object. This needs the help of the metaClass.

import grails.plugin.spock.ControllerSpec

Class PersonControllerSpec extends ControllerSpec {
  def 'save action' () {
    given "":
    mockCommandObject(PersonCommand)
    Map mp = [firstname: 'joe', lastname: 'blog']
    controller.metaClass.getParams { -> mp}

    when : "person form parameters are submitted"
    // This works
    // def cmd = new PersonCommand(firstname: 'joe', lastname: 'blog')

    // This works better as it allows to pass on a map of parameters
    def cmd = new PersonCommand(mp)

    // Call the action
    controller.save(cmd)

    then : "the command object should be valid"
    assert cmd.valid()

    and : "the right model and view can be retrieved"
    renderArgs.view = 'confirm'
    renderArgs.model.person.firstname == 'joe'
  }
}

Note that the mockCommandObject only works when doing controller unit test, not domain unit test.

Grails with customised ID Generator

2010-11-19T10:29:00.000Z

Grails Controller Unit Test with setting params as a map

2010-11-15T12:31:00.000Z

When running controller unit test. Setting the params individually like below works fine

controller.params.firstname = 'joe'
controller.params.lastname = 'blog'

However, if setting the params using a map like below:

controller.params = [firstname: 'joe', lastname: 'blog']

It would throw exceptions:

groovy.lang.ReadOnlyPropertyException: Cannot set readonly property: params for class:

As suggested by Richard Bradley and Amit Jain in Grails mailing list, there are two solutions:

With groovy meta programming:

controller.metaClass.getParams { ->
 [firstname: 'Joe', lastName: 'blog']
}

Or use the putAll on the params:

Map myParams = [firstname: 'joe', lastname: 'blog']
controller.params.putAll(myParams)

Integration Testing Mail function with Greenmail and Spock in Grails

2010-11-11T15:51:00.005Z

Just managed to do spock integration test on my mail function running on grails.

I am using grails: 1.3.5, mail: 0.9, spock: 0.4-groovy-1.7, greenmail: 1.2.1

RegistrationService will save the person's registration record to the database and then send a confirmation email to the person.

class RegistrationService {
def registrate (def person) {
person.save(faileOnError: true)
// when using mail plugin, mailService is automatically injected so we don't have to declare it.
// also valid: mailService.sendMail
sendMail {
multipart true
subject "Hello World"
to person.emailAddress
from "sender@test.com"
body (view: '/email/confirm', model: [person: person])
}
return person
}

To make greenmail integration work, make sure the following settings in the Config.groovy test environment. Please make sure there is no real mail server setting there, and also no real mail server settings in the conf/spring/resources.xml, otherwise a real email will be sent. Bear in mind, by using greenmail plugin for integration test, there is no real mail sent.

Previously I was doing refactoring on someone else's code and got stuck on receiving real email and fail the integration test. Thanks to Mike Hugo on nabble to pinpoint this. Here comes the settings in Config.groovy test environment:

test {
  grails.mail.port = com.icegreen.greenmail.util.ServerSetupTest.SMTP.port
  grails.mail.host = "localhost"
}

The spock integration test is as below:

import grails.plugin.spock.*;
import com.icegreen.greenmail.util.*

class RegistrationServiceIntegrationSpec extends IntegrationSpec{
def greenMail

def "create registration and send email"() {
given:
def service = new RegistrationService()

when: "a user makes a valid registration" 
def person = new Person(title: 'Mr', lastName: 'joe',
firstName: 'blog', 'dateOfBirth': new Date(),
emailAddress: 'receipt@test.com'
)
assert person.validate(), true
person == service.registrate(person)

then: "the registration should be successful and the confirmation email should be sent successfully"
assert 1 == greenMail.getReceivedMessages().length

def message = greenMail.getReceivedMessages()[0]
assert "sender@test.com" == GreenMailUtil.getAddressList(message.from)
assert "Hello World" == message.subject
}
}

When Run (Ctrl+F11) gets stuck in Eclipse.

2010-10-28T16:14:00.003+01:00

In Eclipse (or its derivative Spring STS 2.5.0) generically, Ctrl+F11 is Run and it is context aware. As if the cursor is in a Java class with a main method, it will run the run class; if the cursor is in a test class, it will run the test class; if the cursor is at the method line in a test class, it will run the test for this single method.

However, when a new Grails plugin is installed, or if you run "grails test-app -coverage" you will noticed from the console that: $app/web-app/WEB-INF/classes directory is deleted. And when you Ctrl+F11 to run again, it will have the following exceptions:

Class not found uk.ac.lse.LockerRegisterServiceUnitTests
java.lang.ClassNotFoundException: uk.ac.lse.LockerRegisterServiceUnitTests
at java.net.URLClassLoader$1.run(URLClassLoader.java:200)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:188)
at java.lang.ClassLoader.loadClass(ClassLoader.java:307)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)
at java.lang.ClassLoader.loadClass(ClassLoader.java:252)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.loadClass(RemoteTestRunner.java:693)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.loadClasses(RemoteTestRunner.java:429)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:452)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)

Because the Default output folder is $app/web-app/WEB-INF/classes, that's why the test or run(main method for java) can't be run.

To get your favourite Ctrl+F11 come back work for you, do the following:

1. Delete the project without deleting the content from Eclipse.

2. Import your project into Eclipse.

/***** The following approach DOES NOT work ********/

Or better (29/10/2010)

1. Right click your project.
2. Select Grails Tools -> Refresh Dependencies

Then you will find the classes are compiled in to $app/target/classes which is the place your test or main java classes will run from.

Lockers App is Launched.

2010-10-25T11:25:00.003+01:00

Very excited, my Online Locker Booking System will be launched today. It was built using Grails in 3 months.

550+ lockers will be booked within 1 hour, then the waiting list is built up until it reaches its max limit.

Grails Exception Handling with HTTP Status Code, URLMapping, and Email

2010-08-02T10:36:00.102+01:00

The post describes how to:

1. Configure the UrlMapping.groovy to allow custom action on the specific http status code.
2. Display a customised "https status code handling page" to the user.
3. Send customised "https status code handling page" as an email to the admin staff if the admin email is configured in the Config.groovy file.

1. Configure the UrlMapping.groovy

class UrlMappings {
  static mappings {
    "403" (controller: "error", action: "forbidden")
    "404" (controller: "error", action: "notFound")
    "500" (controller: "error", action: "internalError")
  }
}

So any page status with 500 will be handled by the internalError action in the error controller.

Individual exceptions can be also configured in the response code to give more fine grained level control

"500" (controller: "error", action: "nullPointer", exception: NullPointerException)
  "500" (controller: "error", action: "illegalArgument", exception: IllegalArgumentException)

This allows any NullPointerException with 500 http status code to be handled by nullPointer action of error controller.

2. Display a customised "https status code handling page" to the user.

There are two properties available to the exception handling page. These properties are: exception and request. So you can copy the default error.gsp in the grails-app/view folder to a new file which is specified in the UrlMapping.groovy (i.e. error/internalError.gsp) and modified it to your needs.

...
Error ${request.'javax.servlet.error.status_code'}: ${request.'javax.servlet.error.message'.encodeAsHTML()}

Servlet: ${request.'javax.servlet.error.servlet_name'}

URI: ${request.'javax.servlet.error.request_uri'}

...

  
Stack Trace
${it.encodeAsHTML()}
...

The error page is as below:

3. Send customised "https status code handling page" as an email to the admin staff

The grails mail plugin is required to fulfil this requirement. Please refer to the Grail Mail plugin documentation

The following sending email code needs to be placed in the relevant action specified in the UrlMapping.groovy file.

import org.codehaus.groovy.grails.commons.ConfigurationHolder

class ErrorController {

  def mailService // mailService is provided by the grails mail plugin
 
  def index = { }
    
  def internalError = {
    // admin email is specified in the Config.groovy file
    // An email will be sent to the admin person whenever an internalError occurred. 
    def adminEmail = ConfigurationHolder.config.admin.email 
    try {
      mailService.sendMail {
 multipart true
 to adminEmail
 subject "500 Error"
 body (view: "/email/error")
      }
    }
    catch (Exception e) {
      log.info e
    }
  }
    
  def notFound = {}
}

The exception and request properties in the exception handling page are also available in the email template page. Thus the default error.gsp can be also copied to email template page (i.e. grails-app/email/error.gsp) and modified to your needs.

The error email is as below:

mockLogging in Grails Test

2010-06-29T11:09:00.001+01:00

"By calling mockLogging(Class) in your unit test, any subsequently create instance of the given class will magically gain a working log property that echoes all log messages to the console. By default, debug and trace messages aren't included, to avoid excess output, but you can enable the debug messages by passing true as an optional second argument to mockLogging()." -- (Grails in Action)

class JetService {
  def doSomthing() {
   def a = "hello world"
   log.debug a
  }
}

class JetServiceUnitTests extends grails.test.GrailsUnitTestCase {
  void testDoSomething() {
   mockLogging(JetService, true) // the second parameter "true" will output debug messages in the service method
   ...
  }
}

When running the unit test:

grails test-app unit:unit JetServiceUnit

In the report, you can see the debug message is shown in the System.output

shouldFail in Groovy Testing

2010-06-23T11:20:00.001+01:00

If the program hasn't got code to catch the runtime unchecked exceptions, then shouldFail can be used during groovy testing. http://groovy.codehaus.org/Unit+Testing

shouldFail() allows you to check that a particular lock of code throws an exception.

shouldFail (NullPointerException) {
testService.methodA('xxx')
}

However runtime unchecked exceptions can sometimes be considered as bugs in the programme and should be dealt with.

Grails Controller Unit Test

2010-06-07T17:25:00.001+01:00

import grails.converters.JSON

class PersonController {
   def personService

   def jsonPeople = {
   def people = personService.getPerson('usrname', 'passwd')
   render people as JSON
   }
}

class PersonService {

   static transactional = true

   def getPerson(String usrname, String password) {
   // some business logic
   return [firstname: 'joe', lastname: 'blog']
   }
}

import grails.test.*
import grails.converters.JSON

class PersonControllerTests extends ControllerUnitTestCase {
protected void setUp() {
super.setUp()
}

protected void tearDown() {
super.tearDown()
}

void testJsonResponse() {
controller.params.username= 'usrname'
controller.params.password = 'passwd'

   // mock the colloaborator
def personControl = mockFor(PersonService)
personControl.demand.getPerson(1..1) { String x, String y ->
   // the number of parameters and return type have to match the method
return [firstname: 'joe', lastname: 'blog']
}
controller.personService = personControl.createMock()
controller.jsonPeople()

//parse the JSON
def controllerResponse = controller.response.contentAsString
def jsonResult = JSON.parse(controllerResponse)

//navigate the JSON as an object
assertEquals 'joe', jsonResult.username
assertEquals 'blog', jsonResult.password

}
}

JMeter HTTP Proxy Server Settings

2010-05-21T10:37:00.003+01:00

The procedures below shows how to set up a HTTP proxy server using JMeter together with Firefox.

At WorkBench, add a HTTP Proxy Server.

In the newly added HTTP Proxy Server control panel.

Add "text/html" in the Content-type filter include field, so that all the html format page request will be filtered in.
In the URL Patterns to Exclude, add .*\.jpg .*\.js .*\.png .*\.gif .*\.css

The url request containing these extension will not shown on the JMeter left panel, as we are not interested in requesting these files for our testing purpose.

Change "port" to 8090, if your application is running under 8080
Click Start to start the proxy server.

Launch Firefox, in the Tools -> Options -> Network -> Settings, set the Manual proxy configuration to:
HTTP Proxy: localhost
Port: 8090 (this should be the same as the setting in the JMeter HTTP Proxy Server setting)

Now type any web address in Firefox, you will see only those url (e.g. /myApp/myController/index) request interested to us will come through in the left panel of the JMeter.

If there are other url request which are not interested to us, then simply add their url patterns to the URL Patterns to Exclude section in the HTTP Proxy Server settings in the JMeter.

p.s. remember to put port 80 in the port field in HttpRequest Client

There are video resources which give introductions on JMeter:

http://vimeo.com/10164982
http://vimeo.com/3453772

Convert GroovyRowResult into Domain Class

2010-04-29T15:17:00.001+01:00

There are chances that you might want to convert a GroovyRowResult into a domain class. For example, in the clustered environment, certain class needs to "implments Serializable" but if there is GroovyRowResult is in the class, then it will throw java.io.NotSerializableException as GroovyRowResult can not be serialized.

The workaround is simply create a dummy domain class with properties match the result set fields. It is case sensitive.

If it is oracle database, then it is case sensitive.

GroovyRowResult row = connection.firstRow("select user.firstname as \"firstname\"......")
def person = new Peson (row)

Number format

2010-04-19T10:51:00.000+01:00

When comes to custom number formatting, you might have a user case like room number 001, 075. How to format this:

NumberFormat formatter = new DecimalFormat("000")
def s
s = formatter.format(1) // the result will be 001
s = formatter.format(75) // the result will be 075

current is a reserved word for Grails

2010-03-15T10:26:00.002Z

Groovy/Grails Exchange London 2009

2009-12-10T22:32:00.003Z

Just attended the Groovy/Grails Exchange London 2009 conference. Podcast and slides can be found there as well.

SkillsMatter uploaded more photos. I am in the picture (sitting very front) ;)

It is a festival for those enthusiastic groovy/grails lovers to learn new things and exchange knowledge and practice.

Got quite quite a few point to take away into practice.

Guillaume LaForge introduced new features of Groovy 1.7. Try it out.

iWebKit, the mobile plugin for grails, is a must playing one when off work.

Burt Beckwith, the Spring Security (aka acegi) plugin developer, took the grails application into an enterprise level - Clustering a Grails Application for Scalability and Availability and t

Venkat Subramaniam is the live coding ninja. His presentation and demo style is just fantastic. The pace of his talk is like prison break season 1 -- I want to know what is coming next. Following his way, you increase your job security.

Christian Dupuis from SpringSource demonstrated the Groovy/Grails plugin for Eclipse. I can see lots of improvement which had been made, but there are still lots of features lacking. I am a Eclipse lover. Come one, Let's wave the Eclipse flag.

Graeme Rocher talked about cloud, plugin systems and Grails 1.2 new features. Just try it.

Tomas Lin demonstrated how to use flex as a front end to talk to grails. Brilliant.

Well, so many things to take on to digest. Looking forward to the QCon London 2010.

Groovy/Grails have a bright future for Java developers.

Java Regular Expression Experience.

2009-09-16T10:51:00.006+01:00

If the input only allows the number format like the following: 1, 11, 1.1, 1.11, 11.1, 11.11.


class Test {
  java.math.BigDecimal price

  static constraints = {
    price(blank: false, validator: {val, obj ->
      // this will only allow those 33.33 format
      if (!Pattern.matches("\\d{0,2}\\.\\d{0,2}", val.toString())
        && !Pattern.matches("\\d{0,2}", val.toString())) {
        return ['digital']
        }
      }
    )
}

Please refer to Java Regular Expression docs for more info.

In addition, make sure the mysql table column price with the right (enough) type: decimal (10, 2).

Calendar datepicker Plugin in Grails

2009-09-15T12:47:00.005+01:00

Refer to Grails Calendar Plugin site for how to install and use the plugin.


<g:form>
<calendar:datePicker name="myDate" defaultValue="${new Date()}" dateFormat="%d/%m/%Y"/>
<g:actionSubmit name="myAction" value=Submit"/>

There will be some html and javascript code generated by the plugin when viewing page source. The code we care is:


...
<input type="text" id="myDate_value" name="myDate_value" readonly="true"/>
...

The submitted myDate will be in String format dd/mm/YYYY, and we will use myDate_value in our controller to retrieve value.


class MyController {
    def myAction = {
        if (params['myDate_value'] != null) {
            def f = new SimpleDateFormat("dd/MM/yyyy")
            def myDate = f.parse(params['myDate_value'])

            // Testing
            println myDate.class // it is java.util.Date
            println myDate // Tue Sep 15 00:00:00 BST 2009

            def test = Test.get(1)
            println test.dateCreated.class //java.sql.Timestamp
            println test.dateCreated  // 2009-09-14 10:34:10.0

            // Time comparison
            println myDate > test.dateCreated   // true
            println myDate == test.dateCreated    // false
            println myDate < test.dateCreated    // false 
            ....
        }
    }
}

2009-09-15T12:23:00.005+01:00

The unique constraint in Grails works fine out of the box when the field is not a primary key. But it cause exceptions if the field is a manually assigned primary key.
Also refer to Grails doc for unique constraint.


class Test
  String id

  static mapping = {
    table 'test'
    id generator:'assigned', column:'id'  
  }
static constraints = {
  id(blank: false, unique: true)
}

Exception will be thrown when saving it with a duplicate id.

The solution is as below:


class TestController {
  def save = {
    def testInstance = new Test(params)
       try {
        if(!testInstance.hasErrors() && testInstance.save()) {
            flash.message = "Test ${testInstance.id} created"
            redirect(action:show,id:courseInstance.id)
        }
        else {
            render(view:'create',model:[testInstance:testInstance])
        }
      }
       catch (org.springframework.orm.hibernate3.HibernateSystemException e){
           // Field in view to highlight using  tag
           testInstance.errors.rejectValue('id', 'test.id.notUnique')                                                 
           render(view:'create',model:[testInstance:testInstance])
       }
  }
}

In the message.properties file, add one entry:


test.id.notUnique=The system has already had a id as you entered. Please provide a unique id.

Remove Cookie in Servlet

2009-09-15T11:44:00.004+01:00

In Firefox, view the cookie info via Web Developer plugin. Make sure the path is correct, that is where the cookie located.

In Servlet, to remove a named cookie do:


Cookie myCookie = new Cookie("JSESSIONID", "");
myCookie.setMaxAge(0);
myCookie.setPath("/");
//myCookie.setPath("/" + grailsApplication.metadata['app.name']);
response.addCookie(myCookie);

Refer to the Java Servlet Cookie doc, set the MaxAge to 0 will delete the cookie.

Database Result to Groovy List, Map

2009-08-14T16:25:00.003+01:00

Person --* Order --* LineItem *-- Product


def lineItemList = LineItem.findAll()
def t = []
def q = []
def lineItemMap = []
def orderMap = []
def packs
lineItemList.order.person.unique().each { person ->
    def p = []
    orders = lineItemList.findAll{it.order.person == person}.order
    orders.unique().each { order ->
           lineItemMap = lineItemList.findAll{it.order == order}
           orderMap = [orderId: order.id, lineItemId: lineItemMap.id]
           p.add(orderMap)
           // Use the statement below to get all the products
           //products = LineItem.getAll(lineItemMap.id).product
    }
    q = [personId: person.id, order: p]
    t.add(q)
}

[[personId:1, order:[[orderId:1, lineItemId:[1, 2]], [orderId:2, lineItemId:[3, 4]]]]]

[[personId:1, order:[[orderId:1, lineItemId:[1, 2]]]], [personId:2, order:[[orderId:2, lineItemId:[3, 4]]]]]

Domain Class (Primary Key) Update and Table Generation

2009-08-06T17:21:00.003+01:00

If you set dbCreate = "update" in the DataSource.groovy, then every time you change the domain class, the grails will update the table for you. Sometimes if it doesn't (the primary key (strategy) is changed), then drop the table, and restart the grails application. And it will reflect the changes in the domain class.

To use a manually assigned value as a primary key rather than the default auto_increment one, do:


class Person {
  String id
  
  static mapping = {
    id generator: 'assigned', column: 'id'
  }
}

List (array) of parameter values

2009-08-03T10:49:00.007+01:00

Sometimes in a web form, it is useful to allow inputting multiple values to be associated with one

In some scenarios, a web form can allow inputting multiple values to be associated with the same named field:


<form>
<input name="key" type="text">
<input name="key" type="text">
</form>

The posted url is like: ?key=value1&key=value2

In Grails, params['key'] is always used to get parameter value. The default behaviour will return:

a string if the key only has one value (i.e. ?key=value)
a List if the key has many values (i.e. ?key=value1&key=value2)

It causes problems when you are not sure how many values the key is associated with.

Solutions:

In Java Servlet API, there is a method for Interface ServletRequest

java.lang.String[] request getParameterValues(java.lang.String name)

Returns an array of String objects containing all of the values the given request parameter has, or null if the parameter does not exist.

request.getParameterValues('key')
class [Ljava.lang.String;

According to http://groovy.codehaus.org/JN1025-Arrays, we can use the following code to reconstruct the query string:


def queryArray = request.getParameterValues('key')
def queryString = ""
queryArray.each {
queryString += "&key=$it"
}

For the query string like: http://blabla.com/list?personId=1&personId=2

To accommodate this, in Grails scaffolded list closure:


def list = {
  def personList
  if (params['personId'] != null) {
     personList = Person.getAll(Arrays.asList(request.getParameterValues('personId')))
  }
  else {
     personList = Person.list()
  }
}

To cast an array into a list, using:

Arrays.asList(array[])

Also refer to http://prideafrica.blogspot.com/2007/01/javalangclasscastexception.html for some useful info regarding [Ljava.lang.String.

GORM Lazy

2009-07-29T10:50:00.003+01:00

If we have the domain relations (one Order has many Items, and one Item can appear in many Orders) modelled below:

Order --* LineItem *-- Item

If we want the toString() method of the LineItem class to return its relation classes attributes, then that's where lazy strategy comes in handy.


class LineItem {

  // relation
  Order order
  Item item

  static mapping = {
    columns {
       order lazy: false
       item lazy: false
    }
  }
  
  String toString() {
    return "Order no: $this.order.id, Item: $this.item.name"
  }
}

Get Session in Grails Service

2009-07-21T10:46:00.004+01:00

In Grails, session variable is not available in service. But


import org.springframework.web.context.request.RequestContextHolder

def user = RequestContextHolder.currentRequestAttributes().getSession()?.user

Note: the RequestContextHolder is genuinely a normal web request. If the request is a scheduled job (using Quartz plutin), not a web request, then there will be exceptions like below:


=============================
2009-07-21 00:00:00,269 INFO  [core.JobRunShell] Job GRAILS_JOBS.ExpireJob threw a JobExecutionException:
org.quartz.JobExecutionException: No thread-bound request found: Are you referring to request attributes outside of an actual
 web request, or processing a request outside of the originally receiving thread? If you are actually operating within a web
request and still receive this message, your code is probably running outside of DispatcherServlet/DispatcherPortlet: In this
 case, use RequestContextListener or RequestContextFilter to expose the current request. [See nested exception: java.lang.Ill
egalStateException: No thread-bound request found: Are you referring to request attributes outside of an actual web request,
or processing a request outside of the originally receiving thread? If you are actually operating within a web request and st
ill receive this message, your code is probably running outside of DispatcherServlet/DispatcherPortlet: In this case, use Req
uestContextListener or RequestContextFilter to expose the current request.]
        at org.codehaus.groovy.grails.plugins.quartz.GrailsJobFactory$GrailsTaskClassJob.execute(GrailsJobFactory.java:81)
        at org.quartz.core.JobRunShell.run(JobRunShell.java:202)
        at org.quartz.simpl.SimpleThreadPool$WorkerThread.run(SimpleThreadPool.java:525)
Caused by: java.lang.IllegalStateException: No thread-bound request found: Are you referring to request attributes outside of
 an actual web request, or processing a request outside of the originally receiving thread? If you are actually operating wit
hin a web request and still receive this message, your code is probably running outside of DispatcherServlet/DispatcherPortle
t: In this case, use RequestContextListener or RequestContextFilter to expose the current request.
        at org.springframework.web.context.request.RequestContextHolder.currentRequestAttributes(RequestContextHolder.java:12
2)
        at org.springframework.web.context.request.RequestContextHolder$currentRequestAttributes.call(Unknown Source)
        at org.codehaus.groovy.runtime.callsite.CallSiteArray.defaultCall(CallSiteArray.java:43)
        at org.codehaus.groovy.runtime.callsite.AbstractCallSite.call(AbstractCallSite.java:116)
        at org.codehaus.groovy.runtime.callsite.AbstractCallSite.call(AbstractCallSite.java:120)
        at EmailerService.sendEmails(EmailerService.groovy:64)
        at EmailerService$sendEmails$0.call(Unknown Source)
        at org.codehaus.groovy.runtime.callsite.CallSiteArray.defaultCall(CallSiteArray.java:43)
        at org.codehaus.groovy.runtime.callsite.AbstractCallSite.call(AbstractCallSite.java:116)
        at org.codehaus.groovy.runtime.callsite.AbstractCallSite.call(AbstractCallSite.java:124)
        at ExpireJob$_execute_closure1.doCall(ExpireJob.groovy:38)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
        at java.lang.reflect.Method.invoke(Method.java:597)
        at org.codehaus.groovy.reflection.CachedMethod.invoke(CachedMethod.java:86)
        at groovy.lang.MetaMethod.doMethodInvoke(MetaMethod.java:234)
        at groovy.lang.MetaClassImpl.invokeMethod(MetaClassImpl.java:1061)
        at groovy.lang.ExpandoMetaClass.invokeMethod(ExpandoMetaClass.java:910)
        at groovy.lang.MetaClassImpl.invokeMethod(MetaClassImpl.java:892)
        at groovy.lang.Closure.call(Closure.java:279)
        at groovy.lang.Closure.call(Closure.java:292)
        at org.codehaus.groovy.runtime.DefaultGroovyMethods.each(DefaultGroovyMethods.java:1165)
        at org.codehaus.groovy.runtime.DefaultGroovyMethods.each(DefaultGroovyMethods.java:1141)
        at org.codehaus.groovy.runtime.dgm$87.invoke(Unknown Source)
        at org.codehaus.groovy.runtime.callsite.PojoMetaMethodSite$PojoMetaMethodSiteNoUnwrapNoCoerce.invoke(PojoMetaMethodSi
te.java:270)
        at org.codehaus.groovy.runtime.callsite.PojoMetaMethodSite.call(PojoMetaMethodSite.java:52)
============================

If you are logging this scheduled job, then do:


    try {
      def user = RequestContextHolder.currentRequestAttributes().getSession()?.user
      if (user != null) {
        log.info("Email: ${mail.dump()}, action: sendEmails by ${user} on ${new Date()}")
      }
      else {
        log.info("Email: ${mail.dump()}, action: sendEmails by system on ${new Date()}")
      }
    }
    catch (java.lang.IllegalStateException e) {
      log.info("Email: ${mail.dump()}, action: sendEmails by system on ${new Date()}")
    }

Select Column Name with Space

2009-07-03T15:07:00.001+01:00

If the column name has space in it, then use backtick operator like this `column name`

Migrate Access to MySQL to Fit in Grails

2009-07-03T12:25:00.023+01:00

1. Access Tables Preparation

Open the Access database and modify the table names and column names with the following convention:

Modify the table names to table_name (e.g. account_manager) format if necessary. GRAG will generate a domain class named: TableName.
Modify column names to column_name (e.g. contact_address) format if necessary. GRAG will generate a field named: columnName.
Create an autoNumber id as the primary key if the table doesn't have one
If the table's primary key is not named id, then change it to id. GRAG will generate an id field with the mapping like: id generator:'identity', column:'id'
Modify foreign keys in other tables as table_name_id. GRAG will create a relation for this.

2. Migrate Access to MySQL

MySQL Migration Toolkit to migrate MS Access to MySQL (http://dev.mysql.com/downloads/gui-tools/5.0.html). It is an automatic process with step by step instructions. The tool will generate dbCreate.sql and dbInserts.sql, remember to save them. Then:

Modify the dbCreate.sql to add foreign keys which GRAG will create relations for the generated domain class, and add version int(10) field, otherwise a 'version false' statement will be generated in the mapping, because this isn't available by default for legacy databases
Re run the dbCreate.sql script to re-generate the tables.
Re run the dbInserts.sql script to populate the data.

3. Generate the Domain Classes

Then you can start using Grails Application Generator (GRAG) (http://grag.sourceforge.net/) to generate the domain models. It is not perfect, but at least it saves some manul typings.

Open the generated domain classes to:

check the generated field to see wheter it comforms to the lowerCaseCapital format (e.g. contactAddress)
If the id is an auto_increment field, then comment out the id field, and comment out id generator:'identity', column:'id' statement.
If the id is a user assigned value field (e.g. characters), then don't comment out the id field. Also, change the id generator in the mapping to: id generator:'assigned', column:'id'
modify relations if necessary (i.e. hasMany, belongsTo, or association like: OtherDomain otherDomain)
comment out constraint for a start
modify the toString method to return some meaningful value.

4. Configuration

Change dbCreate to 'update' in the DataSource.groovy so that the data

5. Testing

runt he "grails console", then for each domain class, test it with the following script:

def a = DomainClass.get('KK')

a.dump()

6. Generate Skeletons Code

grails generate-all *

This will generate the controllers and gsp view pages for all the domain classes.

7. Modify assigned id field for controller and gsp

If the id is a user assigned id rather than an auto incremented id, then for the controller, explicitly assign the id:


def save = {
    def nameInstance = new Name(params)
    nameInstance.id = params.id
    if(! nameInstance.hasErrors() && nameInstance.save()) {
       ...
    }
}

For the create.gsp page, add the id input field:

            
<tr class='prop'>
 <td valign='top' style='text-align:left;' width='20%'>
      <label for='id'>ID:</label>
 </td>
 <td valign='top' style='text-align:left;' width='80%'
class='${hasErrors(bean:nameInstance,field:'id','errors')}'>
 <input type='text' name='id' value='${nameInstance?.id}' />
 </td>
</tr>

There is also a very good post regarding Hosting Grails to your Legacy Database

Digesting belongsTo

2009-06-30T16:08:00.012+01:00


class Face {
String name
Nose nose
static constraints = {
nose (nullable: true)
}

String toString() {
return name 
}
}

class Nose {
String name
static belongsTo = [face: Face]
String toString() {
return name 
}
}

def a = new Face(name: 'joe')
def b = new Nose(name: 'blog')
a.b = b
a.save(flush: true)
b.save(flush: true)


// test
def face = Face.findWhere (name: 'joe')
println face.nose

def nose = Nose.findWhere(name: 'blog')
println nose.face

// You must set nullable: true for nose in the constraint, otherwise the save won't work and it doesn't throws any exception
face.nose = null 
face.save()
println face

In the above relationship, the foreign key (i.e. nose_id) will added in the Face side. But you can still get hold of face from the nose, because nose belongsTo face.

No row with the given identifier exists

2009-06-26T12:39:00.005+01:00

No row with the given identifier exists

class A {

B b

}

class B {

String name

}

If you have an A has B relationship. If from the database end, A says has B and with B's id, but actually that B's id doesn't exist in B's table. Then it will complains: No row with the given identifier exists

A workaround of this is to use ignoreNoFound like below

class A {

B b

static mapping = {

b ignoreNotfound : true

}

Submit an array as a parameter

2009-03-20T11:06:00.004Z

When you have an array of values to submit like the code below:

<g:each in="${people}" var="person">

<tr><td>
<input type="checkbox" name="emails[]" value="${person.email}" />
<td></tr>
</g:each>

When submiting this form, the emails[] will be submitted as an array/list object like [Ljava.lang.String;@151313a. To get the value out of the object, do:

params['emails[]'].toString()

That will get the value like: [joe@foo.com, blog@foo.com]

Remote Deploy Grails Application

2009-01-20T17:20:00.005Z

Ant 1.6 or later support scp, ssh tasks.

Download the lastest ant.

Set ANT_HOME variable.

Add %ANT_HOME%\bin in the PATH variable (in Windows environment).

Download the JSch jar to the %ANT_HOME%\lib

Add the remote task in the build.xml in the Grails project:

<target name="remoteDeploy" depends="war" description="-->Deploy the war to the remote server">

</target>

Note: set trust="yes", otherwise it will thrown "reject HostKey" or "java.net.UnknownHostException"

Run the task by:

ant remoteDeploy

===============

There is another Grails remote deploy using GANT post for reference.

Clear Flash Message in Grails

2009-01-16T11:01:00.002Z

According to the Grails documentation:

"Flash is a temporary storage map that stores objects within the session for the next request and the next request only, automatically clearing our the objects held there after the next request completes.

The flash object is essentially a map (a hash) which you can use to store key value pairs. These values are transparently stored inside the session and then cleared at the end of the next request.

This pattern allows you to use HTTP redirects (which is useful for redirect after post and retain values that can retrieved from the flash object."

But just in case the flash message isn't cleared for some unknow reason, there is the code to rescue in your controller:

flash.clear()

Command Object and Error Messages

2009-01-15T16:42:00.007Z

"Grails command Objects provide a simple mechanism to validate from fields that do not map directly to domain objects. "

Command Object

class JetCommand {
  String number
  String name
 
  static constraints = {
    number(blank: false, nullable: false, matches: "\\d+")
    name(nullable: false)
  }
}

The command object class may be defined under src/groovy/ or under grails-app/controllers/. The command object class may also be defined in the same source file as the controller that uses it.

If a custom error message is preferred, then look at the corresponding error code for the above constraints. Add custom error messages in the grails-app/i18n/messages.properties file:

jetCommand.number.blank=The number can't be blank
jetCommand.number.matches.invalid=The number can only be digital numbers
jetCommand.name.nullable=The name can't be null

Controller:

class JetController {
  def jet = { JetCommand cmd ->
  if (cmd.hasErrors()) {
    cmd.errors.allErrors.each {
    println it
  }
}

// You don't have to do the following code, because the Grails will handle it for you.

// If you do the following code, there will be duplicate error messages

/**

if (cmd.errors.hasFieldErrors("name")) {

cmd.errors.rejectValue('choice', 'searchCommand.name.nullable')

}

if (cmd.errors.hasFieldErrors("number")) {

if (cmd.errors.getFieldValue("number").isEmpty()) {

cmd.errors.rejectValue('number', 'searchCommand.number.blank')

}

else {

cmd.errors.rejectValue('number', 'searchCommand.number.matches.invalid')

}

**/

render (view: 'admin', model:[jetCommand: cmd, key1: object1, key2: object2])

}

GSP page

You can display the error messages in the GSP page:

Customised Validator:

You can also add a customised validator:

static constraints = {
  number(validator: {
    if (it.isEmpty() || it == null || !(it ==~ /\d+/)) {
      return ['numberJet']  // numberJet is the error code
    }
  })
}

In this case, in the messages.properties, you should add a error message with the error code:

jetCommand.number.numberJet=Number field is not valid

Redirect Params in Grails

2009-01-14T16:22:00.003Z

Grails params contain controller, action, and other parameters like below:

["_action_search":"Search", "choice":"Locker Register", "action":"search", "numb

er":"1", "controller":"lockerRegister"]

So when doing redirect with all the params like below:

class JetController {

def search = {

redirect (action: "jetAction", params: params)

}

def jetAction {

// some code here

}

It might be in a endless redirect loop. A workaround is to manually specify the parameters your want to redirect. For example:

redirect (action: "testAction", controller: "testController", params:[p1: 'value1', p2: 'value2'])

Put Multiple Objects in the Returning Model in The Controller

2009-01-14T10:22:00.005Z

In controller, you can put multiple objects in a model and return it. You can also pass on the parameters from the request to the model on returning it. For example:

class JetController {

def test = {

return ['key1': object1, 'key2': object2, 'key3': params.person.id]

}

Restart the Application After Changing the Dynamic Finders in Grails

2009-01-14T10:13:00.005Z

When changing the dynamic finders (i.e. find, findAll, findBy) while the grails application is running, you need to restart the application to reflect the changes for the queries.

If you set "logSql=true" in your conf/DataSource.groovy, then you can monitor whether sql queries reflect your changes.

Grails generate-views with all the fields

2008-12-10T14:43:00.005Z

grails generate-views domainClass

By default, it will generate the list view with the first 6 fields including the primary key (i.e. id).

To tell the grails to generate the list view with all the fields, you can modify the file:

$GRAILS_HOME\src\grails\templates\scaffolding\lis.gsp

Then change the 6 in the "if (i < 6)" to a big number. There are two places to change, one is for the table column headers, the other is the row data.

Debugging GSP

2008-08-18T23:47:00.001+01:00

When debugging GSP, you can use ?showSource at the end of the request url to show the comiled Java code to spot on the lines with erros.

Remote Debug Application on Tomcat

2008-08-18T16:23:00.001+01:00

REST with Grails

2008-08-04T16:53:00.003+01:00

Please refer to Grails Documentations for more info on REST with Grails.

1. Create a grails project grails create-app rest

2. Create a domain class with name Book

create domain-class Book

class Book {

String title

String publisher

}

3. Use generate-all to generate views and controller

grails generate-all Book

4. Modify Bootstrap.groovy to add sample data.

class BootStrap {

 def init = { servletContext ->

 new Book(title:"game1",publisher:"pub1").save()

 new Book(title:"game2",publisher:"pub1").save()

 new Book(title:"game3",publisher:"pub2").save()

 new Book(title:"game4",publisher:"pub2").save()

def destroy = {      } }

5. Modify UrlMappings.groovy

 static mappings = {

  "/book/$id?"(controller:"book"){

   action = [GET:"show", PUT:"update", DELETE:"delete", POST:"save"]

6. Modify BookController.groovy show method

import grails.converters.* class BookController {

 def show = {

  if(params.id && Book.exists(params.id)) {

   def b = Book.get(params.id)

   render b as XML

  else {

   def all = Product.list()

   render all as XML

..

The method can be tested with this showTest.groovy client

import org.apache.commons.httpclient.*;

import org.apache.commons.httpclient.methods.*;

def url = "http://localhost:8080/rest/book/${args[0]}"

def method = new GetMethod(url)

// Require HTTPClient library

def client = new HttpClient()

def statusCode = client.executeMethod(method)

println "STATUS CODE:$statusCode"

def stream = method.getResponseBodyAsStream()

println "--- START RESPONSE BODY --- "

System.out << stream println "n--- END RESPONSE BODY ---"

stream.close() method.releaseConnection()

Notes: You need to put Apache Commons Codec, and HTTPClient jars in the $GROOVY_HOMElib

7. Modify BookController.groovy save method

def save = {

 def book = new Book(params['book'])

 if(book.save())

  render book as XML

 else{

  def myerrors = game.errors.allErrors.collect {

   g.message(error:it)

  render(contentType:"text/xml") {

   errors {

    for(err in myerrors) {

     error(err)

You can test the method with the client saveTest.groovy below:

import org.apache.commons.httpclient.*;

import org.apache.commons.httpclient.methods.*;

def url = "http://localhost:8080/rest/game"

def method = new PostMethod(url)

def client = new HttpClient()

def payload = """ <book>

<title>newgame</title>

<publisher>

newpublisher</publisher>

</book>

""" method.addRequestHeader("Content-Type","text/xml") method.addRequestHeader("Accept","text/xml,application/xml;q=0.9") method.setRequestEntity(new StringRequestEntity(payload)) def statusCode = client.executeMethod(method) println "STATUS CODE:$statusCode" def stream = method.getResponseBodyAsStream() println "--- START RESPONSE BODY --- " System.out << stream println "n--- END RESPONSE BODY ---" stream.close() method.releaseConnection()

Groovlets

2008-07-29T16:57:00.001+01:00

For more details please refer to: Groovlets


1. Put the following lines into web.xml in WEB-INF foler

=====================================

<servlet>
<servlet-name>Groovy</servlet-name>
<servlet-class>groovy.servlet.GroovyServlet</servlet-class>
</servlet>

<servlet-mapping>
<servlet-name>Groovy</servlet-name>
<url-pattern>*.groovy</url-pattern>
</servlet-mapping>

=====================================


2. Write your Groovlets hello.groovy like below, and put it into the webapps folder

=====================================

import java.util.Date
import groovy.xml.MarkupBuilder

if (session == null) {
 session = request.getSession(true);
}

if (session.counter == null) {
     session.counter = 1
}

html.html {    // html is implicitly bound to new MarkupBuilder(out)
  head {
     title("Groovy Servlet")
 }
 body {
   p("Hello, ${request.remoteHost}: ${session.counter}! ${new Date()}")
 }
}

session.counter = session.counter + 1

====================================

3. Copy groovy-all-xyz.jar into WEB-INF/lib folder


Notes:

If your Groovlets is at somewhere else rather than $CATALINA_HOME/webapps, then you need to edit the server.xml in the $CATALINA_HOME/conf like below:

<Context path="/groovy" docBase="c:/groovy-servlet"/>

Set System Properties in Java

2008-07-28T11:27:00.002+01:00

You can set system properties by using -D in the java command line:
java -Dfile_properties=file.properties HelloWorld

==========================================

String file_properties = System.getProperty("file_properties");

// load file.properties file which sets the files and directories
Properties properties = new Properties();
try {
//properties.load(new FileInputStream("file.properties"));
properties.load(new FileInputStream(System.getProperty("file_properties")));
} catch (FileNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (IOException e1)
{
// TODO Auto-generated catch block e1.printStackTrace();
}

// get properties File inputDir = new File(properties.getProperty("inputDir"));

==========================================

In Eclipse, you can set system properties in:

1. Right click the java program, choose Run As --> Open Run Dialog
2. Select Arguments tab
3. In "VM argument", write your system properties settings. (i.e. -Dfile_properties=file.properties).

Dealing with namespace in XSLT

2008-07-17T15:45:00.002+01:00

For more general knowledge about namespace, please refer to XML Namespaces and How They Affect XPath and XSLT

If you have an vanilla xml file like below:

<people xmlns="http://xmlns.blabla.com/name" xmlns:abc="http://xmlns-abc.blabla.com/abc"
abc:firstname="jianfeng"
abc:lastname="tian" />

In your xslt, you have to define namespaces in your xsl:stylesheet declaration to make it working:

xmlns:jet="http://xmlns.blabla.com/name"
xmlns:abc="http://xmlns-abc.blabla.com/abc"

<xsl:stylesheet version="2.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:jet="http://xmlns.blabla.com/name"
xmlns:abc="http://xmlns-abc.blabla.com/abc"
exclude-result-prefixes="abc xs xsi xsl">

<xsl:output method="xml" encoding="UTF-8" indent="yes"/>

<xsl:template match="jet:people">
<person>

<xsl:attribute name="firstname">
<xsl:value-of select="@abc:firstname"/>
</xsl:attribute>

<xsl:attribute name="lastname">
<xsl:value-of select="@abc:lastname"/>
</xsl:attribute>

</person>

</xsl:template>
</xsl:stylesheet>

================================================================

If you have an xml file like below:

<people xmlns="http://www.somewhere.com/blabla" >
<person>
<address>
<postcode>110001</postcode>
</address>
<content group="firstname">John</person>
<content group="lastname">Smith</person>
</person>
</people>

In your xslt, you have to define namespaces in your xsl:stylesheet declaration to make it working:

xmlns:jet="http://www.somewhere.com/blabla"

<xsl:stylesheet version="2.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jet="http://www.somewhere.com/blabla"
exclude-result-prefixes="jet xsl xsi">
<xsl:output method="xml" indent="yes" omit-xml-declaration="no" encoding="ISO-8859-1"/>

<xsl:template match="jet:people">
<data>
<postcode>
<xsl:value-of select="jet:person/jet:address/jet:postcode">
</postcode>

<firstname><xsl:value-of select="jet:person/jet:content[@group='firstname']" /></login>
<lastname><xsl:value-of select="jet:person/jet:content[@group='lastname']" /></login>

</data>
</xsl:template>

</xsl:stylesheet>

Convert CSV to XML Using XSLT

2008-07-04T17:11:00.004+01:00

Refer to: http://blogs.msdn.com/kaevans/archive/2003/04/17/5780.aspx

In your CSV file,

1. Surround the whole data with tag.
2. Add tag to the first row which contains the heading titles
3. Add tag to contain the whole data.

<root>
<head>firstname, lastname</content>
<content>bla, bla
bla, bla</conent>
</root>

<xsl:stylesheet version ="2.0" xmlns:xsl ="http://www.w3.org/1999/XSL/Transform" > <xsl:output method ="xml"/>  <xsl:template match ="/" > <root> <xsl:call-template name ="texttorows" > <xsl:with-param name ="StringToTransform" select ="/root/content" /> <xsl:with-param name="heading" select="/root/heading" /> </xsl:call-template> </root> </xsl:template>  <xsl:template name ="texttorows" >  <xsl:param name ="StringToTransform" select ="''" /> <xsl:param name="heading" select="''" />  <xsl:variable name="CR" select="'
'"/> <xsl:choose>  <xsl:when test ="contains($StringToTransform,$CR)" >  <row> <xsl:call-template name ="csvtoxml" > <xsl:with-param name ="StringToTransform" select ="substring-before($StringToTransform,$CR)" /> <xsl:with-param name="heading" select="$heading" /> </xsl:call-template> </row>  <xsl:call-template name ="texttorows" > <xsl:with-param name ="StringToTransform" > <xsl:value-of select ="substring-after($StringToTransform,$CR)" /> </xsl:with-param> <xsl:with-param name="heading"> <xsl:value-of select="$heading" /> </xsl:with-param> </xsl:call-template> </xsl:when>  <xsl:otherwise> <row> <xsl:call-template name ="csvtoxml" > <xsl:with-param name ="StringToTransform" select ="$StringToTransform" /> <xsl:with-param name="heading" select="$heading" /> </xsl:call-template> </row> </xsl:otherwise> </xsl:choose> </xsl:template> <xsl:template name ="csvtoxml" >  <xsl:param name ="StringToTransform" select ="''" /> <xsl:param name ="heading" select ="''" /> <xsl:choose>  <xsl:when test ="contains($StringToTransform,',')" >  <elem> <xsl:value-of select ="substring-before($heading,',')" /><xsl:text> </xsl:text> <xsl:choose> <xsl:when test="starts-with($StringToTransform, '"')"> <xsl:value-of select ="substring-before($StringToTransform,'",')" /> </xsl:when> <xsl:otherwise> <xsl:value-of select ="substring-before($StringToTransform,',')" /> </xsl:otherwise> </xsl:choose> </elem>  <xsl:call-template name ="csvtoxml" > <xsl:with-param name ="heading" > <xsl:value-of select ="substring-after($heading,',')" /> </xsl:with-param> <xsl:with-param name ="StringToTransform" > <xsl:choose> <xsl:when test="starts-with($StringToTransform, '"')"> <xsl:value-of select ="substring-after($StringToTransform,'",')" /> </xsl:when> <xsl:otherwise> <xsl:value-of select ="substring-after($StringToTransform,',')" /> </xsl:otherwise> </xsl:choose> </xsl:with-param> </xsl:call-template> </xsl:when>  <xsl:otherwise> <elem> <xsl:value-of select ="$heading" /><xsl:text> </xsl:text> <xsl:value-of select ="$StringToTransform" /> </elem> </xsl:otherwise> </xsl:choose> </xsl:template> </xsl:stylesheet>

Convert CSV to XML in Excel

2008-07-04T17:00:00.007+01:00

Refer to: http://www.meadinkent.co.uk/xl_xml1.htm

The easiest way of converting the data in Excel to XML is to use some VB script

You can create an Excel Macro with the code below. Then in your excel workbook, run the macro.


Sub MakeXML()
' create an XML file from an Excel table
Dim MyRow As Integer, MyCol As Integer, Temp As String, YesNo As Variant, DefFolder As String
Dim XMLFileName As String, XMLRecSetName As String, MyLF As String, RTC1 As Integer
Dim RangeOne As String, RangeTwo As String, Tt As String, FldName(99) As String

MyLF = Chr(10) & Chr(13)    ' a line feed command
DefFolder = "C:\"   'change this to the location of saved XML files

YesNo = MsgBox("This procedure requires the following data:" & MyLF _
& "1 A filename for the XML file" & MyLF _
& "2 A groupname for an XML record" & MyLF _
& "3 A cellrange containing fieldnames (col titles)" & MyLF _
& "4 A cellrange containing the data table" & MyLF _
& "Are you ready to proceed?", vbQuestion + vbYesNo, "MakeXML CiM")

If YesNo = vbNo Then
Debug.Print "User aborted with 'No'"
Exit Sub
End If

XMLFileName = FillSpaces(InputBox("1. Enter the name of the XML file:", "MakeXML CiM", "xl_xml_data"))
If Right(XMLFileName, 4) <> ".xml" Then
XMLFileName = XMLFileName & ".xml"
End If

XMLRecSetName = FillSpaces(InputBox("2. Enter an identifying name of a record:", "MakeXML CiM", "record"))

RangeOne = InputBox("3. Enter the range of cells containing the field names (or column titles):", "MakeXML CiM", "A3:D3")
If MyRng(RangeOne, 1) <> MyRng(RangeOne, 2) Then
MsgBox "Error: names must be on a single row" & MyLF & "Procedure STOPPED", vbOKOnly + vbCritical, "MakeXML CiM"
Exit Sub
End If
MyRow = MyRng(RangeOne, 1)
For MyCol = MyRng(RangeOne, 3) To MyRng(RangeOne, 4)
If Len(Cells(MyRow, MyCol).Value) = 0 Then
MsgBox "Error: names range contains blank cell" & MyLF & "Procedure STOPPED", vbOKOnly + vbCritical, "MakeXML CiM"
Exit Sub
End If
FldName(MyCol - MyRng(RangeOne, 3)) = FillSpaces(Cells(MyRow, MyCol).Value)
Next MyCol

RangeTwo = InputBox("4. Enter the range of cells containing the data table:", "MakeXML CiM", "A4:D8")
If MyRng(RangeOne, 4) - MyRng(RangeOne, 3) <> MyRng(RangeTwo, 4) - MyRng(RangeTwo, 3) Then
MsgBox "Error: number of field names <> data columns" & MyLF & "Procedure STOPPED", vbOKOnly + vbCritical, "MakeXML CiM"
Exit Sub
End If
RTC1 = MyRng(RangeTwo, 3)

If InStr(1, XMLFileName, ":\") = 0 Then
XMLFileName = DefFolder & XMLFileName
End If

Open XMLFileName For Output As #1
Print #1, ""
Print #1, ""

For MyRow = MyRng(RangeTwo, 1) To MyRng(RangeTwo, 2)
Print #1, "<" & XMLRecSetName & ">"
For MyCol = RTC1 To MyRng(RangeTwo, 4)
' the next line uses the FormChk function to format dates and numbers
   Print #1, "<" & FldName(MyCol - RTC1) & ">" & RemoveAmpersands(FormChk(MyRow, MyCol)) & ""
' the next line does not apply any formatting
'  Print #1, "<" & FldName(MyCol - RTC1) & ">" & RemoveAmpersands(Cells(MyRow, MyCol).Value) & ""
  Next MyCol
Print #1, ""

Next MyRow
Print #1, ""
Close #1
MsgBox XMLFileName & " created." & MyLF & "Process finished", vbOKOnly + vbInformation, "MakeXML CiM"
Debug.Print XMLFileName & " saved"
End Sub
Function MyRng(MyRangeAsText As String, MyItem As Integer) As Integer
' analyse a range, where MyItem represents 1=TR, 2=BR, 3=LHC, 4=RHC

Dim UserRange As Range
Set UserRange = Range(MyRangeAsText)
Select Case MyItem
Case 1
MyRng = UserRange.Row
Case 2
MyRng = UserRange.Row + UserRange.Rows.Count - 1
Case 3
MyRng = UserRange.Column
Case 4
MyRng = UserRange.Columns(UserRange.Columns.Count).Column
End Select
Exit Function

End Function
Function FillSpaces(AnyStr As String) As String
' remove any spaces and replace with underscore character
Dim MyPos As Integer
MyPos = InStr(1, AnyStr, " ")
Do While MyPos > 0
Mid(AnyStr, MyPos, 1) = "_"
MyPos = InStr(1, AnyStr, " ")
Loop
FillSpaces = LCase(AnyStr)
End Function

Function FormChk(RowNum As Integer, ColNum As Integer) As String
' formats numeric and date cell values to comma 000's and DD MMM YY
FormChk = Cells(RowNum, ColNum).Value
If IsNumeric(Cells(RowNum, ColNum).Value) Then
FormChk = Format(Cells(RowNum, ColNum).Value, "#,##0 ;(#,##0)")
End If
If IsDate(Cells(RowNum, ColNum).Value) Then
FormChk = Format(Cells(RowNum, ColNum).Value, "dd mmm yy")
End If
End Function

Function RemoveAmpersands(AnyStr As String) As String
Dim MyPos As Integer
' replace Ampersands (&) with plus symbols (+)

MyPos = InStr(1, AnyStr, "&")
Do While MyPos > 0
Mid(AnyStr, MyPos, 1) = "+"
MyPos = InStr(1, AnyStr, "&")
Loop
RemoveAmpersands = AnyStr
End Function

Increase Java heap size

2008-07-03T15:12:00.003+01:00

Refer to: http://hausheer.osola.com/docs/5

"
If Java runs out of memory, the following error occurs:

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

This can have two reasons:

* Your Java application has a memory leak. There are tools like YourKit Java Profiler that help you to identify such leaks.
* Your Java application really needs a lot of memory (more than 128 MB by default!). In this case the Java heap size can be increased using the following runtime parameters:

java -Xms -Xmx

Defaults are:

java -Xms32m -Xmx128m

You can set this either in the Java Control Panel or on the command line, depending on the environment you run your application.

"

Write Logs to Different Files Using Log4J

2008-05-14T16:10:00.006+01:00

If you have one generic java program to transform xml files from different directory.

java -Dfile_properties=/path/to/file.properties -jar YourProgramm.jar

You can specify different file.properties input directory using the "-D" parameter in the command line.

In each file.properties file, you specify:

input_dir=/bla/bla
xslt_dir=/bla/bla
output_dir=/bla/bla
log4j_properties=/bla/bla

Because you might want different logs for different transformations from different source, thus you can spot on which source file cause the problem.

By default, if you don't specify where to load the log4j configurations, it will load the log4j.properties, and then log4j.xml from the class folder, which would be uneditable when put in a jar. This might not what you want. You want to specify an external log4j configuration which you can edit outside of the program.

Here is what you can do:

Put the xml log4j file (e.g. xmllog4jconfig.xml) in the project directory.

In your java program

Public class Transformer {

private static Logger logger = Logger.getLogger(SaxonTransform.class);

public static void main(String[] args) {

DOMConfigurator.configure("xmllog4jconfig.xml");
logger.debug("Here is some DEBUG");
logger.info("Here is some INFO");
logger.warn("Here is some WARN");
logger.error("Here is some ERROR");
logger.fatal("Here is some FATAL");
}
}

In the log4j xml configuration file, you can use LevelRange filter to log different levels of information into different log files like below:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd" >
<log4j:configuration>

<!-- log without a filter -->
<appender name="file"
class="org.apache.log4j.FileAppender">
<param name="File" value="logs/test.log" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern"
value="%d{ABSOLUTE} %5p %c{1}:%L - %m%n" />
</layout>
</appender>

<!-- log with a filter -->
<appender name="debugfile"
class="org.apache.log4j.FileAppender">
<param name="File" value="logs/debug.log" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern"
value="%d{ABSOLUTE} %5p %c{1}:%L - %m%n" />
</layout>

<!-- set the filter -->
<filter class="org.apache.log4j.varia.LevelRangeFilter">
<param name="LevelMin" value="debug" />
<param name="LevelMax" value="debug" />
</filter>
</appender>

<root>
<priority value="debug"></priority>
<appender-ref ref="debugfile" />
<appender-ref ref="file" />
</root>
</log4j:configuration>

For more tutorials on Log4J, please have a look at:

Log4J Tutorial from The University Of Birmingham
Log4J Tutorial from Laliluna

Encoding in XSLT

2008-05-06T17:06:00.003+01:00

If you have an xml document which contains German or French characters, then in your xml declarations, you should write:

<?xml version="1.0" encoding="ISO-8859-1"?>

Don't put "UTF-8" for it. It will not work

When using Java to write an xml fie, do the following:


File f = new File("newFile.xml");
FileOutputStream fos = new FileOutputStream(f);
OutputStreamWriter osw = new OutputStreamWriter(fos, Charset.forName("ISO-8859-1"));

// Begin to write an xml file.
osw.append("..");

Otherwise, if use the FileWriter instead of OutputStreamWriter, the programme will use the system default encoding which cause problems if the xml file contains German or French characters.

Remove unwanted namespace in XSLT

2008-05-06T12:44:00.008+01:00

If we have the xslt like below:


<xsl:stylesheet version="2.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:abc="http://www.abc.com"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<content>
...
</content>

</xsl:stylesheet>

The result xml will be look like:


<conent xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns="http://www.polopoly.com/polopoly/cm/xmlio"
   xmlns:abc="http://www.abc.com">
...
</conent>

The namespaces in the tag are not what we want. We can remove these namespaces by using

exclude-result-prefixes="xsl abc xsi" in the xsl:stylesheet declaration.

Escape in XML / XSLT

2008-04-28T16:55:00.008+01:00

If an xml file is embeded in another xml file like below:

<?xml version="1.0" encoding="UTF-8"?>
..
<value>
<?xml version="1.0" encoding="UTF-8"?>
<name>Your name</name>
..
</value>
..

And you want to extract the embedded xml file and remove its xml declaration tag, then do the following:


<!-- Disable xml declaration by xslt -->
<xsl:output method="xml" omit-xml-declaration="yes" />

<!-- Define the string you want to remove -->
<xsl:variable name="declare">
<![CDATA[<?xml version="1.0" encoding="UTF-8"?>]]>
</xsl:variable>

<!-- Get the embedded xml file -->
<xsl:variable name="prepared">
<xsl:value-of select="value" />
</xsl:variable>

<!-- Remove the xml declaration and escape special characters -->
<xsl:value-of select="substring-after($prepared, $declare)" 
disable-output-escaping="yes" />

Define variable using xsl:choose in XSLT

2008-04-28T15:48:00.003+01:00


<xsl:variable name="doctype">
<xsl:choose>
  <xsl:when test="condition1">value1</xsl:when>
  <xsl:when test="condition2">value1</xsl:when>
<xsl:choose>
</xsl:variable>

Get filename using XSLT

2008-04-28T15:37:00.005+01:00


<!-- Get the filename -->
<xsl:variable name="filename" select="tokenize(base-uri(.), '/')[last()]">

<!-- Split the filename using '\.' -->
<xsl:variable name="filenamepart" select="tokenize($filename, '\.')">

<!-- Remove the file extension -->
<xsl:value-of select="$filenamepart[1]"/>

2008-04-11T10:57:00.001+01:00

How To Make A Web Site On The Local Machine Available To Other Computer Users If you deployed a web site on apache, tomcat, or IIS on port 80, then do the following: 1. Control Panel / Network Connections / Local Area Connection (right click) / Properties 2. Advanced tab / Windows Firewall (click Settings button) / Exception tab / click Add Port button 3. Enter Name (i.e. blackboard), Port number: 80 (TCP). 4. Then click "Change scope" button, select the relevant option.

How to Set JAVA_HOME in Linux

2008-04-08T15:27:00.003+01:00

Set JAVA_HOME for One User

1. Make sure you are in bash mode by typing bash

2. Edit your .bashrc file vi ~/.bashrc

3. Add the following lines

JAVA_HOME=/usr/local/java/jdk1.5.0_15
export JAVA_HOME export PATH=$JAVA_HOME/bin:$PATH

Make sure put $JAVA_HOME/bin in front of $PATH, so that the system will look for javac and java first in the $JAVA_HOME/bin, and then $PATH.

4. Refresh the user profile using the following command.

source ~/.bashrc

Note: You have to make sure you are in the bash mode by typing: bash, otherwise the user profile won't be refreshed by the above source command.

5. Check your variables:

echo $JAVA_HOME
echo $PATH
which java
which javac

Set JAVA_HOME for All Users

1. Login as root.

2. Change it to bash shell by typing bash bash

3. Edit /etc/bashrc file vi /etc/bashrc

4. 5. 6 are the same as Set JAVA_Home for One User.

2008-01-26T01:33:00.000Z

Ant, Log4J, JUnit, Eclipse

1. Technical Specification

The target application environment Java compiler's version is Java 1.5.
Create a project in Eclipse.
Need to connect a database (e.g. Oracle).
Should log error message using Log4J.
Delivery the project as a jar.

2. Procedures

2.1 Create User Library for Log4J and JDBC driver (oracle-jdbc)

2.2 Add these two user libraries to the project build path

2.3 Establish The Application Environment in Eclipse

2.3.1 Create file.properties file as a property file for the application to read

2.3.2 Create a log4j.properties file for log4j to read

2.4 Follow the instructions to set up JUnit available to Ant

2.5 Create build.xml file

2.1 Create User Libraries

1. In Eclipse, Window > Preferences > Java > Build Path > User Libraries.
2. Click New button, and enter the 'user library name'.
3. Click Add JARs... button, and select the jar files to be added to this user library.
4. Click OK button.

Do the above steps for Log4J, and oracle-jdbc

2.2 Add User Libraries to the project

1. Right click the project, and select properties (or Alt+Enter).
2. Select Java Build Path > Libraries, and click Add Library... button
3. Select User Library, and click next> button
4. Select lo4j, and oracle-jdbc (the two we just created in the previous step).
5. Click OK to add these user libraries to the project environment.

Doing this can make sure these libraries are in the project classpath.

2.3 Establish Project Structure

1. Create build directory, and its sub directories (classes and jar)
md build/classes
md build/jar
2. Create lib directory, and copy log4j and oracle-jdbc jars in.

2.3.1 Create file.properties file as a property file for the application to read
name1 = value1
name2 = value2

2.3.2 In the src directory, create a log4j.properties file for log4j to read. Below is a sample

For more info about log4j, please look at: How to use log4j logging API and Log4J Manual

************************************************
# Log levels
# Uncomment the following line to enable full loggin for every class
#log4j.rootLogger=trace, stdout, R
log4j.logger.pma=error, stdout, R

# Console appender configuration
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
# Pattern to output the caller's file name and line number.
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n

# Rolling File Appender
log4j.appender.R=org.apache.log4j.RollingFileAppender
# Path and file name to store the log file.
log4j.appender.R.File=./logs/error.log
log4j.appender.R.MaxFileSize=500KB
# Keep one backup file
log4j.appender.R.MaxBackupIndex=1
# Rolling File Appender layout
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%d - %c - %p - %m%n

****************************************************

2.4 Follow the instructions to set up JUnit available to Ant

2.5 Create build.xml file

For more information about Ant and its build.xml file, please have a look at Tutorial: Hello World with Ant

Below is a sample build.xml file:

********************************************************

<?xml version="1.0"?>

<project name="pma" basedir="." default="main">
<property name="src.dir" value="src">
</property>
<property name="build.dir" value="build">
</property>
<property name="classes.dir" value="${build.dir}/classes">
</property>
<property name="jar.dir" value="${build.dir}/jar">
</property>
<property name="main-class" value="pma.PMADAO_Split">
</property>
<property name="lib.dir" value="lib">
</property>
<property name="report.dir" value="${build.dir}/junitreport">
</property>

<path id="classpath">
<fileset dir="${lib.dir}" includes="**/*.jar">
</fileset>
</path>

<target name="clean">
<delete dir="${build.dir}">
</delete>
</target>

<target name="compile">
<mkdir dir="${classes.dir}"/>
<javac srcdir="${src.dir}" destdir="${classes.dir}"
classpathref="classpath"
source="1.5"
target="1.5"
compiler="javac1.5"/>
<copy todir="${classes.dir}">
<fileset dir="${src.dir}" excludes="**/*.java">
</fileset>
</copy>
</target>

<target name="jar" depends="compile">
<mkdir dir="${jar.dir}"/>
<jar destfile="${jar.dir}/${ant.project.name}.jar" basedir="${classes.dir}" update="true">

<zipfileset src="${lib.dir}/ojdbc14.jar"/>
<zipfileset src="${lib.dir}/log4j-1.2.15.jar"/>

<manifest>
<attribute name="Main-Class" value="${main-class}"/>
</manifest>
</jar>
</target>

<target name="run" depends="jar">
<java fork="true" classname="${main-class}">
<classpath>
<path refid="classpath">
</path>
<path id="application" location="${jar.dir}/${ant.project.name}.jar">
</path>
</classpath>
</java>
</target>

<target name="clean-build" depends="clean,jar">
</target>
<target name="main" depends="clean,run">
</target>

<target name="junit" depends="jar">
<mkdir dir="${report.dir}" />
<junit printsummary="yes">
<classpath>
<path refid="classpath" />
<path refid="application" />
</classpath>
<formatter type="xml" />
<batchtest fork="yes" todir="${report.dir}">
<fileset dir="${src.dir}" includes="*Test.java" />
</batchtest>
</junit>
</target>

<target name="junitreport">
<junitreport todir="${report.dir}">
<fileset dir="${report.dir}" includes="TEST-*.xml"/>
<report todir="${report.dir}"/>
</junitreport>
</target>

</project>

**********************************************

In the task "jar", the following code can make sure the created jar (pma.jar) file contains the following libraries (log4j, and oracle-jdbc jars) in an extracted format. If the libraries (log4j, and oracle-jdbc jars) in the created jar (pma.jar) are in its jar format, then the application won't find the libraries in its classpath when running.

<zipfileset src="${lib.dir}/ojdbc14.jar"/>
<zipfileset src="${lib.dir}/log4j-1.2.15.jar"/>

In the task "compile", we have to add:

source="1.5" target="1.5" compiler="javac1.5" to make the application java 1.5 compatible on the target environment, otherwise it will complains about "class version something" when running.

crontab

2008-01-15T16:53:00.000Z

Weblog Analysis with Webalizer

2008-01-15T16:01:00.000Z

Webalizer is a web log analysis tool which runs very fast. You can download Webalizer Here.

By default

>./webalizer logfile

will process only one log file. If all the logs are in one file, then it is ok. But for logs which rotate on a daily basis, you have to configure webalizer to do so.

Here is my webalizer.conf, which should be at the webalizer command directory.

**********************************************
...
LogType clf
OutputDir /outputdirectory
HistoryName webalizer.hist
Incremental yes
IncrementalName webalizer.current
...
**********************************************

Create a script foo.sh like below will do the business:

**********************************************
#!/bin/sh

for file in /logfiles/*
do
/pathtowebalizer/webalizer $file
done
exit 0
**********************************************

Java Logging using java.util.logging

2008-01-11T10:10:00.000Z

Java's logging facility (see Sun's overview and API ) has two parts : a configuration file, and an API for using logging services. It is a good tool, and is perfectly fine for simple and moderate logging needs. (For complex logging needs, you might consider the log4j tool as an alternative.)

Log entries can be sent to these destinations, as either simple text or as XML :

the console
a file
a stream
memory
a TCP socket on a remote host

The Level class defines seven levels of logging enlightenment :

FINEST, FINER, FINE, CONFIG, INFO, WARNING, SEVERE
ALL and OFF are defined values as well

Here is one style of using these Levels in code, which may be modified as desired :

upon startup, use CONFIG to log configuration parameters
during normal operation, use INFO to log high-level "heartbeat" information
when bugs or critical conditions occur, use SEVERE
debugging information might default to FINE, with FINER and FINEST used occasionally, according to taste.

There is flexibility in how logging levels can be changed at runtime, without the need for a restart :

simply change the configuration file and call LogManager.readConfiguration.
or, change the level in the body of your code, using the logging API ; for example, one might automatically increase the logging level in response to unexpected events

Levels are attached to these items :

an originating logging request (from a single line of code)
a Logger (usually attached to the package containing the above line of code)
a Handler (attached to an application)

The flow of execution for a particular logging request usually proceeds as follows :

logging request of some level is made to logger attached to current package
if the request level is too low for that package's logger {
discard it
}
otherwise {
cycle through all handlers {
if the request level is too low for that handler {
discard it
}
otherwise {
log the request
}
}
}

Here is an example of a logging configuration file :

# Properties file which configures the operation of the JDK
# logging facility.

# The system will look for this config file, first using
# a System property specified at startup:
#
# >java -Djava.util.logging.config.file=myLoggingConfigFilePath
#
# If this property is not specified, then the config file is
# retrieved from its default location at:
#
# JDK_HOME/jre/lib/logging.properties

# Global logging properties.
# ------------------------------------------
# The set of handlers to be loaded upon startup.
# Comma-separated list of class names.
# (? LogManager docs say no comma here, but JDK example has comma.)
handlers=java.util.logging.FileHandler, java.util.logging.ConsoleHandler

# Default global logging level.
# Loggers and Handlers may override this level
.level=INFO

# Loggers
# ------------------------------------------
# Loggers are usually attached to packages.
# Here, the level for each package is specified.
# The global level is used by default, so levels
# specified here simply act as an override.
myapp.ui.level=ALL
myapp.business.level=CONFIG
myapp.data.level=SEVERE

# Handlers
# -----------------------------------------

# --- ConsoleHandler ---
# Override of global logging level
java.util.logging.ConsoleHandler.level=SEVERE
java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter

# --- FileHandler ---
# Override of global logging level
java.util.logging.FileHandler.level=ALL

# Naming style for the output file:
# (The output file is placed in the directory
# defined by the "user.home" System property.)
java.util.logging.FileHandler.pattern=%h/java%u.log

# Limiting size of output file in bytes:
java.util.logging.FileHandler.limit=50000

# Number of output files to cycle through, by appending an
# integer to the base file name:
java.util.logging.FileHandler.count=1

# Style of output (Simple or XML):
java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter

An application should likely centralize the naming policy for Loggers, since switching naming styles becomes a simple edit in one method, instead of a large number of edits spread throughout the application. Reasons to alter the naming policy might include :

in a shared environment, adding an application name to the Logger name can help distinguish one application's entries from others
adding application version information might be beneficial for debugging

There is a common complaint with the JDK logging config file : a Handler cannot be restricted to a specific Logger. That is, Handlers defined in the config file are global, in the sense that they will be attached to all Loggers. This is particularly annoying in a server environment, since different applications will, by default, output logging statements into the same file. This behavior can be easily changed, but only by using the JDK logging API. Many would prefer to do this directly in the config file.

Here is an example of using the logging API :

package myapp.business;

import java.util.logging.*;

/**
* Demonstrate Java's logging facilities, in conjunction
* with a logging config file.
*/
public final class SimpleLogger {

public static void main(String argv[]) {
 SimpleLogger thing = new SimpleLogger();
 thing.doSomething();
}

public void doSomething() {
 //Log messages, one for each level
    //The actual logging output depends on the configured
    //level for this package. Calls to "inapplicable"
    //messages are inexpensive.
    fLogger.finest("this is finest");
 fLogger.finer("this is finer");
 fLogger.fine("this is fine");
 fLogger.config("this is config");
 fLogger.info("this is info");
 fLogger.warning("this is a warning");
 fLogger.severe("this is severe");

 //In the above style, the name of the class and
    //method which has generated a message is placed
    //in the output on a best-efforts basis only.
    //To ensure that this information is always
    //included, use the following "precise log"
    //style instead :
    fLogger.logp(Level.INFO, this.getClass().toString(), "doSomething", "blah");

 //For the very common task of logging exceptions, there is a
    //method which takes a Throwable :
    Throwable ex = new IllegalArgumentException("Some exception text");
 fLogger.log(Level.SEVERE, "Some message", ex);

 //There are convenience methods for exiting and
    //entering a method, which are at Level.FINER :
    fLogger.exiting(this.getClass().toString(), "doSomething");

 //Display user.home directory, if desired.
    //(This is the directory where the log files are generated.)
    //System.out.println("user.home dir: " + System.getProperty("user.home") );
  }

// PRIVATE //

//This logger will inherit the config of its parent, and add
  //any further config as an override. A simple style is to use
  //all config of the parent except, perhaps, for logging level.

//This style uses a hard-coded literal and should likely be avoided:
  //private static final Logger fLogger = Logger.getLogger("myapp.business");

//This style has no hard-coded literals, but forces the logger
  //to be non-static.
  //private final Logger fLogger=Logger.getLogger(this.getClass().getPackage().getName());

//This style uses a static field, but hard-codes a class literal.
  //This is probably acceptable.
  private static final Logger fLogger =
                  Logger.getLogger(SimpleLogger.class.getPackage().getName());
}

Example Run 1 , using the config file defined above :

>java -Djava.util.logging.config.file=C:\Temp\logging.properties
-cp . myapp.business.SimpleLogger

ConsoleHandler is configured to show only SEVERE messages :

Jan 8, 2003 10:43:47 AM myapp.business.SimpleLogger doSomething
SEVERE: this is severe
Jan 8, 2003 10:43:47 AM myapp.business.SimpleLogger doSomething
SEVERE: Some message
java.lang.IllegalArgumentException: Some exception text
at myapp.business.SimpleLogger.doSomething(SimpleLogger.java:39)
at myapp.business.SimpleLogger.main(SimpleLogger.java:13)

While the FileHandler shows ALL that is sent to it :

Jan 8, 2003 10:43:46 AM myapp.business.SimpleLogger doSomething
CONFIG: this is config
Jan 8, 2003 10:43:47 AM myapp.business.SimpleLogger doSomething
INFO: this is info
Jan 8, 2003 10:43:47 AM myapp.business.SimpleLogger doSomething
WARNING: this is a warning
Jan 8, 2003 10:43:47 AM myapp.business.SimpleLogger doSomething
SEVERE: this is severe
Jan 8, 2003 10:43:47 AM class myapp.business.SimpleLogger doSomething
INFO: blah
Jan 8, 2003 10:43:47 AM myapp.business.SimpleLogger doSomething
SEVERE: Some message
java.lang.IllegalArgumentException: Some exception text
at myapp.business.SimpleLogger.doSomething(SimpleLogger.java:39)
at myapp.business.SimpleLogger.main(SimpleLogger.java:13)

Example Run 2, showing the ConsoleHandler output, using the logging.properties file which ships with the JDK, and which logs only INFO level and above :

>java -cp . myapp.business.SimpleLogger

Jan 8, 2003 10:52:31 AM myapp.business.SimpleLogger doSomething
INFO: this is info
Jan 8, 2003 10:52:31 AM myapp.business.SimpleLogger doSomething
WARNING: this is a warning
Jan 8, 2003 10:52:31 AM myapp.business.SimpleLogger doSomething
SEVERE: this is severe
Jan 8, 2003 10:52:31 AM class myapp.business.SimpleLogger doSomething
INFO: blah
Jan 8, 2003 10:52:31 AM myapp.business.SimpleLogger doSomething
SEVERE: Some message
java.lang.IllegalArgumentException: Some exception text
at myapp.business.SimpleLogger.doSomething(SimpleLogger.java:39)
at myapp.business.SimpleLogger.main(SimpleLogger.java:13)

Enable logging remote host name is tomcat access log.

2007-11-12T16:26:00.000Z

To enable remote host name to be logged in tomcat access log, in conf/server.xml, you have to do two things:

1.

<Service name="Catalina">
...
<Connector port="8080" ... enableLookups="true"..>
...
<Service>

2.

<Host name="localhost" ..>
...
<Valve className="org.apache.catalina.valves.FastCommonAccessLogValve"
directory="logs" prefix="access_log." suffix=".txt"
pattern="combined" resolveHosts="true" rotatable="true" fileDateFormat="yyyy-MM-dd"/>
...
</Host>

In the access log, it will look like:

host217-43-97-182.range217-43.btcentralplus.com - - [12/Nov/2007:16:39:48 +0000] "GET /styles/topmenu.css HTTP/1.1" 200 1184 "http://www.jetonrails.com" "
Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727; InfoPath.1)"

The first part is the remote host name instead of remote IP address.

Escape xml in JSTL

2007-11-09T12:12:00.000Z

For <c:out> in JSTL:

<c:out value="Hello"/>

It will generate source code like:

& lt;p& gt;hello& lt;/p& gt;

And it will show the wording in the browser like:

Hello

Solution: put excapteXml="false" in.

<c:out escapexml="false" value="Hello"/>

It will generate source code like:

Hello

And it will show the wording in the browser like:

Hello

Select Distinct Values in XML

2007-11-05T12:49:00.000Z

For the xml file like below:


<books>
  <book author="Kevin Williams" title="Professional XML 2.0" />
  <book author="Lewis Carroll" title="Alice in Wonderland" />
  <book author="Lewis Carroll" title="Through the Looking-Glass" />
</books>

If you want to select distinct author from it, then make sure you use: xslt 2.0, and SaxonBB parser (in OxygenXML for example)


<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
   <xsl:output method="xml" indent="yes" />
  
   <xsl:template match="units">
           <xsl:for-each select="distinct-values(unit_instance/lev_code)">
       <xsl:value-of select="."/>
            </xsl:for-each>
       </xsl:template>
   </xsl:stylesheet>

Link spans two lines.

2007-11-01T17:00:00.000Z

If a link spans two lines and looks terrible, then use the following code in the CSS.

line-height: 14pt;

Website Skip Navigation

2007-09-13T16:33:00.000+01:00

Refer to the link. Creating a "Skip Navigation" in the web site allows visual disabled people to use the screen reader to jump over the navigation links and directly to the content.

Retrieve a text file from a web address

2007-08-17T14:18:00.000+01:00

Requirement:

Retrieve a text file from a web address and write it to a local file.



// Retrieve the web address from the property file, in which you can change the web address without changing the Java code

Properties properties = new Properties();
try {
properties.load(new FileInputStream("file.properties"));
} catch (IOException e){
System.out.println("Can't fild file.properties");
}
String webAddress= properties.getProperty("webAddress");

// Construct the url
URL url = new URL(webAddress);

// Establish the connection
HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();

// Retrieve the response status code
int statusCode = httpURLConnection.getResponseCode();

if (statusCode == 200){
  // Create an empty file
  File file = new File ("folderName" + "/" + "fileName" + ".extensionName");
  if (file.exists()) {
   file.delete();
  }
  // Create a buffered writer for output
  BufferedWriter output = new BufferedWriter(new FileWriter(file, true));


  // Create a buffered reader to retrieve content from the web address
  BufferedReader reader = new BufferedReader(new InputStreamReader((InputStream)httpURLConnection.getContent()));

  String lLine = "";

  // Read web content line by line and write it to the output file    
  while ((line = reader.readLine()) != null) {
  output.append(line);
  }

  // Close the buffered writer
  output.close();         
}

Vi: Search and Replace

2007-08-16T11:48:00.000+01:00

Search (Wraped around at end of file):

  Search STRING forward :   / STRING.
 Search STRING backward:   ? STRING.

 Repeat search:   n
 Repeat search in opposite direction:  N  (SHIFT-n)

Replace: Same as with sed, Replace OLD with NEW:


First occurrence on current line:      :s/OLD/NEW

Globally (all) on current line:        :s/OLD/NEW/g

Between two lines #,#:                 :#,#s/OLD/NEW/g

Every occurrence in file:              :%s/OLD/NEW/g

svn merge example

2007-08-10T15:49:00.000+01:00

Problem Solving:

Merge code from one branch to the trunk.

The release candidate server has the code from trunk.

In release_candidate server's source code directory:

svn merge --dry-run -r rev1:rev2 branch_url

# rev1 is the revision number when first branch out from trunk
# rev2 is the latest revision number from the branch

svn merge -r rev1:rev2 branch_url

svn status | grep "C "

# see any conflicts after merge, "C" stands for conflict

# for those conflict files, edit them to fix the conflict.

# filename.working is the local copy (here is the trunk code)
# filename.right is the latest from the branch
# filename.left is the original from the brach when first branched out from trunk

# happy

svn resolved filename

svn commit -m "commit rev1:rev2 branch_url"

# commit the merged code to the trunk

# done

For more svn knowledge, please see SVN RedBook

Sorting Map

2007-08-10T14:47:00.000+01:00

The following definition is from Java API.

HashMap:

Hash table based implementation of the Map interface. This implementation provides all of the optional map operations, and permits null values and the null key. (The HashMap class is roughly equivalent to Hashtable, except that it is unsynchronized and permits nulls.) This class makes no guarantees as to the order of the map; in particular, it does not guarantee that the order will remain constant over time.

LinkedHashMap:

Hash table and linked list implementation of the Map interface, with predictable iteration order. This implementation differs from HashMap in that it maintains a doubly-linked list running through all of its entries. This linked list defines the iteration ordering, which is normally the order in which keys were inserted into the map (insertion-order). Note that insertion order is not affected if a key is re-inserted into the map. (A key k is reinserted into a map m if m.put(k, v) is invoked when m.containsKey(k) would return true immediately prior to the invocation.)

TreeMap:

Red-Black tree based implementation of the SortedMap interface. This class guarantees that the map will be in ascending key order, sorted according to the natural order for the key's class (see Comparable), or by the comparator provided at creation time, depending on which constructor is used.

Problem Solving:
One university department has three levels of courses, namely undergraduate, postgraduate taught, and postgraduate research to offer. The department wants to show these courses in alphabatical order within respective level of course. The order of the level should be: undergraduate, postgraduate taught, postgraduate research.


LinkedHashMap courseMap = new LinkedHashMap();
TreeMap ugCourseTreeMap = new TreeMap();
courseMap.put("UG", ugCourseTreeMap);
 
TreeMap pgtCourseTreeMap = new TreeMap();
courseMap.put("PGT", pgtCourseTreeMap);

TreeMap pgrCourseTreeMap = new TreeMap();
courseMap.put("PGR", pgrCourseTreeMap);

// looping begins
// courseName is a String
// course is a class

ugCourseTreeMap.put(courseName, course);
pgtCourseTreeMap.put(courseName, course);
pgrCourseTreeMap.put(courseName, course);

// looping end

Iterator it = ugCourseTreeMap.values().iterator();
while(it.hasNext()) {

}


/**************No need to do the following************
/**************Because TreeMap is ordered*************
ArrayList keysUG = new ArrayList();
keysUG.addAll(ugCourseMap.keySet());
Collections.sort(keysUG);

ArrayList keysPGT = new ArrayList();
keysPGT.addAll(pgtCourseMap.keySet());
Collections.sort(keysPGT);
  
ArrayList keysPGR = new ArrayList();
keysPGR.addAll(pgrCourseMap.keySet());
Collections.sort(keysPGR);

// Iteration example
Iterator it = ugCourseMap.keySet().iterator();
while (it.hasNext()) {
..
}

/**********************************************

Search a keyword in a directory recursively

2007-08-10T09:53:00.000+01:00

If you want to search a keyword in files of the current directory and its sub directories:

$/usr/local/home/jet>

then do:

find . | xargs grep whatever

To Learn List

2007-08-08T09:52:00.000+01:00

WTP + JSF

Dali + JPA

Grails

The use of Link in HTML

2007-08-06T13:42:00.000+01:00

Can't add Alt in background image in CSS

2007-08-06T12:10:00.000+01:00

When using background: url(/imagesource); in CSS, please be aware that there no way to add Alt text. Therefore, using normal html instead.

Replacing string in multiple files without changing filenames.

2007-08-03T11:01:00.000+01:00

#!/bin/sh

for file in /path/to/my/files/*
do
sed 's/stringA/stringB/g' $file > $file.new
mv $file.new $file
done
exit 0

Make the script executable
$ chmod u+x foo.sh

Then run it (assuming it's in the current directory)
$ ./foo.sh

For more sed examples, please have a look at the IBM articles

WTP Tutorials - JavaServer Faces Tools Tutorial

2007-08-02T16:19:00.000+01:00

Any Eclipse fans who want to learn JSF should have a look at this tutorial.

Make sure you say "Hello World!" ;)

Generic Thing Pattern

2005-02-15T13:05:00.000Z

Generic Thing Pattern

Hay (1996) introduced a powerful data model by 'extracting the essence of each thing in order to deal with it as more of an abstraction'.

The context meaning for the diagram is:

A 'Thing Type' (aka a type of a thing) has many 'Attributes'.
A 'Thing' belongs to a 'Thing Type'.
A 'Thing' has its values which is associated with 'Attibutes'

Its conventions of thought has been influencing many database designers and researchers. Silverton (2001) expanded this to introduce a flexible People and Organisations pattern.

A dynamic form creator, Horde Ulaform (2005), based on the 'Thing' pattern uses the 'Thing Type' and 'Attribute' to define the form and uses the 'Thing' and 'Value' for storage of form fields values. It is a robus application which allows for easy creation of forms, but lacks of the relationships between entities which is what the database's power about. Furthermore it doesn't store the historical data of form fields. In terms of version manangement, it only store the current values of form fields. So it won't be suitable for version management for form data storage.

Reference:

Hay D.C., 1996. Data Model Patterns: Conventions of Thought. New York: Doset House Publishing co., inc.

Silverston L, 2001. The Data Model Resource Book. Volume 1: A Library of Universal Data Models for All Enterprise. Revised Edition. Canada: Wiley.

Horde. 2005. Ulaform [online]. Available from: http://www.horde.org/ulaform/ [Accessed 15 February 2005].

Posted by Hello