Question

我正在编写一些代码，这些代码将用于网站，我对我的＆＃34;架构＆＃34;有一些疑问。

域我有一个数据库，并且在最低级别我有** Domain * *包，其中包含代表数据库表的类。我使用Hibernate和lazy fetch来建立关系。
访问此程序包包含在域上执行数据库操作的所有类。我想这相当于DAO。我使用主键获取条目，返回表中的所有条目，对其执行查询。一切都以域类或其集合的形式返回。
服务此软件包具有更复杂逻辑的类（同样与每个域类相关）。它使用 Access 包来获取域对象，并将它们转换为 model 对象，其中 model 就是我所谓的类代表一个等效的域类，但没有像它们那样具有关系的成员，如* ToMany，它们可能具有无法序列化的hibernate代理，并且使对象“更重”＆＃34;。在将来，我可能会编写自定义方法/转换，将域对象的集合转换为描述性的呈现方式，但现在我忽略了它们。
模型此软件包与域具有完全相同的类数，就像我提到的那样是域对象的表示形式我可以用于演示，传输等的东西（这类似于其他层次结构而不是订单的一部分。）
Servlet 此软件包包含网站的所有Servlet，每个servlet包含网站想要执行的操作的代码。它使用服务类来获取它想要操作的数据。 service 类将获取相关的域对象，并将它们转换为 model 对象，这些对象将返回到 servlet 将执行网站请求所需操作，然后以JSON格式返回网站的类。

显然，我想对这种方法和我的以下想法提出一些反馈。

1）我认为服务类应该只有将域对象转换为模型对象的代码。我正在考虑使用Dozer，只需添加一些Dozer无法做到的更复杂的代码（基本上是将来的位）。从我看到的，因为我的模型类基本上是域类，没有繁重的东西，而且成员具有相同的名称，我甚至不需要注释或xml。 / p>

2）在 Access 中，我使用所有域类的基类作为参数，所以我可以有一个抽象类，并在那里实现所有常用方法所以

public abstract class DomainAccess<T extends Domain> {

    protected abstract Logger getLogger();

    protected DatabaseFacade db;

    protected Class<T> domainClass;

    @Inject
    public DomainAccess(DatabaseFacade databaseFacade, Class<T> domainClass) {
        this.db = databaseFacade;
        this.domainClass = domainClass;
    }

    @SuppressWarnings("unchecked")
    public T fetchByPrimaryKey(Object primaryKey) {
        return (T) db.find(domainClass, primaryKey);
    }

    // TODO This might be better to be used for complete comparison if expanded
    public boolean exists(T object) {
        return fetchByPrimaryKey(object.getPrimaryKey()) == null ? false : true;
    }

    public void save(T object) {
        db.save(object);
    }

    public void merge(T object) {
        db.merge(object);
    }

    public void delete(T object) {
        db.remove(object);
    }

    public void saveOrUpdate(T object) {
        if (exists(object)) {
            merge(object);
        } else {
            save(object);
        }
    }

    public void deleteByPrimaryKey(T object) throws EntityNotFoundException {
        Object primaryKey = object.getPrimaryKey();
        T objectToDelete = fetchByPrimaryKey(primaryKey);

        if (objectToDelete == null) {
            getLogger().debug("There was no entry found with primary key: " + primaryKey);
            throw new EntityNotFoundException("No entry was found with specified primary key [" + primaryKey + "]");
        } else {
            getLogger().debug("Deleting entry with id: " + primaryKey);
            delete(objectToDelete);
        }
    }

    @SuppressWarnings("unchecked")
    public List<T> getResultList(String hql, String... parameters) {
        TypedQuery<T> query = db.createTypedQuery(hql, domainClass);
        for (int i = 0; i < parameters.length; i++) {
            query.setParameter(i + 1, parameters[i]);
        }
        return query.getResultList();

    }

    @SuppressWarnings("unchecked")
    public T getSingleResult(String hql, String... parameters) {
        TypedQuery<T> query = db.createTypedQuery(hql, domainClass);
        for (int i = 1; i <= parameters.length; i++) {
            query.setParameter(i, parameters[i - 1]);
        }

        return query.getSingleResult();
    }
}

3）同样地，我认为在服务中我认为我应该使用模型作为参数公共抽象类DomainService {

    protected abstract Logger getLogger();

    protected final Validator validator;

    protected DomainService() {
        // TODO this might be needed only for insertion so instead of a class member, maybe it's better to have it as
        // a method variable?
        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        this.validator = factory.getValidator();
    }

    /**
     * Inserts an entry in the database for the object passes an an argument.
     * 
     * @param object The object representing the entry to be inserted
     * @throws ValidationException When the object doesn't pass the validation. i.e. a member value is not valid based
     */
    //TODO handle validation exception with message
    abstract public void insert(T object) throws ValidationException;

    /**
     * Deletes an entry from the database. A whole object of the appropriate type is passed as an argument which
     * will be used as a storage/collection of the attributes of the entry by which the deletion can occur. Different
     * implementations can use these attributes to performs filtering and collection of entries to be deleted.
     * 
     * @param object An object representing the entry to be deleted.
     * 
     * @throws EntityNotFoundException when no entry to be deleted is found
     */
    // TODO remove TransactionRequiredException, IllegalArgumentException
    abstract public void delete(T object) throws EntityNotFoundException;

    /**
     * Returns all the entries of the table.
     * 
     * @return a list containing objects representing all the entries in the table.
     */
    abstract public List<T> fetchAll();
}

因此，在我将拥有对象的所有值的servlet中，我将构建一个成员实例，然后将其传递给 service ，这将转换它到域或使用它来更新现有的域对象（例如，它是从数据库中检索的）等等

域到模型类

0 个答案: