Premetto che era partito come un esercizio,volevo esercitarmi un po' sui metodi ricorsivi,poi la cosa mi ha preso un po' di piu' perche' c'era quel problema che ho risolto grazie a Doch88 nella discussione Strano errore,sempre in questa sezione,allora ora che ho risolto,ho pensato di dare un nome,esportare in un jar e uppare sul foro
...
Il programmino e' abbastanza semplice,dato appunto che e' nato come semplice esercizio,il piu' si basa sulla ricorsivita',partendo da una path iniziale mostra tutti i files contenuti in quella path,se trova nella path directory,elenca tutti i files di quella directory,cosi via per ogni directory e sottodirectory varie che trova...
l'utilizzo e' molto semplice...
CODICE
java -jar J-FileDetected.jar -h
per avere l'help
In particolare l'utilizzo e':
CODICE
java -jar J-FileDetected.jar "Path di partenza" -C
oppure
CODICE
java -jar J-FileDetected.jar "Path di partenza" -F
(-f e -c sono case insensitive)
la diffenza fra -c e -f e' che -c mostra l'output in consolle,mentre -f salva su un file (il file verra' creato nella directory dove risiede il file .jar)
Sorgenti:
si divide in 2 classi,la prima si chiama Detected che e' quella che gestisce le funzioni ricorsive ed implementa altri metodi utili,la seconda si chiama MainClass,che e' la classe di alto livello,contiene il main,gestisce un oggetto Detected e gestisce eventuali errori,etc..
ecco i codici...
Detected
CODICE
import java.io.File;
import java.io.IOException;
/**
* Questa classe gestisce la funzione il controllo
* della struttra di una determinata path
* La classe permette di analizzare una directory
* e tutte le sue sottodirectory.
*
* @author -AsCiA-
*
*/
public class Detected {
//-------------------------
//--------VARIABILI--------
//-------------------------
//Errori durante la lettura di alcuni file(corrotti/protetti)
private int iErrorFileRead = 0;
//-------------------------
//---------OGGETTI---------
//-------------------------
//File o directory di partenza
private File oFile;
//StringBuffer che conterra' il risultato dell'operazione
private StringBuffer oStringBuffer = new StringBuffer("");
//-------------------------
//-----COSTRUTTORRE--------
//-------------------------
/**
* Costruttore unico della classe.
* Si puo' instanziare un oggetto di questa
* classe utilizzando questo costruttore.
* <br/>
* @param oFile <br/>
* Path di partenza.<br/>
*
* @throws IOException <br/>
* Viene sollevata questa eccezione se il file
* o la directory non esiste o non puo'
* essere aperto.
*/
public Detected(File oFile) throws IOException {
//Setto il file o la directory di partenza
setFile(oFile);
}
//-------------------------
//------METODI PUBBLICI----
//-------------------------
//---------------------------METODI SET--------------------------------//
/**
* Questo metodo permette di settare
* il file o la directory di partenza.
* <br/>
* @param oFile <br/>
* File o directory da settare.
*
* @throws IOException <br/>
* Viene sollevata questa eccezione se il file
* o la directory non esiste o non puo'
* essere aperto.
*/
public void setFile(File oFile) throws IOException {
if(!oFile.exists()) throw new IOException();
this.oFile = oFile;
}
//---------------------------METODI GET------------------------------//
/**
* Questo metodo restituisce
* il file o la directory di
* partenza.
*/
public File getFile(){
return oFile;
}
//-----------------------------------------------------------------//
/**
* Questo metodo restituisce
* il valore degli errori
* occorsi durante la lettura
* del file.
*/
public int getErrorFileRead(){
return iErrorFileRead;
}
//----------------------------METODI VARI----------------------------//
/**
* Questo metodo inizializza il processo
* di analisi e restituisce il risultato
* dell'operazione.
* <br/>
* @return String <br/>
* Restituisce il risultato dell'operazione
* <br/>
* @throws IOException
*/
public String detected() throws IOException{
iErrorFileRead = 0;
return recursiveFunction(getFile());
}
//-------------------------
//------METODI PRIVATI-----
//-------------------------
/**
* Metodo principale della classe.<br/>
* Questo metodo e' basato principalmente sulla
* ricorsivita'.<br/>
* E' necessario passare come parametro al metodo
* la path da analizzare.
* Se la path risulta essere un file,viene inserito
* il suo nome nella stringa che sara' restituita,
* altrimenti,se la path risultera' essere una
* directory,il metodo si autorichiamera' impostando
* come path,la directory appena trovata.
*
* @param oFile <br/>
* Path di partenza; </br>
*
* @return String <br/>
* Il metodo restituisce una stringa contenenete
* tutte le informazioni estratte.
* La formattazione della stringa e' data dalla
* posizione di vari files all'interno delle
* rispettive directory.
*
* <br/>
*
* @throws IOException <br/>
* Viene sollevata questa eccezione se il file
* o la directory non esiste o non puo'
* essere aperto.
*/
private String recursiveFunction(File oFile) throws IOException {
String[] sFileList;
String pathname = oFile.getAbsolutePath();
//Se e' un file,memorizzo il suo nome nella stringa da restituire.
if(oFile.isFile()){
oStringBuffer.append(oFile.getName()+'\n');
}
/*
* Se e' una direcoty e non e' un collegamento simbolico,
* memorizzo nella stringa da restituire il suo percorso e
* ottengo la lista di file nella direcoty stessa.
* Per ogni file contenuto nella directory richiamo questo
* metodo per analizzarlo.
*/
else if(oFile.isDirectory() && !isSymlink(oFile))
{
oStringBuffer.append(""+'\n');
oStringBuffer.append("DIR---->" + oFile.getPath()+'\n');
sFileList = oFile.list();
for(int i=0; i<sFileList.length; i++){
try{
File nextFile = new File(pathname +File.separator+sFileList[i]);
recursiveFunction(nextFile);
}
//In caso di errore aumento di 1 l'apposita variabile di istanza e memorizzo nella stringa da restituire
catch (Exception e) {
oStringBuffer.append("One process error occured here"+'\n');
addErrorFileRead(1);
}
}
}
return oStringBuffer.toString();
}
//-----------------------------------------------------------------//
/**
* Questo metodo viene utilizzato per controllare
* se il file e' un collegamento simbolico.
* <br/>
* <b><u> @author Apache <u></b>
* <br/>
* @return boolean
* <br/>
* @throws IOException <br/>
* Viene sollevata questa eccezione se il file
* o la directory non esiste o non puo'
* essere aperto.
*/
private boolean isSymlink(File file) throws IOException {
if (file == null)
throw new NullPointerException("File must not be null");
File canon;
if (file.getParent() == null) {
canon = file;
} else {
File canonDir = file.getParentFile().getCanonicalFile();
canon = new File(canonDir, file.getName());
}
return !canon.getCanonicalFile().equals(canon.getAbsoluteFile());
}
//-----------------------------------------------------------------//
/**
* Questo metodo incrementa la variabile
* intera degli errori occorsi durante
* la lettura del file.
* <br/>
*
* @param iValue <br/>
* Valore del quale incrementare
*/
private void addErrorFileRead(int iValue){
int iActualValue = getErrorFileRead();
int iNewValue = iActualValue + iValue;
iErrorFileRead = iNewValue;
}
}
MainClass
CODICE
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;
public class MainClass {
//-----------------------------------------------------//
//---------------------METODO MAIN---------------------//
//-----------------------------------------------------//
public static void main(String[] args) {
MainClass oMain = new MainClass();
//Switch intero per l'output
int iOutputSwitch;
//Controllo i parametri inseriti
int insertParamsValue = oMain.paramsIsOk(args);
//I numero di parametri e' errato
if(insertParamsValue == -1)
{
System.out.println(oMain.getErrorMex());
System.exit(1);
}
//Il parametro e' la richiesta di help
if(insertParamsValue == 1)
{
System.out.println(oMain.getHelpMex());
System.exit(1);
}
//Il numero di parametri e' esatto
if(insertParamsValue == 0)
{
//Controllo la richiesta di output
iOutputSwitch = oMain.outputType(args[1]);
//Il paramtro e' errato
if(iOutputSwitch == -1)
{
System.out.println(oMain.getErrorMex());
System.exit(1);
}
try {
File oFile = new File(args[0]);
Detected oDetected = new Detected(oFile);
System.out.println("---------------------------------------------");
System.out.println(oMain.S_APP_NAME+" PROCESS START...");
System.out.println("");
System.out.println("THE DURATION OF THE PROCESS DEPENDS \nON THE SIZE OF THE SELECTED DIRECTORY");
System.out.println("---------------------------------------------");
System.out.println("");
oMain.output(iOutputSwitch, oDetected.detected());
System.out.println("");
System.out.println("---------------------------------------------");
System.out.println(oMain.S_APP_NAME+" PROCESS AS BEEN COMPLETE...");
System.out.println("");
System.out.println("PROCESS ERROR ==> "+ oDetected.getErrorFileRead());
System.out.println("");
System.out.println("*The process errors are the files that is \n not possible to read, this may result from file \n corrupt and/or protected");
System.out.println("--------------------------------------------");
}
catch(IOException e){
System.out.println(oMain.S_APP_NAME+": Impossibile analizzare la path specificata.");
System.exit(1);
}
}
}
//-----------------------------------------------------//
//-----------------------OGGETTI-----------------------//
//-----------------------------------------------------//
//Oggetto data
Date oDate = new Date();
//-----------------------------------------------------//
//---------------------VARIABILI-----------------------//
//-----------------------------------------------------//
//Formato stringa della data odierna
private String sNowDate = oDate.toString().replace(":", ".");
//-----------------------------------------------------//
//----------------------COSTANTI-----------------------//
//-----------------------------------------------------//
//Nome dell'applicazione
public final String S_APP_NAME = "J-FileDetected";
//Nome dell'evntuale file sul quale salvare l'output
private final String S_FILE_OUT_NAME = S_APP_NAME + "_" + sNowDate;
private final String S_FILE_OUT_PATH = System.getProperty("user.dir")+File.separator + S_FILE_OUT_NAME + ".txt";
//-----------------------------------------------------//
//--------------------ALTRI METODI---------------------//
//-----------------------------------------------------//
/**
* Questo medoto controlla i parametri inseriti e
* restituisce un intero corrispondente al
* risultato del controllo
* <br/>
* @param String[] <br/>
* Rappresenta l'array di parametri da controllare.
* <br>
* @return int: <br/>
* -1 Errore <br/>
* 0 OK <br/>
* 1 Richiesta di help <br/>
*/
public int paramsIsOk(String[] sArgs){
if(sArgs.length < 1) return -1;
if(sArgs.length > 2) return -1;
if(sArgs.length == 1)
{
if(sArgs[0].equals("-h")) return 1;
else return -1;
}
return 0;
}
//-----------------------------------------------------//
/**
* Questo metodo controlla il tipo di parametro
* impostato per l'output. <br/>
*
* <br/>
* @param sParamValue <br/>
* Parametro inserito dall'utente
*
* @return int <br/>
* Rappresenta il tipo di output selezionato: <br/>
*
* 1 output su consolle; <br/>
* 2 output su file; <br/>
* -1 parametro non valido; <br/>
*
*/
public int outputType(String sParamValue){
if(sParamValue.equalsIgnoreCase("-c")) return 1;
if(sParamValue.equalsIgnoreCase("-f")) return 2;
return -1;
}
//-----------------------------------------------------//
/**
* Questo metodo gestisce l'output del risultato in base
* al paramtero passato come argomento.
* <br/>
* @param iType <br/>
* Intero - rappresenta il tipo di output da applicare.
* <br/>
* @param sArgToWrite <br/>
* Stringa di output.
*
* @throws IOException <br/>
* In caso si scelga di scrivere su file e il file di output
* non puo' essere aperto viene sollevata questa eccezione.
*
*/
public void output(int iType,String sArgToWrite) throws IOException{
if( iType == 1){
System.out.print(sArgToWrite);
}
if(iType == 2)
{
File oFileCreated = new File(S_FILE_OUT_PATH);
FileWriter oFileWriter;
PrintWriter oWriter;
oFileWriter = new FileWriter(oFileCreated);
oWriter = new PrintWriter(oFileWriter);
oWriter.append(sArgToWrite);
oWriter.flush();
oWriter.close();
}
}
//-----------------------------------------------------//
/**
* Restituisce il messaggio di errore
*/
public String getErrorMex(){
return "Invalid call. Use -h for get help";
}
//-----------------------------------------------------//
/**
* Restituisce il messaggio di aiuto
*/
public String getHelpMex(){
String sMsg = "\n";
sMsg = sMsg + "---------------------------------------------------------------------------- \n";
sMsg = sMsg + S_APP_NAME + " HELP: \n";
sMsg = sMsg + "To use this program you must specify 2 parameters \n";
sMsg = sMsg + "On order: \n";
sMsg = sMsg + "1) Path to start \n";
sMsg = sMsg + "2) -c OR -f \n";
sMsg = sMsg + "-c ==> Outoput on Consolle \n";
sMsg = sMsg + "-f ==> Outoput on File, (the file will be created in the program dir)\n";
sMsg = sMsg + "---------------------------------------------------------------------------- \n";
sMsg = sMsg + " \n";
return sMsg;
}
}
Infine ecco il file jar
Edited by -AsCiA- - 5/10/2011, 00:12
