XML Development Using Borland JBuilder 8

Transcription

1 XML Development Using Borland JBuilder 8 Jumpstart XML development with the Apache XML framework, supported in JBuilder 8 A Borland White Paper Kathy L. Alexion, Systems Engineer January 2003

2 Contents Introduction... 3 JBuilder 8 wizards for XML... 3 Framework Component... 4 Description... 4 XML basics... 5 Create a project... 5 XML to DTD... 5 DTD to XML... 8 XML and databinding...12 Databinding wizards Creating a class Apache Cocoon...20 XSL with XML Running Cocoon with JBuilder SAX Handler wizard...35 XML DBMS...45 Conclusion...51 Appendix A...51 Borland XML: marshalling and unmarshalling Appendix B...53 The Database Pilot

3 Introduction Borland JBuilder Enterprise is a comprehensive set of award-winning visual development tools for creating enterprise-scale applications written entirely in the Java programming language for the Java 2 platform. JBuilder 8 Enterprise provides out-of-the box support for Apache XML framework components, as well as being compliant with the W3C (World Wide Web Consortium) specifications. JBuilder 8 wizards for XML Presentation, transformation, and validation of XML documents is supported within the JBuilder 8 wizard suite. Data binding and the programmatic manipulation of XML documents along with support for transferring data between XML and databases is also available. With the Apache framework supported in JBuilder 8, the XML wizard suite includes a SAX Parser generation wizard along with library definitions for JAXP (Java API for XML Processing) and DOM (Document Object Model). For performing presentation transformations, a wizard created on top of the Cocoon publishing engine is conveniently included. Transformation and validation is supported within the Cocoon publishing wizard in JBuilder. JBuilder 8 includes tools for data binding and the programmatic manipulation of XML documents: Borland XML for generating Java sources from Documentation Type Definition (DTD), and Castor for generating Java sources from schema. The wizard suite includes tools for transferring data to and from databases (XML-DBMS wizard for model-based database support), along with conversion support and verification including: DTD to XML and XML to DTD. The following is the list of XML framework components, which can be easily developed and verified using JBuilder 8 wizards. 3

4 Framework Component XML (Extensible Markup Language) DTD (Document Type Definition) Apache TM Cocoon Publishing Framework for XML XSL (Extensible Style Language) SAX (Simple API for XML) Description XML allows developers to create and customize their own markup tags, and it enables the transfer, validation, and interaction of data within and between applications. A type of file associated with XML documents, which defines how the markup tags or markup declarations should be interpreted by the application presenting the document. It is a servlet-based, Java publishing framework for XML that allows separation of content, style, and logic and uses Extensible Style Language (XSL) transformation to merge them. A specification from the W3C, which defines the language for separating/creating style (sheets) from content when creating HTML or XML pages. JBuilder utilizes the Apache Xalan stylesheet processor for transformation of XML documents. Xalan uses stylesheets written in Extensible Style Language Transformations (XSLT) for transformation. An Extensible Style Language (XSL) stylesheet contains instructions for transforming XML documents from one document type into another document type (XML, HTML, PDF, WML, or other). SAX is a standard API for event-based XML parsing. The JBuilder Sax Handler wizard utilizes the Apache Xerces parsing engine that enables custom parsing of XML documents. Borland XML A programmable class generator used for databinding to generate JavaBean classes from DTD, enabling the use of simple JavaBean programming conventions to manipulate XML data without worrying about the XML details. Castor An open source databinding framework which provides a Java to XML binding. Castor has the ability to generate Java classes from schema files (.xsd). Table 1: List of XML components and technologies supported by JBuilder 8 4

5 XML basics With the Borland XML to DTD and DTD to XML generation wizards, you can rapidly create.xml from a.dtd and.dtd from.xml. By either opening the JBuilder Object Gallery or by a right-click of the mouse on your.dtd or.xml file, you have quick access to file generation as well as verification. Create a project Start JBuilder 8. Click File -> New -> Select Project tab from the Object Gallery. Click Project. Click OK. In the Project Wizard Step 1 of 3 specify a Directory Name and a Project Name. For this exercise, the project directory is E:/Example/XMLPrj and Project Name is XML. Leave the Template as (Default Project). Click Finish. XML to DTD Create an XML file (for pre-existing XML files, skip this step): In JBuilder, above the project pane, click the Add Files/Packages button as shown in Figure 1. Figure 1: Add Files/Packages button Enter the name XMLShoppingCart.xml into the File name field as shown in Figure 2. 5

6 Figure 2: Dialog box for XMLShoppingCart.xml creation Click OK. A blank.xml file is created. Copy and paste the following text (Figure 3) into your newly created XMLShoppingCart.xml file. Make sure to save this file to your XMLPrj directory. <?xml version="1.0"?> <XMLShoppingCart> <CustomerId>pcdata</CustomerId> <FirstName>pcdata</FirstName> <LastName>pcdata</LastName> <Address>pcdata</Address> <ZipCode>pcdata</ZipCode> <Item>pcdata</Item> <Qty>pcdata</Qty> <Company>pcdata</Company> 6

7 <JobCountry>pcdata</JobCountry> <FullName>pcdata</FullName> </XMLShoppingCart> Figure 3: Sample XML Text Note: If you have a pre-existing XML document, you can skip the previous step. In JBuilder, Choose File-> New -> Select the XML tab, Choose XML to DTD In the XML-DTD dialog box, choose the directory where your (input).xml file is located. Click the [ ] ellipses button and navigate to your project directory, or directory of your choice. Locate and select your.xml file. The Output DTD file directory will automatically be populated. See Figure 4. Figure 4: XML to DTD wizard window 7

8 Click OK. JBuilder will generate the.dtd file from your.xml file. See Figure 5 below. <?xml version="1.0" encoding="utf-8"?> <!ELEMENT XMLShoppingCart ( CustomerId, FirstName, LastName, Address, ZipCode, Item, Qty, Company, JobCountry, FullName ) > <!ELEMENT FullName ( #PCDATA ) > <!ELEMENT Item ( #PCDATA ) > <!ELEMENT Company ( #PCDATA ) > <!ELEMENT Address ( #PCDATA ) > <!ELEMENT JobCountry ( #PCDATA ) > <!ELEMENT LastName ( #PCDATA ) > <!ELEMENT ZipCode ( #PCDATA ) > <!ELEMENT CustomerId ( #PCDATA ) > <!ELEMENT FirstName ( #PCDATA ) > <!ELEMENT Qty ( #PCDATA ) > Figure 5: Generated DTD DTD to XML JBuilder allows you to generate XML from DTD as well. 8

9 Right-click the XMLShoppingCart.dtd as shown in Figure 6. Figure 6: Right-click menu on the.dtd file You have many options with this menu. In this example, XML will be generated from this.dtd file, click Generate XML. The DTD to XML dialog box will appear as shown in Figure 7. Figure 7: DTD to XML wizard 9

10 The Input DTD file field should already be populated with the appropriate directory and.dtd. file. Select the Root element drop down list and choose XMLShoppingCart. In the Output XML file field, choose the [ ] ellipses button and rename XMLShoppingCart.xml to DTDGen_ShoppingCart.xml. Under the Identifiers option, System edit field, type in the name of the.dtd file that the XML file will be referencing, in our case it is XMLShoppingCart.dtd. Click OK. JBuilder has generated the XML File from your.dtd as shown in Figure 8. <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE XMLShoppingCart SYSTEM "XMLShoppingCart.dtd"> <XMLShoppingCart> <CustomerId>pcdata</CustomerId> <FirstName>pcdata</FirstName> <LastName>pcdata</LastName> <Address>pcdata</Address> <ZipCode>pcdata</ZipCode> <Item>pcdata</Item> <Qty>pcdata</Qty> <Company>pcdata</Company> <JobCountry>pcdata</JobCountry> <FullName>pcdata</FullName> </XMLShoppingCart> Figure 8: Generated XML from.dtd Note: You can also access the DTD to XML wizard by choosing File -> New. In the Object Gallery, select the XML tab, choose DTD to XML. Right-click the DTDGen_ShoppingCart.xml file as shown in Figure 9. 10

11 Figure 9: Right-click menu on a.xml file Choose Validate. JBuilder will validate that your.xml file for correct content and tag matching. You should receive a dialog box stating that your.xml document is valid as shown in Figure 10. Figure 10: Valid XML box Click OK. You have successfully created an.xml file, generated DTD, and then generated an.xml file from the DTD utilizing the JBuilder XML/DTD wizards. 11

12 XML and databinding Databinding wizards The Databinding wizard in JBuilder allows you to use Borland XML or Castor. See Introduction section for a definition of these components. With Borland XML, you can rapidly create Java files, instantly by inputting your.dtd file. The setter and getter methods for the attributes (column names) in your.dtd file are automatically generated which means you save time on coding. Borland XML also generates the methods for marshalling and unmarshalling objects, so all you have to do is invoke the methods. They have been created for you. For this paper, we will be using Borland XML. Choose File -> New. Choose the XML tab, select Databinding. The Databinding wizard will start up as shown in Figure 11. Figure 11: Databinding wizard 12

13 Choose Borland XML in the drop down list. Click Next. Navigate to your XMLPrj directory and choose the XMLShoppingCart.dtd file as shown in Figure 12. Figure 12: Databinding wizard Step 2 Choose XMLShoppingCart as the Root Element. Click Finish. If you expand the xmlprj package in the project pane, you can see that JBuilder has generated the class files based on the XMLShoppingCart.dtd file as shown in Figure 13 after utilizing the Databinding wizard with Borland XML. 13

14 Figure 13: Generated Java classes after using the Databinding wizard with Borland XML If you select the XMLShoppingCart.java file, you will be able to see the generated methods. Specifically examine the marshal and unmarshalling methods that were generated. By using these methods, you can write to an XML document from a JavaBean object (marshalling), or you can read an XML document into JavaBean objects (unmarshalling). See Appendix A for more information about marshalling and unmarshalling. In the next section, you will learn how to use these methods. Create a project. (For instructions on how to do this, see section entitled Create a project ). Create an.xml file called ShoppingCart.xml. (See section XML to DTD for instructions on creating a new file). Paste the text below, into the.xml file: 14

15 <?xml version="1.0"?> <!DOCTYPE ShoppingCart SYSTEM "ShoppingCart.dtd"> <ShoppingCart> <ShoppingCart> <CustomerId>1</CustomerId> <FirstName>Jessica</FirstName> <LastName>Baker</LastName> <Address>250 Bayberry Road</Address> <ZipCode>02895</ZipCode> <Item>Jbuilder Enterprise</Item> <Qty>25</Qty> <Company>XYZ Company</Company> <JobCountry>USA</JobCountry> <FullName>Baker, Jessica</FullName> </ShoppingCart> <ShoppingCart> <CustomerId>5</CustomerId> <FirstName>Brian</FirstName> <LastName>Smith</LastName> <Address>10673 W Coast Dr</Address> <ZipCode>95066</ZipCode> <Item>OptimizeIt</Item> <Qty>50</Qty> <Company>Foo Company</Company> <JobCountry>USA</JobCountry> <FullName>Smith, Brian</FullName> </ShoppingCart> <ShoppingCart> <CustomerId>77</CustomerId> <FirstName>Carter</FirstName> <LastName>Ritz</LastName> <Address>22 Bell St</Address> <ZipCode>77375</ZipCode> <Item>JBuilder Enterprise</Item> <Qty>130</Qty> <Company>TechABC Company</Company> <JobCountry>USA</JobCountry> <FullName>Ritz, Carter</FullName> </ShoppingCart> </ShoppingCart> Save your new ShoppingCart.xml file. 15

16 Create another file and name it ShoppingCart.dtd. Copy and paste the text, below, into that file: <?xml version="1.0" encoding="utf-8"?> <!ELEMENT FullName ( #PCDATA ) > <!ELEMENT Item ( #PCDATA ) > <!ELEMENT Company ( #PCDATA ) > <!ELEMENT Address ( #PCDATA ) > <!ELEMENT JobCountry ( #PCDATA ) > <!ELEMENT LastName ( #PCDATA ) > <!ELEMENT ZipCode ( #PCDATA ) > <!ELEMENT CustomerId ( #PCDATA ) > <!ELEMENT FirstName ( #PCDATA ) > <!ELEMENT ShoppingCart ( ShoppingCart?, CustomerId?, FirstName?, LastName?, Address?, ZipCode?, Item?, Qty?, Company?, JobCountry?, FullName? ) > <!ELEMENT Qty ( #PCDATA ) > Save your new ShoppingCart.dtd file. Right-click the ShoppingCart.dtd file and choose Generate Java. In the Databinding wizard, make sure Borland XML is selected. Choose Next. In the Root element drop down list, select Shopping Cart. Choose Finish. The.java files have been generated. See XML and Databinding for additional information. Creating a class Create a new class, by choosing File -> New. The Object Gallery will appear. Click the General tab. Choose Class. In the Class wizard, type in SC_BorlandXML for the class name. Leave the defaults for everything else, and click OK, as shown in Figure

17 Figure 14: Class wizard Navigate to the SC_BorlandXML.java class in the project pane. Copy and paste the text, below, into your new class: package borlandxml; public class SC_BorlandXML { String filename = "ShoppingCart.xml"; ShoppingCart shoppingcart; static SC_BorlandXML sc_borlandxml; public SC_BorlandXML() { } /** * This methods unmarshals (reads) the content of the XML file and initializes corresponding * class instances. */ public void readshoppingcart() { 17

18 java.io.fileinputstream in = null; try { in = new java.io.fileinputstream(filename); System.out.println("== unmarshalling \"" + filename + "\" =="); shoppingcart = ShoppingCart.unmarshal(in); shoppingcart.setsystemid("shoppingcart.dtd"); }catch (Throwable ex) { ex.printstacktrace(); } System.out.println("Getting customer information! "); ShoppingCart customerinfo = shoppingcart.getshoppingcart(); System.out.println("Customer's Full Name is " + customerinfo.getfullnametext()); System.out.println("Items in shopping cart: " + customerinfo.getitemtext()); System.out.println("Quantity: " + customerinfo.getqtytext()); } public static void main(string[] args) { sc_borlandxml = new SC_BorlandXML(); sc_borlandxml.readshoppingcart(); } } Take a closer look at the SC_BorlandXML.java file. It has one method: readshoppingcart(). First, a FileInputStream is created and then the unmarshal() method is invoked from the ShoppingCart object. The unmarshal() method is reading the XML into the Shopping Cart Java object. You can see in the main() method, that the class is instantiated and then the readshoppingcart() method is invoked. 18

19 Right-click your project file: BorlandXML.prj and choose Make. This will build the entire project. Highlight and right-click the SC_BorlandXML.java file. Choose Run using Defaults. In the message window in JBuilder, you should see the following results, as shown in Figure 15. You can see that data from the XML file is being read and displayed. Figure 15: Results after running the SC_BorlandXML.java file Double-click the ShoppingCart.xml file in the project pane, and examine the data in the file. BorlandXML is fast and makes generating your.java files from an XML file easier. 19

20 Apache Cocoon JBuilder 8 has support for publishing your XML documents with the Apache Cocoon Publishing Framework. Choose File ->New XML Tab -> Cocoon Name your Web application ShoppingCart. Change the default directory by navigating to your XMLPrj directory. JBuilder allows you to use the following frameworks: InternetBeans Express 1.1, JSTL 1.0, and Apache Struts 1.0. For this exercise, we will not be using these frameworks. Leave the defaulted value in the Launch URI drop-down list. Click OK. See Figure 16. Figure 16: Web application wizard 20

21 JBuilder has generated the necessary Web application information used to publish your XML. If you look in the project pane, you can see the Shopping Cart Web application. Expand the Web application and click the Root directory. You should see the files that JBuilder has pulled into the project as well as the files that were generated: DTDGen_ShoppingCart.xml, index.xml, index.xsl, sitemap.xmap, and XMLShoppingCart.xml. XSL with XML In the next section we will apply the generated index.xsl stylesheet to the ShoppingCart.xml file. For more information about XSL refer to the Framework Components table. In the project pane, navigate to the index.xsl file. Double-click the file and examine the body of the file in the editor window. This is a JBuilder generated.xsl file. Let s apply it to our ShoppingCart.xml file and see the results. Double-click the ShoppingCart.xml file. In the editor window, choose Transform View tab, as shown in Figure 17. Figure 17: Tabs in the editor window for XML files Click the Add Stylesheets button, located in the upper left corner of the editor pane, as shown in Figure 18. Figure 18: XML buttons. The first button from the left is the Default Stylesheet button. The second button from the left is the Refresh button. The third button from the left is the Set Trace Options button. The last button is the Add Stylesheets button. 21

22 The Default Stylesheet button allows you to apply a default stylesheet. The Set Trace Options button, when clicked, brings up a window that allows you to set different trace options for your.xml file, as shown in Figure 19. The options are as follows: Generation: outputs information after each result tree generation event, such as start document, start element, characters, and so on. Templates: outputs an event when a template is invoked. Elements: outputs events that occur as each node is executed in the stylesheet. Selections: outputs information after each selection event. Figure 19: Set Trace Options window You can also access Trace Options by going to the Tools Menu -> IDE Options -> XML tab, as shown in Figure

23 Figure 20: XML options in the Tools Menu ->IDE Options You can choose which Trace Options you would like enabled here as well as select other general XML options. For this exercise, do not select any trace options. Let s add the stylesheet to our ShoppingCart.xml file. Click the button Add StyleSheets. Choose Add. Navigate to the index.xsl file and select it. Click the Refresh button. Here is what the ShoppingCart.xml file looks like with the index.xsl stylesheet applied to it, as shown in Figure

24 Figure 21: ShoppingCart.xml file with index.xsl stylesheet applied to it As you can see, this stylesheet doesn t format the data in a readable manner. So let s create a new stylesheet that displays the data in a table so that it is easier to read. Create a file, name it ShoppingCartTableView.xsl. For instructions on how to create a file, see the XML to DTD section of this document. Copy and paste the text below into your new ShoppingCartTableView.xsl file: <?xml version="1.0"?> <xsl:stylesheet xmlns:xsl=" version="1.0" xmlns:java=" exclude-result-prefixes="java"> <xsl:output method="xml" indent="yes"/> <xsl:output encoding="iso "/> <xsl:strip-space elements="*"/> <xsl:template match="/"> <html> <head> <xsl:element name="title">orders</xsl:element> </head> <body> <xsl:element name="h1">list of Orders</xsl:element> <xsl:element name = "table"> <xsl:attribute name="border">2</xsl:attribute> <xsl:attribute name="bgcolor">#ff8040</xsl:attribute> <xsl:attribute name="cellpadding">3</xsl:attribute> <xsl:attribute name="cellspacing">3</xsl:attribute> <xsl:attribute name="frame">box</xsl:attribute> <xsl:attribute name="bordercolor">black</xsl:attribute> <xsl:attribute name="rules">all</xsl:attribute> 24

25 <tr BGCOLOR = "Yellow"> <th>customerid</th><th>firstname</th><th>lastname</th><th>address </th><th>zipcode</th><th>item</th> <th>qty</th><th>company</th><th>country</th><th>fullname</th> </tr> <xsl:for-each select="shoppingcart/shoppingcart"> <tr> <xsl:element name="td"> <xsl:value-of select="customerid"/> </xsl:element> <xsl:element name="td"> <xsl:value-of select="firstname"/> </xsl:element> <xsl:element name="td"> <xsl:value-of select="lastname"/> </xsl:element> <xsl:element name="td"> <xsl:value-of select="address"/> </xsl:element> <xsl:element name="td"> <xsl:value-of select="zipcode"/> </xsl:element> <xsl:element name="td"> <xsl:value-of select="item"/> </xsl:element> <xsl:element name="td"> <xsl:value-of select="qty"/> </xsl:element> 25

26 <xsl:element name="td"> <xsl:value-of select="company"/> </xsl:element> <xsl:element name="td"> <xsl:value-of select="jobcountry"/> </xsl:element> <xsl:element name="td"> <xsl:value-of select="fullname"/> </xsl:element> </tr> </xsl:for-each> </xsl:element> </body> </html> </xsl:template> </xsl:stylesheet> Save your file. Now, double-click the ShoppingCart.xml file. Click the TransformView tab in the code editor pane. Click the Add Stylesheets button. Highlight the index.xsl file, and choose Remove. Choose Add. Navigate to the ShoppingCartTableView.xsl file, select it, and click OK. Click the Refresh button. You are now able to view your newly formatted ShoppingCart.xml file with the newly applied ShoppingCartTableView.xsl stylesheet, as shown in Figure

27 Figure 22: ShoppingCart.xml file with the ShoppingCartTableView.xsl file applied to it In the project pane, you can see under the Shopping Cart Web application, that a.war file has been created as well as other files. Let s take a closer look at these files: ShoppingCart.war a Web archive file Web.xml a Web application deployment descriptor Index.xml a sample XML document Index.xsl a sample stylesheet that is applied to the index.xml file, this will allow this.xml file to be rendered as an.html file. Sitemap.xmap maps the URI space to the different pipelines in Cocoon. A pipeline is a path from a Generator to a Serializer. Let s run Cocoon with the sample index.xml file. First, you must have a Web server configured. Tomcat is automatically configured within JBuilder, so for this exercise we will use Tomcat 4.1. Choose Tools > Configure Servers. To verify that Tomcat is set up properly, click Tomcat 4.1 in the Configure Servers window. Make sure that there is a check in the Enable Server box for Tomcat 4.1, as shown in Figure 23. Choose OK. 27

28 Figure 23: Configure a Web server using Tomcat 4.1 Note: You are free to choose any Web server you would like, provided you have access to it on your own computer. We need to check one more setting before we run the application. Choose Project -> Project Properties. Choose the Server tab. Make sure Tomcat 4.1 is selected in the drop-down list, as shown in Figure

29 Figure 24: Project Properties Server setup tab Running Cocoon with JBuilder Right-click the ShoppingCart Web application and choose Web Run using Defaults. This will start up Tomcat, deploy, and run your ShoppingCart.war file, as shown in Figure

30 Figure 25: Running your Web application Figure 26 shows the result of running Cocoon. Now let s run the Web application and ShoppingCart.xml file. First we need to make a few changes to the sitemap.xmap file. 30

31 Figure 26: Results after running Cocoon with the sample index.xml Double-click the sitemap.xmap file. Navigate to the text below: <map:pipeline> <map:match pattern="index.xml"> <map:generate src="index.xml"/> <map:transform src="index.xsl"/> <map:serialize/> </map:match> </map:pipeline> </map:pipelines> Change this file to publish the ShoppingCart.xml file. See changes below: map:pipeline> 31

32 <map:match pattern="shoppingcart.xml"> <map:generate src="shoppingcart.xml"/> <map:transform src="shoppingcarttableview.xsl"/> <map:serialize/> </map:match> </map:pipeline> </map:pipelines> </map:sitemap> Right-click the ShoppingCart Web application. Choose properties. In Launch URI, use the ellipses button to navigate to the ShoppingCart.xml file. Highlight it, and click OK, as shown in Figure

33 Figure 27: Changing the Launch URI setting Click OK. Save your work. It is time to run your application. Right-click the Shopping Cart and choose Web Run using defaults. See section Running Cocoon with JBuilder for further instructions. You can now see the ShoppingCart.xml file running within JBuilder hosted by Cocoon, as shown in Figure

34 Figure 28: ShoppingCart.xml running within JBuilder Examine the code editor pane. The URL is : You can open up a browser (Microsoft Internet Explorer, Netscape Navigator), copy and paste the URL above, and view the ShoppingCart.xml file in an external (from JBuilder) browser. Note: You can add the JBuilder index.xml sample into the sitemap.xmap file together with the ShoppingCart.xml file by modifying the file as follows: <map:pipeline> <map:match pattern="index.xml"> 34

35 <map:generate src="index.xml"/> <map:transform src="index.xsl"/> <map:serialize/> </map:match> </map:pipeline> <map:pipeline> <map:match pattern="shoppingcart.xml"> <map:generate src="shoppingcart.xml"/> <map:transform src="shoppingcarttableview.xsl"/> <map:serialize/> </map:match> </map:pipeline> </map:pipelines> </map:sitemap> By adding both.xml references, when you run your Web application, you can view either.xml file by changing the URL: or You can also add a link in either of the.xml files to avoid changing the URL each time. You can publish your.xml files with a quick click of a button and a few entries in the Cocoon wizard within JBuilder. SAX Handler wizard SAX, the Simple API for XML, is a standard interface for event-based XML parsing. SAX reports parsing events directly to the application through callbacks. The application implements handlers to deal with the different events, similar to event handling in a graphical user interface. 35

36 With the SAX Handler wizard in JBuilder, you can easily create SAX parser implementation templates with your implemented methods to parse your XML. The JBuilder SAX Handler wizard helps you create a SAX parser, using the Apache Xerces parsing engine, for custom parsing of your XML documents. Let s create a SAX Handler with the JBuilder wizard. In this example, we will parse an.xml file and add indentations to the output, making it easier to read. Create a project called is Sax Handler. See the section Create a project for additional instructions. Create an.xml and.dtd file or use the ShoppingCart.xml and ShoppingCart.dtd files from the previous sections. Please refer to the section XML to DTD on how to create a file. Refer to the section Databinding wizards for the body of the ShoppingCart.xml and ShoppingCart.dtd files. To add a pre-existing file to your project, click the Add Files/Packages button and navigate to your.xml file, as shown in Figure 29. Figure 29: Add Files/Packages button Choose File > New. The Object Gallery window will appear, choose the XML tab. Click Sax Handler. In the wizard, keep the default package name. Change the Class name to MySaxParser. In the methods to override box, click ContentHandler. Expand ContentHandler and choose: characters, enddocument, endelement, startdocument, startelement., as shown in Figure

37 Figure 30: Sax Parser Wizard, Step 1 Note: For more information on these methods and interfaces, refer to the Apache Web site: Click Next. In Step 2 of the wizard, you can choose any of the parser options that you need. For this exercise, we will not select any. The options vary according to the SAX parser selected. The General parser is a JAXP-compatible parser, which only supports JAXP required features. JDK 1.4 uses Crimson as the default parser. For more information, see the SAXParserFactory class. The Xerces parser supports all Xerces 2 features. For more information on Xerces and the options it supports, see the documentation in <jbuilder>\extras\xerces\docs\features.html. Important: If you're using JDK 1.3 for your project, use Xerces as the parser, since JDK 1.3 doesn't include a JAXP parser. When you 37

38 choose Xerces as the parser, JBuilder automatically adds the Xerces library to the project, as shown in Figure 31. Figure 31: Sax Parser Wizard, Step 2 Click Next. In step 3, change the name of the runtime configuration to MySaxParser. Click Finish. This step is shown in Figure

39 Figure 32: Sax Parser Wizard, Step 3 Open the MySaxParser.java file double-click it in the project pane. Examine the generated code. Notice that your new class extends DefaultHandler. The DefaultHandler Java class is the default base class for Sax event handlers. It provides default implementations for all of the callbacks in the four core SAX2 handler classes: EntityResolver DTDHandler ContentHandler ErrorHandler Application writers can extend this class when they need to implement only part of an interface; parser writers can instantiate this class to provide default handlers when the application has not supplied its own. For this example, we will use the ContentHandler class. 39

40 Let s modify the MySaxParser.java file: 1. Add the following print statement to the startdocument() method: System.out.println(" Start Document "); Remove the throw statement in this method. 2. Add the following print statement to the enddocument() method: System.out.println(" End Document "); Remove the throw statement in this method. 3. Before the characters() method, add a variable: private int idx = 0; //indent 4. Before the main() method, add a variable: private static int INDENT = 2; 5. Create a getindent() method at the end of the MySaxParser class after the startelement() method. This method provides indentation for the parsing output to make it easier to read. private String getindent() { StringBuffer sb = new StringBuffer(); for (int i = 0; i < idx; i++) sb.append(" "); return sb.tostring(); } 6. Add the following code to each of the methods (indicated in bold) to add indenting to the output: public void characters(char[] ch, int start, int length) throws SAXException { //instantiates s, indents output, prints character values in element String s = new String(ch, start, length); if (!s.startswith("\n")) System.out.println(getIndent()+ " Value: " + s); } public void enddocument() throws SAXException { idx -= INDENT; System.out.println(getIndent() + "end document"); 40

41 } System.out.println("...PARSING ends"); public void endelement(string uri, String localname, String qname) throws SAXException { System.out.println(getIndent() + "end element"); idx -= INDENT; } public void startdocument() throws SAXException { idx += INDENT; System.out.println("PARSING begins..."); System.out.println(getIndent() + "start document: "); } public void startelement(string uri, String localname, String qname, Attributes attributes) throws SAXException { idx += INDENT; System.out.println('\n' + getindent() + "start element: " + qname); } 7. Save your project. Before we run the project, we need to make sure the Xerces library is accessible to the project within JBuilder. Go to Project > Project Properties. Click the Paths tab. Click the Required Libraries tab. Click Add. Navigate to the pre-defined Xerces library and add it, as shown in Figure

42 Figure 33: Required Libraries Adding the Xerces library to the project Let s run the project. Go to Run > Configurations. We need to modify the runtime configuration. Make sure that your MySaxParser class is in the Main Class box. If it isn t, using the ellipses button to navigate to your MySaxParser.java file. Add the application parameter: file:///c:\borland\jbuilder8\projects\saxhandler\shoppingcart.xml Click OK. This is shown in Figure

43 Figure 34: Runtime configuration properties Click your Runtime Configuration: MySaxParser, as shown below. Click the green play button and select your file. 43

44 In the output window, you should see the results of the parsed.xml file with added indents. PARSING begins... start document: start element: ShoppingCart start element: ShoppingCart start element: CustomerId Value: 1 end element start element: FirstName Value: Jessica end element start element: LastName Value: Baker end element start element: Address Value: 250 Bayberry Road end element start element: ZipCode Value: end element start element: Item Value: Jbuilder Enterprise end element start element: Qty Value: 25 end element start element: Company Value: XYZ Company end element 44

45 start element: JobCountry Value: USA end element. Much more Parsing of the ShoppingCart.xml file here, but it was left out due to its length.. start element: JobCountry Value: USA end element start element: FullName Value: Ritz, Carter end element end element end element end document...parsing ends You have now successfully used the Sax Handler wizard to create events, format, and parse your.xml. The Sax Handler wizard makes it easier to use Xerces parsing engine and generate event handler methods with the click of a button. XML DBMS Generate XML-DBMS files for fast table creation and data transfer with the JBuilder XML- DBMS wizard. The XML-DMBS wizard takes your.dtd file as input and generates an SQL file for table creation and a.map file, which describes how the data is transferred from the XML elements to the correct columns in the new database. With the Database Pilot, you can rapidly create your tables and test database connections. To create a new project, see the section Create a project. 45

46 Go to File > New. In the Object Gallery, choose the XML tab. Select XML-DBMS. The XML-DBMS wizard will start up. In Step 1, you will select your database connection and then test it. To set up a database connection, see Appendix B. After you have set up and selected your database connection, save the connection information and then test the connection, as shown in Figure 35. Figure 35: XML-DBMS Wizard Step 1 In Step 2 of the wizard, you with specify an existing input DTD file, a name for the Output Map file, and a name for the Output SQL file. JBuilder will generate a.sql file with table creation information and a.map file. 46

47 For this exercise, we will use the Employee.dtd file, located under <JBuilder home>\samples\tutorials\xml\databinding\fromdtd See Figure 36 for an example. Figure 36: XML-DBMS wizard, Step 2 Choose Finish. Look in the project pane and navigate to your new files. Examine the.sql and the.map files. Now, we will load the SQL script into the Database Pilot and execute it. Go to Tools > Database Pilot. Double-click your connection. For this exercise, we will use the pre-defined example connection. Choose the Enter SQL tab. Input the SQL statements from your newly generated Employees.sql file, and choose Execute, as shown in Figure

48 Figure 37: Database Pilot, enter SQL tab After clicking Execute, examine the newly created tables: XMLEmployee and XMLEmployees. Let s use the XML components in the JBuilder designer and transfer data from the Employee table to our new XMLEmployee table. Choose File -> New, General tab, select Class. Call your new class XML. Double-click your new XML class. On the bottom of the code editor pane, click the Design tab. Once the designer is launched, examine the palettes of components. Choose the XML tab. Select the XMLDBMSTable component. Drag and drop it onto the gray canvas. In the lower left-hand pane, right-click the xmldbmstable1 component, as shown in Figure

49 Figure 38: XMLDBMSTable1 component Click Customizer. In the Customizer window, select your database connection and test it. After you have a successful connection, click the Transfer tab. Choose XML to DB radio button. Navigate to your Employee.xml file as your Input XML file. Navigate to your Employee.map file as your Map file, as shown in Figure

50 Figure 39: Customizer Transfer tab configurations Click Transfer after you have filled in the appropriate input fields. Go to Tools > Database Pilot. Double-click your connection, navigate to the XMLEmployee table. Click it, and then in the right-hand pane, choose the Data tab. You can see that the data from the Employee table has been transferred to the XMLEmployee table. Additional to this tutorial: To transfer data from the database to an XML file, choose the DB to XML radio button. You can also use the other XML components in the JBuilder designer for other database/xml manipulation. 50

51 Conclusion In thousands of software implementation projects around the world, JBuilder is the essential technology that speeds the development of XML, EJB, Web client, Web Services and database applications, supporting rapid deployment to leading applications servers for the J2EE platform. With enhanced techologies for team productivity and efficiency, JBuilder is engineered to enable Java development teams to create reliable, enterprise-class applications fast. Appendix A Resources: Borland XML: marshalling and unmarshalling Borland XML provides a data binding mechanism that hides the details of XML and reduces code complexity with increased ease of maintenance. Borland XML is a template-based programmable class generator used to generate JavaBean classes from a Document Type Definition (DTD). You then use the simple JavaBean programming convention to manipulate XML data without worrying about the XML details. Borland XML uses DTDs in a two-step process to generate Java classes. In the first step, Borland XML generates a class model file from a DTD. The class model file is an XML file with.bom extension. This file describes a high-level structure of the target classes and provides a way to customize these classes. In the second step, Borland XML generates Java classes from the.bom file (class model XML file). 51

52 Borland XML supports several features: 1. JavaBean manipulation: manipulates a bean to construct an XML document or access data in the document. 2. A marshalling framework for conversion between Java and XML. 3. Document validation: validates JavaBean objects before marshalling objects to XML or after unmarshalling an XML document back to JavaBean objects. 4. PCDATA customization: allows PCDATA to be customized to support different primitive data types, such as integer and long, and to support customized property names. 5. Variable names: allows generated variable names for elements and attributes to have customized prefixes and suffixes. 52

53 Marshalling framework: See also "The XML Databinding Specification" at Appendix B The Database Pilot The JBuilder Database Pilot is an easy tool used for setting up database connections via your specified JDBC driver. You can access your application data within JBuilder, which saves time and keeps all development in one environment the JBuilder IDE. 53

54 To set up your database connection and JDBC driver from within JBuilder, go to Tools > Database Pilot. See Figure 40: Database Pilot. Figure 40: Database Pilot We have created a connection to JDataStore, the database written entirely in Java that ships with JBuilder. You can see that the test connection was successful and the tables in the database are listed. Note the URL and Driver information in the right pane of the window. To create a new connection, in the Database Pilot, choose File > New. Choose your database driver and enter the URL. If your driver is not listed, you must add it to JBuilder. You can do this by going to Tools>Enterprise Setup > Database Drivers tab. The Borland JBuilder development environment is the core of the Borland software platform for Java and a critical element in the Borland Suite of application lifecycle management 54

55 technologies. Designed to give developers the tools they need to maximize productivity in the development of enterprise applications, JBuilder enables development teams to do more: reduce development costs, deliver consistent, high-quality applications, and shorten time-tomarket. In fact, from within the JBuilder IDE, developers can manage the entire application development lifecycle, from design to deployment. Made in Borland. Copyright 2003 Borland Software Corporation. All rights reserved. All Borland brand and product names are trademarks or registered trademarks of Borland Software Corporation in the United States and other countries. Microsoft, Windows, and other Microsoft product names are trademarks or registered trademarks of Microsoft Corporation in the U.S. and other countries. Linux is a registered trademark of Linus Torvalds. All other marks are the property of their respective owners. Corporate Headquarters: 100 Enterprise Way, Scotts Valley, CA Offices in: Australia, Brazil, Canada, China, Czech Republic, France, Germany, Hong Kong, Hungary, India, Ireland, Italy, Japan, Korea, the Netherlands, New Zealand, Russia, Singapore, Spain, Sweden, Taiwan, the United Kingdom, and the United States