SpringBoot系列教材 （十八）- CRUD+分页 - SPRINGBOOT 基于SQLITE 和JPA 方式

原创 已于 2023-11-01 19:42:26 修改 · 510 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#jvm #spring boot #后端 #开发语言
于 2023-11-01 19:35:28 首次发布

步骤1:SQLite 介绍
步骤2:先运行，看到效果，再学习
步骤3:模仿和排错
步骤4:基于前面的知识点
步骤5:SQLite 方言一堆
步骤6:application.properties
步骤7:pom.xml
步骤8:重启运行

步骤 1 : SQLite 介绍

SQLite 是一种数据库，它是跑在 JVM里面的，所以不需要像 mysql 那样得独立安装配置，而是直接拿来就用。。。
本知识点就会把对mysql 的依赖，建立在 sqlite 上，这样大家跑起来就不用费神地安装配置 mysql 数据了啦

步骤 2 : 先运行，看到效果，再学习

老规矩，先下载下载区(点击进入)的可运行项目，配置运行起来，确认可用之后，再学习做了哪些步骤以达到这样的效果。
如图所示，效果和使用 mysql 一样， CRUD和分页都有~
测试地址：

http://127.0.0.1:8080/listCategory


注： 启动方式是Springboot特有的，直接运行类：com.how2java.springboot.Application 的主方法。

先运行，看到效果，再学习

步骤 3 : 模仿和排错

在确保可运行项目能够正确无误地运行之后，再严格照着教程的步骤，对代码模仿一遍。
模仿过程难免代码有出入，导致无法得到期望的运行结果，此时此刻通过比较正确答案 ( 可运行项目 ) 和自己的代码，来定位问题所在。
采用这种方式，学习有效果，排错有效率，可以较为明显地提升学习速度，跨过学习路上的各个槛。

推荐使用diffmerge软件，进行文件夹比较。把你自己做的项目文件夹，和我的可运行项目文件夹进行比较。
这个软件很牛逼的，可以知道文件夹里哪两个文件不对，并且很明显地标记出来
这里提供了绿色安装和使用教程：diffmerge 下载和使用教程

步骤 4 : 基于前面的知识点

本知识点是建立在上一个知识点 Springboot使用JPA实现完整的增删改查 CRUD和分页 可运行项目的基础上进行的改进,所以最好把上个知识点理解和消化了.

步骤 5 : SQLite 方言一堆

因为是使用 JPA 来链接 SQlite, 而 JPA 默认用的是 Hibernate，所以要为 Hibernate 配置专门的方言。
方言是什么意思呢？
为了更好地和四川人打交道，最好说四川方言。
为了更好地和浙江人打交道，最好说浙江方言。
为了更好地和 sqlite 打交道，最好说 sqlite 方言。
方言就是这么个意思啦，方便 Hibernate和 Sqlite打交道。 方言的英文是 Dialect， 所以就有了SQLiteDialect 这个类了。
除此之外，还需要其他两个类配合。

至于他们是怎么工作的。。。就不用关心啦，反正能用就行啦。。。

package com.how2java.sqlite;

  

import java.sql.SQLException;

import java.sql.Types;

import org.hibernate.JDBCException;

import org.hibernate.ScrollMode;

import org.hibernate.dialect.Dialect;

import org.hibernate.dialect.function.AbstractAnsiTrimEmulationFunction;

import org.hibernate.dialect.function.NoArgSQLFunction;

import org.hibernate.dialect.function.SQLFunction;

import org.hibernate.dialect.function.SQLFunctionTemplate;

import org.hibernate.dialect.function.StandardSQLFunction;

import org.hibernate.dialect.function.VarArgsSQLFunction;

import org.hibernate.dialect.identity.IdentityColumnSupport;

import org.hibernate.dialect.pagination.AbstractLimitHandler;

import org.hibernate.dialect.pagination.LimitHandler;

import org.hibernate.dialect.pagination.LimitHelper;

import org.hibernate.dialect.unique.DefaultUniqueDelegate;

import org.hibernate.dialect.unique.UniqueDelegate;

import org.hibernate.engine.spi.RowSelection;

import org.hibernate.exception.DataException;

import org.hibernate.exception.JDBCConnectionException;

import org.hibernate.exception.LockAcquisitionException;

import org.hibernate.exception.spi.SQLExceptionConversionDelegate;

import org.hibernate.exception.spi.TemplatedViolatedConstraintNameExtracter;

import org.hibernate.exception.spi.ViolatedConstraintNameExtracter;

import org.hibernate.internal.util.JdbcExceptionHelper;

import org.hibernate.mapping.Column;

import org.hibernate.type.StandardBasicTypes;

public class SQLiteDialect extends Dialect {

    private final UniqueDelegate uniqueDelegate;

  

    public SQLiteDialect() {

        registerColumnType(Types.BIT, "boolean");

        registerColumnType(Types.DECIMAL, "decimal");

        registerColumnType(Types.CHAR, "char");

        registerColumnType(Types.LONGVARCHAR, "longvarchar");

        registerColumnType(Types.TIMESTAMP, "datetime");

        registerColumnType(Types.BINARY, "blob");

        registerColumnType(Types.VARBINARY, "blob");

        registerColumnType(Types.LONGVARBINARY, "blob");

  

        registerFunction("concat", new VarArgsSQLFunction(StandardBasicTypes.STRING, "", "||", ""));

        registerFunction("mod", new SQLFunctionTemplate(StandardBasicTypes.INTEGER, "?1 % ?2"));

        registerFunction("quote", new StandardSQLFunction("quote", StandardBasicTypes.STRING));

        registerFunction("random", new NoArgSQLFunction("random", StandardBasicTypes.INTEGER));

        registerFunction("round", new StandardSQLFunction("round"));

        registerFunction("substr", new StandardSQLFunction("substr", StandardBasicTypes.STRING));

        registerFunction("trim", new AbstractAnsiTrimEmulationFunction() {

            @Override

            protected SQLFunction resolveBothSpaceTrimFunction() {

                return new SQLFunctionTemplate(StandardBasicTypes.STRING, "trim(?1)");

            }

  

            @Override

            protected SQLFunction resolveBothSpaceTrimFromFunction() {

                return new SQLFunctionTemplate(StandardBasicTypes.STRING, "trim(?2)");

            }

  

            @Override

            protected SQLFunction resolveLeadingSpaceTrimFunction() {

                return new SQLFunctionTemplate(StandardBasicTypes.STRING, "ltrim(?1)");

            }

  

            @Override

            protected SQLFunction resolveTrailingSpaceTrimFunction() {

                return new SQLFunctionTemplate(StandardBasicTypes.STRING, "rtrim(?1)");

            }

  

            @Override

            protected SQLFunction resolveBothTrimFunction() {

                return new SQLFunctionTemplate(StandardBasicTypes.STRING, "trim(?1, ?2)");

            }

  

            @Override

            protected SQLFunction resolveLeadingTrimFunction() {

                return new SQLFunctionTemplate(StandardBasicTypes.STRING, "ltrim(?1, ?2)");

            }

  

            @Override

            protected SQLFunction resolveTrailingTrimFunction() {

                return new SQLFunctionTemplate(StandardBasicTypes.STRING, "rtrim(?1, ?2)");

            }

        });

        uniqueDelegate = new SQLiteUniqueDelegate(this);

    }

  

    private static final SQLiteDialectIdentityColumnSupport IDENTITY_COLUMN_SUPPORT = new

            SQLiteDialectIdentityColumnSupport(new SQLiteDialect());

  

    @Override

    public IdentityColumnSupport getIdentityColumnSupport() {

        return IDENTITY_COLUMN_SUPPORT;

    }

  

    // limit/offset support ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    private static final AbstractLimitHandler LIMIT_HANDLER = new AbstractLimitHandler() {

        @Override

        public String processSql(String sql, RowSelection selection) {

            final boolean hasOffset = LimitHelper.hasFirstRow(selection);

            return sql + (hasOffset ? " limit ? offset ?" : " limit ?");

        }

  

        @Override

        public boolean supportsLimit() {

            return true;

        }

  

        @Override

        public boolean bindLimitParametersInReverseOrder() {

            return true;

        }

    };

  

    @Override

    public LimitHandler getLimitHandler() {

        return LIMIT_HANDLER;

    }

  

    // lock acquisition support ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    @Override

    public boolean supportsLockTimeouts() {

        // may be http://sqlite.org/c3ref/db_mutex.html ?

        return false;

    }

  

    @Override

    public String getForUpdateString() {

        return "";

    }

  

    @Override

    public boolean supportsOuterJoinForUpdate() {

        return false;

    }

  

    // current timestamp support ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  

    @Override

    public boolean supportsCurrentTimestampSelection() {

        return true;

    }

  

    @Override

    public boolean isCurrentTimestampSelectStringCallable() {

        return false;

    }

  

    @Override

    public String getCurrentTimestampSelectString() {

        return "select current_timestamp";

    }

  

    // SQLException support ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  

    private static final int SQLITE_BUSY = 5;

    private static final int SQLITE_LOCKED = 6;

    private static final int SQLITE_IOERR = 10;

    private static final int SQLITE_CORRUPT = 11;

    private static final int SQLITE_NOTFOUND = 12;

    private static final int SQLITE_FULL = 13;

    private static final int SQLITE_CANTOPEN = 14;

    private static final int SQLITE_PROTOCOL = 15;

    private static final int SQLITE_TOOBIG = 18;

    private static final int SQLITE_CONSTRAINT = 19;

    private static final int SQLITE_MISMATCH = 20;

    private static final int SQLITE_NOTADB = 26;

  

    @Override

    public SQLExceptionConversionDelegate buildSQLExceptionConversionDelegate() {

        return new SQLExceptionConversionDelegate() {

            @Override

            public JDBCException convert(SQLException sqlException, String message, String sql) {

                final int errorCode = JdbcExceptionHelper.extractErrorCode(sqlException) & 0xFF;

                if (errorCode == SQLITE_TOOBIG || errorCode == SQLITE_MISMATCH) {

                    return new DataException(message, sqlException, sql);

                } else if (errorCode == SQLITE_BUSY || errorCode == SQLITE_LOCKED) {

                    return new LockAcquisitionException(message, sqlException, sql);

                } else if ((errorCode >= SQLITE_IOERR && errorCode <= SQLITE_PROTOCOL) || errorCode == SQLITE_NOTADB) {

                    return new JDBCConnectionException(message, sqlException, sql);

                }

  

                // returning null allows other delegates to operate

                return null;

            }

        };

    }

  

    @Override

    public ViolatedConstraintNameExtracter getViolatedConstraintNameExtracter() {

        return EXTRACTER;

    }

  

    private static final ViolatedConstraintNameExtracter EXTRACTER = new TemplatedViolatedConstraintNameExtracter() {

        @Override

        protected String doExtractConstraintName(SQLException sqle) throws NumberFormatException {

            final int errorCode = JdbcExceptionHelper.extractErrorCode(sqle) & 0xFF;

            if (errorCode == SQLITE_CONSTRAINT) {

                return extractUsingTemplate("constraint ", " failed", sqle.getMessage());

            }

            return null;

        }

    };

  

    // union subclass support ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  

    @Override

    public boolean supportsUnionAll() {

        return true;

    }

  

    // DDL support ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  

    @Override

    public boolean canCreateSchema() {

        return false;

    }

  

    @Override

    public boolean hasAlterTable() {

        // As specified in NHibernate dialect

        return false;

    }

  

    @Override

    public boolean dropConstraints() {

        return false;

    }

  

    @Override

    public boolean qualifyIndexName() {

        return false;

    }

  

    @Override

    public String getAddColumnString() {

        return "add column";

    }

  

    @Override

    public String getDropForeignKeyString() {

        throw new UnsupportedOperationException("No drop foreign key syntax supported by SQLiteDialect");

    }

  

    @Override

    public String getAddForeignKeyConstraintString(String constraintName,

                                                   String[] foreignKey, String referencedTable, String[] primaryKey,

                                                   boolean referencesPrimaryKey) {

        throw new UnsupportedOperationException("No add foreign key syntax supported by SQLiteDialect");

    }

  

    @Override

    public String getAddPrimaryKeyConstraintString(String constraintName) {

        throw new UnsupportedOperationException("No add primary key syntax supported by SQLiteDialect");

    }

  

    @Override

    public boolean supportsCommentOn() {

        return true;

    }

  

    @Override

    public boolean supportsIfExistsBeforeTableName() {

        return true;

    }

  

    @Override

    public boolean doesReadCommittedCauseWritersToBlockReaders() {

        // TODO Validate (WAL mode...)

        return true;

    }

  

    @Override

    public boolean doesRepeatableReadCauseReadersToBlockWriters() {

        return true;

    }

  

    @Override

    public boolean supportsTupleDistinctCounts() {

        return false;

    }

  

    @Override

    public int getInExpressionCountLimit() {

        return 1000;

    }

  

    @Override

    public UniqueDelegate getUniqueDelegate() {

        return uniqueDelegate;

    }

  

    private static class SQLiteUniqueDelegate extends DefaultUniqueDelegate {

        public SQLiteUniqueDelegate(Dialect dialect) {

            super(dialect);

        }

  

        @Override

        public String getColumnDefinitionUniquenessFragment(Column column) {

            return " unique";

        }

    }

  

    @Override

    public String getSelectGUIDString() {

        return "select hex(randomblob(16))";

    }

  

    @Override

    public ScrollMode defaultScrollMode() {

        return ScrollMode.FORWARD_ONLY;

    }

}

package com.how2java.sqlite;

  

import org.hibernate.dialect.Dialect;

import org.hibernate.dialect.identity.IdentityColumnSupportImpl;

  

public class SQLiteDialectIdentityColumnSupport extends IdentityColumnSupportImpl {

    public SQLiteDialectIdentityColumnSupport(Dialect dialect) {

        super(dialect);

    }

  

    @Override

    public boolean supportsIdentityColumns() {

        return true;

    }

    @Override

    public boolean hasDataTypeInIdentityColumn() {

        return false;

    }

  

    @Override

    public String getIdentitySelectString(String table, String column, int type) {

        return "select last_insert_rowid()";

    }

  

    @Override

    public String getIdentityColumnString(int type) {

        return "integer";

    }

}

package com.how2java.sqlite;

  

import org.hibernate.boot.MetadataBuilder;

import org.hibernate.boot.registry.StandardServiceRegistry;

import org.hibernate.boot.spi.MetadataBuilderInitializer;

import org.hibernate.engine.jdbc.dialect.internal.DialectResolverSet;

import org.hibernate.engine.jdbc.dialect.spi.DialectResolver;

import org.jboss.logging.Logger;

  

public class SQLiteMetadataBuilderInitializer implements MetadataBuilderInitializer {

  

    private final static Logger logger = Logger.getLogger(SQLiteMetadataBuilderInitializer.class);

  

    @Override

    public void contribute(MetadataBuilder metadataBuilder, StandardServiceRegistry serviceRegistry) {

        DialectResolver dialectResolver = serviceRegistry.getService(DialectResolver.class);

  

        if (!(dialectResolver instanceof DialectResolverSet)) {

            logger.warnf("DialectResolver '%s' is not an instance of DialectResolverSet, not registering SQLiteDialect",

                    dialectResolver);

            return;

        }

  

        ((DialectResolverSet) dialectResolver).addResolver(resolver);

    }

  

    static private final SQLiteDialect dialect = new SQLiteDialect();

  

    static private final DialectResolver resolver = (DialectResolver) info -> {

        if (info.getDatabaseName().equals("SQLite")) {

            return dialect;

        }

  

        return null;

    };

}

步骤 6 : application.properties

对 mysql 的配置，修改到了对 sqlite 的配置，都做了注释，很简单明了

spring.mvc.view.prefix=/WEB-INF/jsp/

spring.mvc.view.suffix=.jsp

#spring.datasource.url=jdbc:mysql://127.0.0.1:3306/how2java?characterEncoding=UTF-8

#spring.datasource.username=root

#spring.datasource.password=admin

#spring.datasource.driver-class-name=com.mysql.jdbc.Driver

#spring.jpa.properties.hibernate.hbm2ddl.auto=update

spring.jpa.database-platform=com.how2java.sqlite.SQLiteDialect

#表结构由hibernate根据实体类来帮你创建

spring.jpa.generate-ddl=true

#自动根据Entity配置创建表

spring.jpa.hibernate.ddl-auto=update

#数据库文件位置

spring.datasource.url=jdbc:sqlite:how2j.db

#驱动名称

spring.datasource.driver-class-name=org.sqlite.JDBC

步骤 7 : pom.xml

增加 sqlite jar 包

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

  <groupId>com.how2java</groupId>

  <artifactId>springboot</artifactId>

  <version>0.0.1-SNAPSHOT</version>

  <name>springboot</name>

  <description>springboot</description>

  <packaging>war</packaging>

   

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>1.5.9.RELEASE</version>

    </parent>

    <dependencies>

        <dependency>

            <groupId>org.xerial</groupId>

            <artifactId>sqlite-jdbc</artifactId>

            <scope>runtime</scope>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-tomcat</artifactId>

             

        </dependency>

        <dependency>

              <groupId>junit</groupId>

              <artifactId>junit</artifactId>

              <version>3.8.1</version>

              <scope>test</scope>

        </dependency>

        <!-- servlet依赖. -->

        <dependency>

              <groupId>javax.servlet</groupId>

              <artifactId>javax.servlet-api</artifactId>

               

        </dependency>

              <dependency>

                     <groupId>javax.servlet</groupId>

                     <artifactId>jstl</artifactId>

              </dependency>

        <!-- tomcat的支持.-->

        <dependency>

               <groupId>org.apache.tomcat.embed</groupId>

               <artifactId>tomcat-embed-jasper</artifactId>

                

        </dependency>    

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-devtools</artifactId>

            <optional>true</optional> <!-- 这个需要为 true 热部署才有效 -->

        </dependency>

         

        <!-- mysql-->

        <dependency>

            <groupId>mysql</groupId>

            <artifactId>mysql-connector-java</artifactId>

            <version>5.1.21</version>

        </dependency>

        <!-- jpa-->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-data-jpa</artifactId>

        </dependency>       

    </dependencies>

    <properties>

        <java.version>1.8</java.version>

    </properties>

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

</project>

步骤 8 : 重启运行

重启运行，然后访问如下地址就可以看到效果了啦，注： 刚开始没数据，要自己加

http://127.0.0.1:8080/listCategory


更多内容，点击了解： https://how2j.cn/k/springboot/springboot-sqlite/2018.html

JPA整合Sqlite解决Dialect报错问题， 最新版Hibernate6
之城的专栏
11-17 3883
我个人项目中，不想使用太重的数据库，而内嵌数据库中SQLite又是最受欢迎的， 因此决定采用这个数据库。可是JPA并不支持Sqlite，这篇文章就是记录如何解决这个问题的。由于我个人比较喜欢使用最新版本的各种包，所以容易遇到各种问题， 多找找网络信息，多花点心思往往都容易找到解决方案的。
spring-boot-starter-data-jpa + SQLite简单例子（含全部代码）
程裕强的专栏
11-16 6571
1、介绍 1.1 SQLite SQLite官网：http://www.sqlite.org/ SQLite是比 Access 更优秀的文件型数据库，支持复杂的 SQL 语句，支持索引、触发器，速度很快，开源等。 1.2 spring-boot-starter-data-jpa Spring Data JPA 是 Spring 基于 ORM 框架、JPA 规范的基础上封装的一套JPA应用框架，可使开发者用极简的代码即可实现对数据的访问和操作。它提供了包括增删改查等在内的常用功能，且易于扩展。spring-b
Hibernate6与Sqlite方言兼容实战：JPA整合最新版解决方案
最新发布
time3的博客
03-01 581
本文针对Hibernate6项目整合SQLite时遇到的方言不兼容问题，提供了官方解决方案。通过引入Hibernate官方维护的`hibernate-community-dialects`依赖，并正确配置`SQLiteDialect`，可彻底解决因第三方方言包过时而导致的启动报错。文章还涵盖了实战中的DDL生成、连接池配置、并发访问等精细调优指南，帮助开发者高效完成JPA与SQLite的整合。
[笔记] - springboot-jpa 使用sqlite 踩坑
31415926535x的博客
12-28 1684
Unable to load class [org.hibernate.dialect.SQLiteDialect] 解决方式
三分钟数据持久化：Spring Boot, JPA 与 SQLite 的完美融合
kfashfasf的博客
03-01 2195
三分钟，迎接一个更加高效和简便的开发体验。在快节奏的软件开发领域，每一个简化工作流程的机会都不容错过。想要一个无需繁琐配置、能够迅速启动的数据持久化方案吗？这篇文章将是你的首选攻略。在这里，我们将向你展示如何将的便捷性、的强大查询能力和的轻量级特性结合在一起，实现快速而又优雅的数据管理。
SpringBoot整合JPA+SQLite
TomPig_1024
11-12 2396
由于项目需求，要求能用一款不需要部署，并且可以跨平台使用，并且支持事务管理的关系型数据，我的第一问题就是为啥不能采用类似MySQL或者Oracle这一类的关系型数据库，并且它们的部署其实也不是很繁琐，他们说服务器不需要额外部署数据库，我的第一反映就是SQLite。至于是JAP或者MyBatis还是什么其他的ORM框架，这些都是无所谓的。
Spring Data JPA 使用 SQLite
孙亖的专栏
10-11 5077
没有安装数据库，但想测试一下 spring data jpa 的功能，为了简单一点想找一个嵌入式的数据库。Java 里面有两个嵌入式数据库，H2 和 Hsqldb，但是这两个数据库我都没有现成好用客户端，不方便去随时查看数据的变化，于是就选择了 Sqlite。 网上有教程说怎么在什么 Spring JPA 里面使用SQllite这个数据库，但是都比讲比较复杂，还要自己实现一些东西，这种方式可以参考...
Springboot集成sqlite数据库，并使用jpa、Hibernate操作sqlite
热门推荐
tianyaleixiaowu的专栏
03-05 2万+
之前举例使用jpa、Hibernate多是以mysql为例，这次因为需要使用一个内嵌式数据库，选择了sqlite，网上多是讲一些sqlite的api封装的框架。这里我们还是使用jpa、Hibernate来操作sqlite。新建一个Springboot项目，pom如下：&lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="ht...
【Linux应用】龙芯派loongsonpai开发者日记（三）----文件系统
平凡的世界
08-31 956
前言 本节主要讲述如何配置boot和文件系统。 1.准备工作 将编译生成的vmlinuz拷贝到龙芯派中，这里我们用winscp工具来操作。 另外建议开启SSH服务，root下执行以下命令就可以 sudo service sshd start 此时，我们操作单板的方式就有：串口，SSH，FTP。开发工作即将开始。 2.boot配置 编辑boot.cfg文件，增加一组，设置波特率等 3.文件系统 buildroot官网：https://buildroot.org/ 下载buildroot-2020.0
JPA与SQLite的配置
Java 之路
11-18 6011
JPA persistence.xml配置 <persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/n
SQLite数据库和JPA简单介绍
weixin_33971977的博客
08-25 527
SQLite数据库和JPA简单介绍 SQLite数据库和JPA简单介绍SQLite数据库和JPA简单介绍 一、SQLite简单使用 SQLite是遵循ACID的关系数据库管理系统，它的处理速度很快，它的设计目标是嵌入式的，只需要几百K的内存就可以了。 1.下载SQLitehttp://www.sqlite.org/download.htmlsqlite-...
Spring Boot 中使用 SQLite
cnzzs的博客
11-23 2802
在现代的软件开发中，Spring Boot 已成为构建 Java 应用程序的热门框架之一。其简洁的配置、快速的开发周期以及对各种数据库的支持，使得开发者能够高效地创建稳定的应用程序。SQLite 作为一种轻量级的嵌入式数据库，常用于开发、测试和小型应用程序。本文将介绍如何在 Spring Boot 项目中使用 SQLite...
Spring-boot 整合sqlite使用Hibernate和Jpa操作
RiverRiverSmile的博客
05-31 3158
https://blog.csdn.net/tianyaleixiaowu/article/details/79445561这篇博客进行了介绍，在windows下可以正常使用，但是在使用docker或linux环境运行springboot会报错，故此重新整理，做一记录，同时供遇到问题的朋友参考；1、application.properties增加以下配置：spring.jpa.database-p...
SQLite数据库 hibernate配置方言
com_xpp的专栏
04-12 794
配置hibernate时，设置数据的方言是很重要的，SQLite是一款内存式小数据库，在项目中很有用，数据查询和更新速度不错。但是，hibernate没有针对SQLite的方言。这就需要我们自己配置了。下面是SQLite数据库的方言类。 package xidian.sms.common; import java.sql.Types; import org.hibernate.Hibe...
jpa整合sqlLite
qq_37576449的博客
09-15 862
jpa整合sqlLite 新建标准springboot项目 导入依赖 <dependency> <groupId>org.xerial</groupId> <artifactId>sqlite-jdbc</artifactId> </dependency> 配置yml文件 spring: application: name: magicbox-admin
SQLITE | 遇到 [SQLITE_BUSY] The database file is locked (database is locked) 问题
qq_43604667的博客
12-28 5461
在springboot 下使用 SQLITE, 出现错误. 由于找了很久没有找到解决方式, 误打误撞解决了, Mark 一下. 最终原因: 使用了 DB Browser for SQLite 工具连接数据库, 导致在 IDEA 执行的时候出现上锁错误, 关掉工具即可. ...
Springboot + Sqlite实战(离线部署成功)
范大的博客
09-04 5557
用的springboot + mybatis-plus + mysql，无法实现，于是考虑使用内嵌式轻量级的数据库SQLlite。此处的url折磨了一晚上，网上各种百度加resource目录下什么的，最后直接这样，启动后会在根目录下自动生成一个db文件。建议方框内的值直接填写生成的db名即可，同时别忘记点击一个test Connection测试一下。sqllite的数据类型和mysql不同,但同时也包容（不确定）最近有个需求，是手机软件离线使用，选择之前的sql执行，可以看日志。OK, 我这边都成功了。
381、Java中级36 -【Spring Boot - CRUD+分页（SpringBoot SQLite）】 2020.09.23
youyouwuxin1234的博客
09-23 304
0、目录1、SQLite 介绍2、先运行，看到效果，再学习3、SQLite 方言一堆4、application.properties5、pom.xml6、重启运行7、参考链接 1、SQLite 介绍 SQLite 是一种数据库，它是跑在 JVM里面的，所以不需要像 mysql 那样得独立安装配置，而是直接拿来就用。。。 本知识点就会把对mysql 的依赖，建立在 sqlite 上，这样大家跑起来就不用费神地安装配置 mysql 数据了啦 2、先运行，看到效果，再学习 老规矩，先下载右上角的可运行项目，配置运
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值