# Patent

## Title
Image distribution for dynamic server pages

## Abstract

Methods, systems, and products for distributing images in a data processing system, including receiving a request for a dynamic server page having a multiplicity of associated images, each image having a storage location identified in the dynamic server page by an image resource locator; inserting in the dynamic server page an image group identifier for the images; and inserting in the dynamic server page client data names for the images. Typical embodiments also include receiving from the client a request for a group of images, wherein the request comprises the image group identifier; retrieving from storage the images identified by the image group identifier; and sending the retrieved images to the client.

## Background
CROSS REFERENCE TO RELATED APPLICATIONS
The present application is related to the following co-pending application:
U.S. patent application Ser. No. 10/631,057.
BACKGROUND OF THE INVENTION
1. Field of the Invention
The field of the invention is data processing, or, more specifically, methods, systems, and products for image distribution for dynamic server pages in data processing systems.
2. Description of Related Art
In distributing images on data processing systems, documents having many images are slow to load on the client side, and the images are cumbersome to administer on the server side. Consider the following HTML segment:












<HTML>









<HEAD>









<TITLE>Business Partner support from IBM



PartnerWorld</TITLE>









</HEAD>



<BODY>









<table width=“760” border=“0”



cellspacing=“0” cellpadding=“0”>



<img src=“//www.ibm.com/i/v11/m/en/mast_logo.gif”



border=“0”



alt=“IBM” width=“150” height=“47”/></td>



<td width=“310” class=“tbg”><a href=“#main”>



<img src=“//www.ibm.com/i/c.gif” border=“0”



width=“1” height=“1”



alt=“Skip to main content”/></a></td>



<table border=“0” cellpadding=“0” cellspacing=“0”>



<form name=“Search” method=“get”



<input type=“hidden” name=“v”



value=“11” size=“15”/><tr>



<img src=“http://t1d.www-1.cacheibm.com/printer.gif”



width=“23”



height=“19” alt=“Link to printable version of page”></td>



<tr valign=“middle”><td>



<img src=“http://t1d.www-1.cacheibm.com/pwhome.jpg”



width=“610”



height=“52” alt=“IBM PartnerWorld home header



graphic” /></td>



<td><input maxlength=“100” class=“input” size=“15”



name=“q”



value=“” type=“text”/></td><td>



<img src=“//www.ibm.com/i/v11/icons/fw.gif”



width=“16”



height=“16” alt=“”/></td>









</BODY>







</HTML>









This example HTML segment is an excerpt from the IBM website at http://www.developer.ibm.com. Notice the repeated use of <img> elements. This segment contains five <img> elements, and the document from which this example was excerpted, at the time of this writing, contained 156 <img> elements. For each such element, a browser displaying the document opens a separate TCP/IP connection to a server, and transmits an HTTP request message requesting the image file identified in the ‘src’ attribute of the <img> element. Each such request eventually results in a corresponding HTTP response message from the server, through still another TCP/IP connection. In addition, each TCP/IP connection requires system calls to establish sockets and transmit TCP/IP ‘send’ messages, each of which requires a full-blown context switch at the CPU level, recognized by persons of ordinary skill in the art as a heavy computer processing burden. Displaying the document from which this example was excerpted requires 312 TCP/IP connections just for the image transfers. Moreover, this is not at all atypical. Web pages today often contain many images.
Notice also that the ‘src’ attributes identify image files in several file system locations. In fact, the ‘src’ attribute can only identify files stored in file system locations. System administrators on the server side must store and manage image files in ways that are cumbersome, with image files often scattered around in different file system locations on different servers. Tracking updates and locating and removing obsolete images are all very cumbersome on file systems. For all these reasons, there is an ongoing need for improved ways of distributing images in data processing systems.
SUMMARY OF THE INVENTION
This specification discloses exemplary embodiments of methods, systems, and products for distributing images for dynamic server pages in which advantageously prior art image elements are replaced with new image elements identifying image groups and client-side storage locations so that all images in a predefined group generally may be downloaded to browsers or other clients at approximately the same time, thereby greatly reducing the data communications connection burden of communicating images for display through dynamic server pages.
More particularly, exemplary embodiments of methods, systems, and products are disclosed and explained for distributing images in a data processing system, including receiving a request for a dynamic server page having a multiplicity of associated images, where each image has a storage location identified in the dynamic server page by an image resource locator.
Typical embodiments also include inserting in the dynamic server page an image group identifier for the images. Inserting an image group identifier may be carried out by inserting a markup element that includes the image group identifier. Such markup elements generally represent instructions to a client to retrieve, during a single communication connection to a server, all images identified by the image group identifier.
Typical embodiments also include inserting in the dynamic server page client data names for the images. Inserting client data names is often carried out by inserting in dynamic server page content as rendered markup elements representing instructions to display the images at client display locations. Inserting client data names for each image may include replacing the image resource locators with the client data names. In many embodiments, image resource locators are set forth in HTML <img> elements in the dynamic server page, and replacing the image resource locators with client data names includes replacing the <img> elements with markup elements comprising the client data names.
Typical embodiments also include receiving from the client a request for a group of images, wherein the request comprises the image group identifier; retrieving from storage the images identified by the image group identifier; and sending the retrieved images to the client. Typical embodiments include storing as a group on a server all the images associated with a dynamic server page, including storing with the images an image group identifier, a dynamic server page name, and client data names for the images.
The foregoing and other objects, features and advantages of the invention will be apparent from the following more particular descriptions of exemplary embodiments of the invention as illustrated in the accompanying drawings wherein like reference numbers generally represent like parts of exemplary embodiments of the invention.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 depicts an architecture for a data processing system in which various embodiments of the present invention may be implemented.
FIG. 2 sets forth a block diagram of automated computing machinery.
FIG. 3 sets forth a data flow diagram illustrating an exemplary method for distributing images in a data processing system.
FIG. 4 sets forth a data flow diagram illustrating a further exemplary method for distributing images in a data processing system.
FIG. 5 sets forth a database relationship diagram illustrating relations among records representing images and groups of images.
FIG. 6 sets forth a data flow diagram illustrating a still further exemplary method for distributing images in a data processing system.



DETAILED DESCRIPTION OF EXEMPLARY EMBODIMENTS
Introduction
Exemplary embodiments are described generally in this specification in terms of methods for image distribution for dynamic server pages in data processing systems. Persons skilled in the art, however, will recognize that any computer system that includes suitable programming means for operating in accordance with the disclosed methods also falls well within the scope of the present invention.
Suitable programming means include any means for directing a computer system to execute the steps of the method of the invention. Suitable programming means include, for example, systems comprised of processing units and arithmetic-logic circuits connected to computer memory. Such systems generally have the capability of storing in computer memory programmed steps of methods according to exemplary embodiments for execution by a processing unit. Generally in such systems, computer memory is implemented in many ways as will occur to those of skill in the art, including magnetic media, optical media, and electronic circuits configured to store data and program instructions.
Further, embodiments may be implemented as a computer program product for use with any suitable data processing system. Embodiments of a computer program product may be implemented as a diskette, CD ROM, EEPROM (‘flash’) card, or other magnetic or optical recording media for storage of machine-readable information as will occur to those of skill in that art. Persons skilled in the art will immediately recognize that any computer system having suitable programming means will be capable of executing the steps of methods according to exemplary embodiments as included in a computer program product. Moreover, persons skilled in the art will recognize immediately that, although many of the exemplary embodiments described in this specification are oriented to software installed on computer hardware, nevertheless, alternative embodiments implemented as firmware or other computing machinery are well within the scope of the present invention.
DEFINITIONS
“BLOB” stands for “Binary Large OBject,” a collection of binary data stored as a single entity in a database. BLOBs are used to hold multimedia content such as video and audio clips, although they are also used to store software, even executable binary code. Images are typically expressed in binary encodings such as JPEG and GIF, and BLOBs are useful for storing images according to various embodiments of the present invention. Not all databases support BLOBs.
“Browser” means a web browser, which is a communications application for locating and displaying web pages. Browsers typically include a markup language interpreter, web page display routines, and an HTTP communications client. Typical browsers can display text, graphic images, audio and video. Browsers are operative in network-enabled devices, including wireless network-enabled devices such as network-enabled PDAs and mobile telephones. Browsers in wireless network-enabled devices often are downsized browsers called “microbrowsers.” Microbrowsers in wireless network-enabled devices often support markup languages other than HTML, including for example, WML, the Wireless Markup Language.
“CGI” means “Common Gateway Interface,” a standard technology for data communications of resources between web servers and web clients. CGI provides a standard interface between servers and server-side ‘gateway’ programs that administer actual reads and writes of data to and from files systems and databases.
“Client,” “client device,” “client machine,” or “client computer” means any computer or process requesting a service of another computer system or process using a protocol. Clients include, for example, personal computers, mainframes, PDAs, mobile telephones, laptop computers, devices capable of wireless as well as wireline communications, and any instrument capable of administering search queries and search results or responses. Clients may further include communications software applications that establish connections for data communications with servers and issue requests for documents, images, and other resources.
A “communications application” is any data communications software capable of sending and receiving images distributed for documents or other data streams in data processing systems. Examples include browsers, microbrowsers, special purpose data communications systems, server applications, and others as will occur to those of skill in the art.
“CPU” means ‘central processing unit.’ The term ‘CPU’ as it is used in this disclosure includes any form of computer processing unit, regardless whether single, multiple, central, peripheral, or remote, in any form of computing machinery, including client devices, servers, and so on.
“Data processing system” means one or more computers, peripheral equipment, and software that performs data processing. Data processing system is synonymous with ‘computer system,’ ‘computing system,’ and ‘information processing system.’
A “data stream” is any resource on any data processing system whose contents are organized by markup. Data streams include, for example, static files in markup languages, such as static HTML files or static HDML files. Data streams also include dynamically-generated content such as query results and output from CGI scripts, JavaTM servlets, Active Server Pages (“ASPs”), Java Server Pages (“JSPs”), and other kinds of dynamically-generated content as will occur to those of skill in the art.
“GUI” means ‘graphical user interface.’
“HDML” stands for ‘Handheld Device Markup Language,’ a markup language used to format content for web-enabled mobile phones. HDML is proprietary to Openwave Systems, Inc. and can only be operated on phones that use Openwave browsers. Rather than WAP, HDML operates over Openwave's Handheld Device Transport Protocol (“HDTP”).
“HTML” stands for ‘HyperText Markup Language,’ a standard markup language for displaying web pages on browsers.
“HTTP” stands for ‘HyperText Transport Protocol,’ a standard data communications protocol of the World Wide Web.
A “hyperlink,” also referred to as “link” or “web link,” is a reference to a resource name or network address that allows the named resource or network address to be accessed. More particularly in terms of the present invention, invoking a hyperlink implements a request for access to a resource, generally a document. Often a hyperlink identifies a network address at which is stored a resource such as a web page or other document. Hyperlinks are often implemented as anchor elements in markup in documents. As the term is used in this specification, however, hyperlinks include links effected through anchors as well as URIs invoked through ‘back’ buttons on browsers, which do not involve anchors. Hyperlinks include URIs typed into address fields on browsers and invoked by a ‘Go’ button, also not involving anchors. In addition, although there is a natural tendency to think of hyperlinks as retrieving web pages, their use is broader than that. In fact, hyperlinks access “resources” generally available through hyperlinks including not only web pages but many other kinds of data as well as dynamically-generated server-side output from Java servlets, CGI scripts, and other resources as will occur to those of skill in the art.
An “image” is an electronic representation of a picture produced by means of sensing light, sound, electron radiation, or other emanations foment from the picture or reflected by the picture. An image also can be generated directly by software without reference to an existing picture. Images include pictures of scenes as well as pictures of graphical elements for display on computer screens. Images typically are expressed in digital formats, such as, for example, JPEG, GIF, PNG, TIFF, BIFF, bmp, Clear, FITS, IFF, NFF, OFF, PCX, TGA, and XBM. “JPEG” abbreviates “Joint Photographic Experts Group,” the original name of the committee that wrote the standard. “GIF” stands for “Graphics Interchange Format,” a format whose compression algorithm is proprietary to Unisys. “PNG” stands for “Portable Network Graphics,” a format developed as a non-proprietary alternative to GIF.
“The Internet” is a global network connecting millions of computers utilizing various protocols, including the Internet Protocol or ‘IP’ as the network layer of their networking protocol stacks. The Internet is decentralized by design, an example of a data processing system. An “internet” (uncapitalized) is any set of networks interconnected with routers.
“LAN” is an abbreviation for “local area network.” A LAN is a computer network that spans a relatively small area.
“Markup” means information added to a document to enable a person or system to process it. Markup is composed of syntactically delimited characters added to the data of a document to represent its structure. Markup information can describe the document's characteristics, or it can specify the actual processing to be performed. Markup is composed of markup “elements,” each of which is defined by one or more tags. Markup elements may be defined with one or more “attributes.” Each attributes has a name and a value. The well known HTML anchor element, for example, includes a start tag <a> and an end tag <a>. The anchor element also attributes including, for example, an HREF attribute that is used to identify a URI for a hyperlink and a NAME attribute that is used to make an anchor available as a hyperlink. An example of an anchor element is:














<a href=“http://www.SomeWebSite.com/index.html”> Home </a>









This example establishes the word “Home” as an anchor of a hyperlink to the index.html document located at the URI identified by the HREF element, “http://www.SomeWebSite.com/index.html”. This example:












<img src=“//www.ibm.com/i/mast_logo.gif” width=“150” height=“47”/>









is an HTML image element <img>. HTML image elements reference images with hyperlinks identified by URIs in their SRC attributes. This example has a SRC attribute with a URI of “//www.ibm.com/i/mast_logo.gif.” In addition, this example <img> element has attributes defining image width and height. The image element is an example of an “empty” element in that, rather than having both a start tag and an end tag, it is composed of only the single tag <img>.

A “markup language” is a language used to define information (markup) to be added to the content of a document as an aid to processing it. Examples of markup languages include HDML, HTML, WML, XML, and many others. Markup elements in some markup languages are predefined by a standard for the language, as is the case for HDML, HTML, and WML, for example. Markup elements in other markup languages are user defined, which is the case generally for XML and for SGML (the Standard Generalized Markup Language), the language upon which XML is based.
“PDA” refers to a personal digital assistant, a handheld computer useful as a client according to embodiments of the present invention.
“Resource” means any aggregation of information administered in data processing systems according to embodiments of the present invention. Network communications protocols, such as, for example, HTTP, generally transmit resources, not just files. A resource is an aggregation of information capable of being identified by a URI or URL. In fact, the ‘R’ in ‘URI’ stands for ‘Resource.’ The most common kind of resource is a file, but resources include dynamically-generated query results, the output of CGI scripts, dynamic server pages, and so on. It may sometimes be useful to think of a resource as similar to a file, but more general in nature. Files as resources include web pages, graphic image files, video clip files, audio clip files, files of data having any MIME type, and so on. As a practical matter, most HTTP resources, WAP resources, and the like are currently either files or server-side script output. Server side script output includes output from CGI programs, Java servlets, Active Server Pages, Java Server Pages, and so on.
A “server” is a computer that provides shared services to other computers over a network. Examples of servers include file servers, printer servers, email servers, web servers, and so on. Servers include any computer or computing machinery on a network that manages resources, including documents, and responds to requests for access to such resources. A “web server” is a server that communicates with other computers through data communications application programs, such as browsers or microbrowsers, by means of hyperlinking protocols such as HTTP, WAP, or HDTP, for example, in order to manage and make available to networked computers documents, images, and other resources.
“SQL” stands for ‘Structured Query Language,’ a standardized query language for requesting information from a database. Although there is an ANSI standard for SQL, as a practical matter, most versions of SQL tend to include many extensions. This specification provides examples of database queries against semantics-based search indexes expressed as pseudocode SQL. Such examples are said to be ‘pseudocode’ because they are not cast in any particular version of SQL and also because they are presented for purposes of explanation rather than as actual working models.
A “Java Servlet” is a program designed to be run from another program rather than directly from an operating system. “Servlets” in particular are designed to be run on servers from a conventional Java interface for servlets. Servlets are modules that extend request/response oriented servers, such as Java-enabled web servers. Java servlets are an alternative to CGI programs.
“TCP/IP” refers to two layers of a standard OSI data communications protocol stack. The network layer is implemented with the Internet Protocol, hence the initials ‘IP.’ And the transport layer is implemented with the Transport Control Protocol, referred to as ‘TCP.’ The two protocols are used together so frequently that they are often referred to as the TCP/IP suite, or, more simply, just ‘TCP/IP.’ TCP/IP is the standard data transport suite for the well-known world-wide network of computers called ‘the Internet.’
A “URI” or “Universal Resource Identifier” is an identifier of a named object in any namespace accessible through a network. URIs are functional for any access scheme, including for example, the File Transfer Protocol or “FTP,” Gopher, and the web. A URI as used in typical embodiments of the present invention usually includes an internet protocol address, or a domain name that resolves to an internet protocol address, identifying a location where a resource, particularly a document, a web page, a CGI script, or a servlet, is located on a network, often the Internet. URIs directed to particular resources, such as particular documents, HTML files, CGI scripts, or servlets, typically include a path name or file name locating and identifying a particular resource in a file system connected through a server to a network. To the extent that a particular resource, such as a CGI file, a servlet, or a dynamic web page, is executable, for example to store or retrieve data, a URI often includes query parameters, or data to be stored, in the form of data encoded into the URI. Such parameters or data to be stored are referred to as ‘URI encoded data,’ or sometime as ‘form data.’
“URI encoded data” or “form data” is data packaged in a URI for data communications, a useful method for communicating variable names and values in a data processing system such as the Internet. Form data is typically communicated in hyperlinking protocols, such as, for example, HTTP which uses GET and POST functions to transmit URI encoded data. In this context, it is useful to remember that URIs do more than merely request file transfers. URIs identify resources on servers. Such resources may be files having filenames, but the resources identified by URIs also may include, for example, queries to databases, including queries to search engines according to embodiments of the present invention. Results of such queries do not necessarily reside in files, but they are nevertheless data resources identified by URIs and identified by a search engine and query data that produce such resources. An example of URI encoded data is:












http://www.foo.com/cgi-bin/MyScript.cgi?field1=value1&field2=value2









This example shows a URI bearing encoded data. The encoded data is the string “field1=value1&field2=value2.” The encoding method is to string field names and field values separated by ‘&’ and “=” with spaces represented by ‘+.’ There are no quote marks or spaces in the string. Having no quote marks, spaces are encoded with ‘+,’ and ‘&’ is encoded with an escape character, in this example, ‘%26.’ For example, if an HTML form has a field called “name” set to “Lucy”, and a field called “neighbors” set to “Fred & Ethel”, the data string encoding the form would be:














name=Lucy&neighbors=Fred+%26+Ethel









“URLs” or “Universal Resource Locators” comprise a kind of subset of URIs, such that each URL resolves to a network address. That is, URIs and URLs are distinguished in that URIs identify named objects in namespaces, where the names may or may not resolve to addresses, while URLs do resolve to addresses. Although standards today are written on the basis of URIs, it is still common to such see web-related identifiers, of the kind used to associate web data locations with network addresses for data communications, referred to as “URLs.” This specification uses the terms URI and URL more or less as synonyms.
“WAN” means ‘wide area network.’ One example of a WAN is the Internet.
“WAP” refers to the Wireless Application Protocol, a protocol for use with handheld wireless devices. Examples of wireless devices useful with WAP include mobile phones, pagers, two-way radios, hand-held computers, and PDAs. WAP supports many wireless networks, and WAP is supported by many operating systems. WAP supports HTML, XML, and particularly WML (the Wireless Markup Language), which is a language particularly designed for small screen and one-hand navigation without a keyboard or mouse. Operating systems specifically engineered for handheld devices include PalmOS, EPOC, Windows CE, FLEXOS, OS/9, and JavaOS. WAP devices that use displays and access the Internet run “microbrowsers.” The microbrowsers use small file sizes that can accommodate the low memory constraints of handheld devices and the low-bandwidth constraints of wireless networks.
“WML” stands for ‘Wireless Markup Language,’ an XML language used as a markup language for web content intended for wireless web-enabled devices that implement WAP. There is a WAP forum that provides a DTD for WML. A DTD is an XML ‘Document Type Definition.’
“World Wide Web,” or more simply “the web,” refers to a system of internet protocol (“IP”) servers that support specially formatted, hyperlinking documents, documents formatted in markup languages such as HTML, XML, WML, and HDML. The term “web” is used in this specification also to refer to any server or connected group or interconnected groups of servers that implement a hyperlinking protocol, such as HTTP, WAP, HDTP, or others, in support of URIs and documents in markup languages, regardless whether such servers or groups of servers are connected to the World Wide Web as such.
“XML” stands for ‘eXtensible Markup Language,’ a language that support user-defined markup including user-defined elements, tags, and attributes. XML's extensibility contrasts with most web-related markup languages, such as HTML, which are not extensible, but which instead use a standard defined set of elements, tags, and attributes. XML's extensibility makes it a good foundation for defining other languages. WML, the Wireless Markup Language, for example, is a markup language based on XML. Modern browsers and other communications clients tend to support markup languages other than HTML, including, for example, XML.
Data Processing Systems
Exemplary methods, system, and products for image distribution in data processing systems are now explained with reference to the accompanying drawings, beginning with FIG. 1. FIG. 1 depicts an architecture for a data processing system in which various embodiments of the present invention may be implemented. The data processing system of FIG. 1 includes a number of computers connected for data communications in networks. The data processing system of FIG. 1 includes networks (102, 104). Networks (102, 104) may be connected as LANs, WANs, intranets, internets, the Internet, webs, the World Wide Web itself, or other connections as will occur to those of skill in the art. Such networks are media that may be used to provide data communications connections between various devices and computers connected together within the data processing system.
In FIG. 1, servers 128 and 104 and storage unit 132 connect to network 102. In addition, several exemplary client devices including a PDA 106, a workstation 108, and a mobile phone 110 are connected for data communications to network 102. Network-enabled mobile phone 110 connects to network 102 through wireless link 116, and PDA 106 connects to network 102 through wireless link 114. In the example of FIG. 1, server 128 connects directly to client workstation 130 and network 104 (which may be a LAN). Network 104 incorporates wireless communication links supporting a wireless connection to laptop computer 126. Network 104 also incorporates wireline protocols supporting a wired connection to client workstation 112.
The terms ‘client’ and ‘server’ are used generally to explain data communications according to the exemplary embodiments set forth in this disclosure. This use of the terms ‘client’ and ‘server,’ however, does not exclude peer to peer communications.
The particular servers and client devices illustrated in FIG. 1 are for explanation, not for limitation. Data processing systems useful according to various embodiments of the present invention may include additional servers, clients, routers, other devices, and peer-to-peer architectures, not shown in FIG. 1, as will occur to those of skill in the art. Networks in such data processing systems may support many data communications protocols, such as, for example, TCP/IP, HTTP, WAP, HDTP, and others as will occur to those of skill in the art. Various embodiments of the present invention may be implemented on a variety of hardware platforms in addition to those illustrated in FIG. 1.
FIG. 2 sets forth a block diagram of computing machinery that includes a computer 106, such as a client or server, useful in systems for image distribution in data processing systems according to embodiments of the present invention. The computer 106 of FIG. 2 includes at least one computer processor 156 or ‘CPU’ as well as random access memory 168 (“RAM”). Stored in RAM 168 is an application program 152. Application programs useful in implementing inventive methods of the present invention include servlets and CGI scripts running on servers and data communications programs such as browsers or microbrowsers running on client machines. Also stored in RAM 168 is an operating system 154. Operating systems useful in computers according to embodiments of the present invention include AIXTM, Linux, Microsoft NTTM, and many others as will occur to those of skill in the art.
The computer 106 of FIG. 2 includes computer memory 166 connected through a system bus 160 to the processor 156 and to other components of the computer. Computer memory 166 may be implemented as a hard disk drive 170, optical disk drive 172, electrically erasable programmable read-only memory space (‘EEPROM’ or ‘Flash’ memory) 174, RAM drives (not shown), or as any other kind of computer memory as will occur to those of skill in the art.
The example computer 106 of FIG. 2 includes communications adapter 167 implementing data communications connections 184 to other computers 182, servers, clients, or networks. Communications adapters implement the hardware level of data communications connections through which client computers and servers send data communications directly to one another and through networks. Examples of communications adapters include modems for wired dial-up connections, Ethernet (IEEE 802.3) adapters for wired LAN connections, and 802.11b adapters for wireless LAN connections.
The example computer of FIG. 2 includes one or more input/output interface adapters 178. Input/output interface adapters in computers implement user-oriented input/output through, for example, software drivers and computer hardware for controlling output to display devices 180 such as computer display screens, as well as user input from user input devices 181 such as keyboards and mice.
Receiving and Displaying Images
FIG. 3 sets forth a data flow diagram illustrating an exemplary method for distributing images in a data processing system that includes receiving (304) in a client (302) a data stream (e.g., document 306) for display, the document (306) having markup (308) according to a markup language, the document further having an image group identifier (310) identifying a group of images (312). In the case of the web as a data processing system, receiving a document occurs because a user invokes a hyperlink through a data communications application such as a browser or microbrowser, and the application sends to a server identified in the hyperlink a request message according to a communication protocol supported on the web, such as HTTP, WAP, and so on, receiving in response the document identified in the hyperlink, which typically is a web page (static or dynamically generated on the server) expressed in a markup language such as HTML or WML.
In this example, the document includes an image group identifier (310) identifying a group of images (312). An image group identifier (310) may be included in a document as shown by the <IMGDB> element in the following exemplary markup:












<HTML>









<HEAD>









<TITLE>Business Partner support from IBM PartnerWorld</TITLE>









</HEAD>



<BODY>









<IMGDB









src=“http://www.ibm.com/cgibin/retrieve.cgi?imageGroupID=myGroup”



/>









<table width=“760” border=“0” cellspacing=“0” cellpadding=“0”>



<IMGID src=“myGroup.mast_logo.gif ” border=“0” alt=“IBM” width=“150”



height=“47”/></td>



<td width=“310” class=“tbg”><a href=“#main”>



<IMGID src=“myGroup.c.gif ” border=“0” width=“1” height=“1” alt=“Skip



to main content”/></a></td>



<table border=“0” cellpadding=“0” cellspacing=“0”>



<form name=“Search” method=“get” <input type=“hidden” name=“v”



value=“11” size=“15”/><tr>



<IMGID src=“myGroup.printer.gif ” width=“23” height=“19” alt= “Link to



printable version of page”></td>



<tr valign=“middle”><td>



<IMGID src=“myGroup.pwhome.jpg” width=“610” height=“52” alt=“IBM



PartnerWorld home header graphic” /></td>



<td><input maxlength=“100” class=“input” size=“15” name=“q” value=“”



type=“text”/></td><td>



<IMGID src=“myGroup.fw.gif” width=“16” height=“16” alt=“”/></td>









</BODY>







</HTML>









This example is derived from the prior art example set forth above. This example, however, contains a new markup element: <IMGDB>. The new markup element <IMGDB> represents an instruction to retrieve, during a single communications connection to the server, all images identified by an image group identifier, which is set forth in a ‘src’ attribute in the new markup element shown above. In this example, the image group identifier is URI encoded as “myGroup.”
Because <IMGDB> is new, data communications applications such as browsers or microbrowsers may be adapted to respond to the new element by alterations at the source code level, by use of downloadable plug-ins such as Java applets, other client-side scripting means, or in other ways as will occur to those of skill in the art. The name of the new element <IMGDB> is an example only, not a limitation of the invention. The new element can be named anything, <IMG-DOWNLOAD>, <GET-IMG>, <GET-GROUP>, and so on, as will occur to those of skill in the art, and all such names are well within the scope of the present invention.
The method of FIG. 3 includes retrieving (316) the images, from a server (314) in the data processing system, in dependence upon the image group identifier (310). In typical servers according to the present invention, images are stored in files systems or databases according to their respective image group identifiers. That is, each image is stored in association with an image group identifier so that all images in a group can be retrieved, gathered, and returned at approximately the same time, so long as the server knows the desired image group identifier. Retrieving (316) images in dependence upon the image group identifier (310) therefore is typically carried out by transmitting from the client to a server identified in markup a request message expressed in a data communications protocol and bearing an image group identifier. In the example under discussion, the markup is:












<IMGDB


src=“http://www.ibm.com/cgi-bin/retrieve.cgi?imageGroupID=myGroup”


/>









The target server is identified by the domain name “www.ibm.com;” the protocol is identified as “http;” and the image group identifier is represented as “myGroup.” Retrieving (316) images in dependence upon the image group identifier (310) therefore in this example is carried out by transmitting from a client browser to the server at “www.ibm.com” an HTTP request message bearing the image group identifier URI encoded as “myGroup.” In this example, the request message actually requests the resource identified as “/cgi-bin/retrieve.cgi,” which is a CGI script called by the server that takes a call parameter of an image group identifier, retrieves from a database the images associated with the image group identifier, and returns the images to the calling server, which in turn returns them to the requesting client in an HTTP response message.
The CGI script “retrieve.cgi” is server-side functionality for retrieving images. The use of a CGI script, however, is only for explanation, not a limitation of the invention. On a server supporting IBM's DB2 database management system, server-side functionality for retrieving images may be implemented as a DB2 ‘stored procedure.’ On a Java server, for a further example, server-side functionality for retrieving images can be implemented as a servlet and invoked with a URI such as, for example: src=“http://www.ibm.com/servlets/retrieve?imageGroupID=myGroup”.
Advantageously, all images in the group are returned at approximately the same time, that is, typically through a single request/response sequence. In fact, in many implementations of the method of FIG. 3, retrieving (316) images (312) is carried out by retrieving all images in a group identified by an image group identifier (310) before displaying any of the images. Documents may include more than one markup element requiring an image group, that is, in the current example, more than one <IMGDB> element. In a document having only one <IMGDB> element, however, downloading all images in a group at the same time reduces the HTTP request/response traffic from one round trip per image to one round trip per document.
Typically according to the example of FIG. 3, retrieving (316) the images includes aggregating the images in a data structure on the client. Aggregating images in a data structure on the client may be carried out, for example, by use of an array of structures in C, a two-element container object in C++, a hashtable in Java, and so on as will occur to those of skill in the art. An example of such an aggregation is a table named for an image group identifier, “myGroup,” having two columns, one storing image identifiers and the other storing images:










myGroup










Image IDs
Images







mast_logo.gif
—



c.gif
—



printer.gif
—



pwhome.jpg
—



fw.gif
—










This example, with a table named “myGroup” for an image group identifier and a column containing the image identifiers from the exemplary HTML segment above, supports references to the images of the form: groupImageID.imageID, so that a reference to myGroup.mast_logo.gif may be used by a browser or other communications application to retrieve the first image from the table. A reference to myGroup.c.gif returns the second image in the table, myGroup.printer.gif the third image, and so on. The images in this table are represented by dashes only because in this example the images are like BLOBs, the actual raw binary images themselves, stored in computer memory client-side, ready for display through the browser.
In typical implementations of the method of FIG. 3, the markup (308) includes markup elements that represent instructions to display images at display locations. The markup elements in this example include identifications of images in a data structure on the client, and the method includes displaying (318) the images on the client (302) according to the markup (308). The HTML segment under discussion, for example, contains not only the new markup element <IMGDB>, but another new markup element as well: <IMGID>. The new element <IMGID> represents an instruction to display an image at a display location corresponding to the element's location in the logical structure of a document, that is, the structure provided by the markup itself, HTML tables, HTML paragraph marks, HTML line marks, HTML forms, and so on. The new element <IMGID> includes identifications of images in a data structure on the client. In this example, the identifications of images in a data structure on the client take the form described above: groupImageID.imageID. More particularly, the example HTML segment sets forth five <IMGID> elements:














<IMGID src=“myGoup.mast_logo.gif ” border=“0”



alt=“IBM” width=“150”



height=“47”/>



<IMGID src=“myGoup.c.gif ” border=“0” width=“1”



height=“1” alt=“Skip to



main content”/>



<IMGID src=“myGoup.printer.gif ” width=“23”



height=“19” alt=“Link to



printable version of page”>



<IMGID src=“myGoup.pwhome.jpg” width=“610” height=“52”



alt=“IBM



PartnerWorld home header graphic” />



<IMGID src=“myGoup.fw.gif” width=“16” height=“16”



alt=“”/>









The ‘src’ attributes in these examples, rather than identifying images located in remote file systems on remote servers across a data processing systems as was the case in prior art, now point to images in a data structure on the client machine itself, ready for quick retrieval and display. In the first example <IMGID> element, the attribute src=“myGoup.mast_logo.gif” identifies an image associated with the image identifier “mast_logo.gif” in a data structure on the client named “myGroup.” In the second example <IMGID> element, the attribute src=“myGoup.c.gif” identifies an image associated with the image identifier “c.gif” in a data structure on the client named “myGroup.” In the third example <IMGID> element, the attribute src=“myGoup.printer.gif” identifies an image associated with the image identifier “printer.gif” in a data structure on the client named “myGroup.” And so on.
Storing and Sending Images
FIG. 4 sets forth a data flow diagram illustrating a further exemplary method for distributing images in a data processing system that includes storing 402 images 312 on a server 314 and, in the process of storing the images, associating 404 each image with at least one group of images identified by an image group identifier 412.
In some implementations of the method according to FIG. 4, storing 402 images 312 is carried out by storing images as BLOBs in a database. In such implementations, associating 404 each image with at least one group of images is accomplished by storing an image identifier for each BLOB in association with an image group identifier for each file. In other implementations, storing 402 images is carried out by storing images as files on a file system. In such implementations, associating 404 each image with at least one group of images is accomplished by storing a pathname for each file in association with an image group identifier for each file. Either way, the availability of database management tools, automated queries, inserts, deletions, updates, reports, and so on, substantially eases the administrative burden on the server side and speeds response time with respect to methods of prior art.
Methods for storing (402) images (312) and associating (404) images with groups are further explained with reference to FIG. 5. FIG. 5 sets forth a database relationship diagram illustrating relations among records representing images and groups of images. In the table named “Image Groups” 512, each record represents a group of images, and each record includes an image group identifier 412 and a text description field 514. In the table named “Images” 502, each record represents an image, and each record includes an image identifier 504, typically an identification code implemented as a string such as an image file name or an integer code, for example. The Images table 502 in FIG. 5 also includes images, stored in the table in the form of BLOBs 506. Moreover, the Images table 502 illustrates a further alternative form of image storage in which the images themselves are stored on a file system and the Image table 502 stores, for each image, a pathname specifying where in a file system the image is found in an image file.
A pathname is a sequence of subdirectory names that identifies a file. Every file in a file system typically has a name, called a filename, so the simplest type of pathname is just a filename. When a pathname is specified as only a filename, an operating system looks for that file in a current working directory. If the file resides in a different directory, however, the operating system requires more information to find the file. The additional information is provided by specifying a path that the operating system must follow through a file system to find the file. The pathname always starts from a working directory or from a root directory. Each operating system has its own rules for specifying paths. In DOS, for example, the root directory is named \, and subdirectories are separated in pathnames by additional backslashes. In UNIX, the root directory is named /, and subdirectories are separated in pathnames by additional slashes. In Macintosh operating systems, subdirectories in pathnames are separated by colons.
It is clear to readers of skill in the art that the Images table 502 and the Image Groups table 512 advantageously will have a many-to-many relationship because each image can be in many groups and each group may have many images in it. The many-to-many relationship is advantageous because it helps to ‘normalize’ the database, avoiding storing the same image or the same image group definition more than once. The table named “Junctions” 510 in FIG. 5 is a junction table which, in conjunction with the Images table 502 and the Image Group table 512 implements the many-to-many relationship. The Junctions table 510 contains one record for each combination of image and image group. That is, each record in the Junctions table represents one association of an image and an image group, and each record in the Junction table 510 contains an image identifier 504 and an image group identifier 412. The imageID field 504 in the Junctions table 510 is a foreign key to the Images table 502, forming a one-to-many relationship between the Images table 502 and the Junctions table 510. The groupID field 412 in the Junctions table 510 is a foreign key to the Image Group table 512, forming a one-to-many relationship between the Image Group table 512 and the Junctions table 510. The relationship of the Images table 502 and the Image Groups table 512, therefore, implemented through the Junctions table 510, is many-to-many 516.
The exemplary method of FIG. 4 includes receiving (406) from a client (302) a request (414) for a group of images, the request comprising an image group identifier (310). Receiving a request comprising an image group identifier is typically carried out by receiving in a server, from a client browser, an HTTP request message bearing the image group identifier URI encoded as, for example: “imageGroupID=myGroup.” Such a request message typically originates in a client in response to markup like that illustrated earlier by:












<IMGDB


src=“http://www.ibm.com/cgi-bin/retrieve.cgi?imageGroupID=myGroup”


/>









In this example, as described above, the request message actually requests the resource identified as “/cgi-bin/retrieve.cgi,” a CGI script called by the server that takes a call parameter of an image group identifier (in this case “myGroup”), retrieves from a database or a file system the images associated with the image group identifier, and returns the images to the calling server, which in turn returns them to the requesting client in an HTTP response message.
The method of FIG. 4 further includes retrieving (408) from storage images (416) identified by the image group identifier (310). In typical servers according to embodiments of the present invention, where images are stored as BLOBs in database records, retrieving images is carried out by parsing request messages into database queries, such as, for example:














SELECT imageBLOB FROM images, junctions



WHERE junction.groupID = “myGroup”



AND images.imageID = junctions.imageID;









This is an example SQL query having a form like the following:












SELECT imageBLOB FROM images, junctions


WHERE junction.groupID = “/*insert image group identifier here*/”


AND images.imageID = junctions.imageID;









Given a request message bearing URI encoded image group identifier “myGroup,” parsing the request message includes extracting the image group identifier from the request message and inserting it into the SQL query form. Asserting the example SQL query against a database of the form shown in FIG. 5, extracts from the database all the images in the image group designated as “myGroup.”
The method of FIG. 4 also includes sending (410) the retrieved images to the client. In this example, sending retrieved images is carried out by marshalling them into an HTTP response message and transmitting the response message to the client that requested the images. Advantageously by use of this method, all the images for a document may be sent at the same time through a single data communications connection, such as, for example, a TCP/IP connection, representing a substantial efficiency in use of data communications resources and time as compared with prior art.
FIG. 6 sets forth a data flow diagram illustrating a further exemplary-method for distributing images in a data processing system. The method of FIG. 6 includes storing (402) images (312), receiving (406) requests for images, retrieving (408) images, sending (410) retrieved images, and so on, all as described above regarding the method of FIG. 4.
The method of FIG. 6 further includes associating (418) groups of images with an image retrieval routine (420), wherein retrieving the images is carried out by invoking (422) the image retrieval routine. In typical embodiments, an image retrieval routine is server-side functionality for image retrieval, described above as being implemented as a CGI script, a Java servlet, or a DB2 stored procedure. In such embodiments, associating the groups with the routine is carried out by inserting the script, servlet, or stored procedure name in an HTML document in a markup element established for that purpose, such as, for example, the <IMGDB> element described in detail above. Invoking (422) the routine (420) then is carried out by calling the script, servlet, or stored procedure identified in the request message and handing off the image group identifier as a call parameter to the retrieval routine.
The method of FIG. 6 also includes storing (402) on a server (314) documents comprising markup according to a markup language, wherein each document further includes at least one markup element containing an image group identifier identifying a group of images and markup elements that include identifications of individual images in a data structure on the client and represent instructions to display individual images at particular display locations. In typical embodiments, a markup element containing an image group identifier identifying a group of images is implemented as described above with regard to the exemplary <IMGDB> element. In typical embodiments, markup elements that include identifications of individual images in a data structure on the client and represent instructions to display individual images at particular display locations are implemented as described above with regard to the exemplary <IMGID> element.
Image Distribution for Dynamic Server Pages
Readers of skill in the art will recognize that there are many dynamic server pages in computer storage around the world with prior art image elements in them. A well known example of a prior art image element is the HTML element <IMG>. One way to improve existing dynamic server pages according to embodiments of the present invention is to scan through them with a word processor or an automated tool, replace the image elements with <imgid> elements or their like as described above, associate the images of each dynamic server page as a group identified by an image group identifier, and insert the image group identifier in the dynamic server page. This approach, however, is laborious and prone to error because it is the nature of dynamic server pages that the images to be associated with a particular rendering of a page may change each time the page is requested by a client. It would be advantageous to have improved ways of distributing images for dynamic server pages.
Dynamic server pages are web resources that include dynamic content in addition to static content. Static content is the usual text and markup structuring the text. Dynamic content in the context of this discussion is executable program content generally represented by server-side scripting capabilities. In the case of the World Wide Web, for example, web page content includes the usual static content such as display text and markup tags, and, in addition, executable program content. Executable program content includes, for example, Java, VBScript, CGI gateway scripting, PHP script, and Perl code.
Dynamic content is distinguished from the static content in which it is embedded by markup according to the type of dynamic content. Markup identifying both Java scriptlets in JSP dynamic content and VB scripts in ASP dynamic content, for example, is a standard syntax: <% %>.
The kinds of executable program content supported by any particular dynamic server page depends on the kind of dynamic server page engine that is intended to render the executable program content. For example, Java is typically used in Java Server Pages (“JSPs”) for Java Server Page engines (sometime referred to in this disclosure as “JSP engines”); VBScript is often used in Active Server Pages (“ASPs”) for Microsoft Active Server Page engines (sometime referred to in this disclosure as “ASP engines”); and PHP script, a language based on C, C++, Perl, and Java, is used in PHP pages for PHP: Hypertext Preprocessor engines.
There are several kinds of dynamic server page engines, each of which typically is capable of rendering only one kind of dynamic server page. In each case, the kind of dynamic content rendered by a particular dynamic server page engine is the particular kind of dynamic server page for which the engine was developed in the first place. JSP engines render JSPs. ASP engines render ASPs. PHP engines render PHP pages. And so on.
A web server, upon receiving a request for a particular dynamic server page, sends the dynamic server page to a dynamic server page engine for rendering. The dynamic server page engine ‘renders’ the dynamic server page by executing its executable program content and placing the output from execution of the executable program content in-line, typically on the standard output of the dynamic server page engine, with the static content in which the dynamic content is embedded.
A web server may support many kinds of dynamic server pages. Which is to say that a web server may support a multiplicity of dynamic server page engines, typically one for each kind of dynamic server page supported. Upon receiving a request for a particular dynamic server page, a web server determines which dynamic page engine is to render the dynamic server page by reference to the location of the dynamic server page engine or by reference to the dynamic server page's filename, or, more particularly, to the filename's extension. A URI requesting:















http://www.foo.com/cgi-bin/someCGIScript.cgi,










for example, is directed to a CGI engine (“a Common Gateway Interface”) because the dynamic server page someCGIScript.cgi is located in a subdirectory /cgi-bin/ known to house CGI scripts or because the filename extension ‘cgi’ identifies someCGIScritp.cgi as a CGI script. Similarly, a URI requesting:
















http://www.foo.com/jspPages/someJSPPage.jsp










is sent for rendering to a JSP engine because it is located in the JSP subdirectory /jspPage/ or because of its filename extension ‘jsp.’ Similarly, the dynamic server page identified by this URI:
















http://www.foo.com/aspPages/someASPPage.asp










is sent to an ASP engine, and the dynamic server page identified by this URI:
















http://www.foo.com/phpPages/somePHPPage.php










is sent to a PHP engine.

FIG. 7 illustrates a computing architecture in which improved methods of image distribution for dynamic server pages may be implemented. The architecture of FIG. 7 includes a web server 314 that stores images 312 associated with a dynamic server page 808. The dynamic server page 708 includes image resource locators 710 associating the dynamic server page 708 with the images 312. An example of an image resource locator is shown by the following HTML image element:












<img src=“//www.ibm.com/i/v11/m/en/mast_logo.gif” border=“0”,









where the ‘src’ attribute's value, “//www.ibm.com/i/v11/m/en/mast_logo.gif,” is a URI identifying the storage location of an image file named ‘mast_logo.gif.’ The image so represented is associated with the dynamic server page by the <img> element setting forth in the dynamic server page the storage location of the image. Associated images may be stored on server 314 or at other storage locations in cyberspace.

The architecture of FIG. 7 includes dynamic server page engines 724. Server 314 is connected through network 318 to client 302. Server 314 typically receives from client 302 requests for dynamic server pages. Such requests arrive, for example, in the form of HTTP request messages, WML request messages, HDML request messages, and so on. When server 314 receives a request for a dynamic server page 708, as described above, server 314 determines which of the dynamic server page engines 724 is to render the dynamic server page and sends the dynamic server page to that engine for rendering. Server 314 receives back from the selected dynamic serve page engine 724 the dynamic serve page content as rendered 720. The dynamic server page content as rendered is the original static content including insertions of rendered dynamic content, the output of executing the dynamic content. Server 314 then returns the dynamic server page content as rendered to the requesting client 302.
FIG. 8 sets forth a data flow diagram illustrating a method for distributing images in a data processing system that includes receiving 702 a request 704 for a dynamic server page 708. The dynamic server page 708 has a multiplicity of associated images 312. Each image associated with the dynamic server page 708 in the sense that each image's storage location is identified in the dynamic server page by an image resource locator 710. The image resource locator 710 typically is represented in the dynamic server page by a URI in an image markup element, such as, for example, the HTML <IMG> element.
In the example of FIG. 8, the request 704 is an HTTP request message from a client 302. The request message implements a URI 706 identifying the requested dynamic server page 708. Server 314 sends the dynamic server page 708 to a dynamic server page engine 712 where it is rendered 711 into dynamic server page content as rendered 720.
The method of FIG. 8 also includes inserting in the dynamic server page an image group identifier for the images. Image group identifiers, as described in more detail above, are data elements representing identifications codes for groups of images, such as, for example, the imageID at reference 504 in the example data structures of FIG. 5. Inserting 714 an image group identifier 712 typically includes inserting a markup element that includes the image group identifier, where the markup element represents an instruction to a client to retrieve, during a single communication connection to the server, all images identified by the image group identifier. Such a markup element may be represented, for example, as:












<IMGDB


src=“http://www.ibm.com/cgi-bin/retrieve.cgi?imageGroupID=myGroup”


/>









In this example, as described above, the request message actually requests the resource identified as “/cgi-bin/retrieve.cgi,” a CGI script called by the server that takes a call parameter of an image group identifier (in this case “myGroup”), retrieves from a database or a file system the images associated with the image group identifier, and returns the images to the calling server, which in turn returns them to the requesting client in an HTTP response message.
Although inserting 714 the image group identifier 712 may be implemented as a literal insertion in the dynamic server page itself, the image group identifier is preferably inserted in the dynamic server page content as rendered. It is an advantage of typical embodiments of the present invention that their operations may be transparent to the structure and operation of underlying dynamic server pages. So the underlying pages themselves are preferably left undisturbed, and image group identifiers are inserted in dynamic server page content as rendered 720 by a dynamic server page engine 712.
The method of FIG. 8 also includes inserting 714 in the dynamic server page client data names 718 for the images. Client data names for the images are data element names for client-side storage locations for the images, storage in client-side computer memory. Inserting 716 client data names 718 typically includes inserting in the dynamic server page content as rendered 720 markup elements representing instructions to display the images at client display locations. As explained in more detail above, such markup elements may be represented as:















<IMGID src=“myGoup.mast_logo.gif ” border=“0”



alt=“IBM” width=“150”



height=“47”/>.










The ‘src’ attributes in this example, rather than identifying images located in remote file systems on remote servers across a data processing systems as was the case in prior art, now points to an image in a client-side data structure. In this example <IMGID> element, the attribute src=“myGoup.mast_logo.gif” identifies an image associated with the image identifier “mast_logo.gif” in a client data structure named “myGroup.”
In many embodiments according to the present invention, inserting 716 a client data name 718 for each image is carried out by replacing the image resource locators with client data names. Consider the following example of dynamic server page content as rendered:















<HTML>









<HEAD>









<TITLE>Business Partner support from IBM



PartnerWorld</TITLE>









</HEAD>



<BODY>









<img src=“//www.ibm.com/i/v11/m/en/mast_logo.gif”









clientDataName=“clientImages.image1”>









<img src=“//www.ibm.com/i/c.gif”>









clientDataName=“clientImages.image2”>









<img src=“http://t1d.www-1.cacheibm.com/printer.gif”>









clientDataName=“clientImages.image3”>









</BODY>









</HTML>










In this example, client data names ‘image1,’ ‘image2,’ and ‘image3’ in a client-side data structure named ‘clientImages’ have been inserted in the dynamic server page content as rendered. The insertions are in the standard HTML image element <img>. The insertions are implemented, however, with a new markup attribute name ‘clientDataName.’ This approach leaves the standard markup element in place and adds a new attribute that may be used by improved browsers to retrieve the images from client-side storage while being ignored by prior art browsers. Alternatively, the prior art image elements may be replaced entirely by new elements, as shown here:















<HTML>









<HEAD>









<TITLE>Business Partner support from IBM



PartnerWorld</TITLE>









</HEAD>



<BODY>









<imgid src= “clientImages.image1”/>



<imgid src=“clientImages.image2”/>



<imgid src=“clientImages.image3”/>









</BODY>









</HTML>










In this example, the prior art HTML image elements <img> are replaced entirely with new <imgid> elements and the prior art ‘src’ attribute is modified in usage to identify a client-side storage location of an image rather than setting forth a URI to an image as in prior usage. In addition to the methods described here, other methods of inserting in dynamic server pages client data names for images will occur to those of skill in the art, and all such methods are well within the scope of the present invention.
Although inserting 716 the client data names 718 may be implemented as a literal insertion in the dynamic server page itself, the client data names are preferably inserted in the dynamic server page content as rendered. Inserting the client data names directly into dynamic server pages as such would be prone to error because the images to be associated with a particular rendering of a page may change each time the page is requested by a client. In typical embodiments of the present invention, therefore, client data names 718 for images preferably are inserted in the dynamic server page content as rendered by a dynamic server page engine 712.
The method of FIG. 8 includes returning 722 to the requesting client 302 the dynamic server page content as rendered 720, including the image group identifier and a multiplicity of client data names, one for each image associated with the dynamic server page content as rendered. The client, in the process of displaying the dynamic server page content as rendered, which now appears to the client as a markup document, notes the image group identifier and sends a request for the image group.
Processing from the server's point of view then proceeds as explained above in connection with FIG. 4. That is, the method includes receiving 406 from the client 302 the request 414 for a group of images, where the request includes the image group identifier 310. The request itself is implemented as a communications protocol message, such as, for example, an HTTP request message. The method includes retrieving 408 from storage the images 312 identified by the image group identifier 310. The method also include sending 410 the retrieved images 416 to the client 302.
The method of FIG. 8 includes storing 726 the images as a group 728 on a server. In typical embodiments, storing the images as a group includes storing with the images an image group identifier, a dynamic server page name, and client data names for the images. As described above, the images may be stored as BLOBs in a database system that supports BLOBs, or the images may be stored as image files in a file system with their pathnames databased in association with image identification codes, all as shown, for example, in the exemplary data structures of FIG. 5. The structures of FIG. 5 include storage for an image group identifier 412, a dynamic server page name 550, and a client data name for each image 552. Storing a dynamic server page name 550 with the image group 512 enables a server according to embodiments of the present invention to determine, upon subsequent requests for a particular dynamic server page, whether a group of image for that dynamic server page has been stored previously. If a group of images for that dynamic server page has been stored previously, then the efficiency of the process of storing a group of images for that dynamic server page may be improved despite the fact that the exact same group of images may not be stored due to the dynamic nature of dynamic server pages.
It will be understood from the foregoing description that modifications and changes may be made in various embodiments of the present invention without departing from its true spirit. The descriptions in this specification are for purposes of illustration only and are not to be construed in a limiting sense. The scope of the present invention is limited only by the language of the following claims.

## Claims

1. A method for distributing images in a data processing system, the method comprising:
receiving a request for a dynamic server page having a multiplicity of associated images, each image having a storage location identified in the dynamic server page by an image resource locator;
inserting in the dynamic server page an image group identifier for the images;
inserting in the dynamic server page client data names for the images;
receiving from the client a request for a group of images, wherein the request comprises the image group identifier;
retrieving from storage the images identified by the image group identifier; and
sending the retrieved images to the client.

2. The method of claim 1 wherein inserting an image group identifier comprises inserting a markup element that includes the image group identifier, wherein the markup element represents an instruction to retrieve, during a single communication connection to the server, all images identified by the image group identifier.

3. The method of claim 1 wherein inserting client data names further comprises inserting in the dynamic server page content as rendered markup elements representing instructions to display the images at client display locations.

4. The method of claim 1 further comprising storing the images as a group on a server, including storing with the images an image group identifier, a dynamic server page name, and client data names for the images.

5. The method of claim 1 wherein inserting a client data name for each image further comprises replacing the image resource locators with client data names

6. The method of claim 5 wherein the image resource locators are set forth in HTML <img> elements in the dynamic server page and replacing the image resource locators with client data names includes replacing the <img> elements with markup elements comprising the client data names.