[JAVA] Utilizzo delle Regular expression

[hetabeta]

buongionro a tutta la comunità, avrei bisogno urgente del vostro aiuto:
sto cercando di finire una funzionalità per l'analisi del codice java del mio progetto e mi ritrovo a dover cercare e segnalare quei files in cui non viene sipettata una certa struttura logica di comandi del tipo

comando;
try{
/* QUALSIASI COSA */
}
finally{
comando;
}
Fino ad ora ho pensato di trasformare l'intero file in stringa per poi applicarci una regular expression che funziona solo per trovare il comando su una riga ma se voglio trovarne l'intera struttura non riesco
Ho provato anche con dei tool di visualizzazione dell'espressione ma non ne vengo a capo, qualcuno di voi può aiutarmi? Sono ovviamente ben accette anche altre forme di soluzione...
Vorrei farvi notare che per ogni file potrebbero esser presenti più istanze di questa struttura.
Grazie di cuore a tutti

[Pacio88]

Premettendo che non ho ben capito che cosa vuoi fare, mi chiedo...
I file che devi cercare sono tutti sorgente?
Ammesso che lo siano trovo "difficile", naturalmente non impossibile, verificare la condizione che ti poni. In quanto una semplice ricerca di campi di testo (try{...}, final{...}) all'interno del file potrebbero scaturire un risultato inaspettato. Per esempio...

...
tutto il codice
...
try {}
finally {}

In questo prototipo di codice la condizione sarebbe verificata ma è palese che sia il blocco try che finally sono inutili ai fine del codice.

Ribadisco comunque che forse ho capito male quali sono le tue intenzioni, ma nel caso invece avessi capito spero di esserti stato di aiuto.

[hetabeta]

Grazie ma forse mi sono espresso male io, l'obiettivo è quello di controllare tutti i sorgenti, per ogni sorgente che utilizza un determinato metodo (apre per intenderci una certa connessione) devo verificare che la stessa connessione (comando) sia chiusa nel finally dunque:

comando
#QUALUNQUE COSA#
Connection.getInstance().getConnection();
#QUALUNQUE COSA#
try {
#QUALUNQUE COSA#
} finally {
Connection.getInstance().closeConnection(conn);
#QUALUNQUE COSA#
}

Spero di eser stato più chiaro, comunque grazie

[Pacio88]

Secondo me allora la difficoltà non sta nel cercare qualcosa all'interno di un blocco try e successivamente nel rispettivo finally, ma piuttosto riconoscere il metodo che deve comparire. Infatti seguendo il tuo esempio dovresti saper catalogare per ogni metodo invocato nel blocco try il corrispettivo metodo che deve essere chiamato nel blocco finally.

P.S. Per curiosità... stai scrivendo questo programma per aiutarti nella scrittura di codici sorgenti?

[hetabeta]

no, non è proprio quello che pensi, sto cercando di fare un'utility per migliorare la qualità del codice dei sorgenti.
Tornando al problema a me non interessa cosa succede nel try o nel catch, l'importante è che se apro una connessione la richiudo (mi serve che stia nel finally perchè se si genera qualche eccezzione comunque la devo richiudere).
Riesco fino ad ora a creare la regular expression per cercare le istanze di apertura della connessione ma non quella di chiusura.
La logica applicata finora è:
- leggo il file
- lo trasformo in unica stringa
- verifico se viene aperta una connessione e se aperta verifico che sia chiusa nel finally

Per verificare l'apertura uso:
Connection\\.getInstance\\(\\)\\.getConnection
per la chiusura
Connection\\.getInstance\\(\\)\\.getConnection" +
".*try.*\\{.*\\}.*" +
"finally.*\\{.*" +
"connection\\.getinstance\\(\\)\\.closeConnect ion
ma il risultato aspettato non è corretto, basta che ne trova ( o non ne trova) uno e il match vale per tutto il codice restante

[andbin]

Originariamente inviato da hetabeta
Connection\\.getInstance\\(\\)\\.getConnection" +
".*try.*\\{.*\\}.*" +
"finally.*\\{.*" +
"connection\\.getinstance\\(\\)\\.closeConnect ion

.* è "greedy", ovvero cerca la sequenza più lunga, non quella più corta. Usa .*? che è "reluctant" ovvero cerca la sequenza più corta.

[hetabeta]

Originariamente inviato da andbin
.* è "greedy", ovvero cerca la sequenza più lunga, non quella più corta. Usa .*? che è "reluctant" ovvero cerca la sequenza più corta.

grazie, ho provato a sostiure .* con .? ma purtroppo il risultato non cambia :master:

per comodità posto il codice incriminato

//trasformo il file in stringa
String fileContent = readFile(file);
if (!"".equals(fileContent)) {

// ricerca se nel file viene utilizzata la connessione
String pat = OPEN_SYNTAX;

Pattern pattern = Pattern.compile(pat, Pattern.CASE_INSENSITIVE | Pattern.DOTALL | Pattern.MULTILINE);
Matcher matcher = pattern.matcher(fileContent);

if (matcher.find()) {
for (int i = 0; i < matcher.groupCount(); i++) {
//stringa che rappresenta il patter suggerito
String pat1 = SYNTAX_BLOCK1;
Pattern pattern1 = Pattern.compile(pat1,Pattern.CASE_INSENSITIVE| Pattern.MULTILINE |Pattern.DOTALL);
Matcher matcher1 = pattern.matcher(fileContent);
if (!matcher1.matches()) {
System.out.println("++++++++++++++ FILE: " + file.getPath());
break;
}
}
}
}