HSSFWorkbook als Return-Wert für Input in andere Methode

[astramare]

wie / kann man das wb als type oder String aus der Methode in eine andere übergeben / übernehmen?

Hintergrund: ich will aus oracle heraus einzelne Zellen anhand extern vorliegender Zuordnungen für Zeile / Spalte / Sheet auslesen, dies funktioniert ,
wobei jedoch jedesmal per url-Stream usw. das gesamte wb geöffnet, die eine Zelle ausgelesen dann das wb / fs wieder geschlossen und der Zellwert in der DB mit einer vorhandenen procedure verarbeitet wird.

um bei der nachfolgenden Abfrage wieder alles zu öffnen , auszulesen , und zu schließen.
Dies braucht logischerweise viel Zeit.

Gibt es also einen Weg, das wb einmal zu öffnen, dann jeweils bestimmte Zellen auszulesen wobei jedesmal die Zeile / Spalte / sheet extra übergeben werden können
und zum Ende gesamt das wb/ fs zu schliessen.

die println - ausgabe des wb als String ( siehe unten ) erzeugt soetwas wie
"org.apache.poi.hssf.usermodel.HSSFWorkbook@9ac5d3f6"
dies müsste bei einem geöffneten wb doch weiter verarbeitbar sein , oder ?


public static String StartNow_OpenUrl ( String URLPath ) throws SQLException
{
Connection conn = DriverManager.getConnection("jdbc:default:connection:");

String RetWb = "null";


String remoteURL = new String(URLPath);

try
{
URL url = new URL(remoteURL);
InputStream is = url.openStream();

POIFSFileSystem fs = new POIFSFileSystem( is );
HSSFWorkbook wb = new HSSFWorkbook(fs);

// anzeige zb:
// 100 StartNow_OpenUrl wb= org.apache.poi.hssf.usermodel.HSSFWorkbook@9ac5d3f6
System.out.println("100 StartNow_OpenUrl wb= "+wb );

//is.close();


}

catch (Throwable ew) {
ew.printStackTrace(System.out);
}


//return wb ;
return "wb" ; // normaler String wird ok zurück gegeben

}

 

[nrg]

das Ganze vllt nicht statisch programmieren.
Eine Klasse, die im Konstuktor die Connection etc. als Attribute initialisiert und eine doIt() und eine close() Methode.
Methoden- und Variablennamen (ausser Konstanten) schreibt man übrigens klein

 

[astramare]

danke, heisst dies, dass auf das Objekt wb eine nicht-statische Methode gesetzt wird
in der Art callNonstatic / doSomething ( s. unten )


public static void startNow ( String urlpath ) throws SQLException
{
Connection conn = DriverManager.getConnection("jdbc:default:connection:");

String remoteURL = new String(urlpath);

try
{
URL url = new URL(remoteURL);
InputStream is = url.openStream();

POIFSFileSystem fs = new POIFSFileSystem( is );
HSSFWorkbook wb = new HSSFWorkbook(fs);
System.out.println("100 tt wb= "+wb );
}
catch (Throwable ew) {
ew.printStackTrace(System.out);
}
}


public static String getCellValue( HSSFCell cell , String cellType )
{
String str;
// funktionierender Code für return Cell-Value als String ....

return str ;
}

public static String callNonstatic ( String sheetName, int pCol, int pRow )
{
wb.doSomething();
// auslesen wb ? return ?
return ?? ;
}

public String doSomething()
{
// nicht-statische Methode

System.out.println( "Hallo " );

// auslesen wb ?
// ...
String RetCellValue = "null";
HSSFSheet sheet = wb.getSheet(sheetName);
HSSFRow Row = sheet.getRow(pRow);
HSSFCell Cell = Row.getCell((short)pCol);
RetCellValue = getCellValue(Cell, cellType ) ;

return RetCellValue ;
}

// ---------------------------------------------------------

ich habe jetzt ( als 'Anfänger' ) eine menge dazu gelesen und probiert,
doch ist mir nicht klar, wie bekomme ich wb nach callNonstatic
und wenn, wie bekomme ich den returnwert zurück,
den ich ja haben will ?

 

[nrg]

kann dir jetzt nicht mit einem kompilierbaren beispiel dienen aber kann dir mal zeigen, wie ich das meine (vllt verstehe ich dich auch falsch)

public class DeineConnection {
	
	private Connection conn;
	// Deine weiteren Attribute
	// private POIFSFileSystem fs;
	// private HSSFWorkbook wb;
	
	public static void main(String[] args) throws SQLException {
		DeineConnection dc = new DeineConnection( "bla" );
		dc.doSomething(); // Zeile lesen
		dc.doSomething(); // Zeile lesen
		dc.doSomething(); // Zeile lesen
		dc.doSomething(); // Zeile lesen
		dc.doSomething(); // Zeile lesen
		dc.doSomething(); // Zeile lesen
		dc.close();
	}
	public DeineConnection( String urlpath ) throws SQLException {
		this.conn = DriverManager.getConnection("jdbc:default:connection:");
		// fs und wb etc. intialisieren
		// ....
	}
	public String doSomething() {
		// blablabla
		return "deineZeile";
	}
	public void close() throws SQLException {
		conn.close();
	}

}

ausserdem benutze bitte javatags

 

[astramare]

ja, es ist denke ich etwas anders gedacht,


alles zusammen über einen einzigen aufruf funktioniert,
das habe ich vorliegen,jedoch

der weitere hintergrund ist der,
dass es eine vorhandene programmmstruktur in plsql gibt,
aus der die excelverarbeitung angesprochen wird,
dies soll ( in einem ersten schritt ) möglichst 1:1 auf java umgestellt werden,
dh. die klassen / methoden - aufrufe werden in plsql - funktionen gekapselt
und so per plsql aufgerufen.

es sollen also folgende drei insofern eigenständige schritte
( plsql bzw. methoden-aufrufe ) abgebildet werden:

1. öffnen des stremas / wb
( eigenständige erster plsql-aufruf / klasse / methode )

2.1 auslesen einer zelle
( über eine zweiter plsql-aufruf / klasse / methode,
wobei auf den geöffneten wb aus 1 zugegriffen wird )

ggf. weitere aufrufe zum auslesen einer zelle
2.2 ... 2.x


3. schliessen des wb / streams
( eigenständige dritter plsql-aufruf / klasse / methode )


ich will also die unten stehende methode GetCellValueJava 'auseinander teilen' ,
wobei der bezug auf fs und wb untereinander erhalten bleiben muss.

  public static String GetCellValueJava ( String pUrlPath, String pSheetName , int pCol , int pRow , String pCellType  )throws SQLException
  {
    //Connection conn =   DriverManager.getConnection("jdbc:default:connection:");
    
    // erster schritt:
    String retCellValue = "null";
  	String remoteURL = new String(pUrlPath);

      try
      {
        URL             url   = new URL(remoteURL);
        InputStream     is    = url.openStream();

		POIFSFileSystem fs 	  = new POIFSFileSystem(is);
		HSSFWorkbook    wb 	  = new HSSFWorkbook(fs);

		//----------------------------------------------------------------
		// anfang auslagern als autonome methode / klasse / plsql-funktion
		//
		// verfahrens-stand dieser klasse / methode ist, dass jeweils für eine cell-abfrage der gesamte wb
		// geladen, die eine zelle ausgelesen und der gesamte wb wieder geschlossen wird
		// dies funktioniert aus forms/plsql heraus ok, dauert jedoch und logischerweise sehr lange ;-(
		//
		// da die umgebung ( vorerst ) beibehalten werden soll wäre das ziel
		// ziel: einmaliges öffnen des wb
		// nacheinander auslesen über forms/plsql-funktion jeweils einer einzelnen zelle auf basis des ( bereits ) geöffneten wb
		// und somit innerhalb einer session
		// zum schluss wieder schließen des wb / stream
		//
		// zweiter schritt(e):
		// ------------------------------------------------------------------------
		HSSFCell cell = wb.getSheet(pSheetName).getRow(pRow).getCell((short) pCol);
 		retCellValue  = getCellValue(cell, pCellType ) ;
		// ------------------------------------------------------------------------
 		//
 		// ende auslagern als autonome methode / klasse / plsql-funktion
 		// --------------------------------------------------------------
          
 		// dritter schritt :
        is.close();
      }
	  catch (Throwable ew) {
	  ew.printStackTrace(System.out);
	  }
    return retCellValue;
  }
}

 

[astramare]

ich habe die Anforderungen lösen können, letztendlich in dieser form ( Ausschnitt der Klasse )

// ....
  private static FileInputStream fis;
  private static InputStream     is;
  private static POIFSFileSystem fs;
  private static HSSFWorkbook    wb;
  private static HSSFSheet       sh;
  private static HSSFRow         rw;
  private static HSSFCell        cl;


  // öffnen xls-Datei aus dem File-System :
  public static HSSFWorkbook excelStartNowFile (String pFilePath )throws SQLException
  {
    //Connection conn =   DriverManager.getConnection("jdbc:default:connection:");
      try
      {
      fis = new FileInputStream(pFilePath);
      fs  = new POIFSFileSystem(fis);
	  wb  = new HSSFWorkbook(fs);

      }
	  catch (Throwable ew) {
	  ew.printStackTrace(System.out);
	  }
    return wb ;
  }
  
//  .....

  // aufruf auslesen einer einzelnen zelle aus sheet, spalte, zeile und datenTyp :
  public static String GetCellValue ( String pSheetName , int pCol , int pRow , String pCellType  )throws SQLException
  {
    //Connection conn =   DriverManager.getConnection("jdbc:default:connection:");
    String retCellValue = "null";
      try
      {

		 cl = wb.getSheet(pSheetName).getRow(pRow).getCell((short) pCol);
		 retCellValue  = getCellValue(cl, pCellType ) ;   // extra methode getCellValue 

      }
	  catch (Throwable ew) {
	  ew.printStackTrace(System.out);
	  }
    return retCellValue;
  } 

//   ......