我们还（要）在用jdbc吗？

Jdbc的灵活性和性能我们都是知道的。
它的不方便性我们也是共知的。
今天，我们仍然需要为它的性能或灵活，忍受它的不便的吗？
No! :-)
向大家推荐一个全新的ORM解决方案。
1，它有jdbc的速度，里面有一个测试程序，欢迎大家测试，你也可以自己写程序测试。
2，它具有jdbc的灵活性，jdbc能做的，它几乎都能做。
3，它还能做jdbc不能做的：ORM（关系与对象的映射）。

访问它：https://dcoat.dev.java.net/

满大街都有产品，给点更新奇的特性吧。

呵呵，就是没有你想要的吧。
都是些垃圾产品，对吧？这个也是。

jdbc能做的，有的hibernate就不行

比JDBC快吗? 大型项目性能第一, 方不方便倒是其次的.

dcoat is a orm solution base relation database.   除了这句话,我看不出它有什么特点,请问这产品是给你自己用的吗?

1. 易学易用。不把在开发ORM框架本身中冒出的问题或概念带到用户面前。
2. 高性能。在不用cache的情况下，保持与jdbc同级的速度；设计高效率的
cache，在有限空间里，解决或最大程度上缓解用户的性能问题。
3. 提倡简洁舒心的编程。充分利用java语言本身的特性，用心的设计，提供简明轻快
的接口。
4. 高效率。这是dcoat为客户提供的核心价值之一，也是我们开发dcoat中一直关注，
强调和实施的重要目标。

可以考虑用ibatis。

1， dcoat 比ibatis更容易学，用起来更简单。
    dcoat不用写sql语句, 不用写sql语句的xml mapping

2， dcoat的性能比ibatis只高不低。

3， dcoat的编程更干净舒适，更容易维护。

4， dcoat比ibatis有更高的开发效率。

我们可以通过一个简单的CRUD + find的例子来说明：

在dcoat里实现：

Book newBook = new Book("bookName");
newBook.store(); //Create
Book book = Book.load(newBook.getId()); // Read
book.setName("updatedBookName");
book.update(); //Update.
List<Book> bookList = Book.find(null, eq(Book.NAME, "updatedBookName")); // find
book.delete(); //Delete

在ibatis里实现：
1， 先写一个sql mapping xml 文件：
<?xml version="1.0" encoding="UTF-8" ?>
    <!-- 在这里就省略掉 -->
</sqlMap>

2， 要写一个BookDao类

public class BookDao {

    .......
    public void addBook(Book newBook) {
        // do something.
    }

    public static Book loadBook(long id) {
        // do something.
    }
    .......

}

3， 做CRUD + find

Book newBook = new Book("bookName");
bookDao.addBook(newBook); //Create
Book book = bookDao.load(newBook.getId()); // Read
book.setName("updatedBookName");
bookDao.updateBook(book); //Update.
List<Book> bookList = bookDao.findByName("updatedBookName"); // find
bookDao.deleteBook(book); //Delete

就前面说的四点举个例子说明。
假设我们现在要增加一个需求：不仅能根据“名称＝”查询，还要“名称 like”查询

dcoat需要做什么呢？ nothing！
List<Book> bookList = Book.find(null, like(Book.NAME, "updatedBookName")); // find

而ibatis要做什么呢？
1， 首先要配置sql xml mapping，
2， 在BookDao添加一个函数。

还有更多的，例如增减一个字段......用ibatis工作和维护都不会太简单。
用ibatis，你不但要会写sql语句，还要记住表名，表的定义，字段，表和对象是怎么映射的，等等。
而用dcoat，你完全可以把数据库扔到一边去。

（注：在处理对象和关系映射方面，dcoat要比ibatis强多了，由于这个不是这里讨论话题，就不说了:D ）

下面是dcoat自动生成的Book类：

/*
 * Generated by dcoat - Do not edit!
 */
package hello.po;
import com.qz.dcoat.node.condition.Condition;
import com.qz.dcoat.CoatException;

import com.qz.dcoat.util.N;

import com.qz.dcoat.object.AbstractNappy;
import java.util.*;


/**
 * @dcoat-generated at ${TODAY}
 * @copyright The dcoat Team
 * @author dcoat
 * @version ${version}
 */
public class Book extends AbstractNappy implements java.io.Serializable {
    /**
     * Name of "Book" object. 
     */
    public static final String _ = "Book";

    /**
     * Name of "id" property. 
     * java type: long. 
     * column: "id". 
     * jdbc type: INTEGER UNSIGNED(10). 
     */
    public static final String ID = _ + ".id";

    /**
     * Name of "name" property. 
     * java type: java.lang.String. 
     * column: "name". 
     * jdbc type: VARCHAR(45). 
     */
    public static final String NAME = _ + ".name";


    private static final long serialVersionUID = 1184918896300L;
    private long id;
    private String name;

    public Book() {
    }

    public Book(long id) {
        this();
        setId(id);
    }

    public Book(String name) {
        this();
        setName(name);
    }

    public Book(long id, String name) {
        this();
        setId(id);
        setName(name);
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
        super.setUpdatedPropName(ID);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
        super.setUpdatedPropName(NAME);
    }

    public static Book load(long id, Collection<String> selectPropNames, Object... options) throws CoatException {
        return (Book) AbstractNappy.load(Book.class, N.newOid(ID, id), selectPropNames, options);
    }

    public static List<Book> find(Collection<String> selectPropNames, Condition condition, Object... options) throws CoatException {
        return AbstractNappy.find(Book.class, _, selectPropNames, condition, options);
    }

    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof Book) {
            Book anotherBook = (Book)anObject;
            if ((id == anotherBook.id)
                && (name == null ? anotherBook.name == null : name.equals(anotherBook.name))) {
                return true;
            }
        }
        return false;
    }

    public int hashCode() {
        int h = 17; 
        h = 31*h + getHashCode(id);
        h = 31*h + getHashCode(name);
        return h; 
    }

    public String toString() {
        return "{"
        + "id=" + id + ", "
        + "name=" + (null == name ? null : name.toString())   
        + "}";
    }

    private int getHashCode(Object object) {
        if (null == object) {
            return 0;
        } else {
            return object.hashCode();
        }
    }
}

从代码上看  好像是另一个hibernate