Object caching provides a mechanism to store frequently accessed data in memory, minimizing the calls to back-end database, and resulting in significant improvement in the application performance. By making caching an Aspect we get the flexibility of dynamically adding caching ability in a J2EE application for cached objects. We can also remove caching out of the application whenever it becomes a bottleneck in terms of memory usage. In this article, I will provide an example of object caching as an Aspect in J2EE applications and discuss the steps involved in injecting the caching functionality into a sample web application.

Describes techiques (such as an in-memory database) for reducing the execution time and maintenance costs of automated regression test suites.

This tutorial presents a real-world example that integrates IBM® Informix® and ZK, a rich Internet application (RIA) framework. Informix is a flagship IBM RDBMS product, while ZK is a Java-based web application framework supporting Ajax applications. This event-driven framework enables creation of rich user interfaces with minimal knowledge and use of JavaScript. ZK's unique server-centric approach enables synchronization of components and events across the client and server via the core engine.

The connection between object-oriented systems and relational databases is commonly solved by employing a so-called O/R mapping (ORM) framework whose goal it is to map object-oriented models to entity relationship models which are used, often generated, in relational databases. An unwritten consensus in the industry is that the best approach in solving these problems is a process where the business requirements are modelled in the object domain and where the resulting object model is mapped via an O/R mapping framework into the relational database system. This article proposes a reversed approach where the modelling is done in the relational tier and as much business logic as possible is handled within the database by employing a set of stored procedures as the middle tier.

A burst of innovation in the open source world over the last few years has led to an increase in Java™ developer productivity. Freely available tools, frameworks, and solutions address once-common time sinks. A promising new entry on the scene is Apache CouchDB, hailed by some as the database for Web 2.0. The big picture of CouchDB is easy to grasp, and using it is as simple as using a Web browser. This Java development 2.0 column introduces CouchDB and shows you how Groovy's RESTClient can help you tap into its strengths.

Conflicting requirements, such as those related to security, performance, and economy, multiply the challenge of integration developments typical in programming in the oil-and-gas industry. One technique that can help ease the burden on slimmed-down development teams is to centralize database accesses through the open source SQL Relay product.

This article explains database objects: what they are, how they act, how they are stored, and how they relate to one another.

One pattern that shows up repeatedly is creating a Many-to-Many relationship using a mapping class. In Rails, the hasMany/through directive provides this functionality. Grails doesn't have an explicit hasMany/through statement like Rails. Rather, Many-to-Many relationships are created implicitly by GORM via your domain classes.

This article focuses on another area that Grails makes easy: persistence using the Grails Object Relational Mapping (GORM) API. I'll start by describing what an object-relational mapper (ORM) is and how to create a one-to-many relationship. Next, you'll learn about data validation, ensuring that your application isn't plagued with garbage in/garbage out syndrome. You'll see the Grails ORM domain-specific language (DSL) in action, which allows you to fine-tune how your POGOs (plain old Groovy objects) are persisted behind the scenes. Finally, you'll see how easy it is to swap out one relational database for another. Any database with a JDBC driver and a Hibernate dialect is fair game.

In this Mastering Grails installment, Scott Davis explores the various ways that Grails can use database tables that don't conform to the Grails naming standard. If you have Java™ classes that already map to your legacy databases, Grails allows you to use them unchanged. You'll see examples that use Hibernate HBM files and Enterprise JavaBeans 3 annotations with legacy Java classes.