Questione : Scheduling di lavoro in Java

Ciao, il

We ha un'applicazione del web funzionare sul Tomcat v6.0.10 del Apache. Naturalmente, i rapporti sono inoltre disponibili come componente della nostra applicazione.  Ora, abbiamo progettato di introdurre una nuova caratteristica nella programmazione di rapporto denominato di applicazione.  Using il rapporto che programma, i rapporti di programma della latta dell'utente di applicazione della loro scelta e lo ottengono trasportato alla loro cassetta postale. Vogliamo dare flessibilità dell'utente tanta come possono nella programmazione del reports.

I anche sentito & letto sulla programmazione di lavoro in Java a: i programmatori di lavoro di fonte del

Open nel rel= " nofollow " " del _blank " " del target= " di http://java-source.net/open-source/job-schedulers del href= di Java
n-source/job-schedulers

What di http://java-source.net/ope è rel= " nofollow " " del _blank " " del target= " di http://onjava.com/lpt/a/6207 del href= di Quartz
rel= " nofollow " " del _blank " " del target= " di http://www.javalobby.org/java/forums/t68751.html del href= di Scheduler
07

JobServer 1.4 Open Source Java di http://onjava.com/lpt/a/62 > caso di uso del ava/forums/t68751.html

Considering di http://www.javalobby.org/j il mio hanno spiegato sopra, le mie domande sono: Il
1) è esso possibile usare il proprio java.util.TimerTask del Sun per la mia programmazione complessa di rapporto? Il
2) che cosa è i motivi/limitazioni validi/forti di java.util.TimerTask confrontato ad altre strutture del programmatore di lavoro?  In modo che io stesso abbia una forte credenza/motivo prima della scelta del programmatore di lavoro di terzi framework.
3) ci è un massimo di 100-200 utenti nella mia applicazione.  Nel caso, gli utenti programmino i rapporti in tale maniera contemporaneamente ci sono 100 richieste di rapporto nella coda.  Come la struttura del programmatore di lavoro O il java.util.TimerTask tratta tali piani d'azione?  Abbiamo controllo sopra questo? Il
4) in qualunque momento, utenti è permesso cambiare i loro programmi di rapporto. La struttura del programmatore di lavoro sostiene questa? Il
5) ovviamente, fare funzionare un rapporto là è input di rapporto, che deve essere passato ad ogni programma di rapporto.  Abbiamo la flessibilità/opzione nel passare i parametri alla struttura del programmatore di lavoro?
5) che è il migliore senso? Struttura d'integrata del programmatore di lavoro con l'applicazione Web o il funzionamento esso come un autonomo?

NOTE
a causa della perdita di memoria nella nostra applicazione, abbiamo un nuovo inizio della giornalmente-base di servizio del Tomcat a tempo di basso-uso.  Il motivo che sto spiegando questo è che il rapporto preveduto da Users dovrebbe essere persistito attraverso l'assistente/nuovi inizi del Tomcat.  Prendere questo nell'opinione di consideration.

Experts nel giusto senso sono appreciated.
 class= del

Risposta : Scheduling di lavoro in Java

Ho avuto bene appena uno sguardo ad uno delle mie applicazioni che usa il quarzo (spostato a primavera Spring) e sul unschedule dell'aggiornamento i un lavoro ed allora programmo quello variabile.

Qui il mio codice per sheduling/unscheduling… anche devo comunicare abbastanza alcune informazioni al lavoro, in modo da è relativamente simile a che cosa avete bisogno (ma tenere presente, che il codice categoria dei mabe uno o altro è soltanto disponibile quando usando l'involucro del quarzo della molla) (“i dati„ sono i dati reali di lavoro, il molla-contesto e il lavoro-executer-servizio si riferiscono al contesto della molla e ad un servizio, di che ho bisogno all'interno del mio lavoro)
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:

	protettivo
	scheduleJob vuoto (aJob finale di SchedulerJob)
	{
        // genera un contesto di lavoro (Quarzo-Oggetto).
        jobDataMap finale di JobDataMap = nuovo JobDataMap ();
        jobDataMap.put (“dati„, aJob);
        jobDataMap.put (“molla-contesto„, ctx);
        jobDataMap.put (“lavoro-executer-servizio„, jobEcecuterService);

        // genera un particolare di esecuzione di lavoro (Quarzo-Oggetto).
        jobDetail finale di JobDetail = nuovo JobDetail (aJob.getId (),
                posizione di segnale minimo, DefaultSchedulerExecuter.class);
        jobDetail.setJobDataMap (jobDataMap);

        // aggiunge la JOD-definizione al programmatore.
        prova {
            schedulerFactory.addJob (jobDetail, allinea);

            // genera un innesco del quarzo per iniziare il lavoro.
            innesco finale di CronTrigger = nuovo CronTrigger ();
            // ha fissato il nome all'identificazione
            trigger.setName (aJob.getId ());
            trigger.setJobName (aJob.getId ());
            Inizio di // ora.
            trigger.setStartTime (Calendar.getInstance () .getTime ());
            Programma di // come specificato nell'espressione del cron.
            trigger.setCronExpression (aJob.getCronExpression ());

            se (log.isInfoEnabled ()) {
                log.info (" [PROGRAMMATORE] - lavoro di Scheduling: „ +
                        aJob.getId () + “con executer„ +
                        jobDetail.getJobClass () .getCanonicalName ());
            }

            Programma di // il nuovo lavoro.
            schedulerFactory.scheduleJob (innesco);
        } fermo (eccezione finale e) {
            se (log.isDebugEnabled ()) {
                log.info (“lavoro di Scheduling di errore„ + aJob.getName () + “. Lavoro disattivato. „, e);
            }

            // disattiva il lavoro, in modo da non è iniziato automaticamente ancora.
            aJob.setEnabled (falso);

            // conserva il lavoro modificato.
            prova {
                updateJob (aJob);
            } fermo (eccezione finale ex) {
                tiro nuovo RuntimeException (ex);
            }
        }
	}

	protettivo
	unscheduleJob vuoto (aJobId finale della stringa)
	{
    	prova {
    		se (schedulerFactory.getJobDetail (
                    aJobId, “DIFETTO„)! = posizione di segnale minimo) {
				se (log.isInfoEnabled ()) {
					log.info (" [PROGRAMMATORE] - lavoro di Unscheduling: „ +
							aJobId);
				}

				schedulerFactory.deleteJob (aJobId, “DIFETTO„);
    		}
		} fermo (SchedulerException finale e) {
			tiro nuovo RuntimeException (
					“Lavoro unscheduling di errore con l'identificazione„ + aJobId, e);
		}
	}
Altre soluzioni  
 
programming4us programming4us