工作单元模式（java）

个人理解：工作单元模式是为了解决事务性问题，即保证数据修改提交的一致性。

晚上在看到工作单元模式时，觉得比较有意思，看到的基本都是c#实现的，本着学习的态度，使用java语言实现，实现出来才发现有点蹩脚，权当记录，有时间再完善。

 

package com.xiaolu.unitofwork;

import com.xiaolu.domain.AggrateRoot;
import com.xiaolu.repository.UnitOfWorkRepository;

/**
 * @author : xiaolu 2018年2月5日
 * @todo : 工作单元接口
 */
public interface UnitOfWork {
    public void registerAdd(AggrateRoot root, UnitOfWorkRepository repository);

    public void registerModify(AggrateRoot root, UnitOfWorkRepository repository);

    public void registerDelete(AggrateRoot root, UnitOfWorkRepository repository);

    public void commit();
}

 

package com.xiaolu.unitofworkimpl;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;

import com.xiaolu.datasource.DataSource;
import com.xiaolu.domain.AggrateRoot;
import com.xiaolu.repository.UnitOfWorkRepository;
import com.xiaolu.unitofwork.UnitOfWork;

public class UnitOfWorkImpl implements UnitOfWork {
    private Map<AggrateRoot, UnitOfWorkRepository> addMaps = new HashMap<AggrateRoot, UnitOfWorkRepository>();
    private Map<AggrateRoot, UnitOfWorkRepository> deleteMaps = new HashMap<AggrateRoot, UnitOfWorkRepository>();
    private Map<AggrateRoot, UnitOfWorkRepository> modifyMaps = new HashMap<AggrateRoot, UnitOfWorkRepository>();

    @Override
    public void registerAdd(AggrateRoot root, UnitOfWorkRepository repository) {
        if (!addMaps.containsKey(root)) {
            this.addMaps.put(root, repository);
        }
    }

    @Override
    public void registerModify(AggrateRoot root, UnitOfWorkRepository repository) {
        if (!modifyMaps.containsKey(root)) {
            this.modifyMaps.put(root, repository);
        }
    }

    @Override
    public void registerDelete(AggrateRoot root, UnitOfWorkRepository repository) {
        if (!deleteMaps.containsKey(root)) {
            this.deleteMaps.put(root, repository);
        }
    }

    @Override
    public void commit() {
        // 在这里稍微卡顿了，c#中可以方便的使用TransactionScope事务域，但是java中没有这个概念
        // 而事务性是建立在数据库链接的基础上，如果这里的添加，删除，修改使用的不是同一个数据库链接
        // 那么就无法保证其事务性

        Connection conn = DataSource.getConnection();
        try {
            conn.setAutoCommit(false);
            doCommit(conn);
            conn.commit();
        } catch (SQLException e) {
            try {
                conn.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
        } finally {
            // 这里不太舒服，更好的方式是实现java.sql.Connection接口,对原始Connection做一个封装（间接层）
            DataSource.close();
        }
    }

    private void doCommit(Connection conn) {
        for (AggrateRoot root : addMaps.keySet()) {
            addMaps.get(root).doPut(conn, root);
        }

        for (AggrateRoot root : modifyMaps.keySet()) {
            modifyMaps.get(root).doModify(conn, root);
        }

        for (AggrateRoot root : deleteMaps.keySet()) {
            deleteMaps.get(root).doRemove(conn, root);
        }
    }
}

package com.xiaolu.domain;
/**
 * @author : xiaolu 2018年2月5日
 * @todo   : 语义标记接口
 */
public interface AggrateRoot {
}

package com.xiaolu.repository;

import java.sql.Connection;

import com.xiaolu.domain.AggrateRoot;
import com.xiaolu.unitofwork.UnitOfWork;
import com.xiaolu.unitofworkimpl.UnitOfWorkImpl;

public abstract class UnitOfWorkRepository {

    private UnitOfWork work = new UnitOfWorkImpl();

    public void put(AggrateRoot root) {
        work.registerAdd(root, this);
    }

    public void modify(AggrateRoot root) {
        work.registerModify(root, this);
    }

    public void remove(AggrateRoot root) {
        work.registerDelete(root, this);
    }

    // 实现中不能关闭连接---
    public abstract void doPut(Connection conn, AggrateRoot root);

    // 实现中不能关闭连接---
    public abstract void doModify(Connection conn, AggrateRoot root);

    // 实现中不能关闭连接---
    public abstract void doRemove(Connection conn, AggrateRoot root);
}

package com.xiaolu.domain;

public class Account implements AggrateRoot {
    private int id;
    // 仅作示例
    private int money;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public void add(int money) {
        if (money > 0) {
            this.money += money;
        }
    }

    public void minus(int money) {
        if (this.money >= money) {
            this.money -= money;
        }
    }

}

package com.xiaolu.datasource;

import java.sql.Connection;
import java.sql.SQLException;

public class DataSource {
    private static Connection conn = null;

    private DataSource() {
    }

    // 不考虑多线程的情况
    public static Connection getConnection() {
        if (conn == null) {
            // 创建链接---或者从连接池拿
        }

        return conn;
    }

    public static void close() {
        try {
            if (conn != null) {
                conn.close();// 关闭或放回连接池中
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            conn = null;
        }
    }
}

package com.xiaolu.service;

import com.xiaolu.domain.Account;
import com.xiaolu.repository.UnitOfWorkRepository;
import com.xiaolu.unitofwork.UnitOfWork;

public class TranslateAccountService {
    private UnitOfWork work;
    private UnitOfWorkRepository repository;

    public TranslateAccountService(UnitOfWork work, UnitOfWorkRepository repository) {
        this.work = work;
        this.repository = repository;
    }

    public void translate(Account from, Account to, int money) {
        // 省略验证

        from.minus(money);
        to.add(money);

        repository.modify(from);
        repository.modify(to);

        work.commit();
    }
}

这里实现主要的点在于维系一个同一个数据库连接。