Using Derby as a Network Database Server Engine
The initial promise of Derby has been its applicability to embedded solutions—i.e., situations in which a complete light-footprint database engine is incorporated into a small software component or environment. In this context, Derby really delivers on the promise of component-oriented development because with it you can embed a standalone database into an application based on a browser. This aspect of Derby has received much attention, and you can follow up on this by studying the detailed examples that come with Sun's Derby distribution. However, Derby has another side that hasn't received so much attention: It can function as a network database server engine. This is an interesting development because it might potentially start to compete with the established vendors in this space.
In this article, I want to introduce you to the network server side of Derby. As with my other article on the embedded version of Derby, I'll use some of the example programs that come bundled as part of the Derby distribution. So, if you don't already have one, the first thing to do is get yourself a copy of Derby from the Apache web site. It also 'might not be a bad idea to read my earlier Informit article ("Getting Started with Derby") to get acquainted with the embedded framework and the general Derby philosophy. So, while this article builds on the previous one, it's not mandatory that you read both.
The Network Server Framework
The Derby network server framework, on the other hand, differs from the embedded framework in that the former provides a continuously running server-style Java application that allows multiple, remote JDBC applications to connect to Derby. The major difference between the embedded and network-server frameworks is that the latter allows applications from multiple JVMs to access the same database. This database is the one provided by the network server and the multiple JVMs that access it are the clients. So, the network server framework frees you from the restriction of the embedded framework where all access must be from within the one JVM.