常见Java内存数据库比较

本文介绍了在Java应用中使用内存数据库的原因,包括项目初期调试、单元测试、资源有限等场景。文章列举了五种常见的内存数据库:SQLite、H2、Derby、MariaDb4j和embededmysql,并分析了各自的优缺点。推荐在不同场景下选择sqlite、H2或MariaDb4j,并提供了相应的示例代码。最后,文章展示了如何在项目中集成和使用这些数据库。
摘要由CSDN通过智能技术生成

1. 为什么要内存数据库

在常见的Java应用项目中,通常会有需求将数据保存到DB中。但实际环境中,受到服务器资源限制或者网络限制等因素,无法为项目提供DB资源。比如:

  • 项目研发初期本地调试运行阶段,无法连接公司有网络访问控制的DB;
  • 项目单元测试阶段,单测数据与正常测试数据污染隔离,清理测试库效率较低;
  • 开发初学者用自己电脑运行程序,但又不想在本地安装MySQL导致电脑运行较慢;
  • 云ECS服务器资源受限;

以上场景下需要DB又不能很好获取DB资源,所以会优先考虑内存型数据库。内存数据库一方面能满足应用对DB的需求,另一方面依赖资源(CPU和内存)简单,能及时打扫清理现场,认可度很高。

2. 有哪些常见的内存数据库

DB类型优点缺点其它
sqlite

1. C语言开源,轻量级,通过jar方式引用;

2. 嵌入式模式运行,支持Java/go/python/php等多语言;

3. 嵌入式运行支持内存和磁盘模式,存储文件可以跨平台使用;

4. 支持实物隔离和索引;

1. 多线程并发读写能力弱;

2. Mysql兼容性较弱;

3. 无用户管理;

官网地址:SQLite Home Page
H2

1. 纯Java编写,通过Jar方式引用;

2.支持client/server多线程模式;

3. 支持内存和磁盘存储数据;

4.支持索引和事务隔离,支持全文索引;

5. 相比于Sqlite对mysql语法支持更多;

6. 相同数据量级内存模式比较性能最好;

与SQLite类似官网地址:H2 Database Engine
derby

1. 开源Java语言编写,核心部分derby.jar只有2M;

2. 支持主从模式,支持授权用户;

1. derby 对很多 mysql 的关键字并不支持,同时 derby 不支持插入空值;

2. 只支持Java语言;

3. 不支持内存模式和全文本搜索;

官网地址:Apache Derby
mariaDb4j

1. 号称能兼容MySQL的内存数据库;

2. 支持sql 索引;

1. 运行会依赖外部os的动态lib;

github:MariaDB4j/mariaDB4j-pom-lite at master · vorburger/MariaDB4j · GitHub
embeded mysql

1. 支持client/server模式;

2. 号称对mysql语法兼容性最强;

1. 只支持内存模式;

2. 5.8以后就被移除了,开源维护性较差;

3. 支持数据量级和性能受限,10万数据量级可能有问题;

github: GitHub - wix/wix-embedded-mysql: embedded mysql based on https://github.com/flapdoodle-oss/de.flapdoodle.embed.process

3. 如何选择

进考虑单机嵌入式情况,推荐使用sqlite,具体原因如上;

考虑事务支持以及内存情况下运行效率,选择H2;

如果考虑对MySQL语法支持,优先选择使用mariaDb4j,LZ亲测对sql语法兼容性强;

4. 示例代码

为了屏蔽底层DB引擎的差异性以及对查询的多线程使用,楼主选用了Druid作为数据库连接池,DAO层直接用Spring JDBC做封装。

公共依赖包:

    <dependency>
        <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.2</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

抽象公共的RbdUtil:

package com.book.xw.common.dal;

import com.alibaba.druid.pool.DruidDataSource;
import lombok.Data;
import org.springframework.jdbc.core.JdbcTemplate;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public abstract class RdbDaoUtil {
    protected static String DB_LOCAL_PATH = "./mydb";
    private JdbcTemplate  jdbcTemplate;
    private DruidDataSource dataSource;
    protected String dbName;

    private volatile Integer dataSourceStatus = 1;


    public RdbDaoUtil(String dbName) {
        this.dbName = dbName;
        this.dataSource = buildRdbDataSource(dbName);
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }

    protected abstract DruidDataSource buildRdbDataSource(String ... args);
    // 保障不同数据库名字对应的实例只有一个
    protected DruidDataSource buildDataSource(String dbUrl, String user, String pwd, String driverClass){
        synchronized (dbName){
            if(dataSourceStatus == 1){
                DruidDataSource dataSource = new DruidDataSource();
                dataSource.setUrl(dbUrl);
                dataSource.setUsername(user);
                dataSource.setPassword(pwd);

                dataSource.setInitialSize(1);
                dataSource.setMinIdle(1);
                dataSource.setMaxWait(30000);
                dataSource.setMinEvictableIdleTimeMillis(30000);
                dataSource.setTestWhileIdle(true);
                dataSource.setValidationQuery("select 1");
                dataSource.setTestOnBorrow(true);
                dataSource.setTestOnReturn(false);
                dataSource.setLogAbandoned(true);
                try {
                    dataSource.init();
                }catch (Exception e){
                    throw new RuntimeException(e);
                }
            }else{
                return this.dataSource;
            }
        }
        return dataSource;
    }

    public void destroyDataSource(){
        if(this.dataSource != null && !dataSource.isClosed()){
            this.dataSource.close();
            dataSourceStatus = 1;
        }
    }

    public void createTable(String table, List<ColumnType> columns ){
        String sql = "";
        jdbcTemplate.execute(sql);
    }

    public void deleteTable(String table){
        String sql = "delete table if exists ` "+table+"` ;";
        jdbcTemplate.update(sql);
    }

    public void executeSql(String sql){
        jdbcTemplate.execute(sql);
    }

    public List<Map<String, Object>> queryForMap(String sql){
        return jdbcTemplate.queryForList(sql);
    }

    public MyData queryDbData(String sql, boolean needColName){
        MyData data = new MyData();
        Connection conn = null;
        PreparedStatement stmt = null;
        ResultSet rs = null;

        try {
            conn = this.dataSource.getConnection();
            conn.setAutoCommit(false);
            stmt = conn.prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
            rs = stmt.executeQuery();
            if(needColName){
                getColNameAndType(rs, data);
            }
            int row = 0;
            while (rs.next()){
                getColData(rs, data);
                row++;
            }
            data.setRows(row);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if(rs != null){
                    rs.close();
                }
                if(stmt != null){
                    stmt.close();
                }
                if(conn != null){
                    conn.setAutoCommit(true);
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return data;
    }

    private void getColData(ResultSet rs, MyData data){
        int size = data.getColNames().size();
        if(rs != null){
            List<Object> list = new ArrayList<>(size);
            try {
                for(int i = 0; i< size; i++){
                    list.add(rs.getObject(i + 1));
                }
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
            data.getColData().add(list);
        }
    }

    private void getColNameAndType(ResultSet rs, MyData data){
        List<String> names = new ArrayList<>();
        List<Integer> types = new ArrayList<>();
        if(rs != null){
            try {
                ResultSetMetaData rms = rs.getMetaData();
                for(int i = 1; i<=rms.getColumnCount(); i++){
                    types.add(rms.getColumnType(i));
                    names.add(rms.getColumnLabel(i));
                }
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        data.setColNames(names);
        data.setColTypes(types);
    }


    @Data
    public class ColumnType{
        // 字段名字
        private String name;
        // 字段类型
        private String type;
        // 约束条件,主键、普通索引
        private String constraint;
    }

    @Data
    public class MyData{
        private List<String> colNames;
        private List<Integer> colTypes;
        private List<List<Object>> colData = new ArrayList<>();
        private int rows ;
    }
}

 Embedded Msql需要引入的包为:

        <dependency>
            <groupId>com.wix</groupId>
            <artifactId>wix-embedded-mysql</artifactId>
            <version>4.6.2</version>
        </dependency>

引擎代码:

import com.alibaba.druid.pool.DruidDataSource;
import com.book.xw.common.dal.RdbDaoUtil;
import com.wix.mysql.EmbeddedMysql;
import com.wix.mysql.config.Charset;
import com.wix.mysql.config.MysqldConfig;
import com.wix.mysql.distribution.Version;
import lombok.SneakyThrows;

import java.net.ServerSocket;
import java.util.TimeZone;

public class EmbeddedMysqlUtil extends RdbDaoUtil {

    private EmbeddedMysql embeddedMysql;

    public EmbeddedMysqlUtil(String dbName) {
        super(dbName);
    }

    @Override
    protected DruidDataSource buildRdbDataSource(String... args) {
        MysqldConfig config = mysqldConfig();
        embeddedMysql = EmbeddedMysql
                .anEmbeddedMysql(mysqldConfig())
                .addSchema(dbName)
                .start();
        String url = "jdbc:mysql://localhost:"+config.getPort()+"/"+dbName+"?useUnicode=true&characterEncoding=UTF-8";
        String driverClass = "com.mysql.jdbc.driver";
        return buildDataSource(url, mysqldConfig().getUsername(), mysqldConfig().getPassword(), driverClass);
    }


    @Override
    public void destroyDataSource() {
        super.destroyDataSource();
        if(embeddedMysql != null){
            embeddedMysql.stop();
        }
    }

    private MysqldConfig mysqldConfig(){
        return MysqldConfig.aMysqldConfig(Version.v5_7_latest)
                .withCharset(Charset.UTF8)
                .withPort(randomPort())
                .withTimeZone(TimeZone.getDefault())
                .withTempDir(DB_LOCAL_PATH)
                .build();
    }

    @SneakyThrows
    private int randomPort(){
        try(ServerSocket serverSocket = new ServerSocket(0)){
            return serverSocket.getLocalPort();
        }
    }

}

MariaDB4j引擎jar:

        // 核心包
        <dependency>
            <groupId>ch.vorburger.mariaDB4j</groupId>
            <artifactId>mariaDB4j-core</artifactId>
            <version>2.4.0</version>
        </dependency>
        // linux os依赖包
        <dependency>
            <groupId>ch.vorburger.mariaDB4j</groupId>
            <artifactId>mariaDB4j-db-linux64</artifactId>
            <version>10.2.11</version>
        </dependency>
        // mac os 依赖包
        <dependency>
            <groupId>ch.vorburger.mariaDB4j</groupId>
            <artifactId>mariaDB4j-db-mac64</artifactId>
            <version>10.2.11</version>
        </dependency>

引擎代码:

import ch.vorburger.mariadb4j.DB;
import ch.vorburger.mariadb4j.DBConfigurationBuilder;
import com.alibaba.druid.pool.DruidDataSource;
import com.book.xw.common.dal.RdbDaoUtil;
import lombok.SneakyThrows;

public class MariaDb4jUtil extends RdbDaoUtil {

    private DB mariaDb;

    public MariaDb4jUtil(String dbName) {
        super(dbName);
    }

    @SneakyThrows
    @Override
    protected DruidDataSource buildRdbDataSource(String... args) {
        buildDb();
        mariaDb.createDB(dbName);
        String url = "jdbc:mysql://localhost:"+mariaDb.getConfiguration().getPort()+"/"+dbName+"?useUnicode=true&characterEncoding=UTF-8";
        String driverClass = "com.mysql.jdbc.driver";
        return buildDataSource(url, "root", "", driverClass);
    }

    @SneakyThrows
    private void buildDb(){
        DBConfigurationBuilder builder = DBConfigurationBuilder.newBuilder();
        // 0 -> auto detect free port
        builder.setPort(0);
        builder.setBaseDir(DB_LOCAL_PATH);
        mariaDb = DB.newEmbeddedDB(builder.build());
        mariaDb.start();
    }

    @SneakyThrows
    @Override
    public void destroyDataSource() {
        super.destroyDataSource();
        if(mariaDb != null){
            mariaDb.stop();
        }
    }
}

Java中,缓存数据库是一种优化数据库访问性能的常见技术。它通过将数据存储在内存中,以避免频繁的数据库查询和磁盘IO操作。 Java缓存数据库通常由两部分组成,即缓存层和数据库层。缓存层是一个位于应用程序和数据库之间的中间层,它负责获取数据并将其存储在内存中。当应用程序需要查询数据时,它首先检查缓存层是否已经存在该数据,如果存在,则直接从缓存中获取数据,从而避免了与数据库的通信。如果缓存中不存在该数据,才会向数据库发起查询请求,并将查询结果存储在缓存中,以便后续使用。 Java缓存数据库具有以下优点: 1. 提升读取性能:由于缓存数据库将数据存储在内存中,读取数据时可以直接从内存中获取,避免了磁盘IO操作,因此读取性能得到了显著提升。 2. 减轻数据库压力:通过将数据存储在缓存中,可以减少对数据库的频繁查询,从而减轻了数据库的负载压力,提高了数据库的可扩展性和性能。 3. 提高响应速度:由于读取数据的速度得到了提升,应用程序可以更快地响应用户请求,提供更好的用户体验。 4. 数据一致性:由于缓存中的数据是根据数据库中的数据生成的,因此缓存数据库可以保证数据的一致性。当数据库中的数据发生变化时,缓存数据库会更新缓存中的数据,确保数据的一致性。 然而,使用Java缓存数据库也存在一些潜在的问题。例如,缓存数据可能会占用大量的内存空间,需要合理的缓存策略来管理缓存的大小和过期时间。此外,缓存中的数据可能会存在与数据库不一致的情况,需要通过合适的缓存更新策略来保证数据的一致性。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值