嵌入式数据库——BerkeleyDB之JavaEdition

之前听说嵌入式什么的，就觉得好牛B的，理解比较困难，像我这种小菜鸟真是望尘莫及...

今天有机会接触一款之前被Oracle收购的嵌入式数据库BerkeleyDB，初接触感觉什么数据库阿不一样是存东西嘛，就网上各种找资料看资料，半天下来总算有点眉目了

JE 适合于管理海量的，简单的数据。其中的记录都以简单的键值对保存，即key/value对。由于它操作简单，效率较高，因此受到了广泛的好评。

JE 下载地址：http://www.oracle.com/technology/software/products/berkeley-db/je/index.html 下载相关zip文件 解压之后把lib下jar文件拷贝至工程中即可使用

实例：

	// 数据库环境
	private Environment myDbEnvironment = null;
	// 数据库配置
	private DatabaseConfig dbConfig = null;
	// //数据库游标
	// private Cursor myCursor = null;
	// 数据库对象
	private Database myDatabase = null;
	// 数据库文件名
	private String fileName = "D:\\env";
	// 数据库名称
	private String dbName = "sample";

	/*
	 * 打开当前数据库
	 */
	public void openDatabase() {
		// TODO Auto-generated method stub
		try {
			System.out.println("打开数据库: " + dbName);
			EnvironmentConfig envConfig = new EnvironmentConfig();
			envConfig.setAllowCreate(true);// 如果不存在则创建一个
			envConfig.setTransactional(true);
			// envConfig.setReadOnly(false);
			// envConfig.setTxnTimeout(10000, TimeUnit.MILLISECONDS);
			// envConfig.setLockTimeout(10000, TimeUnit.MILLISECONDS);

			// 打开一个环境
			File file = new File(fileName);
			if (!file.exists())
				file.mkdirs();
			myDbEnvironment = new Environment(file, envConfig);

			dbConfig = new DatabaseConfig();
			dbConfig.setAllowCreate(true);// 如果数据库不存在则创建一个
			dbConfig.setTransactional(true);
			// dbConfig.setReadOnly(false);

			if (myDatabase == null)
				myDatabase = myDbEnvironment.openDatabase(null, dbName,
						dbConfig);

			// System.out.println(dbName + "数据库中的数据个数: " + myDatabase.count());
			// 取得数据库的名称
			// System.out.println("数据库名称："+myDatabase.getDatabaseName());
			// Environment theEnv = myDatabase.getEnvironment();//
			// 取得包含这个database的环境信息

			// theEnv.getDatabaseNames(); // 返回当前环境下的数据库列表
			// theEnv.removeDatabase(); //删除当前环境中指定的数据库

			// theEnv.renameDatabase(null, null, null); // 给当前环境下的数据库改名

			// theEnv.truncateDatabase(null,"dbName",true);
			// //清空database内的所有数据，返回清空了多少条记录。
		} catch (DatabaseException e) {
			System.out.println(e.getMessage());
		}
	}

	/*
	 * 向数据库中写入记录 传入key和value
	 */
	public boolean writeToDatabase(String key, String value, boolean isOverwrite) {
		// TODO Auto-generated method stub
		try {
			// 设置key/value,注意DatabaseEntry内使用的是bytes数组
			DatabaseEntry theKey = new DatabaseEntry(key.trim().getBytes(
					"UTF-8"));
			DatabaseEntry theData = new DatabaseEntry(value.getBytes("UTF-8"));
			OperationStatus res = null;
			// Transaction txn = null;
			try {
				// TransactionConfig txConfig = new TransactionConfig();
				// txConfig.setSerializableIsolation(true);
				// txn = myDbEnvironment.beginTransaction(null, txConfig);
				if (isOverwrite) {
					res = myDatabase.put(null, theKey, theData);
				} else {
					res = myDatabase.putNoOverwrite(null, theKey, theData);
				}
				// txn.commit();
				if (res == OperationStatus.SUCCESS) {
					System.out.println("向数据库" + dbName + "中写入:" + key + ","
							+ value);
					return true;
				} else if (res == OperationStatus.KEYEXIST) {
					System.out.println("向数据库" + dbName + "中写入:" + key + ","
							+ value + "失败,该值已经存在");
					return false;
				} else {
					System.out.println("向数据库" + dbName + "中写入:" + key + ","
							+ value + "失败");
					return false;
				}
			} catch (LockConflictException lockConflict) {
				// txn.abort();
				System.out.println("向数据库" + dbName + "中写入:" + key + "," + value
						+ "出现lock异常");
				System.out.println(lockConflict.getMessage());
				System.out.println(lockConflict.getCause().toString());
				System.out.println(lockConflict.getStackTrace().toString());
				return false;
			}
		} catch (Exception e) {
			// 错误处理
			System.out.println("向数据库" + dbName + "中写入:" + key + "," + value
					+ "出现错误");
			return false;
		}
	}

	/*
	 * 从数据库中读出数据 传入key 返回value
	 */
	public String readFromDatabase(String key) {
		// TODO Auto-generated method stub
		// Database.getSearchBoth()
		try {
			DatabaseEntry theKey = new DatabaseEntry(key.getBytes("UTF-8"));
			DatabaseEntry theData = new DatabaseEntry();
			Transaction txn = null;
			try {
				TransactionConfig txConfig = new TransactionConfig();
				txConfig.setSerializableIsolation(true);
				txn = myDbEnvironment.beginTransaction(null, txConfig);
				OperationStatus res = myDatabase.get(txn, theKey, theData,
						LockMode.DEFAULT);
				txn.commit();
				if (res == OperationStatus.SUCCESS) {
					byte[] retData = theData.getData();
					String foundData = new String(retData, "UTF-8");
					System.out.println("从数据库" + dbName + "中读取:" + key + ","
							+ foundData);
					return foundData;
				} else {
					System.out
							.println("No record found for key '" + key + "'.");
					return "";
				}
			} catch (LockConflictException lockConflict) {
				txn.abort();
				System.out.println("从数据库" + dbName + "中读取:" + key + "出现lock异常");
				System.out.println(lockConflict.getMessage());
				System.out.println(lockConflict.getCause().toString());
				System.out.println(lockConflict.getStackTrace().toString());

				return "";
			}

		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();

			return "";
		}
	}

	/*
	 * 遍历数据库中的所有记录，返回list
	 */
	public ArrayList<String> getEveryItem() {
		// TODO Auto-generated method stub
		System.out.println("===========遍历数据库" + dbName
				+ "中的所有数据==========");
		Cursor myCursor = null;
		ArrayList<String> resultList = new ArrayList<String>();
		Transaction txn = null;
		try {
			txn = this.myDbEnvironment.beginTransaction(null, null);
			CursorConfig cc = new CursorConfig();
			cc.setReadCommitted(true);
			if (myCursor == null)
				myCursor = myDatabase.openCursor(txn, cc);
			DatabaseEntry foundKey = new DatabaseEntry();
			DatabaseEntry foundData = new DatabaseEntry();
			// 使用cursor.getPrev方法来遍历游标获取数据
			if (myCursor.getFirst(foundKey, foundData, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
				String theKey = new String(foundKey.getData(), "UTF-8");
				String theData = new String(foundData.getData(), "UTF-8");
				resultList.add(theKey);
				System.out.println("Key | Data : " + theKey + " | "
						+ theData + "");
				while (myCursor.getNext(foundKey, foundData, LockMode.DEFAULT) == OperationStatus.SUCCESS) {
					theKey = new String(foundKey.getData(), "UTF-8");
					theData = new String(foundData.getData(), "UTF-8");
					resultList.add(theKey);
					System.out.println("Key | Data : " + theKey
							+ " | " + theData + "");
				}
			}
			myCursor.close();
			txn.commit();
			return resultList;
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return null;
		} catch (Exception e) {
			System.out.println("getEveryItem处理出现异常");
			System.out.println(e.getMessage().toString());
			System.out.println(e.getCause().toString());

			txn.abort();
			if (myCursor != null) {
				myCursor.close();
			}
			return null;
		}
	}

	/**
	 * 关闭数据库以及环境
	 */
	public void closeDatabase() {
		try {
			if (myDatabase != null) {
				myDatabase.close();
			}
			if (myDbEnvironment != null) {
				myDbEnvironment.cleanLog();
				myDbEnvironment.close();
			}
		} catch (DatabaseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}