<?xml version="1.0" encoding="ISO-8859-1" standalone="no"?>
<!DOCTYPE rss PUBLIC "-//Netscape Communications//DTD RSS 0.91//EN" "http://my.netscape.com/publish/formats/rss-0.91.dtd">

<rss version="0.91">
	<channel>
		<title>TrooBloo - JavaBeans</title>
		<description>Articles and tutorials regarding JavaBeans</description>
		<link>http://www.troobloo.com/tech/javabeans.shtml</link>
		<language>en-us</language>

		<item>
			<title>JavaBeans: Unlocking the BeanContext API</title>
			<link>http://developer.java.sun.com/developer/technicalArticles/jbeans/BeanContext/</link>
			<description>By Onno Kluyt (May 1999) Since the introduction of the JavaBeans TM component architecture in the Java TM Development Kit v 1.1 (JDK TM ) release in February 1997, additional specifications have been added to this component architecture such as the Extensible Runtime Containment and Services Protocol and the InfoBus standard extension. Both of these additions provide APIs that enable Beans to interconnect during run-time. Read on to learn more about the Extensible Runtime Containment...</description>
		</item>

		<item>
			<title>Serialize Java Data Objects to XML</title>
			<link>http://www.fawcette.com/javapro/2003_06/magazine/features/chavener/</link>
			<description>June 2003 Issue ADVERTISEMENT O ne of the least publicized new features of the Java Development Kit (JDK) 1.4 is the java.beans.XMLEncoder/XMLDecoder, which is built into the java.beans package. At a stroke this feature makes it possible to easily save and restore Java data objects, graphs of objects, and GUI state to a compact XML form that is so robust it continues to be usable even when the original class definitions change. There is nothing to download and install. It certainly...</description>
		</item>

		<item>
			<title>Let InfoBus Plug Your Beans Together</title>
			<link>http://developer.java.sun.com/developer/technicalArticles/jbeans/Infobus/</link>
			<description>by Mark Colan and Christopher J. Karle (March 1998) The InfoBus is a public specification of dynamic data-sharing technology that enables developers to equip their JavaBean components to communicate with other JavaBean components. InfoBus was jointly designed by Lotus Development Corporation and Sun Microsystems' JavaSoft division; the final release 1.1 specification, the release candidate for InfoBus 1.1, and other information about InfoBus can be found at...</description>
		</item>

		<item>
			<title>Decoupling Application Logic, Persistence, and Flow: The Model Technique</title>
			<link>http://www.developer.com/design/article.php/3306961</link>
			<description>By Michael Nash JavaBeans and Object-Oriented Design Virtually every Java developer is familiar with the JavaBean specification. One of the most important parts of this specification is the use of certain predictable method signatures to control properties of the bean (e.g. the &quot;getXXX&quot; and setXXX&quot; methods we all know and love). JavaBeans are of course a specific instance of the general object-oriented method that is a foundation of any well-structured Java application. Objects are, in...</description>
		</item>

		<item>
			<title>JDO vs. Entity Beans: A Modest Proposal</title>
			<link>http://www.oreillynet.com/pub/a/onjava/2002/02/20/jdoview.html</link>
			<description>by Marek Mosiewicz 02/27/2002 When Sun introduced the EJB 1.1 spec (including Entity Beans) two years ago, it was a revolution in enterprise computing. Experience revealed, however, that it was not perfect. The remote interface is slow and it makes creation of fine-grained objects difficult, in many cases. The Java Data Objects (JDO) interface was later introduced as a new interface for storing objects to a data store, which in many cases could be a replacement for Entity Beans. At...</description>
		</item>

		<item>
			<title>Building Java Enterprise Applications: Business Logic, Part 3</title>
			<link>http://www.oreillynet.com/pub/a/onjava/excerpt/bldgjavaent_8/index3.html</link>
			<description>Related Reading Building Java Enterprise Applications vol I: Architecture By Brett McLaughlin Table of Contents Index Sample Chapter by Brett McLaughlin This is the final part of an extended excerpt from Chapter 8 of Building Java Enterprise Applications, Vol I: Architecture . This installment focuses on issues of statefulness and statelessness. The second article looked at the UserManager component. The first installment covered the facade pattern, a way to use session beans to access...</description>
		</item>

		<item>
			<title>XML JavaBeans TM Integration, Part 3</title>
			<link>http://developer.java.sun.com/developer/technicalArticles/jbeans/XMLJavaBeans3/</link>
			<description>by Mark Johnson, JavaWorld July 1999 This article completes the three-part series on the XMLBeans package (see Resources for the previous two articles in the series). Simply put, XMLBeans can transform a JavaBean in memory into an XML document, or can transform an XML document (of a particular form) into a running JavaBean. Figure 1 shows an extremely simplified schematic of the concept. If you've experimented with XML and JavaBeans in this series, you'll have noticed that the...</description>
		</item>

		<item>
			<title>Netscape TM Proposes a New Standard for Communication Among JavaBeans, Objects</title>
			<link>http://developer.java.sun.com/developer/technicalArticles/jbeans/Netscapeprop/</link>
			<description>Lisa Stapleton, JavaSoft (June 1997) Netscape Communications Corp. unveiled details of its new proposed model for using JavaSoft's JavaBean TM technology, and demonstrated a prototypical application based on the new BeanConnect model at the Netscape Developer Conference. The model would let all Java objects in a BeanConnect program run in the same execution space in the Java TM Virtual Machine 1 , and would allow direct communication between Java objects. Thus, Java objects embedded in...</description>
		</item>

		<item>
			<title>XSLT and JSP: A Dynamic Combination</title>
			<link>http://www.fawcette.com/xmlmag/2002_04/magazine/columns/presentation/cson/</link>
			<description>S ince Sun released the Java 2 Enterprise Edition (J2EE) specification in December of 1999, there has been a tremendous push toward object-oriented programming. The Enterprise JavaBeans component is built around business objects session beans representing different parts of a business model and entity beans representing persistent data in a database. When creating dynamic content, you can reuse these objects by employing tags and custom tags within JavaServer Pages (JSP). Further, these...</description>
		</item>

		<item>
			<title>Building Java Server Pages</title>
			<link>http://www.webdevelopersjournal.com/articles/jsp_build.html</link>
			<description>by Mark Webber If you've ever used Microsoft's very popular Active Server Pages (ASP) then you'll have a good idea of what JSP is. It consists of HTML or XML markup into which special tags and code blocks are inserted. The code is executed on the server and the result is a dynamic page that is returned to the client browser. Although JSPs are simple to build they have at their disposal the full power of object-oriented Java and the Java Server API. JSPs make heavy use of Java Beans,...</description>
		</item>

		<item>
			<title>Enterprise JavaBeans</title>
			<link>http://developer.java.sun.com/developer/technicalArticles/ebeans/EJBEntity/</link>
			<description>By Monica Pawlan (November 1998) Today, more and more developers want to write distributed transactional applications for the enterprise, and leverage the speed, security, and reliability of server-side technology. One approach is to use a multitiered model where a thin-client application invokes business logic that executes on the server. Normally, thin-client multitiered applications are hard to write because they involve many lines of intricate code to handle transaction and state...</description>
		</item>

		<item>
			<title>Introspective JavaBeans</title>
			<link>http://www.fawcette.com/javapro/2004_07/magazine/columns/proshop/</link>
			<description>Posted June 13, 2004 I 've always found building graphical user interfaces in Java to be a chore. I've tried GUI builders, user interface languages, and most recently scripting languages like Groovy and Jelly. In the end, I always find that writing Java code is the only way to get done exactly what I want. For the most part, I avoid using Java for desktop applications and use it mostly for server applications with Web-based interfaces, dodging the GUI issue altogether. However, there...</description>
		</item>

		<item>
			<title>Test Infect Your Enterprise JavaBeans TM</title>
			<link>http://developer.java.sun.com/developer/technicalArticles/J2EE/testinfect/</link>
			<description>by Michael T. Nygard and Tracie Karsjens ; Reprinted from JavaWorld Software can never be tested sufficiently, and testing usually starts too late, particularly for J2EE TM applications. Since components often behave differently when they are alone than when they have been assembled, testing each component individually before two or more components are joined together ensures each piece of code in a J2EE application will work as it was designed to do. Then, if an error occurs in the...</description>
		</item>

		<item>
			<title>An Introduction to Enterprise JavaBeans TM Technology</title>
			<link>http://developer.java.sun.com/developer/technicalArticles/ebeans/IntroEJB/</link>
			<description>By Bill Roth (October 1998) There is a fundamental problem facing enterprise developers today. Writing distributed business applications is difficult. Writing any large application is difficult. This is compounded if the application is distributed, or lives in multiple pieces on a network. This is further compounded if the application must execute its business logic in a guaranteed, reliable fashion. Another complication that enterprises face is that they are themselves fundamentally...</description>
		</item>

		<item>
			<title>Automating EJB Unit Testing</title>
			<link>http://www.oreillynet.com/pub/a/onjava/2003/02/05/automate_ejb.html</link>
			<description>by JiRong Hu 02/05/2003 Testing EJB is different Container matters Enterprise Java Beans, or EJBs, cannot be tested on their own as can plain Java classes. There are additional steps to deploy them to an EJB container before they can be tested. This means that our testing process must include the additional process of deployment and re-deployment of EJBs. The deployment must be automated as well. There are some arguments on the differences between running the EJB test client inside or...</description>
		</item>

		<item>
			<title>EJB Inheritance, Part 1</title>
			<link>http://www.oreillynet.com/pub/a/onjava/2002/09/04/ejbinherit.html</link>
			<description>by Emmanuel Proulx 09/04/2002 Java is an object-oriented language, which means it follows the principles of object-oriented programming, such as encapsulation, inheritance, and polymorphism. (Inheritance and polymorphism pretty much go together, so they are often simply referred to as inheritance, which is what I will do in these articles.) These are great principles and can be used to represent relationships between objects in very powerful ways. Entity beans are objects that represent...</description>
		</item>

		<item>
			<title>Critical Steps to Secure Tomcat on Windows NT/2K/XP</title>
			<link>http://www.developer.com/java/ent/article.php/2241061</link>
			<description>By Akash Kava Tomcat is a worldwide-used Web server for JSP and servlets. It runs with proper the JAVA Runtime and supports object-oriented Web application deployement. Running Tomcat is simple; just install Tomcat with the default installer given on Tomcat's website. No one knows fully how dangerous Tomcat is. The major security risks with Tomcat Web applications are the following: Tomcat's JSP or bean called in JSP can do the following highly risky tasks: Run an application in System...</description>
		</item>

		<item>
			<title>XML Persistence Pays Off</title>
			<link>http://www.fawcette.com/javapro/2004_09/magazine/features/kgauthier/</link>
			<description>August 13, 2004 I worked with the JavaBeans XML Persistence API for more than a year before I realized that I could use it to serialize any object. When its default mechanisms did the trick, the API produced compact, version-resilient archives. When they failed, however, I thought that extending the API wasn't worth the trouble. This misconception was unfortunate because it kept me from using the full potential of XML persistence. With just a little knowledge, I could easily have...</description>
		</item>

		<item>
			<title>Filtering JNDI Operations</title>
			<link>http://www.fawcette.com/javapro/2004_10/magazine/features/blimaye/</link>
			<description>August 30, 2004 S uppose you have an existing J2EE application with Enterprise JavaBeans (EJBs), Remote Method Invocation (RMI) objects, Java Message System (JMS) destinations, and other objects bound into a Java Naming and Directory Interface (JNDI) registry. During the course of the project schedule you need to make significant changes to the underlying architecture, redefine business processes, or need to identify transactional and performance problems. Without a proper framework in...</description>
		</item>

		<item>
			<title>Introducing Betwixt</title>
			<link>http://www.developer.com/java/ejb/article.php/3550616</link>
			<description>By Vikram Goyal Go to page: 1 2 3 4 Next Betwixt is a Jakarta Commons component that provides XML introspection routines for mapping JavaBeans to XML and vice versa.. It uses concepts similar to the JavaBeans Introspector and BeanInfo to decipher information about XML data and map it to JavaBeans. Digester rules are used to create JavaBeans from XML internally. Betwixt lies in the category commonly classed as data-binding tools Betwixt is a feature rich product that provides a lot of...</description>
		</item>

		<item>
			<title>Introduction to EJBs</title>
			<link>http://www.developer.com/java/ejb/article.php/1434371</link>
			<description>J2EE provides different types of components for different purposes. Today, you will start to look at one of the principal types of component in J2EE Enterprise JavaBeans (EJBs). The study of EJBs is continued on Day 5, &quot;Session EJBs,&quot;, Day 6, &quot;Entity EJBs&quot;, Day 7, &quot;CMP and EJB QL&quot;, Day 8, &quot;Transactions and Persistence&quot;, and Day 10, &quot;Message-Driven Beans&quot;. As you can see, there is a lot to learn about EJBs, so today serves as a first step on the road to all of this EJB knowledge. Today,...</description>
		</item>

		<item>
			<title>Enterprise Java without Tears</title>
			<link>http://www.sdmagazine.com/documents/sdmsdw3a/</link>
			<description>At Scott Ambler5;s strenuous give-and-take, discussion grew dicey, but no one cried By Rick Wayne March 28, 2003 In his March 26, 2003, SD West panel discussion, 6;Enterprise JavaBeans Don5;t Support Complex Object Models: What to Do,6; Scott Ambler gestured at the panelists. 6;If you can make them cry,6; he told the audience, 6;we5;ll count this one a success.6; The panelists mimed shock and fear. Ambler, the president of Ronin International, didn5;t want the audience to pull any...</description>
		</item>

		<item>
			<title>What is Java 2 Micro Edition?</title>
			<link>http://www.developer.com/ws/j2me/article.php/1378921</link>
			<description>By Eric Gigu&#xE8;re Java is known primarily as a server-side programming environment, centered around the technologies that make up the Java 2 Enterprise Edition (J2EE), such as Enterprise JavaBeans (EJBs), servlets, and JavaServer pages (JSPs). Early adopters of Java, however, will recall that it was originally promoted as a client-side application environment. In fact, Java was originally designed as a programming language for consumer appliances. Now Java is returning to its roots with...</description>
		</item>

		<item>
			<title>Develop enterprise Java applications with POJOs in Action</title>
			<link>http://www.javaworld.com/javaworld/jw-07-2006/jw-0703-pia.html</link>
			<description>Avoid the problems associated with EJB by working with plain-old Java objects and lightweight frameworks Summary Many enterprise Java developers have discovered that Java EE's Enterprise JavaBeans framework causes more problems than it solves. POJOs in Action is a book that identifies these problems and presents an alternative based on plain-old Java objects and lightweight frameworks. In this article, Jeff Friesen reviews this book chapter by chapter. ( 2,000 words; July 3, 2006 ) By...</description>
		</item>

		<item>
			<title>Jumping Into JBoss</title>
			<link>http://www.developer.com/java/ejb/article.php/3071661</link>
			<description>By Thornton Rose and David Thurmond Go to page: 1 2 3 Next JBoss is a free, open source, application server that implements the complete Java 2 Enterprise Edition (J2EE) stack, including Java Server Pages (JSP), servlets, and Enterprise JavaBeans (EJB). For J2EE developers that are getting started with JBoss, this article presents the basics, including downloading, installation, application deployment, and data source configuration. Tools To run JBoss, you will need the following tools:...</description>
		</item>

		<item>
			<title>Spring into JavaServer Faces</title>
			<link>http://www.developer.com/java/ent/article.php/3602061</link>
			<description>By Michael Klaene Go to page: 1 2 Next In the context of Java development, the Spring framework and JavaServer Faces are two names that frequently come up in conversation. Spring is a powerful application framework that rivals Enterprise JavaBeans in the breadth of its features. JavaServer Faces, commonly known as JSF, is a component-oriented, event-driven framework for building Web applications. Given the popularity of both Spring and JSF, it is natural that there will be some interest...</description>
		</item>

		<item>
			<title>Automate Updates of Dynamic Web Apps</title>
			<link>http://www.fawcette.com/javapro/2003_02/magazine/columns/weblication/</link>
			<description>February 2003 Issue ADVERTISEMENT W riting Web applications is a challenge. Just a few static pages on a simple Web site require hours of work, even with the use of an automated HTML generator. A dynamic multitier application with several pages, code driven by script, JavaBeans, servlets, and a database back end turn out to be far more complex and time-consuming than first meets the eye to say the least. My own Web site, which I originally intended to update once every couple of weeks,...</description>
		</item>

		<item>
			<title>Integrated Testing Builds In Quality</title>
			<link>http://www.fawcette.com/javapro/2003_05/magazine/features/pvarhol/</link>
			<description>May 2003 Issue A pplication development tools have spent the last several years maturing and building up compliance with successive versions of Java Development Kits (JDKs); Java standard and enterprise edition toolkits; and supporting technologies such as JavaServer Pages (JSPs), Enterprise JavaBeans (EJBs), Java API for XML (JAX), JDBC, and a host of others. Today you can use virtually any Integrated Development Environment (IDE) to build a distributed application, using virtually any...</description>
		</item>

		<item>
			<title>Wiring Java Applications with Spring</title>
			<link>http://www.developer.com/java/other/article.php/3504506</link>
			<description>By Michael Klaene Go to page: 1 2 3 Next The Spring Framework In 2002, J2EE expert Rod Johnson published an influential book entitled Expert One-on-One J2EE Design and Development . This book encouraged readers to take a more pragmatic approach to developing J2EE applications, rather than just assuming standard technology, such as Enterprise JavaBeans (EJBs), were always the best solution to the problem. Rod suggested that there was a rather wide gap between the promise of technology...</description>
		</item>

	</channel>
</rss>
