Cheap Java Services With Tomcat, Jsp, Php, Mysql, J2Ee, Servlet, Struts & Hibernate Hosting Support and Coldfusion Web Hosting

Try It Out Reverse Engineering a Schema You will need to have Java installed to run Trang, specifically a Java Runtime Environment (JRE) for the Java 2 Platform, Standard Edition (J2SE) version 1.4 or any later. This is a free download from http:// java.sun.com/j2se/downloads.html. Trang itself is available from www.thaiopensource.com/relaxng/trang.html. Once you have Java and Trang installed, follow these steps: 1. Copy the RSS 2.0 example file rss2example.xml into the directory into which you installed Trang. 2. Open a command window in that directory. 3. Enter the following command: java -jar trang.jar rss2sample.xml rss2.rnc After pressing Return, the command prompt should reappear, hopefully without any error message. If you look in the current directory you should see a new file, rss2.rnc. 4. Open rss2.rnc in a text editor. You should see the following: default namespace = start = element rss { attribute version { xsd:decimal }, element channel { title, link, description, element language { xsd:NCName }, pubDate, element lastBuildDate { text }, element docs { xsd:anyURI }, element generator { text }, element managingEditor { text }, element webMaster { text }, element item { title, link, description, pubDate, element guid { xsd:anyURI } }+ } } title = element title { text } link = element link { xsd:anyURI } description = element description { text } pubDate = element pubDate { text } 259 Modeling Feed Data
Note: In case you are looking for affordable and reliable webhost to host and run your j2ee application check Vision J2ee Web Hosting services.

version #REQUIRED> Most XML standard specifications ship with at least some form of schema, in fact the schema is usually created before any real data. But there isn t an official DTD for RSS 2.0, and truth be told no-one actually sat down and worked out the DTD listed previously. For relatively simple XML formats such as RSS 2.0 it s possible to take advantage of automatic tools to generate at least approximations to their schemas, which you can then handedit as needed. The tool used here was Trang, a free command-line Java application. Given a sample of an XMLformat it can generate a DTD, XML Schema, or RelaxNG schema corresponding to the format. 258 Chapter 20
We recommend high quality webhost to host and run your jsp application: christian web host services.

An XML Model The emphasis with syndication languages has often been down with the syntax after all, their purpose is to deliver data from Ato B, so the format of the data is significant. XML doesn t have a model in the formal sense, although its syntax structure is usually thought of as if it brought a data model to whatever it is used to represent. In general, the structure of XML documents is often used to represent lists or hierarchical data structures, and programming tools such as the Document Object Model (DOM) take advantage of the parent-child tree structure. In these terms RSS, particularly the plain-XML varieties, and Atom can be seen as having a hierarchical model. Figure 20-8 is a trimmed-down version of the RSS 2.0 example listed earlier, as displayed in the XMLmind XML editor (free, multiplatform: www.xmlmind.com). Figure 20-8 The hierarchical structure of the elements is clear, and this can work as a starting point for an XML-oriented approach to modeling feeds. If you are interested in generating original feeds, then such an approach can offer a very quick solution. However, there are drawbacks if you want to use data from other people s feeds, largely due to the not-quite- XMLnature of many feeds. The RSS formats are unusual compared to most XML languages. The Really Simple versions are fairly loosely specified, and have lacked even a DTD since Netscape s version 0.91. The RDF-based versions are strictly defined by comparison. But again there s a problem with using DTDs and XMLSchemas valid RDF/XML extensions may break XML validity. However, if you assume that you are responsible for generating the data (or can suitably filter other people s data), DTDs or XML schemas can be used as the basis of a model. A DTD for RSS 2.0 would look something like the following: Looking for affordable and reliable webhost to host and run your business application? Then look no more and go to servlet web hosting services.

Parallel Elements There are clear parallels between the entities supported by the different syndication formats after all, they share the same historical roots and aim to fulfill more or less the same purpose. The following table lines up these formats against each other, with the Model column using the word that s most commonly used when talking about these entities. Model RSS 1.0 RSS 2.0 Atom Feed rss:channel channel atom:feed Item rss:item item atom:entry Title dc:title title atom:title Date dc:date pubDate atom:issued Content dc:description, description, atom:content content:encoded xhtml:body Author dc:creator author atom:author There are various restrictions on the values that can appear in the elements and attributes in the RSS and Atom specifications. But as noted earlier, these aren t much for use as constraints, and for modeling purposes most can be reduced to simple strings. What causes a lot of work in practice is that the data appearing in the feeds is expressed in different ways, for example RSS 1.0 dates follow the W3CDTF (ISO 8601) format, whereas RSS 2.0 uses the RFC 822 format. But again this is a detail of the data, and doesn t really affect the overall models. Groups of Feeds Any application that uses data from multiple feeds will need to keep track of the feed addresses. In its simplest form, a subscription list could just be a set of feed URIs held in a text file. However, most applications will want to present the user with a little more information than this, such as the name of the feed, the author, and perhaps her e-mail address, and so on. Afairly common requirement is the ability to exchange lists of feeds or render them in a readable form. Afew alternate approaches and formats have appeared for this purpose, and support for them in syndication tools varies. You will see examples of these later in the chapter. Extending Structures RSS and Atom systems are generally designed for syndication, aggregation, and viewing of news-like material. As a result the formats primarily cover the essentials for this job: title, description, and so on. However, the technologies can allow much richer material to be syndicated and aggregated. In terms of the formats, this means including terms from other XML or RDF vocabularies in the feed. In terms of the model, this can mean that completely arbitrary structures can appear. In practice there aren t yet a great deal of extensions currently in use, it s something of a chicken and egg situation with the publication and subscription tools. 256 Chapter 20
Please visit our professional web hosting services to find out about cheap and reliable webhost service that will surely answer all your demands.

http://www.example.org/stuff … However, there followed a drift in the use of RSS as pure metadata about a resource to becoming a delivery mechanism for the resource itself. In other words, RSS got content. This gave the item something of a split personality, as demonstrated in this snippet of RSS 1.0:
http://www.example.org/two Here is an item. This is an item … By its unambiguous RDF/XML interpretation, the item the description property refers to is the resource identified in the rdf:about attribute. But what does it mean for the resource also to have a (different)
URI? What is the relationship between the content here and the identified resource? The most Web architecture friendly interpretation would probably be that the inline content is a representation of the (rdf:about) identified resource, which may have other representations you can get over HTTP using the first URI. In these terms it s probably safest to think of the
as being a related resource. But the true interpretation only matters if people treat the material that way. The grassroots development of syndication has generally meant a shiny new feature stands a much better chance of adoption than any amount of theoretical spec-compliance. GUID Item identification became a problem for the simple XML-style formats because there was no reliable way of telling whether two items were the same. The result was that an item that had been published and later edited again could show up twice in newsreaders. This may sound obvious, but RSS 0.9x items already had fairly distinguishing features such as their title and pubDate (when the item was published). Except that pubDate was the official publication date, rather than any more dependable fixed point in time. The title could be changed at any time. So a new element was introduced: . Here is an example of how it might appear in a feed: http://example.org/three.html The optional isPermaLink attribute is an http: scheme URI that can be used to get a HTML representation of the item. Its default value is true, so most of the time the value of the element is equivalent to the RSS 1.0 rdf:about identifier. There is a caveat the isPermaLink value might be false and the text of the element may not be a URI at all, it can be any string that the source of the feed has established as unique. Crisis, What Crisis? The bottom line is that the RSS formats are pragmatic solutions to the problems that were around when the specs were authored, much of which related to the behavior of existing aggregator tools. One of the aims of Atom is to sort out such muddles and build on what are considered best practices in terms of the overall architecture of the Web. However, Atom is also constrained by the real-world demands of developers. So although existing specifications are followed closely, and ambiguity avoided wherever possible, there is bound to be some degree of improvising to make things work in the fairly messy environment of the Web. 255 Modeling Feed Data
Note: In case you are looking for affordable and reliable webhost to host and run your j2ee application check Vision J2ee Web Hosting services.

Identity It s necessary to identify things before you can talk about them, no matter how abstract the things are. For humans, identification comes down to naming or labeling the things of interest. Similarly, from a computer s point of view, naming and labeling are the key. The Internet is a big place, and there s a potential risk of two different things being given the same name. There are ways of avoiding this, however, by providing Uniform Resource Identifiers (URIs). Uniform and Unique To avoid ambiguity it s desirable to give anything else you want to talk about on the Web a URI. It isn t essential, and some things aren t very amenable to this kind of identification people, for example. But when the resources are on the Web anyhow, it can make life easier. There are really two pieces to identification on the Web, URIs, and URI References (URIRefs). A URI is generally the absolute part, of the form http://example.org/thing. A URIRef may be a URI, a relative reference, or have an additional fragment identifier like this: http://example.org/ thing#part. These are rather evasive concepts that seem to behave differently at different times, whether they re used as identifiers (such as in RDF) or as locators (over HTTP). The whole issue of URIs and URIRefs has proved something of a nightmare for the W3C s Technical Architecture Group, though fortunately in practice rarely causes problems. Aside from the arcane details of URIs themselves, there s an identity issue specific to syndication formats. To locate and obtain a feed in the first place it s necessary to know its URI, but when it comes to identifying individual items, there are complications. It can be difficult to tell the relationship between an item URI, a link URI, and any inline content there may be. This issue has its roots in the use of RSS as pure metadata, without any content. The original RSS 0.9 included a link element like this:
http://www.example.org/stuff … The item being described is the resource identified by that URI. Similarly, the RDF/XML-based RSS 1.0 give items an identifier like this: As the attribute name suggests, the properties of the item (title, description, and so on) will all be about the resource identified by that URI. But RSS 1.0 also adds a link for The item s URL. This has generally been taken to mean the URI of an HTML version of the item, and will usually be the same URI:
http://www.example.org/stuff … The non-RDF thread of RSS also included a link element, which appeared in RSS 0.91 looking the same as in RSS 0.9: 254 Chapter 20
Note: In case you are looking for affordable and reliable webhost to host and run your j2ee application check Vision J2ee Web Hosting services.

the relationship between these two entities will be something like creator. Acommon relationship is is-a, as in the author is a person. This relationship crops up a lot in software where the entities are classes or type, and particular items are individual members of that class or have that type (in English you might say my home page is a Web page, for example). The entities themselves can be said to have attributes, a set of qualities of different types. For example, a person entity will probably have an attribute name, so you could say (in English) the author s name is Charles Dickens. The entity-relationship way of looking at systems led to the development of specific set of techniques for modeling, and this approach is (not surprisingly) known as Entity-Relationship Modeling (E-R). Most CASE (Computer-Aided Software Engineering) tools allow you to describe systems in terms of entities and relationships one way or another because it s a fundamental way of developing a data model. In the context of modeling feeds, it s not necessary to go the entire formal E-R route to take advantage of the basic ideas. For a particular kind of data, if you can select the entities, the attributes of those entities and the relationships between them, you have the essence of a data model. Entities in Feeds The entities in feeds roughly correspond to the elements in the XML format; there is the feed or channel itself, and the individual items. The feed has a set of attributes (title, description, and so on) as does each item. However, there is a slight snag in that some of the attributes could equally well be described as entities in their own right. The part of an RSS 2.0 feed might contain a whole document, the text in the
element will be the URL of a document on the Web. Although in modeling you are looking at things at a conceptual level, what you decide should be entities and what should be attributes of those entities will be determined very much by what you want to do with them in practice. In the context of this book that means storing and manipulating feed data. The approaches covered in this chapter are XML-based, relational database-based, Object-Oriented and RDF-based, and as you will see the E-R models would look a little different in each case. Relationships in Feeds Starting at the top, the primary relationship between a feed and its items is one of containment. This can be seen as a variation of the document-oriented view that, at a given point in time, the document retrievable from a feed URL contains items [X, Y, Z]. Amore useful view is that the conceptual feed (identified with the URI) contains every item ever published and every item that will ever be published from that address. This is a better fit for the item-oriented approach, although obviously some awareness of particular items will be needed there s not a lot useful information associated with blog posts that haven t yet been written. The relationship between an item and its associated elements is a little trickier to describe. On the one hand, the