使用 Java 将记录插入 Berkeley DB

Posted 2023-02-16

【中文标题】使用 Java 将记录插入 Berkeley DB

【英文标题】：Inserting records into Berkeley DB with Java

【发布时间】：2010-04-23 03:30:54

【问题描述】：

我似乎找不到用 Java 构建 Berkeley DB 并将记录插入其中的示例代码。有样品吗？我也不是说 Berkeley DB Java 版。

【参考方案1】：

http://www.oracle.com/technology/documentation/berkeley-db/db/programmer_reference/BDB_Prog_Reference.pdf 第五章

如果您下载 db-5.0.21.NC.zip，您会看到大量示例。 这是一个似乎可以做你想做的事

/*-
 * See the file LICENSE for redistribution information.
 *
 * Copyright (c) 2004, 2010 Oracle and/or its affiliates.  All rights reserved.
 *
 * $Id$ 
 */

// File: ExampleDatabaseLoad.java

package db.GettingStarted;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;
import java.util.Vector;

import com.sleepycat.bind.EntryBinding;
import com.sleepycat.bind.serial.SerialBinding;
import com.sleepycat.bind.tuple.TupleBinding;
import com.sleepycat.db.DatabaseEntry;
import com.sleepycat.db.DatabaseException;

public class ExampleDatabaseLoad 

    private static String myDbsPath = "./";
    private static File inventoryFile = new File("./inventory.txt");
    private static File vendorsFile = new File("./vendors.txt");

    // DatabaseEntries used for loading records
    private static DatabaseEntry theKey = new DatabaseEntry();
    private static DatabaseEntry theData = new DatabaseEntry();

    // Encapsulates the databases.
    private static MyDbs myDbs = new MyDbs();

    private static void usage() 
        System.out.println("ExampleDatabaseLoad [-h <database home>]");
        System.out.println("      [-i <inventory file>] [-v <vendors file>]");
        System.exit(-1);
    


    public static void main(String args[]) 
        ExampleDatabaseLoad edl = new ExampleDatabaseLoad();
        try 
            edl.run(args);
         catch (DatabaseException dbe) 
            System.err.println("ExampleDatabaseLoad: " + dbe.toString());
            dbe.printStackTrace();
         catch (Exception e) 
            System.out.println("Exception: " + e.toString());
            e.printStackTrace();
         finally 
            myDbs.close();
        
        System.out.println("All done.");
    


    private void run(String args[])
        throws DatabaseException 
        // Parse the arguments list
        parseArgs(args);

        myDbs.setup(myDbsPath);

        System.out.println("loading vendors db....");
        loadVendorsDb();

        System.out.println("loading inventory db....");
        loadInventoryDb();
    


    private void loadVendorsDb()
            throws DatabaseException 

        // loadFile opens a flat-text file that contains our data
        // and loads it into a list for us to work with. The integer
        // parameter represents the number of fields expected in the
        // file.
        List vendors = loadFile(vendorsFile, 8);

        // Now load the data into the database. The vendor's name is the
        // key, and the data is a Vendor class object.

        // Need a serial binding for the data
        EntryBinding dataBinding =
            new SerialBinding(myDbs.getClassCatalog(), Vendor.class);

        for (int i = 0; i < vendors.size(); i++) 
            String[] sArray = (String[])vendors.get(i);
            Vendor theVendor = new Vendor();
            theVendor.setVendorName(sArray[0]);
            theVendor.setAddress(sArray[1]);
            theVendor.setCity(sArray[2]);
            theVendor.setState(sArray[3]);
            theVendor.setZipcode(sArray[4]);
            theVendor.setBusinessPhoneNumber(sArray[5]);
            theVendor.setRepName(sArray[6]);
            theVendor.setRepPhoneNumber(sArray[7]);

            // The key is the vendor's name.
            // ASSUMES THE VENDOR'S NAME IS UNIQUE!
            String vendorName = theVendor.getVendorName();
            try 
                theKey = new DatabaseEntry(vendorName.getBytes("UTF-8"));
             catch (IOException willNeverOccur) 

            // Convert the Vendor object to a DatabaseEntry object
            // using our SerialBinding
            dataBinding.objectToEntry(theVendor, theData);

            // Put it in the database.
            myDbs.getVendorDB().put(null, theKey, theData);
        
    


    private void loadInventoryDb()
        throws DatabaseException 

        // loadFile opens a flat-text file that contains our data
        // and loads it into a list for us to work with. The integer
        // parameter represents the number of fields expected in the
        // file.
        List inventoryArray = loadFile(inventoryFile, 6);

        // Now load the data into the database. The item's sku is the
        // key, and the data is an Inventory class object.

        // Need a tuple binding for the Inventory class.
        TupleBinding inventoryBinding = new InventoryBinding();

        for (int i = 0; i < inventoryArray.size(); i++) 
            String[] sArray = (String[])inventoryArray.get(i);
            String sku = sArray[1];
            try 
                theKey = new DatabaseEntry(sku.getBytes("UTF-8"));
             catch (IOException willNeverOccur) 

            Inventory theInventory = new Inventory();
            theInventory.setItemName(sArray[0]);
            theInventory.setSku(sArray[1]);
            theInventory.setVendorPrice((new Float(sArray[2])).floatValue());
            theInventory.setVendorInventory((new Integer(sArray[3])).intValue());
            theInventory.setCategory(sArray[4]);
            theInventory.setVendor(sArray[5]);

            // Place the Vendor object on the DatabaseEntry object using our
            // the tuple binding we implemented in InventoryBinding.java
            inventoryBinding.objectToEntry(theInventory, theData);

            // Put it in the database. Note that this causes our secondary database
            // to be automatically updated for us.
            myDbs.getInventoryDB().put(null, theKey, theData);
        
    


    private static void parseArgs(String args[]) 
        for(int i = 0; i < args.length; ++i) 
            if (args[i].startsWith("-")) 
                switch(args[i].charAt(1)) 
                  case 'h':
                    myDbsPath = new String(args[++i]);
                    break;
                  case 'i':
                    inventoryFile = new File(args[++i]);
                    break;
                  case 'v':
                    vendorsFile = new File(args[++i]);
                    break;
                  default:
                    usage();
                
            
        
    


    private List loadFile(File theFile, int numFields) 
        List records = new ArrayList();
        try 
            String theLine = null;
            FileInputStream fis = new FileInputStream(theFile);
            BufferedReader br = new BufferedReader(new InputStreamReader(fis));
            while((theLine=br.readLine()) != null) 
                String[] theLineArray = splitString(theLine, "#");
                if (theLineArray.length != numFields) 
                    System.out.println("Malformed line found in " + theFile.getPath());
                    System.out.println("Line was: '" + theLine);
                    System.out.println("length found was: " + theLineArray.length);
                    System.exit(-1);
                
                records.add(theLineArray);
            
            fis.close();
         catch (FileNotFoundException e) 
            System.err.println(theFile.getPath() + " does not exist.");
            e.printStackTrace();
            usage();
         catch (IOException e)  
            System.err.println("IO Exception: " + e.toString());
            e.printStackTrace();
            System.exit(-1);
        
        return records;
    


    private static String[] splitString(String s, String delimiter) 
        Vector resultVector = new Vector();
        StringTokenizer tokenizer = new StringTokenizer(s, delimiter);
        while (tokenizer.hasMoreTokens())
            resultVector.add(tokenizer.nextToken());
        String[] resultArray = new String[resultVector.size()];
        resultVector.copyInto(resultArray);
        return resultArray;
    


    protected ExampleDatabaseLoad() 

【讨论】：

是的，我也做到了。插入记录是如何工作的？我已经有一个键值对映射。当我放入数据库时​​，有一个 Transaction 和 DatabaseEntry 对象的概念。

您提供了指向我们产品的 Berkeley DB（用 C 语言编写，带有 Java JNI 层）版本的链接，而不是共享该 Java API 的纯 Java“Berkeley DB Java 版”产品和与 C 版本一样快（或在某些情况下更快）。以下是可供下载的 Java 版软件包。 oracle.com/technetwork/database/berkeleydb/downloads/…

【参考方案2】：

有很多很好的 Oracle Berkeley DB Java 版入门指南。它们包含在文档集中。您将在文档中找到示例代码。如果您是 Oracle Berkeley DB Java 版的新手，那么这是一个正确的起点。下载包中还有其他示例。

我是 Oracle Berkeley DB 的产品经理，希望这能解决您的问题。如果没有，请告诉我还有什么可以帮助您的。

【讨论】：

亲爱的 Greg，我特别致力于 Berkeley DB JE，并希望将其作为我对嵌入式数据库的要求进行分析。 BDB JE 是否适合插入 String、Date、Int 和特别是 BLOB？如果是，请分享一个代码/链接，其中插入并从 BDB JE 读取 BLOB。提前致谢