学习Java6(六) ---嵌入式数据库 Derby

nbtymm 2007-01-17

展开全文

一. Derby简介

    Derby是一个关系型数据库。
    Derby是一个用java实现的数据库。
    Derby是一个开源的数据库。
    Derby是一个嵌入式的数据库。
    Derby是一个JDK6内置的数据库。

    1996年，一个叫做 Cloudscape, Inc 的新公司成立了，公司的目标是构建一个用 Java 语言编写的数据库服务器。公司的第一个发行版在一年之后推出，后来产品的名称变成 Cloudscape。

1999年，Cloudscape, Inc. 被大型数据库厂商 Informix Software, Inc. 收购。

2001年, Informix Software 又被 IBM 收购，然后 IBM Cloudscape™ 数据库系统在许多 IBM 的产品中被用作内嵌的数据库引擎。

2004年4月，IBM 把 Cloudscape 数据库软件赠送给 Apache 软件基金会(ASF)，从此 Apache Derby 项目诞生了。在 Apache 中这个项目叫做 Derby，它是一个孵化器项目。开发人员可以在 Apache 的许可下为 Derby 代码作出贡献，或者下载 Derby 代码。

二.Derby 在java6中的位置

   打开JDK6的安装目录就会发现比JDK5的安装目录里多了一个叫DB的文件夹，
  目录结构
├─demo－－例子
│ ├─databases
│ │ └─toursdb
│ │      ├─log
│ │      └─seg0
│ └─programs
│      ├─nserverdemo
│      ├─simple
│      ├─toursdb
│      └─workingwithderby
├─frameworks－－框架
│ ├─embedded
│ │ └─bin
│ └─NetworkServer
│      └─bin
└─lib－－类库
使用该数据库时会用到lib文件夹中的一些jar

三 .Derby使用的一个简单例子

1 import java.sql.Connection;
2 import java.sql.DriverManager;
3 import java.sql.ResultSet;
4 import java.sql.Statement;
5
6 public class TestDerbyBaisc {
7     public static void main(String[] args) {
8         try {
9             Class.forName("org.apache.derby.jdbc.EmbeddedDriver").newInstance();//加载驱动
10             Connection conn = DriverManager.getConnection("dbc:derby:TESTDB;create=true");//连接数据库
11             Statement st = conn.createStatement();
12             st.execute("create table USER_INFO (ID INT NOT NULL,NAME VARCHAR(10) NOT NULL)");//建表
13             st.executeUpdate("insert into USER_INFO(ID,NAME) values (1,‘hermit‘)");//插入数据
14             st.executeUpdate("insert into USER_INFO(ID,NAME) values (2,‘test‘)");//插入数据
15             ResultSet rs = st.executeQuery("select * from USER_INFO");//读取刚插入的数据
16             while(rs.next()){
17                 int id = rs.getInt(1);
18                 String name = rs.getString(2);
19                 System.out.println("ID="+id);
20                 System.out.println("NAME="+name);
21             }
22         } catch(Exception e){
23             e.printStackTrace();
24         }
25     }
26 }
运行以后输出
ID=1
NAME=hermit
ID=2
NAME=test

在项目下会生成一个文件夹TESTDB

四 .Derby网络版服务器端

1 import java.io.BufferedReader;
2 import java.io.InputStreamReader;
3 import java.io.PrintWriter;
4 import java.sql.Connection;
5 import java.sql.DriverManager;
6 import java.sql.Statement;
7 import org.apache.derby.drda.NetworkServerControl;
8
9 public class TestDerbyServer {
10     public static void main(String[] args) {
11         try {
12             NetworkServerControl dbserver = new NetworkServerControl();//启动服务器
13
14             PrintWriter pw = new PrintWriter(System.out);//获取服务器输出
15             dbserver.start(pw);
16
17             Connection conn = DriverManager.getConnection("jdbc:derby:TESTDB;create=true");//本地连接数据库
18
19             Statement st = conn.createStatement();
20             st.execute("create table USER_INFO (ID INT NOT NULL,NAME VARCHAR(10) NOT NULL)");//建表
21             st.executeUpdate("insert into USER_INFO(ID,NAME) values (1,‘hermit‘)");//插入数据
22             st.executeUpdate("insert into USER_INFO(ID,NAME) values (2,‘test‘)");//插入数据
23
24             /*
25              *等待用户输入，让程序继续运行，不然程序会运行结束，客户端就连不上了
26              */
27             BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
28             System.out.println("Press [Enter] to stop Server");
29             in.readLine();
30
31         } catch (Exception ex) {
32             ex.printStackTrace();
33         }
34     }
35 }运行输出：
服务器准备在端口 1527 上接受连接。
Press [Enter] to stop Server

再强调一下，in.readLine();很重要，不然，程序运行完毕，服务器也就停了

五.Derby网络版客户端

运行这个客户端之前要先运行
学习Java6(六) 嵌入式数据库Derby(4)网络版服务端
中的服务端

1 import java.sql.Connection;
2 import java.sql.DriverManager;
3 import java.sql.ResultSet;
4 import java.sql.Statement;
5
6 public class TestDerbyClient {
7     public static void main(String[] args) {
8         String URL = "jdbc:derby://127.0.0.1:1527/TESTDB;create=true";
9         try {
10
11             Class.forName("org.apache.derby.jdbc.ClientDriver").newInstance();//加载驱动
12             Connection conn = DriverManager.getConnection(URL);//建立连接
13
14             Statement st = conn.createStatement();
15             ResultSet rs = st.executeQuery("select * from USER_INFO");//读取数据
16             while(rs.next()){
17                 int id = rs.getInt(1);
18                 String name = rs.getString(2);
19                 System.out.println("ID="+id);
20                 System.out.println("NAME="+name);
21             }
22
23         } catch (Exception ex) {
24             ex.printStackTrace();
25         }
26     }
27 }

运行输出：
ID=1
NAME=hermit
ID=2
NAME=test

六. Derby 用myeclipse网络方式连接Derby

首先启动学习Java6(六) 嵌入式数据库Derby(4)网络版服务端一文中的服务端。
在打开myeclipse的首选项，找到

点击“new...”。
如下图所示配置：

打开DB BROWSER视图，建立连接，如下图：

用户名密码任意，但是不能为空，奇怪啊。
完成。
打开新建的连接，即可像一般数据库一样进行操作了。

七. Derby用myeclipse本地方式连接Derby

方式连Derby和网络方式的配置有很大的区别：注意看下面两个图：
方式：

本地方式，注意红圈处的不同：

首次连接时会在c盘下面创建TESTDB目录。如果不写绝对路径，数据库会被创建到eclipse的根目录下面。

八 . Derby + Spring+hibernate的配置

1 <?xml version="1.0" encoding="UTF-8"?>
2 <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www./dtd/spring-beans.dtd">
3
4 <beans>
5
6
7     <bean id="dataSource"
8         class="org.apache.commons.dbcp.BasicDataSource">
9         <property name="driverClassName">
10             <value>org.apache.derby.jdbc.EmbeddedDriver</value>
11         </property>
12         <property name="url">
13             <value>jdbc:derby:c:/TESTDB;create=true</value>
14         </property>
15         <property name="username">
16             <value>test</value>
17         </property>
18         <property name="password">
19             <value>test</value>
20         </property>
21     </bean>
22     <bean id="sessionFactory"
23         class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
24         <property name="dataSource">
25             <ref bean="dataSource" />
26         </property>
27         <property name="hibernateProperties">
28             <props>
29                 <prop key="hibernate.dialect">                    org.hibernate.dialect.DerbyDialect                </prop>
30             </props>
31         </property>
32         <property name="mappingResources">
33             <list>
34                 <value>UserInfo.hbm.xml</value></list>
35         </property></bean>
36     <bean id="UserInfoDAO" class="UserInfoDAO">
37         <property name="sessionFactory">
38             <ref bean="sessionFactory" />
39         </property>
40     </bean></beans>
UserInfo.java

1 // default package
2
3
4
5 /**
6  * UserInfo generated by MyEclipse - Hibernate Tools
7  */
8
9 public class UserInfo  implements java.io.Serializable {
10
11
12     // Fields
13
14      private Integer id;
15      private String name;
16
17
18     // Constructors
19
20     /** default constructor */
21     public UserInfo() {
22     }
23
24     /** minimal constructor */
25     public UserInfo(Integer id) {
26         this.id = id;
27     }
28
29     /** full constructor */
30     public UserInfo(Integer id, String name) {
31         this.id = id;
32         this.name = name;
33     }
34
35
36     // Property accessors
37
38     public Integer getId() {
39         return this.id;
40     }
41
42     public void setId(Integer id) {
43         this.id = id;
44     }
45
46     public String getName() {
47         return this.name;
48     }
49
50     public void setName(String name) {
51         this.name = name;
52     }
53
54
55
56
57
58
59
60
61
62 }

UserInfo.hbm.xml

1 <?xml version="1.0" encoding="utf-8"?>
2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
3 "http://hibernate./hibernate-mapping-3.0.dtd">
4 
7 <hibernate-mapping>
8     <class name="UserInfo" table="USER_INFO" schema="APP">
9         <id name="id" type="java.lang.Integer">
10             <column name="ID" />
11             <generator class="assigned" />
12         </id>
13         <property name="name" type="java.lang.String">
14             <column name="NAME" length="10" />
15         </property>
16     </class>
17 </hibernate-mapping>
18

UserInfoDAO.java

  1 // default package
  2
  3 import java.util.List;
  4 import org.apache.commons.logging.Log;
  5 import org.apache.commons.logging.LogFactory;
  6 import org.hibernate.LockMode;
  7 import org.springframework.context.ApplicationContext;
  8 import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
  9
10 /**
11  * Data access object (DAO) for domain model class UserInfo.
12  * @see .UserInfo
13  * @author MyEclipse - Hibernate Tools
14  */
15 public class UserInfoDAO extends HibernateDaoSupport {
16
17     private static final Log log = LogFactory.getLog(UserInfoDAO.class);
18
19     protected void initDao() {
20         //do nothing
21     }
22
23     public void save(UserInfo transientInstance) {
24         log.debug("saving UserInfo instance");
25         try {
26             getHibernateTemplate().save(transientInstance);
27             log.debug("save successful");
28         } catch (RuntimeException re) {
29             log.error("save failed", re);
30             throw re;
31         }
32     }
33
34     public void delete(UserInfo persistentInstance) {
35         log.debug("deleting UserInfo instance");
36         try {
37             getHibernateTemplate().delete(persistentInstance);
38             log.debug("delete successful");
39         } catch (RuntimeException re) {
40             log.error("delete failed", re);
41             throw re;
42         }
43     }
44
45     public UserInfo findById( java.lang.Integer id) {
46         log.debug("getting UserInfo instance with id: " + id);
47         try {
48             UserInfo instance = (UserInfo) getHibernateTemplate()
49                     .get("UserInfo", id);
50             return instance;
51         } catch (RuntimeException re) {
52             log.error("get failed", re);
53             throw re;
54         }
55     }
56
57
58     public List findByExample(UserInfo instance) {
59         log.debug("finding UserInfo instance by example");
60         try {
61             List results = getHibernateTemplate().findByExample(instance);
62             log.debug("find by example successful, result size: " + results.size());
63             return results;
64         } catch (RuntimeException re) {
65             log.error("find by example failed", re);
66             throw re;
67         }
68     }
69
70     public List findByProperty(String propertyName, Object value) {
71       log.debug("finding UserInfo instance with property: " + propertyName
72             + ", value: " + value);
73       try {
74          String queryString = "from UserInfo as model where model."
75                                  + propertyName + "= ?";
76          return getHibernateTemplate().find(queryString, value);
77       } catch (RuntimeException re) {
78          log.error("find by property name failed", re);
79          throw re;
80       }
81     }
82
83     public UserInfo merge(UserInfo detachedInstance) {
84         log.debug("merging UserInfo instance");
85         try {
86             UserInfo result = (UserInfo) getHibernateTemplate()
87                     .merge(detachedInstance);
88             log.debug("merge successful");
89             return result;
90         } catch (RuntimeException re) {
91             log.error("merge failed", re);
92             throw re;
93         }
94     }
95
96     public void attachDirty(UserInfo instance) {
97         log.debug("attaching dirty UserInfo instance");
98         try {
99             getHibernateTemplate().saveOrUpdate(instance);
100             log.debug("attach successful");
101         } catch (RuntimeException re) {
102             log.error("attach failed", re);
103             throw re;
104         }
105     }
106
107     public void attachClean(UserInfo instance) {
108         log.debug("attaching clean UserInfo instance");
109         try {
110             getHibernateTemplate().lock(instance, LockMode.NONE);
111             log.debug("attach successful");
112         } catch (RuntimeException re) {
113             log.error("attach failed", re);
114             throw re;
115         }
116     }
117
118     public static UserInfoDAO getFromApplicationContext(ApplicationContext ctx) {
119         return (UserInfoDAO) ctx.getBean("UserInfoDAO");
120     }
121 }