欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

成倍提升ORM系统SQL性能的一个方法 ORMSQLhibernatefreyja-jdbc

程序员文章站 2022-01-22 10:03:49
...

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