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":

codice:
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":

codice:
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();
	}
}