Schedulare due remoteAction da Dialog.

[maximum]

Salve a tutti,
devo eseguire al clic su un Jbutton, due RemoteAction e pensavo di utilizzare la CompositeAction in modo da gestire entrambe le azioni.

Tuttavia, non capisco perchè al clic sul bottone e al superamento del controllo sulla prima action (nel ciclo for interno), non scatta la seconda Action; per capirci quella evidenziata il grassetto.

Qualche idea?
Vi posto il codice.

        btnConferma = new JButton(getString("tasto.conferma.titolo"));
        btnChiudi = new JButton(getString("tasto.chiudi.titolo"));

//Test Max inizio
        CompositeAction cActions = new CompositeAction(new LoadSpAccInSpRasAction(rasDip,elencoSpAccSsEst){

            private static final long serialVersionUID = 1L;

            @Override public void actionPerformed(ActionEvent e) {
                log.debug("Inizio azione tasto Conferma " + e);
                
                //Se l'elenco delle spese accertate contiene almeno una posizione con riferimento
                //a spese precedenti il mese di compilazione e contestualmente 
                //flag posponi = N o NULL e giorno del mese = NULL, si segnala all'utente
                //di specificare il flag (S o N) ed eventualmente la giornata su cui scaricare la spesa
                boolean errSpAcc = false;
                String annoMeseSpAcc;
                String annoMeseRas = String.format("%04d", rasDip.getAnno())+
                                        String.format("%02d", rasDip.getMese());    
                
                for (SpesaAccertataDTO spAccDTO : elencoSpAccSsEst){
                    annoMeseSpAcc = spAccDTO.anno+spAccDTO.mese;                    
                    if (annoMeseRas.compareTo(annoMeseSpAcc) != 0) {
                        if ((spAccDTO.posponi.equals("N") || spAccDTO.posponi.equals("")) && 
                             spAccDTO.rasRiaGiornoVar == null) {
                            errSpAcc = true;
                            break;
                        }
                    }
                }
                
                if (errSpAcc) {
                    JOptionPane.showMessageDialog(DesktopApplicationContext.getInstance().getMainWindow(), 
                                                  new String(getString("msg.spesa.accertata.incompleta")), 
                                                  new String(getString("tasto.conferma.titolo")), 
                                                  JOptionPane.WARNING_MESSAGE);            
                    return;
                } else {
                    super.actionPerformed(e);
                }
                log.debug("Fine azione tasto Conferma");                    
            }
        });        
                
        cActions.addActionListenerAfter(new RipartisciSpeseAction(rasDip));
        btnConferma.addActionListener(cActions);

[andbin]

Tuttavia, non capisco perchè al clic sul bottone e al superamento del controllo sulla prima action (nel ciclo for interno), non scatta la seconda Action; per capirci quella evidenziata il grassetto.

Cosa è la CompositeAction? (per meglio dire: di chi è, da dove arriva?)
E LoadSpAccInSpRasAction come è fatta?

[maximum]

Chiedo scusa, ma la CompositeAction è una classe personalizzata che estende la classe Action public class CompositeAction implements Action{...}.

Tralasciando questo aspetto, il mio obliettivo è schedulare due remote action in sequenza.
La domanda è, posso fare semplcemente qualcosa del genere?

        btnConferma.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                log.debug("Inizio azione tasto Conferma " + e);
                    new LoadAction1().actionPerformed(e);        
                    new LoadAction2().actionPerformed(e);
                log.debug("Fine azione tasto Conferma");
            }            
        });

[andbin]

Chiedo scusa, ma la CompositeAction è una classe personalizzata che estende la classe Action public class CompositeAction implements Action{...}.

Action è una interfaccia. Quando si vuole creare una action "custom" tipicamente non si implementa direttamente Action ma si estende (per comodità) la classe AbstractAction.

E comunque Action non rappresenta solo la esecuzione di "qualcosa" ma espone anche altre informazioni, ad esempio tramite il isEnabled() (che serve ad esempio per far sì che un pulsante/menù che ha quella action si abiliti o no a seconda di questa informazione).

Quindi creare una Action "composita" cosa vuol dire (in tal sensi)? Hai considerato questi aspetti?

posso fare semplcemente qualcosa del genere?

        btnConferma.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                log.debug("Inizio azione tasto Conferma " + e);
                    new LoadAction1().actionPerformed(e);        
                    new LoadAction2().actionPerformed(e);
                log.debug("Fine azione tasto Conferma");
            }            
        });

Tecnicamente sì ma è bruttino.


Se vuoi applicare il Composite Pattern ad ActionListener (che è più semplice di un Action) e che esegua sempre N ActionListener in sequenza, si può fare:

public class CompositeActionListener implements ActionListener {
    private final ActionListener[] listeners;

    public CompositeActionListener(ActionListener... listeners) {
        this.listeners = listeners;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        for (ActionListener l : listeners) {
            l.actionPerformed(e);
        }
    }
}

btn.addActionListener(new CompositeActionListener(actList1, actList2, actList3));


Se vuoi che un ActionListener "blocchi" o no condizionalmente la sequenza, va fatto diversamente.

[maximum]

Se vuoi che un ActionListener "blocchi" o no condizionalmente la sequenza, va fatto diversamente.

Per favore, puoi chiarirmi meglio questo punto?

[andbin]

Per favore, puoi chiarirmi meglio questo punto?

Se vuoi che un ActionListener possa "bloccare" (o al contrario lasciar continuare) condizionatamente il prossimo ActionListener, allora il CompositeActionListener che ho scritto prima ovviamente non va bene. Perché ciascun ActionListener che passi a CompositeActionListener non "sa" nulla degli altri e non ha alcun appiglio per chiamare/bloccare esplicitamente un altro.
In teoria potrebbe lanciare una eccezione specifica che potrebbe essere catturata nel actionPerformed del CompositeActionListener. Ma è molto molto brutto. Le eccezioni non dovrebbero essere usate (solo) per il controllo del "flusso".

Una alternativa è usare il Decorator Pattern.