JSP Web Hosting - Java Server Pages

// Obtain the home and remove cabin 30. Rerun the same cabin list. ref = jndiContext.lookup(”CabinHome”); CabinHomeRemote c_home = (CabinHomeRemote) PortableRemoteObject.narrow(ref, CabinHomeRemote.class); Integer pk = new Integer(30); c_home.remove(pk); list = agent.listCabins(1,3); System.out.println(”2nd List: After deleting cabin number 30″); for (int i = 0; i < list.length; i++) { System.out.println(list[i]); } First, the application creates a list of cabins, including the cabin with the primary key 30. Then it removes the Cabin EJB with this primary key and creates the list again. The second time the iteration is performed, cabin 30 will not listed. Because it was removed, the listCabin() method was unable to find a cabin with a primary key equal to 30, so it stopped making the list. The bean, including its data, is no longer in the database. Your output should look something like the following: 1st List: Before deleting cabin number 30 1,Master Suite ,1 3,Suite 101 ,1 5,Suite 103 ,1 7,Suite 105 ,1 9,Suite 107 ,1 12,Suite 201 ,2 14,Suite 203 ,2 16,Suite 205 ,2 18,Suite 207 ,2 20,Suite 209 ,2 22,Suite 301 ,3 24,Suite 303 ,3 26,Suite 305 ,3 28,Suite 307 ,3 30,Suite 309 ,3 2nd List: After deleting cabin number 30 1,Master Suite ,1 3,Suite 101 ,1 5,Suite 103 ,1 7,Suite 105 ,1 9,Suite 107 ,1 12,Suite 201 ,2 14,Suite 203 ,2 16,Suite 205 ,2 18,Suite 207 ,2 20,Suite 209 ,2 22,Suite 301 ,3 Copyright (c) 2001 O'Reilly & Associates
Adult web hosting has rich experience in providing unique solutions for the customer’s needs, just check frontpage web hosting services.

Removing beans The EJBHome.remove() methods are responsible for deleting an enterprise bean. The argument is either the javax.ejb.Handle of the enterprise bean or, if it s an entity bean, its primary key. The Handle will be discussed in more detail later, but it is essentially a serializable pointer to a specific enterprise bean. When either of the EJBHome.remove() methods are invoked, the remote reference to the enterprise bean on the client becomes invalid: the stub to the enterprise bean that was removed no longer works. If for some reason the enterprise bean can t be removed, a RemoveException is thrown. The impact of the EJBHome.remove() on the enterprise bean itself depends on the type of bean. For session beans, the EJBHome.remove() methods end the session s service to the client. When EJBHome.remove() is invoked, the remote reference to the session beans becomes invalid, and any conversational state maintained by the session bean is lost. The TravelAgent EJB you created in Chapter 4 is stateless, so no conversational state exists (more about this in Chapter 7). When a remove() method is invoked on an entity bean, the remote reference becomes invalid, and any data that it represents is actually deleted from the database. This is a far more destructive activity because once an entity bean is removed, the data that it represents no longer exists. The difference between using a remove() method on a session bean and using remove() on an entity bean is similar to the difference between hanging up on a telephone conversation and actually killing the caller on the other end. Both end the conversation, but the end results are a little different. The following code fragment is taken from the main() method of a client application that is similar to the clients we created to exercise the Cabin and TravelAgent EJBs. It shows that you can remove enterprise beans using a primary key (entity only) or a handle. Removing an entity bean deletes the entity from the database; removing a session bean results in the remote reference becoming invalid. Context jndiContext = getInitialContext(); // Obtain a list of all the cabins for ship 1 with bed count of 3. Object ref = jndiContext.lookup(”TravelAgentHome”); TravelAgentHomeRemote agentHome = (TravelAgentHomeRemote) PortableRemoteObject.narrow(ref,TravelAgentHomeRemote.class); TravelAgentRemote agent = agentHome.create(); String list [] = agent.listCabins(1,3); System.out.println(”1st List: Before deleting cabin number 30″); for(int i = 0; i < list.length; i++){ System.out.println(list[i]); } Copyright (c) 2001 O'Reilly & Associates
Our stuff is composed of devoted and highly-tainted professionals, creating a mix of powerful and high-quality web hosting perl services, check web hosting perl.

CrewmanRemote crew = ship.getCrewman(”Burns”, “John”, “1st Lieutenant”); OfficerRemote burns = (OfficerRemote) PortableRemoteObject.narrow(crew, OfficerRemote.class); The PortableRemoteObject.narrow() method is not required when the remote type is specified in the method signature. This is true of the create() methods and find methods in remote home interfaces that return a single bean. For example, the create() and findByPrimaryKey() methods defined in the CabinHomeRemote interface (Chapter 4) do not require the use of narrow() method because these methods already return the correct EJB object type. Business methods that return the correct type do not need to use the narrow() method either, as the following code illustrates: /* The CabinHomeRemote.create() method specifies * the Cabin remote interface as the return type * so explicit narrowing is not needed.*/ CabinRemote cabin = cabinHome.create(12345); /* The CabinHomeRemote.findByPrimaryKey() method specifies * the Cabin remote interface as the return type * so explicit narrowing is not needed.*/ CabinRemote cabin = cabinHome.findByPrimaryKey(12345); /* The ShipRemote.getCrewman() business method specifies * the Crewman remote interface as the return type * so explicit narrowing is not needed.*/ CrewmanRemote crew = ship.getCrewman(”Burns”, “John”, “1st Lieutenant”); The Remote Home Interface The remote home interface provides life-cycle operations and metadata for the bean. When you use JNDI to access a bean, you obtain a remote reference, or stub, to the bean s EJB home, which implements the remote home interface. Every bean type may have one home interface, which extends the javax.ejb.EJBHome interface. Here is the EJBHome interface: public interface javax.ejb.EJBHome extends java.rmi.Remote { public abstract EJBMetaData getEJBMetaData() throws RemoteException; public HomeHandle getHomeHandle() // new in 1.1 throws RemoteException; public abstract void remove(Handle handle) throws RemoteException, RemoveException; public abstract void remove(Object primaryKey) throws RemoteException, RemoveException; } Copyright (c) 2001 O’Reilly & Associates
Need a managed web hosting provider to help maintain your website? Our web hosting service is the preferred choice of thousands of demanding customers.

java.lang.Class narrowTo) throws java.lang.ClassCastException; … } The narrow() method only needs to be used when a remote reference to an EJB home or EJB object is returned without a specific Remote interface type. This occurs in six circumstances: When a remote EJB home reference is obtained using the javax.naming.Context.lookup() method: Object ref = jndiContext.lookup(”CabinHome”); CabinHomeRemote home = (CabinHomeRemote) PortableRemoteObject.narrow(ref, CabinHomeRemote.class); When a remote EJB object reference is obtained using the javax.ejb.Handle.getEJBObject() method: Handle handle = …. // get handle Object ref = handle.getEJBObject(); CabinRemote cabin = (CabinRemote) PortableRemoteObject.narrow(ref,CabinRemote.class); When a remote EJB home reference is obtained using the javax.ejb.HomeHandle.getEJBHome() method: HomeHandle homeHdle = … // get home handle EJBHome ref = homeHdle.getEJBHome(); CabinHomeRemote home = (CabinHomeRemote) PortableRemoteObject.narrow(ref, CabinHomeRemote.class); When a remote EJB home reference is obtained using the javax.ejb.EJBMetaData.getEJBHome() method: EJBMetaData metaData = homeHdle.getEJBMetaData(); EJBHome ref = metaData.getEJBHome(); CabinHomeRemote home = (CabinHomeRemote) PortableRemoteObject.narrow(ref, CabinHomeRemote.class); When a remote EJB object reference is obtained from a collection returned by a remote home interface finder method: ShipHomeRemote shipHome = … // get ship home Enumeration enum = shipHome.findByCapacity(2000); while(enum.hasMoreElements()){ Object ref = enum.nextElement(); ShipRemote ship = (ShipRemote) PortableRemoteObject.narrow(ref, ShipRemote.class); // do something with Ship reference } When a wide remote EJB object type is returned from any business method. Here is a hypothetical example: // Officer extends Crewman ShipRemote ship = // get Ship remote reference Copyright (c) 2001 O’Reilly & Associates
Sbc yahoo internet provider is a name that we will not do any shame to. We are as good in what we do. Our sbc yahoo web hosting team will work hard to meet and satisfy all your web hosting needs.Try us out!

The javax.naming.Context.lookup() method returns an Object. In EJB 2.0 s Local Client API, we can assume that it is legal to cast the return argument. However, the Remote Client API must be compatible with Java RMIIIOP, which means that clients must adhere to limitations imposed by the IIOP 1.2 protocol. To accommodate all languages, many of which have no concept of casting, IIOP 1.2 does not support stubs that implement multiple interfaces. The stub returned in IIOP implements only the interface specified by the return type of the remote method that was invoked. If the return type is Object, as is the remote reference returned by the lookup() method, the stub will only implement methods specific to the Object type. Of course, some means for converting a remote reference from a more general type to a more specific type is essential in an object-oriented environment, so Java RMI-IIOP provides a mechanism for explicitly narrowing references to a specific type. The javax.rmi.PortableRemoteObject.narrow() method abstracts this narrowing to provide narrowing in IIOP as well as other protocols. Remember while the Remote Client API requires that you use Java RMI-IIOP reference and argument types, the wire protocol need not be IIOP 1.2. Other protocols besides IIOP may also require explicit narrowing. The PortableRemoteObject abstracts the narrowing process so that any protocol can be used. To narrow the return argument of the Context.lookup() method to the appropriate type, we must explicitly ask for a remote reference that implements the interface we want: import javax.rmi.PortableRemoteObject; … javax.naming.Context jndiContext; … Object ref = jndiContext.lookup(”CabinHome”); CabinHomeRemote home = (CabinHomeRemote) PortableRemoteObject.narrow(ref, CabinHomeRemote.class); When the narrow() method has successfully executed, it returns a stub that implements the Remote interface specified. Because the stub is known to implement the correct type, you can then use Java s native casting to narrow the stub to the correct Remote interface. The narrow() method takes two arguments: the remote reference that is to be narrowed and the type it should be narrowed to. The definition of the narrow() method is:2 package javax.rmi; public class PortableRemoteObject extends java.lang.Object { public static java.lang.Object narrow(java.lang.Object narrowFrom, Other methods included in the PortableRemoteObject class are not important to EJB application developers. They are intended for Java RMI developers. Copyright (c) 2001 O’Reilly & Associates
We specialize in RedHat Linux Apache web server technology for site owners and site developers and all our hosting packages come with a wide range of features as standard including automatic backups, visitor statistics, spam filtering, email anti virus and much more. Web Hosting Apache.Try us out!

public int getCustomerID() throws RemoteException; public Ticket bookPassage(CreditCardRemote card, double price) throws RemoteException,IncompleteConversationalState; public String [] listAvailableCabins(int bedCount) throws RemoteException, IncompleteConversationalState; } Java RMI-IIOP type restrictions In addition to the Java RMI programming model discussed earlier, Java RMI-IIOP imposes additional restrictions on the remote interfaces and value types used in the Remote Client API. These restrictions are born of limitations inherit in the Interface Definition Language (IDL) upon which CORBA IIOP 1.2 is based. The exact nature of these limitations is outside the scope of this book. Here are two of the restrictions; the others, like IDL name collisions, are so rarely encountered that it wouldn t be constructive to mention them.1 Method overloading is restricted; a remote interface may not directly extend two or more interfaces that have methods with the same name (even if their arguments are different). A remote interface may, however, overload its own methods and extend a remote interface with overloaded method names. Overloading is viewed, here, as including overriding. Figure 5-3 illustrates both of these situations. [FIGURE] Figure 5-3: Overloading rules for Remote interface inheritance in Java RMI-IIOP Serializable types must not directly or indirectly implement the java.rmi.Remote interface. Explicit narrowing using PortableRemoteObject In Java RMI-IIOP remote references must be explicitly narrowed using the javax.rmi.PortableRemoteObject.narrow() method. The typical practice in Java would be to cast the reference to the more specific type, as follows: javax.naming.Context jndiContext; … CabinHomeRemote home = (CabinHomeRemote)jndiContext.lookup(”CabinHome”); To learn more about CORBA IDL and its mapping to the Java language consult The Common Object Request Broker: Architecture and Specification and The Java Language to IDL Mapping available at the OMG site (www.omg.org). Copyright (c) 2001 O’Reilly & Associates 7
We are dedicated to offering you a reliable, fast, and scalable unlimited web hosting home for your business, and personal web sites.Go and see our shared web hosting services.

TravelAgent EJB, the create() method takes a reference to a Customer EJB as its only argument. public interface TravelAgentHomeRemote extends javax.ejb.EJBHome { public TravelAgentRemote create(CustomerRemote customer) throws RemoteException, CreateException; } The customer argument is a remote reference to a Customer EJB that is passed into the create() method. When a remote reference is passed or returned in Enterprise JavaBeans, the EJB object stub is passed by copy. The copy of the EJB object stub points to the same EJB object as the original stub. This results in both the enterprise bean instance and the client having remote references to the same EJB object. So changes made on the client using the remote reference will be reflected when the enterprise bean instance uses the same remote reference. Figure 5-1 and Figure 5-3 show the difference between a serializable object and a remote reference argument in Java RMI. [FIGURE] Figure 5-1: Serializable arguments in Java RMI [FIGURE] Figure 5-2: Remote reference arguments in Java RMI Exceptions The Java RMI specification states that every method defined in a Remote interface must throw a java.rmi.RemoteException. The RemoteException is used when problems occur with the distributed object communications, like a network failure or inability to locate the object server. In addition, Remote interface types can throw any application-specific exceptions (exceptions defined by the application developer) that are necessary. The following code shows the remote interface to the TravelAgent EJB discussed in Chapter 2. This remote interface is similar to the one defined in Chapter 4. TravelAgentRemote has several remote methods, including bookPassage(). The bookPassage() method can throw a RemoteException (as required), in addition to an application exception, IncompleteConversationalState. public interface TravelAgentRemote extends javax.ejb.EJBObject { public void setCruiseID(int cruise) throws RemoteException, FinderException; public int getCruiseID() throws RemoteException; public void setCabinID(int cabin) throws RemoteException, FinderException; public int getCabinID() throws RemoteException; Copyright (c) 2001 O’Reilly & Associates
With our Unix hosting accounts you have total control of your Web site content from anywhere in the world.For more information please follow link Unix Web Hosting.

Java RMI Return Types, Parameters, and Exceptions The supertypes of the remote home interface and remote interface, javax.ejb.EJBHome and javax.ejb.EJBObject, both extend java.rmi.Remote. As Remote interface subtypes, they are expected to adhere to the Java RMI specification for Remote interfaces. Parameters and return types As subtypes of the java.rmi.Remote interface, the remote component interfaces must follow several guidelines, some of which apply to the return types and parameters that are allowed. To be compatible with Java RMI, the actual return types and parameter types used in the java.rmi.Remote interfaces must be primitives, String types, java.rmi.Remote types, or serializable types. There is a difference between declared types, which are checked by the compiler, and actual types, which are checked by the runtime. The types that may be used in Java RMI are actual types, which are either primitive types, object types implementing (even indirectly) java.rmi.Remote, or object types implementing (even indirectly) java.io.Serializable. The java.util.Collection type, for example, which does not explicitly extends java.io.Serializable, is a perfectly valid return type for a remote finder methods, provided that the concrete class implementing Collection does implement java.io.Serializable. So Java RMI has no special rules regarding declared return types or parameter types. At runtime, a type that is not a java.rmi.Remotetype is assumed to be serializable; if it is not, an exception is thrown. The actual type passed cannot be checked by the compiler, it must be checked at the runtime. Here is a list of the types that can be passed as parameters or returned in Java RMI: Primitives: byte, boolean, char, short, int, long, double, float. Java serializable types: any class that implements or any interface that extends java.io.Serializable. Java RMI remote types: any class that implements or any interface that extends java.rmi.Remote. Serializable objects are passed by copy (a.k.a. passed by value), not by reference, which means that changes in a serialized object on one tier are not automatically reflected on the others. Objects that implement Remote, like CustomerRemote or CabinRemote, are passed as remote references which is a little different. A remote reference is a Remote interface implemented by a distributed object stub. When a remote reference is passed as a parameter or returned from a method, it is the stub that is serialized and passed by value, not the object server remotely referenced by the stub. In the home interface for the Copyright (c) 2001 O’Reilly & Associates
You need web hosting, easy to use web template and great support. What else could I ask for?All of our reseller accounts include free web hosting templates just check web hosting templates for more information.

the methods of their supertypes provide the mechanisms that clients use to interact with an EJB business system. In EJB 1.1, all clients, whether they are in the same container system or not, must use the Remote Client API, which means they must use the remote interface and remote home interface and Java RMI is all their interactions. In EJB 2.0, remote clients must continue to use the Remote Client API, but enterprise beans that are located in the same EJB container system have the option of using the Local Client API. The Local Client API provides local component interfaces and avoids the restrictions and overhead of the remote client API. This section examines in more detail the remote component interfaces and the primary key, as well as other types that make up EJB s remote client-side API. This will provide you with a better understanding of how the remote client-side API is used and its relationship with the bean class on the EJB server. In the next major section, The Local Client API, the use of local component interfaces will be examined. Java RMI-IIOP Enterprise JavaBeans 2.0 and 1.1 define an EJB s remote interfaces in terms of Java RMI-IIOP, which enforces compliance with CORBA. In other words, the underlying protocol used by remote clients to access enterprise beans can be anything that the vendor wants as long as it supports the types of interfaces and arguments that are compatible with Java RMI-IIOP. EJB 1.1 only required that the wire protocol used by vendors utilize types that would be compatible with Java RMI-IIOP. In other words, the interface types and values used in remote references had to be compliant with the types allowed for Java RMI-IIOP. This ensured that early Java RMI-IIOP adopters were supported and makes for a seamless transition for other vendors who wanted to use real Java RMI-IIOP in EJB 2.0. In EJB 2.0, vendor can still offer other Java RMI-IIOP-compatible protocols, but in addition to any propritary protocols they support, they must also support the CORBA IIOP 1.2 protocol as defined in the CORBA 2.3.1. To be compliant with Java RMI-IIOP types, the EJB vendors have to restrict the definition of interfaces and arguments to types that map nicely to IIOP 1.2. These restrictions are really not all that bad, and you probably won t even notice them while developing your beans, but it s important to know what they are. The next few paragraphs discuss the Java RMI-IIOP programming model for both EJB 2.0 and EJB 1.1. EJB 2.0 s local component interfaces are not Java RMI interfaces and do not have to support IIOP 1.2 or use types compliant with the Java RMI-IIOP protocol. Local component interfaces are discused after remote component interfaces. Copyright (c) 2001 O’Reilly & Associates
File Transfer Protocol comes together with anonymous ftp access with every FTP Web Hosting account we offer today. Enjoy burs table ftp transfers together with fast FTP connection.

used the method getInitialContext() to get a JNDI InitialContext object, which looked as follows: public static Context getInitialContext() throws javax.naming.NamingException { Properties p = new Properties(); // … Specify the JNDI properties specific to the vendor. return new javax.naming.InitialContext(p); } An initial context is the starting point for any JNDI lookup it s similar in concept to the root of a filesystem. The way you create an initial context is peculiar, but not fundamentally difficult. You start with a properties table of type Properties. This is essentially a hash table to which you add various values that determine the kind of initial context you get. Of course, as mentioned in Chapter 4, this code will change depending on how your EJB vendor has implemented JNDI. For WebSphere, getInitialContext() might look something like this: public static Context getInitialContext() throws javax.naming.NamingException { java.util.Properties properties = new java.util.Properties(); properties.put(javax.naming.Context.PROVIDER_URL, “iiop:///”); properties.put(javax.naming.Context.INITIAL_CONTEXT_FACTORY, “com.ibm.ejs.ns.jndi.CNInitialContextFactory”); return new InitialContext(properties); } For BEA s WebLogic Server, this method would be coded as: public static Context getInitialContext() throws Exception { Properties p = new Properties(); p.put(Context.INITIAL_CONTEXT_FACTORY, “weblogic.jndi.T3InitialContextFactory”); p.put(Context.PROVIDER_URL, “t3://localhost:7001″); return new InitialContext(p); } For a more detailed explanation of JNDI, see O Reilly s Java Enterprise in a Nutshell, by David Flanagan, Jim Farley, William Crawford, and Kris Magnusson. The Remote Client API Enterprise bean developers are required to provide a bean class, component interfaces, and for entity beans, a primary key. Of these types, the only the component interfaces and primary key class are visible to the client, while the bean class is not. The component interfaces and primary key contribute to the client-side API in EJB. The methods defined in component interfaces as well as Copyright (c) 2001 O’Reilly & Associates 3
We offer quality web hosting with only $3.99 per month with unlimited email addresses, unlimited bandwidth, and unlimited server space. Check our web hosting unlimited bandwidth section.