Netwiser @ RISGuru

Save Image in Android Content Provider

2011-11-09T15:50:00.002-05:00

import android.provider.MediaStore.Images.Media;
import android.content.ContentValues;
import java.io.OutputStream;
// Save the name and description of an image in a ContentValues map.  
ContentValues values = new ContentValues(3);
values.put(Media.DISPLAY_NAME, "road_trip_1");
values.put(Media.DESCRIPTION, "Day 1, trip to Los Angeles");
values.put(Media.MIME_TYPE, "image/jpeg");
// Add a new record without the bitmap, but with the values just set.
// insert() returns the URI of the new record.
Uri uri = getContentResolver().insert(Media.EXTERNAL_CONTENT_URI, values);
// Now get a handle to the file for that record, and save the data into it.
// Here, sourceBitmap is a Bitmap object representing the file to save to the database.
try {
    OutputStream outStream = getContentResolver().openOutputStream(uri);
    sourceBitmap.compress(Bitmap.CompressFormat.JPEG, 50, outStream);
    outStream.close();
} catch (Exception e) {
    Log.e(TAG, "exception while writing image", e);
}

Introduction to Android development

2011-09-18T21:50:00.002-04:00

The following paragraphs summarize the work of the Android development experts fully conversant with all aspects of the Android development. Watch their Android development advice to avoid surprises. Now that we discussed aspects of Android development, let's turn to some of the other factors that must be considered.

Introduction

The BlackBerry and iPhone, which is attractive and high-volume mobile platforms are addressing opposite ends of a spectrum. The BlackBerry is rock solid for enterprise business user. For a consumer device, it is difficult to compete with the iPhone for ease of use and "cool factor." Android, a young and not-yet proven platform, has the potential to play at both ends of the mobile phone spectrum and perhaps even bridge the gap between work and play.

Today many network-based or network-enabled devices running a flavor of the Linux kernel. It is a solid platform cost-effectively implement and support readily accepted as a good design approach for implementation. The user interface for these drugs is often based on HTML and visible with a PC or Mac browser. But not every device should be checked by a general computing device. Consider a conventional device such as a stove, microwave oven or bread machine. What if your appliances were checked by Android and boasted a color touch screen? With an Android UI on the stove-top, the author may also be able to cook anything.

In this article, learn about the Android platform and how it can be used for mobile applications and mobile no. Install the Android SDK and build a simple application

A brief history of Android

The Android platform is the product of the Open Handset Alliance, a group of organizations working to build better mobile phone. The group, led by Google, including mobile operators, handset device manufacturers, component manufacturers, software solution and platform providers and marketing companies. From a software development standpoint, Android is right in the middle of the open source world.

The first Android-capable phone on the market, the G1 device manufactured by HTC and maintained at T-Mobile. The device was available after almost one year of speculation, where the only software development tools available single step to improve SDK releases. Because the G1 release date neared, the team released Android SDK V1.0 and applications began to surface for the new platform.

To spur innovation, Google sponsored two rounds of the "Android Developer Challenge", where millions of dollars were given to top contest entries. A few months after the G1, the Android Market was released, allowing users to download and view programs on their phones. More than about 18 months, a new mobile platform was the public arena.

The Android platform

The width of Android's capabilities, it would be easy to confuse with a desktop operating system. Android is a layered environment built on a foundation of the Linux kernel, and includes a range of functions. The UI subsystem includes:

Windows
Views
Widgets for displaying common elements, such as input fields, lists and drop-down lists

Android includes an embeddable browser based on WebKit, the same open source browser engine of iPhone Mobile Safari browser.

Android has a healthy array of connectivity options, including WiFi, Bluetooth, and wireless data over a cellular connection (eg, GPRS, EDGE, and 3G). A popular technique in Android applications can be linked to an address directly into Google Maps to display within an application. Support for location-based services (like GPS) and accelerometers is also available in the Android software stack, but not all Android devices are equipped with the necessary hardware.

Historically, two areas where mobile applications are struggling to keep up with their desktop counterparts, graphics / media, and data storage methods. Android focuses on the graphic challenge with native support for 2-D and 3-D graphics, including the OpenGL library. Data storage burden is eased because the Android platform includes the popular open source SQLite database.

Android Application Development

There are many different types of applications in the Android market and the demand for them over the years. People with Mobi, our Android applications division focuses on providing solutions for the development of Android platform. We offer a wide range of Android application development solutions that are built using the capabilities of the Android SDK. We also offer our customers the opportunity to join our team of developers on a project basis or alternatively dedicated developers who can work on the specified client project and according to their guidelines to hire.

Services Offered

Android Application Development:

Our expert team of high quality designs Android application development solutions, where she first introduced to the concepts and understand the framework for creating an Android application. Our Android developers have all the skills and full understanding of the different tools to the industry develop, test, implement and deploy software for the platform.

Our developers can analyze, understand, and therefore make the necessary framework

They possess full knowledge of and experience with different tools, such as Android SDK and API's Framework

Our developers use a variety of techniques, including Qume based emulator SQLiteDatabse, Java Programming Language, Android security architecture and Trace / View tests

Android Social Network Development:

People with Mobi, our developers know the popularity of social networks than enjoying our developers to Android-based social networking application development outsourcing for our customers. This fully functional social networking Android apps to a simple upload of photos, live chat, message notifications and profile views, etc. through our customized Android Social networking applications for our clients outsourcing, we offer:

Applications that can track the movements of online contacts
Create alerts for specific groups of friends
Make sure the network application also works as a guide

Android Game Development

Mobile gaming is one of the most popular applications and there is always a constant demand for Android games. Mobi with people, our game development team consists of enthusiastic, eager and creative professionals looking for something new and out-of-the-box gaming applications all the time to create. Developing games for the Android platform is based on Java and the Android OS extends support for Java, through its various libraries.

Our team of Android game developers will understand the needs of our offshore clients and therefore consider innovative gaming solutions.

They have deep experience and expertise of not only the Android SDK, but also of the NDK r3, which add-on for the original Android SDK kit.

Our developers also have an extensive knowledge of other technologies required to improve the quality games such as Android Java SE Development, Eclipse, Android Eclipse plug-ins, 3D graphics development, reuse and replacement of parts, etc.

Android Wireless Application Development:

There exists in the industry, different races and types of Android wireless applications and our developers are skilled in offering scalable application development services to our offshore clients. We can help organizations meet the demands of wireless applications. Our developers are experienced in providing:

Superior quality interactive data services with high quality wireless application development Android

Our developers are able to conceptualize, design, development, testing and integrating different types of wireless applications Android.

Android by custom wireless application, a large number of activities are carried out, including sports, music downloads, keeping track of various services and e-mail via the hand-held device.

Now you understand why there is a growing interest in Android development. If people are looking for more information on the development of Android, you will be able to meet their needs.

Concurrent Update GORM object

2011-07-29T16:34:00.001-04:00

FYI I believe the reason airport.lock() doesn't work is because according to the hibernate docs, if "airport" has already been loaded in the session, then lock() does a version check - which may fail under concurrency. The workaround is it evict airport from the session then re-obtain it using session.load(clazz, id, LockMode.UPGRADE), e.g.

def session = sessionFactory.currentSession
session.evict(airport) // Force the following load to actually go to the DB instead of doing a version check
airport = session.load(Airport.class, airport.id, LockMode.UPGRADE)

This seems to work OK

Reference: http://jira.grails.org/browse/GRAILS-2790
--
To Live Instead Of Exist!

Search Engine Submission Links (Over 100)

2011-05-23T13:10:00.000-04:00

http://blog.iask.com/add_new_rss.php
http://blog.iask.com/ping.php
http://rpc.weblogs.com/RPC2
http://api.moreover.com/RPC2
http://ping.syndic8.com/xmlrpc.php
http://rpc.blogrolling.com/pinger/
http://services.newsgator.com/ngws/xmlrpcping.aspx
http://www.bloglines.com/ping
http://ping.blo.gs/
http://rpc.blogcatalog.com/
http://xping.pubsub.com/ping/
http://ping.myblog.jp/
http://blog.goo.ne.jp/XMLRPC
http://www.blogpeople.net/servlet/weblogUpdates
http://rpc.twingly.com/
http://rpc.spinn3r.com/open/RPC2
http://api.postrank.com/v2/ping
http://www.wasalive.com/ping/
http://rpc.icerocket.com:10080/
http://www.feedblitz.com/f/f.fbz?XmlPing
http://www.zhuaxia.com/rpc/server.php
http://www.xianguo.com/xmlrpc/ping.php
http://blog.iask.com/RPC2
http://api.my.yahoo.com/rpc2
http://rpc.pingomatic.com/rpc2
http://ping.blog.qikoo.com/rpc2.php
http://rpc.technorati.com/rpc/ping
http://blog.yodao.com/ping/rpc2
http://www.zhuaxia.com/rpc/server.php
http://www.xianguo.com/xmlrpc/ping.php
http://ping.blog.qikoo.com/rpc2.php
http://api.my.yahoo.com/rpc2
http://rpc.pingomatic.com/rpc2
http://ping.blog.qikoo.com/rpc2.php
http://www.zhuaxia.com/rpc/server.php
http://rpc.technorati.com/rpc/ping
http://www.xianguo.com/xmlrpc/ping.php
http://www.bloglines.com/ping
http://blog.yodao.com/ping/rpc2
http://services.newsgator.com/ngws/xmlrpcping.aspx
http://1470.net/api/ping
http://api.feedster.com/ping
http://api.moreover.com/RPC2
http://api.moreover.com/ping
http://api.my.yahoo.com/rss/ping
http://bblog.com/ping.php
http://bitacoras.net/ping
http://blog.goo.ne.jp/XMLRPC
http://blogdb.jp/xmlrpc
http://blogmatcher.com/u.php
http://bulkfeeds.net/rpc
http://coreblog.org/ping/
http://mod-pubsub.org/kn_apps/blogchatt
http://www.lasermemory.com/lsrpc/
http://ping.amagle.com/
http://ping.bitacoras.com
http://ping.blo.gs/
http://ping.bloggers.jp/rpc/
http://ping.cocolog-nifty.com/xmlrpc
http://ping.blogmura.jp/rpc/
http://ping.exblog.jp/xmlrpc
http://ping.myblog.jp
http://ping.rootblog.com/rpc.php
http://ping.syndic8.com/xmlrpc.php
http://ping.weblogalot.com/rpc.php
http://ping.weblogs.se/
http://pingoat.com/goat/RPC2
http://rcs.datashed.net/RPC2/
http://rpc.blogbuzzmachine.com/RPC2
http://rpc.blogrolling.com/pinger/
http://rpc.icerocket.com:10080/
http://rpc.newsgator.com/
http://rpc.pingomatic.com
http://rpc.technorati.com/rpc/ping
http://rpc.weblogs.com/RPC2
http://topicexchange.com/RPC2
http://trackback.bakeinu.jp/bakeping.php
http://www.a2b.cc/setloc/bp.a2b
http://www.bitacoles.net/ping.php
http://www.blogdigger.com/RPC2
http://www.blogoole.com/ping/
http://www.blogoon.net/ping/
http://www.blogpeople.net/servlet/weblogUpdates
http://www.blogroots.com/tb_populi.blog?id=1
http://www.blogshares.com/rpc.php
http://www.blogsnow.com/ping
http://www.blogstreet.com/xrbin/xmlrpc.cgi
http://www.mod-pubsub.org/kn_apps/blogchatter/ping.php
http://www.newsisfree.com/RPCCloud
http://www.newsisfree.com/xmlrpctest.php
http://www.popdex.com/addsite.php
http://www.snipsnap.org/RPC2
http://www.weblogues.com/RPC/
http://xmlrpc.blogg.de
http://blogsearch.google.com/ping/RPC2
http://ping.feedburner.com/
http://www.feedsky.com/api/RPC2
http://www.xianguo.com/xmlrpc/ping.php
http://rpc.technorati.com/rpc/ping
http://rpc.pingomatic.com
http://www.blogpeople.net/servlet/weblogUpdates
http://ping.myblog.jp
http://ping.bloggers.jp/rpc/
http://bblog.com/ping.php
http://api.moreover.com/RPC2
http://xping.pubsub.com/ping/
http://ping.syndic8.com/xmlrpc.php
http://ping.weblogalot.com/rpc.php
http://rpc.weblogs.com/RPC2
http://topicexchange.com/RPC2
http://www.wasalive.com/ping/
http://www.pingoat.com/
http://rpc.weblogs.com/pingSiteForm
http://api.my.yahoo.com/RPC2
http://www.feedping.com
http://www.rssping.com/
http://fgiasson.com/pings/ping.php
http://rpc.feedsky.com/ping

Use AndroidGateway.com guard service to ease your paid Android application development

2011-05-17T11:44:00.002-04:00

Using the same infrastructure stack, removing the need for developers to manually recreate an applications stack for each release to each marketplace.

Android Gateway Authorization and Authentication Service lets you manage access to applications that users have downloaded from various Android application marketplaces. To use Android Gateway Authorization and Authentication Service in an application, you need to have a developer account on Android Gateway, and you can publish the application on different Android Marketplaces delivering to users.

Developers need to register for one account and agree to the Android Gateway terms of service. Once you are registered, you can obtain your developer API key and start to debugging and testing your authorization and authentication implementation. For more information about publishing on different Android Marketplaces, please refer to each marketplace instructions.

Once your developer account is set up, use the account to:

Obtain an API key for licensing
Associate your applications to partnership marketplaces
Debug and test an application's authorization and authentication implementation
Keep track of your application authorization and authentication status

If you have your developer API ready, after you publish your paid applications to different marketplaces, for instance, AndAppOnline.com, write down your account information and product listing information from that marketplace, go back to Android Gateway, register your application and marketplace association with the information you recorded just now.

The information you need to register the association are including:

Your developer API on the marketplace that you have published your Android application
You application key or unique id on the marketplace after you have published you have published your Android application

Android Gateway, authorization and authentication solution for paid android applications

2011-04-16T16:55:00.000-04:00

How does it work

To help Android Application developers add licensing protection to their application, Android Gateway provides open source library (Auth Library) that developers can include in their application project or they can implement by themselves according to the specification. The Auth Library handles all of the authorization and authentication-related communication with the Android Gateway and her partnership marketplaces. With Auth Library integrated, the application can determine its licensing status for current device by simply calling a validation checker method and verifying the received response.

To help to protect the privilege of developers' paid application, it is strongly recommended that developers use obfuscator programs available for Android applications such as ProGuard, to obfuscate their application code. Obfuscating their code helps to make it more difficult to decompile the application's byte code, modify it — such as by removing the license check — and then recompile and redistribute it.

For technical detail information such as how to authorize and authenticate through AndroidGateway.com, please refer to the Technical Documents.

Android Gateway, authorization and authentication solution for paid android applications

2011-04-13T23:59:00.002-04:00

Pretty busy to promote the new service site, AndroidGateway.com, the guards for paid Android Applications.

Throttle Postfix max proc to match Amazon SES max send rate

2011-03-15T10:13:00.000-04:00

By default Postfix will start up to 100 threads to send emails, but SES at the beginning only allows 1 email per second, the emails exceed the max send rate of SES may get lost. ( However I have never experienced any email lost yet, good to SES). It is a slow accumulation process to build up your MaxSendRate in SES. Here is a trick to throttle your Postfix to reduce the concurrent threads by change the config in master.cf from:

aws-email  unix  -       n       n       -       -       pipe

to:

aws-email  unix  -       n       n       -       5       pipe

Success migrate to Amazon Simple Email Service

2011-02-24T23:44:00.000-05:00

After couple of days implement, test and monitor, today I successfully migrate my site's SMTP from Gmail to Amazon Simple Email Service(SES). The first daily cron-job kicks in and sends out 1000 emails, hit the limitation of Amazon SES, has to wait for 3 days for Amazon to increase my sending quota and rate.

Basic step to install Postfix to relay email to Amazon SES

2011-02-24T09:41:00.003-05:00

For many users, this is all one needs to do to configure postfix on an SMTP gateway:

Install postfix from a binary package via your local package tool (rpm, etc.) or by compiling from source and running postfix's INSTALL.sh script.

Open /etc/postfix/main.cf with the text editor of your choice.

Uncomment and set the parameter myhostname to equal your server's fully qualified domain name (FQDN), e.g., “myhostname = james.whatever.com”.

Uncomment and set the parameter mydestination as follows, assuming this is the e-mail gateway for one's entire domain:

mydestination = $myhostname, localhost.$mydomain, $mydomain

Save and close main.cf.

If desired, add a line to /etc/aliases diverting root's mail to a less-privileged account, e.g., root: james. This is also the place to map aliases for users who are served by internal mail servers (for example, james.someone: james@whatever.whatever.com). When you are done editing and/or adding aliases, save the file and enter the command newaliases to convert it into a hash database.

Execute the command postfix start.

The most common invocations of the postfix command are postfix start, postfix stop and postfix reload. Start and stop are obvious; reload causes postfix to reload its configuration files without stopping and restarting. Another handy one is postfix flush, which forces postfix to immediately attempt to send all queued messages.

Security Tips:
In order to prevent giving out information that serves no purpose to legitimate external parties, it is wise to set in the main.cf file the parameter :

masquerade_domains = $mydomain

Setting the following in main.cf will ensure that only localhost can send emails:

inet_interfaces = localhost

To turn off unknown local recipient rejects by the SMTP server, specify:

/etc/postfix/main.cf:
    local_recipient_maps =

Setup Amazon SES to relay email by Grails/Java

2011-02-21T00:41:00.003-05:00

I used Gmail to send email to my users, but was suffering with Gmail restriction which allows max 500 emails per day.

After a couple of hours shot and tried, finally I got the PostFix relay through Amazon SES working seamlessly with Grails.

If you don't know what is Amazon SES, please google by yourself and follow the documentation how to apply for SES on Amazon portal.

Here are the detail steps.

1 Download scripts from http://aws.amazon.com/developertools/Amazon-SES

http://aws-catalog-download-files.s3.amazonaws.com/AmazonSES-2011-02-02.zip

2 Unzip the AmazonSES-2011-02-02.zip to /opt/thirdparty/amazon/bin (or create any folder as your like, but the user you use to execute scripts needs permission to get into the folder to call these scripts)

3 Chmod 755 for all *.pl files under /opt/thirdparty/amazon/bin

4 Create a new text file with the name of your choice—aws-credentials, for example.

Add the following lines ( your own access key and secret key) to this file:

AWSAccessKeyId=00000000000000

AWSSecretKey=xxxxxxxxxxxxxxxxxx

5 Install Perl ( by default, Linux already ship with the latest Perl)

6 Install the required Perl modules:

sudo apt-get install libio-socket-ssl-perl

sudo apt-get install libxml-libxml-perl

7 Verify email address with Amazon (change email to your designated email account)


cd /opt/thirdparty/amazon/bin
./ses-verify-email-address.pl -k aws-credentials -v user@example.com

8 List verified email addresses


./ses-verify-email-address.pl -k aws-credentials -l

9 Update the DNS records to add TXT records for your domain to prevent ISPs put your emails into SPAM.

v=spf1 include:amazonses.com ~all

spf2.0/pra include:amazonses.com ~all

10 Test sending email (use your verified email):


touch msgbody.txt  
## edit msgbody.txt
./ses-send-email.pl -k aws-credentials -s "Test of Amazon SES" -f user@example.com user@example.com < msgbody.txt

11 Check your email to verify the status

12 Once it works, go to this URL request for product access:

https://aws-portal.amazon.com/gp/aws/html-forms-controller/contactus/SESAccessRequest

13 Install PostFix as Satellite Mode


sudo apt-get install postfix
sudo dpkg-reconfigure postfix
 
  >General type of mail configuration: Satellite
  >NONE doesn't appear to be requested in current config
  >System mail name: server1.example.com
  >Root and postmaster mail recipient: <admin_user_name>
  >Other destinations for mail: server1.example.com, example.com, localhost.example.com, localhost
  >Force synchronous updates on mail queue?: No
  >Local networks: 127.0.0.0/8
  >Yes doesn't appear to be requested in current config
  >Mialbox size limit (bytes): 0
  >Local address extension character: +
  >Internet protocols to use: all

14 Modify the master.cf under /etc/postfix/ to add

aws-email  unix  -       n       n       -       -       pipe
  flags=R user=support argv=/opt/thirdparty/amazon/bin/ses-send-email.pl -r -k /opt/thirdparty/amazon/bin/aws-credentials -e https://email.us-east-1.amazonaws.com -f ${sender} ${recipient}
** There must be at least one white space in front of "flags=R"
** user should be your own user (not admin)

15 Modify the main.cf under /etc/postfix/ to add

default_transport = aws-email

16 cp SES.pm from /opt/thirdparty/amazon/bin to /user/local/lib/site_perl (if not existing, create one), this is important!

17

sudo /etc/init.d/postfix restart

18 Test postfix locally (use your verified email address)

sudo apt-get install mailutils
echo test | mail -s "test email sent" user@example.com 
// if the email can't be sent, you have to create a Linix account which is your verified SES username,ie, support, then use "su support" to send email
mailq  // Check the mail queue.

19 Verify the SES status

./ses-get-stats.pl -k aws-credentials -s
./ses-get-stats.pl -k aws-credentials -q

Ok, everything is running smoothly, now we can go to next section. Use Grails to send email through PostFix relay by Amazon SES.

Section Two:
Use Grails and Email plugin to send email
1 Install Grails ( I'm using Grails 1.3.5)

2 Install email plugin

grails install-plugin mail

3 Setup the email setting in Config.groovy

grails.mail.overrideAddress="user@example.com" // use your verified email
grails {
  mail {
    host = "localhost"
    port= 25
    props = ["mail.transport.protocol":"smtp",
      "mail.smtp.port":"25",
      "mail.smtp.host":"localhost"]
  } 
}

4 Write a simple code to send email, verify your email box is having that email. Bravo!

grails console

import org.codehaus.groovy.grails.commons.ApplicationHolder

import org.springframework.context.ApplicationContext

ApplicationContext ctx = (ApplicationContext)ApplicationHolder.getApplication().getMainContext()

def mailService = ctx.getBean('mailService')

mailService.sendMail {

    to 'user@example.com'

    subject 'Does this work? Oh Yeah!'

    body 'Sending email through Amazon SES is great.'

}

5 The beautiful thing is, you can manipulate the email "from address" in "grails.mail.overrideAddress", which means that you can have multiple Grails applications running on same server serving different domains (in my case) with multiple verified email accounts without setting up the virtual mail domains in PostFix.

Troubleshooting:
If the email is not received, verify the log under /var/log/mail.log or /var/log/mail.info to see what is going on.

Prepare for Amazon Simple Email Service (SES) on Ubuntu 10.10

2011-02-20T21:42:00.001-05:00

1. Download scripts from http://aws.amazon.com/developertools/Amazon-SES

http://aws-catalog-download-files.s3.amazonaws.com/AmazonSES-2011-02-02.zip

2. Create a new text file with the name of your choice, aws-credentials, for example.

Add the following lines ( your own access key and secret key) to this file:

AWSAccessKeyId=00000000000000

AWSSecretKey=xxxxxxxxxxxxxxxxxx

3. Install the required Perl modules:

sudo apt-get install libio-socket-ssl-perl

sudo apt-get install libxml-libxml-perl

4. Verify email address (use your email domain and account)

ses-verify-email-address.pl -k aws-credentials -v user@example.com

5. List verified email addresses

ses-verify-email-address.pl -k aws-credentials -l

6. Update the DNS records to add TXT records for your domain.

v=spf1 include:amazonses.com ~all

spf2.0/pra include:amazonses.com ~all

7. Test sending email:

ses-send-email.pl -k aws-credentials -s "Test of Amazon SES" -f user@example.com user@example.com < msgbody.txt

8. Once you are satisfied with SES, go to this URL request for product access:
https://aws-portal.amazon.com/gp/aws/html-forms-controller/contactus/SESAccessRequest

Groovy Meta Programming in Grails Plugin

2011-02-17T12:50:00.003-05:00

I was implementing a SEO plugin, the idea is inspired by Taggable plugin. The plugin is targeting to generate and automatically for each GSP page shows the domain object.

After a long research and test, I sort it out. In order to save someone else precise time, I share the code here:

The plugin create two dynamic methods in the domain class that has implemented a specific interface. A taglib will then invoke two new methods to get the property value from the domain instance and generate the tags in GSP.

Here is the magic part in the SEOGrailsPlugin.groovy.

def doWithDynamicMethods = { ctx ->
  for(domainClass in application.domainClasses) {
    if(SEOObject.class.isAssignableFrom(domainClass.clazz)) {
    // domainClass is the GrailsClass represents Content
      domainClass.clazz.metaClass {
        getSEOKeywords { ->
          def tags = delegate.getTags()
          return tags?.join(',')
        }
        getSEODescription { ->
          def caller = delegate   
            // Keep a caller reference, at this moment the delegate is the Content Instance which calls the getSEODescription closure
          if (!delegate.metaClass.'static'.defaultSEODesc){  
            // Check the caller has the static defaultSEODesc
            return ''
          } 
          def desc = delegate.defaultSEODesc   
            // Get the Content static defaultSEODesc value, could be a List or String
          def description = []
          if (desc instanceof List){
            desc.each { name ->
              if (domainClass.hasProperty(name)){ 
                // Verify the caller in this case is Content Class has the property 
                description << caller."${name}".encodeAsHTML()  
                  // get the property value from the actual Content instance
              }
            }
          } else {
            if (domainClass.hasProperty(desc)){
              description &lt;&lt; caller."${desc}".encodeAsHTML()
            }
          }
          return description.join(' | ')
        }
      }
    }
  }
}

I will be updating this post once I finish cleaning and testing.

Android Gateway is about to launch

2011-02-16T10:06:00.000-05:00

Android Gateway is an one-stop, two-phase authorization and authentication gateway for Android Paid Applications.

Using Grails Console to debug web application

2010-12-07T00:00:00.002-05:00

Basically, using this trick to make your web application debug in Grails much more easier.

import org.codehaus.groovy.grails.commons.ApplicationHolder

import org.springframework.context.ApplicationContext

ApplicationContext ctx = (ApplicationContext)ApplicationHolder.getApplication().getMainContext()

def productService = ctx.getBean('productService')

def newApps = productService.getNewProducts()

def updateApps = productService.getUpdatedProducts()

......

It supports auto reload, if changing the services, controllers, taglib classes, the console can load them automatically.

Enjoy

Using XDelta to incrementally deploy web application on Amazon EC2

2010-12-03T11:43:00.001-05:00

To deploy Java Web Application on Amazon Elastic Compute Cloud, the common practice is to use SCP to upload the whole Java War file and then move to application server deployment folder. If the War file includes lot of video, images and other third party libraries and the size over 100M or something, it is suffering and painful to wait 30 - 60 minutes for uploading such a file over DSL/Cable. It is not recommended to have a build environment in your production server, what should I do?

Here comes XDelta to rescue, yahoo!

XDelta3, (http://code.google.com/p/xdelta/) is a tool and library for differential compression. Xdelta release version 3 supports VCDIFF encoding and decoding. Supports compressing 64 bit files on Windows, Linux, etc. There are versions for Linux and Windows.

Depending on the changes between the two Wars, the difference is usually below 5% of the original War file if release iteration is short and quick.

How it works?

In your local development environment, after the War file built, says neighbour123-1.8.war, and a previous version of War is kept as neighbour123.ref.war,
run: xdelta3 -e -f -s -q neighbour123.ref.war neighbour123-1.8.war diff.bin

Upload the diff.bin by SCP to Amazon EC2, the file size is about 2 - 5 MB and takes only 1 - 2 minutes.

In the production server
run: xdelta3 -d -s -q neighbour123.ref.war diff.bin neighbour123-1.8.war

Here are the definitions for options:

-e           compress
  -d           decompress
-f           force overwrite
-q           be quiet
  -s source    source file to copy from (if any)

It is important to make sure the neighbour123.ref.war in two server environments are the same.

Building the difference by XDelta is extremely fast, it takes maximum 2 seconds on my P9600 CPU/4G Lenovo T400.

You can apply the same technique not only to Java Web Application deployment, buy also Rails on Ruby and Python, even PHP.

Enjoy.

--
To Live Instead Of Exist!

A new ERA starts

2010-11-02T10:48:00.001-04:00

Working for Online Banking Replatform for a bank. It is totally different and new experience to me. Have to pick up tones of technique heard but had never used before.

Painful but enjoyable.

Love the Groovy very much.

Spring Transaction Management

2010-11-02T10:45:00.000-04:00

How It Works
PlatformTransactionManageris a general interface for all Spring’s transaction managers.
Spring has several built-in implementations of this interface for use with different transaction
management APIs:
• If you have to deal with only a single data source in your application and access it with
JDBC, DataSourceTransactionManagershould meet your needs.
• If you are using JTA for transaction management on a Java EE application server, you
should use JtaTransactionManagerto look up a transaction from the application server.
• If you are using an object/relational mapping framework to access a database, you
should choose a corresponding transaction manager for this framework, such as
HibernateTransactionManagerand JpaTransactionManager.

Inserting TEXT into SYBASE

2010-10-28T14:00:00.002-04:00

The text datatype stores up to 2,147,483,647 bytes of printable characters on linked lists of separate data pages. Each page stores a maximum of 1800 bytes of data.

To save storage space, define text columns as NULL. When you initialize a text column with a non-null insert or update, Adaptive Server assigns a text pointer and allocates an entire 2K data page to hold the value.

You cannot use the text datatype:

For parameters to stored procedures, as values passed to these parameters, or for local variables
For parameters to remote procedure calls (RPCs)
In order by, compute, group by, or union clauses
In an index
In subqueries or joins
In a where clause, except with the keyword like
With the + concatenation operator

Inserting TEXT into SYBASE from SAS

TEXT data can only be inserted into a SYBASE table by using the BULK= data set option, as in the following example:

data yourlib.newtable(bulk=yes);
  set work.sasbigtext;
run;

If the BULK option is not used, you will receive the following error message:

ERROR: Object not found in database. Error Code: -2782
An untyped variable in the PREPARE statement 'S401bcf78'
is being resolved to a TEXT or IMAGE type.
This is illegal in a dynamic PREPARE statement.

The writetext command completely overwrites any data in the column it affects. The column must already contain a valid text pointer.

You can use the textvalid() function to check for a valid pointer:

select textvalid("blurbs.copy", textptr(copy)) from blurbs

There are two ways to create a text pointer:

insert actual data into the text, unitext, or image column
update the column with data or a NULL

There are two ways to create a text pointer:

insert actual data into the text, unitext, or image column
update the column with data or a NULL

An “initialized” text column uses 2K of storage, even to store a couple of words. Adaptive Server saves space by not initializing text columns when explicit or implicit null values are placed in text columns with insert. The following code fragment inserts a value with a null text pointer, checks for the existence of a text pointer, and then updates the blurbs table. Explanatory comments are embedded in the text:

/* Insert a value with a text pointer. This could
** be done in a separate batch session. */
insert blurbs (au_id) values ("267-41-2394")
/* Check for a valid pointer in an existing row.
** Use textvalid in a conditional clause; if no
** valid text pointer exists, update ’copy’ to null
** to initialize the pointer. */
if (select textvalid("blurbs.copy", textptr(copy))
    from blurbs
    where au_id = "267-41-2394") = 0
begin
    update blurbs
       set copy = NULL
       where au_id = "267-41-2394"
end
/*
** use writetext to insert the text into the
** column. The next statements put the text
** into the local variable @val, then writetext
** places the new text string into the row
** pointed to by @val. */
declare @val varbinary(16)
select @val = textptr(copy)
    from blurbs
    where au_id = "267-41-2394"
writetext blurbs.copy @val
    "This book is a must for true data junkies."

Top Ten Security Attack in Software Application

2010-09-20T13:46:00.001-04:00

The OWASP Top 10 Web Application Security Risks for 2010 are:

A1: Injection
A2: Cross-Site Scripting (XSS)
A3: Broken Authentication and Session Management
A4: Insecure Direct Object References
A5: Cross-Site Request Forgery (CSRF)
A6: Security Misconfiguration
A7: Insecure Cryptographic Storage
A8: Failure to Restrict URL Access
A9: Insufficient Transport Layer Protection
A10: Unvalidated Redirects and Forwards

--
To Live Instead Of Exist!

Special XML attacks

2010-09-20T13:45:00.000-04:00

Special XML attacks

XML messages have a few intrinsic weakness, that Web Service creators should know about. None of these problems are unique to SOAP; anyone processing incoming XML needs to know and resist these.

Large XML Documents
Have a client post an XML doc of extreme length/depth <foo><foo><foo>...</foo></foo></foo> This does bad things to DOM parsers and memory consumption on the server: a DoS attack. The issue here is that the costs of handling a large XML document are much greater than the cost of generating one.
Entity Expansion Attacks.
If an XML doc header declares some recursive entity declarations, and the file refers to them, then bad things happen. Axis became immune to this between versions 1.0 and 1.1.
Entities referring to the filesystem.
Here you declare an entity referring to a local file, then expand it. Result: you may be able to probe for files, perhaps even get a copy of it in the error response. As Axis does not support entities any more, it resists this. If your code has any way of resolving URLs from incoming messages, you may recreate this problem.

The other thing to know about XML is that string matching is not enough to be sure that the content is safe, because of the many ways to reformat the same XML.

--
To Live Instead Of Exist!

Use CSS3 and HTML 5 to create sticky note

2010-09-09T11:19:00.000-04:00

Here are the sample

http://nettuts.s3.amazonaws.com/771_sticky/step1.html

--
To Live Instead Of Exist!

JSR 168 VS JSR 286

2010-09-08T17:43:00.001-04:00

JSR-168 – What is missing?

inter-portlet communication, only supported within the same portlet application using session attributes
portlet filters
target portlets will only "see" messages during next render request
portlets cannot (should not) update their state during a render request: "event" handling not really possible
A portlet can only render html fragments
Have to fallback/delegate to the servlet container
Requires coordination between portlet and servlet
javascript or css can only be embedded withing the content markup; no body onLoad handling hooks
API forbids adding cookies: only client side setting of cookies using javascript is possible
Most web frameworks are Servlet API only
Servlet dispatching not supported from processAction
Needs Portals Bridges or similar solutions
JSTL support very limited

JSR-286

Binary compatible with JSR-168
Alignment with J2EE 1.4, WSRP 2.0
Portlet coordination
Public render parameters
Shared session state across applications (maybe)
Portlet events
Resource serving
AJAX support
Portlet filters
Extended cache support
Improved support for common web frameworks

Is Google So Call "OPEN"?

2010-09-06T15:32:00.001-04:00

话说我们团队的作品 RockPlayer for android 在 Android Market 上正式发布有 1 个半月了, 算是我王婆卖瓜吧, 来自全球各地的反响还是很不错的. 我们也正在很努力地做进一步的完善和增强, 希望能够进一步地提供更多的功能和更好的性能. 可是, 我们的努力, 由于 Google 在 android market 上的行为, 很可能成为泡影, 至少, 也会是一个非常严重的打击吧.

8 月中旬的某天, 有用户反映在 Market 上找不到 RockPlayer 的 ARMv7 和 ARMv6+VFP 的版本了, 我们赶紧连上 market 一看究竟, 发现这两个版本已经被标记为 suspended 了. 我们的第一感觉是很莫名其妙, 不知道什么原因使得 Google 把这两个版本 suspend 了. 还有剩下的一个版本还在, 用户还能从 Market 下载. 于是我们一方面告知用户需要其余版本的请到网站进行下载, 另一方面积极地想办法寻找与 Google 沟通的方式. 无奈的是, 无论我们通过什么样的途径向 Google 询问 RockPlayer 为啥被 suspend 的原因, 始终得不到任何回答. 同时, 通过在 Internet 上的搜索发现, 象我们一样, 被 suspend 了却得不到任何回应的开发者还有很多. 甚至, 在 Internet 都找不到任何一个 Google 对此类事件有回应的实例!

事情还没完. 今天早上一起来, 发现连剩下的那个都被 suspend 了. 同样是没有任何说明!

Google, 你不是很 open 吗? 你不是就打着 open 的旗号来跟 iPhone 抗衡吗? 但至少, AppStore 拒绝我的应用会给我一个理由, 让我可以修改了之后重新提交. 而你呢? 连个理由都不给, 并且对询问没有任何回应. 这难道就叫 open 吗? 这难道是一个口口声声要号称赶超 AppStore 的 Market 应该干的事吗? 不管 AppStore 是如何独断 – Google 还常拿这个来攻击 AppStore 并号称自己不作监管 – 至少, 对于与开发者的沟通来说, 远远好于这个号称 open 的 android market!

如果 Google 继续这么做, 那么, 对不起, Android Market 永远都赶不上 AppStore 的.

最后还需要说明的是: 我们不会放弃, 会继续进行版本更新, 同时也会以积极的态度去继续试图跟 Google 沟通. 毕竟, market 如果能变得更好一点, 无论对开发者还是用户, 都是一件好事.

OI Notepad | Android Application Online

2010-07-28T17:27:00.000-04:00

OI Notepad | Android Application Online

Very productive. Developed a lot excellent Android applications.

Use JNDI datasource for MySQL in Grails and Tomcat 6.0

2010-07-27T22:06:00.008-04:00

The dataSource for MySQL is always experiencing broken pipe issue, although set the autoReconnect=true, and tune the C3P0 connection pool properties does not help.
Spent a few hours and finally made JNDI datasource for MySQL in Grails 1.3.2 and Tomcat 6.0 to work. ( There were couple of threads and comments you can find by Google, but there were mistakes here and there).

Here are the detail:

In DataSource.groovy, remove datasource section, keep the hibernate section as:

hibernate {

    dialect='org.hibernate.dialect.MySQL5Dialect' // Mandatory

    cache.use_second_level_cache=true

    cache.use_query_cache=true

    cache.provider_class='org.hibernate.cache.EhCacheProvider'

}

and in the "Production" section:

production {

    dataSource {

        dbCreate = "update"

        pooled = false

        jndiName = "java:comp/env/jdbc/YOUR JNDI NAME"

    }

}

If you need to work on development without datasource, here are the code:

development {

    dataSource {

        url = "jdbc:mysql://127.0.0.1:3306/DATABASENAME?useUnicode=true&amp;characterEncoding=UTF-8"       

        dbCreate =  "update"  // one of 'create', 'create-drop','update'   

        username = "root"

        password = "xxxxxxxxxxxxx"   

        driverClassName = "com.mysql.jdbc.Driver"

    }

}

If you are using "/" as your context, the context file for Tomcat will be under $TOMCAT_HOME/conf/Catalina/YOURSERVERNAME/ROOT.xml, otherwise it will be $TOMCAT_HOME/conf/Catalina/yourcontext.xml or your META-INF/context.xml under your GRAILS project.

Edit the context.xml to be something like this:

<context>

    <resource auth="Container" driverclassname="com.mysql.jdbc.Driver"

        maxactive="100" maxidle="30" maxwait="10000" name="jdbc/YOURJNDINAME"

        password="javadude" removeabandoned="true" removeabandonedtimeout="60"

        type="javax.sql.DataSource"

        url="jdbc:mysql://127.0.0.1:3306/DATABASENAME?useUnicode=true&amp;characterEncoding=UTF-8"

        username="javauser" validationquery="SELECT 1;"></resource>

</context>

It is not necessary to create the resource reference in the Web.xml by creating a _Events.groovy under GRAILS project script folder, otherwise it will prompts lobException if BLOB/CLOB has been used in the domain classes

The underlying code in _Events.groovy are not necessary:

//import groovy.xml.StreamingMarkupBuilder

//

//import grails.util.*

//import groovy.util.*

//

//eventWebXmlEnd = {String tmpfile -&gt;

//    println 'Start to twist the web.xml file =======================&gt;'

//    if (GrailsUtil.environment == 'production') {

//        def root = new XmlSlurper().parse(webXmlFile)

//

//        // add the data source

//        root.appendNode {

//            'resource-ref'{

//                'description'('The Andapponline Database resource')

//                'res-ref-name'('jdbc/DATABASENAME')

//                'res-type'('javax.sql.DataSource')

//                'res-auth'('Container')

//            }

//        }

//

//        webXmlFile.text = new StreamingMarkupBuilder().bind {

//            mkp.declareNamespace("": "http://java.sun.com/xml/ns/j2ee")

//            mkp.yield(root)

//        }

//    }

//}

The last step, copy the mysql connectorJ jar file to $TOMCAT_HOME/lib.

All Set.

Help your neighbors, help yourself, visit http://www.neighbour123.com
Looking for Android applications for your hand-held? Get them from http://www.andapponline.com

Reuse, recycle, reciprocal. Save environment, save the planet.

2010-06-06T23:06:00.003-04:00

http://www.neighbour123.com is a Location Base Service (LBS) Web 2.0 platform for neighbors to publish free classified information, share with each other for stuff, labor, service, event, etc. By posting what you want or what you can offer, spare things in the garage can be made use for the people who need them indeed.

Reuse, recycle, reciprocal. Save environment, save the planet.

Everybody can help, help yourself, help your neighbors.

Performance optimization

2010-06-05T01:30:00.001-04:00

Neighbour123.com, performance optimization result:

Performance overview

On average, pages in your site take 0.9 seconds to load (updated on Jun 2, 2010). This is faster than 92% of sites. These estimates are of medium accuracy (between 100 and 1000 data points).

Neighbour123.com is a Location Base Service (LBS) Web 2.0 platform for neighbors to share with each other for stuff, labor, service, event, etc. By posting what you want or what you can offer, as well as some spare things in your garage, you can save serious cash by borrowing from your neighbors, helping from your neighbors or you can earn easy cash for yourself.

Everybody can help, help yourself, help your neighbors.

Welcome to Android Application Online

2010-05-10T22:02:00.001-04:00

Dear Chinese Android Application Developers,

This is James and David, entrepreneurs of Android Application Online (http://www.andapponline.com). We would like to invite you to host your application on our web site, Android Application Online (http://www.andapponline.com)

We are Android Application Online, a quick growth start-up company based on Toronto, Ontario, Canada. We are new, fast and aggressive. We are tech savvy, we love technology. We are gearing toward Android phone users who are looking to fill their mobile devices with QUALITY software. With the constantly growing amount of visitors and contributors of the project, we set our mission to provide Android phone users and developers with the best centralized collection of quality mobile software resources in the most convenient fashion.

Why developers want to publish their applications to our site?

1) Marketing: we are aggressively marketing our site; help them to reach specific interest groups. They can leverage our marketing power to extend their applications reach.

2) Connecting them with a boarder user base – we will fine users for developers and feed developers with ideas and usability feedback.

3) Connecting them with developers community – discuss and share technologies and experience.

4) Fee: free for developers to publish apps for now. Take advantage of the current promotion.

5) Management function: Functions for developers to manage their applications, updates and order history.

6) Service: Translation - help and partner with them to translate the product into different languages.

We are looking forward to hear from you and we are hoping us all together, with our Win-Win-Win strategy, to achieve all success.

Should you agree, you can follow the link Developer Registration, or copy the URL http://www.andapponline.com/developer/register to your browser, and follow a simple 2 minutes create-activate-publish process, you can have your application published and host on Android Application Online and it is absolutely FREE.

Here are some information for you reference:

About Us: http://www.andapponline.com/company/about
Term of Use: http://www.andapponline.com/company/termOfUse
Privacy Policy: http://www.andapponline.com/company/policy

We can be reached by support@andapponline.com, if you have any questions, please do not hesitate to contact us.

Yours sincerely,

James & David

Entrepreneurs, Android Application Online
Web Site: http://www.andapponline.com

Netwiser @ RISGuru: Neighbor123.com

2010-05-04T16:53:00.000-04:00

Netwiser @ RISGuru: Neighbor123.com

Neighbor123.com

2010-05-04T16:51:00.001-04:00

Add deal maker in cron job using quatz plug in
Redefine the email templates for new response and deal
Organize images into single image
Add inactivate user filter
Enforce SEO
Disable delivery in response
Restructure category
Add images to each category
change the home icon in show request after finish the creation
Change the related post to related wanted and related offer
In deal making, provide list of possibilities, best and worst option
In deal making, provide list of reply
Change reply to wanted or offered.
Add message to response as well

Welcome to neighbor123.com, http://www.neighbor123.com, help your neighbors, help yourself.

Andapponline.com has deployed a new release with enhancement and bug fixes.

2010-04-22T23:41:00.000-04:00

Andapponline.com has deployed a new release with enhancement and bug fixes.

Android Application Online - Welcome to Android Application Store

Android Application Online, dedicated Android application platform and store, for Android developers to publish, host and sell and for Android end-users to purchase and download Android Applications

Android application online performance boost

2010-03-05T16:32:00.001-05:00

March 5, 2010 by netwiser

Android application online is releasing her version1.5. After a series
of serious optimization and enhancement including UI optimization,
caching, pooling, multiple-threading, asynchronous processing,
compressing, code refactoring and polishing, the performance has a
significant boost, from 1.0 release average 15.2 seconds page load to
now 1.91 seconds(benchmark by google) on the same hardware resources.
Plus, lot of new web 2.0 technologies are in place.

I am glad to see that within 2 months after lauch, the visitor and
page view per day raise up from 0 to now 50 visitors and 3000 page
views per day. Lot of nice developers have published their android
applications on site, also, they deliver constructive helpful idea and
opinion to improve the site.
Wanna check it out? Http://www.andapponline.com.

New features such as Android client, mobile version, jquery ui/flash
ui and web service Apis are rolling out for development, sit tight,
you will see more and more amazing…

Your opinion is highly appreciated.

James Zhang
Entrepreneur, Android application online

Http://www.andapponline.com

Gopalgo, Your neighborhood expert!

2010-02-12T17:00:00.003-05:00

I am working on a new site, Gopalgo, the neighborhood expert.

This new site is targeting at everything around neighbor, tools, services, events, planning, fun, media, lost and found, etc, that you can find it will be handy for you in your daily routine.

For instance, if you have transportation capacity and would like to help other person nearby, you can post your carpool information easily and wait for someone to give you a sound...

This site is expected to launch in March, sit tight and see.

Android application online release 1.2

2010-02-11T12:52:00.001-05:00

<a href="http://www.andapponline.com">Android Application Online</a>
now is 1.2. We are expecting to implement lot more management
functions for developers in next release.

Android application online, your dedicated Android application market.

Android Applications Online

2009-12-13T08:37:00.002-05:00

I am glad to find that Android Application Online is ready to launch. It is targeting to provide dedicated platform for Android Application Developers and Users to publish, version, download, purchase and subscribe Applications running on Android hand-held devices. It is also targeting to establishing a social community for Android Application Developers and Users to share, exchange and brainstorming ideas in developing brilliant Android Applications.

Here is our Android Application Online : http://www.andapponline.com

Grab from Groovy

2009-06-19T11:10:00.001-04:00

Imagine you want to get the links of all the PDF documents referenced by the Java 5 documentation. You want to parse the HTML page as if it were an XML-compliant document (which it is not) with the Groovy XmlParser, so you can use the TagSoup SAX-compliant parser which transforms HTML into well-formed valid XML. You don't even have to mess up with your classpath when running your script, just grab the TagSoup library through Grape:

import org.ccil.cowan.tagsoup.Parser


// find the PDF links in the Java 1.5.0 documentation
@Grab(group='org.ccil.cowan.tagsoup', module='tagsoup', version='0.9.7')
def getHtml() {
     def tagsoupParser = new Parser()
    def parser = new XmlParser(tagsoupParser)
    parser.parse("http://java.sun.com/j2se/1.5.0/download-pdf.html")
 }

html.body.'**'.a.@href.grep(~/.*\.pdf/).each{ println it }

--
To Live Instead Of Exist!

Groovy 1.6 Mixin

2009-06-18T12:28:00.001-04:00

Now, pair @Category extensions to the @Mixin transformation, and you can mix in various behavior in a class, with an approach similar to multiple inheritance:

@Category(Vehicle) class FlyingAbility {
    def fly() { "I'm the ${name} and I fly!" }
}


@Category(Vehicle) class DivingAbility {
    def dive() { "I'm the ${name} and I dive!" }
 }


interface Vehicle {
    String getName()
}


@Mixin(DivingAbility)
class Submarine implements Vehicle {
    String getName() { "Yellow Submarine" }
}
 

@Mixin(FlyingAbility)
class Plane implements Vehicle {
    String getName() { "Concorde" }
}


@Mixin([DivingAbility, FlyingAbility])
class JamesBondVehicle implements Vehicle {
     String getName() { "James Bond's vehicle" }
}


assert new Plane().fly() ==
       "I'm the Concorde and I fly!"
assert new Submarine().dive() ==
        "I'm the Yellow Submarine and I dive!"


assert new JamesBondVehicle().fly() ==
       "I'm the James Bond's vehicle and I fly!"
assert new JamesBondVehicle().dive() ==
        "I'm the James Bond's vehicle and I dive!"

You don't inherit from various interfaces and inject the same behavior in each subclass, instead you mixin the categories into your class. Here, our marvelous James Bond vehicle gets the flying and diving capabilities through mixins.

--
To Live Instead Of Exist!

Grails GORM Validation

2009-04-21T09:56:00.001-04:00

Page Validation Reference

Edited by ackounts. View change

Domain Class Validation

#Example
#Reference

Example

class User {
    String login
   String password
   static constraints = {
          login(size:5..15,blank:false,unique:true)
           password(size:5..15,blank:false)
   }
}

In the reference that follows, className.propertyName.validationConstraint refers to the error message codes defined in _grails-app/i18n/message.properties_.

For example, referring to the above class, the error message might be defined as: _user.login.blank=Please enter a login_

{_}Since 0.5. You could use common pattern "className.propertyName.constraintName.error" for all constraints, example: "user.login.blank.error=Please enter a login"._

Validation Constraint Reference

blank

Usage: set to false if a string value cannot be blank
Note: an empty form field will appear in the request parameters as an empty string, not as null. Keep this in mind when setting domain fields directly form request parameters
Example:

login(blank:false)

Error message code: className.propertyName.blank

creditCard

Usage: set to true if a string should be a credit card number Example:

cardNumber(creditCard:true)

Error message code: className.propertyName.creditCard.invalid

email

Usage: set to true if a string value is an email address Example:

contactEmail(email:true)

Error message code: className.propertyName.email.invalid

password

Usage: set to true if a string value is a password Example:

password(password:true)

Error message code: className.propertyName.password.invalid

inList

Usage: constrains a value so that it must be contained within the given list Example 1:

name(inList:["Joe", "Fred", "Bob"] )

Example 2:

name(inList:[1 as Short, 2 as Short, 3 as Short] ) // Short could be switched to Double etc

Error message code: className.propertyName.not.inList

This constraint influences schema generation.

length

{color:red}Deprecated in 0.4. Removed in 0.5. Use{color} {color:red}#size{color} {color:red}instead.{color}

Usage: Uses a Groovy range to restrict the length of a string or array Example:

login(length:5..15)

Error message code: className.propertyName.length.toolong, className.propertyName.length.tooshort

This constraint influences schema generation.

matches

Usage: Applies a regular expression against a string value Example:

login(matches:"[a-zA-Z]+")

Error message code: className.propertyName.matches.invalid

max

Usage: sets the maximum value of a class that implements java.lang.Comparable. The same type needs to be used as the property itself. Example:

age(max:new Date())
price(max:999F)

Error message code: className.propertyName.max.exceeded

This constraint influences schema generation.

maxLength

{color:red}Deprecated in 0.4. Removed in 0.5. Use{color} {color:red}#maxSize{color} {color:red}instead.{color}

Usage: sets the maximum length of a string or array property Example:

login(maxLength:5)

Error message code: className.propertyName.maxLength.exceeded

This constraint influences schema generation.

maxSize

Usage: sets the maximum size of a collection or number property

{color:red}Deprecated in 0.5 for number properties. Use{color} {color:red}#max{color} {color:red}instead{color}

Example:

children(maxSize:25)

Error message code: className.propertyName.maxSize.exceeded

This constraint influences schema generation.

min

Usage: sets the minimum value of a class that implements java.lang.Comparable. The same type needs to be used as the property itself. Example:

age(min:new Date())
price(min:0F) // or price(min:0.0 as Double)

Error message code: className.propertyName.min.notmet

This constraint influences schema generation.

minLength

{color:red}Deprecated in 0.4. Removed in 0.5. Use{color} {color:red}#minSize{color} {color:red}instead.{color}

Usage: sets the minimum length of a string or array property Example:

login(minLength:5)

Error message code: className.propertyName.minLength.notmet

This constraint influences schema generation.

minSize

Usage: sets the minimum size of a collection or number property

{color:red}Deprecated in 0.5 for number properties. Use{color} {color:red}#min{color} {color:red}instead{color}

Example:

children(minSize:5)

Error message code: className.propertyName.minSize.notmet

This constraint influences schema generation.

notEqual

Usage: validates that a property is not equal to the specified value Example:

login(notEqual:"Bob")

Error message code: className.propertyName.notEqual

nullable

Usage: set to false if the property value cannot be null
Note: an empty form field will appear in the request parameters as an empty string, not as null. Keep this in mind when setting domain fields directly form request parameters
Example:

age(nullable:true)

Error message code: className.propertyName.nullable

Default: By default, all fields are not nullable (required).

range

Usage: Uses a Groovy range to ensure that a property's value occurs within a specified range Example:

age(range:minAge..maxAge)

Error message code: className.propertyName.range.toosmall or className.propertyName.range.toobig

This constraint influences schema generation.

scale

_Since: 0.4_ Usage: Set to the desired scale for floating point numbers (i.e., the number of digits to the right of the decimal point). This constraint is applicable for properties of the following types: java.lang.Float, java.lang.Double, and java.math.BigDecimal (and its subclasses). When validation is invoked, this constraint determines if the number includes more nonzero decimal places than the scale permits. If so, it automatically rounds the number to the maximum number of decimal places allowed by the scale. This constraint does not generate validation error messages. Example:

salary(scale:2)

Error message code: N/A

This constraint influences schema generation.

size

Usage: Uses a Groovy range to restrict the size of a collection or number or the length of a String

{color:red}Deprecated in 0.5 for{color} {color:red}{}number{}{color} {color:red}properties. Use{color} {color:red}#range{color} {color:red}instead{color}

Example:

children(size:5..15)

Note: currently it could not be used in addition to blank:true or nullable:true contraints, a custom validator may be added to perform this kind of constraints (if not null then...)

Error message code: className.propertyName.size.toosmall or className.propertyName.size.toobig

This constraint influences schema generation.

unique

Usage: set to true if the property must be unique (this is a persistent call and will query the database) Example:

login(unique:true)

Note: be aware that it's possible (though uncommon in practice) for a uniqueness constraint validation to pass but a subsequent save of the data to fail due to a uniqueness constraint enforced at the database level. The only way to prevent this would be to use the SERIALIZABLE transaction isolation level (bad for performance) or just be prepared to get an exception to this effect at some point. [{}Since 0.5] Scope of unique constraint can be specified. "Scope" - is a name of another property of the same class, or list of such names. Semantic in these cases is: pair of constrained property value and scope property value must be unique (or combination of constrained property value and all scope property values must be unique).

Example:

group(unique:'department')

In the above example group name must be unique in one department but there might be groups with same name in different departments.

Another example:

login(unique:['group','department'])

In this example login must be unique in group and department. There might be same logins in different groups or different departments.

Error message code: className.propertyName.unique

url

Usage: set to true if a string value is a URL address Example:

homePage(url:true)

Error message code: className.propertyName.url.invalid

validator

Usage: set to a Closure to use custom validation. A single or no parameter Closure receives the value, a two-parameter Closure receives the value and object reference.

Since 0.5.5 a three-parameter Closure receives the value, object reference and the errors object.

The closure can return:

null or true to indicate that the value is valid
false to indicate an invalid value and use the default message code
a string to indicate the error code to append to the "classname.propertName." string to display an error
a list containing a string as above, and then any number of arguments following it, which can be used as formatted message arguments indexed at 3 onwards. See grails-app/i18n/message.properties to see how the default error message codes use the arguments.

If the closure is a three-parameter closure the return value is ignored and the closure is expected to populate the errors object.

Examples:

even( validator: {
   return (it % 2) == 0
})password1( validator: {
   val, obj ->
      obj.properties['password2'] == val
 })
magicNumber( validator:
   someClosureWithTwoParameters)
// This one assumes you have an error message defined like:
// classname.propertyName.custom.error=My error shows arguments {3} and {4} for value {0}
 otherProperty( validator: { return ['custom.error', arg1, arg2] } )
// The following example does not use custom validation.
// A custom message may be defined in messages.properties:
 // user.login.blank=Please enter a login
// which will be used instead of default.blank.message
class User {
    String login
    static constraints = {
         login(blank:false)
    }
}
// In the following example, custom validation is used:
// user.login.validator.invalid=Please enter a login
class User {
    String login
    static constraints = {
        login(validator: {
            return (it.length != 0)
     	})
    }
}
// The following might define the error message as:
// user.login.invalid.bountyhunter=Invalid bounty hunter ({2}) tried to log in.  (Class name = {1}.  Property name = {0})
 class User {
    String login
    static constraints = {
        login(validator: {
            if (!it.startsWith('boba')) return ['invalid.bountyhunter']
         })
    }
}

Error message code (default): className.propertyName.validator.invalid

For custom error messages, you can also return a custom value to be displayed in the error message. This is usually parameter number 3.

For instance, in messages.properties: source.reportName.invalid=For source type {3}, report name must be specified.

And in the custom validator:

reportName(maxSize:255, nullable: true, validator: { val, obj ->
  if(obj.reportName == null && (obj.sourceName == 'Buddecom Report')){
       return ['source.reportName.invalid', obj.sourceName]
  }	        
})

--
To Live Instead Of Exist!

Happy New Year

2008-12-31T21:50:00.001-05:00

Happy New Year to All,

Wish 2009 is a better year, no more recession.

All the Bests,

James

--
To Live Instead Of Exist!

XA Exception in WAS 6.0

2008-12-22T12:38:00.001-05:00

Exception:
Implementation class name of "Oracle JDBC Driver" : oracle.jdbc.xa.client.OracleXADataSource

DSRA0304E: XAException occurred. XAException contents and details are: The cause is : null.
DSRA0302E: XAException occurred. Error code is: XAER_RMERR (-3). Exception is: <null>
WTRN0037W: The transaction service encountered an error on an xa_recover operation. The resource was com.ibm.ws.rsadapter.spi.WSRdbXaResourceImpl@29bdd791. The error code was XAER_RMERR. The exception stack trace follows: javax.transaction.xa.XAException
at oracle.jdbc.xa.OracleXAResource.recover(OracleXAResource.java(Compiled Code))
at com.ibm.ws.rsadapter.spi.WSRdbXaResourceImpl.recover(WSRdbXaResourceImpl.java(Compiled Code))
at com.ibm.ws.Transaction.JTA.XARminst.recover(XARminst.java(Compiled Code))
at com.ibm.ws.Transaction.JTA.XARecoveryData.recover(XARecoveryData.java(Compiled Code))
at com.ibm.ws.Transaction.JTA.PartnerLogTable.recover(PartnerLogTable.java(Compiled Code))
at com.ibm.ws.Transaction.JTA.RecoveryManager.resync(RecoveryManager.java(Compiled Code))
at com.ibm.ws.Transaction.JTA.RecoveryManager.run(RecoveryManager.java:2394)
at java.lang.Thread.run(Thread.java:570)

Solution:
The application server is trying to recover certain transactions that were in prepared state or heuristically complete. Typically these transactions were not committed/rollbacked when the application server crashed. So as a part of startup, the application server tries to recover these transactions. Unfortunately the transaction are no longer available as the datasource has taken a heuristic decision to commit/rollback.

The only way to fix this is to search for log files named trans*.log and delete them. Basically, these log files are under \profiles\AppSrv01\tranlog.

Reference:

http://www.ibm.com/developerworks/websphere/library/techarticles/0407_woolf/0407_woolf.html

--
To Live Instead Of Exist!

SOA Definition

2008-10-03T14:25:00.001-04:00

A service-oriented architecture is a framework for integrating business processes and supporting IT infrastructure as secure, standardized components—services—that can be reused and combined to address changing business priorities.

Using Groovy and Google Maps API to calculate distance

2008-08-28T11:07:00.001-04:00

package com.risguru.gopalgo.utility

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.UsernamePasswordCredentials;
import org.apache.commons.httpclient.methods.GetMethod;

import static java.lang.Math.*

public class CoordinatesHelper{

    private static final String KEY = '---KEY---'
    private static final String URL = 'http://maps.google.com/maps/geo?key=' + KEY + '&output=csv&q='
    private static final double FACTOR = 60 * 1.1515 * 1.609344

    def static getCoordinates(postalCode) {
        def client = new HttpClient()
        def get = new GetMethod(URL + postalCode)
        get.setRequestHeader("Accept", "text/xml")
        client.executeMethod(get)
        if (get.getStatusCode() != 200){
            // Do something here
            return null
        }
        def string = get.getResponseBodyAsString()
        def stringArray = string.split(',')
        return ['Lat':stringArray[2], 'Lng':stringArray[3]]
    }


    def static calculateDistance(dist1, dist2){
        def kms = toDegrees(acos(sin(toRadians(dist1['Lat'])) * sin(toRadians(dist2['Lat'])) +
                cos(toRadians(dist1['Lat'])) * cos(toRadians(dist2['Lat'])) *
                cos(toRadians(dist1['Lng'] - dist2['Lng'])))) * FACTOR
    }
}

--
To Live Instead Of Exist!

Groovy Inject closure

2008-07-28T17:02:00.001-04:00

lst = ['Programming' , 'In' , 'Groovy' ]

println lst.inject(0) { carryOver, element -> carryOver + element.size() }

inject( ) calls the closure for each element of the collection. The element is represented, in this example, by the element parameter. inject( ) takes as a parameter an initial value that it will inject, through the carryOver parameter, into the first call to the closure. It then injects the result from the closure into the subsequent call to the closure. You'll prefer the inject( ) method over the collect( ) method if you want a cumulative result of applying a computation on each element of a collection.

--
To Live Instead Of Exist!

Five Things You Should Never Tell Your Boss

2008-07-08T11:13:00.001-04:00

Five Things You Should Never Tell Your Boss

There are some things your CIO definitely doesn't want to hear.

Mary K. Pratt

June 20, 2008

In the information biz, more isn't necessarily better. Though full disclosure and transparency are buzzwords today, that doesn't mean your boss wants to hear about everything going on in the office. In fact, there are some things your CIO definitely doesn't want to hear, and if your career is going to thrive, you'd better know what they are.

We asked a group of Computerworld's 2008 Premier 100 IT Leaders to talk about the kinds of messages they never want to hear from their staffers. Here's what they said.

1. All about the technology -- and nothing about the business. Acting like the business is terra incognita is a no-no. "Never tell me you don't know what the business wants but you'll build it when they decide," says James E. Schinski, CIO and vice president of Midwest Independent Transmission System Operator in Carmel, Ind.

Joseph J. Tufano,vice president and CIO at St. John's University in New York, agrees, saying IT workers need to tell him how technology can help the organization and its staff do their jobs better. "You bring so much more credibility to the discussion when you're presenting technology in the context of business," he says.

2. There's only one solution. "People can sometimes develop a fondness for a certain technology or programming language or manufacturer into almost a religion, but it's never the case that one type of solution is the proper one for all situations," says Neal Puff, CIO for Arizona's Yuma County. "And when you develop an attitude like this, you're viewed as an obstacle or a roadblock. People will assume you're just going to like it this way and you're not going to like it any other way."

3. Bad opinions about your colleagues. It's a simple rule that can get overlooked when your team is struggling with a missed deadline or a failing project, but think before you point a finger, because bosses generally don't want to hear about it -- especially if you haven't tried to work it out on your own.

"I want a team that works together and not one that's political, and if I see it happening, then I think people are trying to score points," says Kumud Kalia, CIO and executive vice president of customer operations for Toronto-based Direct Energy, an integrated energy company and part of Centrica PLC.

Of course, there are times when you need to discuss personnel issues with your boss. For example, Kalia wants to know from managers when workers are thinking of leaving. Just be sure the boss really needs to know about the situation; then be discreet and objective.

Editor's Note: When it comes to talking with the boss, knowing what to say, when to say it and how to put it can still be tricky for some people. Learn how the person in charge can encourage the right conversations in the office.

4. There's no way. Robert Strickland, senior vice president and CIO of T-Mobile USA Inc. in Bellevue, Wash., makes his position very clear: Everything is possible.

"It may be impossible to deliver the exact goal, or it may be impossible to deliver the goal in the way it has been outlined, but before you say it is impossible, tell me some of the challenges you may face, and we can have a conversation about overcoming those challenges," he says. "You may be surprised by what you can accomplish if you let go of your biases."

5. A surprise. CIOs almost universally say they don't like surprises -- particularly unpleasant ones. Ian S. Patterson, CIO at Scottrade Inc., a St. Louis-based online brokerage firm, says he always prefers to hear news -- good and bad -- directly from his workers. So when someone comes by and starts with "I want to give you a heads up," it really catches his attention.

Moreover, it's a good bet that your boss prefers to hear that news sooner rather than later, says Gregory B. Morrison, CIO of Cox Enterprises Inc., an Atlanta-based media company and provider of automotive services. "Getting help early could help keep a small problem from turning into a disaster," he says.

--
To Live Instead Of Exist!

生活妙招：蚂蚁怕酸蚊子怕辣蟑螂怕香

2008-06-11T00:02:00.001-04:00

蚂蚁怕酸味？

家里的甜食摆没几分钟，蚂蚁大军立即来袭，让人又气又厌！

献给各位一项无毒无污染又安全有效的妙招――整粒的新鲜柠檬，对切成两半，在看得到蚂蚁的地方及其动线，挤出柠檬汁，并拿着切半有果肉的那一面，沿途涂抹，神奇效果让您再一次验证大自然的奥妙！

蚊子怕辣味？

院子百花争艳，诱使人们常流连其中不忍离去，然而花多蚊子也多，叮咬得肿包累累。

将蒜头分植于花坛四周，其特殊的辛辣味隐隐飘散。令人讶异的是，平日凶猛的蚊子不见了，连下雨过后会出现的超大只蚊子，也销声匿迹了！所以，驱蚊除了打扫环境、清除枯枝烂叶，试植蒜头绝对是上上之策！

蟑螂怕香味？

神出鬼没的蟑螂，最爱隐身于掌管厨房里。面对"打不死的蟑螂"，办法是，将一块浴用香皂切成数小块，置于容器内注入清水，摆放在蟑螂出没的橱柜内，不出数日，打开橱柜将令您讶异于蟑螂的无影无踪，橱柜内还多了怡人的香味。想要效果持续，仅须定期补充香皂容器内的清水。

--
To Live Instead Of Exist!

com.ibm.jsse2.util.h: No trusted certificate found.

2007-11-22T14:28:00.001-05:00

In Portal Server 6.0, start the portal server from RSA 7 with RMI/ORB
connector, the portal server will prompt back an exception

com.ibm.jsse2.util.h: No trusted certificate found.

Anyway, the solution to my problem was to edit the
DeploymentService.properties from
/WPS_HOME/shared/app/config/properties/ (in WPS5.1
/WPS_HOME/shared/app/config/services/) and change following property :
From : was.admin.host = localhost (this is hashed out if no earlier
modifications has been done).
To: was.admin.host = actual_machine_hostname (un-hash it also)

Re-start the portal server that would resolve portlet deploy issue if
customer is getting above exception .

Here's a link which addresses this issue:
http://www-1.ibm.com/support/docview.wss?uid=swg21221259

--
To Living Instead Of Existing!

Specifying the default document editor

2007-10-25T10:16:00.001-04:00

Specifying the default document editor

You can configure Java to use an editing application other than the default rich text editor as the preferred document editor.

Open the Java_directory/jre/lib/content-type.properties file in a text editor.

Add your editing application information using the following format:

application/vnd.application name: \
description=editing application full name;\
file_extensions=.fileextension

For example, an entry for Lotus WordPro would look like the following:
application/vnd.lotus-wordpro: \
description=Lotus WordPro; \
file_extensions=.lwp

Save the changes.

--
To Living Instead Of Existing!

UML 2.0 Diagrams

2007-10-03T14:06:00.001-04:00

There are three classifications of UML diagrams:

Behavior diagrams. A type of diagram that depicts behavioral features of a system or business process. This includes activity, state machine, and use case diagrams as well as the four interaction diagrams.
Interaction diagrams. A subset of behavior diagrams which emphasize object interactions. This includes communication, interaction overview, sequence, and timing diagrams.
Structure diagrams. A type of diagram that depicts the elements of a specification that are irrespective of time. This includes class, composite structure, component, deployment, object, and package diagrams.

Table 1 summarizes the thirteen, up from nine in UML 1.x, diagram types of UML 2.x. In the diagram column the links will take you to description pages for the artifact. The learning priority column indicates how important it is for a business application developer to learn the artifact (IMHO).

Table 1. The diagrams of UML 2.

Diagram	Description	Learning Priority
Activity Diagram	Depicts high-level business processes, including data flow, or to model the logic of complex logic within a system. See UML Activity diagram guidelines.	High
Class Diagram	Shows a collection of static model elements such as classes and types, their contents, and their relationships. See UML Class diagram guidelines.	High
Communication Diagram	Shows instances of classes, their interrelationships, and the message flow between them. Communication diagrams typically focus on the structural organization of objects that send and receive messages. Formerly called a Collaboration Diagram. See UML Collaboration diagram guidelines.	Low
Component Diagram	Depicts the components that compose an application, system, or enterprise. The components, their interrelationships, interactions, and their public interfaces are depicted. See UML Component diagram guidelines.	Medium
Composite Structure Diagram	Depicts the internal structure of a classifier (such as a class, component, or use case), including the interaction points of the classifier to other parts of the system.	Low
Deployment Diagram	Shows the execution architecture of systems. This includes nodes, either hardware or software execution environments, as well as the middleware connecting them. See UML Deployment diagram guidelines.	Medium
Interaction Overview Diagram	A variant of an activity diagram which overviews the control flow within a system or business process. Each node/activity within the diagram can represent another interaction diagram.	Low
Object Diagram	Depicts objects and their relationships at a point in time, typically a special case of either a class diagram or a communication diagram.	Low
Package Diagram	Shows how model elements are organized into packages as well as the dependencies between packages. See Package diagram guidelines.	Low
Sequence Diagram	Models the sequential logic, in effect the time ordering of messages between classifiers. See UML Sequence diagram guidelines.	High
State Machine Diagram	Describes the states an object or interaction may be in, as well as the transitions between states. Formerly referred to as a state diagram, state chart diagram, or a state-transition diagram. See UML State chart diagram guidelines.	Medium
Timing Diagram	Depicts the change in state or condition of a classifier instance or role over time. Typically used to show the change in state of an object over time in response to external events.	Low
Use Case Diagram	Shows use cases, actors, and their interrelationships. See UML Use case diagram guidelines.	Medium

--
To Living Instead Of Existing!

Java Heap Size

2007-08-31T10:29:00.001-04:00

The size of the heap, amount of available RAM and other JVM configuration options affects both capacity and performance (too small a heap will result in execess garbage collection, similarly not enough RAM will causes performance degredation). The following guidelines are suggested:

Using java -Xmx can be used to increase the fairly small default JVM heap size. For example invoking using the: (java -Xmx512m...) command line argument will allocate half a gigabyte of RAM to the JVM heap.
Performance is poor if there isn't enough RAM available to support the requested JVM heap size. Using disk based swapping to support the heap exhibited significant slow downs. We suggest ensuring that the heap size specified with the java -Xmx argument is available as free RAM.
The J2SE server JVM can provide much better performance than the client JVM (in some cases twice as fast), but at the expense of increased memory consumption. If enough RAM is available, adding: java -server ... is recommended for best performance.
32 bit Operating Systems and processors can limit the process virtual address space and thus the amount of memory that you can dedicate to JVM heap usage. Some Operating Systems divide the 32 bit process address space into space for system/kernel and space for user code. For example, Windows™, Linux™ (most distributions/kernels) and MacOSX™ do a 50/50 split, leaving on a 32 bit machine around 2GBytes of space available for the Java heap, even on machines which have larger amounts of RAM installed. 32 bit processes on Solaris Sparc™ (7, 8 & 9) avoid the 50/50 split and make most of the 4Gbytes available to the java heap, for example java -Xmx3900m is possible.
To exceed the 2 or 4GByte Java heap size limits, a 64 bit JVM is usually required. However, for this to work usefully and to see benefits, 64 bit processors, corresponding Operating System support (some Operating Systems available for 64 bit processors only support a 32 bit address space, for example MacOSX™ 10.3) and more than 4 GBytes of RAM will be needed.
The use of Multiple Page Size Suppport

java -XX:+UseMPSS ... on Solaris provided a 5% runtime improvement in testing, with no measurable memory overhead.
Using the incremental garbage collector (java -Xincgc ...) showed no benefit when tested.
It was hoped the use of the Parallel Garbage collector (java -XX:+UseParallelGC ...) would provide improved run times on multiprocessors as garbage collection could occur concurrently on a separate CPU. It actually had the opposite effect, doubling the elapsed runtime and trebling the CPU time consumed.

--
To Living Instead Of Existing!

SAX

2007-08-30T11:54:00.001-04:00

Simple API for XML (SAX), an event-driven, serial-access mechanism for accessing XML documents. This protocol is frequently used by servlets and network-oriented programs that need to transmit and receive XML documents, because it's the fastest and least memory-intensive mechanism that is currently available for dealing with XML documents, other than StAX.

Note: In a nutshell, SAX is oriented towards state independent processing, where the handling of an element does not depend on the elements that came before. StAX, on the other hand, is oriented towards state dependent processing.

Setting up a program to use SAX requires a bit more work than setting up to use the Document Object Model (DOM). SAX is an event-driven model (you provide the callback methods, and the parser invokes them as it reads the XML data), and that makes it harder to visualize. Finally, you can't "back up" to an earlier part of the document, or rearrange it, any more than you can back up a serial data stream or rearrange characters you have read from that stream.

For those reasons, developers who are writing a user-oriented application that displays an XML document and possibly modifies it will want to use the DOM mechanism.

SAX is fast and efficient, but its event model makes it most useful for such state-independent filtering. For example, a SAX parser calls one method in your application when an element tag is encountered and calls a different method when text is found. If the processing you're doing is state-independent (meaning that it does not depend on the elements have come before), then SAX works fine.

On the other hand, for state-dependent processing, where the program needs to do one thing with the data under element A but something different with the data under element B, then a pull parser such as the Streaming API for XML (StAX) would be a better choice. With a pull parser, you get the next node, whatever it happens to be, at any point in the code that you ask for it. So it's easy to vary the way you process text (for example), because you can process it multiple places in the program.

Pull parsers and the SAX API both act like a serial I/O stream. You see the data as it streams in, but you can't go back to an earlier position or leap ahead to a different position. In general, such parsers work well when you simply want to read data and have the application act on it.
--
To Living Instead Of Existing!

Web Service Binging type and Use style -- From IBM (Russell Butek)

2007-07-31T10:51:00.001-04:00

A Web Services Description Language (WSDL) binding style can be RPC or document. The use can be encoded or literal. How do you determine which combination of style and use to use? The author describes the WSDL and SOAP messages for each combination to help you decide.

Introduction

A WSDL document describes a Web service. A WSDL binding describes how the service is bound to a messaging protocol, particularly the SOAP messaging protocol. A WSDL SOAP binding can be either a Remote Procedure Call (RPC) style binding or a document style binding. A SOAP binding can also have an encoded use or a literal use. This gives you four style/use models:

RPC/encoded
RPC/literal
Document/encoded
Document/literal

Add to this collection a pattern which is commonly called the document/literal wrapped pattern and you have five binding styles to choose from when creating a WSDL file. Which one should you choose?

Before I go any further, let me clear up some confusion that many of us have stumbled over. The terminology here is very unfortunate: RPC versus document. These terms imply that the RPC style should be used for RPC programming models and that the document style should be used for document or messaging programming models. That is not the case at all. The style has nothing to do with a programming model. It merely dictates how to translate a WSDL binding to a SOAP message. Nothing more. You can use either style with any programming model.

Likewise, the terms encoded and literal are only meaningful for the WSDL-to-SOAP mapping, though, at least here, the traditional meanings of the words make a bit more sense.

For this discussion, let's start with the Java method in Listing 1 and apply the JAX-RPC Java-to-WSDL rules to it (see Resources for the JAX-RPC 1.1 specification).

Listing 1. Java method

public void myMethod(int x, float y);

RPC/encoded

Take the method in Listing 1 and run it through your favorite Java-to-WSDL tool, specifying that you want it to generate RPC/encoded WSDL. You should end up with something like the WSDL snippet in Listing 2.

Listing 2. RPC/encoded WSDL for myMethod

<message name="myMethodRequest">
    <part name="x" type="xsd:int"/> 
    <part name="y" type="xsd:float"/>
</message>
<message name="empty"/>

<portType name="PT">
    <operation name="myMethod"> 
        <input message="myMethodRequest"/>
        <output message="empty"/>
    </operation>
</portType>

<binding .../>  
<!-- I won't bother with the details, just assume it's RPC/encoded. -->

Now invoke this method with "5" as the value for parameter x and "5.0" for parameter y. That sends a SOAP message which looks something like Listing 3.

Listing 3. RPC/encoded SOAP message for myMethod

<soap:envelope>
    <soap:body>
        <myMethod>
            <x xsi:type="xsd:int">5</x> 
            <y xsi:type="xsd:float">5.0</y>
        </myMethod>
    </soap:body>
</soap:envelope>

A note about prefixes and namespaces

For the most part, for brevity, I ignore namespaces and prefixes in the listings in this article. I do use a few prefixes that you can assume are defined with the following namespaces:

xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance "
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"

For a discussion about namespaces and the WSDL-to-SOAP mapping, see paper "Handle namespaces in SOAP messages you create by hand" (see Resources).

There are a number of things to notice about the WSDL and SOAP message for this RPC/encoded example:

Strengths

The WSDL is about as straightforward as it's possible for WSDL to be.
The operation name appears in the message, so the receiver has an easy time dispatching this message to the implementation of the operation.

Weaknesses

WS-I compliance

The various Web services specifications are sometimes inconsistent and unclear. The WS-I organization was formed to clear up the issues with the specs. It has defined a number of profiles which dictate how you should write your Web services to be interoperable. For more information on WS-I, see the WS-I links in Resources.

The type encoding info (such as xsi:type="xsd:int") is usually just overhead which degrades throughput performance.
You cannot easily validate this message since only the <x ...>5</x> and <y ...>5.0</y> lines contain things defined in a schema; the rest of the soap:body contents comes from WSDL definitions.
Although it is legal WSDL, RPC/encoded is not WS-I compliant.

Is there a way to keep the strengths and remove the weaknesses? Possibly. Let's look at the RPC/literal style.

RPC/literal

The RPC/literal WSDL for this method looks almost the same as the RPC/encoded WSDL (see Listing 4). The use in the binding is changed from encoded to literal. That's it.

Listing 4. RPC/literal WSDL for myMethod

<message name="myMethodRequest">
    <part name="x" type="xsd:int"/> 
    <part name="y" type="xsd:float"/%gt;
</message>
<message name="empty"/>

<portType name="PT">
    <operation name="myMethod"> 
        <input message="myMethodRequest"/>
        <output message="empty"/>
    </operation>
</portType>

<binding .../>  
<!-- I won't bother with the details, just assume it's RPC/ literal. -->

What about the SOAP message for RPC/literal (see Listing 5)? Here there is a bit more of a change. The type encodings have been removed.

Listing 5. RPC/literal SOAP message for myMethod

<soap:envelope>
    <soap:body>
        <myMethod>
            <x>5</x> 
            <y>5.0</y>
        </myMethod>
    </soap:body>
</soap:envelope>

A note about xsi:type and literal use

Although in normal circumstances xsi:type does not appear in a literal WSDL's SOAP message, there are still cases when type information is necessary and it will appear -- in polymorphism, for instance. If the API expects a base type and an extension instance is sent, the type of that instance must be provided for proper deserialization of the object.

Here are the strengths and weaknesses of this approach:

Strengths

The WSDL is still about as straightforward as it is possible for WSDL to be.
The operation name still appears in the message.
The type encoding info is eliminated.
RPC/literal is WS-I compliant.

Weaknesses

You still cannot easily validate this message since only the <x ...>5</x> and <y ...>5.0</y> lines contain things defined in a schema; the rest of the soap:body contents comes from WSDL definitions.

What about the document styles? Do they help overcome this weakness?

Document/encoded

Nobody follows this style. It is not WS-I compliant. So let's move on.

Document/literal

The WSDL for document/literal changes somewhat from the WSDL for RPC/literal. The differences are highlighted in bold in Listing 6 .

Listing 6. Document/literal WSDL for myMethod

				<types>
    <schema>
        <element name="xElement" type="xsd:int"/> 
        <element name="yElement" type="xsd:float"/>
    </schema>
</types>

<message name="myMethodRequest">
    <part name="x"  element="xElement"/>
    <part name="y" element="yElement"/>
</message>
<message name="empty"/> 

<portType name="PT">
    <operation name="myMethod">
        <input message="myMethodRequest"/>
        <output message="empty"/>
    </operation> 
</portType>

<binding .../>  
<!-- I won't bother with the details, just assume it's document/literal. -->

The SOAP message for this WSDL is in Listing 7:

Listing 7. Document/literal SOAP message for myMethod

<soap:envelope>
    <soap:body>
        <xElement>5</xElement>
         <yElement>5.0</yElement>
    </soap:body>
</soap:envelope>

A note about the message part

I could have changed only the binding, as I did from RPC/encoded to RPC/literal. It would have been legal WSDL. However, the WS-I Basic Profile dictates that document/literal message parts refer to elements rather than types, so I'm complying with WS-I. (And using an element part here leads well into the discussion about the document/literal wrapped pattern.)

Here are the strengths and weaknesses of this approach:

Strengths

There is no type encoding info.
You can finally validate this message with any XML validator. Everything within the soap:body is defined in a schema.
Document/literal is WS-I compliant, but with restrictions (see weaknesses).

Weaknesses

The WSDL is getting a bit more complicated. This is a very minor weakness, however, since WSDL is not meant to be read by humans.
The operation name in the SOAP message is lost. Without the name, dispatching can be difficult, and sometimes impossible.
WS-I only allows one child of the soap:body in a SOAP message. As you can see in Listing 7, this example's soap:body has two children.

The document/literal style seems to have merely rearranged the strengths and weaknesses from the RPC/literal model. You can validate the message, but you lose the operation name. Is there anything you can do to improve upon this? Yes. It's called the document/literal wrapped pattern.

Document/literal wrapped

Before I describe the rules for the document/literal wrapped pattern, let me show you the WSDL and the SOAP message in Listing 8 and Listing 9.

Listing 8. Document/literal wrapped WSDL for myMethod

<types>
    <schema>
        <element name="myMethod"> 
            <complexType>
                <sequence>
                    <element name="x" type="xsd:int"/>
                    <element name="y" type="xsd:float"/> 
                </sequence>
            </complexType>
        </element>
        <element name="myMethodResponse">
            <complexType/>
        </element> 
    </schema>
</types>
<message name="myMethodRequest">
    <part name="parameters" element="myMethod "/>
</message>
<message name="empty">
    <part name="parameters" element="myMethodResponse"/>
</message>

<portType name="PT"> 
    <operation name="myMethod">
        <input message="myMethodRequest"/>
        <output message="empty"/>
    </operation>
</portType>

 <binding .../>  
<!-- I won't bother with the details, just assume it's document/literal. -->

The WSDL schema now has a wrapper around the parameters (see Listing 9).

Listing 9. Document/literal wrapped SOAP message for myMethod

<soap:envelope>
    <soap:body>
        <myMethod>
            <x>5</x> 
            <y>5.0</y>
        </myMethod>
    </soap:body>
</soap:envelope>

Notice that this SOAP message looks remarkably like the RPC/literal SOAP message in Listing 5. You might say it looks exactly like the RPC/literal SOAP message, but there's a subtle difference. In the RPC/literal SOAP message, the <myMethod> child of <soap:body> was the name of the operation. In the document/literal wrapped SOAP message, the <myMethod> clause is the name of the wrapper element which the single input message's part refers to. It just so happens that one of the characteristics of the wrapped pattern is that the name of the input element is the same as the name of the operation. This pattern is a sly way of putting the operation name back into the SOAP message.

These are the basic characteristics of the document/literal wrapped pattern:

The input message has a single part.
The part is an element.
The element has the same name as the operation.
The element's complex type has no attributes.

Here are the strengths and weaknesses of this approach:

Strengths

There is no type encoding info.
Everything that appears in the soap:body is defined by the schema, so you can easily validate this message.
Once again, you have the method name in the SOAP message.
Document/literal is WS-I compliant, and the wrapped pattern meets the WS-I restriction that the SOAP message's soap:body has only one child.

Weaknesses

The WSDL is even more complicated.

As you can see, there is still a weakness with the document/literal wrapped pattern, but it's minor and far outweighed by the strengths.

RPC/literal wrapped?

From a WSDL point of view, there's no reason the wrapped pattern is tied only to document/literal bindings. It could just as easily be applied to an RPC/literal binding. But this would be rather silly. The SOAP message would contain a myMethod element for the operation and a child myMethod element for the element name. Also, even though it's legal WSDL, an RPC/literal part should be a type; an element part is not WS-I compliant.

Where is doc/lit wrapped defined?

This wrapped style originates from Microsoft®. There is no specification that defines this style; so while this style is a good thing, unfortunately, the only choice right now, in order to interoperate with Microsoft's and other's implementations, is to make educated guesses as to how it works based on the output of the Microsoft WSDL generator. This pattern has been around for awhile, and the industry has done a good job of understanding it, but while the pattern is fairly obvious in this example, there are corner cases in which the proper thing to do is not particularly clear. Our best hope is that an independent group like the WS-I organization will help stabilize and standardize this in the future.

Why not use document/literal wrapped all the time?

So far, this article has given the impression that the document/literal wrapped style is the best approach. Very often that's true. But there are still cases where you'd be better off using another style.

Reasons to use document/literal non-wrapped

If you have overloaded operations, you cannot use the document/literal wrapped style.

Imagine that, along with the method you've been using all along, you have the additional method in Listing 10.

Listing 10. Problem methods for document/literal wrapped

public void myMethod(int x, float y);
public void myMethod(int x);

A note about overloaded operations

WSDL 2.0 will not allow overloaded operations. This is unfortunate for languages like the Java language which do allow them. Specs like JAX-RPC will have to define a name mangling scheme to map overloaded methods to WSDL. WSDL 2.0 merely moves the problem from the WSDL-to-SOAP mapping to the WSDL-to-language mapping.

WSDL allows overloaded operations. But when you add the wrapped pattern to WSDL, you require an element to have the same name as the operation, and you cannot have two elements with the same name in XML. So you must use the document/literal, non-wrapped style or one of the RPC styles.

Reasons to use RPC/literal

Since the document/literal, non-wrapped style doesn't provide the operation name, there are cases where you'll need to use one of the RPC styles. For instance, say you have the set of methods in Listing 11.

Listing 11. Problem methods for document/literal non-wrapped

public void myMethod(int x, float y);
public void myMethod(int x);
 public void someOtherMethod(int x, float y);

Now assume that your server receives the document/literal SOAP message that you saw back in Listing 7. Which method should the server dispatch to? All you know for sure is that it's not myMethod(int x) because the message has two parameters and this method requires one. It could be either of the other two methods. With the document/literal style, you have no way to know which one.

Instead of the document/literal message, assume that the server receives an RPC/literal message such as the one in Listing 5 . With this message it's fairly easy for a server to decide which method to dispatch to. You know the operation name is myMethod, and you know you have two parameters, so it must be myMethod(int x, float y) .

Reasons to use RPC/encoded

The primary reason to prefer the RPC/encoded style is for data graphs. Imagine that you have a binary tree whose nodes are defined in Listing 12.

Listing 12. Binary tree node schema

<complexType name="Node">
    <sequence>
        <element name="name" type="xsd:string"/> 
        <element name="left" type="Node" xsd:nillable="true"/>
        <element name="right" type="Node" xsd:nillable="true"/>
    </sequence> 
</complexType>

With this node definition, you could construct a tree whose root node -- A -- points to node B through both its left and right links (see Figure 1).

Figure 1. Encoded tree.

The standard way to send data graphs is to use the href tag, which is part of the RPC/encoded style (Listing 13).

Listing 13. The RPC/encoded binary tree

<A>
    <name>A</name>
    <left href="12345"/>
    <right href="12345"/> 
</A>
<B id="12345">
    <name>B</name>
    <left xsi:nil="true"/>
    <right xsi:nil="true"/>
</B>

Under any literal style, the href attribute is not available, so the graph linkage is lost (see Listing 14 and Figure 2). You still have a root node, A, which points to a node B to the left and another node B to the right. These B nodes are equal, but they are not the same node. Data have been duplicated instead of being referenced twice.

Listing 14. The literal binary tree

<A>
    <name>A</name>
    <left>
        <name>B</name> 
        <left xsi:nil="true"/>
        <right xsi:nil="true"/>
    </left>
    <right>
        <name>B</name>
        <left xsi:nil="true"/> 
        <right xsi:nil="true"/>
    </right>
</A>

Figure 2. Literal tree

There are various ways you can do graphs in literal styles, but there are no standard ways; so anything you might do would probably not interoperate with the service on the other end of the wire.

SOAP response messages

So far I have been discussing request messages. But what about response messages? What do they look like? By now it should be clear to you what the response message looks like for a document/literal message. The contents of the soap:body are fully defined by a schema, so all you have to do is look at the schema to know what the response message looks like. For instance, see Listing 15 for the response for the WSDL in Listing 8.

Listing 15. document/literal wrapped response SOAP message for myMethod

<soap:envelope>
    <soap:body>
        <myMethodResponse/>
    </soap:body> 
</soap:envelope>

But what is the child of the soap:body for the RPC style responses? The WSDL 1.1 specification is not clear. But WS-I comes to the rescue. WS-I's Basic Profile dictates that in the RPC/literal response message, the name of the child of soap:body is "... the corresponding wsdl:operation name suffixed with the string 'Response'." Surprise! That's exactly what the conventional wrapped pattern's response element is called. So Listing 15 applies to the RPC/literal message as well as the document/literal wrapped message. (Since RPC/encoded is not WS-I compliant, the WS-I Basic Profile doesn't mention what an RPC/encoded response looks like, but you can assume the same convention applies here that applies everywhere else.) So the contents of response messages are not so mysterious after all.

Summary

There are four binding styles (there are really five, but document/encoded is meaningless). While each style has its place, under most situations the best style is document/literal wrapped.

Resources

Be prepared for those times when you have to create your SOAP message by hand and deal with namespace issues without the help of a tool by reading "Handle namespaces in SOAP messages you create by hand" (developerWorks, May 2005).
Read the Web Services Description Language (WSDL) 1.1, the specification of WSDL.
For a preview of where WSDL is going, read the WSDL 2.0 draft specifications.
Try the SOAP 1.2 Primer, an introduction to the SOAP 1.2 specification.
Java API for XML-Based RPC (JAX-RPC) Downloads & Specifications provides links to the JAX-RPC 1.1 specification itself, as well as javadocs, class files, and Sun's JAX-RPC reference implementation.
Browse the WS-I (Web Services Interoperability) organization's Web pages.
Read the WS-I's profiles. Particularly relevant is the basic profile.
Browse for books on these and other technical topics.
Get involved in the developerWorks community by participating in developerWorks blogs.
Want more? The developerWorks SOA and Web services zone hosts hundreds of informative articles and introductory, intermediate, and advanced tutorials on how to develop Web services applications.

Some good points got from "EJB 3.0 in Action"

2007-07-11T15:21:00.001-04:00

Clearly, EJB 3.0 Session Beans are not your only option in developing the business tier of your application. POJOs managed by lightweight containers such as Spring could also be
used to build the business logic tier.

Before jumping on either the EJB 3.0 Session Bean or Spring bandwagon you should clearly think about what your needs are.
If your application needs robust remoteability or seamlessly exposing your business logic as Web Services, EJB 3.0 is the clear choice. Spring also does not have very good equivalents of instance pooling, automated session state maintenance and passivation/activation. Because of heavy use of annotations, you can pretty much avoid "XML Hell" using EJB 3.0. This is not true of Spring. Moreover, because it is an integral part of the Java EE standard the EJB container is natively integrated with components such as JSF, JSP, Servlets, the JTA transaction manager, JMS providers and JAAS security providers of your application server.

With Spring, you have to worry whether your application server fully supports the framework with these native components and other high performance features like clustering, load
balancing and failover. If these are not factors you are worried about, Spring is not a bad choice at all and has a few strengths of its own. Spring has numerous simple, elegant utilities to perform many common tasks such as the JDBC and JMS templates. If you plan to use dependency injection with regular Java Classes, Spring is great since DI only works for container components in EJB 3.0. Also, Spring AOP/AspectJ is a much more feature-rich (albeit slightly more complex) choice than EJB 3.0 interceptors.

Nevertheless, if portability, standardization and vendor support is important to you, EJB 3.0 may be the way to go anyway. EJB 3.0 is a mature product that is the organic (albeit imperfect) result of the incremental effort, pooled resources, shared ownership and measured consensus of numerous distinct groups of people. This includes the grassroots Java Community Process (JCP), some of the world's most revered commercial technology powerhouses like IBM, Sun, Oracle, BEA, etc and well as spirited open source organizations like Apache and JBoss.

--
To Living Instead Of Existing!

Some notes on using EJB 3.0

2007-07-11T13:54:00.001-04:00

Create Stateless Session Bean

Define an interface :

import javax.ejb.Local;
import com.risguru.example.persistence.User;

public interface RegisterUser{
User registerUser(User user);
}

Define the implementation

import javax.ejb.Stateless;
import com.risguru.example.persistence.User;

@Stateless
public class RegisterUserBean implements RegisterUser {

Define the client usage

@EJB

private RegisterUser registerUser

Create Stateful Session Bean

Define an interface

The same with above

Define the implementation

import javax.ejb.*;

@Stateful
public class RegisterUserBean implements RegisterUser {
......
@Remove
public Long confirm()

Create Message Driven Bean

Define client usage

@Resource(name="jms/QueueConnectionFactory")
private ConnectionFactory connectionFactory;
@Resource(name="jms/UserRegisterQueue")
private Destination userRegisterQueue;

Define the server side MDB

import javax.ejb.MessageDriven;

import javax.ejb.ActivationConfigProperty;

@MessageDriven(
   activationConfig = {
        @ActivationConfigProperty(
            propertyName="destinationName",
            propertyValue="jms/UserRegisterQueue")
    }
)

Create Entity Bean

Define entity

import java.io.Serializable;

import java.sql.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table ;
import javax.persistence.GenerationType;
import javax.persistence.GeneratedValue;

@Entity
@Table(name="USERS")

@Id
@GeneratedValue(strategy=GenerationType.AUTO)
@Column(name="USER_ID")

Use Entity Manager

import javax.persistence.PersistenceContext;
import javax.persistence.EntityManager;

@PersistenceContext(unitName="risGuru")
private EntityManager entityManager;

entityManager.persist(user)

--
To Living Instead Of Existing!

EJB 3.0 new features

2007-07-10T17:07:00.001-04:00

EJB 3.0 components are POJOs configurable through simplified metadata annotations.
Accessing EJBs from client applications has become very simple using dependency injection.
EJB 3.0 standardizes the persistence with the Java Persistence API, which defines POJO
Entities that can be used both inside and outside the container.

--
To Living Instead Of Existing!

Simple Comparison for ebMS 2.0 and ebMS 3.0

2007-06-29T14:27:00.001-04:00

Comparison ebMS 2.0 with 3.0.

ebMS 2.0 compiles SOAP 1.1 and SOAP Messages with Attachments.
ebMS 3.0 works with SOAP 1.1/1.2 and SOAP Messages with Attachments.

ebMS 2.0 uses single message structure for normal messages and error messages.
ebMS 3.0 separates them into two structure: User Message and Signal Message.

ebMS 2.0 has elements in SOAP body.
ebMS 3.0 puts its stuff in SOAP header. The SOAP body is freed for business payload. This clearly isolation makes ebMS 3.0 more compliant than ebMS 2.0 with SOAP processing model.

ebMS 3.0 changes some fields and adds more fields than ebMS 2.0.

--
To Living Instead Of Existing!

How do I set a header when using WSDL2Java stubs?

2007-06-29T11:15:00.001-04:00

How do I set a header when using WSDL2Java stubs?

There are two styles of headers, explicit and implicit. Explicit headers are defined in the WSDL of the service. The WSDL2Java generation tool will recognize these headers in most cases and emit stub class methods that include the headers as arguments to the methods.
In other cases, you may want to set headers that are not explicitly called out in the WSDL. For instance, you want to do some custom processing in a handler or add security. In this case you can add headers to request before you invoke the stub method.
There are are two setHeader APIs on the org.apache.axis.client.Stub class. The first takes the namespace, name and value of the header.
setHeader(String namespace, String partName, Object headerValue)
The second takes a SoapHeaderElement:
setHeader(SOAPHeaderElement header)
Here is an example of using the first API
 FooServiceLocator loc = new FooServiceLocator();
 FooService binding = loc.getFooService();
 org.apache.axis.client.Stub s = (Stub) binding;
 s.setHeader("http://my.name.space/headers ", "mysecurityheader", "This guy is OK");
 result = binding.myOperation(...);

--
To Living Instead Of Existing!

SOAP adapter technology adoption overview

2007-06-28T10:12:00.001-04:00

For the SOAP adapter, the implementation technologies can with these 4,

Axis. Axis is a widely adopted SOAP framework, and de-fact standard in Web Service. It is the only plug-in that is supported by Eclipse WST.
Axis 2. Axis 2 is a re-architecture and re-written Axis, the API is simpler and performance is better. It will be the next generation of Apache SOAP framework. It also provides a separated plug-in for Eclipse.
JAX-WS RI, JAX-WS RI is Sun Web Service Reference Implementation, it supports Annotation and pretty easy to implement.
XFire, yet another well known SOAP lightweight framework, with its simple and easy understanding model, fast speed and maintainability, it grows up quickly. But sometime has to use some vendor special features.

Web Security Concerns:

Axis does not support Web Security Authentication directly, it supports the XML signatures via another Apache project XML security and Digest signature via HttpClient library. Axis supports both SOAP 1.1 and 1.2.
Axis 2 supports WSS4J for security (Apache Rampart), Reliable Messaging (Sandesha), WS-Coordination ( Kandula ), WS-AtomicTransaction and WS-BusinessActivity, but not all of them are released. Axis 2 supports both SOAP 1.1 and 1.2.
JAX-WS RI is using Handler (like Sevlet filter) to handle the WS-Security signature, or apply different handlers for different purposes, this can be much more efficient and convenient than WSS XML configuration files, said someone's blog ( http://cup-of-java.blogspot.com/2007/06/jax-ws-ri-is-good-good-good.html)
XFire supports WSS4J, but use its own inHandler and outHander.

--
To Living Instead Of Existing!

AJAX framework selection

2007-06-22T11:31:00.001-04:00

Let see what I had at this spot.

There are several AJAX frameworks, I will try my best to go through one by one, but of course, these are all my personal opinions.

DOJO, is one of the most popular and more comprehensive open source AJAX framework, with its advanced packaging system and rich API of not only AJAX utilities but also UI components. DOJO has received the backing of many Java projects including Tapestry and WebWork (Struts 2.0) and is widely adopted by IBM, Sun and big name companies. It has a wide developer base and a lot of resource such as trouble shooting, tutorial, jump start, forum, mail list and so on. The downside is since it is a client-centric framework that with its plumbing features, it provides developer the capability to manipulate the lowest layer and hence developers have to deal with a lot of JavaScript coding which will becomes a big issue in maintenance and usability.

ICEFace, is a new and quick growing framework. It is integrated with BEA. It provides lot of pre-built UI components and with BEA Workshop studio, developer can create pages by visually drag and drop. Since ICEFaces offers a JSF programming model, it can be readily adapted to existing JSF tooling. I have never tried out the ICEFaces, so I cannot provide further information here.

Prototype/Scriptaculous: The pairing of Prototype and Scriptaculous has proven popular, thanks in part to the simplicity of its API, giving the developer enhanced tools to navigate and manipulate the DOM, and providing browser-independent access to the XMLHttpRequest object. A number of frameworks more focused on widget have been built on top of Prototype, and ICEFaces incorporates Prototype and Scriptaculous as well.

The Google Web Tookit is a comprehensive framework. The programming model is server-centric and procedural; the API looks a lot like SWT. The Java application code is debugged by running it in the "hosted web browser" tool shipped with the framework. It has a compiler that helps translating Java code into JavasScript file, and then serves it into a Web page. It also provides tools such as Eclipse plug designer IDE that developer can use drag drop function to create interface on Eclipse IDE. The downside of GWT is after the interface is done, it has limited room for developer to optimize or modify the generated code. To me, the GWT is the most compatible AJAX framework that works perfectly in both IE 6+ and Firefox 1.5+. Plus, GWT has a very strong developer team as it's backing.

ZK, I used ZK for quite a while, it is a pretty lightweight AJAX framework, it provides 100% pure Java coding model, that means the developer does not have to worry about or even write a simple JavaScript. It is another kind of SWT alike framework. Unfortunately, the user base of ZK is poor and the developer team of ZK development has only 2 or 3 major developers.

Yahoo UI: the Yahoo library is a sold package with an open source license. Given that Yahoo is using it to power many of its sites, the stability and robustness of the library cannot be put to question.

BroadVision, IBM acquired BroadVision at May last year, and put a lot of effort trying to integrating it into one of WebSphere studio. The BroadVision is JSF base programming model and with the studio, developer can create interface in visually drag and drop way. I cannot tell more since I have not investigated this framework.

At last, if your team has some experienced Microsoft C# developers, you can try out the Microsoft Windows Presentation Foundation, which embedded in Vista and integrated with Visual Studio 2005+. WFP includes two tiers, the front ties is XAML, and the backend tier is C#. In runtime, it has to download a big ActiveX at client side and only support IE 6.0 +. I have to admit that WFP is the most powerful Web 2.0 framework so far I have seen, and it is a big trash as well as it is Microsoft's.

My personal conclusion is : To build a community portal or profolio, I will choose ICEFaces, but to build an enterprise portal, I will go for the GWT.

I hope this can help and please correct me if I am wrong.

--
To Living Instead Of Existing!

Common methods of groovy.util.Node and GPathResult

2007-04-26T16:42:00.000-04:00

--
To Living Instead Of Existing!

The formula calculating mortgage rate in Groovy

2007-04-24T14:30:00.001-04:00

Groovy Code Script to Calculating Mortgage Payment

def monthly = "amount*(rate/12) / (1-(1+rate/12)**-numberOfMonths)"
def shell = new GroovyShell()
def script = shell.parse(monthly)
script.binding.amount = 370000   // the amount browsed
script.rate = 5.25 / 100               // the interest rate
script.numberOfMonths = 12 * 25    // total payment period 12 months * 25 years

def eachmonth = script.run()

--
To Living Instead Of Existing!

New Post for Email Blog

2007-03-07T09:50:00.001-05:00

This is a test blogger for email blog!

--
To Living Instead Of Existing!

ebXML: Global Standard for Electronic Business?

2007-03-06T14:09:00.000-05:00

ebXML: Global Standard for Electronic Business?

After examining the basic blocks with Universal Business Language and XML Common Business Language, what else is missing for electronic business? A whole lot more is incorporated into Electronic Business XML, ebXML for short.

B2B collaboration requires more than just an XML vocabulary. You have to deal with:

Business semantics: What do the individual messages exchanged actually mean in real life?
Negotiating terms and conditions: Business is always bartering of some sort.
Interoperability: Different hardware and software systems need to come together in joint transactions.
Security and Privacy: Some business might be private, and needs to stay that way.
Reliability: To order or not to order, this is the question here.

ebXML provides concrete specifications to enable dynamic B2B collaborations.

ebXML aspires to become the global standard for electronic business, enabling anyone, especially small and medium-size enterprises, anywhere to do business with anyone else over the Internet. It is complementary to other existing B2B initiatives, from both the software developer community (e.g. UDDI, SOAP) and the business sphere (RosettaNet, TradeXchange, etc.).

The vision is to create a global electronic market place where enterprises of any size, anywhere can:

Find each other electronically
And conduct business
Using XML messages
According to standard business process sequences
With clear business semantics
According to standard or mutually agreed trading partner protocol agreements
Using off the shelf purchased business applications

Such an end-to-end B2B XML Framework such as ebXML needs to cover many bases:

Core Components
Registry and Repository
Collaborative Protocol Profiles (CPPs)
Agreements(CPAs)
Message Service

Let's look at each of them in turn.

Core Components

Core components such as UBL or xCBL provide reusable low-level data structures such as party, address, phone, date, currency. They form a single, consistent lexicon used to define business process and information models that facilitates interoperability between disparate systems.

ebXML Registry and Repository

Finding a business party needs a yellow page service in the first place. While the registry is the index of all things ebXML, the repository is the holder. Both systems are based on a distributed model where the nodes can be maintained by industry groups, market places, exchanges, communities, or individual companies.

Registering a business in an ebXML Registry adds offerings to the index of all information in the repository, having the business listed in a rich query facility for finding business partners. The specifications, containing Collaborative Protocol Profiles, Core components, and Classification and categorization schemes all go into an ebXML Repository.

Universal Description and Discovery Interface (UDDI) is a new XML-based technology for building registries. UDDI will be one of the enabling technolgies to help you find ebXML services.

Collaboration Protocol Profile

The profile is defined using the ebXML Specification Schema and is a concrete specification of your ebusiness offerings, that is the business scenarios you support, the service interfaces you implement, as well as document formats exchanged and technical requirements and options for protocols, security, and reliability. The profile is composed of business process models, information models, and context rules.

Standard business scenarios remove the need for prior agreements among trading partners, and. are often defined by Industry Groups. Scenarios include Business Process Models that define interactions between parties, the sequencing of interactions, and the documents exchanged in each interaction. The Information Model defines the documents, and the industry-specific context in which the transactions take place.

Agreement negotiation

After you find a registry and search for partners you examine their CPPs in order to ascertain compatibility of the business process and technical specifications. You stipulate your "rules of engagement" and produce a Collaboration Protocol Agreement, outlining the conditions under which two partners will conduct business transactions together.

The agreement for business interaction between two parties contains technical specifications, in the form of message service requirements and application requirements, and references CPPs and legal terms and conditions. Subsequently a business service interface implements the CPA, and enables one party to converse with the other party using the ebXML Message Service.

Message Service

A reliable, secure XML messaging service is required to enforces the rules of engagement in the CPA. The message service is defined transport independent and extends SOAP messages with attachments. This way it addresses topics beyond SOAP, namely reliability, security, and delivery options.

Conclusion

Worldwide electronic business is a puzzle with many pieces. While the ebXML pieces are at various stages of definition and implementation, the blueprint around them sets the stage for how business transactions will be structured on a world-wide basis. While the world seems to converge, Microsoft goes the other way with biztalk, so stay tuned for the next installment of this mini-series on business XML.

2007-02-05T16:15:00.000-05:00

Technology When/Why to use Requirements

DOM low-level tree-based processing -
SAX event-based push-style parsing can
be useful for streaming large files -
StAX event-based pull-style parsing can
be useful for streaming large files requires tax.jar
DOM4J nicer syntax over DOM processing
plus can be useful for large files if
you use prune capability requires dom4j.jar
XOM nicer syntax over DOM processing
plus a strong emphasis on
compliancy requires xom.jar
JDOM nicer syntax over DOM processing requires jdom.jar
XPath use XPath expressions requires xalan.jar
Jaxen use XPath expressions with
slightly more efficiency than
built-in XPath requires jaxen.jar
XSLT with Java When your transformation is
more easily expressed using
XSLT than code -

Web services technologies

2007-01-12T10:32:00.000-05:00

Web services technology is a collection of standards (or emerging standards)
that can be used to implement an SOA. Web services technology is vendor- and
platform-neutral, interoperable, and supported by many vendors today.
Web services are self-contained, modular applications, that can be described,
published, located, and invoked over networks. Web services encapsulate
business functions, ranging from a simple request-reply to full business process
interactions. The services can be new or wrap around existing applications.
Core elements
The following are the core technologies used for Web services.
Extensible Markup Language (XML)
XML is the markup language that underlies most of the specifications used for
Web services. XML is a generic language that can be used to describe the
content in a structured way, separated from its presentation to a specific
device.
Simple Object Access Protocol (SOAP)
SOAP is a specification for the exchange of structured XML-based messages
between the service provider, service consumer, and service registry,
consisting of three parts:
– The format of a SOAP message is an envelope containing zero or more
headers and exactly one body. The envelope is the top element of the
XML document, providing a container for control information, theaddressee of a message, and the message itself. Headers contain control
information such as quality-of-service attributes. The body contains the
message identification and its parameters.
– Encoding rules are used for expressing instances of application-defined
data types. SOAP defines a programming language independent data type
schema based on an XML Schema Descriptor (XSD), plus encoding rules
for all data types defined to this model.
– RPC representation is the convention for representing remote procedure
calls (RPC) and responses.
SOAP, in principle, is a protocol-independent transport. Consequently, it can
potentially be used in combination with a variety of protocols such as HTTP,
JMS, SMTP, or FTP. Currently, the most common way of exchanging SOAP
messages is through HTTP, which is also the only protocol supported by
WS-I Basic Profile 1.0.
Web Services Description Language (WSDL)
WSDL is an XML-based interface and implementation description language.
A WSDL document contains the following main elements:
Types is the container for data type definitions using a type system such as an
XML Schema.
An abstract, typed definition of the data being communicated, a message can
have one or more typed parts.
A port type is an abstract set of one or more operations supported by one or
more ports.
An operation is an abstract description of an action supported by the service
that define the input and output message and optional fault message.
The binding is a concrete protocol and data format specification for a
particular port type. The binding information contains the protocol name, the
invocation style, a service ID, and the encoding for each operation.
The service as a collection of related ports.
The port is a single endpoint, an aggregation of a binding and a network
address.
Universal Description, Discovery, and Integration (UDDI)
UDDI is both a client-side API and a SOAP-based server implementation that
can be used to store and retrieve information on service providers and Web
services.

Generic Type

2007-01-10T10:46:00.000-05:00

A more realistic use of generic methods might be something like the following, which defines a static method that stuffs references to a single item into multiple boxes:

public static <u>void fillBoxes(U u, List<box<u>> boxes) {
for (Box<u> box : boxes) {
box.add(u);
}
}

To use this method, your code would look something like the following:
Crayon red = ...;
List<box<crayon>> crayonBoxes = ...;

The complete syntax for invoking this method is:

Box.<crayon>fillBoxes(red, crayonBoxes);

Here we've explicitly provided the type to be used as U, but more often than not, this can be left out and the compiler will infer the type that's needed:

Box.fillBoxes(red, crayonBoxes); // compiler infers that U is Crayon

This feature, known as type inference, allows you to invoke a generic method as you would an ordinary method, without specifying a type between angle brackets.

How many percent you understood?

2007-01-09T09:20:00.000-05:00

Must Understand:

- Thread Synchronization (green/native threads, multi-threading)
- Design Patterns (composite view patterns)
- Interpreted vs. Compiled Language
- Working with Oracle without using JDBC- accessing the dbs using Oracle types
- Reflection vs. Introspection

Must Understand Concepts:

1. Thread Synchronization
o What is synchronization? How do you synchronize objects?
o What are the two different methods called which are used for synchronization in Java?
o What's the difference between Vector and ArrayList?
2. Green & Native threads
o Difference between Green and Native threads.
o Which one is better Green or Native?
o Who implements Green threads?
o How Green threads work on a system which does not support threads at the kernel level?
o Define a Java thread

3. Difference between a session bean and entity bean

4. Interpreted vs. Compiled Language. Explain
o Is Java an interpreted or compiled language? Explain

5. Reflection vs. Introspection
o Explain the two and what the differences are?

6. Database design:
o Is it always right to normalize the tables as much as we can or do we encourage denormalization and in what cases?
o What are the steps of normalization and why are we doing it?

7. Design Patterns
o Composite view patterns
o What's composite design pattern.

8. Difference between Model I and Model 2 architecture as applied to MVC in J2EE.

9. Database design questions

Is it always right to normalize the tables as much as we can or do we encourage denormalization and in what cases?
What are the steps of normalization and why are we doing it?

Advantages of Message Security

2007-01-08T14:24:00.000-05:00

Advantages of Message Security

Before we get to message security, it is important to understand why security at the transport layer is not always sufficient to address the security needs of a web service. Transport-layer security is provided by the transport mechanisms used to transmit information over the wire between clients and providers, thus transport-layer security relies on secure HTTP transport (HTTPS) using Secure Sockets Layer (SSL). Transport security is a point-to-point security mechanism that can be used for authentication, message integrity, and confidentiality. When running over an SSL-protected session, the server and client can authenticate one another and negotiate an encryption algorithm and cryptographic keys before the application protocol transmits or receives its first byte of data. Security is "live" from the time it leaves the consumer until it arrives at the provider, or vice versa, even across intermediaries. The problem is that it is not protected once it gets to its destination. One solution is to encrypt the message before sending using message security.
In message-layer security, security information is contained within the SOAP message and/or SOAP message attachment, which allows security information to travel along with the message or attachment. For example, a portion of the message may be signed by a sender and encrypted for a particular receiver. When the message is sent from the initial sender, it may pass through intermediate nodes before reaching its intended receiver. In this scenario, the encrypted portions continue to be opaque to any intermediate nodes and can only be decrypted by the intended receiver. For this reason, message-layer security is also sometimes referred to as end-to-end security.
The advantages of message-layer security include the following:

Security stays with the message over all hops and after the message arrives at its destination.
Is fine-grained. Can be selectively applied to different portions of a message (and to attachments if using XWSS).
Can be used in conjunction with intermediaries over multiple hops.
Is independent of the application environment or transport protocol.

The disadvantage to using message-layer security is that it is relatively complex and adds some overhead to processing.

XML Digital Signature API Examples

2007-01-08T14:08:00.000-05:00

XML Digital Signature API Examples
The following sections describe two examples that show how to use the XML Digital Signature API:

Validate example
Signing example
To run the sample applications using the supplied Ant build.xml files, issue the following commands after you installed Java WSDP:
For Solaris/Linux:

% export JWSDP_HOME=
% export ANT_HOME=$JWSDP_HOME/apache-ant
% export PATH=$ANT_HOME/bin:$PATH
% cd $JWSDP_HOME/xmldsig/samples/
For Windows 2000/XP:

> set JWSDP_HOME=
> set ANT_HOME=%JWSDP_HOME%\apache-ant
> set PATH=%ANT_HOME%\bin;%PATH%
> cd %JWSDP_HOME%\xmldsig\samples\
validate Example
You can find the code shown in this section in the Validate.java file in the /xmldsig/samples/validate directory. The file on which it operates, envelopedSignature.xml, is in the same directory.
To run the example, execute the following command from the /xmldsig/samples/validate directory:
$ ant

The sample program will validate the signature in the file envelopedSignature.xml in the current working directory. To validate a different signature, run the following command:
$ ant -Dsample.args="signature.xml"

where "signature.xml" is the pathname of the file.
Validating an XML Signature
This example shows you how to validate an XML Signature using the JSR 105 API. The example uses DOM (the Document Object Model) to parse an XML document containing a Signature element and a JSR 105 DOM implementation to validate the signature.
Instantiating the Document that Contains the Signature
First we use a JAXP DocumentBuilderFactory to parse the XML document containing the Signature. An application obtains the default implementation for DocumentBuilderFactory by calling the following line of code:
DocumentBuilderFactory dbf =
DocumentBuilderFactory.newInstance();

We must also make the factory namespace-aware:
dbf.setNamespaceAware(true);

Next, we use the factory to get an instance of a DocumentBuilder, which is used to parse the document:
DocumentBuilder builder = dbf.newDocumentBuilder();
Document doc = builder.parse(new FileInputStream(argv[0]));

Specifying the Signature Element to be Validated
We need to specify the Signature element that we want to validate, since there could be more than one in the document. We use the DOM method Document.getElementsByTagNameNS, passing it the XML Signature namespace URI and the tag name of the Signature element, as shown:
NodeList nl = doc.getElementsByTagNameNS
(XMLSignature.XMLNS, "Signature");
if (nl.getLength() == 0) {
throw new Exception("Cannot find Signature element");
}

This returns a list of all Signature elements in the document. In this example, there is only one Signature element.
Creating a Validation Context
We create an XMLValidateContext instance containing input parameters for validating the signature. Since we are using DOM, we instantiate a DOMValidateContext instance (a subclass of XMLValidateContext), and pass it two parameters, a KeyValueKeySelector object and a reference to the Signature element to be validated (which is the first entry of the NodeList we generated earlier):
DOMValidateContext valContext = new DOMValidateContext
(new KeyValueKeySelector(), nl.item(0));

The KeyValueKeySelector is explained in greater detail in Using KeySelectors.
Unmarshaling the XML Signature
We extract the contents of the Signature element into an XMLSignature object. This process is called unmarshalling. The Signature element is unmarshalled using an XMLSignatureFactory object. An application can obtain a DOM implementation of XMLSignatureFactory by calling the following line of code:
XMLSignatureFactory factory =
XMLSignatureFactory.getInstance("DOM");

We then invoke the unmarshalXMLSignature method of the factory to unmarshal an XMLSignature object, and pass it the validation context we created earlier:
XMLSignature signature =
factory.unmarshalXMLSignature(valContext);

Validating the XML Signature
Now we are ready to validate the signature. We do this by invoking the validate method on the XMLSignature object, and pass it the validation context as follows:
boolean coreValidity = signature.validate(valContext);

The validate method returns "true" if the signature validates successfully according to the core validation rules in the W3C XML Signature Recommendation, and false otherwise.
What If the XML Signature Fails to Validate?
If the XMLSignature.validate method returns false, we can try to narrow down the cause of the failure. There are two phases in core XML Signature validation:

Signature validation (the cryptographic verification of the signature)
Reference validation (the verification of the digest of each reference in the signature)
Each phase must be successful for the signature to be valid. To check if the signature failed to cryptographically validate, we can check the status, as follows:
boolean sv =
signature.getSignatureValue().validate(valContext);
System.out.println("signature validation status: " + sv);

We can also iterate over the references and check the validation status of each one, as follows:
Iterator i =
signature.getSignedInfo().getReferences().iterator();
for (int j=0; i.hasNext(); j++) {
boolean refValid = ((Reference)
i.next()).validate(valContext);
System.out.println("ref["+j+"] validity status: " +
refValid);
}

Using KeySelectors
KeySelectors are used to find and select keys that are needed to validate an XMLSignature. Earlier, when we created a DOMValidateContext object, we passed a KeySelector object as the first argument:
DOMValidateContext valContext = new DOMValidateContext
(new KeyValueKeySelector(), nl.item(0));

Alternatively, we could have passed a PublicKey as the first argument if we already knew what key is needed to validate the signature. However, we often don't know.
The KeyValueKeySelector is a concrete implementation of the abstract KeySelector class. The KeyValueKeySelector implementation tries to find an appropriate validation key using the data contained in KeyValue elements of the KeyInfo element of an XMLSignature. It does not determine if the key is trusted. This is a very simple KeySelector implementation, designed for illustration rather than real-world usage. A more practical example of a KeySelector is one that searches a KeyStore for trusted keys that match X509Data information (for example, X509SubjectName, X509IssuerSerial, X509SKI, or X509Certificate elements) contained in a KeyInfo.
The implementation of the KeyValueKeySelector is as follows:
private static class KeyValueKeySelector extends KeySelector {
public KeySelectorResult select(KeyInfo keyInfo,
KeySelector.Purpose purpose,
AlgorithmMethod method,
XMLCryptoContext context)
throws KeySelectorException {
if (keyInfo == null) {
throw new KeySelectorException("Null KeyInfo object!");
}
SignatureMethod sm = (SignatureMethod) method;
List list = keyInfo.getContent();
for (int i = 0; i < list.size(); i++) {
XMLStructure xmlStructure = (XMLStructure) list.get(i);
if (xmlStructure instanceof KeyValue) {
PublicKey pk = null;
try {
pk = ((KeyValue)xmlStructure).getPublicKey();
} catch (KeyException ke) {
throw new KeySelectorException(ke);
}
// make sure algorithm is compatible with method
if (algEquals(sm.getAlgorithm(),
pk.getAlgorithm())) {
return new SimpleKeySelectorResult(pk);
}
}
}
throw new KeySelectorException("No KeyValue element
found!");
}
static boolean algEquals(String algURI, String algName) {
if (algName.equalsIgnoreCase("DSA") &&
algURI.equalsIgnoreCase(SignatureMethod.DSA_SHA1)) {
return true;
} else if (algName.equalsIgnoreCase("RSA") &&
algURI.equalsIgnoreCase(SignatureMethod.RSA_SHA1)) {
return true;
} else {
return false;
}
}
}

genenveloped Example
The code discussed in this section is in the GenEnveloped.java file in the /xmldsig/samples/genenveloped directory. The file on which it operates, envelope.xml, is in the same directory. It generates the file envelopedSignature.xml.
To compile and run this sample, execute the following command from the /xmldsig/samples/genenveloped directory:
$ ant

The sample program will generate an enveloped signature of the document in the file envelope.xml and store it in the file envelopedSignature.xml in the current working directory.
Generating an XML Signature
This example shows you how to generate an XML Signature using the XML Digital Signature API. More specifically, the example generates an enveloped XML Signature of an XML document. An enveloped signature is a signature that is contained inside the content that it is signing. The example uses DOM (the Document Object Model) to parse the XML document to be signed and a JSR 105 DOM implementation to generate the resulting signature.
A basic knowledge of XML Signatures and their different components is helpful for understanding this section. See http://www.w3.org/TR/xmldsig-core/ for more information.
Instantiating the Document to be Signed
First, we use a JAXP DocumentBuilderFactory to parse the XML document that we want to sign. An application obtains the default implementation for DocumentBuilderFactory by calling the following line of code:
DocumentBuilderFactory dbf =
DocumentBuilderFactory.newInstance();

We must also make the factory namespace-aware:
dbf.setNamespaceAware(true);

Next, we use the factory to get an instance of a DocumentBuilder, which is used to parse the document:
DocumentBuilder builder = dbf.newDocumentBuilder();
Document doc = builder.parse(new FileInputStream(argv[0]));

Creating a Public Key Pair
We generate a public key pair. Later in the example, we will use the private key to generate the signature. We create the key pair with a KeyPairGenerator. In this example, we will create a DSA KeyPair with a length of 512 bytes :
KeyPairGenerator kpg = KeyPairGenerator.getInstance("DSA");
kpg.initialize(512);
KeyPair kp = kpg.generateKeyPair();

In practice, the private key is usually previously generated and stored in a KeyStore file with an associated public key certificate.
Creating a Signing Context
We create an XML Digital Signature XMLSignContext containing input parameters for generating the signature. Since we are using DOM, we instantiate a DOMSignContext (a subclass of XMLSignContext), and pass it two parameters, the private key that will be used to sign the document and the root of the document to be signed:
DOMSignContext dsc = new DOMSignContext
(kp.getPrivate(), doc.getDocumentElement());

Assembling the XML Signature
We assemble the different parts of the Signature element into an XMLSignature object. These objects are all created and assembled using an XMLSignatureFactory object. An application obtains a DOM implementation of XMLSignatureFactory by calling the following line of code:
XMLSignatureFactory fac =
XMLSignatureFactory.getInstance("DOM");

We then invoke various factory methods to create the different parts of the XMLSignature object as shown below. We create a Reference object, passing to it the following:

The URI of the object to be signed (We specify a URI of "", which implies the root of the document.)
The DigestMethod (we use SHA1)
A single Transform, the enveloped Transform, which is required for enveloped signatures so that the signature itself is removed before calculating the signature value
Reference ref = fac.newReference
("", fac.newDigestMethod(DigestMethod.SHA1, null),
Collections.singletonList
(fac.newTransform(Transform.ENVELOPED,
(TransformParameterSpec) null)), null, null);

Next, we create the SignedInfo object, which is the object that is actually signed, as shown below. When creating the SignedInfo, we pass as parameters:

The CanonicalizationMethod (we use inclusive and preserve comments)
The SignatureMethod (we use DSA)
A list of References (in this case, only one)
SignedInfo si = fac.newSignedInfo
(fac.newCanonicalizationMethod
(CanonicalizationMethod.INCLUSIVE_WITH_COMMENTS,
(C14NMethodParameterSpec) null),
fac.newSignatureMethod(SignatureMethod.DSA_SHA1, null),
Collections.singletonList(ref));

Next, we create the optional KeyInfo object, which contains information that enables the recipient to find the key needed to validate the signature. In this example, we add a KeyValue object containing the public key. To create KeyInfo and its various subtypes, we use a KeyInfoFactory object, which can be obtained by invoking the getKeyInfoFactory method of the XMLSignatureFactory, as follows:
KeyInfoFactory kif = fac.getKeyInfoFactory();

We then use the KeyInfoFactory to create the KeyValue object and add it to a KeyInfo object:
KeyValue kv = kif.newKeyValue(kp.getPublic());
KeyInfo ki = kif.newKeyInfo(Collections.singletonList(kv));

Finally, we create the XMLSignature object, passing as parameters the SignedInfo and KeyInfo objects that we created earlier:
XMLSignature signature = fac.newXMLSignature(si, ki);

Notice that we haven't actually generated the signature yet; we'll do that in the next step.
Generating the XML Signature
Now we are ready to generate the signature, which we do by invoking the sign method on the XMLSignature object, and pass it the signing context as follows:
signature.sign(dsc);

The resulting document now contains a signature, which has been inserted as the last child element of the root element.
Printing or Displaying the Resulting Document
You can use the following code to print the resulting signed document to a file or standard output:
OutputStream os;
if (args.length > 1) {
os = new FileOutputStream(args[1]);
} else {
os = System.out;
}
TransformerFactory tf = TransformerFactory.newInstance();
Transformer trans = tf.newTransformer();
trans.transform(new DOMSource(doc), new StreamResult(os));

Manipulating Message Content Using SAAJ or DOM APIs

2007-01-08T10:09:00.000-05:00

Manipulating Message Content Using SAAJ or DOM APIs

Because SAAJ nodes and elements implement the DOM Node and Element interfaces, you have many options for adding or changing message content:

Use only DOM APIs.
Use only SAAJ APIs.
Use SAAJ APIs and then switch to using DOM APIs.
Use DOM APIs and then switch to using SAAJ APIs.

The first three of these cause no problems. After you have created a message, whether or not you have imported its content from another document, you can start adding or changing nodes using either SAAJ or DOM APIs.
But if you use DOM APIs and then switch to using SAAJ APIs to manipulate the document, any references to objects within the tree that were obtained using DOM APIs are no longer valid. If you must use SAAJ APIs after using DOM APIs, you should set all your DOM typed references to null, because they can become invalid. For more information about the exact cases in which references become invalid, see the SAAJ API documentation.
The basic rule is that you can continue manipulating the message content using SAAJ APIs as long as you want to, but after you start manipulating it using DOM, you should no longer use SAAJ APIs.

JAXP API Summary

2007-01-05T14:08:00.000-05:00

Why StAX?
The StAX project was spearheaded by BEA with support from Sun Microsystems, and the JSR 173 specification passed the Java Community Process final approval ballot in March, 2004 (http://jcp.org/en/jsr/detail?id=173). The primary goal of the StAX API is to give "parsing control to the programmer by exposing a simple iterator based API. This allows the programmer to ask for the next event (pull the event) and allows state to be stored in procedural fashion." StAX was created to address limitations in the two most prevalent parsing APIs, SAX and DOM.

Streaming Versus DOM
Generally speaking, there are two programming models for working with XML infosets: document streaming and the document object model (DOM).
The DOM model involves creating in-memory objects representing an entire document tree and the complete infoset state for an XML document. Once in memory, DOM trees can be navigated freely and parsed arbitrarily, and as such provide maximum flexibility for developers. However the cost of this flexibility is a potentially large memory footprint and significant processor requirements, as the entire representation of the document must be held in memory as objects for the duration of the document processing. This may not be an issue when working with small documents, but memory and processor requirements can escalate quickly with document size.
Streaming refers to a programming model in which XML infosets are transmitted and parsed serially at application runtime, often in real time, and often from dynamic sources whose contents are not precisely known beforehand. Moreover, stream-based parsers can start generating output immediately, and infoset elements can be discarded and garbage collected immediately after they are used. While providing a smaller memory footprint, reduced processor requirements, and higher performance in certain situations, the primary trade-off with stream processing is that you can only see the infoset state at one location at a time in the document. You are essentially limited to the "cardboard tube" view of a document, the implication being that you need to know what processing you want to do before reading the XML document.
Streaming models for XML processing are particularly useful when your application has strict memory limitations, as with a cellphone running J2ME, or when your application needs to simultaneously process several requests, as with an application server. In fact, it can be argued that the majority of XML business logic can benefit from stream processing, and does not require the in-memory maintenance of entire DOM trees.
Pull Parsing Versus Push Parsing
Streaming pull parsing refers to a programming model in which a client application calls methods on an XML parsing library when it needs to interact with an XML infoset--that is, the client only gets (pulls) XML data when it explicitly asks for it.
Streaming push parsing refers to a programming model in which an XML parser sends (pushes) XML data to the client as the parser encounters elements in an XML infoset--that is, the parser sends the data whether or not the client is ready to use it at that time.
Pull parsing provides several advantages over push parsing when working with XML streams:

With pull parsing, the client controls the application thread, and can call methods on the parser when needed. By contrast, with push processing, the parser controls the application thread, and the client can only accept invocations from the parser.
Pull parsing libraries can be much smaller and the client code to interact with those libraries much simpler than with push libraries, even for more complex documents.
Pull clients can read multiple documents at one time with a single thread.
A StAX pull parser can filter XML documents such that elements unnecessary to the client can be ignored, and it can support XML views of non-XML data.

StAX Use Cases
The StAX specification defines a number of uses cases for the API:

Data binding

Unmarshalling an XML document

Marshalling an XML document
Parallel document processing
Wireless communication
SOAP message processing

Parsing simple predictable structures
Parsing graph representations with forward references
Parsing WSDL
Virtual data sources

Viewing as XML data stored in databases
Viewing data in Java objects created by XML data binding
Navigating a DOM tree as a stream of events
Parsing specific XML vocabularies
Pipelined XML processing

JAXP API Summary

The following table summarizes the characteristics of the JAXP API:

JAXP API Property	StAX	SAX	DOM	TrAX
API Style	Pull events; streaming	Push events; streaming	In memory tree based	XSLT Rule based templates
Ease of Use	High	Medium	High	Medium
XPath Capability	No	No	Yes	Yes
CPU and Memory Utilization	Good	Good	Depends	Depends
Forward Only	Yes	Yes	No	No
Reading	Yes	Yes	Yes	Yes
Writing	Yes	No	Yes	Yes
*Create, Read, Update, Delete (CRUD)*	No	No	Yes	No

Requirements of a JAX-WS Endpoint

2007-01-04T13:41:00.000-05:00

Requirements of a JAX-WS Endpoint
JAX-WS endpoints must follow these requirements:

The implementing class must be annotated with either the javax.jws.WebService or javax.jws.WebServiceProvider annotation.
The implementing class may explicitly reference an SEI through the endpointInterface element of the @WebService annotation, but is not required to do so. If no endpointInterface is not specified in @WebService, an SEI is implicityly defined for the implementing class.
The business methods of the implementing class must be public, and must not be declared static or final.
Business methods that are exposed to web service clients must be annotated with javax.jws.WebMethod.
Business methods that are exposed to web service clients must have JAX-B-compatible parameters and return types. See Default Data Type Bindings.
The implementing class must not be declared final and must not be abstract.
The implementing class must have a default public constructor.
The implementing class must not define the finalize method.
The implementing class may use the javax.annotation.PostConstruct or javax.annotation.PreDestroy annotations on its methods for lifecycle event callbacks.
The @PostConstruct method is called by the container before the implementing class begins responding to web service clients.
The @PreDestroy method is called by the container before the endpoint is removed from operation.

Native Java & .NET Object Database : Open Source

2007-01-02T13:21:00.000-05:00

Here is the URL for the Native Java Object Database :http://www.db4o.com/default.aspx

Understanding UDDI and JAXR

2006-12-28T15:16:00.000-05:00

UDDI Data Model

The UDDI data model contains the following main elements:

businessEntity: Represents a physical company.
businessService: Represents a service offered by a company.
bindingTemplate: Instructions on how to invoke a service.
tModel>: Good luck understanding this! (Just kidding, I will explain this later.)

Figure 1. The relationship between businessEntity,

businessService, bindingTemplate, and tModel

Here is a sample of tModel

company name: mycompany

Service name: helpline
tModel: key=11 (representing telephoneline),

 name=telephone,

       description=telephone stuff, url: byjava.com

binding:
  accesspoint: 1-800-my-helpline
     tModelInstanceInfo: 11

UML representation of a tModel