2. 程式人生 > >leveldb簡介與java實現demo

leveldb簡介與java實現demo

阿新 • • 發佈：2019-01-08

簡介

1.簡介

Leveldb是一個google實現的非常高效的kv資料庫，目前的版本1.2能夠支援billion級別的資料量了。 在這個數量級別下還有著非常高的效能，主要歸功於它的良好的設計。特別是LSM演算法。

2特點

LevelDB 是單程序的服務，效能非常之高，在一臺4核Q6600的CPU機器上，每秒鐘寫資料超過40w，而隨機讀的效能每秒鐘超過10w。 此處隨機讀是完全命中記憶體的速度，如果是不命中 速度大大下降

3侷限

LevelDB 只是一個 C/C++ 程式語言的庫, 不包含網路服務封裝, 所以無法像一般意義的儲存伺服器(如 MySQL)那樣, 用客戶端來連線它. LevelDB 自己也宣告, 使用者應該封裝自己的網路伺服器.

4實現介紹

leveldb中有一系列引數會與讀寫的效率有關，將相關的配置以及編譯常量統一修改成可執行時配置引數，測試選取最佳配置值。

應用場景

  1. 記憶體佔用大的服務
  • leveldb是持久化型資料庫
  1. 寫多於讀
  • 寫操作要大大快於讀操作，而順序讀寫操作則大大快於隨機讀寫操作。官方網站報道其隨機寫效能達到40萬條記錄每秒，而隨機讀效能達到6萬條記錄每秒

涉及專案

  • ActiveMQ

限制和弊端

  1. key和value資料尺寸不能太大，在KB級別，如果儲存較大的key或者value，將對leveld的讀寫效能都有較大的影響。每個key所對應的內容不宜太大，超過32KB效能就會下降很快
  2. 一次只允許一個程序訪問一個特定的資料庫
  3. 沒有內建的C/S架構，但開發者可以使用LevelDB庫自己封裝一個server，不具備“分散式”叢集架構能力
  • 百度開源的分散式檔案系統BFS(開源地址:https://github.com/baidu/bfs)提 供了mount工具，可以將整個分散式檔案系統直接掛載到本地目錄，從而可以像操作本地檔案一樣來操作分散式檔案系統中的檔案，我們可以利用分散式檔案系統本身提供的資料高可靠特性來保證leveldb中資料的安全。
  1. 不支援索引
  2. 不支援事務

java呼叫

原生leveldb是基於C++開發，java語言無法直接使用；iq80對leveldb使用JAVA 語言進行了“逐句”重開發，經過很多大型專案的驗證（比如ActiveMQ），iq80開發的JAVA版leveldb在效能上損失極少（10%）。對於JAVA開發人員來說，我們直接使用即可，無需額外的安裝其他lib。

java maven依賴

<dependency>
	<groupId>org.iq80.leveldb</groupId>
	<artifactId>leveldb</artifactId>
	<version>0.7</version>
</dependency>
<dependency>
	<groupId>org.iq80.leveldb</groupId>
	<artifactId>leveldb-api</artifactId>
	<version>0.7</version>
</dependency>

備註：最新版0.10, 2017年12月

測試demo

package cn.demo.leveldb;

import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.Map;

import org.iq80.leveldb.DB;
import org.iq80.leveldb.DBFactory;
import org.iq80.leveldb.DBIterator;
import org.iq80.leveldb.Options;
import org.iq80.leveldb.ReadOptions;
import org.iq80.leveldb.Snapshot;
import org.iq80.leveldb.WriteBatch;
import org.iq80.leveldb.WriteOptions;
import org.iq80.leveldb.impl.Iq80DBFactory;
import org.junit.Test;

/**
 * 各介面測試
 * @author lym
 *
 */
public class LevelDBDemoTest {

	private static final String PATH = "/data/leveldb";
	private static final Charset CHARSET = Charset.forName("utf-8");
	private static final File FILE = new File(PATH);
	
	@Test
	public void putTest() {
		DBFactory factory = new Iq80DBFactory();
		// 預設如果沒有則建立
		Options options = new Options();
		File file = new File(PATH);
		DB db = null;
		try {
			db = factory.open(file, options);
			byte[] keyByte1 = "key-01".getBytes(CHARSET);
			byte[] keyByte2 = "key-02".getBytes(CHARSET);
			// 會寫入磁碟中
			db.put(keyByte1, "value-01".getBytes(CHARSET));
			db.put(keyByte2, "value-02".getBytes(CHARSET));
			String value1 = new String(db.get(keyByte1), CHARSET);
			System.out.println(value1);
			System.out.println(new String(db.get(keyByte2), CHARSET));
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if (db != null) {
				try {
					db.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
	
	@Test
	public void readFromSnapshotTest() {
		DBFactory factory = new Iq80DBFactory();
		File file = new File(PATH);
		Options options = new Options();
		DB db = null;
		try {
			db = factory.open(file, options);
			// 讀取當前快照，重啟服務仍能讀取，說明快照持久化至磁碟，
			Snapshot snapshot = db.getSnapshot();
			// 讀取操作
			ReadOptions readOptions = new ReadOptions();
			// 遍歷中swap出來的資料，不應該儲存在memtable中。
			readOptions.fillCache(false);
			// 預設snapshot為當前
			readOptions.snapshot(snapshot);
			
			DBIterator it = db.iterator(readOptions);
			while (it.hasNext()) {
				Map.Entry<byte[], byte[]> entry = (Map.Entry<byte[], byte[]>) it
						.next();
				String key = new String(entry.getKey(), CHARSET);
				String value = new String(entry.getValue(), CHARSET);
				System.out.println("key: " + key + " value: " + value);
				if (key.equals("key-01")) {
					System.out.println("".equals(value));
				}
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if (db != null) {
				try {
					db.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
	
	@Test
	public void snapshotTest() {
		DBFactory factory = new Iq80DBFactory();
		Options options = new Options();
		DB db = null;
		try {
			db = factory.open(FILE, options);
			
			db.put("key-04".getBytes(CHARSET), "value-04".getBytes(CHARSET));
			// 只能之前到getSnapshot之前put的值，之後的無法獲取，即讀取期間資料的變更，不會反應出來
			Snapshot snapshot = db.getSnapshot();
			db.put("key-05".getBytes(CHARSET), "value-05".getBytes(CHARSET));
			ReadOptions readOptions = new ReadOptions();
			readOptions.fillCache(false);
			readOptions.snapshot(snapshot);
			DBIterator it = db.iterator(readOptions);
			while (it.hasNext()) {
				Map.Entry<byte[],byte[]> entry = (Map.Entry<byte[],byte[]>) it
						.next();
				String key = new String(entry.getKey(), CHARSET);
				String value = new String(entry.getValue(), CHARSET);
				System.out.println("key: " + key + " value: " + value);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if (db != null) {
				try {
					db.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	@Test
	public void writeOptionsTest() {
		DBFactory factory = new Iq80DBFactory();
		Options options = new Options();
		DB db = null;
		try {
			db = factory.open(FILE, options);
			WriteOptions writeOptions = new WriteOptions().sync(true);	// 執行緒安全
			// 沒有writeOptions時，會new一個，所以猜測這裡添加了這個引數的意義就是可以設定sync和snapshot引數，建議採用這種方式
			db.put("key-06".getBytes(CHARSET), "value-06".getBytes(CHARSET), writeOptions);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if (db != null) {
				try {
					db.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	@Test
	public void deleteTest() {
		DBFactory factory = new Iq80DBFactory();
		Options options = new Options();
		DB db = null;
		try {
			db = factory.open(FILE, options);
			// 存在會刪除，之後查詢不出，根據說明可能不是真刪除，而是新增一個標記，待測試（大量資料之後刪除，檔案大小是否明顯變化）
			db.delete("key-02".getBytes(CHARSET));
			// 不存在不會報錯
			db.delete("key02".getBytes(CHARSET));
			
			Snapshot snapshot = db.getSnapshot();
			ReadOptions readOptions = new ReadOptions();
			readOptions.fillCache(false);
			readOptions.snapshot(snapshot);
			
			DBIterator it = db.iterator(readOptions);
			while (it.hasNext()) {
				Map.Entry<byte[], byte[]> entry = (Map.Entry<byte[], byte[]>) it
						.next();
				String key = new String(entry.getKey(), CHARSET);
				String value = new String(entry.getValue(), CHARSET);
				System.out.println("key: " + key + " value: " + value);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if (db != null) {
				try {
					db.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
	
	@Test
	public void writeBatchTest() {
		DBFactory factory = Iq80DBFactory.factory;
		Options options = new Options();
		DB db = null;
		try {
			db = factory.open(FILE, options);
			// 批量儲存，批量修改
			WriteBatch writeBatch = db.createWriteBatch();
			writeBatch.put("key-07".getBytes(CHARSET), "value-07".getBytes(CHARSET));
			writeBatch.put("key-08".getBytes(CHARSET), "value-08".getBytes(CHARSET));
			writeBatch.put("key-09".getBytes(CHARSET), "value-09".getBytes(CHARSET));
			// 這裡也可以新增writeOptions
			db.write(writeBatch);
			
			DBIterator it = db.iterator();
			while (it.hasNext()) {
				Map.Entry<byte[], byte[]> entry = (Map.Entry<byte[], byte[]>) it
						.next();
				String key = new String(entry.getKey(), CHARSET);
				String value = new String(entry.getValue(), CHARSET);
				System.out.println("key: " + key + " value: " + value);
			}
			it.close();
			
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if (db != null) {
				try {
					db.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
	
	@Test
	public void writeBatchDeleteTest() {
		DBFactory factory = Iq80DBFactory.factory;
		Options options = new Options();
		DB db = null;
		try {
			db = factory.open(FILE, options);
			WriteBatch writeBatch = db.createWriteBatch();
			writeBatch.put("key-10".getBytes(CHARSET), "value-10".getBytes(CHARSET));
			writeBatch.put("key-11".getBytes(CHARSET), "value-11".getBytes(CHARSET));
			// 會將key-01的value置為""
			writeBatch.delete("key-01".getBytes(CHARSET));
			db.write(writeBatch);
			writeBatch.close();
			DBIterator it = db.iterator();
			while (it.hasNext()) {
				Map.Entry<byte[], byte[]> entry = (Map.Entry<byte[], byte[]>) it
						.next();
				String key = new String(entry.getKey(), CHARSET);
				String value = new String(entry.getValue(), CHARSET);
				System.out.println("key: " + key + " value: " + value);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if (db != null) {
				try {
					db.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}

效能測試

資料量 儲存 隨機讀一條 順序讀一條 順序讀所有 磁碟佔用 測試環境 速率
10w 494ms 36ms -- 174ms 9.75M windows 20.29w/s
40w 2772ms 46ms 1ms 551ms 28.6M windows 14.43w/s
100w 5533ms 44ms 1ms 457ms 71.5M windows 18.07w/s
1000w 117661ms 11m+ -- -- 715M windows --

資料型別

1. 物件

需要實現序列化介面

public class DataTest {

	private static final String PATH = "/data/leveldb";
	private static final File FILE = new File(PATH);
	private static final Charset CHARSET = Charset.forName("UTF-8");
	
	@Test
	public void writeObject() {
		Options options = new Options();
		DBFactory factory = Iq80DBFactory.factory;
		DB db = null;
		try {
			db = factory.open(FILE, options);
			User user = new User();
			user.setName("admin");
			user.setSex("男");
			WriteOptions writeOptions = new WriteOptions();
			writeOptions.snapshot(true);
			
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			ObjectOutputStream oos = new ObjectOutputStream(baos);
			oos.writeObject(user);
			
			db.put(user.getName().getBytes(CHARSET), baos.toByteArray());
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (db != null) {
				try {
					db.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	@Test
	public void readObject() {
		Options options = new Options();
		DBFactory factory = Iq80DBFactory.factory;
		DB db = null;
		try {
			db = factory.open(FILE, options);
			byte[] valueByte = db.get("admin".getBytes(CHARSET));
			ByteArrayInputStream bais = new ByteArrayInputStream(valueByte);
			ObjectInputStream ois = new ObjectInputStream(bais);
			User user = (User) ois.readObject();
			System.out.println(user);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			if (db != null) {
				try {
					db.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}

2. 物件集合

@Test
public void writeObjectList() {
	Options options = new Options();
	DBFactory factory = Iq80DBFactory.factory;
	DB db = null;
	try {
		db = factory.open(FILE, options);
		List<User> userList = new ArrayList<User>();
		User user = new User();
		user.setName("admin");
		user.setSex("男");
		User user2 = new User();
		user2.setName("root");
		user2.setSex("女");
		userList.add(user);
		userList.add(user2);
		WriteOptions writeOptions = new WriteOptions();
		writeOptions.snapshot(true);
		
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(baos);
		oos.writeObject(userList);
		
		db.put("userList".getBytes(CHARSET), baos.toByteArray());
	} catch (IOException e) {
		e.printStackTrace();
	} finally {
		if (db != null) {
			try {
				db.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}
@Test
public void readObjectList() {
	Options options = new Options();
	DBFactory factory = Iq80DBFactory.factory;
	DB db = null;
	try {
		db = factory.open(FILE, options);
		byte[] valueByte = db.get("userList".getBytes(CHARSET));
		ByteArrayInputStream bais = new ByteArrayInputStream(valueByte);
		ObjectInputStream ois = new ObjectInputStream(bais);
		List<User> userList = new ArrayList<User>();
		userList = (List<User>) ois.readObject();
		System.out.println(userList);
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (ClassNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} finally {
		if (db != null) {
			try {
				db.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

參考：

相關推薦

leveldb簡介與java實現demo

簡介 1.簡介 Leveldb是一個google實現的非常高效的kv資料庫，目前的版本1.2能夠支援billion級別的資料量了。 在這個數量級別下還有著非常高的效能，主要歸功於它的良好的設計。特別是LSM演算法。 2特點 LevelDB 是單程序的服務，效能非常之高

HTTP POST請求報文格式分析與Java實現檔案上傳

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

小程式與java實現websocket通訊

1.websocket類 /** * @ServerEndpoint 註解是一個類層次的註解，它的功能主要是將目前的類定義成一個websocket伺服器端, * 註解的值將被用於監聽使用者連線的終端訪問URL地址,客戶端可以通過這個URL來連線到WebSocket伺服器端 */ @Serv

AVL樹簡介及Java實現

AVL樹簡介 AVL樹是被最先發明的一種較為簡單的平衡二叉查詢樹。 它的特點是： 1.本身首先是一棵二叉查詢樹。 2.帶有平衡條件：每個結點的左右子樹的高度之差的絕對值（平衡因子LoadFactor）最多為1。（設根結點的高度為1） 上面的兩張圖片，左邊的是AV

求倆圓交叉部分面積 java實現demo

import static java.lang.StrictMath.acos; import static java.lang.StrictMath.sin; /** * @author sun * @date 2018/1/31 14:41 */ public class Demo {

Factorization Machines簡介與程式碼實現

介紹 FM是聯合SVM與因式分解模型的優點所得。在有比較大的資料稀疏情況下，也能從中找出聯絡。FM可以線上性時間內優化。 優點 可以在非常稀疏的資料中進行合理的引數估計 FM模型的時間複雜度是線性的 FM是一個通用模型，它可以用於任何特徵為實值的

Atitit 資料join 的原理與java實現 Atitit join表連線的原理與實現 13、SQL Server 表連線的三種方式 　　(1) Merge Join 　　(2) Nested

Atitit 資料join 的原理與java實現   Atitit join表連線的原理與實現   13、SQL Server 表連線的三種方式 (1) Merge Join (2) Nested Loop Join (3) Hash Join &

模擬退火(Simulated Annealing, SA)演算法簡介與MATLAB實現

目錄 演算法步驟 演算法特點 模擬退火演算法概述 模擬退火演算法(Simulated Annealing，簡稱SA)的思想最早是由Metropolis等提出的。其出發點是基於物理中固體物質的退火過程與一般的組合優化問題之間的相似性。模擬退火法是一種

時間複雜度為O(N*logN)的常用排序演算法總結與Java實現

時間複雜度為O(N*logN)的常用排序演算法主要有四個——快速排序、歸併排序、堆排序、希爾排序1.快速排序·基本思想    隨機的在待排序陣列arr中選取一個元素作為標記記為arr[index](有時也直接選擇起始位置)，然後在arr中從後至前以下標j尋找比arr[inde

MD5簡介與程式碼實現

MD5簡介       md5的全稱是message-digest algorithm 5（資訊-摘要演算法），在90年代初由mit laboratory for computer science和rsa data security inc的ronald l. rivest開

DeepFM: A Factorization-Machine based Neural Network for CTR Prediction簡介與程式碼實現

論文簡介 Abstract 對於一個基於CTR預估的推薦系統，最重要的是學習到使用者點選行為背後隱含的特徵組合。在不同的推薦場景中，低階組合特徵或者高階組合特徵可能都會對最終的CTR產生影響。但是現存的方法總是忽視了高階或低階組合特徵的聯絡，或者要求專門的特徵工程，因此作者建立了

Field-aware Factorization Machines for CTR Prediction簡介與程式碼實現

摘要 FM被廣泛應用在CTR，但是FFM在一些世界範圍的CTR競賽表現好於目前存在的模型。作者實現了相關程式碼，並與一些競爭模型進行了全面的分析。實驗證明FFM在某些分類問題上非常有用。 介紹 FFM 對於這個例子來說，FM的隱向量表示應該為： 在FM中，每個

紅黑樹的理解與Java實現

等價 可能 操作 一次 jdk1.8 第一步 重新 節點 這樣的 前言 前段時間在研究 JDK1.8 的 hashmap 源碼，看到 put 方法的插入環節，遇到了紅黑樹，不得不停止閱讀源碼的過程，因為還沒掌握紅黑樹是無法完全讀透 hashmap 源碼的。紅黑樹作為一種數據

各個ip地址庫對比與java實現

1.    產品篇 1.  ipip.net 優勢：支援離線下載，資料更新頻繁，資料精確 劣勢：收費如下，收費的才有經緯度 2.Max Mind 優勢：支援離線下載，資料如果是收費版的更新頻繁，資料精確，有大致經緯度            Maxmind更像是一個

八大排序演算法總結與Java實現

概述 因為健忘，加上對各種排序演算法理解不深刻，過段時間面對排序就蒙了。所以決定對我們常見的這幾種排序演算法進行統一總結，強行學習。首先羅列一下常見的十大排序演算法： 直接插入排序 希爾排序 簡單選擇排序 堆排序 氣泡排

《演算法導論》紅黑樹詳解（二）：Java實現Demo

使用Java簡單地實現紅黑樹，程式碼如下： /** * 紅黑樹實現demo */ public class RedBlackTree<Key extends Comparable<Key>> { private stati

九種排序演算法總結與Java實現

一、九種排序演算法總結 平均時間複雜度O(n^2): 氣泡排序、選擇排序、插入排序 平均時間複雜度O(nln):  快速排序、歸併排序、堆排序 時間複雜度介於O(nlgn)和O(n^2)：希爾排序 時間複雜度O(n+k):計數排序 時間複雜度O(d(n+k)):基數排序

JavaWeb開發中Ajax技術、json與java實現List、Map資料直接傳遞的研究

 一、在JavaWeb開發中基於jquery框架來使用ajax技術，Json與後臺servlet進行資料互動示例,下面示例中基於servlet技術，沒有使用struts2等框架。         由於專案需要通過ajax得到後臺的List物件、map物件裡面的值，閒暇時間

simHash 簡介以及 java 實現

傳統的 hash 演算法只負責將原始內容儘量均勻隨機地對映為一個簽名值，原理上相當於偽隨機數產生演算法。產生的兩個簽名，如果相等，說明原始內容在一定概 率 下是相等的；如果不相等，除了說明原始內容不相等外，不再提供任何資訊，因為即使原始內容只相差一個位元組，所產生的簽名也很可能差別極大。從這個意義 上來

並查集演算法的簡介與演算法實現

並查集（Union-find Sets）是一種非常精巧而實用的資料結構，它主要用於處理一些不相交集合的合併問題。一些常見的用途有求連通子圖、求最小生成樹的 Kruskal 演算法和求最近公共祖先（Least Common Ancestors, LCA）等。 使用並查集時，首先會存在一組不相交的動態集合 S=