lunedì 28 luglio 2014

Eseguire un singolo metodo di test JUnit in Eclipse

Normalmente si dovrebbe eseguire tutti i test JUnit per assicurare che le modifiche non hanno infranto nessuna delle prove. Ma a volte si desidera concentrarsi su un metodo di prova unico e solo eseguire nuovamente quel test, soprattutto se l'esecuzione di tutte le prove è troppo lenta o se si scrive un singolo (non) prova di anticipo.
Ad esempio, nel codice seguente si potrebbe desiderare solo per eseguire testMethod2 () :
1
2
3
4
5
6
7
pubblico class SomeTest {
   @ Test
   pubblico nullo TestMethod1 () {...}
 
   @ Test
   pubblico nullo testMethod2 () {...}
}
Eclipse fornisce un paio di modi per eseguire metodi di prova individuali, uno all'interno dell'editor stesso e un altro dal punto di vista JUnit. Ha anche particolarmente buono il supporto della tastiera in modo da poter eseguire questi test senza raggiungere per il mouse.
Eseguire dall'interno dell'editor classe
Il modo più semplice di gestire un singolo metodo di test JUnit è quello di eseguire dall'interno dell'editor classe del test case:
  1. Posizionare il cursore sul nome del metodo all'interno della classe di test. Mi consiglia di utilizzare la tastiera per navigare al metodo , soprattutto se ci sono molte prove.
  2. Premere Alt + Maiusc + X, T per eseguire il test (o tasto destro del mouse, Esegui come> JUnit test ).
  3. Se si desidera eseguire nuovamente lo stesso metodo di prova, basta premere  Ctrl + F11 . Per questo lavoro, in modo che tu hai detto Eclipse per eseguire sempre l'ultima applicazione lanciata .
Ecco come eseguire solo testForecastNormal () nell'esempio seguente:
Eseguire singolo test da banco di prova
Suggerimento: Un modo equivalente per farlo è andando alla visualizzazione Struttura e l'esecuzione del metodo da lì. Il risultato finale è lo stesso che esegue il metodo di prova dalla classe.

Eseguire dal punto di vista JUnit

Un altro modo per eseguire un metodo di test JUnit è di lanciarlo dalla vista JUnit. Per fare questo, dovete prima di eseguire l'intero set di test in test case.
  1. Eseguire tutti i test nella classe di test utilizzando Alt + Maiusc + X, T o destro del mouse, Esegui come> JUnit test .
  2. Vai alla vista JUnit ed espandere tutte le prove che correva.
  3. Fare clic destro sul metodo di prova desiderato e fare clic su Esegui .
  4. Si noti che premendo Ctrl + F11 sarà rieseguire tutti i test nel caso di prova, non solo quello che hai appena eseguito. Se si desidera eseguire nuovamente il test, tornare alla visualizzazione JUnit e fare clic sul pulsante Esegui nella parte superiore della vista:JUnit_run_button
Eseguire singolo test dal punto di vista JUnitL'esempio sopra mostra come eseguire il metodo testForecastNormal () dalla vista JUnit.
Differenza tra le tecniche
Allora, qual è la differenza tra i due e che si dovrebbe utilizzare? Qui ci sono alcune differenze:
  • Esecuzione dalla classe crea una configurazione di esecuzione Eclipse che va dalla visualizzazione JUnit non lo fa.
  • Se è stato eseguito dal editor, è possibile eseguire nuovamente l'ultima prova utilizzando Ctrl + F11Dal punto di vista si può solo eseguire nuovamente dalla vista.
  • Esecuzione dal punto di vista utilizza la stessa configurazione della configurazione di esecuzione come l'esecuzione di tutti i test. Questo è utile se avete personalizzato la configurazione di esecuzione per particolari esami, ad es. quando si utilizza SWTBot o l'esecuzione di test di integrazione con l'installazione quadro necessario.
Mi consiglia di correre dalla classe come predefinita e l'unica volta che ci si vuole davvero correre dalla vista è quando si desidera riutilizzare configurazione di esecuzione personalizzata.

lunedì 21 luglio 2014

Parole JavaScript avvertimento

Quando vedo una delle seguenti parole JavaScript, mi preoccupo cose potrebbero essere scritte molto meglio qualche altro modo.
  caso   costruttore  difetto  eval  instanceof  navigatore  nuovo  prototipo  stopPropagation  interruttore
  questo   typeof  vuoto  con
Ho usato nuovi , questo e prototipi molte volte, ma li usano meno col passare del tempo e pensare eliminando loro potrebbe essere utile. nuovo non è del tutto evitabile di un'istanza di alcuni oggetti host. L'eliminazione di questo e prototipo è un obiettivo che ho lavorato verso per un bel po. Quando ho iniziato la programmazione JavaScript non avrei mai avevo pensato che alla fine avrei voluto evitare queste parole. Ora ogni volta imparo un modo per utilizzare le chiusure, invece sembra che il mio codice migliora notevolmente.

interruttori dichiarazioni sono quasi sempre un segno che gli oggetti devono avere alcune proprietà delle funzioni con valori di implementare il polimorfismo.

Ci sono alcuni grandi usi di eval in codice a livello di biblioteca, ma ogni utilizzo deve essere considerato con molta attenzione per le prestazioni compromessi.

Io non sono appassionato di instanceof o typeof perché sono in direzione di linguaggi tipizzati e una spirale verso il basso in complessità; Tuttavia, queste due parole sembrano inevitabili per le porzioni di rilevazione funzionalità di JavaScript sul browser destinata.

navigatore mi fa accapponare la pelle. L'utilizzo del navigatore è come affidarsi a tipi in un linguaggio tipizzato in cui il sistema tipo è talmente rotto che i tipi sono circa la stessa probabilità di essere menzogne ​​come verità.

costruttore è un altro tentativo rotto in un sistema di tipo.

Non ho mai usato con . Ha troppe sottigliezze difficili e non fa per il codice leggibile e mantenibile.

nulla mai attraversa anche la mia mente.

stopPropagation rompe la capacità di ascoltatori legati a qualche altro compito di fare il loro lavoro. Chiunque handler particolare, non dovrebbe avere questo molto controllo.

Non ritengo che una qualsiasi di queste parole completamente off limits. Se si verifica una situazione in cui una parola è davvero il modo migliore o solo per realizzare un compito, allora me ne occupo io. Queste parole sono la mia lista avvertimento che il treno può andare fuori dai binari.

UPDATE Ho scritto un follow-up articolo sulla programmazione, senza questo .

giovedì 17 luglio 2014

In lode di motori template Java

Come moderni motori template Java confronta con JSP 2.0 's file tag incorporati?
In "Come costruire modello guidato Siti web Java con FreeMarker e RESTEasy," sviluppatore Java Dele Taylor sostiene che la combinazione di modello di sviluppo guidato con le risorse RESTful aggiunge ad uno sweet spot grave per gli sviluppatori web Java. Il suo esempio di programmazione veloce sfrutta FreeMarker insieme al quadro RESTEasy di JBoss e il quadro front-end di Twitter Bootstrap per costruire una web app in pochi semplici passi.

Motori di template Java sono spesso favoriti da sviluppatori nuovi alla programmazione, che possono trarre beneficio dai vincoli built-in e l'architettura MVC di sviluppo template-driven. Gli sviluppatori più esperti possono utilizzare un template per un rapido sviluppo, una maggiore varietà UI e la flessibilità, e perché lo sviluppo template-driven in grado di facilitare la comunicazione più facile tra i team di progettazione e sviluppo web. In "10 motivi per sostituire il vostro JSP con i Modelli FreeMarker," Taylor sostiene anche che i modelli possono mettere il divertimento in Java programmazione web:

Sempre con Java Server Pages? Ero troppo, ma alcuni anni fa li ho mollato e non ho guardato indietro. JSP sono un concetto bene, ma prendono la gioia di sviluppo web. Per me, era le piccole cose, come avere a rottura miei modelli di pagina in file separati: header.jsp e footer.jsp, non essendo in grado di chiamare i metodi nel linguaggio delle espressioni, e non essendo in grado di combinare e organizzare le parti di pagina nella runtime.

Motore di template di Taylor open source di scelta è FreeMarker ma gli sviluppatori Java hanno molte altre opzioni, che vanno da quadri a pieno titolo come Velocity e piastrelle di nuovi progetti più leggeri come Rythm, Thymeleaf, e Trimou.

Qual è la vostra opinione su motori di modello: qual è lo stato dell'arte e come si confronta all'utilizzo di file di tag JSP 2.0? Condividi i tuoi consigli e le esperienze di seguito.

venerdì 11 luglio 2014

Generare, rinominare e cancellare immediatamente getter / setter in Eclipse

Nonostante gli argomenti e dibattiti su getter e setter in Java, il fatto è che sono una realtà e si deve lavorare con loro.

Ma la gestione di getter e setter è uno sforzo che richiede tempo. Creazione di un getter / setter per 5 campi in una classe può richiedere alcuni minuti, rinominare uno è soggetta a errori ed eliminare uno è semplicemente scomodo.

Ci sono opzioni come progetto Lombok (che crea implicitamente getter / setter, senza la necessità di codificare loro) e si poteva evitare di getter / setter completamente ridisegnando le classi.

Ma queste opzioni non sono sempre disponibili, quindi è una buona cosa Eclipse ha alcune caratteristiche utili per la gestione di getter e setter. In combinazione con la capacità di generare costruttori in base ai campi , è possibile ottenere il codice standard allontanato in pochi secondi e andare avanti con la vera codifica.


Pubblicità



Generare getter e setter

Per generare getter e setter, effettuare le seguenti operazioni:

Creare i campi desiderati nella classe quindi premete Alt + Maiusc + S, R . una finestra pop-up che consente di scegliere i campi che si desidera generare getter e setter per.
Fare clic su Seleziona tutto per creare getter / setter per tutti i campi. Naturalmente è possibile scegliere i singoli campi come richiesto.
Cambiare punto di inserimento per ultimo membro . Questo dice Eclipse che si desidera inserire i metodi nella parte inferiore della classe. Questo è normalmente l'opzione migliore per me come io li voglio fuori strada.
Fare clic su OK . Eclipse creerà i getter e setter per voi.
Ecco un esempio di ciò che il dialogo dovrebbe essere simile.



Nota: per impostazione predefinita, Eclipse non consente di creare un setter per un finale di campo - il setter semplicemente non compare nella finestra di dialogo. Questo può essere un fastidio, soprattutto se hai attivato autoformatting per fare campi di finale dove possibile. Per ignorare questa restrizione, attivare la casella di controllo Consenti setter per i campi finali nella finestra di dialogo. Il setter per il campo verrà visualizzato nella finestra di dialogo. Una volta che si fa clic su OK, Eclipse rimuoverà la definitiva parola dal campo e generare il setter. Eclipse ricorda anche questa impostazione.

Un altro modo per aggiungere un solo getter / setter è quello di posizionare il cursore in qualsiasi punto della classe (fuori da qualsiasi metodo), inizia a digitare "GET" o "set" e premete Ctrl + Spazio . Le opzioni del menu di completamento automatico comprenderanno alcuna getter / setter di campi che non hanno ancora alcun definita. Questo è un modo rapido per creare un unico getter / setter, ma non è orientata per la creazione di massa.

Ecco un esempio di come il completamento automatico appare:



Rinominare getter e setter

Il modo più semplice per rinominare getter / setter è quello di utilizzare il refactoring Rinomina.

Posizionare il cursore sul nome del campo (in qualsiasi classe, non solo la dichiarazione) e premete Alt + Maiusc + R . Se stai usando sul posto rename (il default), poi basta rinominare il campo, premere Invio e Eclipse sarà rinominare i getter e setter corrispondenti pure.

Se hai scelto di utilizzare la finestra di refactoring classico (vedi nota sotto), quindi assicurarsi di attivare Rinomina getter e setter Rinomina nella finestra di dialogo Rinomina.

Nota: È possibile scegliere di non rinominare utilizzando la finestra di dialogo tradizionale Rename andando in Finestra> Preferenze> Java e deselezionando Rinomina dall'editor senza finestra . Io preferisco usare la finestra di dialogo Rinomina quanto mette in evidenza l'intero nome di default rendendo più facile per sovrascrivere e ho la possibilità di non rinominare i getter e setter se io non voglio. L'impostazione predefinita Eclipse in questi giorni è quello di utilizzare il nuovo rinominare sul posto.

Anche se Eclipse sarà rinominare il getter / setter, non rinominare l'argomento passato al metodo setter. Se si vuole coerenza, è possibile passare a tale metodo (es. usando Ctrl + O ) e rinominare l'argomento da soli.
Pubblicità


Eliminare getter e setter

Eliminazione di getter e setter non è così semplice come solo eliminare il campo nell'editor. Tuttavia, è possibile eliminare un campo e le sue getter / setter dalla vista Struttura.

Aprire la visualizzazione Struttura ( Alt + Shift + Q, O ), selezionare il campo che si desidera eliminare e premere il tasto Delete (o tasto destro del mouse, Elimina). Eclipse vi chiederà se si desidera eliminare i getter / setter pure. Basta scegliere Sì tutti e saranno rimossi.

È necessario disporre di campi visibili nella vista Struttura per utilizzare questa funzione (cioè untoggle il pulsante Nascondi Fields ).



È possibile selezionare più campi contemporaneamente. Ed è possibile eliminare singoli getter / setter (escluso il settore), sia selezionando il getter / setter e premendo Elimina .

martedì 8 luglio 2014

Vai a inizio e fine di metodi, cicli, blocchi e tag XML

Saggezza comune dice che dovremmo tenere i nostri metodi piccola ed evitare nidificato se dichiarazioni e cicli nidificati. Ma ho visto alcuni metodi enormi (1000 di linee) e il codice che includeva un caso in una , mentre in una di ciclo in se .
Il problema è trovare dove inizia blocco e dove finisce (cioè dove sta aprendo e staffe di chiusura sono).Inoltre, la maggior parte dei quadri richiedono la configurazione XML, portando a grandi file XML che diventano difficili da navigare, ad es. spostamento tra tags.
Ma, ancora una volta, Eclipse rende facile saltare tra l'apertura e chiusura staffe / tags utilizzando un tasto.
Vai a una staffa di corrispondenza
Ecco come saltare tra parentesi corrispondenza nei metodi, loop, se le dichiarazioni e qualsiasi blocco in generale:
  1. (Non richiesto per Eclipse 4.2): Posizionare il cursore dopo sia l'apertura o la parentesi di chiusura del blocco siete interessati poll (Sarebbe stato più bello per Eclipse per passare alla staffa più vicino da qualsiasi posizione si è, ma ahimè non è così. Infatti, Eclipse 4.2 lo fa automaticamente in modo che il desiderio viene esaudito.)
  2. Premere Ctrl + Maiusc + P . Eclipse si prende subito dopo la parentesi aperta corrispondente / chiusura.
Suggerimento: Questo metodo funziona per le staffe di argomenti così, utile per il metodo di chiamate multilinea con classi interne anonime passate come argomenti.
L'immagine sotto mostra un esempio di dove il cursore deve essere posizionato per saltare alla fine del sedichiarazione.

Vai a un tag corrispondente in XML

Ecco come saltare tra i tag corrispondenti in XML.
  1. Posizionare il cursore sul tag di apertura / chiusura siete interessati poll Può essere ovunque nel tag.
  2. Premere Ctrl + Maiusc +> . Eclipse si porta al tag di apertura corrispondente / chiusura.
L'immagine seguente mostra un esempio di come saltare alla chiusura di proprietà tag.

venerdì 4 luglio 2014

Saltare alcune classi quando si utilizza Step Into nel debugger di Eclipse

Ogni volta che uso la Step Into funzione (F5) in debugger di Eclipse, sono interessati soprattutto a passo tramite il codice nelle mie classi, non quelli provenienti da librerie esterne o addirittura classi Java.
Ad esempio, non c'è quasi alcun motivo per desiderare di entrare nel codice o del proxy classi di primavera (diversi da quelli per saperne di più su di loro o forse il debug di un potenziale bug in primavera).E normalmente io non sono interessato a classi Java util (es. ArrayList). Questo vale anche per Hibernate, Apache Commons, Google e molte altre librerie esterne.
Fortunatamente, Eclipse, è facilissimo specificare quali classi di saltare consentendo filtri passo. Questo rende più facile concentrarsi sul proprio codice e mantiene anche la vostra zona redattore puliti, perché Eclipse non sarà l'apertura classi in editor separati per tutto il tempo.

Abilita Step Filtri

Per utilizzare i filtri step, il primo passo è quello di consentire esso. Eclipse è dotato di alcuni filtri predefiniti quindi cominciamo consentendo loro tutti. Questo filtrerà tutte le classi Java (es. java. * ) e tutte le classi Sun (es. il sole. * ).
  1. Vai a Finestra> Preferenze> Java> Debug> Passaggio filtrante .
  2. Selezionare l'opzione Usa filtri Passo .
  3. Fare clic su Seleziona tutto per consentire a tutti i filtri.
  4. Lasciare le altre opzioni di seguito l'elenco di filtri come-è.
Ecco un esempio di quello che dovrebbe essere simile:
NB: Anche con i filtri attivati ​​passo, si può ancora breakpoint all'interno di una qualsiasi di queste classi set (se avete la fonte) e Eclipse sarà ancora fermarsi al punto di interruzione. Passaggio filtrante influisce solo sul modo in cui Step Into opere.
Si noti inoltre che Eclipse sarà ancora un passo nelle vostre classi se si chiamano dalle classi ignorati. Ad esempio, quando si chiama Collections.sort (List, comparatore) e passare il proprio comparatore diimplementazione, Eclipse non sarà un passo nel codice ordinamento, ma sarà un passo nel tuo comparatore quando viene chiamato dal codice ordinamento.
Se si desidera modificare questo comportamento (cioè impedire Eclipse di fermarsi nel metodo), quindi deselezionate passaggio attraverso i filtri. Comunque, io consiglierei di fare solo questo se hai provato il default, perché il più delle volte probabilmente vi vuole passare tramite il proprio codice.
Il passo successivo è quello di creare dei filtri passo della vostra.

Creare i propri filtri passo

Dopo aver attivato i filtri passo, tutto quello che dovete fare è aggiungere le classi che si desidera filtrare.Supponiamo che vogliamo ignorare tutte le classi di Primavera, in particolare le classi proxy.
  1. Se non siete già lì, vai a Finestra> Preferenze> Java> Debug> Passaggio filtrante .
  2. Fare clic su Aggiungi filtro ... Una finestra dovrebbe apparire che richiede di inserire un pattern.
  3. Inserisci un espressione regolare per le classi che si desidera filtrare in Pattern per filtrare campo quindi fare clic su OK . Nel nostro esempio, immettere org.springframework. * (vedi immagine sotto). E 'più facile per specificare il nome del pacchetto di livello superiore con un asterisco alla fine.
  4. Aggiungi un altro filtro con il pattern Proxy $ * a saltare le classi proxy di primavera (es. quando si utilizza Transazioni primavera).
  5. Fare clic su OK nella finestra di dialogo delle preferenze quando hai finito.
Ecco ciò che il dialogo step del pattern del filtro dovrebbe essere simile:
Ora, quando si utilizza il debugger, non sarete presi in classi primavera, quando si utilizza Step Into (F5).

Alcune idee per filtri personalizzati

Oltre alle classi primavera, si potrebbe anche prendere in considerazione l'aggiunta dei seguenti librerie comuni per i filtri passo per rendere più facile il debug:
  • org.apache. *
  • org.hibernate. *
  • com.google. *
  • org.eclipse. *
  • org.osgi. *
Gli ultimi due sono particolarmente utili se si sta facendo Eclipse RCP e / o sviluppo OSGi.