Coldfusion Web Hosting - Java Programming - Cheap Web Hosting Blog

CHAPTER 4 CACHE CONTROLLER PATTERN Figure 4-1. Example data-mining application The predefined queries also can be converted into look-ahead queries; for example, to pan left, you want to preload the map left of Denver. Preloading the map by using a background task will make the map application appear fluid. Figure 4-2 is an example application that uses preloading. Like MapQuest, Maps.google.com is another mapping web application that provides the capability to pan and zoom. What makes Maps.google.com unique is that the map pieces that could be referenced as a result of one of the predefined operations are preloaded. If you experiment with the mapping application, you ll see that it is fluid. The application stops becoming fluid if you pan or zoom too quickly and the preloading task is busy loading other map pieces. The Maps.google.com application is using a cache to preload map pieces. A cache can also be used to remember old pieces of data so that if they are referenced multiple times, they are not loaded multiple times. A nontechnical reason for using a cache is for legal reasons. When creating web applications, very often you will be integrating other data sources. Those other data sources reference very large databases (for example, Amazon.com). The data contained within those very large databases is not yours, and you cannot store the data locally in your database for future reference. Most end-user license agreements will specifically state that the data that is retrieved does not belong to you. Having a cache will increase the performance of your application without having to illegally store the data locally.
Note: In case you are looking for affordable and reliable webhost to host and run your business application check Vision ftp web hosting services

CHAPTER 4 Cache Controller Pattern Intent The Cache Controller pattern provides the caller a mechanism to temporarily store resources in a consistent manner, resulting in an improved application experience for the caller. Motivation There are many forms of web applications, and one form is a data-mining application. There are different types of data-mining applications, but they all have one thing in common: they query a repository, and the repository responds with data. This means an application will retrieve data based on a query that in structure is identical over the multiple queries. Figure 4-1 shows a data-mining application that has a series of maps as a database. Looking a bit closer at the MapQuest application, there are a number of links and advertisements. What is of interest in the context of this pattern are the navigational and zooming controls. The navigational controls are used to pan the map left, right, up, and down. The zooming controls are used to zoom in to or out of the map. These controls are necessary, of course, because the user will want to focus in on various parts of the map. What is more important about the navigational and zooming controls is that they are predefined operations used to retrieve values from the same repository. This is in stark contrast to the links surronding the controls, which will result in the execution of some query on an unrelated repository (unrelated, that is, to the map database). The predefined queries can be converted into standard operations such as zoom in, zoom out, pan left, pan right, pan up, and pan down.
Note: If you are looking for cheap and reliable webhost to host and run your mysql application check Vision mysql hosting services

CHAPTER 3 CONTENT CHUNKING PATTERN In Figure 3-13, the initial page is downloaded by clicking the button. The downloaded content is JavaScript, and the initial page has no idea what the content does. When the content has been downloaded, it is executed. The HTML framework page has coded the referencing of the variable dynamicFilter and the calling of the method MakeCall. The MakeCall method does not exist when the HTML framework page is executed, and is available when the downloaded content is executed. The downloaded content that is executed downloads yet another piece of content that is injected into the HTML page. The result is the loading of an image where the text Nothing was. The role of the HTML framework page has changed into a bootstrap page that loads the other code chunks. The other code chunks are purely dynamic and contain references and code that the HTML framework page does not know about. The advantage of this implementation is that the document can be loaded incrementally by using pieces of dynamic code that are defined when they are loaded. The Content Chunking pattern defines the loading of content dynamically. But the additional use of JavaScript makes it possible to dynamically define the logic that is used by the HTML framework page. Pattern Highlights The following points are the important highlights of the Content Chunking pattern: An HTML page is the sum of an HTML framework page and content chunks. The HTML framework page is responsible for organizing, referencing, and requesting the appropriate chunks. It should act as a mediator for the individual chunks. The HTML framework page delegates the processing of the chunks to another piece of code. The content chunks are uniquely identified by a URL. Content chunks that are distinct do not use the same URLs. Content chunks are used to implement functionality that is determined by the user. Content chunks should be one of three types: XML (preferred), HTML (preferred XHTML), or JavaScript. There are other formats, but they are not covered in this book and their use should be carefully considered.
Note: In case you are looking for affordable and reliable webhost to host and run your j2ee application check Vision web and email hosting services

76 CHAPTER 3 CONTENT CHUNKING PATTERN The example JavaScript source code is formatted using object initializers. An object initializer is the persisted form of a JavaScript object. You should not equate an object initializer with a JavaScript class definition; they are two entirely separate things. When an object initializer is processed, an object instance is created, and the identifier of the object instance is the variable declaration. In the example, the variable dynamicFiller is the resulting object instance. The variable dynamicFiller has two properties (generatedAsyncand reference) and two methods (complete and makeCall). The property generatedAsync is an instantiated Asynchronous type and is used to make an asynchronous call to the server. The property reference is the HTML element that will be manipulated by the method complete. The method makeCall is used to make an XMLHttpRequest, and the parameter destination is assigned to the property reference. Putting all the pieces together, the HTML framework code contains general code that references an incomplete variable. To make a variable complete, the JavaScript content is downloaded and executed. The complete variable contains code to download content that is injected into the framework page. Figure 3-13 illustrates the execution sequence of events. Figure 3-13. Sequence of events when downloading and executing JavaScript
Note: In case you are looking for affordable webhost to host and run your web application check Vision cheap hosting services

CHAPTER 3 CONTENT CHUNKING PATTERN 75 Consider the following example HTML page: Start Process

As in previous examples, a variable of type Asynchronous is instantiated. The button is wired to make an asynchronous method call with the URL /chap03/chunkjs04.js. When the request receives the JavaScript chunk, it is executed via the eval statement. After the eval statement has returned, the method dynamicFiller.MakeCall is made. The call to the method dynamicFiller. MakeCall is a general piece of code. In the implementation of the dynamicFiller.MakeCall method is the specific code managed by the server. Referencing the dynamicFiller.MakeCall method is done using an incomplete variable; that is, the initial script includes no definition of the variable dynamicFilter. Of course, a loaded and processed script cannot reference an incomplete variable because that would generate an exception. But what a script can do is load the implementation just before an incomplete variable is used. That is what the example HTML page has illustrated. For those wondering, there is no definition of dynamicFilter in the files factory.jsor asynchronous.js. Incomplete variables, types, and functions are possible in JavaScript, allowing a script to be loaded and processed without generating an exception. The following source code implements the incomplete dynamicFiller variable: var dynamicFiller = { generatedAsync : new Asynchronous(), reference : null, complete : function(status, statusText, responseText, responseXML) { dynamicFiller.reference.innerHTML = responseText; }, makeCall : function(destination) { dynamicFiller.reference = destination; dynamicFiller.generatedAsync.complete = dynamicFiller.complete; dynamicFiller.generatedAsync.call(’/chap03/chunkjs05.html’); } }
Note: If you are looking for cheap webhost to host and run your apache application check Vision jboss web hosting services

CHAPTER 3 CONTENT CHUNKING PATTERN In this example, the variable img is an instance of an Image, which cross-references to the HTML tag img. The property src is assigned the URL of the image. The last line of the code chunk uses the method appendChild to add the instantiated Image instance to the HTML document. Not associating the variable img with the HTML document will result in an image that is loaded but not added to the HTML document, and hence not generated. The resulting generated HTML page is shown in Figure 3-12. Figure 3-12. Generated HTML page after image has been inserted Figure 3-12 is not that spectacular because it illustrates yet again how an image can be added to an HTML page. What is of interest is that the text Nothing has remained and is not replaced as in previous examples. The reason is that the method appendChild was used (and not replaceChild or removeChild, and then appendChild). The advantage of using the Dynamic HTML object model approach is that it enables images or arbitrary actions to be downloaded in the background that can at the script s choosing be displayed. Instantiating Objects Another type of JavaScript chunk that can be downloaded are object states. By using an object state, you can add a level of indirection, allowing functionality to be added during the execution of the HTML page. In all of the past example HTML code pieces, the initial HTML page had to have all the scripts and know the URLs of the resources that were retrieved. Using an indirection, the JavaScript on the client side does not need to know the specifics of a URL or data structure. The client references a general piece of code that is executed. The general piece of code is managed by the server, and contains specific instructions to do something that the client was not programmed to do. Using indirection, it is possible to add functionality to the client that the client did not possess at design time.
Note: If you are looking for best quality webspace to host and run your tomcat application check Vision shared web hosting services

CHAPTER 3 CONTENT CHUNKING PATTERN var asynchronous = new Asynchronous(); asynchronous.complete = function(status, statusText, responseText, responseXML) { eval(responseText); } Get Script

When the user clicks the Get Script button, an XMLHttpRequest request is made that retrieves the document /chap03/chunkjs01.html. The document contains a JavaScript chunk that is executed by using the eval function. The following chunk is downloaded: window.alert(”oooowweee, called dynamically”); The example chunk is not very sophisticated and pops up a dialog box. What would concern many people with arbitrarily executing JavaScript code is that arbitrary JavaScript code is being executed. An administrator and user might be concerned with the security ramifications because viruses or Trojans could be created. However, that is not possible because JavaScript executes within a sandbox and the same origin policy applies. Granted, if a developer bypasses the same origin policy, security issues could arise. When receiving JavaScript to be executed, a simple and straightforward implementation is to dynamically create a JavaScript chunk that executes some methods. The JavaScript chunks make it appear that the web browser is doing something. For example, the JavaScript chunk downloaded in the previous example could be used to assign the spanor td tag as illustrated here: document.getElementById(”mycell”).innerHTML = “hello”; The generated script is hard-coded in that it expects certain elements to be available in the destination HTML page. Generating a JavaScript That Manipulates the DOM Earlier you saw the image generation solution in which an image was broken and then made complete by downloading a valid link. It is also possible to download an image by modifying the Dynamic HTML object model. You modify the object model by using a JavaScript chunk to insert the img tag. The following is an example image JavaScript chunk that creates a new img tag and chunks it into the HTML document: var img = new Image(); img.src = “/static/patches01.jpg”; document.getElementById(”insertplace”).appendChild(img);
Note: In case you are looking for affordable webhost to host and run your servlet application check Vision mysql5 web hosting services

72 CHAPTER 3 CONTENT CHUNKING PATTERN It seems a bit odd to download and assign links that are then processed by the web browser. This indirect approach is done not to illustrate how complicated a web application can be made. The indirect technique is necessary because directly downloading binary data is not possible. But all is not lost, because of the way that the browser caches images. If an image is referenced and downloaded, the image stays in the browser s cache. If the image is referenced a second time, the image is retrieved from the cache. Of course this happens only if the HTTP server implements caching. There is a downside: If a request is made for a URL that references an image, two HTTP requests are required: one to download the content that contains the URL of the image, and the image itself. If both requests are using HTTP 1.1, which most likely is the case, the requests will be inlined using a single connection. Another variation of the illustrated strategy is to download not a URL but the entire HTML to create an image. The strategy does not save a request connection, but provides a self-contained solution that involves no additional scripting. The following HTML code snippet illustrates how the entire img HTML tag is downloaded: When injecting both the imgtag and its appropriate srcattribute, the browser will dynam ically load the image as illustrated in the previous example. The advantage of injecting the HTML is that the server side could inject multiple images or other types of HTML. Additionally, by injecting the entire imgtag, there is no preliminary stage where a broken image is generated. However, either approach is acceptable, and which is used depends on the nature of the appli cation. When injecting HTML, there might be a flicker as the HTML page resizes. When you assign the srcproperty, there is no flicker, but an empty image needs to be defined or the image element needs to be hidden. JavaScript Chunking Another form of chunking is the sending of JavaScript. Sending JavaScript can be very effective because you don t need to parse the data but only execute the JavaScript. From a client script point of view it is very easy to implement. For reference purposes, do not consider downloading JavaScript faster than manually parsing and processing XML data and then converting the data into JavaScript instructions. JavaScript that is downloaded needs to be parsed and validated before being executed. The advantage of using the JavaScript approach is simplicity and effectiveness. It is simpler to execute a piece of JavaScript and then reference the properties and functions exposed by the resulting execution. Executing JavaScript Consider the following HTML code that will execute some arbitrary JavaScript: Get Image
The img tag is used to reference an image. The img tag is in most cases defined by using a src attribute that references an image location. In the example, the srcattribute does not exist, and instead an id attribute exists. When the HTML page is downloaded and presented, a broken image is displayed because there is no image associated with the img tag. To make the img tag present an image, the Get Image button is clicked to make a request to retrieve the single-line file containing the URL of the image. When the XMLHttpRequest has downloaded the single-line file, the function implementation for complete is called and the attribute/property src is assigned to the URL of the remote image. Thus the browser updates itself, loading the image and displaying it. The single-line file is stored at the URL /chap03/chunkimage01.html, and its content is defined as follows: /static/patches01.jpg When the previously outlined HTML page with an undefined src attribute is loaded, Figure 3-10 is generated. Figure 3-10 shows a small box below the Get Image button that indicates a broken imgtag, because there is no loaded image. When the Get Image button is clicked, the link of the image is downloaded and assigned to the img tag, which causes the image to be loaded. Figure 3-11 is the regenerated HTML page.
Note: In case you are looking for affordable webhost to host and run your servlet application check Vision make web site services