Revisione codice Procedure ottimali J2EE

La revisione codice Procedure ottimali J2EE consiste in una sola categoria; essa è anche denominata Procedure ottimali J2EE.

Scopo

La revisione codice Procedure ottimali J2EE applica regole per individuare anti-schemi nel codice che sono molto difficili da individuare con mezzi comuni. Gli anti-schemi sono problemi noti che si verificano nel codice e che non seguono le procedure ottimali. Mentre gli schemi di progettazione sono modelli validi e da seguire, gli anti-schemi sono modelli errati e da evitare. Tali anti-schemi possono causare gravi diminuzioni delle prestazioni o blackout di sistema. Questa revisione codice viene eseguita solo sui servlet. I servlet devono essere in progetti Web dinamici indirizzati a uno dei seguenti stub:
  • WebSphere Application Server 5.0
  • WebSphere Application Server 5.1
  • WebSphere Application Server 6.0

Non sono supportati JSP, strut e EJB.

Alcune regole nella revisione codice richiedono analisi del flusso di dati per individuare alcuni risultati. L'analisi del flusso di dati registra il percorso di un risultato. Di conseguenza, la revisione del codice richiede più tempo quando vengono applicate tali regole.

Categorie di regole

La seguente tabella elenca tutte le categorie e sottocategorie nella revisione codice Prestazioni ottimali J2EE, insieme alla descrizione delle regole in ciascuna di esse. Nella colonna a sinistra, le categorie sono in grassetto e le sottocategorie in testo normale.

Categoria o sottocategoria Descrizione
Procedure ottimali J2EE Contiene regole basate sulle procedure ottimali di sviluppo J2EE e supporta i progetti Web destinati a server WebSphere
Correttezza Contiene regole per rilevare chiamate ai metodi non corrette
Velocità dati Contiene regole per rilevare chiamate dei metodi che possono determinare le condizioni della velocità dati nelle applicazioni J2EE
Raccolta dei dati non utilizzati Contiene regole per rilevare chiamate dei metodi che possono ritardare la raccolta dei dati non utilizzati
Gestibilità Contiene regole per rilevare un codice che può essere difficile da gestire nelle applicazioni J2EE
Prestazione e scalabilità Contiene regole per rilevare chiamate ai metodi che ostacolano le prestazioni o limitano la scalabilità di un'applicazione J2EE
Gestione risorse Contiene regole di procedure ottimali J2EE per utilizzare risorse in applicazioni J2EE

Tipi di regole

La revisione codice Procedure ottimali J2EE applica regole che sono di due tipi: regole rapide e regole profonde. Le caratteristiche che distinguono i tipi di regole sono la quantità di tempo richiesta perché vengano applicate e il tipo di informazioni che presentano in un risultato.

Regole J2EE rapide

Le regole J2EE rapide richiedono meno tempo per essere applicate nella revisione codice Procedure ottimali J2EE rispetto alle regole profonde. Le regole rapide presentano le stesse informazioni per un risultato rispetto alle regole nelle altre revisioni codice.

Regole J2EE profonde

Le regole J2EE profonde richiedono l'analisi del flusso di dati, per cui impiegano più tempo per produrre risultati rispetto alle regole rapide. Le regole J2EE profonde non solo producono risultati, ma mostrano anche i percorsi che conducono ai risultati. Tali regole richiedono l'analisi del flusso dei dati, il metodo che registra i percorsi, per cui impiegano più tempo per produrre risultati rispetto alle regole rapide. Le regole profonde forniscono le seguenti informazioni aggiuntive:

Elenco regole J2EE profonde

Esistono 36 regole J2EE profonde. La colonna sinistra della seguente tabella elenca le sottocategorie che le contengono. La colonna destra elenca o descrive quali regole nella sottocategoria sono regole J2EE profonde.

Categoria o sottocategoria Regola J2EE profonda
Correttezza
Non memorizzare oggetti che non implementano java.io.Serializable in javax.servlet.http.HttpSession
Velocità dati
Non assegnare al servlet campi di istanze, da javax.servlet.Service.service(), senza 
utilizzare un blocco condiviso
Prestazione e scalabilità
Richiamare sempre javax.servlet.http.HttpSession.invalidate() in seguito a javax.servlet.http.HttpServletRequest.getSession()
Gestione risorse Tutte le 32 regole in questa sottocategoria sono regole J2EE profonde.

Esempi di regole

Questa sezione contiene un esempio di ciascun tipo di regola che viene applicata nella Revisione codice Procedure ottimali J2EE.

Esempio di regola rapida

La seguente regola rappresenta un esempio di regola rapida della sottocategoria Prestazione e scalabilità.

Non richiamare java.lang.Runtime da un servlet

Esempio di regola profonda

La seguente regola rappresenta un esempio di regola profonda della sottocategoria Gestione risorse.
Richiamare sempre java.io.FileInputStream.close() in seguito a una nuovaj ava.io.FileInputStream(java.io.File)

Problemi noti

Questa sezione documenta i problemi noti con la Revisione codice Procedure ottimali J2EE.

Falso positivo: un flusso di input non è stato chiuso

Riepilogo: la Revisione codice Procedure ottimali J2EE produce un risultato che indica che un flusso di input non è stato chiuso. In realtà, non esiste un altro flusso di input da chiudere.

Descrizione: la revisione codice non riconosce che tutti i flussi di input sono chiusi nelle seguenti situazioni:
  • Se bis è null, non esiste alcun flusso di input da chiudere
  • Viene utilizzato un flusso di input, FileInputStream, per crearne un secondo, BufferedInputStream. Quando il secondo flusso di input viene chiuso, viene chiuso anche il primo.
Spiegazione: le righe evidenziate nel seguente esempio di codice illustrano entrambe le situazioni:
public static int readFirstByte(String fileName) {
 int firstByte = -1;
 FileInputStream fis=null;
 BufferedInputStream bis = null;
 try {
  fis = new FileInputStream(fileName);
  bis = new BufferedInputStream(fis);  firstByte = bis.read();
 } catch (FileNotFoundException fnfe) {
  LogUtility.log(fnfe);
 } catch (IOException ioe) {
  LogUtility.log(ioe);
 } finally {
  if (bis!=null){   try {
    bis.close();   } catch (IOException ioe){
    LogUtility.log(ioe);
   }
  }
 }
 return firstByte;
} 

Soluzione provvisoria: fare clic con il pulsante destro del mouse sul risultato e fare clic su Ignora.

Informazioni insufficienti: il risultato viene riportato rispetto a un file .classpath

Riepilogo: la Revisione codice Procedure ottimali J2EE produce un risultato sul file .classpath anziché su una risorsa del workbench.

Descrizione: la revisione codice rileva un problema con un tipo binario, che non ha una risorsa corrispondente nel workbench perché è contenuto in un JAR esterno.

Riferimenti: RFE RATLC00038795

Soluzione provvisoria:

  1. Nella vista Dettagli revisione codice, fare clic sulla scheda Percorsi per verificare quale tipo non ha una risorsa corrispondente nel workbench.
  2. Espandere le informazioni del percorso per visualizzare i nomi dei tipi, e possibilmente metodi e campi, implicati nel risultato.

Filtri risorsa: non hanno effetto per regole profonde

Riepilogo: nella pagina Filtri risorsa vengono specificati i file per cui non si desidera applicare una regola profonda durante una revisione codice. Tuttavia, il filtro non funziona e la regola viene ancora applicata ai file specificati.

Descrizione: le regole J2EE profonde lavorano in maniera differente quando specificano file per cui non si desidera che una regola venga applicata durante una revisione codice. Le regole profonde non riconoscono file specificati nella pagina Filtri risorsa, ma riconoscono file nella pagina Escluso, dove per impostazione predefinita sono elencati file JAR. Tali regole riconoscono due tipi di file da escludere, un servlet completamente qualificato o un file JAR, e ignorano tutti gli altri.

Soluzione provvisoria:
  1. Fare clic su Finestra > Preferenze per aprire la finestra Preferenze.
  2. Nel riquadro a sinistra, espandere Java e Revisione codice, quindi selezionare Escluso.
  3. Nella pagina Escluso, esaminare i file elencati nella pagina Risorse ed effettuare una delle seguenti operazioni:
    • Se il file da escludere dalla revisione con regole J2EE profonde è presente nell'elenco, fare clic su OK. Non è necessario eseguire ulteriori operazioni.
    • Per escludere un servlet dalla revisione con regole J2EE profonde, selezionare il file .java o .class del servlet e fare clic su OK.
    • Per escludere un file JAR dalla revisione con regole J2EE profonde, selezionare il file JAR e fare clic su OK.
Se nell'elenco è presente un file che non si desidera escludere dalla revisione codice, selezionare il file e fare clic su Rimuovi.
Termini di utilizzo | Feedback
(C) Copyright IBM Corporation 2000, 2005. Tutti i diritti riservati.