24.1. What Is PDE Build?At its heart, PDE Build is an Ant script generator. It takes in a collection of plug-ins and features, their manifests and build.properties files, and generates a set of Ant build scripts. These scripts are run to produce a build. The export operations you have been doing throughout this book use PDE Build under the covers. PDE Build is quite flexible. It can consume hybrid mixes of plug-ins and features that are pre-built and those that remain to be built. Some may be included in the final output, while others may not. The output of a build can also vary from plug-ins in directories to update sites and Zip archives of JAR'd and signed plug-ins and features. The build mechanism builds plug-ins and features, or cascades of the transitively included features and plug-ins starting at a root feature. Cross-platform building is also supported. The main benefit of PDE Build is that it brings all this together into one relatively simple process. Developers express their normal runtime dependencies in manifest files and a mapping from development time structure to runtime structure in the feature and plug-in build.properties files. PDE Build does the rest. Key to this process is the automatic generation of the build scripts. Using the input manifests and build.properties, PDE generates Ant scripts that copy identified files and compile identified code using a classpath derived by effectively flattening the plug-in dependency graph. The runtime classpath for a plug-in is defined as a complex graph of plug-in dependencies as described in its manifest file. The classes referenced at runtime are also needed at compile-time, so the compile-time classpath is similarly complex. PDE Build uses the Runtime's plug-in resolution and wiring mechanisms to derive the classpath for each plug-in being built. As we mentioned above, you have already been using PDE Build if you followed along with the feature- or product-exporting examples. When you use these actions, you are under the covers, running PDE Build. The rest of this chapter explores the use of PDE Build in a release engineering setting, where reproducibility and automation are key concerns. |
Wednesday, October 21, 2009
Section 24.1. What Is PDE Build?
Section 22.3. Distributed Builds
22.3. Distributed BuildsIf you have a large project and more than one Macintosh at your disposal, you can see dramatically shorter build times with distributed builds. A Macintosh can volunteer idle time for distributed builds by opening the Distributed Builds panel of the Preferences window (Figure 22.1) and checking the first checkbox in the panel. Xcode processes on other computers or even the same computer can then send portions of their builds to the volunteer for compilation. The volunteer can choose to give the distributed-build background process low, medium, or high priority. Figure 22.1. The Distributed Builds panel of the Xcode Preferences window. The upper checkbox makes this machine available to others for compiling modules. The lower checkbox makes this machine a host for distributed builds, either on every machine that advertises itself on the local Bonjour net as a distcc node or on only those listed machines you mark as trusted.[View full size image] If you want to take advantage of distributed builds, check the second checkbox in the Distributed Builds panel of the Preferences window. The list below the checkbox will then fill with the names of all the local net's computers that are advertising via Bonjour (formerly Rendezvous) that they can take distributed builds. You can choose to distribute work to all comers or only to the machines you indicate in the list are trusted. Each machine participating in a distributed build must be running the same architecture and the same versions of Mac OS X, gcc, and Xcode. Xcode need not be running on the distributed machines. No matter what your Distributed Builds settings, some tasks are always done on the home machine of the build. In particular, the home machine builds precompiled headers and does preprocessing before sending out compilation units. Because the home machine has work to do that no other machine can, it is wisest not to enable the local machine as sharable for distributed builds. Distributed compilation can't benefit from more than about six remotes; beyond that point, the local machine is spending all its time assembling preprocessed compilands for the remotes and becomes the limiting factor. Remember that distributing the source and getting the compiled objects back takes time. Distributed builds may be a net loss in productivity if you use it on a network of less than 100Mb/second capacity. This rules out wireless and 10Base-T networks. If you are dealing with a firewall, be sure that it passes the distributed-build ports of 3632 and 7264. |
26.5 OpenGL in the Pop Framework
| [ Team LiB ] |
26.5 OpenGL in the Pop FrameworkLook back at the code for CPopView::OnDraw(CDC* pDC)
|
| [ Team LiB ] |
Section 10.5. XSLT Concepts
10.5. XSLT ConceptsWhen developing an XSL style sheet, I usually find myself using only two of the XSL functions shown earlier: the key() function and the generate-id() function, both of which are indispensable when doing something unique to XSL style sheets. I am referring to something called Muenchian grouping. Muenchian grouping, invented by Steve Muench, the XML Evangelist of the Oracle Corporation, is a method of grouping nodes based upon their values. Although I can describe how it works, it is probably a better idea to take a look at the example of Muenchian grouping shown in Listing 10-13. After that, we take it apart to see how it works. Listing 10-13. A Muenchian Grouping Example
The element that starts the whole ball rolling is the key element, which creates a cross-reference based upon the node specified by the use attribute. Using the series element as the key results in an index consisting of The Lord of the Rings and Lord Darcy, with the book The Way Station left out because its series element is null. This cross-reference is accessed using the key function, which accepts two parameters: the name from the key element and the node. Another function that plays an integral part in Muenchian grouping is the generate-id function. This function, well, generates a unique ID for every node in an XML document every time that the document is processed. So the XPath statement //book[generate-id(.) = generate-id(key('keyBook',series)[1])] locates the first element with each unique key from the cross-reference and applies the matching template. The matching template then uses the unique series to select the matching elements. It is all pretty basic XSLT and XPath stuff, although it does have a tendency to make grown men whimper like little scared puppies. If it doesn't, here is one that will put someone over the edge: Imagine trying to group based upon multiple criteria, such as author and series. Although it isn't done very often, and you'll probably never have to do it, I'll give you a hint: Concatenate the elements using the concat function. |
Initialization
InitializationIn the last section, you introduced the numberOfStudents field and initialized it to 0. This initialization is technically not requiredint fields are initialized to 0 by default. Explicitly initializing a field in this manner, while unnecessary, is useful to help explain the intent of the code. For now, you have two ways to initialize fields: You can initialize at the field level or you can initialize in a constructor. You could have initialized numberOfStudents in the CourseSession constructor:
There is no hard-and-fast rule about where to initialize. I prefer initializing at the field level when possiblehaving the initialization and declaration in one place makes it easier to follow the code. Also, as you will learn later in this lesson, you can have more than one constructor; initializing at the field level saves you from duplicate initialization code in each constructor. You will encounter situations where you cannot initialize code at the field level. Initializing in the constructor may be your only alternative. |
Hour 8
Hour 8
| 1: | Why would you want to include a .resx file in your project rather than just including the already compiled .resources file? |
| A1: | In case you need to make changes to the resources contained within the .resx file. You can't make changes to a compiled .resources file. |
| 2: | What is an advantage of using managed resources compared to unmanaged resources? What are some disadvantages? |
| A2: | Managed resources are handled by the common language runtime and thus gain all the advantages that it entails. However, there is currently more work that needs to be done to Visual C++ .NET to make working with managed resources easier. |
| 3: | Can you use the GetObject function within the ResourceManager class to retrieve a string resource? |
| A3: | Yes, you can. The GetString function is just a modified GetObject call that automatically performs the cast from the Object type to the String object. You can call GetObject and cast to a String object to retrieve a string resource. |
| Top |
Digital Game Spaces
< Day Day Up > |
Digital Game Spaces
Although games have been played in real-world spaces for millennia, the appearance of electronic and digital games in the last few decades have provided new kinds of game spaces: playgrounds that exist only on the screens of computer monitors and televisions. These game spaces take a multitude of forms, from blocky 2D grids to expansive 3D worlds. One useful taxonomy for describing the range of these digital spaces comes from Mark J. P. Wolf, in his essay "Space in the Video Game." Wolf lists eleven ways that video games operate to structure and represent space. We paraphrase these categories below, with examples from Wolf's essay:
Text-only space: text adventure games such as Zork and Planetfall
One contained screen: Pong, Space Invaders, Breakout
One screen with wraparound: Asteroids, Pac-Man (with teleporter wraparound)
Scrolling on one axis: Defender, Atari's Football arcade game
Scrolling on two axes: Gauntlet, Sim City
Adjacent spaces displayed one room at a time: Berzerk, Atari's Adventure
Scrolling with separate background layers: Zaxxon, Double Dragon
Limited 3D space: Tempest, Night Driver
Two spaces on one screen or two separate screens: Spy vs. Spy, Dactyl Nightmare
Full 3D spaces: Battlezone, DOOM, Tomb Raider
"Mapped" Spaces: Defender, Myst (both have a separate radar or map display) [9]
Wolf 's categories are not without some conceptual problems. For example, there is a fundamental difference between a "two-and-a-half" dimensional space like DOOM and a more fully 3D space like Tomb Raider (in DOOM the player can only move in two dimensions and the objects are completely flat). Additionally, some of his categories, such as separate background scrolling layers and "mapped" spaces, seem to be fuzzier designations (most of the categories he lists could also incorporate a "map" element). Wolf's typology is certainly not the only way to conceptualize digital game spaces, but his categories are useful in pointing out the wealth of forms they take.
Zork: Text-only space
The structure of a digital game space always grows directly from the formal system that defines the game. However, the space that a player experiences is also a function of representation (how the space is displayed to the player) and interaction (how a player navigates through the space). These three ele-ments—formal structure, structure of display, and interactive structure—together constitute the experience of a digital game space. All three of them need to be designed in concert to achieve proper narrative effect in your game.
For example, the feeling of zero-G drift in Asteroids is linked directly to the design of the game space. Rather than bouncing off the screen wall like a Pong ball, the player's ship moves right on through to the other side, evoking the illusion of endless movement through the darkness of space. The game's style of movement, emphasizing inertial drift and retro-rocket maneuvers, also heightens the feeling of space travel. Although the player's ship never leaves the screen, at the beginning of each wave, asteroids drift in from the edges. Once they appear, these asteroids follow the same wraparound logic as the player's ship. Other objects, such as the UFO saucers, don't ever wrap around, and simply disappear once they reach the edge of the screen. Curiously, these inconsistencies never break the game's spatial continuity. The fact that some objects remain constantly on screen (the player's ship and existing asteroids) whereas others seem to drift in from parts unknown (new asteroids and UFOs), adds up to a rich and multi-layered narrative of cosmic exploration and survival. Space creates narrative in all senses of Miller's definition: space helps define the "characters"(the game objects); space is the context in which narrative events occur; and space patterns narrative experience over time for the player.
Asteroids: One screen with wraparound
Tempest: Limited 3D space
Tomb Raider: Full 3D space
Double Dragon: Scrolling with separate background layers
Spy vs. Spy: Two spaces on one screen
Defender: "Mapped" space
The design of a game space creates a context for narrative interaction, by structuring events in patterns of space, time, and causality. As Marsha Kinder notes in Playing with Power in Movies, Television, and Video Games, " Narrative creates a context for interpreting all perceptions. Narrative maps the world and its inhabitants, including one's own position within that grid."[10] The narrative play of games is always connected to an underlying grid of possibility, to goals and conflict, to uncertainty and the moment-to-moment action of the core mechanic. The space of a game is quite literally its space of play.
In a fighting game such as Tekken, the space is tightly constrained, crowding the two fighters up against each other. There is nowhere to run and nowhere to hide. All you can do is fight your opponent, an action the design of the space explicitly encourages and facilitates. In contrast, the corridors and rooms of a Quake deathmatch space create a narrative of stealthy maneuvers, mad dashes to grab power-ups, and the surprise of sudden death. Tekken has no hidden spatial information. But in Quake, walls block players from seeing each other, dark lighting makes hiding in shadows possible, and the periodically appearing power-ups create uncertainty about when and where they can be found. In both Tekken and Quake, a player's "position on the grid," as Kinder puts it, is simultaneously a location in the space of the game and a position within the space of the game narrative. The formal, represented, and interactive spaces of games are also narrative spaces, contexts for interpreting the experience of a game as a story.
When we frame experience as narrative, the events and actions of game play take on form and meaning within the game's representational universe. The dynamic properties of the space of Tekken and Quake are important in creating emergent narratives of conflict. But the spaces contain embedded narrative qualities as well. In Quake, the spaces embody the sets, props, and characters of pulp sci-fi horror. In Tekken, as with most fighting games, each arena is thematically linked to one of the game's characters. Space can therefore be used to express information about a character's persona or backstory, or to create narratives about defending one's home turf or invading an enemy's territory.
[9]Mark J. P. Wolf, "Space in the Video Game." In The Medium of the Video Game, edited by Mark J. P. Wolf (Austin: University of Texas Press, 2002), p.53-70
[10]MarshaKinder, Playing with Power in Movies, Television, and Video Games: From Muppet Babies to Teenage Mutant (Los Angeles: University of California Press, 1993), p. 2.
< Day Day Up > |
Recipe 2.4. Using Multiple Struts Configuration Files
Recipe 2.4. Using Multiple Struts Configuration FilesProblemYou want to break SolutionSplit your monolithic struts-config.xml into Example 2-9. Multiple config files (single module)<servlet> When the ActionServlet is loaded, Struts will DiscussionFor anything other than the most trivial applications, the Struts 1.1 introduced support for multiple configuration files. Each Just because you are using multiple configuration files Example 2-10. Multiple config files (multiple modules)<servlet> If you are doing team development, consider splitting your See AlsoRecipe 2.5 details the nuances of using |
Section 23.3. IP Statistics
23.3. IP StatisticsThe Linux kernel keeps several sets of statistics about different events and conditions that can be useful for accounting, debugging, or confirming compatibility with standards. In this chapter, we will only briefly see what statistics are kept by the IP protocol layer (without touching on the SNMP infrastructure) and how they are updated. In previous chapters, especially when describing the various functions, we saw a few cases where macros such as IP_INC_STATS were used to update the value of some counters. Let's start with the data structure that contains all of the counters associated with the IP protocol. It is called ip_statistics and is defined in net/ipv4/ip_input.c. It is a vector with two pointers, each one pointing to a vector of ipstats_mib[*] structures (defined in include/net/snmp.h), one per CPU. The allocation of such vectors is done in init_ipv4_mibs in net/ipv4/af_inet.c.
The ipstats_mib structure is simply declared as an array of unsigned long fields of size _ _IPSTATS_MIB_MAX, which happens to be the size of the IPSTATS_MIB_XXX enumeration list in include/linux/snmp.h. Here is the meaning of the IPSTATS_MIB_XXX values, classified into four groups. For a more detailed description, you can refer to RFC 2011 for IPv4 and RFC 2465 for IPv6. The IPSTATS_MIX_XXX counters that are not used by IPv4 (with the exception of IPSTATS_MIB_INADDRERRORS) are not defined in RFC 2011.
The values of these counters are exported in the /proc/net/snmp file. Each CPU keeps its own accounting information about the packets it processes. Furthermore, it keeps two counters: one for events in interrupt context and the other for events outside interrupt context. Therefore, the ip_statistics array includes two elements per CPU, one for interrupt context and one for noninterrupt context. Not all of the events can happen in both contexts, but to make things easier and clearer, the vector has simply been defined of double in size; those elements that do not make sense in one of the two contexts are simply not to be used. Because some pieces of code can be executed both in interrupt context and outside interrupt context, the kernel provides three different macros to add an event to the IP statistics vector:
The first can be used in either context, because it checks internally whether it was called in interrupt context and updates the right element accordingly. The second and the third macros are to be used for events that happened in and outside interrupt context, respectively. The macros IP_INC_STATS, IP_INC_STATS_BH, and IP_INC_STATS_USER are defined in include/net/ip.h, and the three associated SNMP_INC_XXX macros are defined in include/net/snmp.h. |
22.9. Wrap-Up
|
11.1 Introduction
| [ Team LiB ] |
11.1 IntroductionAll the examples so far in this text have used numeric addresses for the hosts (e.g., 206.6.226.33) and numeric port numbers to identify the servers (e.g., port 13 for the standard daytime server and port 9877 for our echo server). We should, however, use names instead of numbers for numerous reasons: Names are easier to remember; the numeric address can change but the name can remain the same; and with the move to IPv6, numeric addresses become much longer, making it much more error-prone to enter an address by hand. This chapter describes the functions that convert between names and numeric values: gethostbyname and gethostbyaddr to convert between hostnames and IPv4 addresses, and getservbyname and getservbyport to convert between service names and port numbers. It also describes two protocol-independent functions: getaddrinfo and getnameinfo, which convert between hostnames and IP addresses and between service names and port numbers. |
| [ Team LiB ] |
The Java Way of File Operations
| I l@ve RuBoard |
The Java Way of File OperationsInterfaces and classes for dealing with files and other I/O types are in the java.io package. An interface is a class that contains abstract methods. Classes in java.io form a class hierarchy. The two main class types in java.io are text oriented (character streams) and binary oriented (byte streams). Subclasses of the Reader and Writer classes are text oriented; those of the InputStream and OutputStream classes are binary oriented. InputStream and OutputStream are abstract; that is, they can't be instantiated directly. To use an abstract class you must subclass it and instantiate the subclass. The subclasses of InputStream and OutputStream allow the reading of binary data to and from various types of input and output such as byte arrays (memory), files, and even network sockets. Streams can be chained to provide extra functionality. For example, you can buffer a FileInputStream by chaining it to a BufferedInputStream Then you can chain the BufferedInputStream to an ObjectInputStream to read in whole objects at one time. (This is similar to the pickle functionality in Python.) Java 1.1's binary data input streams are complemented by somewhat equivalent text input streams. The parents of these classes are the abstract classes Reader and Writer. Having an equivalent set of text-oriented character stream classes allows the conversion of Unicode text. Readers and Writers, like streams, can be chained together. For example, you can buffer a FileReader by chaining it to a BufferedReader. (Buffering will be explained shortly.) I/O Classes to Be CoveredThere are more than thirty I/O classes, not including interfaces and abstract classes. This seems like a lot, but if you understand how Reader, Writer, InputStream, and OutputStream work, you can easily understand the rest. Reader and Writer subclasses deal with character streams, that is, text. InputStream and OutputStream subclasses deal with binary streams. An easy way to remember this is, if you can read it, use Reader and Writer; if you can't, use InputStream and OutputStream.
|
| I l@ve RuBoard |
Creating the User Module
Creating the User Module
The user module of the online discussion forum application allows end users to view and post discussions. The user module contains three files: UserPage.jsp, AddDiscussion.jsp, and ViewDiscussion.jsp.
Creating the UserPage.jsp File
The UserPage.jsp file of the application provides links that allow an end user to post a new discussion or view the existing discussion topics.
Listing 7-10 shows the content of the UserPage.jsp file:
Listing 7-10: The UserPage.jsp File
<%@page import="TxtConverter.*"%>
<%
/*Call the constructor of DisplayString by passing the value of query parameter, lang*/
DisplayString ds=new DisplayString((session.getAttribute("lang1")).toString());
%>
<html>
<html>
<head>
<meta http-equiv="Content-Language" content="en-us">
<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
<title>User Options</title>
</head>
<body>
<!--Display banner heading using getHeading() method of DisplayString class-->
<center><h1 class="style1"><span class="style1"><font
color="#E24907"><%= ds.getHeading()%></font> </h1></center>
<p> </p>
<!--Display page name using getUserOption() method of DisplayString class-->
<p align="center"><b><font face="Arial" size="5" color="#0000FF"><%=
ds.getUserOption() %> </font></b></p>
<table border="0" width="215" cellspacing="0" cellpadding="0" height="1">
<tr>
<!--Display user ID label using getUser() method of DisplayString class-->
<td width="95" bgcolor="#FFFFFF" height="1"><div align="center"><font
color="#FF0000"><b><%= ds.getUser() %>
</b></font></div></td>
<td width="104" bgcolor="#FFFFFF" height="1">
<div align="left"></div>
<!--Display user ID value from session-->
<div align="center"><font
color="#FF0000"><%=session.getAttribute("userid")%></font></div></td>
</tr>
</table>
<div align="justify">
<table border="0" cellpadding="0" cellspacing="0" width="200" style="position: absolute; left: 653px; top: 128px;
width: 259px" >
<tr>
<!--Display logout hyperlink-->
<td height="18" bgcolor="#FFFFFF"><div align="center"><font
color="#FFFFFF"><b><a href="DoLogout.jsp"><%=
ds.getLogout()%></a></b></font></div></td>
</tr>
</table>
</div>
<p align="center"> </p>
<div align="justify">
<table border="0" cellpadding="0" cellspacing="0" width="300" style="position: absolute;
left: 322px; top: 248px; width:
300">
<tr>
<!--Display text for hyperlink to AddDiscussion.jsp using getNewDiscussion() method of
DisplayString class-->
<td bgcolor="#FFFFFF"><div align="center"><i><b><a
href="AddDiscussion.jsp"><%= ds.getNewDiscussion() %>
</a></b></i></div></td>
</tr>
<tr>
<!--Display text for hyperlink to ViewDiscussion.jsp using getViewDiscussion() method of
DisplayString class-->
<td bgcolor="#FFFFFF"><div align="center"><i><b><a
href="ViewDiscussion.jsp"><%= ds.getViewDiscussion()%>
</a></b></i></div></td>
</tr>
</table>
</div>
</body>
</html>
Download this listing.
The above code creates the UserPage.jsp file. This code retrieves the value of the String, lang1, which represents an end user country stored in session, to create an object of the DisplayString class. The code calls the methods of the DisplayString class to provide the user interface. The user interface displays hyperlinks to access the AddDiscussion.jsp and ViewDiscussion.jsp files.
Figure 7-7 shows the user interface of the UserPage JSP in French:
Figure 7-7: User Interface of UserPage JSP in French
Creating the AddDiscussion.jsp File
The AddDiscussion JSP page provides fields that accept end user information about a new discussion. This information is stored in the discussionlist.xml file.
Listing 7-11 shows the content of the AddDiscussion.jsp file:
Listing 7-11: The AddDiscussion.jsp File
<!--Import the necessary packages-->
<%@page import="javax.xml.parsers.*, java.net.*, java.io.*, java.util.*, org.w3c.dom.*"%>
<%@page
import="javax.xml.transform.Transformer, javax.xml.transform.TransformerFactory,javax.xml.
transform.TransformerException"%>
<%@page
import="javax.xml.transform.TransformerConfigurationException,
javax.xml.transform.dom.DOMSource, javax.xml.transform.stream.StreamResult"%>
<%@page import="javax.xml.transform.OutputKeys"%>
<%@page import="TxtConverter.*"%>
<%!String discussionpath;%>
<%
/*Call the constructor of DisplayString by passing the value of query parameter, lang*/
DisplayString ds=new DisplayString((session.getAttribute("lang1")).toString());
%>
<html>
<%
/*Retrieve category, sub category, and discussion content from request object*/
String tempCategory, tempSubCategory,tempDiscussion,tempuser;
tempCategory=request.getParameter("txtCategory");
tempDiscussion=request.getParameter("txtDiscussion");
tempSubCategory=request.getParameter("txtSubCategory");
if(!(tempCategory == null || tempDiscussion == null ||tempSubCategory == null))
{
try{
/*Create a URL object to load properties file*/
URL url=new URL("http://127.0.0.1:8080/seven/path.properties");
/*Open URL connection*/
URLConnection ucon=url.openConnection();
/*Retrieve the discussionlistpath property*/
Properties prop = new Properties();
prop.load(ucon.getInputStream());
discussionpath = prop.getProperty("discussionlistpath");
}
catch(Exception ex)
{
ex.printStackTrace();
}
/*Obtain a DocumentBuilder object by calling the newInstance()method*/
DocumentBuilderFactory docbfact = DocumentBuilderFactory.newInstance();
/*Call the newDocumentBuilder() method to obtain a DocumentBuilder object*/
DocumentBuilder docb = docbfact.newDocumentBuilder();
/*Parse the discussionlist XML document*/
Document doc = docb.parse(new FileInputStream(discussionpath));
/*Obtain Element object that represents the root element of an XML document*/
Element doce = doc.getDocumentElement();
/*Create a new child element*/
Element newe = doc.createElement("query");
/*Obtain user ID from session*/
tempuser=session.getAttribute("userid").toString();
/*Set category, sub category, discussion, and user ID values as attributes to the query Element*/
newe.setAttribute("Category", tempCategory);
newe.setAttribute("Discussion", tempDiscussion);
newe.setAttribute("user",tempuser);
newe.setAttribute("SubCategory", tempSubCategory);
/*Append query Element to root Element*/
doce.appendChild(newe);
/*Obtain a TransformerFactory object*/
TransformerFactory tFactory = TransformerFactory.newInstance();
/*Create a Transformer object*/
Transformer transformer = tFactory.newTransformer();
/*Set output property of Transformer object*/
transformer.setOutputProperty(OutputKeys.INDENT,"yes");
/*Create a DOMSource that acts a transformation source*/
DOMSource source = new DOMSource(doc);
/*Create a StreamResult object that represents a stream to the XML document and acts as the
/*destination of the transformation*/
StreamResult result = new StreamResult(new PrintStream(new
FileOutputStream(discussionpath)));
/*Perform the transformation to transform the document object tree to the XML document*/
transformer.transform(source, result);
}
%>
<!--Display banner heading using resource bundle-->
<Center><H1 class="style1"><font color="#E24907"><%=
ds.getHeading()%></font></H1></Center>
<br><br>
<p align="center"><font size="5"><b>
<!--Display page heading using resource bundle-->
<%= ds.getPostNewQuery() %></b></font>
</p>
<table border="0" width="215" cellspacing="0" cellpadding="0" height="1">
<tr>
<!--Display user ID label using resource bundle-->
<td width="95" bgcolor="#FFFFFF" height="1"><div align="center"><font
color="#FF0000"><b><%= ds.getUser() %>
</b></font></div></td>
<td width="104" bgcolor="#FFFFFF" height="1">
<!--Display user ID value from session-->
<font color="#FF0000"><b>
<%=session.getAttribute("userid")%></b></font></td>
</tr>
</table>
<div align="justify">
<table border="0" cellpadding="0" cellspacing="0" width="200" style="position: absolute;
left: 707px; top: 129px; width: 208px">
<tr>
<!--Display text of hyperlink to DoLogout.jsp using resource bundle-->
<td height="18" bgcolor="#FFFFFF"><font color="#FFFFFF"><b><a
href="DoLogout.jsp"><%= ds.getLogout() %></a></b></font></td>
</tr>
<tr>
<td height="18" bgcolor="#FFFFFF"><b>
<!--Display text of hyperlink to UserPage.jsp using resource bundle-->
<a href="UserPage.jsp">
<%= ds.getGoMain() %></a></b></td>
</tr>
</table>
</div>
<!--Display HTML form to add new discussion-->
<form action = AddDiscussion.jsp method ="post">
<div align="center">
<table width="544" border="1" cellpadding="0" cellspacing="0" bordercolor="#FF0000">
<tr>
<!--Display label for category field using resource bundle-->
<td width="194" bgcolor="#FFFFFF"><div align="center"><%= ds.getCategory()
%></div></td>
<td width="450" bgcolor="#FFFFFF">
<input name="txtCategory" size="30" >
<select name ="txtCategory1" onChange="{form.txtCategory.value=''+this.value+'';}">
<%
java.util.HashMap hmap = new HashMap();
try{
/*Create a URL object to load properties file*/
URL url=new URL("http://127.0.0.1:8080/seven/path.properties");
/*Open URL connection*/
URLConnection ucon=url.openConnection();
/*Retrieve the discussionlistpath property*/
Properties prop = new Properties();
prop.load(ucon.getInputStream());
discussionpath = prop.getProperty("discussionlistpath");
}
catch(Exception ex)
{
ex.printStackTrace();
}
/*Obtain a DocumentBuilder object by calling the newInstance()method*/
DocumentBuilderFactory docbfact = DocumentBuilderFactory.newInstance();
/*Call the newDocumentBuilder() method to obtain a DocumentBuilder object*/
DocumentBuilder docb = docbfact.newDocumentBuilder();
/*Parse the discussionlist XML document*/
Document doc = docb.parse(new FileInputStream(discussionpath));
/*Obtain query elemens of the XML document as a NodeList object*/
NodeList nl1 = doc.getElementsByTagName("query");
/*Iterate through the NodeList object*/
for(int int_1 = 0; int_1 < nl1.getLength(); int_1 ++)
{
/*Obtain the Node object*/
Node n=nl1.item(int_1);
/*Retrieve attributes of the Node objects*/
NamedNodeMap nnp = n.getAttributes();
Object
obj1=hmap.put((nnp.getNamedItem("Category")).getNodeValue(),(nnp.getNamedItem("Category")).getNodeValue());
if(obj1==null)
{
%>
<!--Populate category drop-down list with values of Category attributes-->
<option
value="<%=(nnp.getNamedItem("Category")).getNodeValue()%>"><%=(nnp.getNamedItem
("Category")).getNodeValue()%></option>
<%
}
}
%>
</select>
</td>
</tr>
<tr>
<!--Display label for sub category field using resource bundle-->
<td width="194" bgcolor="#FFFFFF"><div align="center"><%= ds.getSubCategory()
%></div></td>
<td width="450" bgcolor="#FFFFFF">
<input name="txtSubCategory" size="30" >
<select name ="txtSubCategory1"
onChange="{form.txtSubCategory.value=txtSubCategory1.value;}">
<%
hmap = new HashMap();
/*Obtain a DocumentBuilder object by calling the newInstance()method*/
docbfact = DocumentBuilderFactory.newInstance();
/*Call the newDocumentBuilder() method to obtain a DocumentBuilder object*/
docb = docbfact.newDocumentBuilder();
/*Parse the discussionlist XML document*/
doc = docb.parse(new FileInputStream(discussionpath));
/*Obtain query elemens of the XML document as a NodeList object*/
nl1 = doc.getElementsByTagName("query");
/*Iterate through the NodeList object*/
for(int int_1 = 0; int_1 < nl1.getLength(); int_1 ++)
{
/*Obtain the Node object that represents elements of an XML document*/
Node n=nl1.item(int_1);
/*Retrieve attributes of the Node objects*/
NamedNodeMap nnp = n.getAttributes();
Object
obj1=hmap.put((nnp.getNamedItem("SubCategory")).getNodeValue(),(nnp.getNamedItem
("SubCategory")).getNodeValue());
if(obj1==null)
{
%>
<!--Populate category drop-down list with values of SubCategory attributes-->
<option
value="<%=(nnp.getNamedItem("SubCategory")).getNodeValue()%>"><%=(nnp.getNamedItem
("SubCategory")).getNodeValue()%></option>
<%
}
}
%>
</select>
</td>
</tr>
<tr>
<!--Display label for discussion field using resource bundle-->
<td width="194" bgcolor="#FFFFFF"><div align="center"><%= ds.getDiscussion()
%></div></td>
<td width="338" bgcolor="#FFFFFF">
<textarea name="txtDiscussion" rows="4" cols="50"></textarea>
</td>
</tr>
</table>
<p>
<!--Display label for submit button using resource bundle-->
<input type="submit" value=<%= ds.getSubmitQuery() %>>
</p>
</div>
</form>
Download this listing.
The above code creates the AddDiscussion JSP file. The code retrieves the value of the String object, lang1, which is stored in session to create an object of the DisplayString class. The object of the DisplayString class retrieves country-specific data to provide the user interface of the AddDiscussion JSP page. When an end user specifies a topic, sub topic, and content of a discussion, and clicks the Submit button, the code parses the discussionlist.xml file to create an object tree of that file. The code adds a node that corresponds to the discussion in the object tree and transforms the object tree into an XML document. Figure 7-8 shows the user interface of AddDiscussion.jsp in French:
Figure 7-8: User Interface of AddDiscussion.jsp in French
Creating the ViewDiscussion.jsp File
The ViewDiscussion.jsp file displays existing discussions and allows an end user to search for a specific discussion.
Listing 7-12 shows the content of the ViewDiscussion.jsp file:
Listing 7-12: The ViewDiscussion.jsp File
<!--Import the necessary packages-->
<%@page import="javax.xml.parsers.*, java.net.*, java.io.*, java.util.*, org.w3c.dom.*"%>
<%@page
import="javax.xml.transform.Transformer,javax.xml.transform.TransformerFactory, javax.xml.
transform.TransformerException"%>
<%@page
import="javax.xml.transform.TransformerConfigurationException, javax.xml.transform.dom.
DOMSource, javax.xml.transform.stream.StreamResult"%>
<%@page import="javax.xml.transform.OutputKeys"%>
<%@page import="TxtConverter.*"%>
<%!String discussionpath;%>
<%
/*Call the constructor of DisplayString by passing the value of query parameter, lang*/
DisplayString ds=new DisplayString((session.getAttribute("lang1")).toString());
%>
<%
String tempCategory,tempSubCategory;
/*Retrieve values of category and sub category of discussion from request object*/
tempCategory = request.getParameter("txtCategory");
tempSubCategory = request.getParameter("txtSubCategory");
%>
<Center><H1 class="style1"><font color="#E24907"><%=
ds.getHeading()%></font></H1></Center>
<br>
<p align="center"><font size="5"><b>
<%= ds.getQueryList() %> </b></font>
</p>
<table border="0" width="215" cellspacing="0" cellpadding="0" height="1">
<tr>
<td width="95" bgcolor="#FFFFFF" height="1"><div align="center"><font
color="#FF0000"><b><%= ds.getUser() %>
</b></font></div></td>
<td width="104" bgcolor="#FFFFFF" height="1">
<font color="#FF0000"><b>
<%=session.getAttribute("userid")%> </b></font></td>
</tr>
</table>
<div align="justify">
<table border="0" cellpadding="0" cellspacing="0" width="200" style="position: absolute;
left: 713px; top: 115px; width: 207px" >
<tr>
<!---->
<td height="18" bgcolor="#FFFFFF"><font color="#FFFFFF"><b><a
href="DoLogout.jsp"><%= ds.getLogout() %></a></b></font></td>
</tr>
<tr>
<td height="18" bgcolor="#FFFFFF"><b>
<a href="UserPage.jsp">
<%= ds.getGoMain() %></a></b></td>
</tr>
</table>
</div>
<form action = ViewDiscussion.jsp method ="get">
<Center>
<table width="346" border="1" cellpadding="0" cellspacing="0" bordercolor="#FF0000">
<tr>
<td width="179" bgcolor="#FFFFFF"><%= ds.getCategory() %> </td>
<td width="153" bgcolor="#FFFFFF">
<select name="txtCategory" >
<option value=""></option>
<%
HashMap hmap = new HashMap();
try{
/*Create a URL object to load properties file*/
URL url=new URL("http://127.0.0.1:8080/seven/path.properties");
/*Open URL connection*/
URLConnection ucon=url.openConnection();
/*Retrieve the discussionlistpath property*/
Properties prop = new Properties();
prop.load(ucon.getInputStream());
discussionpath = prop.getProperty("discussionlistpath");
}
catch(Exception ex)
{
ex.printStackTrace();
}
/*Obtain a DocumentBuilder object by calling the newInstance()method*/
DocumentBuilderFactory docbfact = DocumentBuilderFactory.newInstance();
/*Call the newDocumentBuilder() method to obtain a DocumentBuilder object*/
DocumentBuilder docb = docbfact.newDocumentBuilder();
/*Parse the discussionlist XML document*/
Document doc = docb.parse(new FileInputStream(discussionpath));
/*Obtain query elemens of the XML document as a NodeList object*/
NodeList nl1 = doc.getElementsByTagName("query");
/*Iterate through the NodeList object*/
for(int int_1 = 0; int_1 < nl1.getLength(); int_1 ++)
{
/*Obtain the Node object*/
Node n=nl1.item(int_1);
/*Retrieve attributes of the Node objects*/
NamedNodeMap nnp = n.getAttributes();
Object obj1 =
hmap.put((nnp.getNamedItem("Category")).getNodeValue(),(nnp.getNamedItem("Category")).
getNodeValue());
if(obj1==null)
{
%>
<!--Populate category drop-down list with values of Category attributes-->
<option><%=(nnp.getNamedItem("Category")).getNodeValue()%></option>
<%
}
}
%>
</select></td>
</tr>
<tr>
<td width="179" height="26" bgcolor="#FFFFFF"><%= ds.getSubCategory() %> </td>
<td width="153" bgcolor="#FFFFFF">
<!--Display sub-category drop-down list-->
<select name="txtSubCategory" >
<option value=""></option>
<%
hmap = new HashMap();
/*Obtain a DocumentBuilder object by calling the newInstance()method*/
docbfact = DocumentBuilderFactory.newInstance();
/*Call the newDocumentBuilder() method to obtain a DocumentBuilder object*/
docb = docbfact.newDocumentBuilder();
/*Parse the discussionlist XML document*/
doc = docb.parse(new FileInputStream(discussionpath));
/*Obtain query elemens of the XML document as a NodeList object*/
nl1 = doc.getElementsByTagName("query");
/*Iterate through the NodeList object*/
for(int int_1 = 0; int_1 < nl1.getLength(); int_1 ++)
{
/*Obtain the Node object that represents elements of an XML document*/
Node n=nl1.item(int_1);
/*Retrieve attributes of the Node objects*/
NamedNodeMap nnp = n.getAttributes();
Object obj1 = hmap.put((nnp.getNamedItem("SubCategory")).getNodeValue(),
(nnp.getNamedItem("SubCategory")).
getNodeValue());
if(obj1==null)
{
%>
<!--Populate category drop-down list with values of SubCategory attributes-->
<option
value="<%=(nnp.getNamedItem("SubCategory")).getNodeValue()%>"><%=
(nnp.getNamedItem("SubCategory")).getNodeValue()%></option>
<%
}
}
%>
</select></td>
</tr>
</table>
<p>
<input type="submit" value= <%= ds.getViewDiscussion() %>">
</p>
</Center>
</form>
<div align="justify">
<table width="300" border="1" cellpadding="0" cellspacing="0" bordercolor="#FF0000"
style="position: absolute; left: 335px; top: 311px; width: 371px;">
<tr bgcolor="#FFFFFF">
<td colspan="3">
<!--Call getExistingDiscussion() method of DisplayString object to display country
specific data-->
<p align="center"><i><font color="#FF0000"><b> <%=
ds.getExistingDiscussion() %> </b></font></i></p>
</td>
</tr>
<tr>
<td width="147" bgcolor="#FFFFFF"><font color="#FF0000"><b> <%=
ds.getCategory() %></b></font></td>
<td width="147" bgcolor="#FFFFFF"><font color="#FF0000"><b><%=
ds.getSubCategory() %></b></font></td>
<td width="147" bgcolor="#FFFFFF"><font color="#FF0000"><b><%=
ds.getDiscussion() %></b></font></td>
</tr>
<%
hmap = new HashMap();
/*Obtain a DocumentBuilder object by calling the newInstance()method*/
docbfact = DocumentBuilderFactory.newInstance();
/*Call the newDocumentBuilder() method to obtain a DocumentBuilder object*/
docb = docbfact.newDocumentBuilder();
/*Parse the discussionlist XML document*/
doc = docb.parse(new FileInputStream(discussionpath));
/*Obtain query elemens of the XML document as a NodeList object*/
nl1 = doc.getElementsByTagName("query");
/*Iterate through the NodeList object*/
for(int int_1 = 0; int_1 < nl1.getLength(); int_1 ++)
{/*If end user does not specifies any search criteria display all discussion data*/
Node n=nl1.item(int_1);
NamedNodeMap nnp = n.getAttributes();
if(tempCategory == null && tempSubCategory == null )
{
%>
<tr>
<td width="147"
bgcolor="#FFFFFF"><%=(nnp.getNamedItem("Category")).getNodeValue()%></td>
<td width="147"
bgcolor="#FFFFFF"><%=(nnp.getNamedItem("SubCategory")).getNodeValue()%></td>
<td width="147"
bgcolor="#FFFFFF"><%=(nnp.getNamedItem("Discussion")).getNodeValue()%></td>
</tr>
<%
}
else
{
if (!(tempCategory.equals("")))
{
if ((nnp.getNamedItem("Category")).getNodeValue().equals(tempCategory))
{
/*If end user specifies a category,match end user category with the node value. For
/* matching categories, display discussion data.*/
%>
<tr>
<td width="147"
bgcolor="#FFFFFF"><%=(nnp.getNamedItem("Category")).getNodeValue()%></td>
<td width="147"
bgcolor="#FFFFFF"><%=(nnp.getNamedItem("SubCategory")).getNodeValue()%></td>
<td width="147"
bgcolor="#FFFFFF"><%=(nnp.getNamedItem("Discussion")).getNodeValue()%></td>
</tr>
<%
}
}
else
{
if (!(tempSubCategory.equals("")))
{
if ((nnp.getNamedItem("SubCategory")).getNodeValue().equals(tempSubCategory))
{
/*If end user specifies both category and sub category,match end user sub
category with the node value. For matching categories, display discussion data.*/
%>
<tr>
<td width="147"
bgcolor="#FFFFFF"><%=(nnp.getNamedItem("Category")).getNodeValue()%></td>
<td width="147"
bgcolor="#FFFFFF"><%=(nnp.getNamedItem("SubCategory")).getNodeValue()%></td>
<td width="147"
bgcolor="#FFFFFF"><%=(nnp.getNamedItem("Discussion")).getNodeValue()%></td>
</tr>
<%
}
}
}
}
}
%>
</table>
</div>
Download this listing.
The above code creates the ViewDiscussion JSP page. The code creates an object of the DisplayString class to display country-specific data. The parse() method of the DocumentBuilder object parses the discussionlist.xml file and retrieves values of the Category and SubCategory attributes. The Topic and Sub Topic drop-down lists display the attribute values. When an end user selects a topic or sub topic to view discussions, the code iterates through the object tree node of the discussionlist XML document to retrieve data of all matching discussions. The code displays the data in the country-specific user interface in a tabular format.
Figure 7-9 shows the user interface provided by the ViewDiscussion JSP page in French:
Figure 7-9: User Interface of the ViewDiscussion JSP Page in French
Selecting the Data as Java Objects
Selecting the Data as Java Objects
You have learned how to use JdbcTemplate to perform raw data operations, but there is too much code to write, and in most cases, writing code for various select statements results in massive code duplication. Also, the queryForList() method returns a List of Map instance because it is not aware of the columns being selected. Unfortunately you still need to write lots of code to retrieve the data using ResultSets and create appropriate domain objects.
In Listing 8-14, we show the use of Spring JDBC support classes. We are going to start the discussion with the use of the MappingSqlQuery class that will process the result set and create appropriate domain objects. Subclasses of MappingSqlQuery must implement its mapRow method. This method gets the values from the underlying ResultSet and returns the appropriate domain object.
Listing 8-14: MappingSqlQuery Usage
package com.apress.prospring.ch10.spring;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.SqlParameter;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
import org.springframework.jdbc.object.MappingSqlQuery;
import com.apress.prospring.ch10.TestDao;
import com.apress.prospring.ch10.domain.Test;
public class JdbcTestDao implements TestDao, InitializingBean {
private DataSource dataSource;
private static final String SELECT_BY_NAME_SQL =
"select * from Test where Name=?";
abstract class AbstractSelect extends MappingSqlQuery {
public AbstractSelect(DataSource dataSource, String sql) {
super(dataSource, sql);
}
protected Object mapRow(ResultSet rs, int rowNum) throws SQLException {
Test test = new Test();
test.setName(rs.getString("Name"));
test.setTestId(rs.getInt("TestId"));
return test;
}
}
class SelectByName extends AbstractSelect {
public SelectByName (DataSource dataSource) {
super(dataSource, SELECT_BY_NAME_SQL);
declareParameter(new SqlParameter(Types.VARCHAR));
}
}
public void afterPropertiesSet() throws Exception {
if (dataSource == null) {
throw new BeanCreationException("Must set dataSource on UserDao");
}
// more initialization code
}
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
}
The code in Listing 8-14 looks like it can actually do some database work! Let's review what we have implemented.
First, we have the AbstractSelect class that extends MappingSqlQuery. This class maps the ResultSet columns and returns the appropriate Test domain object. All query classes that select users inevitably return User objects, so we can use the AbstractSelect class as a super- class of all select classes. The SelectByName class exemplifies this approach. The constructor takes only a single DataSource parameter, because this class performs one specific SQL query. This particular query requires two VARCHAR parameters, username and password. We declare the parameters using a call to declareParameter().
AbstractSelect is a superclass for all concrete Select implementations that no longer have to implement the mapRow() method to create an instance of the domain object. This implies that all select statements need to return the same set of columns in order for AbstractSelect.mapRow() to be able to create the domain object.
You may be wondering why AbstractSelect is still marked as abstract; after all, it already implements the mapRow() abstract method. There is a simple explanation for this: we should not use the AbstractSelect class to perform any SQL query, because different queries may use different parameters, and by marking this class abstract, we are forcing ourselves to subclass AbstractSelect for every SQL query.
A more important benefit, however, is that by implementing each individual query in its own class, we can take advantage of the fact that most databases precompile the queries and cache the compiled query plan. This may not be very critical in simple select * from Table queries similar to those that result in a full table scan, but it becomes more important as the queries get more complex.
| Note | Some databases do not use the precompiled plans. The rationale behind this is that the statistics used to create the query plan may become out of date very quickly as records are inserted into the database. If a table has 100 rows, for example, it is not worth the effort to use index operations, but if a table has |
1,000,000 rows, then the additional work of an Index Scan operation is well justified. It is not impossible to imagine that a query plan was created for a table of 100 rows and, in the meantime, the number of rows increased to a million. If this was the case, the database would be using a very inefficient query plan, and the query time saved by using the precompiled query plan would be insignificant.
Listing 8-15 shows how to use the concept of the AbstractSelect class in a TestDao implementation.
Listing 8-15: TestDao Interface
package com.apress.prospring.ch10;
import java.util.List;
public interface TestDao {
public List getByName(String name);
}
To implement the method declared in the TestDao interface, we are going to use the SelectByName inner class (see Listing 8-16). To use this class, we need to instantiate, and we will do so in the afterPropertiesSet() method declared in InitializingBean.
Listing 8-16: Implementation of getByName
package com.apress.prospring.data.jdbc;
public class JdbcTestDao implements TestDao, InitializingBean {
private DataSource dataSource;
private static final String SELECT_BY_NAME_SQL =
"select * from Test where Name=?";
abstract class AbstractSelect extends MappingSqlQuery {
public AbstractSelect(DataSource dataSource, String sql) {
super(dataSource, sql);
}
protected Object mapRow(ResultSet rs, int rowNum) throws SQLException {
Test test = new Test();
test.setName(rs.getString("Name"));
test.setTestId(rs.getInt("TestId"));
return test;
}
}
class SelectByName extends AbstractSelect {
public SelectByName(DataSource dataSource) {
super(dataSource, SELECT_BY_NAME_SQL);
declareParameter(new SqlParameter(Types.VARCHAR));
}
}
private SelectByName selectByName;
public void afterPropertiesSet() throws Exception {
if (dataSource == null) {
throw new BeanCreationException("Must set dataSource on testDao");
}
selectByName = new SelectByName(dataSource);
}
public List getByName(String name) {
return selectByName.execute(new Object[] { name });
}
}
This code links all pieces of the puzzle together. We created an abstract subclass of Spring's MappingSqlQuery named AbstractSelect, which takes care of mapping the results retrieved from the database into a Test object. We then subclassed AbstractSelect in SelectByName to execute the SQL query that selects rows from the Test table to return a test whose name matches the parameters passed to the method. In the SelectByName constructor, we have declared that name is the only parameter and is stored as VARCHAR in the database table. To select the Test objects by name, we need to pass the parameter value to the execute() method in an Object[] array containing a single value. The execute() method returns a List of objects returned by the mapRow() method. Because SelectByName is a subclass of AbstractSelect, and because the AbstractSelect.mapRow() method returns an instance of the Test class, we can safely cast the Objects in the List to Tests.
Keep in mind that the order in which the parameters are passed is critical to the execute() method: if we accidentally change the order of the parameters, we do not get the correct results.
Let us step back and look at the code we have written. If this is the only DAO implementation class in the application, it is just fine the way it is. However, most applications have more than one DAO class. If this is the case, we need to create a DAO class that has a dataSource property and implements InitializingBean and the appropriate DAO interface. This has a nasty code smell and as a result, we need to refactor the code. Spring supports this situation by providing a JdbcDaoSupport class.
The refactored JdbcTestDao class is shown in Listing 8-17.
Listing 8-17: Refactored JdbcTestDao
public class JdbcTestDao
extends JdbcDaoSupport implements TestDao, InitializingBean {
private DataSource dataSource;
private static final String SELECT_BY_NAME_SQL =
"select * from Test where Name=?";
abstract class AbstractSelect extends MappingSqlQuery {
/* omitted for clarity */
}
class SelectByName extends AbstractSelect { /* omitted for clarity */ }
private SelectByName selectByName;
protected void initDao() throws Exception {
super.initDao();
selectByName = new SelectByName(getDataSource());
}
public void afterPropertiesSet() throws Exception {
if (dataSource == null)
throw new BeanCreationException("Must set dataSource on testDao");
selectByName = new SelectByName(dataSource);
}
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
public List getByName(String name) {
return selectByName.execute(name);
}
}
This code is much cleaner after we remove the stricken-out lines and add the lines in bold. We had to remove some of the code because JdbcDaoSupport implements InitializingBean's afterPropertiesSet as final, and it also has the dataSource property. Because we still need to instantiate the query inner classes, JdbcDaoSupport allows us to override the initDao() method, which is called after all properties have been set on JdbcDaoSupport. We can access the dataSource property by calling the getDataSource() method.
The code we now have looks like it does not need any more refactoring, and indeed, that would be true if we were only selecting and updating data. Before we take a look at the inevitable catch with inserts, we will discuss data updates.