# Datensatz einfügen und quittierung



## chipmount (27. Nov 2004)

Hi
ich möchte folgendes machen :
Einfügen eines vollständigen Datensatzes in die tabelle und quittieren des erfolgreich abgeschlossenen Vorgangs

mein programm sie wie folgt aus:

```
....
Connection c = null; 
    PreparedStatement p = null;
  public DBManagerImpl()
  {
    super();

    String bestnr = "" ;
    String name = "" ;
    String bestelldatum = "" ;
    try {
    	
      Class.forName ("oracle.jdbc.driver.OracleDriver"); 
      c = DriverManager.getConnection("jdbc:oracle:thin:@:1521:", "", "");
      p = c.prepareStatement( 
        "INSERT INTO Bestellung(bestnr, name, bestelldatum)VALUES(?,?,?) "
       );
      
      p.setString(1,bestnr);
      p.setString(2,name);
      p.setString(3,bestelldatum);
      p.executeUpdate();
    }
    catch (Exception e) 
    { 
      e.printStackTrace(); 
    } 
    finally 
    { 
      if(p!=null) { try { p.close(); } catch(Exception e){}} 
      if(c!=null) { try { c.close(); } catch(Exception e){}} 
    } 
  }
}
```

wie geht es denn mit dieser quittierung hat oracle oder jdbc eine funktion die abfragt ob vorgang erfolgreich abgeschlossen worden ist???

hat jemand ein tipp für mich??

danke


----------



## Guest (27. Nov 2004)

```
Connection c=null;
boolean commit = false;
try
{
  c = DriverManager.getConnection(...);
  c.setAutoCommit(false);
  ...

  commit = true;
}
catch(Exception e)
{
  // Fehler loggen
}
finally
{
  if(c != null)
  {
    try
    {
      if(commit)
        c.commit();
      else
        c.rollback();
      c.close(); 
    } 
    catch(Exception e)
    {
      // Fehler loggen
    }
  }
}
```


----------



## akira (27. Nov 2004)

Hi,

was meinst Du mit quittieren? Die Methode


```
p.executeUpdate();
```

liefert ein int zurück, welches aussagt, wievele Zeilen geändert wurden.
Wenn Du einen Datensatz einfügst, sollte 1 zurückgegeben werden.

Ansonsten ist das Statement erfolgreich, wenn *keine* SQLException geworfen wird.


----------



## abollm (27. Nov 2004)

akira hat gesagt.:
			
		

> ...
> was meinst Du mit quittieren? ...
> Ansonsten ist das Statement erfolgreich, wenn *keine* SQLException geworfen wird.



Sehe ich ähnlich. Ansonsten schau einmal, was Gast gepostet hat.  Bei üblichen DML-Anweisungen in typischen Client-Server-DB-Ungebungen muss diese nach Absetzten immer durchgeschrieben werden (-> commit), um endgültig wirksam zu sein, anonsten kann man sie auch "zurücknehmen" oder "zurück abwickeln" (-> rollback).


----------



## chipmount (27. Nov 2004)

mit quittieren meine ich, der client kriegt eine rückmeldung vom server ob datensatz erfolgreich eingefügt worden ist oder nicht


----------



## Guest (27. Nov 2004)

Konvertieren die SQLException in irgendein eigene und wirf sie gleich weiter an den Client.
z.B. ApplicationException mit einem Errorcode und Message. ("000001", "Fehler beim Speichern von Bestellung...")
Vermeide es SQL-Typen und Exceptions bis zum Client weiter zu reichen. 
Dies spart Dir viel Ärger, wenn Du die Persistenzschicht mal anders implementieren musst (z.B. EJB etc.)


----------



## abollm (27. Nov 2004)

Anonymous hat gesagt.:
			
		

> ...
> Vermeide es SQL-Typen und Exceptions bis zum Client weiter zu reichen.
> Dies spart Dir viel Ärger, wenn Du die Persistenzschicht mal anders implementieren musst (z.B. EJB etc.)



Kläre mich doch bitte einmal auf, warum das Durchreichen von SQL-Exceptions einem bei einer anderen Implementation der Persistenzschicht viel Ärger sparen kann. Hängt das nicht letztlich von den Möglichkeiten des RDBMS ab?


----------



## Guest (27. Nov 2004)

Reicht das als Begründung?
	
	
	
	





```
...ejbCreate(...) throws javax.ejb.CreateException
```


----------



## abollm (27. Nov 2004)

@Gast:
Ehrlich gesagt nein. Vielleicht habe ich zu wenig Ahnung von EJB und damit deine Bemerkungen zum Thema nicht richtig verstanden.

Im Grunde frage ich mich, wie chipmount oder ein anderer "die SQLException in irgendein eigene und ... sie gleich weiter an den Client" werfen soll. Du hast dazu z.B. geschrieben "z.B. ApplicationException mit einem Errorcode und Message. ("000001", "Fehler beim Speichern von Bestellung..."). 

Letztlich ist das doch eine Frage, was man hier unter Client versteht. In EJB-Umgebungen spricht man ja von einer Mehrschichten-Architektur (also typischerweise Drei-Schichten-Architektur). Also gibt es ziwschen Client und RDBMS bzw. der eigentlichen DB eine Zwischenschicht (z.B. Applikationsserver).

Naja, vielleicht eine akademische Diskussion...?


----------



## Guest (27. Nov 2004)

Hast Recht, bei einer Mehrschichtenarchitektur bekommt die Bezeichnung Client 
eine andere Bedeutung (JSP's, Servlets etc. sind auch Clients aus der Sicht von EJB).

Was ich meinte ist folgendes:

Wenn man SQLException bis zum Client weiterreicht, dann beschränkt man die Signaturen 
von Methode auf immer und Ewig für SQLException.
Speicherst Du jetzt eine Bestellung über EJB, dann geht es z.B. über eine SessionBean,
die dann die EntityBean erstellt. Der reine Datenbankzugriff wird dabei von der EJB-Schicht 
"versteckt". Hast Du jetzt den Client so entwickelt, dass es im Fehlerfall eine SQLException 
erwartet,
	
	
	
	





```
try
{
  whatever.createBestellung(bestellung);
}
catch(SQLException e)
{
  // Fehler anzeigen etc. 
}
```
dann hast Du ein Problem. Vom Server kriegst Du eine RemoteException, ausgelöst
vom EJB-Container (wegen CreateException serverseitig). Von der SQLExcepition keine
Spur. Die Folge davon ist, dass Du den Client-Code anpassen musst.
Abstrahierst Du die ganze Geschichte über eigene Interfaces/Exceptions mit bestimmten 
Signaturen, die allgemein genug sind, dann kannst Du den Client so lassen, wie er ist. 
Was sich ändert ist nur die Implementierung der Schnittstelle zum Server. (Patterns: Connector; Clientside Proxy)
z.B.

```
interface MyConnector
{
  void addBestellung(...) throws ApplicationException;
  ...
}

class MyJdbcConnector implements MyConnector
{
  public void addBestellung(...) throws ApplicationException
  {
    try
    {
      ... // Bestellung direkt über JDBC oder über speziell dafür vorgesehene DB-Klasse erstellen
    }
    catch(SQLException e)
    {
      logger.log("error-00001", e);
      throw new ApplicationException("error-00001");
    }
  }
}

class MyEjbConnector implements MyConnector
{
  public void addBestellung(...) throws ApplicationException
  {
    try
    {
    ... // Bestellung über eine SessionBean erstellen
    }
    catch(RemoteException e)
    {
      logger.log("error-00001", e);
      throw new ApplicationException("error-00001");
    }
  }
}

class ConnectorFactory ...
{
  public static MyConnector getConnector(...)
  {
    ... eine Implementierung von MyConnector initialisieren und zurückgeben
  }
}

// Jetzt der eigentliche Client

try
{
  MyConnector connector = MyConnectorFactory.getConnector(...);
  connector.addBestellung(...);
}
catch(ApplicationException e)
{
  // anzeigen oder sonstwas schlaues tun
  showError(ErrorHandling.getMessage(e.getErrorCode()));
}
```
Mann kann dann auch den Client unabhängig vom Server entwickelt, indem man
einen DummyConnector erstellt, der einfach nur die Daten zwischenspeichert
oder bestimmte vorinitialisierte Daten zurückgibt.
Die Verabredung ist hier die Signatur der Methoden bzw. die Interfaces. Wie es 
implementiert ist, interessiert den Client nicht.

Hoffe, ich habe halbwegs verständlich beschrieben, was mir da gerade im Kopf herumspuckt.


----------



## chipmount (27. Nov 2004)

also ich brauche eine antwort von DB(jdbc) die ich dann mit CORBA an client weiterleite nix mit EJB


----------



## Guest (27. Nov 2004)

Dann eben 
	
	
	
	





```
class MyCorbaConnector implements MyConnector 
{ 
  public void addBestellung(...) throws ApplicationException 
  { 
    ...
  }
}
```
 Der Client sollte nix davon wissen, dass es über Corba, RMI, WebServices, 
JDBC, Sockets o.ä. geht.


----------



## chipmount (27. Nov 2004)

???:L   ???:L 

mit welcher abfrage bekomme ich eine meldung(wert) von oracle ob die datensätze eingefügt worden sind oder nicht


----------



## abollm (27. Nov 2004)

@Gast:

Danke für deine Antwort.

@chipmount:

Sei doch nicht so ungeduldig, wenn die Erwachsenen sich unterhalten  :wink:


----------



## abollm (27. Nov 2004)

chipmount hat gesagt.:
			
		

> ???:L   ???:L
> 
> mit welcher abfrage bekomme ich eine meldung(wert) von oracle ob die datensätze eingefügt worden sind oder nicht



Schau nach oben.


----------



## Jaraz (27. Nov 2004)

...


----------



## Guest (27. Nov 2004)

Jaraz hat gesagt.:
			
		

> ...


Ist nicht Dein Ernst!


----------



## chipmount (27. Nov 2004)

kann damit nichs anfangen(ist mir zu ungenau)

```
class MyCorbaConnector implements MyConnector 
{ 
  public void addBestellung(...) throws ApplicationException 
  { 
    ... 
  } 
}
```


----------



## Guest (28. Nov 2004)

Du kannst in IDL eigene Exceptions und DTO-Klassen/Strukturen definieren. (dto = data transfer object)

```
module WWS
{
  interface BestellungService
  {
    exception AppException
    {
      string errorcode;
    };

    struct BestellungDTO
    {
      ...die Daten einer Bestellung
    };

    string addBestellung( in BestellungDTO bestellung ) raises (AppException);
    void updBestellung( in BestellungDTO bestellung ) raises (AppException);
    void delBestellung( in string bestellNr) raises (AppException);
  };
  ...
};
```
Im Normalfall, wenn nichts schiefgeht, gibst Du die BestellNr oder sonstige ID der neuen 
Bestellung zurück. Wenn es Fehler gibt, dann wirfst Du eine ApplicationException mit 
einem eindeutigen Errorcode, der clientseitig einer Fehlermeldung zugeordnet werden 
kann. Alternativ kannst Du die Fehlermeldungen bereits serverseitig vorformatieren
und eine für Menschen lesbare Fehlermeldung zurückgeben.

Dann kommt noch die Klasse MyCorbaConnector dazwischen (clientseitig), damit die 
Corba-Funktionalität schön vom eigentlichen Client getrennt ist.

```
class MyCorbaConnector implements MyConnector 
{ 
  public String addBestellung(BestellungBean bestellung) throws ApplicationException 
  { 
    try
    {
      // Verbindung zum BestellungService holen
      BestellungService s = ServiceLocator.getBestellungService();
      // Bean in DTO konvertieren und die Bestellung zum Server schicken
      return s.addBestellung(bean2dto(bestellung));
    }
    catch(AppException e) 
    {
      // die Exception vom Corba-Service in eine lokale konvertieren
      throw ExceptionFactory.createApplicationException(e.errorcode);
    }
  } 
}
```


----------



## chipmount (28. Nov 2004)

danke   

werde mal ausprobieren


----------



## chipmount (4. Dez 2004)

also hab die programme angepast und habe keine fehlermeldungen  

nur leider tut sich nichts  in der datenbank die eingegebenen werte werden nich angelegt ich bekomme auch keine fehlermeldung

hab ich was vergessen??


----------



## Guest (4. Dez 2004)

Meine Glaskugel ist in Reparatur.
Zeig etwas Code, dann kann Dir vielleicht jemand helfen.

Ich tippe auf fehlendes commit().


----------



## chipmount (4. Dez 2004)

also an sql liegts schon mal nicht
da ich dieses fragment (sql anweisung) extra ausgefürt habe und es geht commit() hab ich nicht vergessen

also meine schnitstellendef:


```
module M_N 
{ 
interface I_N{ 
struct abc { 
string bestnr; 
string name; 
string bestelldaum; 
}; 
void setBestellung (in abc bestellung, out long anzahl); 
}; 
};
```

clientprogramm: 

```
... 
        String name; 
         System.out.print("Name: "); 
         name = in.readLine(); 
          String bestnr; 
         System.out.print("Name: "); 
         bestnr = in.readLine(); 

..... 
//parameterübergabe an server via corba 

M_N.I_NPackage.abc bestellung= new M_N.I_NPackage.abc (bestnr, name, bestelldatum);
```
serverprogramm: 

```
class I_NImpl extends I_NPOA{ 

//aufruf setbestellung 
public void setBestellung(M_N.I_NPackage.abc bestellung, org.omg.CORBA.IntHolder anzahl) 
{ 
try 
{ 
    JDBC bla bla.... 
} 
} 
class server{bla bla }
```

ich habe so das gefül das die werte beim server nicht ankommen(parameterübergabe von client falsch???) den der client bekommt eine antwort vom server das 0 datensätze geändert worden sind

ich bekomme auch keine fehlermeldung


----------



## Guest (4. Dez 2004)

Gib serverseitig die übergebenen Daten auf die Console aus, dann siehst Du,
ob überhaupt etwas ankommt.

Prüfe auch, ob Du clientseitig nicht irgendwo Exceptions "übersiehst"
z.B.

```
try
{
  ...
}
catch(Exception e)
{
  // Leerer Block ohne Fehlerbehandlung oder Ausgabe
}
```
Ansonsten kann es nur noch an der Initialisierung liegen. Wie sieht die aus?


----------



## chipmount (4. Dez 2004)

was meinst du mit Initialisierung??
wie kann ich die übergebenen Daten auf die Console ausgeben??


----------



## chipmount (4. Dez 2004)

also clientprogramm:

```
import M_N.*;
import M_N.I_NPackage.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
import java.io.*;

public class Client
{
 static I_N I_NImpl;

  public static void main(String args[])
    {
      try{
        // create and initialize the ORB
	ORB orb = ORB.init(args, null);

        // get the root naming context
        org.omg.CORBA.Object objRef = 
	    orb.resolve_initial_references("NameService");
        // Use NamingContextExt instead of NamingContext. This is 
        // part of the Interoperable naming Service.  
        NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
 
        // resolve the Object Reference in Naming
        I_N serverRef= I_NHelper.narrow(ncRef.resolve_str("I_N"));

       
        System.out.println("Bestellung");
        BufferedReader in =
        new BufferedReader(new InputStreamReader(System.in));
        
         
        String bestnr;
        System.out.println("BestNr:");
        bestnr=in.readLine();
        //String eingabe =in.readLine();
        //int bestnr=Integer.parseInt(eingabe);
        
        
        
        String name;
        System.out.println("Name:");
        name=in.readLine();
        
        String bestelldatum;
        System.out.println("Bestelldatum:");
        bestelldatum=in.readLine();
       
       
     in.close();
       
  M_N.I_NPackage.abc bestellung = new M_N.I_NPackage.abc(bestnr,name,bestelldatum);
   
  
     
     
	org.omg.CORBA.IntHolder anzahl= new org.omg.CORBA.IntHolder ();
	System.out.println("Anzahl der geänderten Datensätze : " + anzahl.value) ;
	
	} catch (Exception e) {
          System.out.println("ERROR : " + e) ;
	  e.printStackTrace(System.out);
	  }
    }

}
```

serverprogramm:

```
import M_N.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
import org.omg.PortableServer.*;
import org.omg.PortableServer.POA;
import java.sql.*;
import java.util.Properties;

class I_NImpl extends I_NPOA {
	
public void setBestellung (M_N.I_NPackage.abc bestellung, org.omg.CORBA.IntHolder anzahl)	
	{ 
		try{
			
   			int datensätze;
   			String sql;
   		    Connection c= null ; 
    sql ="INSERT INTO Bestellung(bestnr,name,bestelldatum)VALUES(?,?,?)";
       
    
      Class.forName ("oracle.jdbc.driver.OracleDriver"); 
      c = DriverManager.getConnection("jdbc:oracle:thin:@:1521:"", "", ""); 
      
        
      
      PreparedStatement p = c.prepareStatement(sql) ;				
      p.setString(1,"bestellung.bestnr");
      p.setString(2,"bestellung.name"); 
      p.setString(3,"bestellung.bestelldatum");
      p.executeUpdate();
      c.commit();
      datensätze = p.executeUpdate();
      
      anzahl.value=datensätze;
       p.close();
       c.close();
      
      
  } //end try
    
    catch (Exception e) 
    { 
      e.printStackTrace(); 
    } //end catch
    
  }//end updbestellung 
 }//end class I_NImpl
 
  
public class Server {

  public static void main(String args[]) {
    try{
      // create and initialize the ORB
      ORB orb = ORB.init(args, null);

      // get reference to rootpoa & activate the POAManager
      POA rootpoa = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));
      rootpoa.the_POAManager().activate();

      // create servant and register it with the ORB
      I_NImpl serverImpl = new I_NImpl();
      
      // get object reference from the servant
      org.omg.CORBA.Object ref = rootpoa.servant_to_reference(serverImpl);
      I_N sRef = I_NHelper.narrow(ref);
	  
      // get the root naming context
      org.omg.CORBA.Object objRef =
          orb.resolve_initial_references("NameService");
      // Use NamingContextExt which is part of the Interoperable
      // Naming Service (INS) specification.
      NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);

      // bind the Object Reference in Naming
      NameComponent path[] = ncRef.to_name( "I_N" );
      ncRef.rebind(path, sRef);

      System.out.println("Hello Server ready and waiting ...");
     

      // wait for invocations from clients
      orb.run();
    } 
	
      catch (Exception e) {
        System.err.println("ERROR: " + e);
        e.printStackTrace(System.out);
      }
	  
      System.out.println("HelloServer Exiting ...");
	
  }
}
```


----------



## Guest (4. Dez 2004)

OK, machen wir es mal der Reihe nach. 

1) Erstelle folgende Verzeichnisstruktur


```
[beispiel]
   |--- [classes]
   |--- [idl-src]
   |--- [src]
         |--[wws]
             |--[server]
             |    |--[impl]
             |--[client]
```

2) Diese Dateien kommen in das Verzeichnis [beispiel]

build.bat
	
	
	
	





```
@echo off
idlj -td idl-src -pkgTranslate wws wws.server.impl -pkgTranslate wws.BestellServicePackage wws.server.impl -fall wws.idl
javac -classpath .\classes; -sourcepath .\src;.\idl-src; -d .\classes src\wws\server\Server.java src\wws\client\Client.java
```
exec-server.bat
	
	
	
	





```
@echo off
java -cp .\classes; wws.server.Server
```
exec-client.bat
	
	
	
	





```
@echo off
java -cp .\classes; wws.client.Client
```
wws.idl
	
	
	
	





```
module wws
{
  interface BestellService
  {
    exception AppException
    {
      string errorcode;
    };

    struct BestellungDTO
    {
      string bestellNr;
    };

    string addBestellung( in BestellungDTO bestellung ) raises (AppException);
    void updBestellung( in BestellungDTO bestellung ) raises (AppException);
    void delBestellung( in string bestellNr) raises (AppException);
  };
};
```
3) Im Verzeichnis src\wws\server\impl

```
package wws.server.impl;

public class BestellServiceImpl extends BestellServicePOA
{
  public String addBestellung(BestellungDTO bestellung) throws AppException
  {
    System.out.println("ADD:" + bestellung.bestellNr);

    // nur mal so zum Test eine Exception schmeissen
    AppException e = new AppException();
    e.errorcode = "BlaBla";
    throw e;
  }

  public void updBestellung (BestellungDTO bestellung) throws AppException
  {
    System.out.println("UPD:" + bestellung.bestellNr);
  }

  public void delBestellung(String bestellNr) throws AppException
  {
    System.out.println("DEL:" + bestellNr);
  }
}
```
In src\wws\server

```
package wws.server;

import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
import org.omg.PortableServer.*;

import wws.server.impl.*;

public class Server
{
  public static void main(String argv[])
  {
    try
    {
      ORB orb = ORB.init(argv, System.getProperties());

      POA rootPOA = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));
      rootPOA.the_POAManager().activate();
      BestellServiceImpl bestellServiceImpl = new BestellServiceImpl();
      org.omg.CORBA.Object objRef = rootPOA.servant_to_reference(bestellServiceImpl);
      BestellService ref = BestellServiceHelper.narrow(objRef);

      org.omg.CORBA.Object namingRef = orb.resolve_initial_references("NameService");
      NamingContextExt ncRef = NamingContextExtHelper.narrow(namingRef);
      NameComponent path[] = ncRef.to_name( "BestellService" );
      ncRef.rebind(path, ref);

      orb.run();
    }
    catch(Exception e)
    {
      System.err.println("ERROR: " + e);
      e.printStackTrace();
    }
  }
}
```
in src\wws\client

```
package wws.client;

import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;

import wws.server.impl.*;

public class Client
{
  public static void main(String argv[])
  {
    try
    {
      ORB orb = ORB.init(argv, System.getProperties());

      org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
      NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
      BestellService bestellService = BestellServiceHelper.narrow(ncRef.resolve_str("BestellService"));

      BestellungDTO bestellung = new BestellungDTO();
      bestellung.bestellNr = "001";

      try
      {
        bestellService.addBestellung(bestellung);
      }
      catch(AppException e)
      {
      	System.out.println(e.errorcode);
      }
      bestellService.updBestellung(bestellung);
      bestellService.delBestellung(bestellung.bestellNr);
    }
    catch(Exception e)
    {
      System.out.println("ERROR : " + e);
      e.printStackTrace(System.out);
    }
  }
}
```
4) Führe build.bat aus, dann tnameserv 
5) exec-server.bat
6) exec-client.bat


----------



## chipmount (5. Dez 2004)

ES GEHT NICHT  :autsch: 
die fehlermeldungen kann ich nicht lesen da es zu schnell geht aber ich glaube das hängt mit den verzeichnissen
ich bastle die(server + bestiml) mal zusammen und schaue was passiert


----------



## chipmount (5. Dez 2004)

also hab jetz folgenddes gemacht:

idl:

```
module wws 
{ 
  interface BestellService 
  { 
    exception AppException 
    { 
      string errorcode; 
    }; 

    struct BestellungDTO 
    { 
      string bestnr; 
    }; 

    string addBestellung( in BestellungDTO bestellung ) raises (AppException); 
    void updBestellung( in BestellungDTO bestellung ) raises (AppException); 
    void delBestellung( in string bestnr) raises (AppException); 
  }; 
};
```

client:

```
import wws.*; 
import org.omg.CosNaming.*; 
import org.omg.CosNaming.NamingContextPackage.*; 
import org.omg.CORBA.*; 
import org.omg.PortableServer.*; 
import org.omg.CosNaming.*; 
import org.omg.CosNaming.NamingContextPackage.*; 
import org.omg.CORBA.*; 



public class Client 
{ 
  public static void main(String argv[]) 
  { 
    try 
    { 
      ORB orb = ORB.init(argv, System.getProperties()); 

      org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService"); 
      NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef); 
      BestellService bestellService = BestellServiceHelper.narrow(ncRef.resolve_str("BestellService")); 

      wws.BestellServicePackage.BestellungDTO bestellung = new wws.BestellServicePackage.BestellungDTO(); 
      bestellung.bestnr = "6000"; 

      try 
      { 
        bestellService.addBestellung(bestellung); 
      } 
      catch(wws.BestellServicePackage.AppException e) 
      { 
         System.out.println(e.errorcode); 
      } 
      bestellService.updBestellung(bestellung); 
      bestellService.delBestellung(bestellung.bestnr); 
    } 
    catch(Exception e) 
    { 
      System.out.println("ERROR : " + e); 
      e.printStackTrace(System.out); 
    } 
  } 
}
```

server:

```
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
import org.omg.PortableServer.*;
import org.omg.PortableServer.POA;
import java.sql.*;
import java.util.Properties;

import wws.*; 

 class BestellServiceImpl extends BestellServicePOA 
{ 
   public String addBestellung(wws.BestellServicePackage.BestellungDTO bestellung) throws wws.BestellServicePackage.AppException
  { 
    System.out.println("ADD:" + bestellung.bestnr); 

    // nur mal so zum Test eine Exception schmeissen 
    wws.BestellServicePackage.AppException e = new wws.BestellServicePackage.AppException(); 
    e.errorcode = "BlaBla"; 
    throw e; 
  } 

  public void updBestellung (wws.BestellServicePackage.BestellungDTO bestellung) throws wws.BestellServicePackage.AppException 
  { 
    System.out.println("UPD:" + bestellung.bestnr); 
  } 

  public void delBestellung(String bestnr) throws wws.BestellServicePackage.AppException
  { 
    System.out.println("DEL:" + bestnr); 
  } 
}

public class Server 
{ 
  public static void main(String argv[]) 
  { 
    try 
    { 
      ORB orb = ORB.init(argv, System.getProperties()); 

      POA rootPOA = POAHelper.narrow(orb.resolve_initial_references("RootPOA")); 
      rootPOA.the_POAManager().activate(); 
      BestellServiceImpl bestellServiceImpl = new BestellServiceImpl(); 
      org.omg.CORBA.Object objRef = rootPOA.servant_to_reference(bestellServiceImpl); 
      BestellService ref = BestellServiceHelper.narrow(objRef); 

      org.omg.CORBA.Object namingRef = orb.resolve_initial_references("NameService"); 
      NamingContextExt ncRef = NamingContextExtHelper.narrow(namingRef); 
      NameComponent path[] = ncRef.to_name( "BestellService" ); 
      ncRef.rebind(path, ref); 

      orb.run(); 
    } 
    catch(Exception e) 
    { 
      System.err.println("ERROR: " + e); 
      e.printStackTrace(); 
    } 
  } 
}
```

als ausgabe bekomme ich
Server:
 ADD:6000
UPD:6000
DEL:6000

Client:
BlaBla

irgendwo ist ein "kleiner" fehler  :lol: bei mir im programm aber ich sehe es nicht ,
siehst du ihn???


----------



## Guest (5. Dez 2004)

Ich sehe nur Sachen, die in meinem Code nicht drin sind (wws.BestellServicePackage.)
oder auch umgekehrt (fehlende Package-Angaben).
Warum machst Du nicht einfach Copy & Paste, dann läuft das Grundgerüst.


----------



## chipmount (5. Dez 2004)

wenn ich Copy & Paste mache
dann spinnt der java compiler weil ??????

also ich hab dein beispiel so angepass das es funk. 
jetz hab ich das obige beispiel so angepasst das er mir schon was in die DB ablegt (die werte stimmen überein) :lol:   :lol: 

problemm ist jetzt die sql abfrage
sie hierhttp://www.java-forum.org/de/viewtopic.php?t=11364

danke für die tipps


----------



## Admiralz (8. Dez 2004)

ich weiss ja nicht womit du programmierst, aber versuch doch mal ne andere IDE.
Eclipse macht Dich Beispielsweise schon frühzeitig auf Fehler aufmerksam und kann die imports managen. Ich denke damit könntest Du wesentlich weniger Ärger haben.
Achja der Konsolen-Output bleibt sichtbar und lässt sich wunderbar scrollen.


----------

