本文由码农网 – 孙腾浩原创翻译，转载请看清文末的转载要求，欢迎参与我们的付费投稿计划！
(“Too Long; Didn’t Read.”太长不想看，可以看这段摘要 )ORM是一种讨厌的反模式，违背了所有面向对象的原则。将对象分隔开并放入被动的数据包中。ORM没有理由存在任何应用中，无论是小的网络应用还是涉及增删改查上千张表的企业系统。用什么来替代它呢？SQL对象(SQL-speaking objects)。
ORM如何工作
Object-relational mapping(ORM)是一种链接关系型数据库和面向对象语言(比如Java)的技术。在各种语言中有大量ORM的实现；比如:Java中的Hibernate，Ruby on Rails中的ActiveRecord，PHP中的Doctrine，Python中的SQLAlchemy。在Java中，甚至把ORM设计作为JPA标准。
首先,让我们看看ORM如何工作。比如，我们用Java，PostgreSQL和Hibernate。我们在数据库有张表，叫 post:
| id | date | title |
|---|---|---|
| 9 | 10/24/2014 | How to cook a sandwich |
| 13 | 11/03/2014 | My favorite movies |
| 27 | 11/17/2014 | How much I love my job |
如果我们在Java应用中对这张表增删改查(CRUD:create, read, update, and delete).首先,我们创建一个 Post 类(很抱歉代码很长,我尽量简洁一点)
@Entity
@Table(name = "post")
public class Post {
private int id;
private Date date;
private String title;
@Id
@GeneratedValue
public int getId() {
return this.id;
}
@Temporal(TemporalType.TIMESTAMP)
public Date getDate() {
return this.date;
}
public Title getTitle() {
return this.title;
}
public void setDate(Date when) {
this.date = when;
}
public void setTitle(String txt) {
this.title = txt;
}
}
在Hibernate做任何操作前,我们要创建一个session工厂:
SessionFactory factory = new AnnotationConfiguration() .configure() .addAnnotatedClass(Post.class) .buildSessionFactory();
这个工厂能在每次我们需要操作 Post对象时给我们”session”。任何有关session的操作应该包裹下面代码块:
Session session = factory.openSession();
try {
Transaction txn = session.beginTransaction();
// your manipulations with the ORM, see below
txn.commit();
} catch (HibernateException ex) {
txn.rollback();
} finally {
session.close();
}
当session准备就绪，下面是我们从数据库表中获取所有 post:
List posts = session.createQuery("FROM Post").list();
for (Post post : (List<Post>) posts){
System.out.println("Title: " + post.getTitle());
}
我认为到这就很简单了。Hibernate是一个强大的引擎，链接数据库，执行SQL SELECT请求，然后取得数据。然后实例化 Post对象并装填数据。当我们得到对象时，它已经有了数据，比如我们上面使用 getTitle()。
当我们想进行反向操作，将一个对象存入数据库，操作相同，顺序相反。我们先实例化 Post对象，装填数据，然后让Hibernate保存它:
Post post = new Post();
post.setDate(new Date());
post.setTitle("How to cook an omelette");
session.save(post);
这就是所有的ORM如何工作。基本原则总是一样的——ORM对象就是数据的信使。我们与ORM框架交互。框架与数据库交互。对象只是帮助我们向框架发送请求并处理响应。除了get和set，没有其他方法，我们甚至不知道数据库在哪。
这就是对象-关系映射如何工作。
你或许会问哪里有问题？到处！
ORM有什么问题?
讲真的，这有什么问题？Hibernate成为最受欢迎的Java库已有10多年，几乎所有处理SQL的应用都在使用它，每个Java教程都会介绍Hibernate(或其他ORM,比如TopLink和OpenJPA)作为数据库连接应用，它已成为一个标准。我还要认为它有问题吗？当然。
我想说整个ORM的构想就是有问题的，它的发明简直是面向对象编程里NULL指针之后的第二大错误。
事实上，我并不是第一个指出这个问题的人，有众多知名作者讨论这个话题，包括Martin Fowler写的OrmHate(虽然不是反对ORM，但是也值得关注)，Jeff Atwood写的Object-Relational Mapping Is the Vietnam of Computer Science，Ted Neward写的The Vietnam of Computer Science，Laurie Voss写的ORM Is an Anti-Pattern等等。
然而，我的论点不同于上面几位，尽管他们的论点实用又有根据，比如“ORM很慢”或“数据库升级困难”，他们没抓住重点。你可以在Bozhidar Bozhanov的ORM Haters Don’t Get It这篇博客中找到很棒的论点。
重点是ORM没有在对象中封装数据库的交互，而是把固定的数据和活动的交互分隔开。一部分在对象中储存数据，另一部分由ORM引擎实现(session工厂)来与数据库交互数据。上面这张图展示了ORM做了什么。
我作为 post数据的操作者，需要处理两个组件：一是ORM，二是返回的”删减版”(指只有get和set方法)对象。面向对象编程强调的是关注单一的切入点，也就是对象。但在ORM中，我需要关注两个切入点——ORM引擎和我们甚至不能称之为对象的”东西”。
因为这严重违背了面向对象的范式，我们可以从很多德高望重的论文中找到实用的解决方案，我可以再提供更多的解决方案。
SQL不再隐藏(SQL Is Not Hidden)，ORM用户常使用SQL(或其他方言，比如HQL)。上面例子中，我们调用 session.createQuery(“FROM Post”) 来获取所有 post。即使这不是SQL，但很像SQL，所以关系模型并没有封装在对象中。反而暴露在整个应用中，每个人操作对象时无可避免的需要处理关系模型，来获取或存储数据。所以ORM并没有隐藏和包裹SQL，反而使其暴露在整个应用中。
难于测试。如果某个对象处理post的数组，它必须处理 SessionFactory的实例。我们如何mock这个依赖呢？看上面的代码，你就会意识到单元测试会有多繁琐和麻烦。相反，我们可以编写集成测试，用整个应用链接到虚构的测试PostgreSQL。这样，我们就不需要mock一个 SessionFactory，但这样的测试会很慢，更重要的是，我们虚构的和数据库无关这个对象会和数据库实例冲突。这是个可怕的设计。
我再次重申，ORM的实际问题就是这种后果，本质缺点就是ORM将对象分隔开，严重违反了对象的含义。
SQL对象(SQL-Speaking Objects)
有什么解决方案？让我给你举个例子，我们来设计一个 Post类，我们需要将它分成两个类:Post和 Posts，单个和多个。我曾在我的一篇文章中提到过，一个好的对象是现实生活中实体的抽象，我们来实践这一原则。我们有两个实体：数据库表和表格行，这就是为什么我们创建两个类:Post展示表,Post展示行。
我也曾在文章中说过，每个对象应该关联并实现一个接口，让我们先来创建两个接口，当然我们的对象是不可变的，Posts应该是这样的:
interface Posts {
Iterable<Post> iterate();
Post add(Date date, String title);
}
单一的 Post应该是这样的:
interface Post {
int id();
Date date();
String title();
}
遍历数据库中的所有的post:
Posts posts = // we'll discuss this right now
for (Post post : posts.iterate()){
System.out.println("Title: " + post.title());
}
创建一个新post:
Posts posts = // we'll discuss this right now posts.add(new Date(), "How to cook an omelette");
你可以看到，我们有真实对象了，他们掌握所有操作，并且在内部隐藏实现细节，没有事务，会话或工厂，我们甚至不知道这些对象是否真的和PostgreSQL交互，或许它只是把数据保存在txt文件中。Posts带给我们的是获取post列表和创建新post的能力，具体实现很好地隐藏在其中，现在让我们看一看如何实现这两个类。
我将使用jcabi-jdbc作为JDBC包裹，当然你也可以使用其他你喜欢的JDBC，这无所谓，重点是与数据库的交互要隐藏在对象中，让我们开始实现 PgPosts类(“pg”表示PostgreSQL)。
final class PgPosts implements Posts {
private final Source dbase;
public PgPosts(DataSource data) {
this.dbase = data;
}
public Iterable<Post> iterate() {
return new JdbcSession(this.dbase)
.sql("SELECT id FROM post")
.select(
new ListOutcome<Post>(
new ListOutcome.Mapping<Post>() {
@Override
public Post map(final ResultSet rset) {
return new PgPost(
this.dbase,
rset.getInteger(1)
);
}
}
)
);
}
public Post add(Date date, String title) {
return new PgPost(
this.dbase,
new JdbcSession(this.dbase)
.sql("INSERT INTO post (date, title) VALUES (?, ?)")
.set(new Utc(date))
.set(title)
.insert(new SingleOutcome<Integer>(Integer.class))
);
}
}
然后我们创建 PgPost类来实现 Post接口:
final class PgPost implements Post {
private final Source dbase;
private final int number;
public PgPost(DataSource data, int id) {
this.dbase = data;
this.number = id;
}
public int id() {
return this.number;
}
public Date date() {
return new JdbcSession(this.dbase)
.sql("SELECT date FROM post WHERE id = ?")
.set(this.number)
.select(new SingleOutcome<Utc>(Utc.class));
}
public String title() {
return new JdbcSession(this.dbase)
.sql("SELECT title FROM post WHERE id = ?")
.set(this.number)
.select(new SingleOutcome<String>(String.class));
}
}
下面就是我们用刚刚创建的类来和数据库交互:
Posts posts = new PgPosts(dbase);
for (Post post : posts.iterate()){
System.out.println("Title: " + post.title());
}
Post post = posts.add(new Date(), "How to cook an omelette");
System.out.println("Just added post #" + post.id());
你可以在这看到完整例子.这是一个开源的web app使用PostgreSQL来实现上面提到的-SQL-speaking objects.
性能如何?
我能听到你的惊呼“性能怎么样?”在上面几行代码中，我们创建了和数据库的冗余链接。首先我们用 SELECT id来检索post的ID，然后为了获取它们的title，我们对应每个post发送 SELECT title请求，这确实效率很低。
不要担心，这是面向对象编程，意味着这是可伸缩的！我们来创建一个 PgPost的装饰器，其构造函数接受数据，并在内部缓存:
final class ConstPost implements Post {
private final Post origin;
private final Date dte;
private final String ttl;
public ConstPost(Post post, Date date, String title) {
this.origin = post;
this.dte = date;
this.ttl = title;
}
public int id() {
return this.origin.id();
}
public Date date() {
return this.dte;
}
public String title() {
return this.ttl;
}
}
注意：这个装饰器并不知道PostgreSQL或JDBC，它仅仅是 POST对象的装饰，并缓存数据和title。通常，这个装饰器是不可变的。
现在我们来创建 Posts的另一个实现，其返回一个”不可变”的对象:
final class ConstPgPosts implements Posts {
// ...
public Iterable<Post> iterate() {
return new JdbcSession(this.dbase)
.sql("SELECT * FROM post")
.select(
new ListOutcome<Post>(
new ListOutcome.Mapping<Post>() {
@Override
public Post map(final ResultSet rset) {
return new ConstPost(
new PgPost(
ConstPgPosts.this.dbase,
rset.getInteger(1)
),
Utc.getTimestamp(rset, 2),
rset.getString(3)
);
}
}
)
);
}
}
现在所有post通过这个 iterate()方法返回，并且从数据库中取到了数据装配在新的类中。
使用装饰器和对相同接口的众多实现，你可以组合任意的功能，最重要的是扩展功能的同时，不要增加设计的复杂度，因为类的大小不会增长，我们使用新的高聚合的类，它们更小巧。
事务又如何?
每个对象应该在其单独的事务中执行，并且将 SELECT和 INSERT封装在一起，这需要内置事务，数据库提供非常棒的支持。如果没有这样的支持，创建一个会话事务对象必须接受一个”callable”类，比如:
final class Txn {
private final DataSource dbase;
public <T> T call(Callable<T> callable) {
JdbcSession session = new JdbcSession(this.dbase);
try {
session.sql("START TRANSACTION").exec();
T result = callable.call();
session.sql("COMMIT").exec();
return result;
} catch (Exception ex) {
session.sql("ROLLBACK").exec();
throw ex;
}
}
}
然后，当你想在一个事务中进行一系列的操作，像下面这样:
new Txn(dbase).call(
new Callable<Integer>() {
@Override
public Integer call() {
Posts posts = new PgPosts(dbase);
Post post = posts.add(new Date(), "How to cook an omelette");
posts.comments().post("This is my first comment!");
return post.id();
}
}
);
这段代码会创建一个新的post并提交一个comment.如果任何调用失败，整个事务将回滚。
对于我来说，这就是面向对象，我称它为”SQL-speaking objects”，因为它们知道如何与数据库服务器通过SQL交互，这是它们的能力，完美封装在其内部。