以太坊数据库RocksDB的ColumnFamily的修改

以太坊中使用到RocksDB数据库，现记录列族的相关操作

public class RocksDBUtilUpdate {
    //RocksDB对象
    private static RocksDB rocksDB;

    //RocksDB存储的数据库位置
    private static String dbPath;

    //用于存储从RocksDB中取得的数据
    private static Map<String, Map<String,byte[]>> resultMap=new HashMap<>();

    //加载RocksDB引擎
    static {
        RocksDB.loadLibrary();
    }

    //列族中使用到的对象
    public static List<ColumnFamilyDescriptor> columnFamilyDescriptors;
    public static List<ColumnFamilyHandle> columnFamilyHandles;

    /**
     * 创建RocksDB对象
     * @return
     */
    public static RocksDB createRocksDB(){
        dbPath="/yunduo2018NC";
        System.out.println("************执行了RocksDBUpdate************");
        //列族描述
        columnFamilyDescriptors = new ArrayList<>();
        Options options = new Options();
        options.setCreateIfMissing(true);
        try {
            //创建一个新的列族
            List<byte[]> cfs = RocksDB.listColumnFamilies(options, dbPath);
            if (cfs.size() > 0) {
                for (byte[] cf : cfs) {
                    columnFamilyDescriptors.add(new ColumnFamilyDescriptor(cf, new ColumnFamilyOptions()));
                }
            } else {
                columnFamilyDescriptors.add(new ColumnFamilyDescriptor(RocksDB.DEFAULT_COLUMN_FAMILY, new ColumnFamilyOptions()));
            }
            //列族处理器集合
            columnFamilyHandles = new ArrayList<>();
            DBOptions dbOptions = new DBOptions();
            dbOptions.setCreateIfMissing(true);

            //创建RocksDB对象
            rocksDB = RocksDB.open(dbOptions, dbPath, columnFamilyDescriptors, columnFamilyHandles);
            return rocksDB;
        }catch(RocksDBException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 存储数据到列族
     * @param rocksDB
     * @param columnFamilyDescriptors
     * @param columnFamilyHandles
     * @param columnFamilyName
     * @param key
     * @param value
     * @return
     */
    public static boolean save(RocksDB rocksDB,
                               List<ColumnFamilyDescriptor> columnFamilyDescriptors,
                               List<ColumnFamilyHandle> columnFamilyHandles,
                               String columnFamilyName,
                               String key,
                               byte[] value){
        try {
            //如果列族已存在（根据列族名称的唯一性判断），那么删除原有列族
            for (int i = 0; i < columnFamilyDescriptors.size(); i++) {
                if (new String(columnFamilyDescriptors.get(i).columnFamilyName()).equals(columnFamilyName)) {
                    rocksDB.dropColumnFamily(columnFamilyHandles.get(i));
                }
            }

            //创建列族处理器
            ColumnFamilyHandle columnFamilyHandle = null;

            columnFamilyHandle = rocksDB.createColumnFamily(new ColumnFamilyDescriptor(columnFamilyName.getBytes(), new ColumnFamilyOptions()));


            //存储数据
            rocksDB.put(columnFamilyHandle, key.getBytes(), value);

            //获取数据
            byte[] getValue = rocksDB.get(columnFamilyHandle, key.getBytes());
            System.out.println("<ColumnFamilyUtil.java>存储的列族:"+columnFamilyName+";key值:" +key+";value值:"+ new String(getValue));
            //将数据存储到Map
            Map<String,byte[]> map=new HashMap<>();
            map.put(key,getValue);
            resultMap.put(columnFamilyName,map);
            return true;
        } catch (RocksDBException e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 取出数据
     * @param columnFamilyName
     * @param key
     * @return
     */
    public static byte[] getValueFromCF(String columnFamilyName,String key){
        Map<String,byte[]> map=resultMap.get(columnFamilyName);
        byte[] result=map.get(key);
        return result;
    }

}

修改后：

import org.apache.log4j.Logger;
import org.rocksdb.Options;
import org.rocksdb.RocksDB;
import org.rocksdb.RocksDBException;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class InitRocksDB {

    private static final Logger log=Logger.getLogger(InitRocksDB.class);
    //rocksDB对象
    private static RocksDB rocksDB;
    //rocksDB初始化
    public static  RocksDB init(String dbPath){

        //加载引擎
        RocksDB.loadLibrary();
        Options options = new Options();
        options.setCreateIfMissing(true);

        // 文件不存在，则先创建文件
        if (!Files.isSymbolicLink(Paths.get(dbPath))) {
            try {
                Files.createDirectories(Paths.get(dbPath));
                rocksDB = RocksDB.open(options, dbPath);
            } catch (IOException e) {
                e.printStackTrace();
            } catch (RocksDBException e) {
                e.printStackTrace();
            }


        }
        log.info("<-------------Rocks初始化成功 文件路径+"+dbPath+"--------------->");
        return rocksDB;

    }
}

import org.apache.log4j.Logger;
import org.rocksdb.*;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class RocksDBUtil {
    private static final org.apache.log4j.Logger log = Logger.getLogger(InitRocksDB.class);
    private static RocksDB rocksDB = null;
    static String basePath = "/rocksDB/test";
    //列族集合
    private static Map<String,ColumnFamilyHandle> handleMap = new HashMap<>();

    //初始化rocksDB
    static void init(String dbPath) {
        if(rocksDB != null){
            return;
        }
        basePath = dbPath;
        //加载引擎
        RocksDB.loadLibrary();

        // 文件不存在，则先创建文件
        if (!Files.isSymbolicLink(Paths.get(dbPath))) {
            try {
                Files.createDirectories(Paths.get(dbPath));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //实例化rocksDB
        List<ColumnFamilyDescriptor> columnFamilyDescriptors = new ArrayList<>();
        Options options = new Options();
        options.setCreateIfMissing(true);

        try{
            List<byte[]> cfs = RocksDB.listColumnFamilies(options, dbPath);
            if(cfs.size() > 0) {
                for(byte[] cf : cfs) {
                    columnFamilyDescriptors.add(new ColumnFamilyDescriptor(cf, new ColumnFamilyOptions()));
                }
            } else {
                columnFamilyDescriptors.add(new ColumnFamilyDescriptor(RocksDB.DEFAULT_COLUMN_FAMILY, new ColumnFamilyOptions()));
            }

            List<ColumnFamilyHandle> columnFamilyHandles = new ArrayList<>();
            DBOptions dbOptions = new DBOptions();
            dbOptions.setCreateIfMissing(true);

            rocksDB = RocksDB.open(dbOptions, dbPath, columnFamilyDescriptors, columnFamilyHandles);
            //保存列族名称和处理器
            for(int i=0; i<columnFamilyHandles.size(); i++){
                ColumnFamilyHandle handle = columnFamilyHandles.get(i);
                handleMap.put(new String(cfs.get(i)),handle);
            }
        } catch (RocksDBException e) {
            e.printStackTrace();
        }
        log.info(">>>>Rocks初始化成功--url: "+dbPath);
    }

    //初始化rocksDB2
    static void init() {
        init(basePath);
    }

    /**
     * 将数据存储到RocksDB列族中
     * @param columnFamilyName 列族名称，这个名称在RocksDB中是唯一的
     * @param key 一个列族中，key不能重复；不同列族中可以有相同名称的key
     * @param value
     * @return 数据存储成功返回true
     */
    public static void put(String columnFamilyName,String key,byte[] value) throws RocksDBException {
        //列族处理器
        ColumnFamilyHandle handle = null;
        if(handleMap.containsKey(columnFamilyName)){
            log.info("列族已存在：" + columnFamilyName);
            handle = handleMap.get(columnFamilyName);
        }else {
            log.info("列族不存在：" + columnFamilyName);
            try {
                handle = createColumnFamily(columnFamilyName);
            } catch (Exception e) {
                log.error(e);
            }
        }
        //存储数据
        rocksDB.put(handle, key.getBytes(), value);
    }

    public static byte[] get(String columnFamilyName,String key) throws RocksDBException {
        ColumnFamilyHandle handle = handleMap.get(columnFamilyName);
        if(handle == null){
            log.info("处理器获取不到~");
            return null;
        }
        return rocksDB.get(handle,key.getBytes());
    }

    /**
     * 创建列族
     * @param cfName
     * @return
     * @throws Exception
     */
    private static ColumnFamilyHandle createColumnFamily(String cfName) throws Exception {
        ColumnFamilyHandle handle = rocksDB.createColumnFamily(new ColumnFamilyDescriptor(cfName.getBytes()));
        //保存handle
        handleMap.put(cfName, handle);
        return handle;
    }

    public static void main(String[] args){
        init();
        //创建列族
//        try{
//            createColumnFamily("cf-test");
//        }catch (Exception e){
//            e.printStackTrace();
//        }
        //列族描述
        List<ColumnFamilyDescriptor> columnFamilyDescriptors = new ArrayList<>();
        Options options = new Options();
        options.setCreateIfMissing(true);
        try {
            List<byte[]> cfs = RocksDB.listColumnFamilies(options, basePath);
            for(byte[] cf : cfs){
                System.out.println(new String(cf));
            }
            //存入列族
            put("cf-test","sxf-key","test-value".getBytes());
            //从列族取数据
            byte[] value = get("cf-test","sxf-key");
            System.out.println("从列族取数据:" + new String(value));
        } catch (RocksDBException e) {
            e.printStackTrace();
        }
        rocksDB.close();
    }

}