在我们的项目中,经常会有一些数据会涉及到频繁更改。如果每次都从数据库中读取再修改,这样不仅浪费时间,而且还更加危险。那此时我们究竟该如何解决这个问题呢?此时,DDL(脏数据层)就出现了。
首先说一下为什么操作不能保证原子性就会危险,因为这时就很有可能出现同时修改的情况,最终的结果极有可能并不是你所希望的(除非这些操作都是幂等性,但这种情况应该比较少)。如果是利用数据库中的锁,一来我在项目中用的比较少,二来也增加了维护难度。当然,有人说可以利用CAS,那针对一些复杂的情况(比如类里面属性的修改会有一些相关性,你的一次更改需要涉及几个属性等),可能你还是需要单独设计一套系统,而且还会有经典的ABA问题。如果你是利用CAS解决的,希望能够在下方评论区告知,就当互相学习。
那现在来说说DDL层具体是什么。**DDL全称是Dirty Data Layer,即脏数据层。**针对那些在系统运行经常会更改的domain类,我们将其再做一次封装,组成一个类似map的形式。单独由一组线程来管理这些map,每当有数据改动时,我们就往这个map中添加内容,而我们的线程则定期向数据库中写入内容。这样做的好处,首先是让你的每一次操作都没有IO的参与,提高了相应速度,而且定时提交意味着你可以把原本的几次提交变成为1次,减少了和数据库的交互。当然,缺点也是存在的,如果你的系统是分布式,那么你的这个DDL层的实现可能就没有那么方便,因为这些数据你可能需要存储在类似Redis这种共享缓存中,因此每次的拿和取就需要封装一下(这个应该算是小问题,因为原本就算你用的是本地缓存,所有操作依旧是需要封装的,只不过你的IO消耗由原本的数据库变成了共享缓存)。接下来,我就针对本地缓存的情况来具体实现一个DDL。
定义操作
这是我定义出的一些操作:
public interface IDirtyEntity {
//region manage content
/**
* 获取entity的内容。
*/
Object getContent();
/**
* 获取entity的内容。 获取的内容是复制的对象,属性值是调用该方法时的属性值。
*/
Object copyContent();
//endregion
//region persisting flag
/**
* 是否正在进行持久化
*/
boolean isPersisting();
/**
* 设置正在持久化标志
*/
void setPersistingFlag();
/**
* 清除正在持久化标志
*/
void clearPersistingFlag();
//endregion
//region persist state
/**
* 设置为脏数据状态
*/
void setDirtyState();
/**
* 清除脏数据状态
*/
void clearDirtyState();
/**
* 当前持久化状态。
*
* @see PersistState
*/
PersistState currentPersistState();
//endregion
//region get/set field
/**
* 获取属性值。
*/
Object getField(String fieldName);
/**
* 设置属性值。
*/
void setField(String fieldName, Object value);
/**
* 设置多个属性的值。
*/
void setFields(List<EntityField> fields);
/**
* 增加int类型属性的值。
*/
void addInt(String fieldName, int delta);
/**
* 增加long类型属性的值。
*/
void addLong(String fieldName, long delta);
//endregion
//region manage dirty field
/**
* 标记脏数据字段
*/
void addDirtyField(String fieldName);
/**
* 获取修改过的属性。
*/
List<EntityField> getAndClearDirtyFields();
//endregion
//region wrapper implement
/**
* 返回id的属性名。
*/
String getIdFieldName();
/**
* 返回id
*/
String getId();
/**
* 返回DATA的class
*/
Class getDataClass();
//endregion
}
分类
DDL解决的是数据频繁更改的问题,其实这里的更改说的并不准确,并不仅仅只是update,还有insert。用过mongodb的应该清楚有一种叫upsert的操作,就是找到就修改,找不到就添加。我们这里就需要将我们的数据分成两类:Detachable(可拆分的)、Nondetachable(不可拆分的)。
可拆分的,就意味着你针对这个数据的修改最小可以精确到其中的一个属性,项目中大多数都属于这种情况。
不可拆分的,即每次都是以一个整体添加,比如一次交易,每次添加都是一个整体,不可能说你先提交买方,再提交卖方,后面还会修改买方。这种类型大多都是一条记录,整体存入数据库。
因此,我们来定义一下这两种结构:
可拆分的类型:
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cglib.beans.BeanCopier;
import org.springframework.cglib.beans.BeanMap;
public abstract class DetachableDirtyEntityAdapter implements IDirtyEntity {
private static final Logger log = LoggerFactory.getLogger(DetachableDirtyEntityAdapter.class);
/**
* 数据属性的map引用
*/
private BeanMap beanMap;
private final BeanCopier beanCopier;
public DetachableDirtyEntityAdapter(Object content, BeanCopier beanCopier) {
Preconditions.checkNotNull(content);
Preconditions.checkNotNull(beanCopier);
this.content = newEmptyContentInstance();
this.beanCopier = beanCopier;
this.beanCopier.copy(content, this.content, null);
this.beanMap = BeanMap.create(this.content);
}
//region manage content
/**
* 数据的内容。
*/
private Object content;
@Override
public Object getContent() {
return content;
}
private Object newEmptyContentInstance() {
Class cls = getDataClass();
try {
return cls.newInstance();
} catch (Exception e) {
log.error("initiate {} failed: {}", cls.getSimpleName(), e.getMessage());
return null;
}
}
@Override
public synchronized Object copyContent() {
Object copy = newEmptyContentInstance();
beanCopier.copy(this.content, copy, null);
return copy;
}
//endregion
//region persisting flag
private volatile boolean persisting = false;
@Override
public boolean isPersisting() {
return persisting;
}
@Override
public void setPersistingFlag() {
this.persisting = true;
}
@Override
public void clearPersistingFlag() {
this.persisting = false;
}
//endregion
//region persist state
@Override
public void setDirtyState() {
throw new UnsupportedOperationException();
}
@Override
public void clearDirtyState() {
throw new UnsupportedOperationException();
}
@Override
public synchronized PersistState currentPersistState() {
int dirtySize = dirtyFieldNames.size();
if (dirtySize == 0) {
return PersistState.PERSISTED;
} else {
return PersistState.DIRTY;
}
}
//endregion
//region get/set field
@Override
public synchronized Object getField(String fieldName) {
Preconditions.checkArgument(!Strings.isNullOrEmpty(fieldName));
return beanMap.get(fieldName);
}
@Override
public synchronized void setField(String fieldName, Object value) {
Preconditions.checkArgument(!Strings.isNullOrEmpty(fieldName));
beanMap.put(fieldName, value);
dirtyFieldNames.add(fieldName);
}
@Override
public synchronized void setFields(List<EntityField> fields) {
Preconditions.checkNotNull(fields);
for (EntityField f : fields) {
beanMap.put(f.getName(), f.getValue());
dirtyFieldNames.add(f.getName());
}
}
@Override
public synchronized void addInt(String fieldName, int delta) {
Preconditions.checkArgument(!Strings.isNullOrEmpty(fieldName));
int origin = (int) beanMap.get(fieldName);
beanMap.put(fieldName, origin + delta);
dirtyFieldNames.add(fieldName);
}
@Override
public synchronized void addLong(String fieldName, long delta) {
Preconditions.checkArgument(!Strings.isNullOrEmpty(fieldName));
long origin = (long) beanMap.get(fieldName);
beanMap.put(fieldName, origin + delta);
dirtyFieldNames.add(fieldName);
}
//endregion
//region manage dirty fields
/**
* 当前entity的包含脏数据的属性名列表。
*/
private final HashSet<String> dirtyFieldNames = new HashSet<>(16);
@Override
public void addDirtyField(String fieldName) {
Preconditions.checkArgument(!Strings.isNullOrEmpty(fieldName));
dirtyFieldNames.add(fieldName);
}
@Override
public synchronized List<EntityField> getAndClearDirtyFields() {
ArrayList<EntityField> list = new ArrayList<>();
for (String f : dirtyFieldNames) {
list.add(new EntityField(f, beanMap.get(f)));
}
// 清空dirtyFieldNames, 记录上一次持久化的事件
dirtyFieldNames.clear();
return list;
}
//endregion
}
不可拆分的类型:
import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cglib.beans.BeanCopier;
import org.springframework.cglib.beans.BeanMap;
public abstract class NonDetachableDirtyEntityAdapter implements IDirtyEntity {
private static final Logger log = LoggerFactory.getLogger(NonDetachableDirtyEntityAdapter.class);
/**
* 数据属性的map引用
*/
private BeanMap beanMap;
private final BeanCopier beanCopier;
public NonDetachableDirtyEntityAdapter(Object content, BeanCopier beanCopier) {
Preconditions.checkNotNull(content);
Preconditions.checkNotNull(beanCopier);
this.content = newEmptyContentInstance();
this.beanCopier = beanCopier;
this.beanCopier.copy(content, this.content, null);
this.beanMap = BeanMap.create(this.content);
}
//region manage content
/**
* 数据的内容。
*/
private Object content;
@Override
public Object getContent() {
return content;
}
private Object newEmptyContentInstance() {
Class cls = getDataClass();
try {
return cls.newInstance();
} catch (Exception e) {
log.error("initiate {} failed: {}", cls.getSimpleName(), e.getMessage());
return null;
}
}
@Override
public synchronized Object copyContent() {
Object copy = newEmptyContentInstance();
beanCopier.copy(this.content, copy, null);
return copy;
}
//endregion
//region persisting flag
private volatile boolean persisting = false;
@Override
public boolean isPersisting() {
return persisting;
}
@Override
public void setPersistingFlag() {
this.persisting = true;
}
@Override
public void clearPersistingFlag() {
this.persisting = false;
}
//endregion
//region persist state
private volatile PersistState persistState = PersistState.DIRTY;
@Override
public void setDirtyState() {
persistState = PersistState.DIRTY;
}
@Override
public void clearDirtyState() {
persistState = PersistState.PERSISTED;
}
@Override
public PersistState currentPersistState() {
return persistState;
}
//endregion
//region get/set field
@Override
public synchronized Object getField(String fieldName) {
Preconditions.checkArgument(!Strings.isNullOrEmpty(fieldName));
return beanMap.get(fieldName);
}
@Override
public synchronized void setField(String fieldName, Object value) {
Preconditions.checkArgument(!Strings.isNullOrEmpty(fieldName));
beanMap.put(fieldName, value);
}
@Override
public synchronized void setFields(List<EntityField> fields) {
Preconditions.checkNotNull(fields);
for (EntityField f : fields) {
beanMap.put(f.getName(), f.getValue());
}
}
@Override
public synchronized void addInt(String fieldName, int delta) {
Preconditions.checkArgument(!Strings.isNullOrEmpty(fieldName));
int origin = (int) beanMap.get(fieldName);
beanMap.put(fieldName, origin + delta);
}
@Override
public synchronized void addLong(String fieldName, long delta) {
Preconditions.checkArgument(!Strings.isNullOrEmpty(fieldName));
long origin = (long) beanMap.get(fieldName);
beanMap.put(fieldName, origin + delta);
}
//endregion
//region manage dirty fields
@Override
public void addDirtyField(String fieldName) {
throw new UnsupportedOperationException();
}
@Override
public synchronized List<EntityField> getAndClearDirtyFields() {
throw new UnsupportedOperationException();
}
//endregion
}
两种类型最大的不同在于真正往数据库中存储时,前者是可以单独字段存储,后者是整体存储,因此最后和DirtyField相关的操作便需要注意,NondetachableDirtyEntityAdapter不需要记录DirtyFields。
针对原本类中属性的复制和存储,我这儿用的是spring提供的BeanCopier,如果你有什么更高效的工具,欢迎在下方留言。(我一直在找一种深度克隆高效的组件,试过kryo,但如果实现序列化接口,其效率和正常的set/get大概相差10倍,如果有好的组件,希望一并告知)。
以上就是DDL的准备工作,其实后面的工作就是将具体的类做一个封装,再封装针对该类的所有操作,然后另写一个线程组执行往数据库的写入操作。这个工作其实针对各个项目都有其特殊的地方,博主在这儿就不具体展示了。
有兴趣的话可以看看我的私人博客,也可以关注我的公众号,说不定会有意外的惊喜。