For 4.2.2 and beyond

Replace the following from the web.xml found under jboss-4.2.2.GA\server\<config-name>\deploy\jboss-web.deployer\conf.

   <init-param> 
     <description>JSF standard tlds</description> 
     <param-name>tagLibJar0</param-name> 
     <param-value>jsf-libs/jsf-impl.jar</param-value> 
   </init-param> 
   <init-param> 
     <description>JSTL standard tlds</description> 
     <param-name>tagLibJar1</param-name> 
     <param-value>jstl.jar</param-value> 
   </init-param>

with

   <init-param> 
     <description>MyFaces tlds</description> 
     <param-name>tagLibJar0</param-name> 
     <param-value>myfaces-libs/myfaces-impl.jar</param-value> 
   </init-param>

Install Apache MyFaces JSF implementation

   commons-beanutils.jar
   commons-digester-1.6.jar
   commons-el.jar
   commons-lang-2.1.jar
   myfaces-api.jar
   myfaces-impl.jar

Modify the web.xml found under jboss-4.2.0.GA\server\<config-name>\deploy\jboss-web.deployer\conf to add the listener as follows:

  <listener>
    <listener-class>org.apache.myfaces.webapp.StartupServletContextListener</listener-class>
  </listener>

INCOME TAX RATES APPLICABLE FOR FINANCIAL YEAR 2007-2008

# Slab for Women (below 65) begins from 1,45,001

* Slab for Senior Citizen begins from 1,95,001

Transactional Capabilities
in Oracle9iAS Containers for J2EE (OC4J)



Date: 22-Jul-2002




Introduction







A key service required for robust server side development
is transactions. A Transaction can be defined as a series of operations that

appear to execute as one large, atomic operation. Transactions guarantee an
all-or-nothing value proposition. Transactions allows multiple users to share
the same data and guarantee that any set of updated data will be completely
updated, with no interleaving of updates from other clients. This document contains
the following topics:




• Different types of  Transaction
  
• Transaction Attributes
• Transaction Isolation
• Concurrency Control



Different Types of Transaction





1. Declarative Transactions: Container-Managed Transactions





XML deployment descriptors are used to specify transaction
boundaries for components, in case of declarative transactions. At runtime,

the container initiates a transaction and commits it. This helps the user in
avoiding the transaction related code and helps in focussing on the core business
logic of the application. In this approach, the EJB code is completely isolated
from the transaction APIs. For sample deployment descriptor code snippet click
here.





2. Programmatic Transactions: Bean-Managed Transactions




In this approach, the transactions have to be controlled by

the bean developer explicitly. The benefit of this approach is that the bean
developer has full control over the transactional boundaries. The developer
has to start a transaction by issuing begin and complete the transaction by
issuing a end or abort statement. For sample code  snippet click here.

Unrepeatable read problem occurs when a component finds that
the data it read previously has been modified by some other component. Phantom
problems are related to appearance of a new set of data in a database between
2 database operations

These different isolation levels are set in the XML deployment
descriptor e orion-ejb-jar.xml, which has to be packaged with deployment jar
file. The tag <entity-deployment> should be present for every entity bean.
The isolation attribute value can be set using the isolation attribute.  
DTD for this file can be found at orion-ejb-jar.dtd. 
For Sample orion-ejb-jar.xml file please click here.

Concurrency Control

There are 2 ways by which concurrency control can be implemented.
They are pessimistic & optimistic. In optimistic concurrency control, 
lock is acquired only at the time of committing the transaction, whereas in
pessimistic concurrency control, lock is acquired for the entire duration of
the transaction. Concurrency control can be specified in <entity-deployment>

tag of orion-ejb-jar.xml.

Answer





The Enterprise JavaBeans model supports six different transaction rules:

• TX_BEAN_MANAGED. The TX_BEAN_MANAGED setting indicates that the enterprise bean manually manages its own transaction control. EJB supports
  manual transaction demarcation using the Java Transaction API. This is very tricky and should not be attempted without a really good reason.
  
  
  
• 
  TX_NOT_SUPPORTED. The TX_NOT_SUPPORTED setting indicates that the enterprise bean cannot execute within the context of a transaction. If a client
  (i.e., whatever called the method-either a remote client or another enterprise bean) has a transaction when it calls the enterprise bean, the container suspends the transaction for the duration of the method call.
  
  
  
• 
  TX_SUPPORTS. The TX_SUPPORTS setting indicates that the enterprise bean can run with or without a transaction context. If a client has a transaction when it calls the enterprise bean, the method will join the client's transaction
  context. If the client does not have a transaction, the method will run without a
  transaction.
  
  
  
• 
  TX_REQUIRED. The TX_REQUIRED setting indicates that the enterprise
  bean must execute within the context of a transaction. If a client has a transaction
  when it calls the enterprise bean, the method will join the client's transaction
  context. If the client does not have a transaction, the container automatically
  starts a new transaction for the method.
  Attributes
  
  
  
• 
  TX_REQUIRES_NEW. The TX_REQUIRES_NEW setting indicates that the
  enterprise bean must execute within the context of a new transaction. The
  container always starts a new transaction for the method. If the client has a
  transaction when it calls the enterprise bean, the container suspends the client's
  transaction for the duration of the method call.
  
  
  
• 
  TX_MANDATORY. The TX_MANDATORY setting indicates that the
  enterprise bean must always execute within the context of the client's transaction.
  If the client does not have a transaction when it calls the enterprise bean, the
  container throws the TransactionRequired exception and the request fails.
  
  
  

How
do I prevent the output of my JSP or Servlet
pages from being cached by the browser?

<%

response.setHeader("Cache-Control","no-store");
//HTTP 1.1

response.setHeader("Pragma\","no-cache");
//HTTP 1.0

response.setDateHeader
("Expires", 0); //prevents caching
at the proxy server

%>

A Minimalist's Perspective on ESBs










Blogger: Anne Thomas Manes











Steve Jones has just posted a blog and a specification of what he calls a Business Service Bus (BSB), which he defines as "a simple mechanism for exchanging information between business domains". Steve is proposing that a BSB should be very simple -- doing only what is absolutely essential to enable information exchange--and explicitly disallowing more complex transformation capabilities typically associated with an Enterprise Service Bus (ESB).





To get a better sense of Steve's proposal, you should also read his previous post on the subject, in which he separates out ESB capabilities into two tiers:





• Business Service Bus (BSB)
• Domain Service Bus (DSB)





The DSB supports information exchange within a particular business domain, and typically supports more integration features than the BSB.

Static has been discussed many times on this forum.

• Static code is loaded before the clas is instantiated and stays in memory until the JVM exits (as opposed to instance members which are loaded and unloaded: "dynamic" code),
• each class has one copy of each of its static members in memory,
• Each instance of the class has access to that single static memory location,
• the single member is the same for every instance,
• but a static member does not have access to instance members (it has no way of knowing where they are located), nor the keyword this and super.

Volatile means that the value of a variable is liable to change suddenly, and it instructs methods using a volatile member to update it immediately before use. I have never actually seen it used.

When you create an instance of the java.net.URL class,
>

its constructor can throw a MalformedURLException. This occurs when the URL is invalid. When it is thrown, it isn't because the host machine is down, or the URL path points to a missing file; a malformed URL exception is thrown when the URL cannot be correctly parsed.
>

Common mistakes include :-
>



1. leaving out a protocol
>


(eg "www.microsoft.com"
>

instead of "http://www.microsoft.com/")
>


2. specifying an invalid protocol
>

(eg "www://netscape.com")
>


3.leaving out the ':' character
>


(eg http//www.micrsoft.com/)
>






MalformedURLException will not be thrown if :-
>


1. the host name is invalid
>


eg "www.microsoft-rules-the-world.com")
>



2. the path is invalid
>

(eg "http://www.microsoft.com/company_secrets.htm")
>

The <driver-class/> and
<connection-url/> settings for Oracle are
as follows:





Oracle OCI Type 2 Driver




• Class: oracle.jdbc.driver.OracleDriver
• URL: jdbc:oracle:oci8:@<database>
• Class: oracle.jdbc.driver.OracleDriver
• URL: jdbc:oracle:thin:@<host>:<port>:<database>
• Class: oracle.jdbc.xa.client.OracleXADataSource
• URL: jdbc:oracle:thin:@<host>:<port>:<database>
• Class: oracle.jdbc.driver.OracleDriver
• URL: jdbc:oracle:oci8:@<database>