Learn Oracle Applications With Me

MSCA/MWA Framework - Custom Development and Extension - Part 2

2015-07-20T13:25:00.004+05:30

Technical Overview of MSCA/MWA Framework Continues...

Event Listener Model

MWAEvent

Event object passed to the listener methods in the handlers at the field, page, or app level.
public class MWAEvent extends java.util.EventObject
Frequently used properties and their getters and setters inherited from EventObject

public Object getSource()
public String toString()

Stores action property (private java.lang.String m_action)

public java.lang.String getAction()

Stores session property (private oracle.apps.mwa.container.Session m_session)

public Session getSession()

MWAEvent Listeners:

Listeners are utilised for validations, dynamic rendering of the fields, update the values etc. Following are the key Listeners:

oracle.apps.mwa.eventmodel.MWAListener

Parent class for all MWA Listeners.
public interface MWAListener extends java.util.EventListener
Direct subinterfaces - MWAAppListener, MWAPageListener, MWAFieldListener
We don't implement this interface directly.

oracle.apps.mwa.eventmodel.MWAAppListener

Application Level Event Listener
public interface MWAAppListener extends MWAListener
Methods -

void appEntered(MWAEvent e) throws AbortHandlerException, InterruptedHandlerException, DefaultOnlyHandlerException
void appExited(MWAEvent e) throws AbortHandlerException, InterruptedHandlerException, DefaultOnlyHandlerException

This interface is& typically implemented by our custom application's menu item bean.

oracle.apps.mwa.eventmodel.MWAPageListener

Page Level Event Listener
public interface MWAPageListener extends MWAListener
Methods -

void pageEntered (MWAEvent e) throws AbortHandlerException, InterruptedHandlerException, DefaultOnlyHandlerException
void pageExited(MWAEvent e) throws AbortHandlerException, InterruptedHandlerException, DefaultOnlyHandlerException
void specialKeyPressed(MWAEvent e) throws AbortHandlerException, InterruptedHandlerException, DefaultOnlyHandlerException

Ex. Generating Barcodes, Navigating to Main menu etc.

This interface is typically implemented by our custom application's page bean.

oracle.apps.mwa.eventmodel.MWAFieldListener

Field Level Event Listener
public interface MWAFieldListener extends MWAListener
Methods -

void fieldEntered(MWAEvent e) throws AbortHandlerException, InterruptedHandlerException, DefaultOnlyHandlerException
void fieldExited(MWAEvent e) throws AbortHandlerException, InterruptedHandlerException, DefaultOnlyHandlerException

Probably most important class in terms of the custom code that we need to write in this.
This interface is typically implemented in a standalone class.
The standalone field listener class is instantiated and referenced inside page bean, where we associate it with every field on the page.
Field Listener will typically have a constructor where session is passed from page and stored in a class variable.
Following are few important code snippet typically used in this field listeners:

To get the source of the event:

String fieldName = ((FieldBean)mwaEvent.getSource()).getName();

To check if it is a submit event:

if (mwaEvent.getAction().equals("MWA_SUBMIT"))

To get the current page details

session.getCurrentPage();

To show message in status bar:

this.ses.setStatusMessage("Qty Should be > 0");
this.ses.setStatusMessage("Trx Successful");

To set next field for user entry:

session.setNextFieldName();

To refresh the screen:

session.setRefreshScreen();

To throw exceptions:

throw new AbortHandlerException("Qty Should be > 0");

To signal end of transaction

setNextPageName("|END_OF_TRANSACTION|")

Most of the above code is from session, we'll see session details in coming section.

Other Important Classes - MWA Session Classes

oracle.apps.mwa.container.Session

public class Session extends oracle.apps.mwa.container.BaseSession
BaseSession is base class for user session and telnet session.
Key methods inherited from BaseSession

public java.sql.Connection getConnection()
public java.sql.Connection getConnectionFromSession()
public void returnConnection()
public java.lang.String getCurrentPageName()

Key methods in Session class

public PageBean getCurrentPage()

Returns the current page bean in the page bean list

public void setStatusMessage(java.lang.String msg)

Displays the argument string on the status bar.

public java.lang.String getStatusMessage()
public void setRefreshScreen(boolean RefreshScreenFlag)

This method set the refresh screen variable Whenever developer change the UI property of the page, e.g. hidden, value, creation of new field, etc, he/she needs to call this method with parameter true so that server will know and refresh the screen

public boolean isRefreshScreen()
public FieldBean getFieldFromCurrentPage(java.lang.String fieldName)
public void setNextFieldName(java.lang.String fName)

To set the cursor to some other field.

public java.lang.String getNextFieldName()
public Logger getLogger()

Application Flow

Coding Hints:

A. Ctrl + X shortcut key for About This Page is a good start for customizing existing functionality.

B. We typically create following 4 files:

XXABCTransactFunction.java

public class XXABCTransactFunction extends MenuItemBean implements MWAAppListener
With following two lines in constructor:

setFirstPageName("xxabc.oracle.apps.xxabc.applpkg.module.server.XXABCTransactPage");
addListener(this);

It'll have appEntered() and appExited() methods.

XXABCTransactPage.java

public class XXABCTransactPage extends PageBean implements MWAPageListener
Typically it'll have following Member variables:

For all field beans
For session
For FieldListener for all fields

Constructor will initialize FieldListener bean (Explained Next)
Constructor will initialize all fields, associate field listener and add them to page hierarchy.
It'll have pageEntered(), pageExited() and specialKeyPressed() methods.
It'll have methods for business transactions typically calling PLSQL procedures.

XXABCTransactFListener.java

public class XXABCTransactFListener implements MWAFieldListener
Typically it'll have following Member variables:

session

Paramterized Constructor with session variable will initialize member session variable.
Rarely we need to write code in fieldEntered() method.
FieldExited() will have bulk of the coding based on current page and field exited:

String fieldName = ((FieldBean)mwaEvent.getSource()).getName();

To identify the field exited.

this.ses.getCurrentPage();

To identify the current page

For transaction logic, it'll have a call to the pageBean's transaction method.

XXABCFieldLOV.java

public class XXABCFieldLOV extends LOVFieldBean implements MWAFieldListener
Since LOVs are shared components, for easy of use/reuse we usually create them as separate Java files.
It'll have member variables, their getters and setters for the return values of the selected LOV record.
It'll have constructor will following api calls:

setName(), setRequired(), setPrompt(), setValidateFromLOV(), setlovStatement(), setInputParameterTypes(), setSubfieldPrompts(), setSubfieldDisplays(), addListener(this).

It'll have fieldEntered() method (usually empty).
It'll have fieldExited() method (usually we set all the return values from selected LOV record to member variables).

Sample Code for all Files:

Standard Oracle MWA code provides good insight in how to write code. If still any help is needed, please reach me.

Steps to test the code:

Deploy it on the server.
Restart the server.
Testing on desktop telnet client.
View the log for debugging.

Debugging:

Steps to enable logging are in document 338291.1

Log files are located in $INST_TOP/logs
Logging Levels are Fatal, Error, Warning, Debug and Trace.
All Log files start with telnet port number as prefix.

In java code following method is used to write log statement:

oracle.apps.inv.utilities.server.UtilFns.trace()

In java code to check if trace is enabled:

if (UtilFns.isTraceOn)

In PLSQL, following code will be used
Use Mirroring
Check Mobile Services are up and Runing:

ps -ef |grep mwa
./ $INST_TOP/admin/scripts/mwactl.sh status

Check MWA user sessions

netstat -a |grep <MWA PORT> | wc -l
netstat -an | grep <MWA PORT>

Find port Number of Mobile Services :

grep mwa $CONTEXT_FILE

Connect to Mobile Services :

telnet hostname.domainname portnumber(mobile application service port_number)

MWA Troubleshooting Tips for Release 12 (Doc ID 782162.1)

Reference and Further Reading:

Note 578667.1 - Customization of Oracle Mobile Supply Chain Applications and Oracle Warehouse Management System
Note 959087.1 - How To Download The MSCA/WMS JAVADOCS Files For Doing Customization?
Note 338291.1 - How to Enable WMS / MSCA Logging
Note 297992.1 - Advanced Barcode Strategies – Custom Scan Framework & profile option "MWA: Custom Scan"
For Multi-lingual Support and DFI (Data Field Identifier) - Integration with AK repository is needed.

Previous Read: MSCA/MWA Framework - Custom Development and Extension - Part 1
Previous Read: Oracle MSCA/MWA Framework - Introduction

MSCA/MWA Framework - Mobile Personalization

2015-07-20T13:21:00.001+05:30

Mobile Personalization:

Mobile personalization enables you to customize Oracle Warehouse Management pages without making code changes. Personalization support is present in R12.1.X onwards. Personalization metadata is stored in database level similar to OAF personalization. Following are typical examples of personalizations:

Hide fields and buttons
Provide default field values
Copy the value of a field to another field
Set editable fields as read only
Set non-required fields as required.

Personalization Level:
Similar to OAF Personalization, Following are various levels of personalization for Mobile Pages:

Function
Responsibility
Organization (Inventory Org)
User

Personalization Support in Pages:

There are around 40 pages (No. of pages vary from release to release) that support personalization. Customers can raise request for new pages to allow personalization. Following are some example:

Assembly Completion by LPN
GME Mobile Backflush
GME Mobile Complete Product
GME Mobile Create Pending Lot
GME Mobile Issue Ingredients
Lot Attributes Page - PO Receipt
Mobile ASN Receipt
Mobile Alias Issue
Mobile Alias Receipt
Mobile Cycle Count
Mobile Inspect LPN
Mobile Item Inquiry
Mobile LPN Inquiry
Mobile LPN Ship
Mobile LPN Ship - Ship Confirm
Mobile Move Order Replenishment
Mobile Org Transfer
Mobile PO Receipt
Mobile PO Receipt Information
Mobile Physical Count
Mobile Pick Drop - Mobile WMS Drop Loaded LPNs
Mobile Pick Load - Mobile WMS Manual Picking
Mobile Replenish Kanban
Mobile Sub Transfer
Mobile WMS Inbound Manual Load
Mobile WMS Inbound Manual Load - Select Contents
Mobile WMS LPN Split
Mobile WMS Manual Picking
Mobile WMS Move Any LPN
Mobile WMS Move Any LPN (Select Item)
Mobile WMS Pack
Mobile WMS Unpack
Mobile WMS Update LPN

Pre-requisite and Setups needed:

WMS Setup should be completed
Set profile option "MWA: Enable Personalization" to Yes.
Set profile option "MWA: Cache Personalized Metadata" to No. If this profile option value is set to Yes, then bounce will be required after personalization. Setting the profile option to Yes, results in better performance for personalized pages.

Steps To Personalize:

Navigate to "Warehouse Manager > Setup > MWA Personalization Framework".
Select the mobile page/function.
Click Personalize
Edit the field to personalize

Update the Prompt/Default Value/Rendered/Read Only/Required etc properties.

Click on Activate/Deactivate Personalizations to activate/deactivate personalizations on that page.

DFF on Mobile Screen:

If DFF is present on mobile screen, it can also be personalized. Example - LPN DFF.
DFF can be in-line - DFF fields are displayed along with other fields on page. If DFF is not in-line, pressing Ctrl + F will open the DFF window.

Reference:
Note 469339.1 - Oracle WMS Personalization Framework
Note 1600812.1 - Mobile Supply Chain Applications (MSCA) Personalization - Webinar
Note 470011.1 - What WMS Patchset Is Required In Order To Personalize MWA Per Note 469339.1?
Note 961198.1 - Mobile Personalization White Paper

MSCA/MWA Framework - Custom Development and Extension - Part 1

2015-07-20T13:18:00.001+05:30

MWA Responsibilities, Menu and Functions

The way we create responsibilities, menus and functions is similar to other oracle applications.

Responsibilities:

Responsibilities should have "Oracle Mobile Applications" selected in "Available From".

Menu:

Menu are normally created with menu type "Standard".

Function:

Function should be created with type "Mobile Applications".

HTML Call of the function should point to java class full name for menu item bean (We'll discuss more on this in coming section.

Technical Overview of MSCA/MWA Framework

In technical overview of the MSCA/MWA Framework, we need to understand Mobile Application Beans (Mobile Application Screen UI Construction) and Event Listener Model (Event Handling like Page Enter, Field Exit, Button click etc):

Mobile Application Beans

Following are key Mobile Application Beans:

oracle.apps.mwa.beans.MWABean

public class MWABean extends java.lang.Object implements java.io.Serializable
Base class for all UI beans.
MenuItemBean, PageBean, FieldBean, FlexfieldBean all extend from this class.
Maintains a list of MWA event listeners (protected java.util.Vector m_listeners).

public void addListener(MWAListener Listener)
public void removeListener(MWAListener Listener)
public java.util.Vector getListeners()

We don't use this bean directly in our coding.

oracle.apps.mwa.beans.MenuItemBean

public class MenuItemBean extends MWABean
Connects FND Menu Structure to Mobile Application. FND Form function for the Mobile Application points to a MenuItemBean.
As per naming convention, MenuItemBean ends with suffix "Function".
It stores the key name of the first page of the mobile application (protected java.lang.String m_firstPageName).

public java.lang.String getFirstPageName()

public void setFirstPageName(java.lang.String FirstPageName)

Example - Following statement is typically written in the Constructor:

setFirstPageName("xxabc.oracle.apps.abc.xyz.inv.invtxn.server.MyFirstCustomPage");
FirstCustomPage is custom PageBean.

Other functions it provides are to set/get the menu confirmation message:

public void setMenuConfirmMessage(java.lang.String msg)

public java.lang.String getMenuConfirmMessage()

oracle.apps.mwa.beans.PageBean

public class PageBean extends MWABean
Base class for all user developed page level beans.
Contains the page prompt which is displayed to the end user as the title of the page (protected java.lang.String m_prompt)

public void setPrompt(java.lang.String Prompt)
public java.lang.String getPrompt()

Maintains list of field beans which are part of this page (protected java.util.Vector m_fieldBeans) and current field indicator (protected int m_curtField):

public void addFieldBean(FieldBean FB)
public void addFieldBean(int index, FieldBean FB)
public void removeFieldBean(FieldBean FB)
public void removeAllFieldBeans()
public int getCurrentFieldIndex()
public int getFieldIndex(java.lang.String key)
public FieldBean getCurrentFieldBean()
public java.util.Vector getFieldBeanList()
public void setFieldBeanList(java.util.Vector BeanList)

Contains Session for the page (protected Session m_session) Session Handling methods:

public Session getSession()
public void setSession(Session sessionObject)

Other key methods:

To return the full name of the pagebean: public java.lang.String getName()
To mark if a page bean is to be instantiated upon each visit during runtime: public boolean isMultipleInstance(), public void setMultipleInstance(boolean MultipleInstance)

Typically as first step, we declare the FieldBeans in pageBean class's declaration section, and generate getters and setters for the fieldbeans. In Constructor to add field beans, modify fieldbean properties, change the order of the fieldbeans, associate field Listener to field beans (Details on FieldListener will be covered later).

For code examples - please refer FieldBean.

oracle.apps.mwa.beans.FieldBean

public class FieldBean extends MWABean
Base class for all field level beans.
Important Subclasses - ButtonFieldBean, HeadingFieldBean, InputableFieldBean (With Subclasses - LOVFieldBean, MultiListFieldBean, TextFieldBean), ListFieldBean, MessageFieldBean.
Maintains name property of the field (protected java.lang.String m_name)

public java.lang.String getName()
public void setName(java.lang.String Name)

Maintains prompt property of the field (protected java.lang.String m_prompt)

public java.lang.String getPrompt()
public void setPrompt(java.lang.String Prompt)

Maintains hidden property of the field (protected boolean m_hidden)

public boolean isHidden()
public void setHidden(boolean Hidden)

Maintains type of field (protected short m_type):

default is INPUTTEXT.
public int getType()
Possible Values include:


public static short TEXT
public static short LOV
public static short MULTILIST
public static short LIST
public static short BUTTON
public static short CHECKBOX
public static short RADIO
public static short HEADING1
public static short HEADING2
public static short LINESEPARATOR
public static short SPACESEPARATOR
public static short MENUITEM
public static short RESPONSIBILITYITEM
public static short LOVRUNTIMEITEM
public static short MULTILISTRUNTIMEITEM
public static short DESCFLEX
public static short KEYFLEX
public static short SEGMENTLOV
public static short SEGMENTTEXT

oracle.apps.mwa.beans.FlexFieldBean

public class FlexfieldBean extends MWABean implements oracle.apps.fnd.flexj.event.FlexfieldListener
It represents the flexfield in the Mobile Applications
Constructor - public FlexfieldBean(oracle.apps.fnd.flexj.Flexfield flexfield, oracle.apps.mwa.container.Session session)
Maintains boolean variables and getters and setters for readonly, hidden and required (private boolean m_readonly, m_hidden, m_required):

public boolean isRequired()
public void setRequired(boolean requiredFlag)
public void setHidden(boolean hiddenFlag)
public void setReadonly(boolean readOnlyFlag)
public boolean isReadonly()

Important Flexfield related APIs:

```
public Flexfield getFlexfield()
```

protected boolean addSegmentBean(Segment Seg)

protected void removeSegmentBean(Segment Seg)

Following are three most frequently used beans on Mobile Application Pages:

oracle.apps.mwa.beans.TextFieldBean

public class TextFieldBean extends InputableFieldBean

Constructor: public TextFieldBean()
Frequently used properties and their getters and setters inherited from FieldBean:

name, prompt, hidden

Frequently used properties and their getters and setters inherited from InputableFieldBean:

editable (protected boolean m_editable)
required (protected boolean m_required)
display length (protected int m_length)
value (protected java.lang.String m_value)
value type (protected java.lang.String m_valueType)

Possible values are: S - String, N - Number, D - Date, C - Calculation, R - Range

Maintains password property (protected boolean m_password)

```
public boolean isPassword()
```

public void setIsPassword(boolean IsPassword)

Maintains navigation to next page property (protected java.lang.String m_nextPageName)

public java.lang.String getNextPageName()

public void setNextPageName(java.lang.String NextPageName)

oracle.apps.mwa.beans.LOVFieldBean

public class LOVFieldBean extends InputableFieldBean
Constructor: public LOVFieldBean()
Frequently used properties and their getters and setters inherited from FieldBean:

name, prompt, hidden

Frequently used properties and their getters and setters inherited from InputableFieldBean:

editable, required, display length (length), value, value type

Maintains navigation to next page property (protected java.lang.String m_nextPageName)

public java.lang.String getNextPageName()

public void setNextPageName(java.lang.String NextPageName)

Maintains LOV Statement (protected java.lang.String m_lovStatement)

This is mandatory to be set.
Store SQL query or PL/SQL procedure with a reference cursor output parameter.

public void setlovStatement(java.lang.String LovStatement)

public java.lang.String getlovStatement()

Maintains key names, prompt, types, rendered property of the subfields of the Lov page, (protected java.lang.String[] m_subfieldNames, protected java.lang.String[] m_subfieldPrompts, protected java.lang.String[] m_subfieldTypes, protected boolean[] m_subfieldDisplays ).

The size of these arrays should be same.

public java.lang.String[] getSubfieldNames()

public void setSubfieldNames(java.lang.String[] SubfieldNames)

public java.lang.String[] getSubfieldPrompts()

public void setSubfieldPrompts(java.lang.String[] SubfieldPrompts)

public java.lang.String[] getSubfieldTypes()

public void setSubfieldTypes(java.lang.String[] SubfieldTypes)

```
public boolean[] getSubfieldDisplays()
```

public void setSubfieldDisplays(boolean[] SubfieldDisplays)

Maintains key names of the input parameters and parameter types (protected java.lang.String[] m_inputParameters, protected java.lang.String[] m_inputParameterTypes)

public java.lang.String[] getInputParameterTypes()

public void setInputParameterTypes(java.lang.String[] InputParameterTypes)

public java.lang.String[] getInputParameters()

public void setInputParameters(java.lang.String[] InputParameters)

Maintains values returned from LOV or selectec values (protected java.util.Vector m_selectedValues)

public java.util.Vector getSelectedValues()

```
public boolean isPopulated()
```

Maintains lov validation required property (protected boolean m_validateFromLOV)

Specifies if user has to always go through LOV page - if false, value in the field is accepted without validation.
Default is True.

public void setValidateFromLOV(boolean validateFromLOV)

```
public boolean isValidateFromLOV()
```

oracle.apps.mwa.beans.ButtonFieldBean

public class ButtonFieldBean extends FieldBean
Constructor: public ButtonFieldBean
()
Frequently used properties and their getters and setters inherited from FieldBean:

name, hidden (behavior of prompt is different for buttons as it includes accelerator keys)

Maintains button prompt property with accelerator key (protected java.lang.String m_prompt):

public void setPrompt(java.lang.String s)

public void setPrompt(java.lang.String s)

If we call setPrompt("&Done"), getPrompt() will return "Done".

'D' will be the hot key for "Done" button

Maintains navigation to next page property (protected java.lang.String m_nextPageName)

public java.lang.String getNextPageName()

public void setNextPageName(java.lang.String NextPageName)

Maintains accelerator key enable/disable property (protected boolean m_enableAcceleratorKey)

public void setEnableAcceleratorKey(boolean b)

public boolean isAcceleratorKeyEnabled()

Please proceed to MSCA/MWA Framework - Custom Development and Extension - Part 2 to read more.
Previous Read: Oracle MSCA/MWA Framework - Introduction

Oracle MSCA/MWA Framework - Introduction

2015-07-20T13:16:00.001+05:30

MSCA

Stands for Mobile Supply Chain Application.
MSCA is for staff in warehouse, shop floor, most of whom are always on the move.
MSCA trasactions are carried out from hand-held devices.
To efficiently operate and infuse visibility in the system - RFID (Radio Frequency Identification) readers are used by warehouse/shop floor staff to read barcodes and use them in transactions.
Items, Locators, Sub-Inventories etc are barcoded and these barcodes are not entered manually but scanned with the handheld devices while performing transactions thus providing efficiency, speed as well as accuracy.

MWA

Stands for Mobile Web Application.
MWA is telnet based application that runs on internet (WIFI and GPRS) based wireless devices.
Telnet client is configured on the handheld device, for testing it is used on desktop.
MWA Applications are based on Java.
MWA is part of WMS (Warehouse Management System).

MWA Architecture:

Fortunate enough to get a chance to closely observe and experience warehouse transactions using handheld devices. Typical work on MWA Applications:

Development of custom screens for handheld devices.
Extend the existing MWA screens.
Personalize existing MWA screens.

Technical Skills Required:

Java
PLSQL
XML

Softwares Required:

JDK to be installed in system.
Mobile Wireless Applications (MWA) J2ME Telnet GUI Client.

Navigation

Navigation on mobile device uses "Enter" key.
"Enter" key will fire fieldExited event.
Whenever we scan a barcode, barcode will populate the value and there is an associated "Enter" key for navigation to next field.

Key Mappings

Key mappings are visible on mobile help screen on pressing "F1" (Standard key for Help).

Following are standard key mappings:

Shortcut Key	Purpose
F1	Help
F2	Menu
F3	Back
F4	Forward
Ctrl K	Clear
Ctrl L	LOV
Ctrl M	Responsibility Menu
Ctrl B	Long Description of status message
Ctrl Z	Toggle between options in a list field
Ctrl A	Show Current Field on page
ESC	For Hot Keys
Ctrl Z	Toggle between options in a list field
Ctrl D	Page Up
Ctrl C	Page Down
Ctrl G	Generate (Generate Serial Number etc)
Ctrl S	Skip Task on Task Page
Ctrl X	About Page
Ctrl F	Open Flexfield Window

MWA Configuration

$INST_TOP/admin/install/mwa.cfg stores the MWA configuration.
Following are the key configuration variables in this file:

mwa.DbcFolder
mwa.DbcFile
mwa.logdir
mwa.LogLevel
mwa.SystemLog
mwa.EnableLogRotation
mwa.MaxLogFileSize
mwa.SubmenuChangeOrgResp

Refer to MSCA Implementation Guide> MWA Server Setup > MWA Configuration File for more details.
Key mappings can be modified for a particular device ($INST_TOP/admin/install/Device IP.ini) or all devices ($INST_TOP/admin/install/default_key.ini). (Refer to MSCA Implementation Guide> MWA Server Setup > Key Mappings).

Steps to Configure MWA Client:

MWA Client needs to confirmed
Search for "Mobile Wireless Applications (MWA) J2ME Telnet GUI Client" or "Latest MWA GUI Client" etc on oracle support. Latest patch that I found and tried was 12780257. Patch "Read me" file contains details on patch installation.
https://support.oracle.com/epmos/main/downloadattachmentprocessor?parent=DOCUMENT&sourceId=294670.1&attachid=294670.1:1&clickstream=yes

MWA Administrator

Standard MWA responsibility for MWA for Mirroring and Sending message to another mobile device for communication.

Mirroring Mobile Session

MWA Administrator > Telnet Session Monitor can be used to mirror an active session of another user.
Both users must be on the same MWA Server.
This can greatly help in debugging and supporting MWA Applications.

Send Message

MWA Administrator > Send Message can be used to send a brief message to another user.
Both users must be on the same MWA Server.
User will see the message on any key press.
After pressing OK, user can continue with their transaction.

Starting/Shutting MWA Server

Location of Scripts - cd $INST_TOP/admin/scripts
Start Command - mwactl.sh start [port number]

Ex. mwactl.sh start 6060

Shutdown Command - mwactl.sh-login xxx/yyy stop/stop_force [port number]

mwactl.sh -login cbaker/welcome stop 6060
mwactl.sh -login cbaker/welcome stop_force 6060

Hardware devices typically used:

Barcode Printer
Ribbon for barcode printing
Rugged/Semi-rugged mobile devices
lamination labels

Please proceed to MSCA/MWA Framework - Custom Development and Extension - Part 1 to read more on custmization in MSCA/MWA Framework.

Please proceed to MSCA/MWA Framework - Mobile Personalization to read more on Personalizing standard MSCA/MWA Screens.

Responsive Web Design

2014-01-14T00:50:00.001+05:30

Designing webpages in a way that webpage adapts to the visible area (Width and Height) of the screen.
Page layout should expand or shrink smoothly and alter itself to optimize and enhance the user experience.
Term "Responsive design" is generally used in the context of mobile devices but responsive design also covers wide screen devices like Smart TV and Gaming Consoles.

There is possibility of size related issued in wide screen devices, so that should also be considered.

Earlier web pages were mostly being viewed in desktops but the same is not true today. Today we don't know the size of the device where our webpage will be viewed. Thus the need for webpages to be designed for various screen sizes and browsers.
Adaptability is the buzz word for Responsive Design.

Focus on more than just Phablets

Different UI Device sizes -

Smartphones
Tablets
Desktops
Wide Screen Smart TVs and Gaming Console

Mobile First Design Approach

Its a good practice to design first for the mobile in a linear manner and then organize the widgets for wider screens.
Designing for the mobile environment comes with a natural set of constraints.
These constraint provides the much needed focus and are good for the overall User Experience.

Importance of Unlearning

We need to forego outdated information and learn new age knowledge.

Earlier TV used to be called Radio with pictures. Radio programs are supplemented with running commentary because expressions, movement of actors was not visible. Older TV programs also used to be supplemented with running commentory though not needed.
Traditionally designing was always done for a constraint canvas whether it is -

Cave Painting (where cave wall was our canvas)
Stone sculpture (where stone was the canvas)
Painting
Newpaper Design
Business Card Design
Wedding Card Design (list is endless).

Even most of the webpages were designed with desktops in mind.

A Not that Good Solution Approach

Device Experience

Having different website for mobile and desktops:
It doesn't address the problem of adaptability.
We are still applying constraints on our design.
URLS cannot be shared between devices.
Doesn't address the landscape and portrait layouts on the mobile devices.

Related Points to remember

Mobile Users Deserve the Same Quality of Browsing Experience.
A simple HTML file in a web browser automatically adapts to fit the width of that browser. We have been breaking the responsiveness of the web over the years by designing to constraints.
Mobile browsers have the ability to take the full-size webpage and scale it to fit on the browser's screen. This gives users the ability to pinch and zoom in order to read it.

The idea for responsive design is that user should not be doing pinch and zoom to read it, content should get rearranged for the optimal user experience.

Hover can't be used on Smartphones and many other devices, thus special care is needed while designing websites relying on Hovers.

Most touch devices activate the hover state on tap.

There is a need to ensure sufficient spaces between the two actions (navigations/buttons etc), this is needed to ensure that user could easily tap with the fingers.
Font Selection, Menus, Links should also consider different devices.
If the requirement is not to expand or shrink the image with the window size but just reducing the width of the image by hiding the overflow the image, then consider using background image.

Steps to Responsive Design

Responsive design uses feature detection (mostly on the client) to determine available device capabilities and adapt accordingly.

Responsive design is achieved with a combination of following to change layout based of the size of the viewport:

Flexible Grids,

As much as possible use proportions for measurement and never design for a fixed layout.

Width, Font size also should be relative (width in percentage and Font Size in ems).

Margins, Padding should also be relative.

Flexible Images and Media,

Width of images should always be entered and needs to be relative.

Max-Width should be set to 100%.

Wide images overflow out of the containing window if the size is reduced. "Max-Width" prevents the value of width property from becoming larger than max-width.

With max-width property set, img element will render at whatever size it wants, as long as it’s narrower than its containing element.

It gives us floating image.
   img,
   embed,
   object,
video {

max-width: 100%;

height:auto;

// To ensure the image is not getting distorted.
   }

If we wish to hide the excess image data, we can also use "overflow:hidden".

Media Queries

Media Queries is a CSS3 module allowing content rendering to adapt to conditions such as screen resolution (e.g. smartphone vs. high definition screen).
It is cornerstone of Responsive Web Design.
It is an improvement on CSS2 Media Types, which allowed us to provide different CSS properties for different media types, thus allowed us to control the document presentation on different devices.

Refer to W3C specification for more details.
Different Media Types - all, braille, embossed, handheld, print, projection, screen, speech, tty, and tv.

Example -

<link rel="stylesheet" href="main.css" media="screen" />
@media screen {
    .container {
        width: 90%;
    }
}
@media handheld {
    body {
        font-size: 110%;
    }
}

Media types were first towards in the direction of Responsive Design but not sufficient for Responsive Design thus came Media Queries.

Media Queries are used to customize CSS for specific types of media, inspecting the physical characteristics of the devices and browsers.

Following are the two components of Media Queries:

Media Type

Condition comparing a feature to a value in parenthesis.

We can have more than one condition linked with And/Or etc.

Popularly used to compare width but other features like height, device-width, device-height, orientation, aspect-ratio, device-aspect-ratio, color, resolution, scan etc.

Examples:

<link rel="stylesheet" href="style_screen_wide.css" media="screen and (min-width: 960px)" />
@import url("style_screen_wide.css") screen and (min-width: 960px);
@media screen and (min-width: 960px) {
    .container{
       width : 90%;
    }
}
@media screen and (min-device-width: 480px) and (orientation: landscape)

Viewport Meta Tag

Term 'Viewport' refers to window of the browser.

Used along with Media Queries to control the responsive design.

Mobile browsers have the ability to take the full-size webpage and scale it to fit on the browser's screen. The default window size of the page is taken as 980px and then browser scales it to the mobile's width.

This is because before responsive design became popular, the expectation was to get fix-width desktop experience on mobile device.

To overcome this Apple introduced the viewport meta tag, most others adopted this but its still not a standard from w3c.

Viewport metatag is placed inside the head and is used to control the scale of the page.

Viewport tag allows us to control the size of that canvas, and override that default behavior.

Examples -

<meta name="viewport" content="width=320" /> // Bad Idea because of hardcoding width to 320px.
<meta name="viewport" content="initial-scale=1.0, width=device-width" /> // setting the width to 100% of the width of device.

Initial scale means default view is without zoom, we could also set the max-scale if we wish to disable (value = 1) or restrict the feature of pinch and zoom to 200% or any other value.

Breakpoints

On altering the screensize(growing or shrinking), we'll reach a point where the layout design will get altered to suite this new size like rearranging of fields, shift from 3-column layout to 2-column or stack, Font sizes will reduce etc.
How many breakpoints and where to set them depends on the website, but there are few tools which can help in this. Ex. web developer extension from chrispederick.
Examples -

<480px - Smaller smartphone screen sizes

<768px - Larger smartphones and smaller tablets

>768px - Large tablet screens and desktops screens.

<320px - Low resolution phones and other devices like barcode reader

>1024px - Wide screens devices

Cross Browser Testing Tools

There are many services for performing cross-browser testing, following are few examples:

browserstack.com
crossbrowsertesting.com

Support for Older Browsers

Following are helpful when it comes to support HTML5 and CSS 3 features in older browsers:

caniuse.com
modernizr
html5shiv

There are many JS based solutions available for HTML5 and CSS3 features not available in older browsers.

Some Words of Caution

Most responsive websites take more time to load.

A responsive website deliver large amounts of code (which is even more when a RWD framework is used) irrespective of the device.
Processing power/Rendering capabilities of a smartphone are much lower than the desktop, the amount content/data/code greatly impacts the rendering time.
Compress page resources (using GZIP etc) for easier transmission across networks is a good practice.
Modular/Multiple css files are very convenient for development but not ideal scenario for deployment. Using CSS Preprocessor like SASS, LESS etc help in easy management of CSS during development as well as production.
Reducing the image sizes using tools like tinypng can reduce data transmission.
Using service like adaptive-images.com, which detects your visitor's screen size and automatically creates, caches, and delivers device appropriate re-scaled versions of your web page's embeded HTML images.
A Content Delivery Network (Network of various servers to serve content at various locations to reduce network time) for Static Content can improve performance.
Using a Content Management System can also help in improving performance.

Few Popular examples of Responsive Websites:

Time.com
living.is
Expedia.com

Key Terms

Adaptive Design

Another term for RESS.

Breakpoint

On altering the screensize(growing or shrinking), we'll reach a point where the layout design will get altered to suite this new size like rearranging of fields, shift from 3-column layout to 2-column or stack, Font sizes will reduce etc.

Device Experience

Design strategy with different websites for each device. It is used for maximum optimization for each type of device.

Display Area

Browser's viewport.

Media Type

First Attempt at the responsive design, part of CSS2 specification.
HTML 4 and CSS2 currently support media-dependent style sheets tailored for different media types.
Created by W3C for classifing each browser or device under a broad, media-specific category.
The recognized media types are: all, braille, embossed, handheld, print, projection, screen, speech, tty, and tv.

Media Query

Media queries extend the functionality of media types by allowing more precise labeling of style sheets
A media query consists of a media type and zero or more expressions that check for the conditions of particular media features. Among the media features that can be used in media queries are 'width', 'height', and 'color'. By using media queries, presentations can be tailored to a specific range of output devices without changing the content itself.

Multi-Channel / Omni Channel

In simple terms - Multi-Device
Refers to multiple channels to content delivery - Smart Phones, Tablets, Desktop, Wide Screen Devices etc.

Rendering Surface

Entire display of the device.

RWD

Responsive Web Design

Viewport

Window of the browser.
It has nothing to do with the device.

What Next ? - RESS

Responsive Design with Server Side components.
Also referred to as "Adaptive Design".
This is second generation of RWD which takes performance into account. [Refer to related section - Some Words of Caution]
RESS can deliver the best of "Responsive Design" and "Device Experience" without the challenges that can hamper each.

Server will deliver code and content based on the client device allowing responsive website to load much faster on different devices.
Server-side techniques include user agent detection, server-side breakpoints, and robust server-side feature detection.

Feature Detection vs Device Detection

Feature detection framework runs a test in the browser to get a boolean answer as output: "Is X Supported?" and the answer is mostly "true" or "false". It works on all browsers (current and future). Ex Modernizr.
Device Detection framework analyses the HTTP header of the device, to get information about the device, then gets capabilities for that device from a database maintained for this purpose.

Cookie can be used to share the information between client and Server.

A short guide to JSON - JavaScript Object Notation

2013-12-30T16:52:00.001+05:30

JavaScript Object Notation

Lightweight, open standard, human-readable, language/platform independent and self-describing text-based designed for storing and transferring structured data.
This format was specified by Douglas Crockford. <LINK>
JSON Internet Media type is application/json.

Use Cases:

Serializing and transmitting structured data over network connection.
Web Services and API's use JSON format to provide public data.
Fetch JSON data from a web server, convert it to a JavaScript object, use it to manipulate the UI.

Advantages:

Easy for computers and humans to read and write.
Supports tree like Hierarchies in data.
Can be easily mapped to data structures used by most programming languages (numbers, strings, booleans, nulls, arrays and associative arrays).
Most programming languages support JSON.

Limitations:

Capable of representing numbers, booleans, strings, null, and arrays and objects. Doesn't natively support complex data types like functions, regular expressions, dates etc.
Doesn't have a widely accepted schema for defining and validating the structure of JSON data.

Syntax:

JSON defines only two data structures: objects and arrays. An object is a set of name-value pairs, and an array is a list of values.
JSON defines six data types: string, number, object, array, true, false and null.
Objects are enclosed in braces ({}).
Name and value in a pair are separated by a colon (:).
Name-Value pairs are separated by a comma (,).
Names in an object are strings, whereas values may be of any of the six data types, including another object or an array.
Arrays are enclosed in brackets ([]), and their values are separated by a comma (,).
Each value in an array may be of a different type, including another array or an object.

JSON Example:

var emptyObj = {};

var empObj = {eid: '7918', ename: 'Prince', grade: 'T3'};

{
"empObjs": [
                   { "eid":"7918" , "ename":"pkapoor", "grade":"T2" },
                   { "eid":"709" , "ename":"jai", "grade":"T4" },
                   { "eid":"13386" , "ename":"rahul", "grade":"T3" }
                   ]
}

Deserialize JSON

Javascript eval() and JSON Parsor:

    <script>
        var txt = '{"empObjs":[' +
        '{"eid":"7918","ename":"pkapoor" },' +
        '{"eid":"709","ename":"jai" },' +
        '{"eid":"13386","ename":"rahul" }]}';

        var obj = JSON.parse(txt);        // var obj = eval ("(" + txt + ")");

document.getElementById("eid").innerHTML=obj.employees[1].eid document.getElementById("ename").innerHTML= obj.employees[1].ename </script>

Serialize JSON

JSON Stringify

JSON.stringify() outputs JSON strings with all whitespace removed. It makes it more compact for sending around the web.

/* Put this line in above example and print the value. */
var text = JSON.stringify(obj);

JSON vs XML

JSON is smaller than XML, faster, easier to parse and more human readable format.
XML is more verbose than JSON, so it's faster to write JSON for humans.
JavaScript's eval method parses JSON. When applied to JSON, eval returns the described object.
The Ajax (Asynchronous JavaScript And XML) originally used XML to transmit data between server and browser, but now JSON has become a more popular way to carry Ajax data.
XML is a tried-and-tested technology and is used in a huge range of applications.
Doesn't have a widely accepted schema for defining and validating the structure of JSON data.

JSON and Java

Java APIs for JSON processing are easily available and easy to use..

javax.json package - contains reader, writer, model builder interfaces for the object model along with other utility classes and Java types for JSON elements.
javax.json.stream package - contains a parser interface and a generator interface for the streaming model.
Refer to http://docs.oracle.com/javaee/7/tutorial/doc/jsonp001.htm for more details.

JSON and AJAX

The Ajax (Asynchronous JavaScript And XML) originally used XML to transmit data between server and browser, but now JSON has become a more popular way to carry Ajax data.

For Further Reading:

JSONPath
JXON
JSON-LD

Reference

http://docs.oracle.com/javaee/7/tutorial/doc/jsonp001.htm#BABEECIB
http://www.json.org/js.html
http://www.youtube.com/watch?v=wbB3lVyUvAM

Java Virtual Machine - Loading, Linking and Initializing

2013-11-22T03:08:00.000+05:30

Previous: Java Virtual Machine - Garbage Collection

Loading

Process of finding the binary representation of a class or interface type with a particular name and creating a class or interface from that binary representation.
(JVM Specification: ) Java Virtual Machine specification gives implementations flexibility in the timing of class and interface loading.
Internal data structures are populated including Method area.
An instance of class java.lang.Class for the class being loaded is created.
Information about a type that is stored in the internal data structures and accessed by invoking methods on the Class instance for that type.
If Class Loader encounters a problem, it is reported during linking phase (LinkageError) on first active use of the class.

Linking

A class or interface is completely loaded before it is linked.
Process of taking a class or interface and combining it into the run-time state of the Java Virtual Machine so that it can be executed.
Linking a class or interface involves verifying and preparing that class or interface, its direct superclass, its direct superinterfaces.
Dynamic linking involves locating classes, interfaces, fields, and methods referred to by symbolic references stored in the constant pool, and replacing the symbolic references with direct references.
Linking is divided into three sub-steps: verification, preparation, and resolution:

Verification ensures the type is properly formed and fit for use by the Java Virtual Machine.

Verification ensures that the binary representation of a class or interface is structurally correct.
Verification may cause additional classes and interfaces to be loaded but need not cause them to be verified or prepared.
Final classes/methods, abstract classes/methods validations are checked here.

Preparation involves allocating memory needed by the type, such as memory for any class variables.

Involves creating the static fields for a class or interface and initializing such fields to their default values (initializing to other values except default values is done in Initialization where explicit initializers are executed).

Resolution is the process of transforming symbolic references in the constant pool into direct references.

It is an optional part of linking.
Implementations may delay the resolution step until each symbolic reference is actually used by the running program.
After verification, preparation, and (optionally) resolution are completed, the type is ready for initialization. Resolution, which may optionally take place after initialization.

(JVM Specification: ) Java Virtual Machine specification gives implementations flexibility in the timing of class and interface linking.

Initialization

Initialization of a class or interface consists of executing the class or interface initialization method <clinit>.

<clinit> is static and has no arguments and is for static initialization blocks.
If there is no initialization of class variables in the code, compiler will not generate <clinit> method

Class variables are initialized during Initialization phase.
Initialization of a class or interface requires careful synchronization, since some other thread may be trying to initialize the same class or interface at the same time.
(JVM Specification: ) All implementations must initialize each class and interface on its first active use.
Involves creating the static fields for a class or interface and initializing such fields to their default values (initializing to other values except default values is done in Initialization where explicit initializers are executed).

Class-In-Use (Working with Objects)

For each constructor in the source code of a class, the Java compiler generates one <init() method.
If the class declares no constructors explicitly, the compiler generates a default no-arg constructor that just invokes the superclassís no-arg constructor.
For every class except Object, an <init() method must begin with an invocation of another <init() method belonging either to the same class or to the direct superclass.
Instance initialization methods may be invoked only by the invokespecial instruction (§invokespecial), and only on uninitialized class instances.

Unloading Class

Java Virtual Machine will run a class's classFinalize() method (if the class declares one) before it unloads the class.
If the application has no references to the type, then the type can't affect the execution of program and it can be garbage collected.

Class Loader

At run time, a class or interface is determined by a its binary name and defining class loader both.
Class Loader deals with file system to load the files for the JVM, no other component in JVM needs to deal with file system.
All Java virtual machines include one class loader that is embedded in the virtual machine, called Primordial class loader.
Every Class object contains a reference to the ClassLoader that defined it.

Class.getClassLoader()

Class LoaderTestClass loaded by class loader A, is not the same class as the class LoaderTestClass loaded with class loader B.
There are following three types of class loaders:

Bootstrap Class Loader
System Class Loader
Extension Class Loader

Premordial (Bootstrap) Class Loader

It implements the default implementation of loadClass().
Written in native language.
JVM assumes that it has access to a repository of trusted classes which can be run by the VM without verification.
Java core API classes are loaded by the bootstrap (or primordial) Class Loader.
Bootstrap ClassLoader searches in the locations (directories and zip/jar files) specified in the sun.boot.class.path system property.

String bootClassPath = System.getProperty("sun.boot.class.path");

Types loaded through the primordial class loader will always be reachable and never be unloaded.

Application (System) Class Loader

Application-specific classes are loaded by the system (or application) ClassLoaders.
Our application's code is loaded using this.
The system ClassLoader searches for classes in the locations specified by the classpath (set as the java.class.path system property) command-line variable passed in when a JVM starts executing.

String appClassPath = System.getProperty("java.class.path");
sun.misc.Launcher$AppClassLoader

Extensions Class Loader

Loads the code in the extensions directories (<JAVA_HOME>/jre/lib/ext, or any other directory specified by the java.ext.dirs system property).

String extClassPath = System.getProperty("java.ext.dirs");
sun.misc.Launcher$ExtClassLoader

Custom (User-Defined) Class Loader

Subclass of the abstract class Java.lang.ClassLoader.
Method loadClass is to be implemented.

loadClass should be synchronized.
Call findLoadedClass to check class is already loaded.
If we have the raw bytes, call defineClass to turn them into a Class object.
If the resolve parameter is true, call resolveClass to resolve the Class object.
If class not found, throw a ClassNotFoundException.

Every loaded class needs to be linked. This is done using the ClassLoader.resolve() method. This method is final.
Following are the steps a class loader performs:

Check if the class was already loaded.
If not loaded, ask parent class loader to load the class.
If parent class loader cannot load class, attempt to load it in this class loader.

Examples of Class Loaders:

java.net.URLClassLoader,
java.security.SecureClassLoader

Related Terms and Concepts:

JVM Startup

The Java Virtual Machine starts up by creating an initial class, which is specified in an implementation-dependent manner, using the bootstrap class loader.
The Java Virtual Machine then links the initial class, initializes it, and invokes the public class method void main(String[]).
In an implementation of the Java Virtual Machine, the initial class could be provided as a command line argument. Alternatively, the implementation could provide an initial class that sets up a class loader which in turn loads an application.

JVM Dynamic Linking

The process of JVM loading your program's classes and interfaces and hooking them together.
Java Virtual Machine builds an internal web of interconnected classes and interfaces.

Binding

Binding is the process by which a function written in a language other than the Java programming language and implementing a native method is integrated into the Java Virtual Machine so that it can be executed.
Although this process is traditionally referred to as linking, the term binding is used in the specification to avoid confusion with linking of classes or interfaces by the Java Virtual Machine.

Previous: Java Virtual Machine - Garbage Collection

Java Virtual Machine - Garbage Collection

2013-11-12T15:02:00.000+05:30

Previous: Java Virtual Machine - Memory Structure

Next: Java Virtual Machine - Loading, Linking and Initializing

Garbage Collection is not restricted to Java, its a generic concept that applies to most of the programming languages.
Garbage collection is the process of automatically freeing objects that are no longer referenced by the program.
The garbage collector must determine which objects are no longer being referenced by the program.
Garbage collector must run any finalizers of objects being freed.
Garbage collection is automatic, thus it removes the possibility of developer errors due to incorrectly freeing of memory.
Runtime.gc() and System.gc() only suggests JVM to run Garbage Collection, it is not mandatory that Garbage Collection will definitely run after call to these methods.
Java virtual machine has an instruction that allocates memory on the heap for a new object (created in source coce), but has no instruction for freeing that memory.
Garbage Collection in Java is carried by JVM's daemon threads for Garbage Collection.
Garbage collection was invented by John McCarthy around 1959 to solve problems in Lisp.

Java provides many garbage collectors, following are some examples:

Parallel Scavenge
Serial Garbage Collector
Parallel New + Serial GC
CMS (Concurrent Mark and Sweep)
G1 (Garbage First, available in Java7)

Regarding JVM Specification:

JVM specification does not specify any particular garbage collection technique, the decision to choose the garbage collection algorithm is left to the discretion of the implementors as they better know the constraints of the target device.
JVM specification mentions the need of garbage collection on heap, it leaves garbage collection or compacting the method area on implementers.
A garbage collector is not strictly required but heap memory should be managed.
The Java language specification states that a finalizer code will be executed only once. Finalizer are allowed to "resurrect" the object again, that is it'll be referenced again, but finalizer will not run next time.

Additional Responsibilities:

Heap Defragmentation

Disadvantages:

Developer has no control on Garbage Collection, reducing the use the finalizers.
At times, it may lead to uneven performance of the application components, as we don't know when Garbage collection will run and how much resources and time it'll consume.

Steps:

Garbage Detection

Identification of live and garbage objects.
Objects on heap which don't have any active references are available for garbage collection.
This process is also called Marking.

Reclaim Memory

Removes unreferenced objects leaving referenced objects and pointers to free space.

Optional Step: Compacting

Defragments the memory space, compacts the remaining referenced objects. This makes new memory allocation much easier and faster.

Stop the World Pauses:

Stop-the-world is term for JVM stopping the application (all threads) from running to execute a GC.
The interrupted tasks will resume only after the GC task has completed.
GC tuning often means reducing this stop-the-world time.

Disruptive Garbage Collection vs Deterministic Garbage Collection:

Garbage collection with noticable Stop the World pauses are called Disruptive Garbage collection.
Disadvantages - These are not suitable for Real-time systems. For end-users noticable pauses are irritating.
Solution Approach - Garbage collection should work incrementally, on small areas of heap at a time.

If each incremental collection can be completed in < Threashhold time, then it is suitable for Real-time system.
Example - Generational Collector used in Hotspot JVM, discussed below.

Tracing Garbage Collector:

Tracing garbage collectors are the most common type of garbage collector. They first determine which objects are reachable (or potentially reachable), and then discard all remaining objects.

Syntactic vs Semantic Garbage:

The reachability definition of "garbage" is not optimal, as there are two cases.

CASE #1: An object variable is now reassigned thus original object doesn't have any references left.
CASE #2: An object is still available in the program, but it is not used anymore.

Syntactic Garbage (Objects that a program cannot possibly reach)

It'll handle CASE #1 but not CASE #2.

Semantic Garbage (Objects that a program will never use again)

It'll handle CASE #1 and CASE #2 both.

Weak vs Strong References:

An object is eligible for garbage collection if there are no strong (i.e. ordinary) references to it, even though there still might be some weak references to it.
Weak Reference is usually reserved for a properly managed category of special reference objects which are safe to use even after the object disappears because they lapse to a safe value.
Weak References will be discussed in another post soon.

Precise vs Conservative:

Collectors that correctly identify all references to an object are called precise (also exact or accurate) collectors.
Collectors that don't identify all references to an object correctly are called conservative or partly conservative collector.
Conservative garbage collectors have traditionally been used in conjunction with programming languages like C and C++, which were not originally designed with a garbage collector in mind.
Conservative collectors assume that any bit pattern in memory could be a pointer if, interpreted as a pointer, it would point into an allocated object.

Moving (Compacting) vs Non-Moving (Non-compacting) Garbage Collectors

A moving GC strategy appears costly and low performance but it gives better performance. Following are details on this:

Since memory is defragmented, large contigous memory is available, new objects can be allocated very quickly.
No additional work is required to reclaim the space freed by dead objects; the entire region of memory from which reachable objects were moved can be considered free space.
While moving the objects special care is needed for objects passed to native methods, as there might be native pointers pointing to this.

Updating references after moving objects is made simpler by adding another layer of abstraction in between. Object references will point to a table of object handles and not directly refer to objects. Thus after de-fragmentation, only the object handle table will get updated.

Garbage Detection:

An object becomes eligible for garbage collection if its all references are null, i.e. If its not reachable from any live threads or any static references.
Achieved by defining a set of roots and determining reachability from the roots.
A distinguished set of objects are assumed to be reachable: these are known as the roots.
Typically, set of roots include all the objects referenced from anywhere in the call stack, and any global variables.

Object references in Local variables and
Operand stack frame,
Static members of classes in method area,
Object references passed to currently executing native methods, etc.

An object is reachable if there is some path of references from the roots by which the executing program can access the object. Reachability is a transitive closure.
The roots are always accessible to the program. Any objects that are reachable from the roots are considered live.
Objects that are not reachable are considered garbage.
Cyclic dependencies are also taken care this way.

Approaches for Garbage Detection:

Tracing

Trace the references from roots.
Mark and Swipe is basic Tracing Collector.

Reference Counting

Keeps count of the references to an object.
Advantage - It can run in small chunks of time closely interwoven with the execution of the program. This characteristic makes it particularly suitable for real-time environments where the program can't be interrupted for very long.
Disadvantage - It does not detect cycles: two or more objects that refer to one another.
This technique is currently out of favor.

Approaches for Heap Fragmentation Problem:

Compacting Collector

Slide/Move live objects to defragment the heap area.
Examples:

Mark and Swipe
Tri-color Marking

Copying Collector

Copying garbage collectors move all live objects to a new area.
Examples:

Stop-and-Copy

Generational Garbage Collection

The generational collection technique can be applied to mark and sweep algorithms as well as copying algorithms.
Dividing the heap into generations of objects can help improve the efficiency of the basic underlying garbage collection algorithm.
The most recently created objects are most likely to become unreachable quickly (known as infant mortality or the generational hypothesis).
Heap is divided into two or more sub-heaps, each of which serves one "generation" of objects.
The younger generation is garbage collected more frequently than older generation.
Once an object has survived a few garbage collections as a member of the youngest generation, the object is promoted to the next generation: it is moved to another sub-heap.
Every sub-heap except the mature sub-heap can be given a maximum size.
Any objects that don't fit in the sub-heaps of the younger generations must go into the mature object space, thus mature object space cannot be given a maximum size.
It ensures that most incremental GC will be complete in less than a threshhold time. Only exception is Mature Generation.
Following image shows generational garbage collection in Hotspot JVM:

Train Algorithm:

Specifies an organization for the mature object space of a generational collector for time bound incremental collections of the mature object space.
The train algorithm, which was first proposed by Richard Hudson and Eliot Moss and is currently used by Sun's Hotspot virtual machine.
Divides the mature object space into fixed-sized blocks of memory, each of which is collected individually during a separate invocation of the algorithm.

Each block belongs to one set.
The blocks within a set are ordered, and the sets themselves are ordered.

Small number indicate an older block within a set and Set with the heap.
For more details on this alogorithm, please google or refer to references section at the end of the Blog post.

Types of Garbage Collectors (Garbage Collection Approaches/Strategies/Algorithms)

Stop-and-Copy (Semi-space) Collector

Memory is partitioned into a "from space" and "to space".
Initially, objects are allocated into "to space" until they become full and a collection is triggered.
At the start of a collection, the "to space" becomes the "from space", and vice versa.
The objects reachable from the root set are copied from the "from space" to the "to space".

Mark and Sweep

This is an example of tracing collector.
Each object in memory has a flag (typically a single bit) reserved for garbage collection use only.
In Garbage detection, every object that is ultimately pointed to from the root set is marked.
In Memory Reclaim step, entire memory is scanned, all non-reachable objects are freed.
Disadvantage - Entire system must be suspended during garbage collection; no mutation of the working set can be allowed. This will cause programs to 'freeze' periodically (and generally unpredictab'ly), making real-time and time-critical applications impossible.

Tri-Color Marking:

This is an example of tracing collector.
White-Set (Condemned Set)

Objects that are candidates for having their memory recycled.

Black-Set

Objects that can cheaply be proven to have no references to objects in the white set, but are also not chosen to be candidates for recycling; in many implementations, the black set starts off empty.
In many implementations, the black set starts off empty.

Grey-Set

Objects that are reachable from root references but the objects referenced by grey objects haven't been scanned yet.
The grey state means we still need to check any objects that the object references.
Grey objects will eventually end up in the black set.

The grey set is initialised to objects which are referenced directly at root level; typically all other objects are initially placed in the white set.
Objects can move from white to grey to black, never in the other direction.
Advantage: it can be performed 'on-the-fly'.

Mark and Don't sweep

This is an example of tracing collector.
All reachable objects are always black.
A white object is unused memory and may be allocated.
The interpretation of the black/white bit can change. Initially, the black/white bit may have the sense of (0=white, 1=black).
If an allocation operation ever fails to find any available memory, the sense of the black/white bit is then inverted (0=black, 1=white). Thus all objects become white. A marking phase begins immediatly to mark reachable objects black.

Adaptive Collectors

An adaptive algorithm monitors the current situation on the heap and adjusts its garbage collection algorithm and configuration.

Oracle Java 7 G1 (Garbage First) Garbage Collector:

Compact free space without lengthy and more predictable GC induced pause times.
Its still not suitable for Real-Time systems.
Targetted for multi-processors with large memories.
G1 is both concurrent and parallel.

It uses all available CPUs to speed up its “stop-the-world” pauses.
It also works concurrently with running Java threads to minimize whole-heap operations during stop-the-world pauses.

Previous: Java Virtual Machine - Memory Structure

Next: Java Virtual Machine - Loading, Linking and Initializing

Java Virtual Machine - Introduction

2013-11-04T09:31:00.001+05:30

Next: Java Virtual Machine - Memory Structure

Typical Java Environment consists of following:

Java Programming Language

JDK
Source code is in Java.

Java Class File Format

Bytecode

Java API

Standard classes and interfaces of JDK.

Java Virtual Machine

JVM:

The Java Virtual Machine, or JVM, is code executing component of Java platform.
Abstract machine that runs compiled Java programs.
The JVM is "virtual" because it is implemented in software on top of a "real" hardware platform and operating system.
The Java Virtual Machine is an abstract computing machine. Like a real computing machine, it has an instruction set and manipulates various memory areas at run time.
Oracle JVM specifications specifies an abstract machine, it doesn't describe any particular implementation of JVM.
Java is for platform-independence, each Java platform has different constraints. Java specification doesn’t give hard and fast rules about the design of JVM with respect to memory and other aspects. JVM is implemented specifically for each platform, and implementation of JVM is left to jvm implementers.

Role:

Read the Class file format (Bytecode) and correctly performs the operations specified in it.

Key points:

Any implementation details like memory structures, garbage-collection etc are not part of the Java Virtual Machine's specification would unnecessarily constrain the creativity of implementers.
The Java Virtual Machine knows nothing of the Java programming language, it only cares for Virtual Machine instructions (or bytecodes).
All Java Virtual Machine implementations must recognize the Java class file format, but individual implementations may also recognize other binary formats.
Any language with functionality that can be expressed in terms of a valid class file can be hosted by the Java Virtual Machine.
For the sake of security, the Java Virtual Machine imposes strong syntactic and structural constraints on the code in a class file for security concerns.

Advantages:

Hardware and operating system independence.
Small size of its compiled code.
Protect users from malicious programs.

Bytecode is carefully inspected by JVM before execution.

JVM Implementation:

Like most virtual machines, the Java virtual machine machine has a stack-based architecture akin to a microcontroller/microprocessor.
JVM doesn't have registers for storing arbitrary values. All computation in the JVM centers on the stack, everything must be pushed onto the stack before it can be used in a calculation.
JVM are usually coded for a particular OS but it can also be coded directly on hardware.
JVM also has low level support for Java like classes and methods, which amounts to a highly idiosyncratic memory model and capability-based architecture.
JVM has no built-in support for dynamically typed languages.
JVM supports following 7 primitive types:

byte - one-byte signed two's complement integer
short - two-byte signed two's complement integer
int - 4-byte signed two's complement integer
long - 8-b yte signed two's complement integer
float - 4-byte IEEE 754 single-precision float
double - 8-byte IEEE 754 double-precision float
char - 2-byte unsigned Unicode character

Few Examples:

Most popular JVM implementation is from Oracle and is named HotSpot, written in C++.
Jinitiator is another popular JVM implementation, especially in Oracle Apps community, developed by Oracle for supporting forms on websites before they purchased Sun.
Mac OS Runtime for Java (MRJ, originally Macintosh Runtime for Java).
SAPJVM (SAP) is a licensed and modified SUN JVM ported to all supported platforms of SAP NetWeaver

About Bytecode

Machine language of the Java virtual machine.
Each instruction consists of a one-byte opcode(represents operation) followed by zero or more operands.
An opcode may optionally be followed by operands(represents parameters required by opcodes).
The total number of opcodes is less (~200), each opcodes requires only one byte.

This helps in minimizing the size of class files and JVM implementation.

Java Bytecode is an intermediate language which is typically compiled from Java but it can also be compiled from other programming language, ex ADA.
Class files contain bytecode and a symbol table, as well as other ancillary information.
Any language with functionality that can be expressed in terms of a valid class file can be hosted by the Java Virtual Machine.
JVM has instructions for Load/Store of variables, Arithmetic, Type Conversions, Stack Management, Exception management, and Monitor based concurrency control etc.
Examples of Opcodes:

iload, lload, fload, and dload are used to load int, long, float and double operand on the stack respectively.
istore, fstore are used to pop int and float from the stack to a variable.
aload, astore operates on references.

There is no support for loops and binary logical operators (|| &&). These are implemented by compiler with jump instructions.

Class File

Each class file contains the definition of a single class or interface.
A class file consists of a stream of 8-bit bytes. All 16-bit, 32-bit, and 64-bit quantities are constructed by reading in two, four, and eight consecutive 8-bit bytes, respectively.
Multibyte data items are always stored in big-endian.

Execution Engine:

It consists of following:

Bytecode Interpreter
JIT (Just In Time) Compiler

Since byte code is interpreted it executes slower than compiled machine code.
Just-in-time compilation (JIT) is also known as dynamic translation.
JIT is used to improve the runtime performance of byte code.
The program is stored in memory as byte code, but the code segment currently running is preparatively compiled to physical machine code in order to run faster.

Virtual Processor

JRE:

Java Execution Environment (Java Runtime Environment).
JRE contained JVM and java class libraries that implement java API.

Other JVM Languages

Groovy
Scala
Jython
JRuby
Kotlin

Next: Java Virtual Machine - Memory Structure

Dependency Injection - An Introduction

2013-10-03T15:23:00.001+05:30

Dependency

Dependency is when a class needs instances of another class to function correctly.
Following is an example of dependency:
class X
  {
      ...
    Y obj = new Y("xyz", "abc") ;
      ...
  }

Dependency Problems

Dependencies are hardcoded.
Unit testing becomes difficult as well, where we need to mock the depencies to perform isolated test cases.
With dependencies like above, if different implementation of Y (with same interface) is needed. Actual code needs to be changed.
Also the code here is not based on interface so its even further less flexible.
If dependency class has further dependencies, those will be needed as well.

Dependency Injection

Injecting Dependency from (pushed from) outside into a class at runtime.
Dependent object instead of instantiating dependencies using "new" operator from inside of the class should take dependent object via constructor parameters or setters.
It decouples class's construction from the construction of its dependencies.
Code should depend upon abstractions(interfaces) rathen than implementation(class references).
Dependency Injection is for Loose Coupling.

An object's dependencies should be on interfaces and not on "concrete" objects.
Dependencies should be less.
Loose coupling promotes greater reusability, easier maintainability.

  class X
  {
      InterfaceY objY = null;
    ...
      X (InterfaceY dependencyObj)
    {
        objY = dependencyObj ;
     }
      ...
  }

Software design pattern that allows the removal of hard-coded dependencies and makes it possible to change them, whether at run-time or compile-time
Its a configuration style of prorgamming, object is configured from outside (may be a configuration file) rather than inside.

Primary ways to implement Dependency Injection:

Constructor Injection

These are considered better than others since at the time of the creation of the class you know what is needed to perform its job.
Easier to maintain.

Setter Injection
Method Injection

How to manage and instantiates dependencies?

Each of our classes require dependencies, we need to figure what dependency each class needs and how to instantiate the dependencies.
The answer is Dependency Injection container.
Dependency Injection container contains map of dedencies needed by a class with the logic to create instances of those dependencies if needed.

Related Topics:
Dependency Inversion Principle
Inversion control Principle
Inversion of Control Container
Dependency Lookup
DI Container Implementations
Butterfly container
factory vs container
factory pattern vs DI Container

NESTED CLASSES - Static Nested and Inner Classes

2013-10-02T13:19:00.003+05:30

Nested Class:

Introduced in version 1.1 of Java.
Class within another Class.
A nested class is a class whose definition appears inside the definition of another class, as if it were a member of the enclosing class.
A nested class can be declared private, public, protected, or package private.
Nested class can be hidden from all other classes using 'private' modifier.
Nested Classes are compiled as separate class files with following format:

EnclosingClass$InnerClass.class

EnclosingClass$StaticNestedClass.class

To run main method of nested class, use "java EnclosingClass$StaticNestedClass".
Divided into two categories - static and non-static (Inner Classes)
Nested class may be nested within another Nested class.

class EnclosingClass {

...

static class StaticNestedClass {

...

}

class InnerClass {

...

}

Features of Nested Classes:

Non-static nested classes (inner classes) have access to other members of the enclosing class, even if they are declared private.
Static nested classes do not have access to other members of the enclosing class.
Inner class is associated with an instance of enclosing instance.
A static nested class is associated with enclosing class(not object).
The way static methods cannot access non static members, static nested class cannot refer to non-static members without object reference.
Inner Class can access non-static members.
Inner class cannot have static members (except constants) because it is linked to an instance of enclosing class.
A static nested class is same as any top-level class just that it has been packaged in another top-level class. Only difference is static nested class can access private static members.
Inner class instance knows about the enclosing class instance, it can access its members using "<EnclosingClassName>.this".
this.<member-name> // Inner Class's member
<EnclosingClassName>.this.<member-name> // Enclosing Class's member
Static nested classes are known as nested top-level classes.
An enclosing class can have multiple inner classes extending other classes, thus providing a way to achieve multiple inheritence.
Inner class needn't be created at the time of creation of enclosing class, it can be created any time after that.
An enclosing class can have multiple instances of same inner class, each with its own state. (Ex. multiple iterators for a rowset).

Typical Usage:

Inner class extends another class or implements an interface (ex. java.util.Iterator). Inner class can access outer class members and closely perform operations on them.

Used for writing test cases, since nested classes have access to private members.

Inner classes are best used in the event handling mechanism and to implement the helper classes.

Why we need Inner Classes:

In the above example, if Iterator would have been a class and not interface, then design couldn't have survived without Inner class, because a class can only extend one class (in that case only Iterator).

Miscellaneous Facts on Nested Classes:

Java supports the concept of nested classes in interfaces, though its a teriible programming practice. Following code will compile:

public interface EnclosingInterface {

void testMethod();

class InnerClass {

int x = 10;

public void testx() {

System.out.println(x);

}

Java supports nested interfaces within interfaces but its also a bad programming practice.
Java supports nested interfaces within classes, though they are helpful in rare scenarios. These also can be avoided with the use of top-level interfaces.

Local Classes

Local classes are classes that are defined in a block, typically inside a method body, though it can be within a loop, if-else blocks etc.
Local classes (since its Inner Class) are non-static because they have access to instance members of the enclosing block.
A local class (since its Inner Class) has access to the members of its enclosing class.
Local classes (since its Inner Class) they cannot define or declare any static members or initializers except constants.
Local classes defined in static methods, can only refer to static members of the enclosing class.
A local class has access to final local variables as well.
local class names are in this format:

<EnclosingFormat>$<number><LocalClassName>.class
<number> starts with 1, gets incremented by 1 and so on. <number> is coming here because class names can be repeated in different blocks.
Ex. EnclosingClass$1LocalA.class, EnclosingClass$1LocalB.class

Anonymous Classes

They are like local classes except that they do not have a name.
Use them if you need to use a local class only once.
They enable you to declare and instantiate a class at the same time.
It is an abbreviated notation for creating a simple local object "in-line" within any expression, simply by wrapping the desired code in a "new" expression.
While local classes are class declarations, anonymous classes are like expressions.
Anonymous class must be part of a statement since its like an expression.
Anonymous classes enable you to make your code more concise.
The syntax of an anonymous class expression is like the invocation of a constructor, except that there is a class definition contained in a block of code.
Anonymous classes have the same access to local variables of the enclosing scope as local class.
Anonymous classes also have the same restrictions as local classes with respect to their members
you cannot declare constructors in an anonymous class.
Since anonymous classes have no names, the Java compiler uses numbers to provide anonymous class names. Ex. EnclosingClass$1.class.
The anonymous class expression consists of the following:

The new operator
The name of an interface to implement or a class to extend.
Parentheses that contain the arguments to a constructor. In case of implementing an interface, there shouldn't be any parameters.
Body of class. Method declarations are allowed in body but statements are not.

Syntax:
new class-name ( [ argument-list ] ) { class-body }
or:
new interface-name () { class-body } // No argument list with interface.
These are mostly used in event handling.
They are useful for writing small encapsulated "callbacks," such as enumerations, iterators, visitors, etc.
Like local classes, anonymous classes cannot be public, private, protected, or static.

When to use Member, Local and Anonymous classes?

When to use anonymous classes and when to use local classes depends on number of instances needed. If number of instances are more, its local class.
When to use local classs and when to use member class depend on the availability of the new type. If wide availability is needed, its member class.

How Inner Classes are Implemented in JVM?

Inner classes were introduced in Java 1.1.
Introduction of inner classes did not change the Java Virtual Machine or the Java class file format.
For Java interpreter and JVM all classes are normal top-level classes.
Java compiler inserts hidden fields, methods (getters for instance references), and constructor arguments into the classes it generates.

Java 8 Enhancements:

Local class can access local variables effectively final (whose value is never changed after initialization).
Local class can access parameters of the enclosing block, i.e., method parameters in case Local class is defined in a method.

Java Annotations - An Overview

2013-09-28T22:03:00.001+05:30

Introduction

Introduced in JDK 1.5
One of the biggest ever feature added in Java.
A form of syntactic metadata that can be added to Java source code. Its basically Data about Data.
Annotations don't do anything on their own, they don't do any processing. They act like a modifier and become useful only when they are processed.
Annotations can be processed at compile time, run time or deployment time.
Annotations are tags that we insert into our code, to be processed by tools like compiler, deployment tools or other external packages. Annotations are part of the code.
Can be embedded in class files generated by the compiler and may be retained by the Java VM to be made retrievable at run-time.(Reference: Retention policy)
Prior to Annotations, Java provided only ad-hoc and non-standardized mechanism, including Serializable interface (other market interfaces), transient modifier, Javadoc comments, @deprecated tag in comments.One of the main reasons for adding annotation and metadata to the Java platform is to enable development and runtime tools to have a common infrastructure.
Annotations are part of java code, Java Docs are not.
java.lang.annotations package provides library support for the Java programming language annotation facility.
Normally a developer needn't create Annotations.
Annotation-based programming is an extensible mechanism for generating application artifacts, packaging the application, and readying the application for execution.
Annotation-based programming offers a set of tags and a processing mechanism that allow you to embed additional metadata into code. Application then uses this additional metadata to derive the artifacts required to execute the application in a J2EE environment.

Defining Annotations:

public @interface TestAnno
{
String str(); // It can never has any parameters.
int count();
}

Implementation Key points:

@interface keyword is used to define annotations.
Annotation types are a form of interface.
Annotation elements must be compile time constant values.
There is no restriction of the type of annotation element.
All annotations consist solely of method declarations. These method declarations are called elements.
The declarations must not have any formal parameters or a throw clause.
java.lang.annotation.Annotation is super-interface for all annotations.
Annotations cannot include the extends clause.
Annotations can be applied to any declaration, ex. classes, methods, fields, parameters, enum, constants or even an annotation type.
There is a default value element in the annotations.
Annotations cannot use Generics, no generic member type, no type parameters.

   public class TestClass
{
        @TestAnno (str="MyFirstAnnoTest", count=1001)
// When a element is given a value only name is used,
// paranthesis are not used.
        public static void main(String[] args)
        {
                ...
        }
}

If the annotation has no elements, then the parentheses can be omitted. Ex @Override.
If there is just one element named value, then the name can be omitted. Ex

@SuppressWarnings(value = "unchecked")
@SuppressWarnings("unchecked")

It is also possible to use multiple annotations on the same declaration:

@TestAnno (str="MyFirstAnnoTest", count=1001)
@SuppressWarnings("unchecked")
class TestClass { ... }

Annotation Uses:

Annotations helps moving away redundant code, remove config xml (ex. deployment descriptor), adds extra checks (ex. @override).
Provide information to Compiler -

To detect errors or suppress warnings (@Deprecated, @Override, @SuppressWarning)

Compile-time and deployment-time processing -

Software tools can process annotation information to generate code, XML files, and so forth. Ex @WebServlet, @WebInitParam, @WebFilter, @WebListener etc.

Runtime processing -

Marker Annotations

Default Value for Annotation elements

We can provide default values to annotations, that will be assigned if no value is specified.
A default value is specified by adding a default clause to a member's declaration.
Syntax:

type member() default default-value
default-value must be type compatible with member type.

   public @interface TestAnno
   {
String str() default "testString" ;
      int count() default -1 ;
   }

Marker Annotations

Similar in concept with Marker interface - no member methods with sole purpose of marking a declaration.

Single-Member Annotations

As the name suggests, only one annotation contains only one member.
member name should be value.
Uniqueness - allows to use shorthand, no need to specify the name of the member.

    public @interface TestSingleAnno
    {
   String value() ;
    }

@TestSingleAnno("Testing Single Annotation")

public static void main(Sting[] args)

{

...

}

Java SE Predefined Annotations:

@Deprecated

Defined in java.lang package.
Introduced in Java 1.5
When @Deprecated is used, documentation (javadoc @deprecated comment) should reflect why open is deprecated and what to use instead.

@Override

Defined in java.lang package.
Introduced in Java 1.5
If a method marked with @Override fails to correctly override a method, the compiler throws an error.
It helps to prevent errors.

@SuppressWarning

Defined in java.lang package.
Introduced in Java 1.5

Instructs the compiler to suppress specific warnings that it would otherwise generate.

Warnings like unused variables, deprecated methods will be suppressed by compiler.
Ex. @SuppressWarnings("deprecation")
Ex. @SuppressWarnings({"unchecked", "deprecation"})

@SafeVarargs

Defined in java.lang package.
Introduced in Java 1.7
It asserts that the code does not perform potentially unsafe operations on its varargs parameter.
Unchecked warnings relating to varargs usage are suppressed.

@FunctionalInterface

Defined in java.lang package.
Introduced in Java 1.8
An informative annotation type used to indicate that an interface type declaration is intended to be a functional interface as defined by the Java Language Specification.
Conceptually, a functional interface has exactly one abstract method.
However, the compiler will treat any interface meeting the definition of a functional interface as a functional interface regardless of whether or not a FunctionalInterface annotation is present on the interface declaration.
If a type is annotated with this annotation type, compilers are required to generate an error message unless:

The type is an interface type and not an annotation type, enum, or class.
The annotated type satisfies the requirements of a functional interface.

Meta-Annotations

Annotations that apply to other annotations.
It is information about annotation.There are several meta-annotation types defined in java.lang.annotati

@Retention

Specifies how the marked annotation is stored, at what point, its discarded.
Java defines 3 such policies encapsulated in java.lang.annotation.RetentionPolicy enumeration - SOURCE, CLASS, RUNTIME.
SOURCE - Retained only in source file and discarded during compilation.
CLASS - Stored in .class file during compilation, but its not available through JVM during runtime.
RUNTIME - Stored in .class file during compilation, and available through JVM during runtime. It offers the greatest annotation persistence.
Default Retention level is CLASS. If no Retention annotation is present on an annotation type declaration, the retention policy defaults to RetentionPolicy.CLASS
Ex. @Retention(RetentionPolicy.RUNTIME)

@Documented

Indicates whenever the specified annotation is used those elements should be documented using the Javadoc tool.
By default, annotations are not included in Javadoc.
To make the information in @TestAnno appear in Javadoc-generated documentation, you must annotate the @TestAnno definition with the @Documented annotation:

      // import this to use @Documented
      import java.lang.annotation.*;

      @Documented
      public @interface TestAnno
{
           String str(); // It can never has any parameters.
         int count();
      }

@Target

Indicates the kinds of program element to which an annotation type is applicable.
If a Target meta-annotation is not present on an annotation type declaration, the declared type may be used on any program element.
A target annotation specifies one of the following element types as its value:

ElementType.ANNOTATION_TYPE can be applied to an annotation type.
ElementType.CONSTRUCTOR can be applied to a constructor.
ElementType.FIELD can be applied to a field or property.
ElementType.LOCAL_VARIABLE can be applied to a local variable.
ElementType.METHOD can be applied to a method-level annotation.
ElementType.PACKAGE can be applied to a package declaration.
ElementType.PARAMETER can be applied to the parameters of a method.
ElementType.TYPE can be applied to any element of a class.

Ex. @Target({ElementType.FIELD, ElementType.METHOD,

                    ElementType.FIELD})

   public @interface TestAnno {
          ...
       }

           @Target(ElementType.ANNOTATION_TYPE)
       public @interface TestAnno {
            ...
           }

@Inherited

Indicates that the annotation type is automatically inherited from the super class.
This annotation applies only to class declarations.

By Default a class doesn't inherit annotations of its super class.

When the user queries the annotation type and the class has no annotation for this type, the class' superclass is queried for the annotation type.

Java 8 Enhancements

Type Annotations and Pluggable Type Systems

Before the Java SE 8 release, annotations could only be applied to declarations.
As of the Java SE 8 release, annotations can also be applied to any type use.
A few examples of where types are used are class instance creation expressions (new), casts, implements clauses, and throws clauses.
This form of annotation is called a type annotation, following are few examples:

    new @Interned MyObject(); //Class instance creation

    myString = (@NonNull String) str; //Type cast

    @NonNull String str;

    class UnmodifiableList<T> implements
        @Readonly List<@Readonly T> { ... } //implements clause

    void monitorTemperature() throws
         @Critical TemperatureException { ... } //Thrown exception declaration

Type annotations were created to support improved analysis of Java programs way of ensuring stronger type checking.
The Java SE 8 release does not provide a type checking framework.
It allows you to write (or download) a type checking framework that is implemented as one or more pluggable modules that are used in conjunction with the Java compiler.

@Repeatable

Indicates that the marked annotation can be applied more than once to the same declaration or type use.
There are situations where you want to apply same annotation multiple times to a declaration or type use. Following are few examples:

A Project could fall under several project categories.
A process needs to be scheduled for multiple time.
An event could be observed by multiple roles.

    //custom annotation without repeatable
    public @interface Schedule { ... }

    //container annotation for repeatable
    public @interface Schedules {
         Schedule[] value;
    }

    //custom annotation with repeatable
    //The value of @Repeatable meta-annotation is container annotation.
    @Repeatable(Schedules.class)
    public @interface Schedule { ... }

Java - Confusing Terms

2013-08-31T22:19:00.000+05:30

Iterable vs Iterator

Implementing Iterable allows an object to be the target of the "foreach" statement. It is in java.lang package. It has one method - Iterator<T> iterator().

Iterator represents iterator over a collection. It is in java.util package. It has three methods - hasNext, Next and remove.

Collection vs Collections

Collection is the root interface in the collection hierarchy. It is in package java.util. This interface is typically used to pass collections around and manipulate them where maximum generality is desired. It implements java.util.Iterable.

Collections class consists exclusively of static methods that operate on or return collections. It doesn't extend/implement any class/interface from collections hierarchy.

Comparator vs Comparable

Comparable interface imposes a total ordering on the objects of each class that implements it. This ordering is referred to as the class's natural ordering, and the class's compareTo method is referred to as its natural comparison method. Lists (and arrays) of objects that implement this interface can be sorted automatically by Collections.sort (and Arrays.sort). Objects that implement this interface can be used as keys in a sorted map or as elements in a sorted set, without the need to specify a comparator.
Comparable has int compareTo(T o) method. It is in java.lang package.

A comparator object (a class that implements Comparator interface) can compare any two objects and these two objects are passed as parameters to compare() method.
Comparator is used to sort objects in other than its natural ordering.
Comparator has int compare(T o1, T o2) and equals method. It is in java.util package.

Following is the result of the compare methods:
    a) A positive integer value if obj1 is greater than obj2.
    b) 0 value if obj1 and obj2 are equal.
    c) A negative integer value if obj1 is less than obj2.

Hashmap vs Hashtable

HashMap is non-synchronized whereas Hashtable is synchronized.
Java 5 introduced ConcurrentHashMap which is an alternative of Hashtable and provides better scalability than Hashtable in Java.
HashMap allows null values as key and value whereas Hashtable doesn’t allow nulls
HashMap does not guarantee that the order of the map will remain constant over time.
HashMap can be synchronized by:

Map m = Collections.synchronizeMap(hashMap);

Iterator vs Enumeration

Iterator has a remove() method while Enumeration doesn't.
Enumeration is very basic and twice as fast as Iterator and uses very less memory.
Iterator is more secure and safe as compared to Enumeration because it does not allow other thread to modify the collection object while some thread is iterating over it and throws ConcurrentModificationException.
Enumeration has two methods and both are available in iterator. Method names for both of them are shortened.

Fail Fast vs Fail Safe

Fail fast means not concealing the error, bringing it out as soon as its detected.
Business is obstructed, but we get a chance to rectify.
Fail-Fast results in interrupted availability, over a period it results in a robust system.
Fail ensures system doesn't continue after a failure and creates data corruption and irreversible changes.
Fail Fast is a better approach in most scenarios but for life critical, mission critical applications we need fail safe programs and not fail fast. Fail-Safe is Achieved with Exception Handling.

Fail Fast Iterator vs Fail Safe Iterator

Difference between Fail Safe Iterator and Fail Fast Iterator is same as discussed above.
Iterator of CopyOnWriteArrayList is an example of fail-safe Iterator also iterator written by ConcurrentHashMap keySet is also fail-safe iterator and never throw ConcurrentModificationException in Java.

ConcurrentHashMap vs Collections.synchronizedMap vs Hashtable vs Hashmap

Collections.synchronizedMap provide a basic thread-safe implementation of Map.
Collections.synchronizedMap has fail-fast iterator and single collection-wide lock, which at times is obstruction to scalability and concurrency.
Collections.synchronizedMap and Hashtable give poor performance if the size is large due to single collection-wide lock.
ConcurrentHashMap implementations provide much higher concurrency while preserving thread safety.
ConcurrentHashMap introduced concept of segmentation , ConcurrentHashMap only locked certain portion of Map to provide thread safety so many other readers can still access map without waiting for iteration to complete.
ConcurrentHashMap do not allow null keys or null values while HashMap allows null keys.

Interfaces vs Abstract Classes

Interface in Java can only contains declaration.
Abstract class may contain both abstract and concrete methods, which makes abstract class an ideal place to provide common or default functionality.
A class can inherit multiple interfaces, but it can inherit only one abstract class.
By extending abstract class, a class can only participate in one Type hierarchy but by using interface it can be part of multiple type hierarchies.
Methods in an abstract class can be protected, private, static etc. But, all items in an interface are implicitly public.
Abstract classes can contain fields that are not static and final.
Interface defines a CAN-DO relationship, Classes (including Abstract) than IS-A relationship.
In comparison with java abstract classes, java interfaces are slow as it requires extra indirection.

Vector vs ArrayList

Vector and ArrayList are derived from AbstractList and implements List interface, which means both of them are ordered collection and allows duplicates.

Vector vs ArrayList is that both are index based Collection and you can use get(index) method to retrieve objects from Vector and ArrayList.

All the methods of Vector are synchronized and methods of ArrayList are not synchronized.
Both the ArrayList and Vector hold onto their contents using an Array.
A Vector defaults to doubling the size of its array, while the ArrayList increases its array size by 50 percent.

Vector vs ArrayList vs LinkedList

LinkedList is implemented as a double linked list. Its performance on add and remove is better than Arraylist, but worse on get and set methods.
LinkedList also implements Queue interface which adds more methods than ArrayList and Vector, such as offer(), peek(), poll(), etc.
While an ArrayList uses an array internally to store the data, a LinkedList uses nodes to hold the elements.
LinkList is a series of instances of a private nested class Entry, which has next, previous and element references.

Dictionary & Properties

Dictionary is an abstract class. Map is an interface.
Dictionary is parent class of Hashtable.
Properties is child class of Hashtable.
Properties represents a persistent set of properties.
Each key and its corresponding value in the property list is a string, while in hashtable it can be any object.
Properties is thread safe.
Properties is a very specialized class that's designed to hold configuration and/or resources that are usually stored in some file.
Properties supports reading and writing its content to a well-defined plain-text format (using load()/store())
Properties supports reading and writing its content to a well-defined XML-based format (using loadFromXML()/storeToXML())
The Dictionary class is the abstract parent of any class, such as Hashtable, which maps keys to values.

Wait vs Sleep

sleep() allows the thread to go to sleep state for x milliseconds. When a thread goes into sleep state it doesn’t release the lock.
wait() allows thread to release the lock and goes to suspended state. The thread is only active when a notify() or notifAll() method is called for the same object.

Notity vs Notify All

notify( ) wakes up the first thread that called wait( ) on the same object.
notifyAll( ) wakes up all the threads that called wait( ) on the same object. The highest priority thread will run first.

Java SE(Standard Edition) vs Java EE(Enterprise Edition) vs Java ME(Micro Edition)

Java SE - Plain vanilla version of Java. Java SE has a large library of code which includes many utilities, algorithms, data structures etc. Java EE and Java ME are built on top of Java SE.
Java EE - Builds on Java SE. Java EE contains additional libraries of code and development tools that are uniquely useful in developing web-based business applications.
Java ME - A reduced version of Java SE and an associated library of software that addresses the unique needs of Java applications that should run on limited capability devices like mobile phones and PDAs.

The list will continue, please contribute.

Session Values - putSessionValue vs putSessionValueDirect

2013-06-26T12:03:00.001+05:30

Values set with putSessionValue function are cleared when redirected to homepage, but values set by putSessionValueDirect are cleared by logout, session invalidation and manual removal only.

putSessionValue can store only String, Number or Date but putSessionValueDirect can store any object.

Use of putSessionValueDirect is not recommended.

putSessionValueDirect is typically for passing information between self-service pages and non self-service pages.

Puts a value on the servlet session directly (through HttpSession.putValue(String name, Object value)) without associating it with a specific transaction ID.

Note: putSessionValueDirect has been used in Multple Transactions in One OAF Page.

Note: Session is not preferred place to store and pass values between pages. Refer to OAF: Passing Parameters, Encryption, Encoding.

OAF: Passing Parameters, encryption, encoding

2013-05-19T16:11:00.001+05:30

OAF: Passing Parameters between pages

Following are three common means of passing parameters between pages:

Request
Transaction
Session

In addition the values set in the View Attributes are available to all pages participating in the transaction.

Request :

Short-lived object created for each HTTP request.
It contains following application state:

URL Parameters
Updatable Field values (Message Text Input etc) and Hidden Field Values (form values) in case of post
Event trigggering bean and the action in case of post.

Request values are accessed using OAPageContext.getParameter() methods.
In OAF, we don't interact with Request directly, we interact with Request through PageContext.

Ways to pass parameters in Request:

Adding in URL: We can specify parameters as literal values or token substituted values (mapped to VO Attributes). Following are the examples:

OA.jsp?page=/xxabc/oracle/apps/xxabc/custommodule/webui/CustomPG&order={@OrderNum}
OA.jsp?OAFunc=XXABC_ADM_SUPP_ENGR&asset=123

OAPageContext.putParameter()

Values are not technically added to request, but are stored in a special page cache.
Equivalent to HttpServletRequest.setAttribute()

Hidden fields (form values)

Passing parameters in Hashmap using setForwardUrl().

Passing parameters in Hashmap is the better approach for following reasons:

URL has size restrictions.
URL is visible to users.
putParamater() and hidden fields are not stored in Request as parameters, thus if we navigate with Breadcrumbs or for other reasons in case the webBean hierarchy needs to be reconstructed, these will not be available.

Transaction:

Transaction has wider scope than Request thus its not preferred approach.

OAPageContext.putTransactionValue()
OAPageContext.getTransactionValue()
((OADBTransactionImpl)getTransaction()).putValue()
((OADBTransactionImpl)getTransaction()).getValue()

Session:

Again, a wider scope than Transaction and not recommended.

pageContext.putSessionValue();
pageContext.getSessionValue();

Using VO Attributes for passing values

Values stored in VO attributes are available in all pages within the transaction with same Root AM.

URL Parameters : Encryption and Encoding

When we are passing parameters in URL, following need to be considered:

{@Attr} - encodes. Changes Prince Kapoor to Prince%20Kapoor
{!Attr} - encrypts. Encrypts sensitive information.
{$Attr} - plain token substitution (no encoding or encryption)
{@@RETURN_TO_MENU} - Used for E-Business Suite Personal Home Page. Same as OAWebBeanConstants.RETURN_TO_MENU_URL.
{@@RETURN_TO_PORTAL} - Return the user to a launching Portal page. Same as OAWebBeanConstants.RETURN_TO_PORTAL_URL.

Oracle 11g Memory Structure

2013-02-14T18:14:00.003+05:30

11g Memory Structure

Oracle has many different memory structures for the various parts of the software's operation.

System Global Area

Shared memory structures for data and sql. It is shared by both background processes and server processes. SGA is Oracle's structural memory area that facilitates the transfer of data and information between clients and the Oracle database. The size of the SGA is controlled by the DB_CACHE_SIZE parameter. Oracle 11g allows users to tune both PGA and SGA areas with a single parameter, called MEMORY_TARGET.

show parameter memory_target

Shared Pool -

Library Cache - A library of ready-to-go SQL statements.
Dictionary Cache - For storing the most recently used data definitions in the Oracle DB. These data definitions may include information about: database files, tables, indexes, privileges, users, etc.
Quickest Result Cache

SQL Result Cache - Stores sql query result. Oracle skips execution next time.
PLSQL Function Result Cache - Cache contains the result from a previous call to the function with the same parameter values, the system returns the cached result to the invoker and does not re-execute the function body.

Database Buffer Cache -
Redo Log Buffer -
Large Pool -
Java Pool -

Following are key SQL Queries related to SGA:

SHOW SGA
SELECT * FROM v$sga;
select * from v$sgainfo;
select * from v$sga_dynamic_components;

Program Global Area

A program global area (PGA) is a memory region that contains data and control information for a server process. It is a nonshared memory created by Oracle when a server process is started. Access to it is exclusive to that server process and is read and written only by Oracle code acting on behalf of it.

When you start a user process, that process has a private RAM area, used for sorting SQL results and managing special joins called “hash” joins.

The PGA can be critical to performance, particularly if your application is doing a large number of sorts. Sort operations occur if you use ORDER by and GROUP BY commands in your SQL statements.

Private SQL Area -

Variables that might be assigned values during SQL execution
Work areas for processing specific SQL needs: sorting, hash-joins, bitmap operations
Cursors

Session memory -

login information
session variables and settings

Following are key SQL Queries related to PGA:

select * from v$pgastat;
select * from v$pga_target_advice order by pga_target_for_estimate;
select max(pga_used_mem), max(pga_alloc_mem), max(pga_max_mem) from v$process;

Java Versions, Features and History

2013-01-21T12:13:00.000+05:30

Came across following excellent blog on Java language:
http://javapapers.com

Liked following post on Java Versions, Features and History:
http://javapapers.com/core-java/java-features-and-history/

Key Internet Terms

2012-12-18T15:28:00.003+05:30

APACHE:

Apache is world's most popular Web server (HTTP server).
Apache Web server(Apache HTTP Server) often referred to as simply Apache.
The first version of Apache was based on the NCSA httpd Web server and was developed in 1995.
The Apache server has been developed by an open source community - Apache Software Foundation.
The original version of Apache was written for UNIX, but there are now versions that run under OS/2, Windows and other platforms.
Apache has various modules for supporting CGI, SSI, user authentication, URL redirection, anonymous user access, automatic directory listings, support for HTTP header metafiles, support for loading modules, content negotiation, caching proxy abilities, server status display, user home directories, etc.

APPLICATION SERVER:

Provides method/business logic for client applications.
An Application Server can support other protocols apart from HTTP.
Application server is based on 3-tier architecture (separation of business logic from the presentation logic and the database logic).
Application servers usually take care of most of technical issues and allow developers to concentrate on the business need.

WEB APPLICATION SERVER:

The application server combines or works with a web Server and is called a Web Application Server.

When we don't need Application Server?

- For non critical and small application, there is no need to invest in an application server.

- A web browser which supports a Html-based front end communicates with a web server. The Web server provides several different ways to service a request band to forward back a modified or new Web page to the user. These approaches include the Common Gateway Interface (CGI), Microsoft's Active Server Page (ASP), and the Java Server Page (JSP).

COOKIE:

Also known as browser cookies or tracking cookies.
Originally designed to help support session state, though custom cookies can be used for other things as well.
A cookie stores a single piece of data under unique name.
Cookie name have to be unique within a given webpage/website (just like a variable).
Cookies are stored w.r.t. the page that created them.
A cookie comes with an expiration date, when expiration date arrives cookie is destroyed. If cookie is created without any expiration date, it gets erased when browser is closes.
Cookie size is limited to 4Kb.
Cookie number is limited to 20 per web server.
Max number of cookies allowed is 300.
A cookie is piece of information that is issued by a server in an HTTP response and stored for future use by the HTTP client (Browser).
Browser will send it back to server with each request.
User doesn’t get involved in cookie exchange it's managed by the server and cookie enabled client.
Format of the cookie -

cookieName=cookieValue;expires=expirationDateGMT;path=URLpath;domain=siteDomain

DEPLOYMENT DESCRIPTOR:

Describes how a component, module or application (such as a web application or enterprise application) should be deployed.
Configuration file for an artifact that is deployed to some container/engine.
Java web applications use a deployment descriptor file to determine how URLs map to servlets, which URLs require authentication, and other information.
Describes the classes, resources and configuration of the application and how the web server uses them to serve web requests.
XML based.
One DD per web application.
JSP compilation and URL mappings are automatically taken care of, but in case more control is required, use <jsp-file> element instead of <servlet-class>.
For web applications, the deployment descriptor must be called web.xml and must reside in the WEB-INF directory in the web application root.
For Java EE applications, the deployment descriptor must be named application.xml and must be placed directly in the META-INF directory at the top level of the application .ear file.
you can use the DD to customize other aspects of your web application including security roles, error pages, tag libraries, initial configuration information, and if it’s a full J2EE server, you can even declare that you’ll be accessing specific enterprise javabeans.

FORM (HTML FORM):

HTML forms are used to pass data to a server.
Part of web page that includes areas where readers can enter information to be sent back to web server.

A form can contain input elements like text fields, checkboxes, radio-buttons, submit buttons and more.

When the user submit a form, browser issues a POST request, which sends the form's data to the server.

HTTP:

It's agreed opon method (protocol) for transferring hypertext documents around the web.
Protocol used by web browser(client) to interact with the Application (server).
HTTP is called a stateless protocol because each request is processed independently, without any knowledge of the requests that came before it.
HTTP protocol doesn’t have any mechanism for the server to know that the client is gone.
HTTP is the network protocol of the Web used to deliver virtually all files and other resources.
Usually HTTP takes place through TCP/IP sockets.
It is both simple and powerful. Knowing HTTP enables you to write Web browsers, Web servers, automatic page downloaders, link-checkers, and other useful tools.
Default port for HTTP servers to listen is 80.

HTTP 0.9

HTTP was initially a very simple protocol used to request pages from a server.
There were no request headers.
Only one method - GET.
Response had to be a HTML document.
The browser would connect to the server and send a GET command (example below), and the server would respond with the contents of the requested file:

GET /welcome.html

HTTP 1.0

HTTP/1.0 evolved from the original '0.9' version of HTTP.

By any reasonable standard, the HTTP/1.0 protocol has been stunningly successful inspite of numerous flows.

The process leading to HTTP/1.0 involved significant debate and experimentation, but never produced a formal specification.

The HTTP Working Group (HTTP-WG) of the Internet Engineering Task Force (IETF) produced a document (RFC1945) that described the 'common usage' of HTTP/1.0, but did not attempt to create a formal standard out of the many variant implementations.

HTTP 1.0 defines 16 headers, none of them is mandatory.

HTTP 1.1

The basic operation of HTTP/1.1 remains the same as for HTTP/1.0, and the protocol ensures that browsers and servers of different versions can all interoperate correctly.
If the browser is compatible with version 1.1, it uses HTTP/1.1 on the request line instead of HTTP/1.0.
When the server sees this is knows it can make use of new 1.1 features, else server will respond to older standard.
The HTTP/1.1 specification states the various requirements for clients, proxies, and servers.
HTTP 1.1 defines 46 headers, and one ("Host") is required in all requests.
Major Changes:

Hostname Identification - Every request sent using HTTP/1.1 must identify the hostname (from URL) of the request. Before HTTP 1.1, each host name required a unique IP Address.
Content Negotiation - Ability to have a number of different versions of a single resource (difference in language, file format etc). Negotiation is done between browser and server.
Persistent connection - (Most Important feature)

In HTTP 1.0, a connection between the client and server is closed after a single request/response cycle.
In HTTP 1.1, a connection between the client and server is kept alive and reused for multiple requests.
HTTP 1.1 is fast because of persistent connections, because client doesn't need to renegociate the TCP connection after each request.
Persistent connections is default behavior, unless browser explicitly tells the server not to use it, i.e., server assumes multiple requests from each connection.
Persistent connections are controlled by the Connection header. Unless a Connection: close header is given, the connection will remain open. Connection also gets closed on server-configurable time out (typically 15 secs).
Pages today include inlined documents, images and other multimedia content. These pages can be slow to download because each item needs to be requested separately from the server, each on a separate connection. With Persistent connection it gets faster.

Byte Ranges

Byte ranges allow browsers to request parts of documents.
This can be used to continue an interrupted transfer, or to obtain just part of a long document (say, a single page).
Byte ranges are implemented by the Range header. For example, to request just the second 500-bytes of a document, the request would include - Range: bytes=500-999
A single request can also ask for more than one range at once (for example, first 500 bytes and the last 500 bytes of a file). When the server replies, it will send back each part in a single response, using MIME multipart encoding to distinguish the parts.

Chunked Transfers - Encoding

Normally when sending back a response the sever has to know everything about the response it is about to send. For instance, servers should set the Content-Length header on each response to the length of the response itself.
This can be difficult for the server to do if the content is dynamically created. So in practice servers (including Apache) often do not send a Content-Length with dynamic documents.
For HTTP/1.1, the Content-Length must be known in advance, if a server wants to start sending a response before knowing its total length, it might use the simple chunked transfer-encoding.
With chunked transfer-encoding, entire document is broken into smaller chunks and sent in series.
"transfer-encoding: chunked" header identifies chunked transfer-encoding.

Why HTTP is Stateless despite proxies, cookies and persistent connections?

Even though multiple requests can be sent over the same HTTP connection, the server does not attach any special meaning to their arriving over the same socket. That is solely a performance thing, intended to minimize the time/bandwidth that'd otherwise be spent reestablishing a connection for each request.
As far as HTTP is concerned, they are all still separate requests and must contain enough information on their own to fulfill the request. That is the essence of "statelessness". Requests will not be associated with each other absent some shared info the server knows about, which in most cases is a session ID in a cookie.
HTTP is considered stateless because the browser sends all the information the server works (cookies, referrer, etc) with in the HTTP Request Headers.
While there might a database involved which does store state, HTTP is stateless, because it doesn't store anything. And even if the socket is kept open, as long as it doesn't store anything it is still considered stateless.
HTTP persistent connections relate to TCP connection being left open. HTTP operates on top of TCP - so TCP can be connected and/or stateful whereas HTTP would not. TCP is just the transport for HTTP.

HTTPS

HTTP + SSL
Default port is 443

HTTP REQUEST:

Request that browser sends to the web server.

Request could be to get some file from the web server.

Request could be to submit the data to be processed.

HTTP RESPONSE:

Reply from a web server to the web browser's request to fetch and transmit the requested web page, image, script and other in the http response.

Normally consists of a status line, one or more header parameters, a blank line, and optionally from a content received in the http response.

An HTTP response can contain HTML. HTTP adds header information to the top of whatever content is in the response (in other words, the thing coming back from the server).

HTTP/1.1 200 OK

Date: Tue 14 Sep 1982 01:40 GMT

Content-Type: text/html

Content-length: 52

<html>

<body>

<h1>Hello</h1>

</body>

</html>

Initial line contains HTTP version, response code and English reason phrase.
HTTP response codes:

1XX - Informational messages.
2XX - success messages.
3XX - redirects the client to another URL.
4XX - error on the client's part.
5XX - Server is aware that it has erred or is incapable of performing the request.

HTTP GET:

Get is the default and most common HTTP method.
"GET" is basically for just getting (retrieving) data.

Its main job is to ask the server for the resource. If the resource is available then then it will given back to the user on your browser. That resource may be a HTML page, a sound file, a picture file (JPEG) etc.

Get is for getting something from the Server. You can send parameters to the server in Get, but the total amount of characters in a GET is really limited.

GET /servlet/WelcomePG?userName=prince HTTP/1.1

HTTP POST:

Used for Form Submissions.

By using Post we can request as well as send some data to the server. We use post method when we have to send a big chunk of data to the server, like when we have to send a long enquiry form then we can send it by using the post method.

Data from the POST method is sent by the client as a part of the request body.

POST /servlet/WelcomePG?userName=prince HTTP/1.1

User-Agent: MOZILLA/1/0

Content-Type: application/x-www-form-encoded

ContentLength: 11

userName=john

HTTP HEAD:

To retrieve the meta-information about a resource, to check the time when the resource was last modified on the server
Structure of HEAD request is same as GET.
Gives you info about the requested resource without actually getting the resource.

HTTP PUT:

"PUT" is used to add a resource to the server.

HTTP TRACE:

Asks for a loop-back of the request message, so that the client can see what’s being received on the other end, for testing or troubleshooting.
TRACE allows the client to see what is being received at the other end of the request chain and use that data for testing or diagnostic information.
It is not used in production, only used for troubleshooting.

HTTP OPTIONS:

This method allows the client to determine the options and/or requirements associated with a resource, or the capabilities of a server, without implying a resource action or initiating a resource retrieval.
Asks for a list of the HTTP methods to which the thing at the requested URL can respond.
Introduced in HTTP 1.1 version.
Almost no one uses it.

HTTP DELETE:

"DELETE" is used to delete a resource to the server.

HTTP CONNECT:

This specification reserves the method name CONNECT for use with a proxy that can dynamically switch to being a SSL/TCP tunnel (to pass servlet through firewall).

HTTP GET, HEAD and PUT are idempotent.

HTTP PROXY:

A program that acts as an intermediary between a client and server.
It receives requests from client, and forwards those requests to the intended servers.
A proxy has functions of both a client and server.
Proxies are commonly used in firewalls, for LAN-wide caches etc.

HYPERLINK:

Hyperlink (or link) is a reference to data that the reader can directly follow, or that is followed automatically.
A hyperlink points to a whole document or to a specific element within a document.

HYPERTEXT:

Hypertext is text which is not constrained to be linear.
Hypertext is text displayed on a computer or other electronic device with references (hyperlinks) to other text that the reader can immediately access.
Hypertext is text with Hyperlink.
Apart from running text, hypertext may contain tables, images and other presentational devices.

HYPERMEDIA:

HyperMedia is a term used for hypertext which is not constrained to be text: it can include graphics, video and sound.

INTERNET:

The Internet is a massive network of networks, a networking infrastructure.
It connects millions of computers together globally, forming a network in which any computer can communicate with any other computer as long as they are both connected to the Internet. Information that travels over the Internet does so via a variety of languages known as protocols.

JAVA BEAN:

A JavaBean (or "bean" for short) is simply a reusable component that implements specific design patterns to make it easy for programmers and development tools to discover the object's properties and behavior.
Reusable component that implements specific design patterns to make it easy for programmers and development tools to discover the object's properties and behavior.

JSP:

File with some HTML and Java code that executes top to bottom. At runtime, it is compiled into a Java class, which is actually a servlet.

A JSP page looks just like an HTML page, except you can put Java and Java-related things inside the page.

Your JSP eventually becomes a full-fledged servlet running in your web app.
Major limitation with JSP - The UI is only as good as the programmer's ability to generate the proper HTML.

JSP FORWARD:

Passes the request object within the server to either a servlet or a JSP page.

The URL shown in the browser stays unchanged when you do forward.

It allows the next Java Servlet/JSP to access the same request object. In OAF request parameters of one page are accessible in PFR in its CO on form submit and also in next page when we navigate using setForwardUrl or forwardImmediatly.

A client browser will never realize whether its request is forwarded since the forwarding happens in the server side.

Forwarding is useful when it is necessary to continue processing the current request with different Java Servlet/JSP.

JSP REDIRECT:

Creates a new request object which doesn't carry any of old requests.

The first request handler JSP page tells the browser to make a new request to the target servlet or JSP page.

The URL shown in the browser therefore changes to the URL of the new page when you redirect.

Client browser with redirection enabled will refresh its address bar to the next Java Servlet/JSP address, which means that a redirection address must be client access-able address.

MIME:

Multipurpose Internet Mail Extensions
Sometimes referred to as Content-types
Instead of term "MIME type", "Internet media type" should be preferred today.
Standard internet protocol that extends the format of email to support:

Text in character sets other than ASCII
Non-text attachments
Message bodies with multiple parts
Header information in non-ASCII character sets

MIME types form a standard way of classifying file types on the Internet.
Internet programs such as Web servers and browsers all have a list of MIME types, so that they can transfer files of the same type in the same way, no matter what operating system they are working in.

MIME TYPE:

Sometimes referred to as Content-types
Instead of term "MIME type", "Internet media type" should be preferred today.
A media type is composed of two or more parts: A type, a subtype, and zero or more optional parameters.
e.g. text/html; charset=UTF-8

text is type
html is subtype
charset is parameter.

MIME types are also used in HTTP response to specify content-type.
Typical content types are “text/html”, “application/pdf”, and “image/jpeg”.

SERVLETS:

Java-based web application server extension program that implements a standard API.

Servlets are modules of Java code that run in a server application (hence the name "Servlets", similar to "Applets" on the client side) to answer client requests. Servlets are not tied to a specific client-server protocol but they are most commonly used with HTTP and the word "Servlet" is often used in the meaning of "HTTP Servlet".

SERVLET CONTAINER:

Also known as WEB CONTAINER, J2EE WEB CONTAINER, SERVLET ENGINE (older name).
It is the component of a web server that interacts with Java servlets.
A servlet container is nothing but a compiled, executable program which takes the responsibility of instantiating, initializing and invoking the components.
Container calls the service() method and handles the Request and Response parameters.
In order to be managed by container components must follow certain contract.
J2EE specification defines contract between components and container, and specifies the deployment model for components.
When developing applications with J2EE, we develop components that follow the contract defined in the specification.
The web container implements Servlet and JSP API and provide infrastructure for deploying and managing web components.
As per the specification, all web containers must support HTTP protocol however it may support addition protocols like HTTPS.
There are three types of Servlet Containers:

Standalone - Java-based web servers where the two modules -- main web server and the servlet container are integral part of a single program. Ex. Tomcat running all by itself.
In-process - Main web server and the servlet container are different programs, but the container runs within the address space of the main as a plug-in. Ex. Tomcat running inside Apache Web Server. Apache loads JVM that runs Tomcat. Webserver handles the static content by itself and Tomcat handles the servlets and jsp.
Out-of-process - Web server and Container both run as separate programs. Web server will use a plug-in to communicate with servlet container. Usually the plug-in will be provided by the servlet container vendor. Ex. Tomcat, Apache and mod_jk (plus-in).

SERVLET INVOKER:

As defined by Apache Tomcat specification, the purpose of Invoker Servlet is to allow a web application to dynamically register new servlet definitions that correspond with a <servlet> element in the /WEB-INF/web.xml deployment descriptor.By enabling servlet invoker the servlet mapping need not be specified for servlets. Servlet ‘invoker’ is used to dispatch servlets by class name.
Enabling the servlet invoker can create a security hole in web application. Because, Any servlet in classpath even also inside a .jar could be invoked directly.
The application will also become not portable.
In Tomcat 3.x, by default the servlet invoker is enabled.
In Tomcat 4.x, by default the servlet invoker id disabled. The <servlet-mapping> tag is commented inside the default web application descriptor (web.xml), located under $CATALINA_HOME/conf.
Deprecated in version 6 and totally removed in 7.

SERVLET SESSION:

Mechanism for maintaining state between HTTP requests during a period of continuous interaction between a browser and a web application. A session may be initiated at any time by the application and terminated by the application, by the user closing the browser, or by a period of user inactivity. A session usually corresponds to an application login/logout cycle.

SSL

Secured Sockets Layer.

Security Protocol used to secure data between two machines using encryption.
Allows private and secured access over internet by providing Authentication, Encryption and Integrity checks.
If SSL detects that the connection is not secure, it'll disconnect the connection and client and server establishes a new secured connection.
SSL sits above communication protocol like TCP/IP and below Application protocol like HTTP/SMTP etc.
Differnt types of SSL - DomainSSL, OrganizationalSSL, and ExtendedSSL (Highest trust level).
SSL Certificate assures that user is on legitimate website.

URI:

Uniform Resource Identifier.
Specific character string that identifies a name or a resource.
URIs can be classified as locators (URLs), as names (URNs).
A resource is some chunk of information, commonly a file, but it could also be a dynamically generated query result, output of a program or script output or something else.

URL:

Uniform Resource Locator.
Specific character string that constitutes a reference to an Internet resource.

URN:

Uniform Resource Name.
URN is a URI that identifies a resource by name. It doesn't provide its location or how to access it.
Ex. ISBN 0-486-27557-4 uniquely identifies a book but doesn't tell anything of its location.

A URN functions like a person's name, while a URL resembles that person's street address. In other words: the URN defines an item's identity, while the URL provides a method for finding it.

WEB:

The World Wide Web (abbreviated as WWW or W3, commonly known as the Web), is a system of interlinked hypertext documents accessed via the Internet.
The World Wide Web, or simply Web, is a way of accessing information over the medium of the Internet. It is an information-sharing model that is built on top of the Internet.
The Web uses the HTTP protocol, only one of the languages spoken over the Internet, to transmit data.
Web or World Wide Web and Internet are used as if they are synonyms, but they are different terms. Please check Internet definition above for details. Web is the system we use to access the Internet. The Web isn't the only system used to access internet but it's the most popular and widely used.

WEB 1.0:

Web 1.0 provided one way communication from Website to visitors. It was primarily in early 1990.

WEB 2.0:

Its a marketing term referring to different way of building application. Ajax is considered to be part of Web 2.0.
Web 2.0 provides two way communication, allow user generated context. It came in late 1990s.
Web 2.0 has made users to be the creator of content.
Ajax, Social networking, mash-ups, media sharing, online commerce, Wikis,
Web 2.0 encourages participation, collaboration, and information sharing. Examples of Web 2.0 applications are Youtube, Orkut, Wiki, Flickr, Facebook, and so on.

WEB 3.0:

Computers can interpret information like humans and intelligently generate and distribute useful content tailored to the needs of users.
Intelligent Web - Machine facilitated understanding of information.
Ex. Recommendor System
JavaScript, JSON, XML, AJAX, Web Services, SAAS, Cloud Computing, Mobile (ubiquitous) Computing.

SOCIAL MEDIA:

Social Media refers to next step after Web 2.0. In addition to two way communication, it allows visitors to communicate to each other. Thus it provides 3-Way communication.

WEB APPLICATION:

Application available from web, composed on web components.

WEB BROWSER:

The World Wide Web (abbreviated as WWW or W3, commonly known as the Web), is a system of interlinked hypertext documents accessed via the Internet.
The browser is the piece of software (like Netscape or Mozilla) that knows how to communicate with the server.
The browser’s other big job is interpreting the HTML code and rendering the web page for the user.
Browser works on HTTP, responsible for creating request, interpreting response.

WEB COMPONENTS:

Software component that services an incoming HTTP request and provides some kind of (hopefully valid) response.

Server-side object used by a Web-based client (browsers) to interact with J2EE applications.

Servlets and JSP pages are collectively called web components.

WEB SERVER:

Web servers tirelessly wait for web requests; on getting a request for a resource, server finds the resource and sends it back.
Web servers are combinations of hardware and softwares that deliver (serves up) Web pages.
It uses Client-Server model and HTTP protocol.
It delivers the web pages to the client and to an application by using the web browser and the HTTP protocols respectively.Web server interacts with the client through a web browser.
Web Server passes the request to Web Container.
A Web application runs within a Web container of a Web server. The servlet container together with the web server (or application server) provides the HTTP interface to the world.

A short guide to Java Script

2012-11-10T12:15:00.002+05:30

Java Script

Also referred to as JS or Js.
JavaScript is the scripting language of the Web.
Major Aim was to energize and enhance the user's web experience.
Inspired by SELF programming language.
Object based, Interpreted, scripting language. The part of the web browser that runs the java script is called JavaScript Interpreter.

JavaScript is object based and not object oriented because it doesn't support Inheritance and Polymorphism. It have built-in objects like windows etc.

JavaScript does not use classes. JavaScript is prototype based, not class based.
Created by Brendan Eich at Netscape in December 1995. (Earlier it was called "LiveScript" before that it was called "Mocha").

European Computer Manufacturer's Association (ECMA) standardized the script and named it as ECMAScript.

JavaScript can be divided into three parts -

Core Language (language fundamentals and syntax),
Client-side (provides access to DOM and various browser objects) and
Server-side (to code for server side standalone components of web application, access to server side objects).

Client-side JavaScript is interpreted on the fly by the browser while Server-side JavaScript is first compiled into bytecode like Java.
Server-side JavaScript is not covered here.

Features

JavaScript provides client side validations, so we are saved from passing data to server and reloading the page. Prior to JavaScript dynamic behavior was achieved with Server-side scripting.
JavaScript is case-sensitive.
A script can get the height and width of the browser window, client date as well as history of visited pages.
Alternate text can be provided, for occasions when JavaScript support is absent or disabled with <noscript> </noscript>.
Cookie data is stored in the DOM document object's cookie property as one or more "name=value" pairs, in which the values may not contain any whitespace, commas, or semi-colon characters.
Cookies can be set using document.cookie as well as readCookie and writeCookie method.
escape() and unescape() methods are used to encode/decode the strings - remove whitespace, etc other characters.

JavaScript and Security Concerns:

JavaScript doesn't allow you to read/write files on the user's hard drive. This limitation wipes out the potential for a lot of viruses. JavaScript doesn't support File Handling.
JavaScript doesn't support Network programming. It cannot establish a direct connection to any other hosts on the network. JavaScript program cannot use a client's machine as an attack platform from which to attempt to crack passwords on another machine.
Most browsers don't allow scripts to open or close windows without the user's approval.
A JavaScript program cannot close a browser window without user confirmation unless it opened the window itself.
Access to cookies is restricted by owning websites.
JavaScript cannot be used to set the value attribute of a file input, and will not be allowed to use them to upload files without permission.
JavaScript cannot read what locations a user has visited by reading them from the location object, although it can tell the browser to jump back or forward any number of steps through the browser history. It cannot see what other Web pages the user has open.
It cannot see when the user interacts with other programs, or other parts of the browser window.
It cannot open windows out of sight from the user or too small for the user to see. JavaScript doesn't allow to open or resize the window to less than 100px.
A script may not cause a window or frame to display an about: URL, such as about:cache, because these URLs can expose system information, such as the contents of the browser's cache.

JavaScript is used as a "script engine" for other software components, such as ActiveX controls in Internet Explorer and plugins in Netscape. These may have file access and networking access.

<Script> Tag

Can be added anywhere in HTML, but its best to put it in <head> tag.
"type" attribute identifies the type of scripting language. Other scripting language examples are VBScript, ASP.Net AJAX etc. It actually specifies MIME type.
In addition to <script> tag, JavaScript code can be put directly into event handlers as well, its not a good practice and is done normally in case of a single line of code like an alert.

<script type="text/javascript">
function ...
....
</script>

<script type="text/javascript" src="myCustomJS.js"> </script>

Event

JavaScript mechanism that allows you to trigger a piece of JavaScript when something of interest happens to the page.
Events are initiated by users but they come from browser.
<h1 onclick="alert('Hello');">Click Here</h1> //executing JS code
<h1 onmouseover="change()">Hello</h1> // calling JS function
document.getElementById("submitButton").onclick=displayName();
document.getElementById("submitButton").onclick=function(){
changeName();
displayName()
};
JavaScript event object has properties for type, target, altKey/shiftKey/ctrlKey gives true/false based on if for alt/shift/ctrl key was pressed, charCode/keyCode provides ascii code in case of KEY-related events etc

Event - Standard Event Model

With events defined in above section, we cannot Add and Remove Event listeners, Standard Event Model provides us ways to add/remove (attach/detach) event listeners.
element.addEventListener(<type>, <JSFunction>, <use Capture>);
element.removeEventListener(<type>, <JSFunction>, <use Capture>);
element.attachEvent(<type>, <JSFunction>); // Old IE browser
element.detachEvent(<type>, <JSFunction>); // Old IE browser
Bubbling is default behavior. (Google Bubbling and Capture for more information).

JavaScript variables, constants and data types

Three basic data types: string, number and boolean.
There are two other data types: function and object.
Data type are assigned to variables automatically depending on the value assigned, it changes with the change in value.
All numbers in JavaScript are stored as 64-bit (8-bytes) base 10, floating point numbers. There is no concept of int, long, and float.
false isn't exactly same as 0, but it converts to 0 when used where a number is expected.
The current variable type can be revealed by the typeof keyword. It returns a value of "undefined" for uninitialized variables.
Number.NaN, Number.POSITIVE_INFINITY, NUMBER.NEGATIVE_INFINITY, isNaN(), isFinite() are some key properties and methods.

JavaScript Functions

There are two ways to define functions -

A. Using Function declaration:
function test()
{

alert(test function);
}

B. Using Function expression (Assigning anonymous function to a variable):
var test2 = function()
{

alert(test function);
}

Approach B demonstrate that functions are variables in JavaScript. This approach is revisited in JavaScript objects.
Approach A on using function declaration are loaded first in the programs. Java script engines hosts function declaration to the top. It is possible to call the function before its declaration. It is not the case with function expression, it'll throw error.

test(); // This will not error out and work normally.

test2(); // This will error out

// because function expressions are not loaded first.

function test()
{

alert(test function);
}

var test2 = function()
{

alert(test function);
}

A function can return another function.

function testFunc(name)
{

return function()
{

var message = "Hello "+ name;

alert(message);

};

}

var func = testFunc("Prince");
func();

To have variable arguments functions - use arguments keyword.

    function sum()    {
        total = 0;
        for (i=0; i < arguments.length; i++)
        {
            total += arguments[i];
        }    }    var sumTotal = sum(100, 1, 2, 4);    document.write(total);

Objects

Memory area created by browser which represents an entity.
Almost everything is object in JavaScript in Java Script, ex Forms, Text field etc.
There are three ways to create objects:-

Define and create a direct instance of an object.

<script>

function customToString()
{
return this.firstname+" "+this.lastname;
};

var emp=new Object();
emp.firstname="Prince";
emp.lastname="Kapoor";
emp.ID=7918;
emp.customToStr = customToString;
document.write(emp.customToStr());
</script>

Using JSON to define an object.

JSON Ex 1:<script>
var emp={firstname:"Prince",lastname:"Kapoor",ID:7918};
document.write("Employee ID of "+emp.firstname + " is " + emp.ID);
</script>

JSON Ex 2:<script>
var emp=
{ firstname:"Prince",
     lastname:"Kapoor",
     ID:7918,
     getOutputText: function() {
        return "Employee ID of "+this.firstname + " is " +this.ID;
     }
};
document.write(emp.getOutputText());
</script>

Using a prototype function to define an object, then create new object instances. (MOST PREFERRED)

By naming conventions, functions starts with small letter and constructors start with Capital letter.

Syntax: function object-name (param1, param2, param3)
{
    this.property1 = param1;
    this.property2 = param2;
        this.property3 = param3;
this.method1 = function1;
this.method2 = function2;
}

Ex:     function Emp(firstname,lastname,id)
// Above declaration could also be written as:
// var Emp = function(firstname, lastname, id)
{
this.firstname=firstname;
this.lastname=lastname;
this.ID=id;
this.getFullName = function ()
            {
                return this.firstname+" "+ this.lastname;
            }
}

var prince = new Emp("Prince", "Kapoor", 7918);

When we need multiple objects, then we can also use factory functions, but using constructors are a better idea.

With Factory methods also, in case we need to modify an object interface, we need to make changes at one place, like adding a new function to the object.

function createEmp(firstName, lastName) {

return {

firstName : firstName,

lastName : lastName,
getFullName : function () {

return this.firstName+" "+ this.lastName;
}

};
}

var prince = createEmp ("Prince", "Kapoor");

The way we have defined functions above, including defining in the constructor is not the best way as it stores function definition in the memory separately for each object.

If we define it using the prototype then function definition will be stored only once.
Functions defined for Date, String etc JavaScript objects are also defined in the same way.

Ex. function Emp(firstname,lastname,id) {
this.firstname=firstname;
this.lastname=lastname;
this.ID=id;
}
Emp.prototype.getFullName = function ()
        {
            return this.firstname+" "+ this.lastname;
        }

By using apply(newObject) on function method, function can be executed as if it is part of another object.

In Apply we pass arguments as array and there is call() method, in which we pass arguments directly without any array.

document.write(emp1.getFullName.call(person1, "Mr."));

Following is practical example of apply/call - using methods of Array on arguments object.

Array.prototype.pop.apply(arguments);

Objects are very flexible and can be extended using prototype property to add more object properties or methods.
" prototype " extends object definition using its name, not instance name.

DOM:

Is an API for accessing and changing content, style document structure.
The W3C Document Object Model (DOM) is a platform and language-neutral interface that allows programs and scripts to dynamically access and update the content, structure, and style of a document. DOM is separated into 3 parts - Core DOM, XML DOM, HTML DOM. HTML DOM is standard object model for HTML.
The HTML DOM is a standard for how to get, change, add, or delete HTML elements.
When a web page is loaded, the browser creates a Document Object Model of the page. The HTML DOM model is constructed as a tree of Objects.

Window

Represents content area of the browser.
There are three types of dialog message communications: window.alert(), window.confirm(), and window.prompt()
window.open() is used to open a new window object.
window.moveTo()to move the current window.
window.document represents HTML document.
Object Type is DOMWindow.
Window object has two self-referential properties, window and self. Either of these global variable to refer directly to the Window object. Ex. self.close().
window.top refers to the top-most window in case of multiple frames.
window.self is mostly used in comparisons like:

window.parent.frames[0] != window.self
window.self != windpow.top

Navigator

Accesses browser program, version etc.
window.navigator.appCodeName,window.navigator.appName, window.navigator.platform, window.navigator.appVersion (in some cases appMinorVersion as well), window.navigator.userAgent, navigator.systemLanguage, navigator.cookieEnabled
navigator.javaEnabled() for checking if java is enabled.

Screen

Updates about physical environment in which browser is running, pixels height width etc.
Some key properties related to client screen are : window.screen.width, window.screen.height, window.innerWidth, window.innerHeight, window.screen.availWidth, window.screen.availHeight, and window.screen.colorDepth

History

For accessing browser history information.
window.history stores history information as an array.
history.back(), history.forward(), history.go() are key methods in history object.

Location

Maintains URL information of the page.
window.location object has 5 properties containing the components of full URL: location.href, location.protocol, location.host, location.pathname, location.hash
Assigning a new URL to the location property will cause the browser to load new page.
reload() method will cause the page to be reloaded.
replace() method replaces the history entry.
location.assign() method loads a new document.
window.location.assign("http://www.princekapoor82.blogspot.com")

Document

Represents the HTML document.
Some key properties related to browser screen size are: document.body.clientWidth, document.body.clientHeight
document.title, document.URL(shows same information as location.href but not used for navigation), document.domain (similar to location.host), document.lastModified and document.referrer are some of the key properties.
document.write(), document.getElementById(), getElementByTagName(), getElementsByClassName() are some of the most frequently used methods.
write() vs CreateElement()

write cannot be used to add new components once the page has been loaded as write will remove the page content and then write its content.
write is mostly used during page load.

document object has properties (arrays) for child objects for forms, anchors, images, and links. Each of these objects is an array and contains items in the order in which they appear in the document. Please note: Images that are incorporated as part of the CSS Style are not part of images array, only images defines with <img> will constitute the array. These arrays are older ways of accessing the components, now getElementBy*() methods are supposed to be used.
form object has its own child elements for all the form elements.
Every form field has a form object that can be passed along to a function.

            onClick="validateDate(this.form)"

            function validateDate(form)

{

                //Value of any field can be accessed using syntax:  

                form["StartDate"].value

}

This approach of accessing data is same as getElementById() - It just makes code more readable.

Just like passing form object using this.form, you can pass form field object with this keyword. Ex

                onClick="validateDate(this)"

All the presentational DOM properties are contained within a parent style property, which is a child of the object. For ex. obj.style.textAlign

To add/remove elements following methods can be used: document.createElement, document.createTextNode, <dom object reference>.appendChild, <parent dom object reference>.removeChild(<child dom object reference>);

Form Validation

Forms are used to collect information from websites checkboxes, textboxes, Buttons, dropdowns etc.
JavaScript can be used to validate data in HTML forms before sending off the content to a server.

Number & String

JavaScript numbers are stored as double precision floating point numbers.
parseInt("4 Apples") returns 4.
"10" == 10.0 returns true.
String (aNumber) converts number to string.
Number (aString) converts string to number.
"Prince" > "Kapoor" returns true because it evaluates based on ASCII.
To convert decimal to binary, octal, hexa-decimal, use toString method with appropriate base as parameter:

    var myNumber=16;
    document.write(myNumber.toString(16))   // prints 1
    document.write(myNumber.toString(8))    // prints 2
    document.write(myNumber.toString(2))    // returns 10000

Auto type casting of numbers to text happens when we use then in Alert (Alert expects text).
Text Strings must be enclosed within double quote, nested inner string should be enclosed within single qoute.
There is a discrepancy in floating point calculations in Java and JavaScript. Check the result of 15 * 81.66 or 0.7 * 5000 or 0.2 + 0.1.
Infinity is a special number, 1/0 is Infinity. (Infinity == var)
NaN - 1/"abc" is NaN, isNan()is used to check if parameter is a number or not.
Key Properties of Number - MAX_VALUE, MIN_VALUE, NEGATIVE_INFINITY, POSITIVE_INFINITY, NaN
Key Methods of Number - toExponential(), toFixed(), toPrecision(), toString(), valueOf()
String Key Property - length
String Key Methods - charAt(), charCodeAt(), concat(), fromCharCode(), indexOf(), lastIndexOf(), localeCompare(), match(), replace(), search(), slice(), split(), substr(), substring(), toLowerCase(), toUpperCase(), toString(), trim(), valueOf().

Image

Refers to images on the HTML screen (<img> tag).
Primarily used to pre-cache/pre-loading images based on some action/event. This helps in getting better response time.
To pre-load an image, we create a new Image() object in JavaScript and pass the URL of the image.

Array

There are three ways to create an array:

var fruits = new Array();
fruits[0]="Orange";

fruits[1]="Apple";

fruits[2]="Banana";

var fruits = new Array("Orange", "Apple", "Banana");

var fruits = ["Orange", "Apple", "Banana"];
var productList = []; // will create empty array.

Commonly used methods - length(), indexOf(), lastIndexOf(), concat().
Other operations methods - toString(), join(), slice(), splice(), reverse(), sort(), push(), pop(), shift(),
Array object has some interesting methods - every(), some(), filter(), forEach(), map()

These methods are passed callback function as parameter.
every() is equivalent of for all.
some() is for atleast one.
filter() creates a new array with items that match the criteria.
forEach() doesn't return anything, just executes the function on every element withing an array.
map() similar to forEach but returns the updated elements in a new array.

ex. arrayVar.every(arrayOfEvenNumbersTestFunc);
signature of callback function -

arrayOfEvenNumbersTestFunc(value, index, array);

Operators

= = = and ! = = should be used to check equality and inequality. = = and ! = may produce unexpected results. For Example - (true = = 1) will return true while (true = = = 1) will return false. = = = and ! = = doesn't perform type coercion.
Switch works fine for number, string, as well as boolean.
typeof operator can be used to get the type of the operand. Ex of types - "object", "boolean", "function", "number", "string", "undefined".
- Ex. typeof var == "string".
instanceOf operator is used to if a variable is an instance of a Object

Ex. prince instanceOf Emp

Cookie

Distinct information delivered by web server to browser when they interact for the first time.
For basics of Cookie - refer to Key Internet Terms.
document.cookie is the cookie property.

DOM and CSS

All the presentational DOM properties are contained within a parent style property, which is a child of the object. For ex. obj.style.textAlign
style.visibility is used to toggle visibility ("hidden"/"visible").
Variable declared without a value will have the value undefined. null and undefined are different.

Timers and Animation

There are following methods related to timer event

setInterval()

Executes a function repeatedly after a specified time interval.
myTimerVar=setInterval(<javascript function>,milliseconds);

setTimeOut()

Executes a function once after a specified time interval.
myTimerVar=setTimeOut(<javascript function>,milliseconds);

clearInterval()

Clears interval set with setInterval() to stop further executions.
clearInterval(myTimerVar);

clearTimeOut()

Same as clearInterval() to stop timer set with setTimeOut().
clearTimeOut(myTimerVar);

JavaScript Local Storage

Designed to hold key/value pairs.
Can only be accessed by JS window object.

localStorage.userName = "Prince"; // stores userName.

localStorage.setItem("LastName", "Kapoor"); // works same as above.

localStorage.removeItem("userName"); // removes userName.

localStorage.clear(); // clears all properties

Values stored in LocalStorage are always of type string.
JSON can also be used to store/retieve objects in LocalStorage.
LocalStorage is restricted to a domain.

Important Notes:

Alert() is technically method of windows object, it can also be called as windows.alert()
Script data gets refreshed on refreshing the web page.
To encode URI parameter (remove spaces and special characters), we have encodeURIComponent(). We normally encode for parameter and value.
obj.innerHTML !== "undefined" can be used to test if obj is a DOM object.
If "new" keyword is missing in object creation, then object properties defined with "this" will be created in window object.
You can redeclare a variable, it'll not loose its value.
var name="Prince";
var name;
To prevent links from refreshing or loading another page, we can use the JavaScript void() function and pass a parameter of 0 (zero) and #.

<a href="JavaScript:void(0);" onClick="alert('Testing Void(0)')">Click</a>

There is a special "for in" loop that can be used to list all the initialized properties and methods of an object (including DOM objects like windows etc). It can also be used for arrays (since arrays are also objects).
RegExp - Object to support regular expression.
The \n escape sequence is used to specify a newline character in the alert dialog text.
KEYPRESS event doesn't capture modifier keys like Shift, Ctrl etc. KEYDOWN and KEYUP does capture.

Callback Functions

Inline JavaScript code and JavaScript functions can be assigned to any HTML event attribute, such as onClick, onLoad etc.
<img id="update" src="updateImg.jpg" onClick="updateNavigation(3);">

Above approach mixes HTML and JavaScript, which intrudes structural nature of the HTML elements and increases maintainance and debugging efforts

We should keep the intergation of JavaScript and HTML to JavaScript itself. Following are some examples:

<body onload="initDetails();">
can be written in JavaScript as
windows.onload=initDetails; in the <HEAD> section.

<body onload="initDetails("read_only");">
can be written in JavaScript as
windows.onload = function(evt) { initDetails("read_only"); }

AJAX and JavaScript

AJAX can write script that request information from the server and then process and display that information on the page.
AJAX is not a technology but simply a new approach towards dynamic user interface combining other technologies.

JavaScript Object Reference

JavaScript Object Reference will be helpful for coding in JavaScript. Reference will provide all the methods and properties available in an object.

Some Javascript examples:-

Restricting users with what keys can be entered -

Check on key press event with the ascii code of the key pressed, if key is one of the restricted keys, then prevents default action.

Implement Hot Keys -

event -> keyDown

event.ctrlKey should be true.

Compare ascii code to check if the key down is the key which we need to capture for hot keys.

A Short Guide to CSS

2012-10-25T19:45:00.000+05:30

Oracle Applications allows creation of Custom Look and Feel. All these custom look and feel creates a new CSS. We also define CSS property for many UI Widgets like OraDataText etc. All the existing skins defined in the profile option Oracle Applications Look and Feel also maintain their own style and thus their own css. You can find all the CSS at $OA_HTML/cabo/styles/cache in your file server. We'll learn basics of CSS here.

CSS

CSS stands for Cascading Style Sheets.
External Style Sheets are stored in CSS files.
Allows to separate HTML content from it’s style. Use your HTML file to arrange the content, and CSS for all of the presentation.
External CSS are shared and thus allows us to change Look and Feel of entire website by modifying one CSS file.
CSS improves performance because style sheet only needs to be downloaded to client machine and then it's used from cache.
A nested element will inherit the properties assigned to the containing element.
In case if same style is mentioned multiple times in same CSS/HTML file, the effect is cascaded. Following are the rules:

If same style is defined multiple times in a file, then the one defined at the end will take preference in case if same property is defined.
Inline Style - Highest Priority
Internal Style Sheet - High Priority
External Style Sheet - Normal Priority
Browser Default - Low Priority

Divisions(<div>) are a block level (X)HTML element used to define sections of an (X)HTML file.
Spans(<span>) are very similar to divisions except they are an inline element versus a block level element.
width:40% will work with <div> and not with <span>, as div is block level while span is inline.

Sample CSS Syntax

selector {property:value;}

    p {color:red;text-align:center;}

    /* Below is syntax in more readable form */

    p

    {

        color:red;

        text-align:center;

    }

P is called Selector.
"color:red;" and "text-align:center;" are called declaration.
Every declaration ends with semi colon, and contains a property and value.
Every declaration group is surrounded by curly brackets.
/* .. */ is used for comments.
We can combine multiple selectors together while defining CSS

    h1, h2, h3, h4, h5, h6 

{

        color: #009900;

        font-family: Georgia, sans-serif;

}

Inline Style

Uses HTML attribute style for this.

<body style="background-color: #FF0000;">

Internal Stylesheet

Placing CSS code directly into the <HEAD> section.

     <head>

         <title><title>

         <style type=”text/css”>

             // CSS Content Goes Here

             body

             {

                 background-color:#d0e4fe;

             }

         </style>

     </head>

<style> tag is used to define style information for a HTML document.
<style> tag can appear multiple times in a HTML document.

External Stylesheet

Created as external file and linked to the HTML document.
We can link to the file externally by using either <link> or <style> with @import in the <head> section.

<link> is intended to link together your Web page with your style sheet.
<link> tag defines the relationship between a document and an external resource.
<link> element is an empty element, it contains attributes only.
<link> element can appear any number of times in <HEAD> section.
@import allows you to import one style sheet into another.
@import is a way of creating a style sheet within your document, and then importing additional rules into the document.
@import rule must always be the first in the document. Even comments shouldn't come before this.
<link> element gives better performance and more readable code compared to @import.

Selector Type

HTML Selector

To redefine the general look for an entire HTML tag.

p
    {
        font-family:verdana;
        text-align:left;
        color:blue;
    }

Id Selector

The id selector is used to specify a style for a single, unique element.

#book
    {
        text-align:left;
        color:blue;
    }
    <div id="book">
        This is my first book. I wish to write a technical book once...
    </div>

Class Selector

Used to specify a style for a group of elements.
Can specify specific HTML elements which should be affected by a class.

.red{color:red;}

    p.red{color:red;} 

Context Dependent Selector or Nested Selector or Decendant Selector

Used to specify a style for a selector when its used in conjunction with another one.

p b{color:red;font-weight:bold;}

innerClassSelector {color:pink;}

outerClassSelector {color:red;}

.outerClassSelector .innerClassSelector{color:blue;}

When innerClassSelector is used inside outerClassSelector then this style will be applicable, else the default of innerClassSelector will be applicable. innerClassSelector needn't be the immediate child, but it should be in the same hierarchy.
Context dependent is specified by separating two classes with a space.

Immediate Child Selector or child combinator selector

Similar to Context Dependent Selector but it looks for immediate child only.
It impacts only the first child.

p > b{color:red;font-weight:bold;}

Adjacent Sibling Selector

It will style only the element that is immediately preceded by the former element.

#MAN + p {color:green;}

General Sibling Selector

It will style only the element that is preceded by the former element, may not be immediatly.

#MAN ~ p {color:green;}

Attribute Selector

Style HTML elements that have specific attributes.

[title]{color:green;}

Attribute and Value Selector

Below Styles all elements with title="Custom Product Branding":

[title="Custom Product Branding"] {color:green;}

Below styles all elements with a title attribute that contains word "Hello":

[title~=Hello] {color:green;}

It'll work for "Hello World", "World Hello" but will not work with "Hello-world".
[title~="Hello"] is same as [title~=Hello]
[title~="Hello World"] or [title~="Hello "] will not select anything for Styling.

Below works if the attribute has hyphen ( - ) separated values:

[title|=Hello] {color:green;}

It'll work for "Hello", "Hello-World" but will not work with "Hello World", "World Hello" or "Hello!".
Mostly used for specifying languages.

Below works if the attribute contains word "Hello" anywhere in value:

[title*=Hello] {color:green;}

Below works if the attribute begins with " http" anywhere in value:

a[href^="http"] {color:green;}

Below works if the attribute ends with " .jpg" anywhere in value:

a[href$=".jpg"] {color:green;}

The CSS Box Model

Every element in web design is a rectangular box.

Calculate Dimensions as follows:

Some Key Style Properties:

text-decoration

Set or remove decorations from text, mostly used to remove underlines from link

h1 {text-decoration:overline;}
h2 {text-decoration:line-through;}
h3 {text-decoration:underline;}
h4 {text-decoration:blink;}

text-transform

To specify uppercase and lowercase letters in a text.

p.uppercase {text-transform:uppercase;} 
p.lowercase {text-transform:lowercase;} 
p.capitalize {text-transform:capitalize;}

text-indentation

To specify the indentation of the first line of a text, like we have in paragraphs in book.

list-style-image:url('listImage.gif');
To specify image to be used for lists (instead of default square or circle etc)

list-style-type:none;

Will display list without any circle or square.

display:inline; when used within the list, will display horizontal list.

Display and Visibility
.hide{visibility:hidden;}
.hide{display:none;}
visibility:hidden hides an element, but it will still take up the same space as before.
display:none doesn't take up any space.

:first-child Pseudo-class
Styles a specified element that is the first child of another element.
p:first-child{color:blue;}

Style the first p element
.outerClass > .innerClass:first-child
Styles first .innerClass element in all .outerClass elements.
.outerClass:first-child .innerClass
Styles all .innerClass elements in first .outerClass element.

:first-letter and :first-line Pseudo-element

The :first-letter selector is used to add a style to the first letter of the specified selector.
:first-line Styles the first line of text in a block level element.

p:first-letter, div:first-letter {font-size:medium; color:#ff0000;}

p:first-line, div:first-line {font-size:medium; color: #00ff00;}

p.intro:first-line, div:first-line {font-size:medium; color: #00ff00;}

opacity
Create a transparent images and text with CSS.
img
{
opacity:0.5;
filter:alpha(opacity=50); /* For IE8 and earlier */
}

@media Rule

Media Types allow you to specify how documents will be presented in different media.

@media screen
{
p {color:red;}
}
@media print
{
p {color:green;}
}

Tips:

Adding a border on hover makes images look coming out on mouse hover in Page.

Few New Features in CSS3:

Border-radius
@font-face
Box-shadow
2D Transforms
Multi-Column Layout
Multiple Backgrounds
Opacity

A short guide on HTML

2012-10-16T18:59:00.002+05:30

We all are working on Web Developments, and underneath all webpages is good old HTML. It helps to understand HTML a bit. I realized it more while working on new OAF CLAF. The challenge was to match the new Oracle Apps skin with the corporate website built on .net. Along with HTML, knowledge of UIX, CSS, and JAVASCRIPT is required for CLAF. Hope to cover it all, starting with HTML.

Every web page you create must include the <HTML>, <HEAD>, <TITLE> and <BODY> tags.
<TITLE> is used to identify the page on Bookmarks and Favorites list.
The web addresses contained in a web page are of two types - Absolute (complete address) and relative (address of the resource from current page).
File Extension (.JSP, .jsp) and (.HTM, .htm) could refer to same file on windows server but different on unix server. Its better to be uniform in the use of extension.
HTML to download a file:

     <A HREF="Prince_Kapoor2012.docx"> Click here to download my resume</A>

While testing your application it'll be a nice idea to test your pages in less color and less resolution mode.
There are actually two ways of making text display as bold: <b> and <Strong> and Italics: <I>, <EM>. Purists prefer to use <Strong> and <EM> because they imply that the text should receive special emphasis, rather than dictating exactly how that effect should be achieved. <B> and <I> remain the more popular of the two options.
Every form must begin with a form tag, which can be located anywhere in the body of the HTML document. The <Form> tag normally has two attributes, METHOD and ACTION:

<form action="mailto:princekapoor82@gmail.com" method="post">

indicates comments.
The format of color code is #RRGGBB, where rr, gg and bb are two digit hexadecimal values for the red, green and blue.
Please be aware that different computer monitors may display colors in very different hues. A shade of blue on one monitor may look purple in another. Sticking to named colors is preferred choice.
Spacer component of OAF and empty space in others is created as a small transparent images used in Img tag with width and height attributes. (/OA_HTML/cabo/images/t.gif)
An HTML table is an orderly arrangement of text and/or graphics into vertical columns and rows.

OAF Table, AdvanceTable and TableLayout both are rendered as HTML table.
Even the MessageTextInput is rendered as an HTML table with prompts as separate column (right aligned) and values as separate (left aligned).
Closing </TD> is optional, since one cell of the table must end before the next one begins.
Tags used in one cell are not carried over to other cells and tags from outside the table don't apply within the table.

A Search Engine is an automated computer program that looks in a database index for pages that contain specific words and phrases.
A Robot (also called a Spider) is an automated computer program that spends all day looking at the web pages all over the internet and building a database of the contents of all the pages it visits. They work for building the database of the Search Engine.
The <meta> tag provides metadata about the HTML document. Metadata will not be displayed on the page, but will be machine parsable.

Meta elements are typically used to specify page description, keywords, author of the document, last modified, and other metadata.
The metadata can be used by browsers (how to display content or reload page), search engines (keywords), or other web services.
It is put in <Head> portion of a document.

<META NAME ="description" CONTENT="Prince Kapoor OAF Blog.">

<META NAME="keywords" CONTENT="OAF, ADF, Oracle Apps Framework, Oracle Apps Technical, Oracle Application Framework">

The first tag gives search engine accurate information about your web page and second slightly increases page's ranking on the result based of the keywords.

NAME - Specifies a name for the metadata. Values for this attribute are application-name, author, description, generator, keywords.

Following is usually the first line in the <Head> section:

HTML 4.01: <meta http-equiv="content-type" content="text/html; charset=UTF-8">
HTML5: <meta charset="UTF-8">

http-equiv - Provides an HTTP header for the information/value of the content attribute. Values for this attribute are content-type, default-style, refresh.

content - Gives the value associated with the http-equiv or name attribute.

charset - Specifies the character encoding for the HTML document.

Following will refresh the document every 30 secs

Frames

Way of arranging and presenting several web pages at once.
Rectangular region within the browser window that displays a page, alongside other pages in other frames.

Frameset

Frameset document is an HTML page that instructs the Web Browser to split its window into multiple frames and specifies which web page should be displayed in each frame.

IFrame

The Iframe (Inline Frame - Inline with the data on text/graphics on the page) is set up as a rigid size window frame that scrolls along with the rest of the page and it can exist without having a frameset defined.
Designed to insert interactive applications in Web pages.
Frameset is not required for IFrame.
One can alter an IFrame’s sections without requiring the user to reload the surrounding page.
PPRs in OAF are implemented using IFRAMEs

In the HTML source of any OAF page, you'll see <div> and <span> used very frequently with the CSS. The difference between them is - div is a block element and comes with line breaks, span is inline.
DHTML is Dynamic HTML.

DHTML is a way for you to change the way your pages look. You can instantly change the color of a page with the click of the mouse or without the click of a mouse. You can cause things to happen just by moving the mouse around the page.
Combination of HTML and Client side scripting like Java Script.

Title attribute is used for showing tip text/extra information. Following are some example:

 <a href="http://princekapoor82.blogspot.com" title="OAF Blog">Prince Kapoor Blog</a>

<abbr title="Oracle Applications Self Service Framework">OAF</abbr>

<p title="Oracle Applications Self Service Framework Training">OAF Training</p>

<IMG> tag should contain alt, width and height attribute. Text in alt will be displayed if image can't be displayed. width and height attribute make the page render faster on the browser.
<!DOCTYPE>

The <!DOCTYPE> declaration must be the very first thing in your HTML document, before the <html> tag.
The <!DOCTYPE> declaration is not an HTML tag; it is an instruction to the web browser about what version of HTML the page is written in.
Following are the examples:
For HTML 5:-
<!DOCTYPE html>

For HTML 4.1 Strict:-
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">

HTML 4.01 Transitional:-
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

DOCTYPE indicates we are specifying the document type.
HTML means HTML is the root(first) element in your page.
PUBLIC means standard is publicly available.
"-//W3C//DTD HTML 4.01 Transitional//EN" indicates the exact version of that HTML.
"http://www.w3.org/TR/html4/loose.dtd" indicates the file that identifies the particular standard.

http://princekapoor82.blogspot.com or http://princekapoor82.blogspot.com/ will cause the server to look for a default file. The URL will change to http://princekapoor82.blogspot.com/index.html or http://princekapoor82.blogspot.com/default.htm depending on the web server.

Show OA References

2012-08-01T21:24:00.001+05:30

OAF Tip:

Right click on any page layout region in structure window, and click on "Show OA References".
Details of all OA Components being used in the page will be shown including the VO attributes, and Attribute sets.

Oracle Locking

2012-07-28T15:18:00.003+05:30

Lock

Multiuser databases use some form of data locking to solve the problems associated with data concurrency, consistency, and integrity.
Prevent destructive interaction between transactions accessing the same resource, Data corruption, Inconsistent Read etc.
All locks acquired by statements are held for the duration of the transaction.
Only transactions not waiting for the previously locked resources can acquire locks on now available resources.

Oracle Lock Modes

Exclusive Lock

Prevents the associates resource from being shared.
This lock mode is obtained to modify data.
The first transaction to lock a resource exclusively is the only transaction that can alter the resource until the exclusive lock is released.
Other Transactions can read the data.

Shared Lock

Allows the associated resource to be shared for read access by multiple transactions.
Multiple transactions can acquire share locks on the same resource.
Shared Lock prevents write access by a transaction(who needs an exclusive lock).

Oracle Lock Types

Locks are used for shared resources. Resources in general are of two types:

User objects, such as tables and rows (structures and data)
System objects not visible to users, such as shared data structures in the memory and data dictionary rows

Following are Oracle Lock Types:

DML locks (data locks) - Applicable on resource type 1 described above
DDL locks (dictionary locks)
Oracle Internal Locks/Latches
Oracle Distributed Locks
Oracle Parallell Cache Management Locks

DML Locks (Data Locks)

DML locks protect data. For example, table locks lock entire tables, row locks lock selected rows.
DML operations can acquire data locks at two different levels: for specific rows and for entire tables.

Row Level Locks

All DML locks Oracle acquires automatically are row-level locks.
Both read committed and serializable transactions use row-level locking, and both will wait if they try to change a row updated by an uncommitted concurrent transaction.
There is no limit to the number of row locks held by a transaction.
Readers of data do not wait for writers of the same data rows.
Row locking provides the lowest level of locking possible provides the best possible transaction concurrency.
A modified row is always locked exclusively so that other users cannot modify the row until the transaction holding the lock is committed or rolled back.
If a transaction obtains a row lock for a row, the transaction also acquires a table lock for the corresponding table. The table lock prevents conflicting DDL operations that would override data changes in a current transaction.
A transaction gets an exclusive DML lock for each row modified by any of the following statements: INSERT, UPDATE, DELETE, and SELECT with the FOR UPDATE clause.

Table Level Locks

A transaction acquires a table lock for DML statements such as INSERT/UPDATE/DELETE, SELECT with the FOR UPDATE, and LOCK TABLE. Reasons are to reserve DML access to the table on behalf of a transaction and prevent DDL operations.
Table locks prevent the an exclusive DDL lock on the same table which prevents DDL operations. Example, a table cannot be altered or dropped if any uncommitted transaction holds a table lock for it.

* Remember: INSERT, UPDATE, DELETE first scan and query the rows that they affect.

DEADLOCKS

Oracle automatically detects deadlock situations and resolves them by rolling back one of the statements involved in the deadlock. This releases one set of the conflicting row locks. A corresponding message also is returned to the transaction that undergoes the rollback.
Deadlocks often occur when transactions override Oracle default locking. Oracle itself does no lock escalation and does not use read locks for queries and does not use page-level locking, deadlocks rarely occur in Oracle.
Deadlocks can usually be avoided if transactions accessing the same tables lock those tables in the same order, either through implicit or explicit locks and when a sequence of locks for one transaction are required, you should consider acquiring the most exclusive (least compatible) lock first
Always close explicit cursors when finished to free locks.

Queries to identify the Locks and Kill Sessions

    SELECT l.inst_id,
    SUBSTR(L.ORACLE_USERNAME,1,8) ORA_USER,
    SUBSTR(L.SESSION_ID,1,3) SID,
    S.serial#,
    SUBSTR(O.OWNER||'.'||O.OBJECT_NAME,1,40) OBJECT, P.SPID OS_PID,
    DECODE(L.LOCKED_MODE,   0,'NONE',
    1,'NULL',
    2,'ROW SHARE',
    3,'ROW EXCLUSIVE',
    4,'SHARE',
    5,'SHARE ROW EXCLUSIVE',
    6,'EXCLUSIVE',
    NULL) LOCK_MODE
    FROM    sys.GV_$LOCKED_OBJECT L
    , DBA_OBJECTS O
    , sys.GV_$SESSION S
    , sys.GV_$PROCESS P
    WHERE     L.OBJECT_ID = O.OBJECT_ID
      and     l.inst_id = s.inst_id
      AND     L.SESSION_ID = S.SID
      and     s.inst_id = p.inst_id
      AND     S.PADDR = P.ADDR(+)
    order by l.inst_id ;
----------------------------------------------------


    select lobj.* from v$locked_object lobj, all_objects obj where obj.object_id = lobj.object_id and obj.object_name = 'EMPLOYEES'

----------------------------------------------------------------------------------------------------------

select * from v$session where sid = 568
serial num = 1190

alter system
kill session '568,1190'

Database Transaction - Isolation, Consistency, Concurrency, Locks, and more

Reference

http://docs.oracle.com/cd/B12037_01/server.101/b10743/consist.htm

Database Transaction - Isolation, Consistency, Concurrency, Locks, and more

2012-07-27T16:00:00.002+05:30

Database Transaction

Set of one or more statements that are executed as a unit.
Logical, atomic unit of work that contains one or more SQL statements.

When a connection is created, it is in auto-commit mode, individual SQL statements are treated as a transaction.

The default is for a SQL statement to be committed when it is completed, not when it is executed. A statement is completed when all of its result sets and update counts have been retrieved.

Transactions can help to preserve the integrity of the data in a table, providing some level of protection against conflicts that arise when two users access data at the same time.

Acid Properties of Transaction

ATOMICITY

All tasks of a transaction are performed or none of them are.

CONSISTENCY

The transaction takes the database from one consistent state to another consistent state.

ISOLATION

The effect of a transaction is not visible to other transactions until the transaction is committed.

DURABILITY

Changes made by committed transactions are permanent.

Data Consistency and Data Concurrency

Multiple transactions executing at the same time need to produce meaningful and consistent results, that’s why Data Consistency and Data Concurrency are important.

Data concurrency

Many users should be able to access data at the same time.

Data consistency

Each user sees a consistent view of the data, including visible changes made by the user's own transactions and transactions of other users.

The ANSI/ISO standard SQL 92 speaks of three different phenomena when a transaction reads data that another transaction might have changed:

Dirty read
Non-repeatable read
Phantom read

DIRTY READ

Occurs when a transaction is allowed to read data from a row that has been modified by another running transaction and not yet committed.

NON-REPEATABLE READ

Occurs when transaction A retrieves a row, transaction B subsequently updates the row, and transaction A later retrieves the same row again. Transaction A retrieves the same row twice but sees different data.

PHANTOM READ

Occurs when transaction A retrieves a set of rows satisfying a given condition, transaction B subsequently inserts or updates a row such that the row now meets the condition in transaction A, and transaction A later repeats the conditional retrieval. Transaction A now sees an additional row. This row is referred to as a phantom.

Isolation Levels

The ANSI/ISO SQL standard (SQL92) defines four levels of transaction isolation with differing degrees of impact on transaction processing throughput.These isolation levels are defined in terms of three phenomena discussed above.

Read Uncommitted
Read Committed
Repeatable Read
Serializable

Read Uncommitted

Each query can see only data last updated before the query, uncommitted data changes are also visible.

Read Committed

Each query can see only data committed before the query, not the transaction, began.

Repeatable Read

Retains locks on every row it touches until the end of the transaction. Even the rows that are not part of the query results are locked. Phantom Read can come because there is no range lock on table (Only insert with values that satisfy the criteria can introduce Phantom Rows).

Serializable

Serializable is similar to Repeatable Read but it also acquires a key range lock which prevents the insertion of any new rows anywhere within the range.

Please note Seriaizable are not usable in Distributed Transactions.

The default isolation level of different DBMS varies quite widely. Most databases that feature transactions allow the user to set any isolation level. Some DBMS's also require additional syntax when performing a SELECT statement to acquire locks (e.g. SELECT ... FOR UPDATE to acquire exclusive write locks on accessed rows).

According to SQL 92 (but not to Oracle), a transaction is always in exactly one of these isolation levels. Further: the isolation level cannot change within a transaction.

The Oracle database uses the Read Committed and Serializable isolation levels in addition to a read-only mode. By default, Oracle uses the read committed isolation level for database transactions.

Read-Only transaction isolation level - Only data that was committed at the start of the transaction can be accessed by a query. No modification to the data is allowed.

Difference between Read Committed Transactions and Serializable Transactions:

Serializable transactions acquires a range lock so that no new rows can be inserted that satisfy the query criteria of Selected rows.
if the blocking transaction commits and releases its locks, a read committed transaction proceeds with its intended update. A serializable transaction, however, fails with the error "Cannot serialize access", because the other transaction has committed a change that was made since the serializable transaction began.

Setting Oracle Isolation Level

Setting at Transaction Level:

SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
SET TRANSACTION ISOLATION LEVEL READ ONLY;

Setting at Session Level:

ALTER SESSION SET ISOLATION_LEVEL READ COMMITTED;
ALTER SESSION SET ISOLATION_LEVEL SERIALIZABLE;
ALTER SESSION SET ISOLATION_LEVEL READ ONLY;

Next Topic - Oracle Locking

ValidateEntity, NewRowState and Commit

2012-07-18T14:04:00.000+05:30

Below is stated from Developer's Guide:

Entity Object Initial / New State

By default, entity objects are created with the row state of STATUS_NEW, and BC4J adds them to its validation and post listener lists. In this case, any event that triggers a validation or database post sequence includes these entity objects.

As stated in the OA Framework Model Coding Standards, always circumvent this behavior by explicitly calling the setNewRowState(STATUS_INITIALIZED) method on its containing ViewRowImpl immediately after you insert the newly created row. This sets the state of any associated entity objects to STATUS_INITIALIZED.

When you do this, BC4J removes the corresponding entity objects from the transaction and validation listener lists, so they will not be validated or posted to the database. As soon as the user makes a change (an attribute "setter" is called), the entity object's state changes to STATUS_NEW, and BC4J returns it to the validation/post lists. You can also call setNewRowState(STATUS_NEW) on the ViewRowImpl to change the state manually at any time.

Code Behaviour:

Case 1: Row has been modified in the UI before submit. Row State could be anything.

The RowState becomes New.
ValidateEntity will get called before processFormRequest().

Case 2: Called row.setNewRowState(Row.STATUS_NEW) after inserting a new row. Row has not been modified from UI.

ValidateEntity will not get called before processFormRequest() but will get called on commit and postChanges.

Case 3: Called row.setNewRowState(Row.STATUS_INITIALISED) after inserting a new row. Row has not been modified from UI.

ValidateEntity will not get called before processFormRequest() or on commit or postChanges.
The Row will be ignored by the Framework and removed from the Cache.
Even the mandatory fields in the Entity Object are not checked.

Please note setting the row state (row.setNewRowState) should be done after adding the row to VO as recommended in the OAF Standard.

Though if you set the row state before adding it to the VO, it'll also work fine as long as you don't call any setter. The moment any setter is called row state changes to NEW.