持久化相关名词解释

JPA与Hibernate的关系

1.JPA

  JPA全称： Java Persistence API
  JPA通过JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。
  JPA的出现？
  JPA的出现有两个原因：
  其一，简化现有Java EE和Java SE应用的对象持久化的开发工作；
  其二，Sun希望整合对ORM技术，实现持久化领域的统一。

1.1.JPA提供的技术

(1)ORM映射元数据
JPA支持XML和JDK 5.0注解两种元数据的形式，元数据描述对象和表之间的映射关系，框架据此将实体对象持
久化到数据库表中；
(2)JPA 的API
用来操作实体对象，执行CRUD操作，框架在后台替我们完成所有的事情，开发者从繁琐的JDBC和SQL代码中解
脱出来。
(3)查询语言
通过面向对象而非面向数据库的查询语言查询数据，避免程序的SQL语句紧密耦合。

2. Hibernate

JPA是需要Provider来实现其功能的，Hibernate就是JPA Provider中很强的一个。从功能上来说，JPA现在就是Hibernate功能的一个子集。Hibernate 从3.2开始，就开始兼容JPA。Hibernate3.2获得了Sun TCK的 JPA(Java Persistence API) 兼容认证。

例如：

(1)实体对象的状态，在Hibernate有自由、持久、游离三种，JPA里有new，managed，detached，removed，而这些状态都是一一对应的。

(2)flush方法，都是对应的，

(3)Query query = manager.createQuery(sql)，它在Hibernate里写法上是session，而在JPA中变成了 manager

3. JPA和Hibernate之间的关系，可以简单的理解为JPA是标准接口，Hibernate是实现。

那么Hibernate是如何实现与JPA 的这种关系的呢？

Hibernate主要是通过三个组件来实现的，及hibernate-annotation、hibernate-entitymanager和hibernate-core。

(1)hibernate-annotation是Hibernate支持annotation方式配置的基础，它包括了标准的JPA annotation以及 Hibernate自身特殊功能的annotation。

(2)hibernate-core是Hibernate的核心实现，提供了Hibernate所有的核心功能。

(3)hibernate-entitymanager实现了标准的JPA，可以把它看成hibernate-core和JPA之间的适配器，它并不直接提供ORM的功能，而是对hibernate-core进行封装，使得Hibernate符合JPA的规范。

总的来说，JPA是规范，Hibernate是框架，JPA是持久化规范，而Hibernate实现了JPA。

DataSource.url路径规则

数据库连接子协议

JDBC的URL＝协议名＋子协议名＋数据源名。 
 a .协议名总是“jdbc”。 
b .子协议名由JDBC驱动程序的编写者决定。 
c .数据源名也可能包含用户与口令等信息；这些信息也可单独提供。

## 几种常见的数据库连接

## 1 —oracle—

 驱动：oracle.jdbc.driver.OracleDriver 
URL：`jdbc:oracle:thin:@machine_name:port:dbname` 
注：machine_name：数据库所在的机器的名称； 
port：端口号，默认是1521

## 2 —mysql—

 驱动：com.mysql.jdbc.Driver 
URL：`jdbc:mysql://machine_name:port/dbname` 
注：machine_name：数据库所在的机器的名称； 
port：端口号，默认3306

## 3 —SQL Server—

 驱动：com.microsoft.jdbc.sqlserver.SQLServerDriver 
URL：`jdbc:microsoft:sqlserver://<machine_name><:port>;DatabaseName=<dbname>` 
注：machine_name：数据库所在的机器的名称； 
port：端口号，默认是1433

## 4 —DB2—

 驱动：com.ibm.db2.jdbc.app.DB2Driver 
URL：`jdbc:db2://<machine_name><:port>/dbname` 
注：machine_name：数据库所在的机器的名称； 
port：端口号，默认是5000

使用sqllite 相关配置

1.pom.xml 的依赖添加(如果直线使用其他的数据库需要把原来的删除掉), 版本号需要自己确定

如下:

<dependency>
            <groupId>org.xerial</groupId>
            <artifactId>sqlite-jdbc</artifactId>
            <version>3.20.0</version>
</dependency>

然后需要配置数据源DataSource(2种方法 1. 代码注解配置 2.yml(properties)中配置如下)
1.代码配置

package com.mindata.blockchain.core.sqlite;
 
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.sqlite.SQLiteDataSource;
 
import javax.sql.DataSource;
 
 
/**
 * 配置sqlite数据库的DataSource
 * @author wuweifeng wrote on 2018/3/2.
 */
@Configuration
public class DataSourceConfiguration {
 
    @Bean(destroyMethod = "", name = "EmbeddeddataSource")
    public DataSource dataSource() {
        DataSourceBuilder dataSourceBuilder = DataSourceBuilder.create();
        dataSourceBuilder.driverClassName("org.sqlite.JDBC");
        dataSourceBuilder.url("jdbc:sqlite:" + "example.db");
        dataSourceBuilder.type(SQLiteDataSource.class);
        return dataSourceBuilder.build();
    }
 
}

2.application.properties 的参考
路径配置.1
数据库连接jdbc.jdbc-url=jdbc:sqlite:db/app.db#
此时db文件放在工程目录下即可。
路径配置2
使用相对路径连接sqlite
数据库连接jdbc.jdbc-url=jdbc:sqlite::resource:db/app.db
连接驱动jdbc.driver-class=org.sqlite.JDBC

由于使用Hibernate, Hibernate不支持sqllite 需要自己写方言
文件如下:

package com.mds.aliyun.dialect;
import java.sql.Types;

import org.hibernate.Hibernate;
import org.hibernate.dialect.Dialect;
import org.hibernate.dialect.function.SQLFunctionTemplate;
import org.hibernate.dialect.function.StandardSQLFunction;
import org.hibernate.dialect.function.VarArgsSQLFunction;
import org.hibernate.type.IntegerType;
import org.hibernate.type.StringType;


public class SQLiteDialect extends Dialect {
     public SQLiteDialect() {
            super();
            registerColumnType(Types.BIT, "integer");
            registerColumnType(Types.TINYINT, "tinyint");
            registerColumnType(Types.SMALLINT, "smallint");
            registerColumnType(Types.INTEGER, "integer");
            registerColumnType(Types.BIGINT, "bigint");
            registerColumnType(Types.FLOAT, "float");
            registerColumnType(Types.REAL, "real");
            registerColumnType(Types.DOUBLE, "double");
            registerColumnType(Types.NUMERIC, "numeric");
            registerColumnType(Types.DECIMAL, "decimal");
            registerColumnType(Types.CHAR, "char");
            registerColumnType(Types.VARCHAR, "varchar");
            registerColumnType(Types.LONGVARCHAR, "longvarchar");
            registerColumnType(Types.DATE, "date");
            registerColumnType(Types.TIME, "time");
            registerColumnType(Types.TIMESTAMP, "timestamp");
            registerColumnType(Types.BINARY, "blob");
            registerColumnType(Types.VARBINARY, "blob");
            registerColumnType(Types.LONGVARBINARY, "blob");
            registerColumnType(Types.BLOB, "blob");
            registerColumnType(Types.CLOB, "clob");
            registerColumnType(Types.BOOLEAN, "integer");
            registerFunction("concat", new VarArgsSQLFunction(StringType.INSTANCE, "", "||", ""));
            registerFunction("mod", new SQLFunctionTemplate(IntegerType.INSTANCE, "?1 % ?2"));
            registerFunction("substr", new StandardSQLFunction("substr", StringType.INSTANCE));
            registerFunction("substring", new StandardSQLFunction("substr", StringType.INSTANCE));
        }
     
        public boolean supportsIdentityColumns() {
            return true;
        }
     
        /*
         public boolean supportsInsertSelectIdentity() {
         return true; // As specify in NHibernate dialect
         }
         */
     
        public boolean hasDataTypeInIdentityColumn() {
            return false; // As specify in NHibernate dialect
        }
     
        /*
         public String appendIdentitySelectToInsert(String insertString) {
         return new StringBuffer(insertString.length()+30). // As specify in NHibernate dialect
         append(insertString).
         append("; ").append(getIdentitySelectString()).
         toString();
         }
         */
     
        public String getIdentityColumnString() {
            // return "integer primary key autoincrement";
            return "integer";
        }
     
        public String getIdentitySelectString() {
            return "select last_insert_rowid()";
        }
     
        public boolean supportsLimit() {
            return true;
        }
     
        public String getLimitString(String query, boolean hasOffset) {
            return new StringBuffer(query.length() + 20).append(query).append(
                    hasOffset ? " limit ? offset ?" : " limit ?").toString();
        }
     
        public boolean supportsTemporaryTables() {
            return true;
        }
     
        public String getCreateTemporaryTableString() {
            return "create temporary table if not exists";
        }
     
        public boolean dropTemporaryTableAfterUse() {
            return false;
        }
     
        public boolean supportsCurrentTimestampSelection() {
            return true;
        }
     
        public boolean isCurrentTimestampSelectStringCallable() {
            return false;
        }
     
        public String getCurrentTimestampSelectString() {
            return "select current_timestamp";
        }
     
        public boolean supportsUnionAll() {
            return true;
        }
     
        public boolean hasAlterTable() {
            return false; // As specify in NHibernate dialect
        }
     
        public boolean dropConstraints() {
            return false;
        }
     
        public String getAddColumnString() {
            return "add column";
        }
     
        public String getForUpdateString() {
            return "";
        }
     
        public boolean supportsOuterJoinForUpdate() {
            return false;
        }
     
        public String getDropForeignKeyString() {
            throw new UnsupportedOperationException(
                    "No drop foreign key syntax supported by SQLiteDialect");
        }
     
        public String getAddForeignKeyConstraintString(String constraintName,
                String[] foreignKey, String referencedTable, String[] primaryKey,
                boolean referencesPrimaryKey) {
            throw new UnsupportedOperationException(
                    "No add foreign key syntax supported by SQLiteDialect");
        }
     
        public String getAddPrimaryKeyConstraintString(String constraintName) {
            throw new UnsupportedOperationException(
                    "No add primary key syntax supported by SQLiteDialect");
        }
     
        public boolean supportsIfExistsBeforeTableName() {
            return true;
        }
     
        public boolean supportsCascadeDelete() {
            return false;
        }

}

在 application.properties 中添加一下配置

spring.jpa.database-platform=com.mds.aliyun.dialect.SQLiteDialect
spring.datasource.driver-class-name=org.sqlite.JDBC

最终application.properties 如下:

spring.datasource.url=jdbc:sqlite:your.db
spring.jpa.database-platform=xxx
spring.datasource.driver-class-name=org.sqlite.JDBC

spring.jpa.generate-ddl=true
spring.jpa.hibernate.ddl-auto=update

上面的xxx是你在项目中生成的方言类的路径.