1.Introduction

2.Hibernate Architecture

3.Main Components of Hibernate

4.Hibernate Configuration

5.Hibernate Mapping File

6.Mapping Association

7.Basic API’s

8.Hibernate Data source properties

9.Complete Example

1: Hibernate Introduction:

While today’s applications are designed using Object Oriented Approach. As the business data is stored in the databases and applications create/fetches/update and remove these data for the business purposes. . Since both data storage and data handling are wast domain, over the period of time they are many vendors have provided mechanism for data data storage like oracle, db2 etc.. and similarly many application development technologies have enhanced theirs capabilities like J2EE,.Net etc.

The basic concept in Object Oriented approach is we consider the solution by identifying different Objects involved in the applications. Where as in case of Data bases there have evolved concept of RDBMS where data is stored in the Relational databases in tables and records. And application developer has to play the role of bridging this gap of data stored in tables and creating objects to be used in the object oriented programming. Developers has to write this data plumbing code as well as data processing code.

Hibernate came up with the solution of bridging this gap and providing all the necessary arrangements through which developer can just configure the required database and tables and later Hibernate will take care of data management work and developer just need to concentrate on data processing i.e. their application programming. Hibernates main advantage is the mapping of Objects data model with the corresponding table, developer do not need to bother about transforming data bases data in to objects. Object creation updation and persistence work will be done by hibernate.

2: Hibernate Architecture

Hibernate architecture is explained in the given figure below. Hibernates persistence layer lies between the data base layer and the application layer.

Figure1:

Hibernate Architecture

Detailed Architecture

Second figure explains the details architecture with all the components. Session Factory is singleton object for every databases. For every connection there will be a session created by this session factory, which can internally create mutiple transaction bases on the requirement.

Figure 2:

Hibernate Detailed Architecture

3: Main Components of Hibernate

Basic building blocks of the hibernate application are listed below:

3.1 SessionFactory org.hibernate.SessionFactory

This is a thread safe singleton immutable object of the database mapping. There is only one connection factory for each database. Its a factory for the hibernate session and it also maintains the second level cache between the application and database at the process level.

Usage example:<to be added>

3.2 Session org.hibernate.Session

This is single threaded an short lived object represents the conversation between the application and the database or persistence store. This is the wrapper over sql connection and works as the factory for the org.hibernate.Transaction. It mentains the first level cache of the application’s persistent object and collections. This cache is used while looking for the object using object id or while navigating the object graph.

Usage example:<to be added>

3.3 ConnectionProvider org.hibernate.connection.ConnectionProvider

This is optional and not directly exposed to the application developer, it represents the pool of connections. If require developer can implement this.

3.4 TransactionFactory org.hibernate.TransactionFactory

This is connection factory for the org.hibernate.Transaction, this is also not exposed to the developer but if require developer can implement this.

3.5 Transaction org.hibernate.Transaction

This is a single threaded short lived object use by the application to specify the atomicity of the work. It abstract the application from underlying jdbc/JTA implementation. Hibernate Session can maintaine more than one transaction also at a time.

3.6 Persistent Object

These are short lived business object represent the persistence state. They are associated with exactly one hibernate session. Once the session is closed they are free to used by the any layer of the application.

3.7 Transient and Detached Object

These are those instance of the persistence java classes whose objects are not yet associated or loaded with the session. They may have been instantiated by the application but not yet been associated with the hibernate session.

4: Hibernate Configuration File

This is the file where we specify the database level configuration. This file is read while application loads and then hibernate creates the connection pool with the specified database as per the specification. It also consist of entire set of mapping of Java Objects and Database tables.

Org.hibernate.cfg.Configuration object represent the entire set of mapping.

Configuarion and Sessionfactory objects:

SessionFactory factory = new Configuration.configure().buildSessionFactory();

Hibernate allows one Session factory for every database. Though it allows multiple session factory for more than one databases.

This is a simple example of the hibernate configuration file.

<?xml version=’1.0′ encoding=’utf-8′?>

<!DOCTYPE hibernate-configuration PUBLIC”-//Hibernate/Hibernate Configuration DTD//EN”

“http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd”>

<hibernate-configuration>

<session-factory>

<property name=”hibernate.connection.driver_class”>com.mysql.jdbc.Driver

</property>

<property name=”hibernate.connection.url”>jdbc:mysql://localhost:3306/mysql

</property>

<property name=”hibernate.connection.username”>root</property>

<property name=”hibernate.connection.password”>root</property>

<property name=”hibernate.connection.pool_size”>10</property>

<property name=”show_sql”>true</property>

<property name=”dialect”>org.hibernate.dialect.MySQLDialect</property>

<property name=”hibernate.hbm2ddl.auto”>update</property>

<!– Mapping files –>

<mapping resource=”contact.hbm.xml”/>

</session-factory>

</hibernate-configuration>

5: Hibernate Mapping File

We specify individual mapping for each database table. Mapping is declared between class with a table and respective column with the attributes of the class.

Mapping can be defined in following ways:

-Using Java 5 Annotations

-Using Hibernate legacy XML file.

5.1 Mapping using Java Annotation

Simple example of hibernate configuration using Annotation, here we can see we are explicitly specifying the mapping in the bean file itself using java 5 annotation.

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.Table;

@Entity

@Table(name = “contact”)

public class Contact implements Serializable {

public Contact() {

}

@Id

@Column(name = “id”)

Integer id;

@Column(name = “firstName”)

String firstName;

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getName() {

return firstName;

}

public void setName(String name) {

this.firstName = name;

}

}

5.2 Using Hibernate legacy XML file.

The traditional way of declaring the mapping is the hibernate configuration file and we can see in this example how we declare the same mapping by XML file.

This is the most simple and popular way of declaring the mapping, we can also specify the mapping between come other class and table in the same file or we can maintain separate mapping file for each table.

<?xml version=”1.0″?>

<!DOCTYPE hibernate-mapping PUBLIC

“-//Hibernate/Hibernate Mapping DTD 3.0//EN”

“http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd”>

<hibernate-mapping>

<class name=”roseindia.tutorial.hibernate.Contact” table=”CONTACT”>

<id name=”id” type=”long” column=”ID” >

<generator class=”assigned”/>

</id>

<property name=”firstName”>

<column name=”FIRSTNAME” />

</property>

<property name=”lastName”>

<column name=”LASTNAME”/>

</property>

<property name=”email”>

<column name=”EMAIL”/>

</property>

</class>

</hibernate-mapping>

…………………………….article to be completed soon !

Creating Drill Down Pivot Table:                                                                                                                                                                                                                                                       We can devide the work in four following logical sections. Each one has its own specific purpose.   

1: Adding event listener on Cell Click.

2: Fetching Selected Cell information on Cell Click.

3: Make another service call for this selected information.

4: Display the received drilled data in a grid\popup window or anyother option of your choice.

1: Adding event listener on cell click:

We know that in flex OLAPDataGrid is the UI component to display the Pivot table and OLAPCube is the model object which holds information of Pivot Dimentions.

<mx:OLAPDataGridFONT-SIZE: 10pt; COLOR: #990000; FONT-FAMILY: ‘Courier New’”>myOLAPDG”  defaultCellString=”" visible=”true” itemClick=”olapClick(event)” selectionMode=”multipleCells” allowMultipleSelection=”false” dataProvider=”{dataSet}”      />  

OLAPData grid is very much similar to the dataGrid component. Default grid allows you to select a row at a time, so you will have to specify that your selection usnit is Cell by setting property selectionMode=”multipleCell”.

We can add an event listener by setting it’s itemClick property by specifying a event listener function. You can also do this by using AddEventListener api at on page load. Other properties you see in code snippet are the normal we can specify with any normal pivot table always like dataprovider etc.                                   

2: Fecthing cell data on cell click.
We have written a function by name olapClick and calling the same on pivot click, now lets look into this fucntion. Main job of this fucntion is to findout the clicked cell and its correcponding Row and Column field name and it’s value.

function olapClick(event:ListEvent){
pvtSlectedColNo = event.columnIndex -1 ; // row count starts from 0 , but colum starts from 1
pvtSelectedRowNo = event.rowIndex;
pivotRowField = “EMPLOYEE”;
pivotRowFieldDim = “EMPLOYEEDim”;
pivotColField = “DATE”;
pivotColFieldDim = “DATEDim”;

var op:OLAPAxisPosition = myOLAPDG.selectedItem as OLAPAxisPosition;
var pivotData:OLAPResult= myOLAPDG.dataProvider as OLAPResult;
var cell:OLAPCell = pivotData.getCell(pvtSelectedRowNo,pvtSlectedColNo) as OLAPCell;
var axis:IOLAPResultAxis = pivotData.getAxis(1) as IOLAPResultAxis;
var dim:IOLAPDimension = myMXMLCube.findDimension(pivotColFieldDim) as IOLAPDimension;
var att:IOLAPAttribute = dim.findAttribute(pivotColField) as IOLAPAttribute;
var rowList:IList = att.children;
var temp:IOLAPMember = rowList[pvtSlectedColNo];
pivotColSelected = temp.displayName
var colList:Array = myOLAPDG.columns;
dim = myMXMLCube.findDimension(pivotRowFieldDim) as IOLAPDimension;
att = dim.findAttribute(pivotRowField) as IOLAPAttribute;
var rowList:IList = att.children;
var temp:IOLAPMember = rowList[pvtSelectedRowNo];
pivotRowSelected = temp.displayName

Alert.show(pivotDataSet+pivotRowField+pivotRowSelected);
Alert.show(tempData+pivotColField+pivotColSelected);
setDrillData();
}

In this function we have tried to fetch the value of selectedRow , selectedColumn, and selected Cell data. Later this value would be used for expandable report or view. We can use this piece of information to make another AJAX call by httpService request and once we receive the resultset of the second call we can populate this drilled down information in any other grid or popup window.

yet to write on last two sections…

Pivot table is a very useful tool for data anlysis in multiple dimention. This is one of the most usefull utility in Excel file to transform the tabular data into more useful and analyticl fashion. We can see below in s simple usecase how we can transform tabular data in to pivot table view.

Suppose we have given this source data, it would be little difficult to analys the day basis cost analysis for the employees.

Better solution is to transfor the given tabulare data into Pivot table for the given dimentions.

Pivot View: 

Creating Pivot in Adobe Flex:

Working with DataGrid comonent.

Adobe flex provides us many wiidgets and components for data presenation and data visualisation like table, grid, progressbas, list, pivot table, charts etc…

Befor going into pivot table, it is desired that developer should be comfortable with datagrid component of flex. 

To read more on adobe flex datagrid follow adobe live docs, it is explained in detail there:

http://livedocs.adobe.com/flex/3/html/help.html?content=dpcontrols_6.html

We will cover a small overview of datagrid comonent.

DataGrid definition in MXML part:

<mx:DataGrid id=”myDataGrid” dataProvider=”{pivotDataSet}” >
 <mx:columns>
       <mx:DataGridColumn headerText=”EMPLOYEE” ataField=”EMPLOYEE” />
       <mx:DataGridColumn headerText=”DATE” dataField=”DATE”/>
  <mx:DataGridColumn headerText=”COST” dataField=”COST”/>
  <mx:DataGridColumn headerText=”AMOUNT” dataField=”AMOUNT”/>
 </mx:columns>
</mx:DataGrid> 

Those who has worked datagrid would be familiar that we need to define a data provide for this grid and need to populate data through this data provider.

Filling data in dataprovider, we can have a httpService ajax call to fetch data from the servers and load into this data provider. We are not going in that topic as it is a separate section, so we assume that user has written required code to lad data into data provider.Looking at the abstract view of onDataReceive function, which you call upon receiving data from the httpService request.

private function onDataRcv(event:ResultEvent):void
{
 //fetch data from the result set data, as per your return value

//data structure
   gridData = dataRcvdFromResulSet;
} 

Having code ready till this level we assume that you datagrid is created and data is also populated.

Creating Pivot Table:

Pivot table compponent has two associated objects.

1. OLAPDataGrid: This object is used to display pivot table on your page, just like dataGrid component.

<mx:OLAPDataGrid id=”myOLAPDG”  temClick=”olapClick(event)”
selectionMode=”multipleCells” allowMultipleSelection=”false”/>

   2.   OLAPCube: Main object, like a model and holds full pivot defenition, inculuding pivot dimentions and hierarchy.

  <mx:OLAPCube name=”FlatSchemaCube”
        dataProvider=”{pivotDataSet}”
        id=”myMXMLCube”
        complete=”runPvtQuery();”>
    
        <mx:OLAPDimension name=”EMPLOYEEDim”>
            <mx:OLAPAttribute name=”EMPLOYEE” dataField=”EMPLOYEE”/>
            <mx:OLAPHierarchy name=”EMPLOYEEHier” hasAll=”true”>
                <mx:OLAPLevel attributeName=”EMPLOYEE”/>
            </mx:OLAPHierarchy>
        </mx:OLAPDimension>
   
        <mx:OLAPDimension name=”PRODUCTDim”>
            <mx:OLAPAttribute name=”PRODUCT” dataField=”PRODUCT”/>
            <mx:OLAPHierarchy name=”PRODUCTHier” hasAll=”true”>
                <mx:OLAPLevel attributeName=”PRODUCT”/>
            </mx:OLAPHierarchy>
        </mx:OLAPDimension>

        <mx:OLAPDimension name=”DATEDim”>
            <mx:OLAPAttribute name=”DATE” dataField=”DATE”/>
            <mx:OLAPHierarchy name=”DATEHier” hasAll=”true”>
                <mx:OLAPLevel attributeName=”DATE”/>
            </mx:OLAPHierarchy>
        </mx:OLAPDimension>
   
        <mx:OLAPMeasure name=”AMOUNT”
            dataField=”AMOUNT”
            aggregator=”SUM”/>
    </mx:OLAPCube>

 3:   runPvtQuery:  If you see in the above OLAPCude defenition, a function is specified on creation complete = runPvtQuery. Since we have already specified the dataStructure of the Pivot table and if you notice we have also specified the data source also, then what does this function do?.

This functions job is to run a query on this cube for the specified data set to fetch the desired out put.  You can imagine a group by kind of SQL query which gives you data in grouped format, this is also doing something like that.

private function runPvtQuery():void {
            var cube:IOLAPCube = myMXMLCube;
            var query:IOLAPQuery = getQuery(cube);
            var token:AsyncToken = cube.execute(query);
            token.addResponder(new AsyncResponder(showResult, showFault));
}

 4:   getQuery(): getQuery function actually performs the query on the given data set on the basis of specified dimensions. We cann see here that we have specifed row domension as EMPLOYEE and column dimension as DATE, so it will rearrand the data for the given dimensions and return the data set which can be feeded to the OLAPDataGrid.

 private function getQuery(cube:IOLAPCube):IOLAPQuery {
     var rwId = “EMPLOYEE”;
     var rwDim = “EMPLOYEEDim”;
     var colId = “DATE”;
     var colDim = “DATEDim”;
     var query:OLAPQuery = new OLAPQuery;
     var rowQueryAxis:IOLAPQueryAxis = query.getAxis    (OLAPQuery.ROW_AXIS);
    var RowSet:OLAPSet = new OLAPSet;
    RowSet.addElements(cube.findDimension(rwDim).findAttribute(rwId).children);
   rowQueryAxis.addSet(RowSet);
   var colQueryAxis:IOLAPQueryAxis = query.getAxis (OLAPQuery.COLUMN_AXIS);        
   var DATESet:OLAPSet= new OLAPSet;
    DATESet.addElements(cube.findDimension(colDim).findAttribute(colId).children);
   colQueryAxis.addSet(DATESet);
   return query;      
  }

Usually a program has logic to execute and some objects or data to modify. In a single threaded system program executes in a sequence line by line. Multithreaded system can allow multiple threads to execute a program parallel in multiple instances. If there is any part of code dealing with the object data modification, there is no guarantee that it will not be attempted any more than one thread at a time.

Now there a need to make sure that such kind of code should be executed exclusively. To achieve this in Java we a concept of LOCK. Using Lock mechanism thread holds complete hold on an object and object is also can not be access any other thread except the thread holding that lock. Lock is an object level control and one thread only can hold it at a time.

Synchronized: We have to specify about the piece of code in a program which should be run exclusively. It could be a code segment or a complete function. Synchronised can be used in following ways:

Function level synchronise will fetch a lock on the object, this function is defined in.

1)  synchronised function updateTotal(){

..

..

}

2)  a block of code can also be defined as synchronised with an specified object, to capture a lock control on. 

function updateTotal(){

..

..

Synchronised(this){

                ..

..

                }

}

Thread Sates or Life cycle. Thread follwos a life cycle, which starts from the threation till it is destroyed.

New State: This is the first state when thread object is created. Thread will be in this state untill the run method is not called of.

Runnable: Once the run method is called, thread goes in the runnble state.  While it is in a runnable state it is eligible to get process time to execute its part. Process though will keep disributing the time among all the active threads. Thread can also move to waiting state due to two reasons. 1 Timed waiting 2: Object waiting. Threads not in runnable states do not get process time.

TimedWaiting: Tread is forced to wait for some period of time may be by using Thread.sleep method. It will automatically come back to runnable state once specifiled time is over.

ObjectWaiting: Some time a thread need a lock on a object and that object is being used bus another prohram or thread, in this case thread will wait for this object untill the object is not free. Some time this can cause a deadlock schenario if there is a possiblility that threads are using same objects in multiple situations and if the program is not designed properly.

Inter Thread Communication: When threads are trying to access a common object and that is bieng used by another thread. Theres has to be some way to notify the waiting threads once that object becomes free. This is achieved by wait,notify, notifyAll machanism. Wait and Notify is a machanism by which we can send signals between the thread when some specific condition is met.

Live Example:
======================================
package corejava.threads;

import java.util.ArrayList;
import java.util.Random;

class Pool{
ArrayList pool = new ArrayList();
int maxSize=10;
public synchronized String popItem(){
if(this.pool.size() = maxSize){
System.out.println(“List Full !” + this.pool.size());
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
notify();
pool.add(item);
}

}

class Supplier extends Thread{
Pool poolSet;
public Supplier(Pool poolSet) {
this.poolSet = poolSet;
this.setName(“Supplier”);
}
public void run() {
while(true){
String rand = new Random().toString();
System.out.println(this.getName()+” Adding ” + rand);
poolSet.pushItem(rand);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}

}

class Consumer extends Thread{
Pool poolSet;
public Consumer(Pool poolSet) {
this.poolSet = poolSet;
this.setName(“Consumer”);
}
public void run() {
while(true){

System.out.println(this.getName()+” Read: ” + poolSet.popItem());

try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}

}

public class TestThread {
public static void main(String[] args){
Pool mypool = new Pool();
Supplier sup = new Supplier(mypool);
Consumer con = new Consumer(mypool);

con.start();
sup.start();

}
}

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

Above Example demonstrate three classes Pool , Consumer and Supplier as all are part defined under the main program so that class Consumer and Supplier have direct access to the object of Class Pool.

Otherwise if they are we can also pass PoolC class object to Consumer and Supplies class constructor if they are not under a same class.

Notify() and NotifyAll(): It’s a good question to ask that what’s difference between notify() and notifyAll() methos. Notify() method will send a signal to one of the thread waiting for the same object (this may depend on any criteria like thread priprity or it can also be random). Whereas notifyAll() will send signal to all the threads who are waiting for that object and then it is upto the processor which therads it allows to execute.

Sleep() method: Sleep method is a static method and called from the Thread class directly. Thread.sleep(100) and it throws intereuptException, so you have to catch it also.

wait() method: Wait is the method of Object class and should always be called from the synchronised block of code.

This article is written to describe a simple way of generating an Excel file in Java. We will be using an open source Java Excel API  ( jxl http://jexcelapi.sourceforge.net/ ) to dynamically generate an excel file and reading and modifying an existing excel file.

Using this technology we can directly generate an Excel file on the fly on a user request.

In a typical web application a user can request for an excel sheet based report from a web based application.

With the proper integration of this API and the server side backend data layer, we can transform the fetched data into an excel sheet. Later this excel sheet can be sent to client side using proper http response header information.

To begin with the application we need to download the jxl.jar file and put it under the project folder.  To download go to the URL: http://sourceforge.net, and under File section you have a link to download the required jar files.

Code side view:

We may need following classes depending on our need:

1)

import jxl.Workbook;

import jxl.format.Colour;

import jxl.format.UnderlineStyle;

import jxl.write.Label;

import jxl.write.Number;

import jxl.write.WritableCellFormat;

import jxl.write.WritableFont;

import jxl.write.WritableSheet;

import jxl.write.WritableWorkbook;

import jxl.write.WriteException;

import jxl.write.biff.RowsExceededException;

2) Create workflow object:

WritableWorkbook  wrtWorkbook = Workbook.createWorkbook(new

File(“MyExcel.xls”));

WritableSheet sheet1 ;

This function will create a writable workBook object. We can specify the location of the Excel file otherwise it will create in the current running folder. Later using defined API’s we can add worksheets on this workbook.

Note in case on reading excel sheet, we need to create WorkBook class

Object not WritableWorkBook.

3) Create worksheet :

sheet1 = this.wrtWorkbook.createSheet(“Sheet1”,0);

params: sheetname and location.

Here we have created a worksheet for the workbook, minimum one worksheet is required for a workbook to write some data in it. Like an Excel file one workbook can also contain more that one Sheet.

4) Adding cells :

sheet1.addCell(number);

Once the sheet object is created, we will use following API to write data in the specified cells. Here we are giving very simple demonstration but if require it also supports various kind of formatting.

To add number

Number number = new Number(colIndex, rowIndex, num);

sheet1.addCell(number);

To add string

Label label = new Label(colIndex, rowIndex, str);

sheet1.addCell(label);

5) Formatted Data

We can also specify specific format by using defined format classes:

WritableFont times10font = new WritableFont(WritableFont.TIMES, 10, WritableFont.NO_BOLD, false, UnderlineStyle.NO_UNDERLINE, Colour.BROWN);

WritableCellFormat times10format = new WritableCellFormat

Label label = new Label(colIndex, rowIndex, str, times10format );

6) Closing Worksheet

wrtWorkbook.write(); this function will write sheet into workBook

wrtWorkbook.close();

 —————————————————————–

Sending an Excel file along with the HTTP Response.

In a typical J2EE web application an http Request is processed in doGet\doPost method and a response is generated and send back to the client. We need to set response header to provide specific information about the content it carrying, so that browser can automatically detect the compatible application to open that.

resp.setHeader(“Cache-Control”, “max-age=30″);

resp.setContentType(“application/vnd.ms-excel”);

application/vnd.ms-excel defines that it is an excel spreadsheet application.

We can defile to send content in inline format or as an attachment.

resp.setHeader(“Content-disposition”,“inline; filename=MyExcel.xls);

here using java.io API’s we will write Excel file content in the response object.

ServletOutputStream sos = response.getOutputStream();

FileInputStream fio = new FileInputStream(“./” + “MyExcel.xls”);

while((c = fio.read()) != -1) {

          sos.write(c);

}

And that’s all. Its all set and Please go and receive the Excel file in the client’s browser.

Regards

Manjul  

—-

choti bate iskadar tum kia na karo…
zindagi mai dosto pe shakk kia na karo…
dosti to nam hai jine ka pyare….
is.me marene marne ki bate kia na karo…
—-

Kuch shiquawe kuch shiquayat ..ke bahane hi shi..

Tum yaad to karo iss rah gujaar ko kabhee…

Jubaan to se falsafe to hardum hi sune hai humne…

Inn aankho se bhi…. karo bayan is dil ko kabhi….

Last Dipawali ….when we were in school .

Today is 17^th October just three days are left for our grand celebration Diwali.  We are so exited about going home and meet our neighbors and friends .     I can easily differentiate the changes , taking place in our mind with the time and surrounding…

I remember those days when we were in schools….Diwali celebration was like :

We started making plans for diwali from more one month before. After leaving from the schools we used to see the market ..not one but 10 times before the final day. We started making string of light bulbs called “Jhalars” from a month back so that at the end time we can decorate fully and better than our last years competitors. As days were coming close we also have to go to the tailors to get our dress ready and fighting with parents for not taking us for our shopping. We also had to do some home-work, as a team member of our PM …I means our mom , she was keep on asking have you cleaned that corner , have you brought that “saman” goods. We also had to go for bringing diwali sweets and “namkeens”.

Finally its a time of going to market and purchase crackers,…. again we got less money, we need more and mom is saying why are you wasting that much of money in crackers but thanks god dad is with us . So we used to go with him and after bringing them, and did not forget to put them in sun-light so that in the night they will give more sound output. Finally diwali evening has come and parents are calling us from ground floor room to come down and do the pooja , I am calling my brother to come down and he is busy in lightening the crackers with his friends. Ok he came and pooja is started (it took around 1 hour ) after that we lighten the whole home with small light lamps ( I specially like this particular part of diwali very much) . Oh god what happened to this “Jhalar” its not working now we need to check it again…after some trouble finally it was started blinking. Now we are going for crackers my brother has already cracked half of his… and now asking mines…I used to give him bombs and rockets coz I like to see them from distant place but flower pot “anar” and fire wheel charkhee is still my unfavorite one.

We also had to go to our neighbor’s home to wish them happy diwaali and eat sweets and namkeens though most of the things are similar . Now lets take dinner and watch tv till late night ( usually diwali night all the channels showed a block buster movie) and then finally go to sleep.

Sweet Dreams……. becous these are only DREAMS now…..!

Radio Frequency Identification (RFID) is an radio waves sensor technology, relying on storing and remotely retrieving data using devices called RFID tags readers. An RFID tag is a small chip that can be attached to an object it could be a simple box or an animal, or person for the purpose of identification using radio waves. Chip-based RFID tags contain silicon chip and antenna. Passive tags require no internal power source, whereas active tags require a power source.
Types of RFID tags
Passive
Passive RFID tags have no internal power supply. A minute electrical current is induced in the small circuit as it is brought in the special magnetic region, generated by the tag Reader. This small power is sufficient to em-mite the response signals. Which can be traced by the Reader.

Active
Unlike passive RFID tags, active RFID tags have their own internal power source which is used to power any ICs that generate the outgoing signal. Active tags are typically much more reliable than passive tags due to the ability for active tags to conduct a “session” with a reader. They are more reliable in magnetic field ore naturally challenged region.

The RFID system
An RFID system may consist of several components: tags, tag readers, edge servers, middleware ( eg. Sun Java System RFID Software, IBM RFID Middle-ware), and enterprise application software.
The purpose of an RFID system is to enable data to be transmitted by a mobile device, called a tag, which is read by an RFID reader and processed according to the needs of a particular application. The data transmitted by the tag may provide identification or location information, or specifics about the product tagged, such as price, color, date of purchase, etc. RFID is being so popular because its ability to track moving objects. As the technology is refined, it is being used in different areas like asset tracking, transportation, inventory management, defense, health care etc. ..

How to develope a RFID prototype application

To develope a RFID prototype, companies like Java, IBM , sybase are we provideing their middleware . Sun has its SUN RFID 1.3 package , similarly IBM is also providing a framework to develope, test and deploy a rfis solution. IBM provides a architecture comprising Device developer kit ( will be used to develope edge controller which will controll rfid related hardware), RFID premises server which works between edge controler and your enterprise application.

feel free to ask more queries\details on RFID :
manjulx@gmail.com