|
|
http://developers.sun.com/javadb/
Java SE 6 新特性:
Java DB 和 JDBC 4.0
http://www.ibm.com/developerworks/cn/java/j-lo-jse65/
长久以来，由于大量（甚至几乎所有）的 Java 应用都依赖于数据库，如何使用 Java
语言高效、可靠、简洁地访问数据库一直是程序员们津津乐道的话题。新发布的 Java SE 6
也在这方面更上层楼，为编程人员提供了许多好用的新特性。其中最显著的，莫过于 Java SE 6 拥有了一个内嵌的 100% 用 Java
语言编写的数据库系统。并且，Java 6 开始支持 JDBC 4.0 的一系列新功能和属性。这样，Java SE
在对持久数据的访问上就显得更为易用和强大了。
Java DB：Java 6 里的数据库
新
安装了 JDK 6 的程序员们也许会发现，除了传统的 bin、jre 等目录，JDK 6 新增了一个名为 db 的目录。这便是 Java 6
的新成员：Java DB。这是一个纯 Java 实现、开源的数据库管理系统（DBMS），源于 Apache 软件基金会（ASF）名下的项目
Derby。它只有 2MB 大小，对比动辄上 G 的数据库来说可谓袖珍。但这并不妨碍 Derby
功能齐备，支持几乎大部分的数据库应用所需要的特性。更难能可贵的是，依托于 ASF 强大的社区力量，Derby 得到了包括 IBM 和 Sun
等大公司以及全世界优秀程序员们的支持。这也难怪 Sun 公司会选择其 10.2.2 版本纳入到 JDK 6 中，作为内嵌的数据库。这就好像为
JDK 注入了一股全新的活力：Java
程序员不再需要耗费大量精力安装和配置数据库，就能进行安全、易用、标准、并且免费的数据库编程。在这一章中，我们将初窥 Java DB
的世界，来探究如何使用它编写出功能丰富的程序。
Hello, Java DB：内嵌模式的 Derby
既然有了内嵌（embedded）的数据库，就让我们从一个简单的范例（代码在 清单 1
中列出）开始，试着使用它吧。这个程序做了大多数数据库应用都可能会做的操作：在 DBMS 中创建了一个名为 helloDB
的数据库；创建了一张数据表，取名为
hellotable；向表内插入了两条数据；然后，查询数据并将结果打印在控制台上；最后，删除表和数据库，释放资源。
清单 1. HelloJavaDB 的代码
public class HelloJavaDB {
public static void main(String[] args) {
try { // load the driver
Class.forName("org.apache.derby.jdbc.EmbeddedDriver").newInstance();
System.out.println("Load the embedded driver");
Connection conn = null;
Properties props = new Properties();
props.put("user", "user1"); props.put("password", "user1");
//create and connect the database named helloDB
conn=DriverManager.getConnection("jdbc:derby:helloDB;create=true", props);
System.out.println("create and connect to helloDB");
conn.setAutoCommit(false);
// create a table and insert two records
Statement s = conn.createStatement();
s.execute("create table hellotable(name varchar(40), score int)");
System.out.println("Created table hellotable");
s.execute("insert into hellotable values('Ruth Cao', 86)");
s.execute("insert into hellotable values ('Flora Shi', 92)");
// list the two records
ResultSet rs = s.executeQuery(
"SELECT name, score FROM hellotable ORDER BY score");
System.out.println("name\t\tscore");
while(rs.next()) {
StringBuilder builder = new StringBuilder(rs.getString(1));
builder.append("\t");
builder.append(rs.getInt(2));
System.out.println(builder.toString());
}
// delete the table
s.execute("drop table hellotable");
System.out.println("Dropped table hellotable");
rs.close();
s.close();
System.out.println("Closed result set and statement");
conn.commit();
conn.close();
System.out.println("Committed transaction and closed connection");
try { // perform a clean shutdown
DriverManager.getConnection("jdbc:derby:;shutdown=true");
} catch (SQLException se) {
System.out.println("Database shut down normally");
}
} catch (Throwable e) {
// handle the exception
}
System.out.println("SimpleApp finished");
}
}
|
随后，我们在命令行（本例为 Windows 平台，当然，其它系统下稍作改动即可）下键入以下命令：
清单 2. 运行 HelloJavaDB 命令
java –cp .;%JAVA_HOME%\db\lib\derby.jar HelloJavaDB
|
程序将会按照我们预想的那样执行，图 1
是执行结果的一部分截屏：
图 1. HelloJavaDB 程序的执行结果
上述的程序和以往没什么区别。不同的是我们不需要再为 DBMS 的配置而劳神，因为 Derby 已经自动地在当前目录下新建了一个名为 helloDB 的目录，来物理地存储数据和日志。需要做的只是注意命名问题：在内嵌模式下驱动的名字应为 org.apache.derby.jdbc.EmbeddedDriver
；创建一个新数据库时需要在协议后加入 create=true
。另外，关闭所有数据库以及 Derby 的引擎可以使用以下代码：
清单 3. 关闭所有数据库及 Derby 引擎
DriverManager.getConnection("jdbc:derby:;shutdown=true");
|
如果只想关闭一个数据库，那么则可以调用：
清单 4. 关闭一个数据库
DriverManager.getConnection("jdbc:derby:helloDB;shutdown=true ");
|
这样，使用嵌入模式的 Derby
维护和管理数据库的成本接近于 0。这对于希望专心写代码的人来说不失为一个好消息。然而有人不禁要问：既然有了内嵌模式，为什么大多数的 DBMS
都没有采取这样的模式呢？不妨做一个小实验。当我们同时在两个命令行窗口下运行 HelloJavaDB
程序。结果一个的结果与刚才一致，而另一个却出现了错误，如 图 2
所示。
图 2. 内嵌模式的局限
错
误的原因其实很简单：在使用内嵌模式时，Derby 本身并不会在一个独立的进程中，而是和应用程序一起在同一个 Java
虚拟机（JVM）里运行。因此，Derby 如同应用所使用的其它 jar 文件一样变成了应用的一部分。这就不难理解为什么在 classpath
中加入 derby 的 jar 文件，我们的示例程序就能够顺利运行了。这也说明了只有一个 JVM 能够启动数据库：而两个跑在不同 JVM
实例里的应用自然就不能够访问同一个数据库了。
鉴于上述的局限性，和来自不同 JVM 的多个连接想访问一个数据库的需求，下一节将介绍 Derby 的另一种模式：网络服务器（Network Server）。
网络服务器模式
如
上所述，网络服务器模式是一种更为传统的客户端/服务器模式。我们需要启动一个 Derby
的网络服务器用于处理客户端的请求，不论这些请求是来自同一个 JVM 实例，还是来自于网络上的另一台机器。同时，客户端使用
DRDA（Distributed Relational Database Architecture）协议连接到服务器端。这是一个由 The
Open Group 倡导的数据库交互标准。图 3
说明了该模式的大体结构。
由于 Derby 的开发者们努力使得网络服务器模式与内嵌模式之间的差异变小，使得我们只需简单地修改 清单 1
中的程序就可以实现。如 清单 5
所示，我们在 HelloJavaDB 中增添了一个新的函数和一些字符串变量。不难看出，新的代码只是将一些在 上一节中特别指出的字符串进行了更改：驱动类为 org.apache.derby.jdbc.ClientDriver
，而连接数据库的协议则变成了 jdbc:derby://localhost:1527/
。这是一个类似 URL 的字符串，而事实上，Derby 网络的客户端的连接格式为：jdbc:derby://server[:port]/databaseName[;attributeKey=value]
。在这个例子中，我们使用了最简单的本地机器作为服务器，而端口则是 Derby 默认的 1527 端口。
图 3. Derby 网络服务器模式架构
清单 5. 网络服务器模式下的 HelloJavaDB
public class HelloJavaDB {
public static String driver = "org.apache.derby.jdbc.EmbeddedDriver";
public static String protocol = "jdbc:derby:";
public static void main(String[] args) {
// same as before
}
private static void parseArguments(String[] args) {
if (args.length == 0 || args.length > 1) {
return;
}
if (args[0].equalsIgnoreCase("derbyclient")) {
framework = "derbyclient";
driver = "org.apache.derby.jdbc.ClientDriver";
protocol = "jdbc:derby://localhost:1527/";
}
}
}
|
当然，仅仅有客户端是不够的，我们还需要启动网络服务器。Derby 中控制网络服务器的类是 org.apache.derby.drda.NetworkServerControl
，因此键入以下命令即可。如果想了解 NetworkServerControl 更多的选项，只要把 start
参数去掉就可以看到帮助信息了。关于网络服务器端的实现，都被 Derby 包含在 derbynet.jar 里。
清单 6. 启动网络服务器
java -cp .;"C:\Program Files\Java\jdk1.6.0\db\lib\derby.jar";
"C:\Program Files\Java\jdk1.6.0\db\lib\derbynet.jar"
org.apache.derby.drda.NetworkServerControl start
|
相对应的，网络客户端的实现被包含在
derbyclient.jar 中。所以，只需要在 classpath 中加入该 jar
文件，修改后的客户端就可以顺利地读取数据了。再一次尝试着使用两个命令行窗口去连接数据库，就能够得到正确的结果了。如果不再需要服务器，那么使用
NetworkServerControl 的 shutdown 参数就能够关闭服务器。
更多
至
此，文章介绍了 Java SE 6 中的新成员：Java DB（Derby），也介绍了如何在内嵌模式以及网络服务器模式下使用 Java
DB。当然这只是浅尝辄止，更多高级的选项还需要在 Sun 和 Derby 的文档中寻找。在这一章的最后，我们将简单介绍几个 Java DB
的小工具来加快开发速度。它们都位于 org.apache.derby.tools 包内，在开发过程中需要获取信息或者测试可以用到。
ij
：一个用来运行 SQL 脚本的工具；
dblook
：为 Derby 数据库作模式提取（Schema extraction），生成 DDL 的工具；
sysinfo
：显示系统以及 Derby 信息的工具类；
http://songzhifeng.iteye.com/blog/206927
---------------------------------------------------------------------------------------------------------------------------------
Derby是一个理想的，并且开源的，100% Java编写的，容易管理的关系数据库管理系统，它可以和一些商业产品的特性进行交付。这篇文章是关注Apache Derby项目——一个两全其美的关系数据库管理系统。Derby是一个名为Cloudscape的小公司构思的；当Cloudscape卖给 Informix后，该产品得到了加强；当IBM加入时，在“big blue”期间，它的高端工程特性得到增强；现在已经成为一个有最自由的许可的开源项目而存在。
两种灵活的使用模式
Derby可以工作在嵌入式模式下，或在完全的客户端/服务器模式下。
Derby引擎可以嵌入在你的应用程序里。当工作在嵌入式模式，你的应用程序访问数据库是直接和专有的。这就意味着其他应用程序不可能在同一时间访问该数据库。嵌入式模式的主要优点是不需要进行网络和服务器设置。因为你的应用程序包含了Derby引擎，使用者并不知道你使用了一个关系数据库。
当使用Derby的嵌入式模式时，并没有复杂的配置和特殊的API需要你去学习。实际上，你仅仅需要做：
1. 确保Derby JARs文件在你的应用程序classpath里
2. 使用嵌入式JDBC驱动
3. 写数据库访问代码到JDBC
Derby根本没有特殊的APIs。只需要为你的应用程序编码到JDBC，然后Derby会为你工作得很好。事实上，如果你已经有了JDBC代码，而想把代码转换到Derby嵌入式模式下运行是十分容易的。
如果你使用过ORACLE，DB2，SQL Server或MySQL，你应该对网络模式（客户端/服务器模式）的工作原理相当熟悉。一个独立的Java进程运行作为Derby的网络服务器，通过网络监听客户端的连接。该Derby网络服务器能唯一的访问数据库存储器，并能同时接受多个客户端连接。这就允许多个用户在同一时间通过网络方式访问该关系数据库管理系统。
当不适合使用嵌入式模式进行操作时（例如：你必须运行和管理个别的服务器进程，或许在不同的机器上），当你需要多用户访问数据库时，Derby的客户端-服务器模式能提供一个有效的解决方案。
配置Derby数据库
为了完全体会Derby设置和使用的好处，你需要自己亲身体验它。首先，下载和安装Derby。然后，确保你的classpath环境变量包含：
derby_installation_directory\lib\derby.jar；和derby_installation_directory\lib\derbytools.jar；
你也可以编辑提供给你的sp.bat文件，设置你的Derby安装目录，然后运行设置你的classpath。
一旦你设置好了classpath，就修改工作目录。数据库将被创建在这个目录里面。从db\createdb目录复制createdb.sql文件到工作目录。然后，启动命令行界面（执行ij）进入Derby：
字串2
java org.apache.derby.tools.ij
你也可以使用在batch子目录下提供的ij.bat，在使用前一定要编辑该批处理文件，添加你的Derby安装目录路径。这样才能进入正确的命令行，使用嵌入式Derby引擎。你看到的提示将与下面的类似：
ij version 10.0
ij>
你可以输入“help”；来查看可以使用的命令。要创建数据库和表来使用，仅仅需要运行createdb.sql文件。使用ij命令： run ‘createdb.sql’;
run命令将调用一个脚本文件并执行它里面的Derby命令，类似于Windows的批处理文件。下面显示的是createdb.sql文件的内容。
connect
'jdbc:derby:vsjdb;create=true';
drop table orders;
drop table custs;
create table custs
(id char (5) not null,
name char(40) not null, 字串1
primary key(id));
create table orders
(id char(8) not null,
custid char(5) not null,
total integer,
primary key(id,custid));
字串9
insert into custs values (
'1', 'John Smith');
insert into custs values (
'2', 'Mary Todd');
insert into orders values(
'0001', '1', 39999);
insert into orders values(
'0002', '1', 2999);
insert into orders values(
'0003', '1', 1904);
insert into orders values(
'0004', '2', 3232);
insert into orders values(
'0005', '2', 109900);
在每一行都需要一个分号，这与命令行输入命令是一样的。脚本的第一行是连接命令，指明连接的嵌入式Derby驱动名字。在脚本里的连接命令为：
connect
‘jdbc:derby:vsjdb;create=true’;
字串1
使用jdbc:derby说明Derby驱动是使用的JDBC协议，而vsjdb是一个数据库的名字，它能通过嵌入式驱动创建和访问。create=true属性说明如果该数据库不存在时，就创建该数据库。
该createdb.sql脚本将创建一个名为vsjdb（当它不存在时）的数据库，并在该数据库中创建custs和orders表。它将在表中添加两个用户和五个定单。如果你使用过其他数据库的SQL语句，你应该相当熟悉在脚本里的SQL语句。
你可以查看你的工作目录，现在你将看到一个vsjdb子目录。数据将保存在里面。数据库可以很简单的的进行备份，就是复制这个子目录。
表格1和表格2是custs和orders表的信息
Table 1: The custs table
Field Name
Data Type
Note
Id
char(5)
primary key
Name
char(40)
Table 2: The orders table
Field Name
Data Type
Note
Id
char(8)
primary key (compound)
Custid
char(5)
primary key (compound) 字串7
Total
int
与关系数据库管理系统数据操作
要查看顾客记录信息，在ij提示行后使用SQL SELECT语句：
select * from custs;
要查看定单，使用下面的命令：
select * from orders;
要删除顾客，尝试使用下面的命令：
delete from custs where id=’1’;
你可以选择custs表里的某一行，并能查看到哪个用户被删除。要删除与这个用户相关联的定单信息，使用下面的命令：
delete from orders where custid=’1’; 字串8
你现在可以查看orders表，并能看见所有关于一号顾客的定单都被删除了。
在你离开ij前，删除数据库里的所有记录：
delete from custs;
delete from orders;
着它将是一个空数据库，在下一部分，将写入自定义的Java代码。
使用exit命令离开ij：
exit;
自从连接URL指定了嵌入式驱动，只有ij能唯一的访问这个数据库。
嵌入Derby到你的Java应用程序中
时间加速我们的Java编译和编写某些代码。这些代码将放入Derby做一个小测试，给你一个关系数据库管理系统能处理现实世界大量数据能力的信心。
下面是名为FillTable.java的代码，将创建1000个用户，每个用户有10条定单——总共10000条定单。在嵌入子目录下你可以找到FillTable.java的源代码。
import java.sql.*;
public class TableFiller {
Connection conn = null;
PreparedStatement insertCust 字串2
= null;
PreparedStatement insertOrder
= null;
上面的申明是标准的JDBC申明。conn控制JDBC连接。insertCust和insertOrder将分别处理插入记录到custs和orders表里的SQL语句。PreparedStatement的使用使关系数据库管理系统得到优化的可能。
其次，下面的代码，driverName包含我们装载和使用的JDBC驱动器的类名。这是一个嵌入式驱动器。连接的URL是url值。你可以看见是使用的绝对路径定位这个数据库（注意：你必须要使用正斜线来分离路径）。如果你总是在你的工作目录运行这个程序的话，你可以仅使用 ”jdbc:derby:vsjdb”。也可以可以设置derby.system.home属性来改变Derby数据库文件的位置（例如：java –D derby.system.home=c:\mydbdir org.apche.derby.tools.ij）。
字串7
String driverName =
"org.apache.derby.jdbc.EmbeddedDriver";
String url =
"jdbc:derby:c:/derby1021/vsjdb";
loadDrivers()方法装载JDBC驱动类并创建获得一个Derby的JDBC连接。并准备两个插入语句。
public void loadDrivers()
throws SQLException,
ClassNotFoundException {
Class.forName(driverName);
conn = DriverManager.getConnection(
url);
insertCust = conn.prepareStatement(
字串2
"INSERT INTO custs VALUES(
?, ?)");
insertOrder =
conn.prepareStatement(
"INSERT INTO orders VALUES(
?, ?, ?)"); 字串3
}
TableFiller的main()方法创建一个TableFiller的实例，并调用它的addCustomer()方法去创建1000个用户。它也调用addOrder()方法去创建10000条定单信息。为了显示进度，它打印顾客编号和’.’到系统输出中。
public static void main(String args[])
throws Exception {
TableFiller tf = new TableFiller();
tf.loadDrivers();
int orderNum = 1;
for (int i=1; i<1001; i++) {
String custNum = "" + i; 字串3
tf.addCustomer(
custNum, "customer #" + i);
System.out.print("\n"
+ custNum); 字串1
for (int j=1; j<11; j++) {
tf.addOrder( ""+ orderNum,
custNum, j * 99);
orderNum++;
System.out.print(".");
}
}
tf.closeAll(); 字串5
} 字串9
addCustomer()方法获得参数并执行insertCust的预编译语句。
public void addCustomer(
String id, String custname)
throws SQLException {
insertCust.setString(1, id);
insertCust.setString(2, custname);
insertCust.executeUpdate();
}
addOrder()方法获得参数并执行insertOrder的预编译语句。
public void addOrder(String id,
String custid, int total)
throws SQLException { 字串6
insertOrder.setString(1, id);
insertOrder.setString(2, custid);
insertOrder.setInt(3, total);
insertOrder.executeUpdate();
}
closeAll()整理和关闭两个预编译语句和JDBC连接，通知Derby释放被控制的资源。
public void closeAll()
throws SQLException {
insertCust.close();
insertOrder.close();
conn.close();
字串2
}
}
当顾客和定单被创建，程序将打印顾客编号到屏幕上。编号从1到1000表明每个顾客被创建。而打印的每个’.’则表明定单被创建。
要编译这个代码，你仅仅需要确信你已经设置了classpath，并且使用标准的Java编译命令：
java TableFiller.java 字串4
你要确保没有ij或其他Derby会话在运行。在嵌入式模式你需要唯一的访问数据库。在编译成功后，需要复制TableFiller.class文件到你的工作目录下，然后从那里运行TableFiller：
java TableFiller
你应该看见打印出来的状态和写入数据库的记录。
检验被创建的记录
现在，去看看你创建的顾客和定单信息，确保你在工作目录并再次登录到ij。连接vsjdb数据库。
connect ‘jdbc:derby:vsjdb’;
然后使用下面的SELECT语句查看所有1000条顾客信息。
select * from custs;
同样的使用下面的SELECT语句查看所有10000条定单信息。
select * from orders;
当然，使用类似于FillTable.java里的标准JDBC代码，你可以整合Derby的关系数据库的访问功能到你的任何一个工程中。当你的项目需要一个嵌入式数据库时，有能力简单和快速处理产生大量的数据的Derby是你最好的选择。Derby的自由Apache许可允许你绑定它到你的程序上，即使你决定把你的产品进行商业买卖。
配置Derby的网络模式
要访问Derby的网络服务器模式，首先你需要把下面的JAR文件地址添加到你的classpath值里。
字串6
derby_installation_directory\lib\derbynet.jar
你还需要为客户端访问下载一个网络JDBC驱动。如果你使用IBM DB2 JDBC普通驱动，你则需要把下面的JAR文件地址添加到你的classpath值里：
derby_installation_directory\lib\db2_jcc.jar
derby_installation_directory\lib\db2_jcc_license_c.jar
batch子目录里的sp.bat文件里的classpath值已经包含了这些JARs文件地址。
启动网络服务器，使用下面的命令：
java org.apache.derby.drda.NetworkServerControl start
你也可以使用batch子目录下的netsvr.bat文件。
在默认情况下，服务器将监听TCP1527端口来接收客户端请求。你可以使用”-p <port number>”参数来改变端口。
如果你需要关闭服务器，使用下面的命令：
java org.apache.derby.drda.NetworkServerControl shutdown
或者你可以使用batch子目录下的netstop.bat文件。
现在服务器已经准备好了，为我们下面的探究铺上了台阶。
自动层叠删除
现在你有超过一万条的定单数据，你需要保证这些在数据库里的数据没有被破坏。固定这些数据是毫无疑问的。
让我举例说明一个潜在的问题，这个问题的中心是围绕在删除一个顾客后。问题就有可能会出现。
使用标准的SQL语句，只从custs表中删除顾客信息： 字串7
delete from custs where id='838';
这是从数据库中删除顾客编号为838的消费者。好极了！
如果这是你所做的，数据库的数据正式被破坏了。为什么呢？这是因为在数据库里有10定单信息没有关联到消费者！
这可能引起应用程序各种各样的错误。所有应用程序取得定单信息并尝试打印顾客信息时，都会涉及到这个异常。当你列出所有用户和他们的定单信息时，有些定单信息永远都不会显示出来。
在关系数据库管理系统的条款中，数据库引用完整性是不允许这样的情况的。这是因为一条顾客记录被删除，而没有删除相应的定单信息。
因此，我们需要这样做：
delete from custs where id='838';
delete from orders where custid='838';
而且，我们需要确保两条删除命令在同一个事务中执行。要么两条语句都执行成功，要么都执行失败。
这个称为删除层叠，因为删除顾客记录导致删除定单信息。
字串5
Derby有能力处理引用完整性。
字串4
Derby触发器
保证引用完整性的方法是定义一个触发器。一个触发器是一段代码或SQL语句，当数据发生修改或存取时，它将在数据库服务器里执行。Derby支持定义触发器（使用SQL语句或Java代码），当顾客记录被删除时，可以编码实现删除关联的定单信息。然而，在Derby里有一个更简单的方法。
它可以告诉Derby，使用标准的SQL DDL（数据定义）语句，这涉及到orders表和custs表。你也可以告诉Derby去完成自动层叠删除。
添加参考约束
要添加自动层叠删除，就要修改原始的createdb.sql里的语句。在db\ref子目录下找到createdbref.sql文件。你需要对orders表定义进行修改。添加下面兰色字体的内容：
create table orders
(id char(8) not null,
custid char(5) not null
references custs (id) on delete
cascade, total integer,
字串7
primary key(id,custid));
另外一个不同是连接数据库的URL值。这时，网络驱动器是指定的。一定要注意网络驱动器是需要用户名和密码的，默认的用户名和密码都是APP，所以URL值将修改为：
connect 'jdbc:derby:net://localhost/
vsjdb:user=APP;password=APP;';
你现在可以强行创建带参考约束的新表。确保复制createdbref.sql到你的工作目录。再次启动ij。现在，使用下面的命令可以删除所有记录并创建新表：
run 'createdbref.sql';
在创建了表后，你可以再次运行TableFiller.java文件去在表中添加10000条定单数据。使用network子目录的修改版本。在原始的TableFiller.java里修改的部分如下面兰色字体显示的:内容：
import java.sql.*;
import java.util.Properties;
public class TableFiller {
Connection conn = null;
字串8
PreparedStatement insertCust
= null;
PreparedStatement insertOrder
= null;
String driverName=
“com.ibm.db2.jcc.DB2Driver”;
String url =“jdbc:derby:net://localhost/
vsjdb:user=APP;password=APP;”;
...
装载的驱动器将要改为网络驱动器（com.ibm.db2.jcc.DBDriver），URL值最好还是改成访问网络JDBC驱动器的值。否则，这个代码将与原始的TableFill.java文件一样。如果你要写你自己的JDBC代码，你可以设置一个string从外部文本文件里读取参数，这样你将不需要修改代码就能在嵌入式关系数据库管理系统和网络关系数据库管理系统之间转换。
多用户并发访问
现在，来关注多用户连接，在另一个控制台窗口启动ij会话，并连接到服务器使用下面的命令：
connect 'jdbc:derby:net://localhost/
vsjdb:user=APP;password=APP;';
在原始的控制台窗口，编译并运行新的TableFiller.java文件。这将创建1000个顾客记录和10000条定单记录。当这些操作执行完毕后，回到新的ij窗口并使用下面的命令：
字串5
select * from custs;
…and:
select * from orders;
当你执行这个命令的时候，你将发现所有用户和定单信息都已经被创建。网络服务器允许多用户并发访问数据。
测试层叠删除
一旦你创建了数据记录，试着在ij里执行下面的语句：
select * from custs where id='700';
接着执行下面的语句：
select * from orders where
custid='700';
你将看到顾客记录和这个顾客的10条定单信息。
现在，尝试删除顾客，使用下面的命令：
delete from custs where id='700';
这将删除用户记录，层叠将会删除关联的定单信息。现在尝试再次使用上面的select语句查看，你将发现那10条定单信息也被删除了。
写一个Derby存储过程 字串4
在实验的最后，你将用Java编程语言创建一个Derby存储过程。你也可以存储代码到存储过程进入Derby数据库内部，Derby能轻松的区分数据和代码。
该存储过程将调用deleteAll()，从它的名字可以理解到，它将删除数据库里的所有记录。在stored子目录下可以找到实现该存储过程的Java代码，它的名字为CleanTables.java。代码内容如下：
import java.sql.*;
public class CleanTables {
public static void delAll ()
throws SQLException {
Connection conn = 字串6
DriverManager.getConnection(
"jdbc:default:connection");
Statement delCusts =
conn.createStatement(); 字串9
delCusts.executeUpdate(
"delete from custs");
delCusts.close();
conn.close();
return;
}
}
你可以看到，该存储程序在Java类里是一个public static的方法。JDBC连接器的内容是代码里url的值：
jdbc:default:connection
这会告诉Derby服务器提供一个默认的连接到代码。Derby将管理这些连接。实际上的语句是执行：
delete from custs;
自从层叠删除生效，删除custs表的任何数据，也将删除orders表里相关联的数据。
在Derby数据库里存储Java代码
要在Derby数据库里存入Java代码，你首先需要编译该代码并创建成JAR文件。编译CleanTables.java代码：
字串4
javac CleanTables.java
创建JAR文件：
jar cvf vsjstproc.jar *.class
或者你可以使用makejar.bat文件来完成上述操作，复制生成的vsjstporc.jar文件到工作目录。
在工作目录，你需要设置该JAR文件到数据库中。在ij中使用下面的命令（确保你的连接会话是通过网络驱动器获得的）：
call sqlj.install_jar('vsjstproc.jar',
'APP.cleanTable', 0);
这个命令实际上是调用一个存储过程，它将设置vsjstporc.jar文件到数据库并为它设置是内部名cleanTable。APP引用应用程序计划。让JAR文件在数据库里是非常方便的。当你复制数据库时，这些代码将跟着被移动。
如果你需要从数据库里删除该JAR文件，你可以使用：
call sqlj.remove_jar(
'APP.cleanTable', 0); 字串6
在删除调用中仅仅需要内部名。
当把JAR设置到数据库里后，当它需要读取Java代码时，你需要告诉Derby去识别该JAR文件。这些都需要通过存储过程设置一个属性：
call syscs_util.syscs_set_database_
property('derby.database.
classpath', 'APP.cleanTable');
当装载Java类时，Derby都会查看内部的APP.cleanTable JAR文件。你最后准备定义一个名为deleteAll()的存储过程。使用下面的命令：
create procedure deleteAll() parameter
style java language java modifies
sql data external name
字串4
'CleanTables.delAll';
Derby将从APP.cleanTable JAR文件找到CleanTable类，并锁定该类的static delAll()方法。如果你需要删除该存储过程，你可以使用下面的命令：
drop procedure deleteAll;
有了该存储过程，你可以删除这两个表的所有数据，只需要简单的在ij下调用存储过程deleteAll()：
call deleteAll();
在这个存储过程执行完毕后，你将发现这两个表是空的了。
结论
Derby是一个具有丰富特性的关系数据库系统，并能集成到你的项目中。
它支持嵌入式模式和客户端-服务器模式操作，它能适应部署多变的情况。它是100%用Java实现的，并与你的Java应用程序一样的享受‘随时发布’。它能快速执行和处理大量数据，同时也支持高级特性，例如引用完整性和存储项目，它以达到理想化的持久化的数据存储所必须的。最后但并不是最小，它自由的 Apache许可让你自由的绑定它到你的产品中。
字串1
下载和安装Derby
你可以在incubator area of the Apache site里找到Derby
一旦你解压下载的Derby，注意你的解压目录，这是你的Derby安装目录。你需要使用这个目录去设置的你的classpath。
下载Derby JDBC的网络驱动器
为了在网络模式下访问Derby，你将需要一个JDBC网络驱动器。IBM捐赠了这个驱动器给Derby项目，但是直到写本文时，它都不是一个标准版本。
暂时，你将需要下载IBM DB2 JDBC Universal driver for Apache Derby Network Server。根据地址里的说明去设置你的classpath。
My Eclipse 8.5 / My Eclipse Derby
F:\Users\Lindows\AppData\Local\Genuitec\Common\binary\com.sun.java.jdk.win32.x86_1.6.0.013\bin\javaw.exe
Apache Deryy Network Server － 10.2.2.0 - (485682) 已启动并且已准备好 2010-12-24 09:07:07.625 GMT 时在端口 1527 上接受连接
Apache Derby 网络服务器 － 10.2.2.0 - (485682) 在 2010-12-24 09:59:22.586 GMT 时关闭
end |
|
QQ群⑧：
窥视卡
雷达卡
发表于 2017-1-3 07:15:10
提升卡
置顶卡
沉默卡
喧嚣卡
变色卡
千斤顶
显身卡