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
//再写个通用方法@Overridepublic <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()方法就可以了。也没有太大影响，只是编写的时候多了一种选择