ing people about server-side Java development, there's no way I can read everything published on Server-Based Java Programming and its fresh approach. Whether you're using J2EE or writing your own, you will need to understand the fundamental concepts of server-based Java. Server-Based Java Programming. Guy-Vincent Jourdan:: CSI based on Jeffrey C. Jackson's slides. 3. Server-side Programming. ◇Similarly, web server response can be static or dynamic.

Server-based Java Programming Pdf

Language:English, Dutch, Portuguese
Published (Last):26.03.2016
ePub File Size:25.80 MB
PDF File Size:12.16 MB
Distribution:Free* [*Registration Required]
Uploaded by: MAURICIO

q Server-side Programming Basics q Brief intro to . q In Java, use the URL class ; get the result by . URL url = new URL("http://localhost/" + file + ".pdf");. Database Programming with JDBC™ and Java™. Java™ Distributed In late , Java on the server side was coming on strong. Several major software. Secondly, based on these programming models, this article introduces the reader to the Java 2, Enterprise Edition (J2EE). If you are a beginner to server-side.

Green threads. Threading issues 6. Synchronization 6. Thread-local storage. Exception-handling with multiple threads. Thread idioms and patterns 6. GJAS 6. Adding thread support to GJAS. Control 7. GJAS 7. Local implementation. Testing the LocalServer implementation.

Navigation menu

HelloAgainService 7. Remote control 8. RMI implementation 8. Configuration 9. Java models 9. ConfigProperty and ConfigProperties. Sockets Simple socket services Encapsulation and refactoring Connection and ConnectionManager Advanced Socket services Servlets Relationship to sockets A filtering servlet. Server-side scripting capabilities. Not just about HTML anymore. Servlets and the n-tier application Separating logic from content.

Persistence Java Serialization Serialization to other places. Beyond the specification Remote storage of objects. Remote construction of objects. JDBC Business objects Modeling data Two-tier Systems vs.

Business objects, entity relationships. Business objects layer interface layer. Using the Business Object layer Classic Presentation Code: Business object models HashtableModel Creating objects.

Finding objects. Removing objects. Middleware Why distribute? Business objects, entity relationships. Business objects layer interface layer. Using the Business Object layer Classic Presentation Code: Business object models HashtableModel Creating objects. Finding objects. Removing objects. Middleware Why distribute? Distributed object design vs. Stateful vs. Technologies Raw access: Java RPC: Object Request Brokers: Distributed Component Object Model. Message-Oriented Middleware: Objects across the wire: Mobile objects.

Employee middleware models RMI implementation. Shared-object implementation. Java Native Interface Native code on the server. JNI essentials Java calling native. Other methods of Java-to-native interaction Integrating the server: GJAS goes native Named pipe. Other JNI uses Debugging support. Monitoring Importance grows Epilogue Where to go from here. About the book Server-Based Java Programming isn't just about implementation—it's also about architecture, and design.

What's inside What's Inside: Servlets Sockets Serialization Mobile objects Extensions Threads Distributing objects over a network Making servers robust and scalable Clustering, fault tolerance, and failover ClassLoaders System monitoring.

Server-Based Java Programming combo added to cart. Your book will ship via to:. Commercial Address. Server-Based Java Programming eBook added to cart. Don't refresh or navigate away from the page.

Java Reflection in Action. Ira R. Forman and Nate Forman. Benjamin J. Evans and Martijn Verburg Foreword by Dr. Heinz Kabutz. The purpose of J2EE is to simplify development and management of distributed component-based Web- centric applications. While J2EE is targeted at large-scale enterprise applications, the J2ME is targeted at consumer electronics and embedded devices. In this article, my focus is limited to server-side programming with J2EE.

As you will see, the J2EE is driving a major section of the Java programming community because the technology addresses most of the infrastructure issues that server-side systems face.

Principles and 9 Technologies What is server-side programming? The terms server and server-side programming are very commonly used. But what is a server? Generally speaking, a server is an application hosted on a machine that provides some services to the other applications clients requesting the services. As is obvious from the definition, a server typically caters to several clients, often concurrently.

The services offered by a server application can be very diverse— ranging from data, and other information, management to the execution of specialized business logic. Although several types of server applications are possible, you can quickly recognize the following two kinds of servers: Servers that manage data, which come from vendors, such as Oracle, Sybase, and Microsoft.

In addition to these standard APIs, you may use vendor-specific client access APIs to communicate with the database server. These servers are responsible for consistently managing data such that multiple clients can manipulate the data without loss of consistency. Web Servers: The other easily recognizable types of servers are Web servers. In its basic mode, a Web server maps a client request to a file in the file system, and then sends the content of the file to the client making the request.

Similar to database servers, Web servers can deal with concurrent requests—often several thousands. Because we are accustomed to working with these types of servers, we often tend to overlook the fact that they are server-side applications, albeit standardized. However, when I use the term server-side programming, I do not mean developing such databases or Web servers. Such applications were commodified years ago. These general-purpose server-side applications provide standard, predefined functionality.

In the case of server-side programming, we are more interested in developing special- purpose applications to implement specific business-use cases. Principles and 10 Technologies Why is it important or relevant to consider server-side applications? Why is it necessary to build applications that can provide services to several client applications? Following are some common scenarios that illustrate the need for server-side applications: Execute some logic available with a different application.

This is one of the reasons that prompted development of early distributed technologies, such as the RPC. Suppose that there is some business logic already implemented in a different application. But, what if such logic and code depends heavily on some data being managed by the existing application? Alternatively, what if such code is dependent on several other parts of the existing application, making it difficult to reuse the code in the new application?

One possible solution to deal with this is by executing this logic in the existing application; that is, instead of reusing the code from the existing application, the new application can send a request with any required data to the existing application to execute this logic and obtain any results. Execute logic available with a different application. Figure 1 shows a sample scenario. In this example, we are dealing with two different applications executing as two separate processes, but we can extend this case further and execute these applications on two different machines.

In the above example, the new application acts as a client for the existing application server that provides the required service, that is, executing some business logic. Principles and 11 Technologies 2.

This is yet another scenario that mandates server-side applications and clients. Database servers and other applications maintain information in a persistent storage fall under this category; however, database servers, such as relational database management systems, typically manage raw data rows of data in various tables. Such data may or may not be directly usable in the business sense by other applications that rely on the data.

For instance, consider a database holding various accounts of all customers in a bank. A common requirement in such systems is to consolidate all the accounts of a given customer and present a summarized view of all accounts. Now consider several applications within the bank performing other banking tasks some of which require a summarized view of all accounts of a customer.

For instance, an application responsible for calculating monthly account charges may require the value of the consolidated account balance. When there are several such applications that require this data, it is appropriate to let one of the applications handle this calculation for all other applications. Access information from another application. Figure 2 illustrates such a case. In this figure, App X is capable of making the necessary calculations and arrives at a summarized view of all customer accounts, while App A, App B, and App C request this information from App X.

Instead of each individual application attempting to calculate the summarized view, these applications can delegate the responsibility to App X. Principles and 12 Technologies scenario, this illustration also requires of clients and servers. Standard Web servers also fall under this category. Integrate applications. In any given enterprise, it is not uncommon to find several applications developed over years that are used for executing different business tasks.

You may even find that such stand-alone applications are maintained by different departments of enterprises and developed using different programming languages and technologies. To some extent, such applications were a result of the drive to decentralize businesses from mainframe-based applications.

However, as we discussed earlier, one of the requirements encountered by almost all enterprises today is the ability to internetwork such applications so that business workflows can be established across the enterprise. To elaborate further, let us take the case of a traditional retail business collecting orders for products via a call center, surface mail, etc.

Let us assume that an order-entry application is used to record all orders in a database captured via these channels. Let us also assume that the company has developed an in-house order-fulfillment application, which takes the orders recorded in the database and conducts whatever tasks are need to fulfill each order. These two applications are stovepiped because each of these applications addresses specific business tasks in a decoupled manner without any knowledge of the overall business flow.

In this case, the overall business flow is to receive and enter orders, and then to fulfill each of the orders. Such stovepiped applications cannot, individually, implement the end-to-end business flow. In order to implement this, you need to integrate the applications such that the order-entry application can automatically trigger the fulfillment application, directly or indirectly.

This is the enterprise application integration18 problem, but there are several ways to achieve such integration. One way is to make the order-entry application invoke or notify the fulfillment application directly after an order has been captured.

The fulfillment application can then start the fulfillment activities thereby streamlining a business flow across these applications. Enterprise application integration. Addison Wesley Longman. This is a simplified application. In practice, you may find that the fulfillment application was developed using some commercial, off-the-shelf enterprise resource planning ERP application such as from SAP.

In such cases, the problem of integration gets more challenging; however, most commercial products offer some technical plumbing to allow for such integration. These three cases illustrate some of the typical scenarios that require solutions based on server-side applications. Although simplified, and not exhaustive, the purpose of these illustrations is to identify the need for server-side applications.

In the previous examples, we did not discuss specific details of how clients communicate with the server. Neither did we discuss the programming requirements and the underlying technologies.

The server-side technologies including the Java server-side technologies can be categorized based on the connectivity model for client-server communication. In the next section, you will find that the connectivity model is what dictates the programming model for different styles of server-side applications. Principles and 14 Technologies Server-Side Applications—Programming Models In this section, we will discuss various programming models for developing server- side applications.

But, what do we mean by a programming model? A programming model describes the structure of programs and the associated abstractions. In the case of server-side applications, the programming model describes how to develop client and server applications, how to distribute various infrastructure-related responsibilities, and how the connectivity between clients and servers is established.

In the case of server-side applications, the style of connectivity largely dictates the programming model. The style of connectivity has to do with the following questions: What is the underlying network protocol?

What is the underlying application protocol? How do clients locate servers? In a client-server world, there may be several services available across the network. At the network level, the network address specifies a location; however, at the application level, clients will be interested in the services available—not how or where they are located. Do clients and server communicate synchronously or asynchronously?

In a synchronous connection, the client connects to the server and waits while the server processes the request. With asynchronous communication, the client does not wait, but instead continues to execute.

What is the application-level contract between clients and servers? Do clients see servers as interfaces with methods, or do clients exchange messages with servers? You will see the possibilities shortly. Principles and 15 Technologies Depending on the application-level protocol, and whether the communication model is synchronous or asynchronous, server-side application programming models can be classified into the following: Synchronous Request-Response Model: This model is meant for method-level communication between clients and servers.

In this model, clients invoke methods on server-side objects, and the programming model is similar to regular method invocation on local objects. Synchronous Stateless Request-Response Model: This is the programming model for the Web.

In the last few years, this programming model has gained tremendous popularity, as it is the model that is driving the externally visible portions of electronic commerce. Asynchronous Communication Model: In this model, clients communicate with servers by sending messages asynchronously. Clients rely on intermediate message brokers or message buses for posting messages. This programming model allows highly decoupled communication from clients to servers, and is widely used for integrating enterprise applications.

Now we will discuss each of these approaches and identify the technical infrastructure needs and the application models. The following features characterize the synchronous request-response model approach: The contract between clients and servers is interface based.

The interface between client and server is the remote interface. The communication between the client and the server is synchronous.

This is no different from local method calls. Upon invoking a method, the client thread waits until the server responds. This also implies that the server should be up and running for the client to invoke methods on the server. The communication is connectionful. The application contract can maintain various requests and responses between the client and the server.

These two features narrow the line between invoking a method on a local object and invoking a method on a remote object. Basic Requirements What are the technical requirements for implementing such an approach?

Before we can identify the technical requirements, let us study this approach in more detail. The following Figure 4 shows as application client invoking a method in a different process.

In object-oriented languages, such as Java, methods exist on interfaces or classes. Therefore, in a Java environment, this approach involves a client invoking a method on an object that exists in a different process possibly on a different machine. Remote method invocation. Once you start considering the details of implementing the above, you will come across the following infrastructure-level challenges: Object References: In an object-oriented runtime environment, an object can invoke methods on another object as long as the calling object holds a reference to the object being invoked.

In Java, an object reference is essentially a handle to an object located in the heap of a process. Because the actual object exists in the heap, an object reference is always local.

Servlets Index

That is, an object cannot maintain a reference to an object existing in the heap of a different process unless we are dealing with shared-memory systems, which we are not! However, the inability of obtaining a reference to a remote object precludes any method invocation in the Figure 4.

In Figure 4, because object B is remote to object A, object A needs to obtain, and maintain, a remote reference to object B. Such a remote reference should be able to maintain a valid reference to an object B existing in process B, and the reference should be valid across the process and network boundaries. But, how to create such a reference? The reference should typically include the following information: Figure 5 shows a remote reference to B.

The remote reference is an object encapsulating the previously listed information. Note that, the client object maintains a reference to the remote reference, while the remote reference object maintains information necessary for connecting to object B. Thus, the role of this remote reference is to be a proxy for object B. Remote reference. Method Invocation: Once the client obtains a remote reference to a remote object, the next step is to use the remote reference to invoke methods on the remote object.

To do this, the remote reference should support all of those methods on the remote object meant for remote invocation. For instance, if object B has five methods that are meant for execution by remote clients, the remote reference should support these methods such that client objects can invoke these methods without having to deal with the remote object directly.

One of the ways to exposing these methods is to specify an interface including all the methods. Such interfaces are called remote interfaces. The remote object object B implements this interface as it provides the behavior required of the methods specified in the interface.

At the same time, the remote reference should also implement this interface, as the clients deal with the remote interface. In this manner, the remote reference acts like a proxy to the remote object. In general, remote references are referred to as proxy objects or stubs. Although both the proxy object and the remote object support implement the remote interface, there is one difference—the proxy object does not implement the methods, rather it delegates the calls on this object to equivalent calls on the remote object.

Figure 6 shows the proxy, and shows the remote interface as a circle attached to an object implementing it. Client-side proxy. To summarize, a proxy object is responsible for the following: Principles and 19 Technologies To act as local representative for the remote object in the client process.

Servlets | Servlet Tutorial

To delegate method implementation over the network to the corresponding remote object. Method invocation, however, does not just end by invoking methods on the proxy object. How does this result in a method invocation on the remote object? Should the remote object be network aware and listen for requests over the network? No, it complicates development of the server-side object i.

On the client-side, the proxy object the remote reference prevents the calling object client from having to deal with the location of the remote object and network semantics. Similarly, on the server-side, we can designate another object to isolate the remote object from the network details.

Such an object can receive network-level method requests and translate them into method invocations on the remote object. Figure 7 completes Figure 6 by introducing a skeleton on the server side. Proxy and skeleton isolating the client from the remoteness of the remote object. The role of this skeleton is similar to that of the proxy on the client side. Both are intermediate objects that prevent the client and the remote object from having to deal with any network-level details.

As far as the client is concerned, it is invoking a method on a local object the proxy. Similarly, as far as the remote object is concerned, it is being invoked by a local object the skeleton.

The proxy and the skeleton handle the true client-server implementation at the network level. Transportation of Data: Let us suppose that we obtain a remote reference to object B. Principles and 20 Technologies object and the object being called.

table of contents

Depending on the argument types, the runtime either copies call by value , or sends references call by reference of arguments to the method being invoked. With primitives, the Java runtime copies the primitives such that these exist in the stack of the method being invoked. In the case of objects as parameters, the runtime copies the references such that the references still point to the same set of objects on the heap.

But, what happens in the case of remote objects? Because references cannot be maintained across processes, all arguments should be copied by value. This applies to both primitives and objects—with one exception, when the argument itself is a remote reference, in which case the remote reference itself can be copied by value.

Because arguments primitives as well as objects can not copied and sent directly across network to the remote process, the state of each argument should be transformed into a raw format that can be transmitted across the wire.

This process is called marshalling, and can be implemented using Java object serialization. Once the argument data is transferred across the wire to the target process, the data must be converted back into the original format. For instance, if an argument is a java. Collection type, the marshalling process converts the collection into a raw format.

On the target process, this raw data must be transformed into an object of the java. Collection type, equal by value to the object that was originally marshalled. This process is called unmarshalling. Object deserialization techniques can be used for unmarshalling. Figure 8 shows these steps. Marshalling and unmarshalling.

The previously listed steps apply to return types, as well. Similar to the arguments, return values should be marshalled into raw data on the server side, and the raw data be unmarshalled into the corresponding Java type on the client side. Principles and 21 Technologies Although marshaling and unmarshalling applies to exceptions, too, exceptions are more complicated than argument and return values.

Apart from copying the exception value to the client side, the same exception should be raised on the client side so that the client application sees the exception as though it was thrown in the same thread. Let us now summarize the solutions for the previous three technical requirements: Solution requires interface specification for each remote object.

In the case of Java RMI, you can specify remote interfaces by extending the java. Remote interface. Proxies and skeletons are classes that are capable of performing all network- level tasks between clients and server objects.

These tasks include marshalling method requests to the server object, unmarshalling return types, arguments, and exceptions. Implementing proxy and skeleton classes requires network-level programming. All available distributed technologies today provide tools to automatically generate these classes based on the remote interface specifications.

Java Programming for Server-Side (JEE) OO-Experienced Developers (C++, etc)

Figure 9 summarizes the technical infrastructure for client-server communication. Proxy and skeleton mediating network level method invocation. Java RMI defines a framework for specifying remote interfaces, which is specified in the java.

The J2SE also includes the runtime support for remote objects and client- server communication. You can specify remote interfaces by making your interface extend the java.

Remote interface this indicates the Java runtime that it is a remote interface as follows: The exception clause is required to denote that this method can throw communication-related exceptions. The next step is to implement a class that implements the remote interface. This is the server object. You will find this compiler under the J2SE distribution. This compiler has options to create source files for the proxy and skeleton classes.

Principles and 23 Technologies Although proxies and skeletons eliminate the need for network-level programming, the following two questions should be considered: How does the skeleton maintain instances of object B? Should the server application create an instance initially, for each request, or should it share one instance for all requests? Location transparency: How do you indicate the location of the server to the proxy object? Can you predetermine this and force the proxy to invoke a specific implementation of the remote interface available at a given network location?

If so, the client application would be dependent on the location of the server. But, is it possible to achieve location transparency? Instance Management Once the remote interface, and its implementation are available, the next question is how to make instances of the implementation class available in a runtime process.

Creating a new instance of an implementation object is not adequate to make this implementation available via a remote interface.

In order for the server implementation object to be available and be able to process requests coming from client applications over the network, the following additional steps are required: The process hosting the instance should be reachable via network. Typically, this boils down to a server socket listening for requests over the network i. The server process should allocate a thread for processing each incoming request. Servers are generally required to be multi-threaded. The server process may host implementations of several remote interfaces.

Depending on some of the information contained in the incoming network request, the server process should be capable of identifying the correct implementation object. For instance, the name of the interface could specify the implementation object for the server. In this case, the server should have knowledge of which class implements which remote interface. Principles and 24 Technologies 4. Once the server identifies the correct interface, it should invoke the associated skeleton class.

This class can unmarshall the request parameters and invoke the appropriate method for the implementation class. In the above list, the task of creating instances depends on whether the client- server communication is required to be stateful or stateless. Address this question when you expect more than one client to invoke methods on a remote object. The main difference between stateful and stateless communication is whether the remote instance can maintain and rely on instance variable between multiple method calls from a client.

For instance, consider that client A is invoking methods on a remote object B. The client may invoke these methods one after the other. While implementing a method, the remote object may store data in its instance variables. For instance, it may store some calculation results in an instance variable. If subsequent methods on this object depend on the value stored in the instance variable, the communication is stateful; that is, the server should make sure that the same instance is being used for all requests from a given client.

This also means that, while an instance is serving a client, the server should not use the same instance for other client requests.

One important ramification of statefulness is that the server will maintain a separate instance for each client. In systems that have a very large number of clients, statefulness may affect performance.

On the other hand, stateless communication does not require the same instance for a given client i. In this case, the server may be able to use ten objects for these ten clients. As a result, stateless communication is more efficient as it converses memory on the server side. A general practice is to implement remote objects using the stateless approach.

On the other hand, the EJB technology allows for stateful server-side objects, too. We shall discuss more about this later. Figure 10 summarizes the instance management. Instance management. Figure 10 shows three client applications communicating with three different remote objects, all being maintained by a single process. Depending on the interface being used, the server process locates an instance and delegates the incoming request to the instance.

Although this figure shows a single server process, in a typical distributed client- server environment, there may be several server processes, each maintaining a set of remote objects. When there is one single known server process, it is easy to indicate the network location of the server process to the proxy object; however, when the possibility exists for several such processes, it is difficult to manage the network locations for each proxy. Location and Naming As discussed in the previous section, it is important to achieve location transparency in distributed applications with several clients invoking methods on a number of remote objects that are being managed by several server processes across the network.

There is one additional question that we did not consider in the previous question. How does the client application create an instance of the proxy object? In the previous discussion we assumed implicitly that the client would create an instance and use it; however, the client should also be aware of the network location of the server process.

Although these two tasks seem independent, both are typically solved using the same approach, with naming and naming services. Principles and 26 Technologies that remote references can be named. Unlike a remote reference which essentially points to a memory address within the process , a name is portable, and can uniquely determine a remote interface.

Therefore, clients can use names to refer to remote objects; however, a name should still correspond to a remote object available at a given network location.

How can this association between names and proxies be maintained? A naming service is one that can manage names and the corresponding remote references proxies. When the server is started, the server creates a proxy object for each remote object that it is responsible for maintaining, and stores it against a name in another process.

Now, this new process has a list of names and the associated proxy objects. The server process can store the network location within the proxy object, or provide sufficient information for the proxy to locate the server.

The client supplies the name of a remote object to this new process, and obtains the proxy object corresponding to that name. Because the server originally created this proxy object with the network location embedded, the proxy is network aware. There is no need for the client application to supply this address to the proxy object. In simple terms, the previous list describes the role of names and naming services.

While proxy objects ought to be network aware, the names need not be. During compile time, the client application developer uses a name. At runtime, the client application looks up the naming service to retrieve a proxy object. Figure 11 shows the role of names and naming service. Role of naming service. During the server process implementation, the server binds publishes the name of the remote object, as shown in the following: When you invoke this class, the main method creates an instance of ProcessImpl, and publishes it in the RMI registry.

Although it appears that the actual ProcessImpl is what is being published in the registry, it is actually a proxy object that gets published. This task is handled under the wraps by RMI. In order for the previously listed code to work, the RMI registry should be up and running. Java Tutorial from Sun at: Principles and 28 Technologies Once the name is published, the client can look up the RMI registry for the proxy object. The following code snippet in a client application illustrates this task: Under the covers, this method call will be marshalled via the proxy object to the server process, unmarshalled by the server-side skeleton, and then handled to the processImpl object awaiting requests.

Programming Model What is the programming model for client-server applications based on synchronous requests and responses? The following list explains: Remote interfaces that specify the contract between server-side objects and clients.

Proxies and skeletons for handling the network level programming. As discussed in this section, these are tool generated, and you need not implement these classes explicitly. Principles and 29 Technologies 3.

A server process to maintain server-side remote objects. As you will see later, the J2EE specifies a full-fledged process for maintaining remote objects. Instead of custom developing, you rely on the runtime support provided by commercial J2EE platforms. Naming services for publishing proxy objects. This is an essential piece that allows location transparency. Clients to lookup for proxy objects using names.

Clients invoke methods on remote objects. The purpose of this programming model is to isolate the network-level tasks involved in client-server communication. The previously listed code snippets contain very minimal additional code to indicate that you are dealing with remote objects and not local objects. Once a proxy object is obtained from the naming service, the client uses it as if it were a local object.

The same is true with the server-side object. The object does not know if the caller is local or remote; the only indicator to point to such communication is the task of publishing a name in a naming service.

The goal of this programming model is, therefore, to make the programming task as close as possible to programming local objects. Principles and 30 Technologies Synchronous Stateless Request-Response Model In the previous section, we focused on an approach that was based on remote interfaces. HTTP21 is the most widely used protocol across the Internet, connecting browser- based clients and Web servers.

HTTP is a generic protocol that only specifies certain types of requests, as well as the structure of requests and responses.

Unlike the remote interface-based model in which you specify a remote interface, with HTTP, the contract between the client browser and the server Web server is fixed by the HTTP. Clients and servers can however express parameters and results within HTTP requests and responses.

In the following discussion, the term client means Web browser, and the word server means a Web server. Although these documents are not called specifications, these documents do not change once released. Any changes to these documents are released as new RFCs. See http: Refer to http: Based on user interaction, the browser makes HTTP requests to specified addresses in links or in the address bar to Web servers, receives HTTP responses downloads , and renders the response typically HTML with embedded images, documents etc.

However, in the context of client-server applications, it is possible to build more specialized HTTP clients and servers that are meant for implementing specific application logic that does not involve content at all. SOAP is also based on the same idea. The request header includes a request URI25 and optionally certain parameters known as query parameters. These parameters are specified as name-value pairs at the end of the request URL.

Depending on the type of the request which will be discussed shortly , the request body might be empty, or it might contain MIME26 messages. For instance, if your HTTP request points to http: Alternatively, the Web server could map a request, such as http: The server also sends a status message. Other types of URLs include ftp: Although URIs are usually used for Internet resources, this scheme can be applied to any resource in an application, or in a network.

One of the basic differences is that, a URI does not indicate a protocol. Secondly, a resource identified by a URI may be physical say, a file or may be abstract a name. MIME allows complex message bodies not necessarily human-readable for Internet messages. This process is shown in Figure Generate response 3. Send response Figure This is the programming model for the Web. Such an object can receive network-level method requests and translate them into method invocations on the remote object.

Apart from copying the exception value to the client side, the same exception should be raised on the client side so that the client application sees the exception as though it was thrown in the same thread. A practical guide to computer security. Remote interface this indicates the Java runtime that it is a remote interface as follows:

FRANCE from Boise City
See my other posts. I absolutely love fossil hunting. I am fond of studying docunments boldly .