Model e AbstractTableModel

[bp69]

Ciao a tutti, sto sviluppando un'applicazione in java (db sql server) nella quale c'è una tabella "NestGen" che contiene i dati generali di lavorazione con chiave "idNest" ed una tabella "NestOrd" che contiene tutti gli ordini legati al nesting, quindi per un nesting più ordini.
Ho creato una classe "NestModel" (che estende Observable per essere osservata delle relative view) nella quale gestisco tutti i metodi per modificare NestGen.
Ho inoltre creato una classe "TblMdlNestOrd" che estende AbstractTableModel nella quale invece gestisco tutti i metodi per modificare NestOrd.
Per gestire sia le modifiche di "NestGen" sia quelle di "NestOrd", la classe "NestModel" contiene un oggetto privato "TblMdlNestOrd" che utilizza come nel codice che vado a postare.
Nella view che mi serve per mostrare tutte le righe di "NestOrd", alla relativa JTable passo come parametro il tblMdlNestOrd di "NestModel".
Il tutto funziona, ma se volessi per esempio gestire con una transazione le modifiche dei dati di "NestGen" con quelle di "NestOrd" in questo modo non riesco.
Ho pensato che potrei gestire direttamete anche i dati di "NestOrd" nella classe "NestModel", facendo in modo che questa estenda AbstactTableModel, in modo da incorporare tutte le proprietà e i metodi di "TblMdlNestOrd" in "NestModel".
In questo modo alla JTable passerei direttamente "NestModel" come tableModel.
Penso di essermi complicato la vita, qualcuno ha dei consigli da darmi per favore ?
Grazie

Model per gestire "NestGen":

public class NestModel extends Observable{
	
	// stato del model
	private NestVO nestVO;			//qui ci sono i dati di NestGen
	private TblMdlNestOrd tblMdlNestOrd;	
	
	// oggetti dao
	private NestDAO nd;
	
	public NestModel(){
		tblMdlNestOrd = new TblMdlNestOrd();
		nd = NestDAOFactory.getInstance();
	}
	
	/**
	 * Aggiunge un record nella tabella Nest
	 * @param NestVO entry
	 */
	public void add(NestVO entry){
		
		// apro la connessione
		Db dataBase = new Db(true);
		
		// apro docNr
		DocNrPK docNrPK = new DocNrPK(DocNrDAO.DOCNR_NEST, 0);
		DocNrDAO dnd = DocNrDAOFactory.getInstance();
		
		DocNrVO docNrVO = dnd.retrive(docNrPK, dataBase);
		int newDocNr = docNrVO.getNrUltDoc();

		// aggiorno docNr
		newDocNr++;
		docNrVO.setNrUltDoc(newDocNr);
		docNrVO.setDtaUltDoc(new Date());
	
		// aggiorno dati input
		entry.setIdNest(newDocNr);
		entry.setNrUtente(Utente.getNrUtente());
		
		NestDAO nDao = NestDAOFactory.getInstance();
		
		// inizio la transazione
		dataBase.setAutoComit(false);

		if(nDao.add(entry, dataBase)){
			if(dnd.update(docNrVO, dataBase)){

				// chiudo la transazione
				dataBase.commit();
				
				// aggiorno lo stato del model
				this.nestVO = entry;
				
				// pulisco la lista nestOrd
				tblMdlNestOrd.clear();
				
				super.setChanged();
			
			}else{
				dataBase.rollback();
			}
			
		} else{	
			dataBase.rollback();
		}
		
		nDao = null;
		dnd = null;
		
		// chiudo la connessione
		dataBase.disconnetti();
		dataBase = null;
		
		// notifico
		super.notifyObservers();
	}
	
	/**
	 * Modifica un record della tabella Nest
	 * @param NestVO entry
	 */
	public void update(NestVO entry){
		
		// verifico se ci sono modifiche
    	if(! this.nestVO.equals(entry)){
    		entry.setNrUtente(Utente.getNrUtente());
    		entry.setDtaMod(new Date());
    	}
		
		// apro la connessione
		Db dataBase = new Db(true);
			
		if(nd.update(entry, dataBase)){
			
			// aggiorno lo stato del model
			this.nestVO = entry;
			super.setChanged();
		}
		
		// chiudo la connessione
		dataBase.disconnetti();
		dataBase = null;
		
		// notifico
		super.notifyObservers();
	}
	
	public void delete(NestPK entry){
		
		// verifico che non ci siano NestOrd collegati
		if (tblMdlNestOrd.getRowCount() == 0){
			
			// apro la connessione
			Db dataBase = new Db(true);
			
			if(nd.delete(entry, dataBase)){
				
				// aggiorno lo stato del model
				this.nestVO = null;
				
				super.setChanged();
			}
			
			// chiudo la connessione
			dataBase.disconnetti();
			dataBase = null;
			
			// notifico
			super.notifyObservers();
		}
	}
	
	/**
	 * Trova un record Nest con i relativi
	 * record NestOrd
	 * @param NestPK entry
	 */
	public void find(NestPK entry){

		// apro la connessione
		Db dataBase = new Db(true);
		
		// azzero lo stato
		this.nestVO = null;
		this.tblMdlNestOrd.clear();
		
		try{
			this.nestVO = nd.retrive(entry, dataBase);
			
			// relativi nestOrd
			this.tblMdlNestOrd.find(entry);
			super.setChanged();
 			
		}catch(NullPointerException e){
			System.out.println(e.toString());
		}
		
		// chiudo la connessione
		dataBase.disconnetti();
		dataBase = null;
		
		// notifico
		super.notifyObservers();
	}
	
	/**
	 * Aggiunge un record a NestOrd
	 * @param NestOrdVO entry
	 */
	public void addOrd(String nrOrdine, int qta){
		
		// preparo i dati di input
		NestOrdVO entry = new NestOrdVO();
		entry.setIdNest(this.nestVO.getIdNest());
		entry.setNrOrdine(nrOrdine);
		entry.setQtaNest(qta);
		
		this.tblMdlNestOrd.add(entry);
	}
	
	/**
	 * Aggiorna un record NestOrd in base
	 * alla sua posizione nell'ArrayList
	 * ed alla quantità di input
	 * @param int index
	 * @param int qtaNest
	 */
	public void updateOrd(int rowNr, int qta){
		
		this.tblMdlNestOrd.update(rowNr, qta);
	}
	
	/**
	 * Elimina un record della tabella NestOrd
	 * @param int index
	 */
	public void deleteOrd(int rowNr){
		
		this.tblMdlNestOrd.delete(rowNr);
	}
	
	public NestVO getNestVO(){
		return this.nestVO;
	}
	
	public TblMdlNestOrd getTblMdlNestOrd(){
		return this.tblMdlNestOrd;
	}
}

TableModel per gestire "NestOrd":

public class TblMdlNestOrd extends AbstractTableModel{
	
	private String[] columnNames = {"nrOrdine", "qta", "id",
			"codArt", "file_Las", "cont"};
	
	private ArrayList<NestOrdVO> rowData;	// qui ci sono i dati di NestOrd
	private NestOrdDAO nod;
	
	public TblMdlNestOrd(){
		rowData = new ArrayList<NestOrdVO>();
		nod = NestDAOFactory.getNestOrdInstance();
	}
	
	public int getColumnCount(){
		return columnNames.length;
	}
	
	public int getRowCount(){
		return rowData.size();
	}
	
	public String getColumnName(int col){
		return columnNames[col];
	}
	
	public Class getColumnClass(int c) {
		Class result = null;
		result = getValueAt(0,c).getClass();
		return result;
	}
	
	public boolean isCellEditable(int row, int col) {
		return false;	
	}
	
	...


	public Object getValueAt(int row, int col){
		
		...
	}
	
	public void update(int rowNr, int qta){
		
		// leggo la riga da modificare
		NestOrdVO nestOrdVO= rowData.get(rowNr);
		nestOrdVO.setQtaNest(qta);

		// apro la connessione
		Db dataBase = new Db(true);
		
		// aggiorno il database
		if(nod.update(nestOrdVO, dataBase)){
			
			// aggiorno i dati del tableModel
			rowData.set(rowNr, nestOrdVO);
			fireTableDataChanged();
		}
		
		// chiudo la connessione
		dataBase.disconnetti();
		dataBase = null;
	}
	
	
	public void add(NestOrdVO entry){
		
		// verifico input
		if(entry == null){
			return;
		}
		
		// apro la connessione
		Db dataBase = new Db(true);
		
		// aggiorno il database
		if(nod.add(entry, dataBase)){
			
			// aggiorno i dati del tableModel
			rowData.add(entry);
			this.fireTableDataChanged();
		}
		
		// chiudo la connessione
		dataBase.disconnetti();
		dataBase = null;
	}
	


	public void delete(int rowNr){
		// leggo la riga da eliminare
		NestOrdVO nestOrdVO= rowData.get(rowNr);
		NestOrdPK nestOrdPK= nestOrdVO.getNestOrdPK();

		// apro la connessione
		Db dataBase = new Db(true);
		
		// aggiorno il database
		if(nod.delete(nestOrdPK, dataBase)){
			
			// aggiorno i dati del tableModel
			rowData.remove(rowNr);
			fireTableDataChanged();
		}
		
		// chiudo la connessione
		dataBase.disconnetti();
		dataBase = null;
	}



	public void find(NestPK entry){
	
		// apro la connessione
		Db dataBase = new Db(true);
	
		// pulisco i dati
		this.clear();
	
		// carico i dati
		this.rowData.addAll(Arrays.asList(nod.retrive(entry, dataBase)));
		
		// chiudo la connessione
		dataBase.disconnetti();
		dataBase = null;
	
		this.fireTableDataChanged();
	}

		
	public void clear(){
		this.rowData.clear();
	}
}

[bp69]

Ciao a tutti, avrei pensato di fare così:
Tutti i dati li metto nel NestModel, tutti nella stessa classe così posso gestirmi eventuali transazioni.
Avevo pensato di implementare l'interfaccia TableModel direttamente in NestModel (visto che questo estende già Observable), guardando anche il codice sorgente java di AbstractTableModel.
Alla fine ho deciso di tenere TblMdlNestOrd facendogli estendere direttamente AbstractTableModel(non mi conviene riscrivere il codice che c'è già), delegandolo solo alla visualizzazione della JTable, spostando tutti i metodi di modifica dati in NestModel.
Nel NestModel ho un oggetto tipo TblMdlNestOrd

public class NestModel extends Observable{
	
	// stato del model
	private NestVO nestVO;			// qui ci sono i dati di NestGen
	private ArrayList<NestOrdVO> rowData;	// qui si sono i dati di NestOrd
	private TblMdlNestOrd tblMdlNestOrd;	
	
	// oggetti dao
	private NestDAO nd;
	
	public NestModel(){
		tblMdlNestOrd = new TblMdlNestOrd();
		nd = NestDAOFactory.getInstance();
	}

	...



	public TblMdlNestOrd getTblMdlNestOrd(){
		return this.tblMdlNestOrd;
	}

	...

	public NestOrdVO getNestOrdVO(int rowNr){
		return this.rowData.get(rowNr)
	}

	...

Quando creo la JTable, passo come TableModel il riferimento al tblMdlNestOrd di NestModel.
Nel TblMdlNestOrd, al metodo getValueAt(int row, int col) vado a puntare ai dati di NestModel tramite getNestOrdVO...
Nei metodi di NestModel che modificano i dati, se la modifica è andata a buo fine, allora oltre che a notificare agli observer, lancio anche il fireTableChanged di tblMdlNestOrd.

Qualcuno mi sa dire se sono sulla strada giusta oppure dico stupidaggini (gradirei molto, se possibile, un parere di un autorevole partecipante al forum LIKE "*bin")
Grazie mille in anticipo.