Java Command-line flags for the JVM

DisableExplicitGC

-XX:+DisableExplicitGC flag automatically turns a System.gc() call into a no-op

HeapDumpOnOutOfMemoryError

 -XX:+HeapDumpOnOutOfMemory

Setting this command tells the JVM to take a "heap dump snapshot" and save it to a file for processing.
You can specify the actual path to which the file is saved using the corresponding -XX:HeapDumpPath flag.

java -X lists all the non-standard (but mostly safe) arguments that the JVM provides — things like:

    * -Xint, which runs the JVM in interpreted mode (which can be useful for testing whether the JIT compiler is actually having an effect on your code or verifying if you have a bug in the JIT compiler).
    * -Xloggc:, which does the same thing as -verbose:gc but logs to a file instead of spe
    
Source
http://www.ibm.com/developerworks/java/library/j-5things11/index.html

Java,Java Command Line Flags

MySQL Joins

Mysql Inner Join returns the set of  only those records which matches in one table with another.
If I do a regular JOIN (with none of the keywords INNER, OUTER, LEFT or RIGHT),
then I get all records that match in the appropriate way in the two tables,
and records in both incoming tables that do not match are not reported:

mysql> select name, phone, selling from demo_people join demo_property
            on demo_people.pid = demo_property.pid;

If I do a LEFT JOIN, I get all records that match in the same way and
IN ADDITION I get an extra record for each unmatched record
in the left table of the join - thus ensuring (in following example) that every
 PERSON gets a mention ie from demo_people table:

mysql> select name, phone, selling from demo_people left join demo_property    
    on demo_people.pid = demo_property.pid;    
   
If I do a RIGHT JOIN, I get all the records that match and
IN ADDITION I get an extra record for each unmatched record in the right table
 of the join - in following example, that means that each property (from demo_property )
gets a mention even if we don't have seller details.

mysql> select name, phone, selling from demo_people right join demo_property
           on demo_people.pid = demo_property.pid;

Mysql Full Join is used to return all the records from both left and right outer join.
The joined table contain all records from both tables and fill nulls values
for those missing matches on either side.
The Full Join in Mysql is the outcome result set of left outer join and right outer join using UNION clause.

mysql>  select * from Roseindia as R left outer join newstrack as N
    -> on  R.empid=n.empid
    -> Union
    -> select * from Roseindia as R right outer join newstrack N
    -> on R.empid=n.empid;

An INNER JOIN does a full join, just like the first example, and
the word OUTER may be added after the word LEFT or RIGHT in the 2nd & 3rd examples -
it's provided for ODBC compatibility and doesn't add an extra capabilities.  

Mysql Natural Join is a specialization of equi-joins. The join compares all columns in
both tables that have the same column-name in both tables that have column name in
the joined table. The resulting set include only one column for each pair of the same named column.
More Info http://www.roseindia.net/sql/sqljoin/mysql-natural-join.shtml

CROSS JOIN:This type of join is the simplest join. The cross join result in cartesian product of all the records from two tables
mysql> select  * from roseindia cross  join newstrack;

INNER JOIN OR EQUI JOIN:This is the type of join where tables are combined based on a common column.
OUTER JOIN: Join is used to combine all rows of one table with  matching rows from the other table and also show unmatchable records from other table. It is used whenever multiple tables must be accessed through a SQL SELECT statement.

http://www.roseindia.net/sql/sqljoin/mysql-join-query.shtml

Sources:
http://www.wellho.net/mouth/158_MySQL-LEFT-JOIN-and-RIGHT-JOIN-INNER-JOIN-and-OUTER-JOIN.html
http://www.roseindia.net/sql/sqljoin/mysql-full-join.shtml
For more info:
http://www.keithjbrown.co.uk/vworks/mysql/mysql_p5.php

Tags:MySQL,SQL Joins,

Spring aware interfaces

For the most part, beans running in the Spring container, They don't know (or
even need to know) their names or even that they are running within a Spring
container. This is usually a good thing because if a bean is aware of the container,
then it becomes coupled with Spring and may not be able to exist outside of the container.

A well designed component should not have direct dependencies on its container,  
But sometimes, beans need to know more. Sometimes they need to know the
truth who they are and where they are running.

This capability comes in the form of the
Bean-NameAware,
BeanFactoryAware,
and ApplicationContextAware interfaces .

By implementing these three interfaces,
beans can be made aware of their name, their BeanFactory, and their ApplicationContext, respectively.

However, by implementing these interfaces, a bean becomes coupled with Spring.

The Spring container tells a bean what its name is through the BeanNameAware
interface.

public interface BeanNameAware {
  void setBeanName(String name);
}

Spring's ApplicationContextAware and BeanFactoryAware interfaces enable a
bean to be aware of its container. These interfaces declare a setApplication-
Context() method and a setBeanFactory() method, respectively.

When to use?

your bean needs access to parameterized text messages in a message source.
Or maybe it needs to be able to publish application
events for application event listeners to respond to. Whatever the case, your bean
should be aware of the container in which it lives.
Spring,Java,Spring FAQ,

UDH in Binary SMS / Multipart SMS messsages

Multipart SMS messaging

By design, SMS is developed to send up to 140 bytes of user data. All user data is send in the 'User Data' part of the SMS packet. Because SMS text messages are encoded using 7-bit characters you can send up to 160 characters in a single SMS message. When sending Unicode text, you can only send 70 characters per single SMS message.
It is however possible to split up text and data messages and send them using multiple SMS messages. The receiving party will be able to combine the messages to the original message. This is called Segmentation and Reassembly (SAR). When sending multipart SMS messages you will be charged for every single SMS message sent.

Sending Multipart Messages through a GSM phone or modem

To send enhanced content, a so called user data header (UDH) is added add the beginning of the user data block of the SMS. When using an UDH, there is less data left for user data in the User Data field (140 - length of UDH).
An UDH can be used to send multipart messages, smart messaging (ringtones, WAP push, pictures etc), voicemail indications and other services. In this article we will only discuss the use of UDH to send multipart text messages.
The UDH for message concatenation will only take 5 bytes, so there are 135 bytes left for the user data. When sending concatenated text messages, you can send 153 characters when using 7-bit text, when using Unicode 67 characters per part.

Byte	Value	Description
01	00	Information Element Identifier: Concatenated short message, 8bit reference number
02	03	Information Element Data Length (always 03 for this UDH)
03	A4	Information Element Data: Concatenated short message reference, should be same for all parts of a message
04	03	Information Element Data: Total number of parts
05	01	Information Element Data: Number of this part (1/3)

Example of a multipart message consisting of 3 parts containing 300 bytes:
SMS 1 User Data: 00 03 A4 03 01 [ 135 bytes of message data ]
SMS 2 User Data: 00 03 A4 03 02 [ 135 bytes of message data ]
SMS 3 User Data: 00 03 A4 03 03 [   30 bytes of message data ]
Source and Full Info

User Data Header (UDH)

The SMS that make up a concatenated SMS are related together by using the User Data Header (UDH) of an SMS. The UDH is a collection of bytes which can be put at the start of the SMS content. It can be used to control what happens to the rest of the content. For instance, it was used to send the older style of Nokia picture messages.
To indicate that the content contains a UDH, a flag on the SMS called the UDH Indicator (UDHI) must be turned on. This tells the phone that it must separate the UDH from the rest of the content.

Figure:Format of an SMS with a UDH

The phone separates the UDH by reading the first byte of the content. The number in this byte is the length of the rest of UDH and is called the User Data Header Length (UDHL). The phone then knows how many bytes make up the UDH and can separate it from the rest of the message.
As already stated, a UDH can control various things and so can contain various commands. These commands are called Information Elements (IE's). These IE's always take the following format: an Identity Element Identifier (IEI) followed by the Length of the IE Data (IEDL) followed by the IE Data (IED). A UDH can contain 1 or more of these IE's.

Source and For full Info

Resources

1)Parameters with Definitions for Sending SMS and MMS

2)Sending Binary Messages using NowSMS