成倍提升ORM系统SQL性能的一个方法
ORM确实事很方便让人不需要大量的写SQL，但是很多人诟病造成SQL性能不好
举个例子，一个功能是修改get用户数据的金币清零然后update
非常简单的一个业务：
User user=dao.getUser(uid); user.setGold(0); dao.updateUser(user);
就这样一个简单的功能，实际会向数据库发送一长串的SQL update语句
如：update user set a=?,b=?,c=?............gold=? where uid = ?
看到这里有人会明白问题出在哪里了，想想一下每个表都有一堆字段， 而实际上我们在各个业务里面只会修改一两个字段，导致每次调用业务都会生产这样一长串的SQL，给数据库来带巨大而且没有必要的压力。
有的人会说：我编程习惯很好，平时都会把调用频率高的方法单独写sql。例如上面修改金币会单独写一个updateGold方法。当然，这是一种很好的习惯并且也能解决这个问题。但是 大部分开发者、大部分业务实现并不会这样做。不是吗?
现在可以通过另外一种方法来实现对原有的ORM系统优化兼顾开发效率和系统性能提升：
/** update之前先比较，只update修改过的列 */ public <T> void compareAndUpdate(T oldT, T newT);
简单的介绍一下就是，通过对比新旧实体，根据修改过的列来生成指定的列到达针对性更新的目的。
//以前： User user=dao.getUser(uid); user.setGold(0); dao.updateUser(user); //产生的sql： update user set a=?,b=?,c=?............gold=? where uid = ? //新的做法： User user=dao.getUser(uid); User oldUser=BeanUtils.cloneBean(user); user.setGold(0); dao.compareAndUpdate(oldUser,user); //产生的sql: update user set gold = ? where uid = ? sql语句的缩短成倍的降低了与数据库通讯的开销，并且大大的降低了数据库压力。 如果上面的写法可能会稍微麻烦点，我们可以再偷点懒： User user=dao.getUser(uid); Object oldBean=BeanUtils.copyBean(user);//这样的区别是copy这段代码即可，不需要经常修改oldBean的类型。因为我们不关心oldBean是什么类型。 user.setGold(0); dao.compareAndUpdate(oldBean,user);
有人会说实体copy和拼接sql也会产生开销，这个是不错。但是这种开销对于数据库的压力来说根本就是九牛一毛不值一提。
compareAndUpdate这个方法是我自己写的ORM框架：freyja-jdbc 里面改写update方法产生的。如果是使用的其他ORM框架 有预留接口的话可以改写下即可。没有接口的话可能需要自己去实现了，方法就是映射实体和字段 生成sql语句
hibernate 好久没碰了，怎么改写hibernate也能达到一样的效果不清楚，有兴趣的可以自己研究下。
最后还是放下相关代码吧
public static Parameter compareAndUpdate(Object oldEntity, Object newEntity) {
FreyjaEntity entity = ShardingUtil.getEntity(newEntity.getClass());
List<Object> args = new ArrayList<Object>();
Object idValue = null;
BeanMap oldBeanMap = BeanMap.create(oldEntity);
BeanMap beanMap = BeanMap.create(newEntity);
List<String> columnNameList = new ArrayList<String>();
for (Property p : entity.getProperties().values()) {
ShardingProperty s = (ShardingProperty) p;
Object newPropertyValue = beanMap.get(p.getName());
if (s.isId()) {
idValue = newPropertyValue;
continue;
} else {
Object oldPropertyValue = oldBeanMap.get(p.getName());
if ((newPropertyValue == null && oldBeanMap == null)
|| newPropertyValue.equals(oldPropertyValue)) {// 值未改变过，不更新
continue;
}
}
columnNameList.add(p.getName());
args.add(newPropertyValue);
}
args.add(idValue);
Parameter parameter = null;
if (entity.isSubTable()) {
DbResult result = ShardingUtil.engine.getShardingStrategy()
.getShardingTableNameById(entity.getTableName(), idValue);
parameter = entity.updateByColumn(columnNameList, idValue);
parameter.setDbNo(result.getDbNo());
} else {
parameter = entity.updateByColumn(columnNameList, null);
}
parameter.setArgs(args.toArray());
return parameter;
}
/** 根据指定列生产相关信息 */
public Parameter updateByColumn(List<String> columnNameList, Object idValue) {
String set = "";
List<Integer> types = new ArrayList<Integer>();
for (String cn : columnNameList) {
ShardingProperty s = (ShardingProperty) getProperties().get(cn);
set += s.getDbColumnName() + " = ? ,";
types.add(s.getTypes());
}
set = set.substring(0, set.length() - 1);
String setSql = " set " + set + " where " + getId().getDbColumnName()
+ " = ?";
types.add(getId().getTypes());
String sql = null;
if (idValue == null) {
sql = "update " + getTableName() + setSql;
} else {// 分库
DbResult result = ShardingUtil.engine.getShardingStrategy()
.getShardingTableNameById(getTableName(), idValue);
sql = "update " + result.getTableName() + setSql;
}
Parameter p = new Parameter();
p.setSql(sql);
p.setSqlTypes(ListUtil.toPrimitive(types));
return p;
}----------------------------------------------------------------------------
实际操作了下后发现虽然确实是不错，但是对现有系统和写法有出入。有没有兼容现有系统的写法更智能一些的办法呢。
然后想到了另外一种做法：
public class PersistObj implements Serializable {
/** 用于更新compareAndUpdate，并且改属性不会被序列化 */
private transient Object oldBean;
get();set();
}
//然后让你的实体继承这个对象，这样默认都会有了一个oldBean属性来存放oldBean
//再写个通用方法
@Override
public <T> T getAndClone(Class<T> clazz, Object id) {
T t = super.get(clazz, id);
if (t instanceof PersistObj) {
PersistObj obj = (PersistObj) t;
Object oldBean = BeanUtils.cloneBean(t);
obj.setOldBean(oldBean);
}
return t;
}
//这样查询的时候就把oldBean存储了。
//之前的update 方法改写下：
if (oldT == null) {
if (newT instanceof PersistObj) {
PersistObj obj = (PersistObj) newT;
oldT = (T) obj.getOldBean();
}
}
让oldBean从 oldBean属性里面去取。不需要再传递了这样做后的效果是：
User user = userDao.getAndClone(uid); user.setGold(0); userDao.compareAndUpdate(user); //这里这样写是为了让大家明白如何工作的。 //实际上这些方法是可以替换底层封装的，业务代码不需要修改。 //也就是说可以达到这种写法效果： User user = userDao.getUser(uid); user.setGold(0); userDao.updateUser(user); //是不是和最初一样了，在不影响现有代码的基础上提升性能
这样做后对原有的业务不需要再修改， 因为这些dao方法都是底层的。替换的就可以了。service业务方法不需要变动。
当然，这样写有2个缺点：
1、无法对缓存有效。
2、每次查询都会克隆一遍。
针对第一个问题：当有用到缓存的地方，只能用之前的方法，手动的cloneBean。
针对第二个问题：首先对于不需要这种功能的实体不用getAndClone方法就没有任何影响
对于其他的一般我们查询肯定是为了修改的。大部分逻辑都是这样。所以默认情况影响不大，如果明确不涉及到修改，不使用getAndClone方法就可以了使用其他默认的get()方法就可以了。也没有太大影响，只是编写的时候多了一种选择