而查询是涉及到数据库使用最广泛的操作，需要最大的灵活性。各种ORM解决方案各不相同，Hibernate和JPA自己实现了HQL和JPQL查询语法，用以生成最终的SQL，而MyBatis则完全手写，每增加一个查询都需要先编写SQL并增加接口方法。

    还有一种Hibernate和JPA支持的Criteria查询，用Hibernate写出来类似：

    上述Criteria查询写法复杂，但和JPA相比，还是小巫见大巫了：

    2. CriteriaQuery<User> q = cb.createQuery(User.class);
    3. Root<User> r = q.from(User.class);
    4. q.where(cb.equal(r.get("email"), cb.parameter(String.class, "e")));
    5. TypedQuery<User> query = em.createQuery(q);
    6. query.setParameter("e", email);
    7. List<User> list = query.getResultList();

    此外，是否支持自动读取一对多和多对一关系也是全自动化ORM框架的一个重要功能。

    如果我们自己来设计并实现一个ORM，应该吸取这些ORM的哪些特色，然后高效实现呢？

    任何设计，都必须明确设计目标。这里我们准备实现的ORM并不想要全自动ORM那种自动读取一对多和多对一关系的功能，也不想给Entity加上复杂的状态，因此，对于Entity来说，它就是纯粹的JavaBean，没有任何Proxy。

    此外，ORM要兼顾易用性和适用性。易用性是指能覆盖95%的应用场景，但总有一些复杂的SQL，很难用ORM去自动生成，因此，也要给出原生的JDBC接口，能支持5%的特殊需求。

    最后，我们希望设计的接口要易于编写，并使用流式API便于阅读。为了配合编译器检查，还应该支持泛型，避免强制转型。

    1. // 按主键查询: SELECT * FROM users WHERE id = ?
    2. User u = db.get(User.class, 123);
    4. // 条件查询唯一记录: SELECT * FROM users WHERE email = ? AND password = ?
    5. User u = db.from(User.class)
    6.            .where("email=? AND password=?", "bob@example.com", "bob123")
    7.            .unique();
    9. // 条件查询多条记录: SELECT * FROM users WHERE id < ? ORDER BY email LIMIT ?, ?
    10. List<User> us = db.from(User.class)
    11.                   .where("id < ?", 1000)
    12.                   .orderBy("email")
    13.                   .limit(0, 10)
    14.                   .list();
    16. // 查询特定列: SELECT id, name FROM users WHERE email = ?
    17. User u = db.select("id", "name")
    18.            .from(User.class)
    19.            .where("email = ?", "bob@example.com")
    20.            .unique();

    这样的流式API便于阅读，也非常容易推导出最终生成的SQL。

    对于插入、更新和删除操作，就相对比较简单：

    对于Entity来说，通常一个表对应一个。手动列出所有Entity是非常麻烦的，一定要传入package自动扫描。

    最后，ORM总是需要元数据才能知道如何映射。我们不想编写复杂的XML配置，也没必要自己去定义一套规则，直接使用JPA的注解就行。

    我们并不需要从JDBC底层开始编写，并且，还要考虑到事务，最好能直接使用Spring的声明式事务。实际上，我们可以设计一个全局DbTemplate，它注入了Spring的JdbcTemplate，涉及到数据库操作时，全部通过JdbcTemplate完成，自然天生支持Spring的声明式事务，因为这个ORM只是在JdbcTemplate的基础上做了一层封装。

    在AppConfig中，我们初始化所有Bean如下：

    1. @Configuration
    2. @ComponentScan
    3. @EnableTransactionManagement
    4. @PropertySource("jdbc.properties")
    5. public class AppConfig {
    6.     DataSource createDataSource() { ... }
    8.     @Bean
    9.     JdbcTemplate createJdbcTemplate(@Autowired DataSource dataSource) {
    10.         return new JdbcTemplate(dataSource);
    13.     @Bean
    14.     DbTemplate createDbTemplate(@Autowired JdbcTemplate jdbcTemplate) {
    15.         return new DbTemplate(jdbcTemplate, "com.itranswarp.learnjava.entity");
    16.     }
    18.     @Bean
    19.     PlatformTransactionManager createTxManager(@Autowired DataSource dataSource) {
    20.         return new DataSourceTransactionManager(dataSource);
    21.     }
    22. }

    以上就是我们所需的所有配置。

    编写业务逻辑，例如UserService，写出来像这样：

    1. @Component
    2. @Transactional
    3. public class UserService {
    4.     @Autowired
    5.     DbTemplate db;
    7.     public User getUserById(long id) {
    8.         return db.get(User.class, id);
    9.     }
    11.     public User getUserByEmail(String email) {
    12.         return db.from(User.class)
    13.                  .where("email = ?", email)
    14.                  .unique();
    15.     }
    17.     public List<User> getUsers(int pageIndex) {
    18.         int pageSize = 100;
    19.         return db.from(User.class)
    20.                  .orderBy("id")
    21.                  .list();
    22.     }
    24.     public User register(String email, String password, String name) {
    25.         User user = new User();
    26.         user.setEmail(email);
    27.         user.setPassword(password);
    28.         user.setName(name);
    29.         user.setCreatedAt(System.currentTimeMillis());
    31.         return user;
    32.     }
    33.     ...
    34. }

    实现链式API的核心代码是第一步从DbTemplate调用select()或from()时实例化一个CriteriaQuery实例，并在后续的链式调用中设置它的字段：

    1. public class DbTemplate {
    2.     ...
    3.     public Select select(String... selectFields) {
    4.         return new Select(new Criteria(this), selectFields);
    5.     }
    7.     public <T> From<T> from(Class<T> entityClass) {
    8.         Mapper<T> mapper = getMapper(entityClass);
    9.         return new From<>(new Criteria<>(this), mapper);
    10.     }
    11. }

    然后以此定义Select、From、Where、OrderBy、Limit等。在From中可以设置Class类型、表名等：

    1. public final class From<T> extends CriteriaQuery<T> {
    2.     From(Criteria<T> criteria, Mapper<T> mapper) {
    3.         super(criteria);
    4.         // from可以设置class、tableName:
    5.         this.criteria.mapper = mapper;
    6.         this.criteria.clazz = mapper.entityClass;
    7.         this.criteria.table = mapper.tableName;
    8.     }
    10.     public Where<T> where(String clause, Object... args) {
    11.         return new Where<>(this.criteria, clause, args);
    12.     }

    在Where中可以设置条件参数：

    最后，链式调用的尽头是调用list()返回一组结果，调用unique()返回唯一结果，调用返回首个结果。

    在IDE中，可以非常方便地实现链式调用：

    需要复杂查询的时候，总是可以使用JdbcTemplate执行任意复杂的SQL。

    从下载练习：设计并实现一个微型ORM （推荐使用快速下载）

    设计ORM - 图1