Visualizzazione dei risultati da 1 a 8 su 8
  1. #1

    ProgressMonitor per upload file

    Salve,

    sto cercando di implementare un ProgressMonitor in un'applicazione che serve per inviare files ad altri pc!
    Sfogliando le api di java ho trovato questo ottimo esempio -> link java sun
    ma non ho ben capito in che modo posso modificare il primo metodo della classe SwingWorker:

    codice:
        class Task extends SwingWorker<Void, Void> {
            /*
             * Main task. Executed in background thread.
             */
            @Override
            public Void doInBackground() {
                Random random = new Random();
                int progress = 0;
                //Initialize progress property.
                setProgress(0);
                while (progress < 100) {
                    //Sleep for up to one second.
                    try {
                        Thread.sleep(random.nextInt(1000));
                    } catch (InterruptedException ignore) {}
                    //Make random progress.
                    progress += random.nextInt(10);
                    setProgress(Math.min(progress, 100));
                }
                return null;
            }
    
            /*
             * Executed in event dispatching thread
             */
            @Override
            public void done() {
                Toolkit.getDefaultToolkit().beep();
                startButton.setEnabled(true);
                setCursor(null); //turn off the wait cursor
                taskOutput.append("Done!\n");
            }
        }
    In che modo potrei collegarlo all'uploading di un file?

  2. #2
    Utente di HTML.it L'avatar di andbin
    Registrato dal
    Jan 2006
    residenza
    Italy
    Messaggi
    18,284
    Il doInBackground() concettualmente dovrebbe contenere il "tuo" lavoro da eseguire, in cui però all'inizio e poi di tanto in tanto aggiorni lo stato del progresso.

    Innanzitutto potresti anche lasciar perdere SwingWorker. Perché SwingWorker, come classe di Java SE è presente solo da Java 6, le versioni precedenti non ce l'hanno ma ne esiste una implementazione (a parte e più limitata) che puoi scaricare da qui.

    Comunque basta un semplice e normale thread. Insomma ... il concetto importante è che il "tuo" lavoro venga eseguito in un thread separato in modo da non tenere impegnato il EDT e che in mezzo al tuo lavoro di tanto in tanto aggiorni la indicazione del progresso (e questo va fatto in modo corretto nel rispetto di Swing per quanto riguarda l'accesso a metodi non thread-safe).
    Andrea, andbin.devSenior Java developerSCJP 5 (91%) • SCWCD 5 (94%)
    java.util.function Interfaces Cheat SheetJava Versions Cheat Sheet

  3. #3
    Se non ho capito male nel metodo inDoBackground() dovrei mettere una funzione che segue il ciclo nel quale avviene il trasferimento dei bytes del file?

    Sinceramente non so come fare questo collegamento, poichè si tratta di creare una classe astratta!

  4. #4
    Utente di HTML.it L'avatar di andbin
    Registrato dal
    Jan 2006
    residenza
    Italy
    Messaggi
    18,284
    Originariamente inviato da VincenzoTheBest
    Se non ho capito male nel metodo inDoBackground() dovrei mettere una funzione che segue il ciclo nel quale avviene il trasferimento dei bytes del file?

    Sinceramente non so come fare questo collegamento, poichè si tratta di creare una classe astratta!
    Lascia perdere un momento questioni su SwingWorker ... classi astratte ecc....

    Ti è chiaro il concetto di fondo?? Hai una applicazione Swing dove (presumo io) a seguito di un qualche evento (pressione pulsante, scelta menù ... quello che vuoi) devi far partire il "tuo" lavoro e mostrare poi lo stato di avanzamento del lavoro.

    Non puoi eseguire questo lavoro direttamente a seguito di un evento, ad esempio nel contesto di un actionPerformed() o altro metodo di listener .... lì sei nel contesto del "EDT", il thread di Swing che non devi mai tenere impegnato per troppo tempo pena congelamento della tua interfaccia.

    Devi eseguire il tuo lavoro in un thread separato e ogni qualvolta devi interagire con la interfaccia utente devi farlo in modo "scrupoloso" per evitare casini.

    Come fare questo cioè definire, istanziare, eseguire il thread ecc..., intendo proprio a livello di scrittura e struttura del codice lo puoi fare in una infinità di modi diversi.
    Andrea, andbin.devSenior Java developerSCJP 5 (91%) • SCWCD 5 (94%)
    java.util.function Interfaces Cheat SheetJava Versions Cheat Sheet

  5. #5
    Bene...quindi potrei anche creare una classe non astratta che estenda la classe thread e dunque nel metodo run() vado ad implementare il ProgressMonitor!
    Può essere una buona soluzione questa?

  6. #6
    Ho creato due classi in due file .java diversi, ma se provo ad applicare metodi di una classe nell'altra, non riesco a compilare il file (in cui ho applicato i metodi dell'altra classe), perchè mi dice che non trova i metodi dell'altra classe!

    Non capisco perchè ho questo problema? :master:

  7. #7
    Utente di HTML.it L'avatar di andbin
    Registrato dal
    Jan 2006
    residenza
    Italy
    Messaggi
    18,284
    Originariamente inviato da VincenzoTheBest
    Ho creato due classi in due file .java diversi, ma se provo ad applicare metodi di una classe nell'altra, non riesco a compilare il file (in cui ho applicato i metodi dell'altra classe), perchè mi dice che non trova i metodi dell'altra classe!
    Senza sapere cosa hai scritto, come/dove sono i sorgenti, come li hai compilati ecc... non si può dire granché ....
    Andrea, andbin.devSenior Java developerSCJP 5 (91%) • SCWCD 5 (94%)
    java.util.function Interfaces Cheat SheetJava Versions Cheat Sheet

  8. #8
    Ho fatto una cosa più o meno uguale all'esempio compresso nel file zip della pagina che mi hai linkato!

    SwingWorker per la creazione e la gestione del Thread:
    codice:
    import javax.swing.SwingUtilities;
    
    public abstract class SwingWorker 
    {
    
    	private Object valore;
    	private Thread thread;
    	
    	//classe privata ThreadVar per mantenere il riferimento al worker thread corrente
    	private static class ThreadVar
    	{
    		private Thread thread;
    		
    		ThreadVar(Thread t)
    		{
    			thread=t;
    		}
    		
    		synchronized Thread get()
    		{
    			return thread;
    		}
    		
    		synchronized void clear()
    		{
    			thread=null;
    		}
    	}
    	
    	private ThreadVar threadVar;
    	
    	//metodi classe SwingWorker
    	
    	protected synchronized Object getValore()
    	{
    		return valore;
    	}
    	
    	private void setValore(Object newValore)
    	{
    		valore=newValore;
    	}
    	
    	// computa il valore ritornato applicando il metodo get()
    	public abstract Object construct();
    	
    	public void finished(){
    	}
    	
    	public void interrupt()
    	{
    		Thread t=threadVar.get();
    		
    		if(t != null)
    			t.interrupt();
    		
    		threadVar.clear();
    	}
    	
    	//questo metodo restituisce il valore fornito dal metodo construct
    	public Object get()
    	{
    		while(true)
    		{
    			Thread t = threadVar.get();
    			
    			if(t != null)
    			{
    				return getValore();
    			}
    			
    			try
    			{
    				t.join();
    			}
    			catch(InterruptedException e)
    			{
    				Thread.currentThread().interrupt();
    				return null;
    			}
    		}
    	}
    
    
        public SwingWorker() 
        {
        	final Runnable doFinished = new Runnable()
        	{
        		public void run()
        		{
        			finished();
        		}
        	};
        	
        	Runnable doConstruct = new Runnable()
        	{
        		public void run()
        		{
        			try
        			{
        				setValore(construct());
        			}
        			finally
        			{
        				threadVar.clear();
        			}
        			
        			SwingUtilities.invokeLater(doFinished);
        		}
        	};
        	
        	Thread t=new Thread(doConstruct);
        	threadVar = new ThreadVar(t);
        }
        
        //metodo start
        public void start()
        {
        	Thread t=threadVar.get();
        	
        	if(t != null)
        		t.start();
        }
        
        
    }
    Classe che utilizza i metodi dello SwingWorker
    codice:
    /**
     * @(#)Sender.java
     *
     *
     * @author 
     * @version 1.00 2009/1/24
     */
    
    import java.awt.*;
    import java.awt.event.*;
    import javax.swing.*;
    import javax.swing.border.*;
    import java.io.*;
    
    class Sender extends JPanel
    {
    
    	//variabili
    	JProgressBar progressBar = new JProgressBar();
    	JLabel  label = new JLabel("", JLabel.CENTER);
    	SwingWorker worker;
    	JButton startButton;
    	JButton annullaButton;
    	
    	//per file
    	int fileSize;
    	
    	JButton getStartButton()
    	{
    		return startButton;
    	}
    	
    	void updateStato(final int i)
    	{
    		Runnable setProgressBarValore = new Runnable()
    		{
    			public void run()
    			{
    				progressBar.setValore(i); //non lo trova
    			}
    		};
    		
    		SwingUtilities.invokeLater(setProgressBarValore);
    	}
    	
    	int getFileSize(FileInputStream lettura)
    	{
    		int nbyte=0, n=0;
    		byte[] dati = new byte[10000];
    		
           	while((nbyte=lettura.read(dati)) > 0)
           			n=n+nbyte;
           
           	return fileSize=n;			
    	}
    	
    	Object Work()
    	{
    		int nbyte=0, n=0;
    		
    		try
    		{
    			for(int i=0; i<fileSize; i++)
    			{
    				upadateStato(i);
    				
    				if(Thread.interrupted())
    				{
    					throw new InterruptedException();
    				}
    				
    				Thread.sleep(500);
    			}
    		}
    		catch(InterruptedException e)
    		{
    			updateStato(0);
    			return "Upload Interrotto";
    		}
    		
    		return "Upload effettuato con successo";
    	}
    	
    	
    	//azione chiamata dal bottone start
    	ActionListener startListener = new ActionListener()
    	{
    		public void actionPerformed(ActionEvent event)
    		{
    			startButton.setEnabled(false);
    			annullaButton.setEnabled(true);
    			// da finire
    			
    		}
    	};
    	
    	//azione chiamata alla pressione del tasto annulla
    	ActionListener annullaListener = new ActionListener()
    	{
    		public void actionPerformed(ActionEvent event)
    		{
    			//da fare
    		}
    	};
    	
    	//interfaccia del programma
        Sender() 
        {
    	//da fare
        }
        
    
        //altri metodi
    }

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.