用Java访问数据库的不同方法

Question

There are a lot of technologies to access data using Java. I was reading about some of them, including:

• JPQL
• HQL
• Criteria API
• Querydsl
• jOOQ
• JaQu
• JDBC
• ActiveJDBC

Now I am really confused because of the overhead. What are the main differences and similarities between these technologies? Which are most commonly used? Short comparison is more than welcome.

Answer 1

The fundamental foundation for database access in Java is JDBC. It is an interface (no implementation) that permits database vendors to expose their databases in a standard way, so Java programmers don't have to radically alter their code to support different relational databases.

That said, it accepts SQL, and SQL is standard, with so many variants that the standards do not permit cross database portability.

The rest of the platforms tend to build upon JDBC in an attempt to ease the cost of integrating with other databases. The numbers of ways one can interact with a database is varied, basically you get improvement on issuing SQL commands or the additional library takes over the writing of a compatible SQL command for you.

The two major categories are "database like" and "object storage" where object storage focuses on you storing a Java Object, and the libraries take care of most of the details of SQL generation.

Technology                 / query language / type         / notes

Java Persistance API       / JPQL           / object store / not an implementation, but an interface allowing multiple implementations, query language is not table specific, but object specific
Hibernate                  / HQL            / object store / a popular Java solution, but tied to Hibernate only.
Java Persistance API       / Criteria API   / object store / Criteria API is the code (programming) equivalent to the JPQL strings.
Java Persistance API & JDO / QueryDSL API   / object store / Java API to build queries similar to Criteria API, but different
JDBC                       / jOOQ           / direct JDBC  / Java API that replaces SQL strings construction with method calls that are table centric
H2 database                / JaQu           / object store / Linked directly to one database, non-portable.  Follows Microsoft LINQ syntax.
JDBC                       / ActiveJDBC     / object store / Looks like a branded version of almost-JPA for webapps.  

The two fundamental APIs in this space are JDBC and JDO, where the subset of JDO you wish to use if you are only going to support relational databases is JPA. Neither JDBC nor JDO provide a database connection directly, they are pure-play APIs. That said, a lot of database vendors push their APIs which don't leverage these technologies, I would advise not using any technology that isn't based on JDBC and JPA.

Again to leverage multiple implementations, I would also advise that you not use a query language that isn't based on JPQL (if you build queries in Strings) or the CriteriaAPI (if you build queries in code), both which are conceptual components of JPA. If you are using JDBC directly, use PreparedStatements for all issued SQL, and keep in mind that while you may be able to leverage your existing SQL codebase with a pure JDBC solution, you will likely get a better quality implementation (and possibly faster delivery) using JPA, because there are lots of corner cases in mapping Relational Databases to Java that very few existing database codebases handle.

Answer 2

Do not write JDBC code. You will never do a better job of it than MyBatis and/or Hibernate.

Instead, learn and use either MyBatis or Hibernate.

MyBatis is simpler (and most likely sufficient for anything you will need) and Hibernate has a million features (none of which you probably need).

Answer 3

1. Using JDBC API and registering your DB class and making the connection.
2. Using Datasource , where you define DB details on your server like WebSphere or Weblogic server And you lookup the defined datasource.
3. Using some ORM framework like Hibernate.