neilyoung wrote:
参考一下COMPOSITE PATTERN 吧。

floater wrote:
1. The simplest way is to post your code here so we may get some ideas what goes long.
2. You may have a form class to contain your table/item and sheet/table header class and then your manager class just delegates some operations to those classes.
3. check how Swing handles tables, I have a post "JDBC revisited", there is some code there, you may take a look too. For example, you may seperate input, output, state maitaining operations into seperate classes and inherit/compose them together, depending on whether you want to expose the interfaces to users of these classes or not.

jacob wrote:
问题是不是出在数据的持久化代码重复？

palatum wrote:
我最近一直有一个问题在困扰我，希望大家能帮助我。

问题：
一个业务单据的类设计。

一个业务单据一般都有表头部分，条目部分两个大块。我原来的设计是这样的：3个类
Item类：描述条目信息
Sheet类：描述表头信息，包含一个Item类的数组。
Manager类：管理Sheet类，包含一个Sheet类的数组，还有保存表单（同时保存表头和条目），查询表单，更新表单内容和状态等等有关报单的操作。

我觉得这样挺烦人的。尤其是Manager类，很庞杂。一直想简化，但是不知道如何简化，希望有人能给出建议。

floater wrote:
1. Your chart is symmetic, so let's concentrate on the left side(without loss of generality,gosh I haven't used this phrase for 10 years, ).
2. The top and bottom classes are bases, so I could ignore them in business logic. Now we have 3 objects: Manager, sheet and item.

So I don't find anything wrong with your structure. (well, remove the getSheetItems() from the manager, that doesn't sound good) I assume you are using db and DAO:
ItemDAO(used by Sheet) and SheetDAO(used by Manager)

Manger:
addSheet();
updateSheet();
deleteSheet();
selectSheet();
getSheetList();

Sheet:
addItem(),
updateItem(),
deleteItem(),
selectItem()
getItemList();

Item:

I just finished a similar structure like this and my manager class has 230 lines of code and 14 action methods.

palatum wrote:
Where did you put the DB contact source code, another class or just in Manager Class?

Biubiu wrote:
你的这种设计方式比较常见，应该说没有什么问题。关键是有一个Persistce Mananger，这样你的Business Manager的code就不会那么长了。

当然有更好的设计方式，可以参考《Server-based Java Programming》中关于Business Layer的论述。

palatum wrote:
Persistce Manager？Faint, Biubiu made a mistake. It should be Persistence.

能解释一下Persisitence Manager做什么的吗？如果有类图就更好了。

/**
 * The PersistentManager class.
 *
 * @author Jason Hao
 */
public class PersistentManager {

    public PersistentManager() {
        init();
    }

    private void init() {
    }

    /**
     * Return the persistent instance of the given entity class with the given identifier,
     * assuming that the instance exists.
     * <br><br>
     * You should not use this method to determine if an instance exists (use <tt>find()</tt>
     * instead). Use this only to retrieve an instance that you assume exists, where non-existence
     * would be an actual error.
     *
     * @param aClass a persistent class
     * @param anId a valid identifier of an existing persistent instance of the class
     * @return the persistent instance or proxy
     */
    public Object load( Class aClass, Serializable anId ) {
    }

    /**
     * Persist the given transient instance, first assigning a generated
     * identifier. (Or using the current value of the identifier property
     * if the assigned generator is used.)
     *
     * @param anObject a transient instance of a persistent class
     * @return true if succeeded, false if failed
     */
    public boolean create( Object anObject ) {
    }

    /**
     * Update the persistent instance with the identifier of the given transient
     * instance. If there is a persistent instance with the same identifier,
     * an exception is thrown.<br>
     * <br>
     * If the given transient instance has a <tt>null</tt> identifier, an exception
     * will be thrown.<br>
     * <br>
     *
     * @param anObject a transient instance containing updated state
     * @return true if succeeded, false if failed
     */
    public boolean update( Object anObject ) {
    }

    /**
     * Remove a persistent instance from the datastore. The argument may be
     * an instance associated with the receiving <tt>Session</tt> or a transient
     * instance with an identifier associated with existing persistent state.
     *
     * @param anObject the instance to be removed
     * @return true if succeeded, false if failed
     */
    public boolean delete( Object anObject ) {
    }

    public List doHqlQuery( String aQueryString ) {
    }

    public List doHqlQuery( String aQueryString, Object aParam ) {
    }

    public List doHqlQuery( String aQueryString, Object[] aParamArray ) {
    }

    public Session getSession() {
    }
}

palatum wrote:
Thanks Biubiu. But I think that to define PersistentManager class as an interface maybe better. What do you think about?

floater wrote:
Persistence Manager should be one level above DAO. Biubiu's code should be the DAO implementation. Persistence Manager should be the manager for DAOs.

In the same fashion, if appropriate, we should have business managers too for different business logic.

Always use DAO interfaces, because these are the gates between two layers(We have far less layers than components, so layers are more distinct and we use interfaces).

Biubiu wrote:
你的这种设计方式比较常见，应该说没有什么问题。关键是有一个Persistce Mananger，这样你的Business Manager的code就不会那么长了。

当然有更好的设计方式，可以参考《Server-based Java Programming》中关于Business Layer的论述。

palatum wrote:
看了两遍，还是不太理解，能给些建议吗？最好是UML图，类与类之间关系画清楚就行了。

Biubiu wrote:
里面不是有个例子吗，连代码都有啊？