说明：这篇文章不探讨Latke框架的IOC/DI部分，Latke框架中的IOC/DI功能跟Spring是很相似的，用起来会觉得很好上手，在这里只是说明为什么Latke可以将一个JSON用类似ORM的功能存储到关系型数据库。
add源码追溯
以solo新增一篇博客的后台全过程为例
- 博客新增入口
@RequestProcessing(value = "/console/article/", method = HTTPRequestMethod.POST)
public void addArticle(final HttpServletRequest request, final HttpServletResponse response, final HTTPRequestContext context,
final JSONObject requestJSONObject) throws Exception {
//省略代码
final String articleId = articleMgmtService.addArticle(requestJSONObject);
//省略代码
}- 上面接口调用的下一层方法
public String addArticleInternal(final JSONObject article) throws ServiceException {
//省略代码，将前台传过来的json封装成最终新增所需要的JSON数据，调用新增方法
articleRepository.add(article);
//省略代码
}articleRepository是通过Latke框架的注解@Inject注入进来的，在它的实现类ArticleRepositoryImpl中没有add(JSONObject jsonObject)类型的方法，那么它调的肯定是其父类的add(JSONObject jsonObject)方法
- 看看ArticleRepository的实现类ArticleRepositoryImpl的结构
public class ArticleRepositoryImpl extends AbstractRepository implements ArticleRepository {
public ArticleRepositoryImpl() {
super(Article.ARTICLE);
}
}- 这个无参的构造方法，发现它没干什么事，只是调用了父类的无参构造方法，注意Article.ARTICLE后面会用到
public AbstractRepository(final String name) {
try {
Class<Repository> repositoryClass;
final Latkes.RuntimeDatabase runtimeDatabase = Latkes.getRuntimeDatabase();
switch (runtimeDatabase) {
case MYSQL:
case H2:
case MSSQL:
case ORACLE:
repositoryClass = (Class<Repository>) Class.forName("org.b3log.latke.repository.jdbc.JdbcRepository");
break;
case NONE:
repositoryClass = (Class<Repository>) Class.forName("org.b3log.latke.repository.NoneRepository");
break;
default:
throw new RuntimeException("The runtime database [" + runtimeDatabase + "] is not support NOW!");
}
final Constructor<Repository> constructor = repositoryClass.getConstructor(String.class);
repository = constructor.newInstance(name);
} catch (final Exception e) {
throw new RuntimeException("Can not initialize repository!", e);
}
Repositories.addRepository(repository);
LOGGER.log(Level.INFO, "Constructed repository [name={0}]", name);
}Latkes.getRuntimeDatabase()是从配置文件local.properties中获取变量名为runtimeDatabase（运行数据库类型）的值，从代码中可以看到，支持三种数据库：MYSQL、H2、ORACLE，根据runtimeDatabase的值通过反射实例化一个JdbcRepository对象，这个对象就是比较底层的一个持久方法了。
- 接着再看看ArticleRepositoryImpl的父类AbstractRepository中的add(JSONObject jsonObject)方法
@Override
public String add(final JSONObject jsonObject) throws RepositoryException {
if (!isWritable() && !isInternalCall()) {
throw new RepositoryException("The repository [name=" + getName() + "] is not writable at present");
}
Repositories.check(getName(), jsonObject, Keys.OBJECT_ID);
return repository.add(jsonObject);
}前面说了repository对象是根据runtimeDatabase的值通过反射实例化一个JdbcRepository对象，那么调用的就是JdbcRepository类中的add方法
@Override
public String add(final JSONObject jsonObject) throws RepositoryException {
final JdbcTransaction currentTransaction = TX.get();
if (null == currentTransaction) {
throw new RepositoryException("Invoking add() outside a transaction");
}
final Connection connection = getConnection();
final List<Object> paramList = new ArrayList<>();
final StringBuilder sql = new StringBuilder();
String ret;
try {
if (Latkes.RuntimeDatabase.ORACLE == Latkes.getRuntimeDatabase()) {
toOracleClobEmpty(jsonObject);
}
ret = buildAddSql(jsonObject, paramList, sql);
JdbcUtil.executeSql(sql.toString(), paramList, connection, false);
JdbcUtil.fromOracleClobEmpty(jsonObject);
} catch (final Exception e) {
LOGGER.log(Level.ERROR, "Add failed", e);
throw new RepositoryException(e);
}
return ret;
}从方法的命名应该可以很轻易的判断出是什么意思了，就是第一步构造SQL语句，第二步执行SQL语句
private String buildAddSql(final JSONObject jsonObject, final List<Object> paramlist, final StringBuilder sql) throws Exception {
String ret = null;
if (!jsonObject.has(Keys.OBJECT_ID)) {
if (!(KEY_GEN instanceof DBKeyGenerator)) {
ret = (String) KEY_GEN.gen();
jsonObject.put(Keys.OBJECT_ID, ret);
}
} else {
ret = jsonObject.getString(Keys.OBJECT_ID);
}
setProperties(jsonObject, paramlist, sql);
return ret;
}判断传进来的JSON中设置的默认主键是否为空，如果为空就设置一个，如果不为空就取出来用来返回，solo项目中的主键名称都是oId,值是时间戳，
调用setProperties(jsonObject, paramlist, sql);方法。
private void setProperties(final JSONObject jsonObject, final List<Object> paramlist, final StringBuilder sql) throws Exception {
final Iterator<String> keys = jsonObject.keys();
final StringBuilder insertString = new StringBuilder();
final StringBuilder wildcardString = new StringBuilder();
boolean isFirst = true;
String key;
Object value;
while (keys.hasNext()) {
key = keys.next();
if (isFirst) {
insertString.append("(").append(key);
wildcardString.append("(?");
isFirst = false;
} else {
insertString.append(",").append(key);
wildcardString.append(",?");
}
value = jsonObject.get(key);
paramlist.add(value);
if (!keys.hasNext()) {
insertString.append(")");
wildcardString.append(")");
}
}
sql.append("insert into ").append(getName()).append(insertString).append(" values ").append(wildcardString);
}这段代码的意思就是在根据传进来的JSON拼接SQL语句，最后一句中有一个getName()语句，其实拼接在这里就是对应数据库的表名称，什么时候传进来的，其实是在上面的ArticleRepositoryImpl类中调用父类的无参构造方法时传进来的，在父类中通过反射实例化JdbcRepository对象需要传入name属性，在类JdbcRepository中会经常用到，可以说只要跟数据库相关的操作可能都要用到表名称。
拼接好SQL语句后，就是执行SQL了，至此一个新增操作的全部就解读完毕了。
总结
通过看源码，就不难明白，为什么他说不需要像Hibernate、MyBatis那类ORM框架非得从JSON转到实体类对象，再跟关系型数据库对应了，为什么能前端拼接的JSON能直接调用add方法就能保存到数据库了。
