Datenbanken, Internet Technologien - von am Thursday, November 19, 2009 9:24 - 0 Kommentare

Oracle WebServices im praktischen Einsatz

1. Einleitung

Dieser Praxisreport schildert den Einsatz von Oracle als WebService-Consument und WebService-Provider. Dabei wird anhand eines Praxisbeispiels gezeigt wie der Zugriff auf einen externen WebService aus einer Oracle-Datenbank mittels PL/SQL-Routine möglich ist um damit einen Ladeprozess (ETL) zu implementieren. Des weiteren wird gezeigt, wie die Datenbank ihre PL/SQL-Routinen als WebService zur Verfügung stellen kann.

2. Einführung in WebServices

Grds. stellt ein WebService einen Dienst (Service) dar, der über eine eindeutige URI (Uniform Resource Identifier) identifizierbar ist. Dabei spielt es für den Aufrufenden des WebServices bzw. dessen Anbieter keine Rolle, mit welcher Programmiersprache oder auf welchem Betriebssystem, das jeweilige andere System arbeitet. Aufrufender und Anbieter können dabei zusätzlich räumlich getrennt sein.

WebServices setzen dabei auf bewährte Internet-Technologien und Protokollen wie beispielsweise das HTTP-Protokoll auf. Dies hat zur Folge, dass für die Nutzung und die Bereitstellung von WebServices beispielsweise der Standardport 80 des HTTP-Protokolls genutzt werden kann und somit keine weitere Konfigurationen und Freischaltungen innerhalb der Unternehmens-Firewall notwendig sind.

In Zusammenhang mit WebServices wird häufig der Begriff “SOA” genannt, welches aber nicht dasselbe meint. SOA als ServiceOrientierte Architektur bezeichnet lediglich ein Konzept wie eine Architektur service-orientiert aufgebaut sein kann, beschriebt jedoch keine Technologie oder gar eine Spezifikation.

Grundsätzlich senden Client-Programme (wie beispielsweise eine PL/SQL-Routine) Anfragen an einen WebService. Dieser sendet die Information dann an das aufrufende System zurück. Sowohl die Anfrage als auch die Antwort erfolgen dabei grundsätzlich im XML-Format. Dabei wird zwischen einer sog. “Header-Information” und einer “Payload-Information” unterschieden. Im Header werden dabei Steuerungsinformation versandt, während der Payload die eigentlichen Nutzdaten enthält.

Der Anbieter eines WebServices stellt für die Nutzung seines Systems aufrufbare Methoden zur Verfügung. Diese werden vom Anbieter in Form einer sog. “WSDL” veröffentlich. WSDL (WebService Definition Language) ist eine Beschreibungssprache für Dienste zum Austausch von Informationen auf Basis von XML. Hierdurch enthält das aufrufende System Informationen darüber, welche Methoden und Operationen ein WebService wie bereitstellt, welche Parameter diese ggf. benötigen und wie etwaige Rückgaben aufgebaut sind.

Nachfolgend ein Beispiel für die WSDL einer öffentlich zugänglichen Wetter-Abfrage-Information:

http://www.webservicex.net/globalweather.asmx?WSDL

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <wsdl:definitions xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tm="http://microsoft.com/wsdl/mime/textMatching/" xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/" xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/" xmlns:tns="http://www.webserviceX.NET" xmlns:s="http://www.w3.org/2001/XMLSchema" xmlns:soap12="http://schemas.xmlsoap.org/wsdl/soap12/" xmlns:http="http://schemas.xmlsoap.org/wsdl/http/" targetNamespace="http://www.webserviceX.NET" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">
  3.   <wsdl:types>
  4.     <s:schema elementFormDefault="qualified" targetNamespace="http://www.webserviceX.NET">
  5.       <s:element name="GetWeather">
  6.         <s:complexType>
  7.           <s:sequence>
  8.             <s:element minOccurs="0" maxOccurs="1" name="CityName" type="s:string" />
  9.             <s:element minOccurs="0" maxOccurs="1" name="CountryName" type="s:string" />
  10.           </s:sequence>
  11.         </s:complexType>
  12.      </s:element>
  13.       <s:element name="GetWeatherResponse">
  14.         <s:complexType>
  15.           <s:sequence>
  16.           <s:element minOccurs="0" maxOccurs="1" name="GetWeatherResult" type="s:string" />
  17.           </s:sequence>
  18.         </s:complexType>
  19.       </s:element>
  20.  
  21. [...]
  22.  
  23.   <wsdl:message name="GetWeatherSoapIn">
  24.     <wsdl:part name="parameters" element="tns:GetWeather" />
  25.   </wsdl:message>
  26.   <wsdl:message name="GetWeatherSoapOut">
  27.     <wsdl:part name="parameters" element="tns:GetWeatherResponse" />
  28.   </wsdl:message>
  29.  
  30. [...]
  31.  
  32.  <wsdl:operation name="GetWeather">
  33.       <wsdl:documentation xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">Get weather report for all major cities around the world.</wsdl:documentation>
  34.       <wsdl:input message="tns:GetWeatherSoapIn" />
  35.       <wsdl:output message="tns:GetWeatherSoapOut" />
  36.     </wsdl:operation>
  37.  
  38. [...]
  39.  
  40.   <wsdl:binding name="GlobalWeatherSoap" type="tns:GlobalWeatherSoap">
  41.     <soap:binding transport="http://schemas.xmlsoap.org/soap/http" />
  42.     <wsdl:operation name="GetWeather">
  43.       <soap:operation soapAction="http://www.webserviceX.NET/GetWeather" style="document" />
  44.       <wsdl:input>
  45.         <soap:body use="literal" />
  46.       </wsdl:input>
  47.       <wsdl:output>
  48.         <soap:body use="literal" />
  49.       </wsdl:output>
  50.     </wsdl:operation>

Dieser WebService stellt die Methode GetWeather zur Verfügung und erwartet dabei als obligatorische Parameter ein Stadtnamen (CityName) sowie ein Namen des Landes (CountryName) als String. Als Rückgabewert (GetWeatherRepsonse) wird ebenfalls ein String zurückgegeben. Auch die für den Konsumenten aufzurufende URL für den WebService wird übermittelt (http://www.webserviceX.NET/GetWeather). Jeder Programmierer kann nun diesen WebService nutzen und erhält dafür durch den Aufruf der obigen URL eine Beschreibung dieses Services. Da es bei der WSDL um eine genormte und durch eine XML-Definitionsdatei festgelegte Antwort handelt, können nun Drittsysteme sich auf Basis dieser ihre Routinen mit Hilfe von Tools halbautomatisch entwickeln.

Der Zugriff auf den eigentlichen WebService erfolgt dann mit Hilfe des sogenannten SOAP-Protokolls. SOAP nutzt dabei das Transport-Protokoll HTTP / TCP und XML als Präsentation der Daten. Eine SOAP-Nachricht besteht dabei dann aus einem sog. „Envelope“, der wiederum einen Header und einen Body mit den eigentlichen Nutzdaten enthält. Der Header enthält dabei etwaige Statusinformationen wie beispielsweise eine Anfragekennung oder ähnliches. Im Body befinden sich dann die eigentlichen Nutzdaten.

Man sollte sich bewusst sein, dass durch den Einsatz von XML als Präsentation der Daten sich das Problem ergibt, dass beim Einsatz von SOAP ein sehr hohes Datenvolumen entsteht. So führt beispielsweise das einfache Versenden von “Wahr” oder “Falsch” zu einem Datenvolumen von mehreren hundert Bytes, obwohl in einem stark gekoppelten System theoretisch ein Bit reichen würde.

Das Zusammenspiel zwischen WSDL, SOAP und HTTP zeigt folgende Visualisierung:

Interaktion zwischen WSDL, SOAP und HTTP

3. WebServices mit Oracle

3.1 Use-Case der Praxisanwendung

Die Praxisanwendung sammelt halbstündlich Daten über die aktuelle Wettertemperatur für bestimmte Städte durch Aufruf eines kommerziell angebotenen WebServices, bereitet diese intern auf und stellt diese dann wiederum anderen Inhouse-Systemen angereichert als WerbService zur Verfügung. Der Aufruf des externen WebServices, die Anreicherung der Daten sowie das Bereitstellen eines WebServices wurden mittels PL/SQL umgesetzt. In diesem Praxisbericht wird aus Gründen der Übersichtlichkeit nur auf die Bereiche des WebServices-Aufrufes und der WebService-Bereitstellung eingegangen.

Hinweis: In dem hier vorliegenden Praxisbericht wurde der kommerzielle WebService durch einen offenen WebService ersetzt, da der Betreiber des kommerziellen WebServices einer Veröffentlichung seines Namens nicht zugestimmt hat. Der freie WebService bietet aber grds. die gleiche Funktionalität, garantiert jedoch keine entsprechende Verfügbarkeit wieder entsprechende kommerzielle Anbieter.

3.2 Aufruf von WebServices auf Basis von PL/SQL

Für den Aufruf von WebServices aus einer PL/SQL-Routine stellt Oracle seit der Version 10g das Package UTL_DBWS zur Verfügung. Ein Zugriff ist zwar auch mittels UTL_HTTP möglich, aus Gründen der Vereinfachung wurde aber in der hier beschriebenen Projekt der Einsatz von UTL_DBWS gewählt, da ansonsten das Bauen des gesamten SOAP-Requestes per Hand erfolgen müsste. Um dieses Package nutzen zu können, müssen zuvor noch zwei Java-Libaries in die Datenbank geladen werden.

[dos]loadjava -u sys/ -r -v -f -s -grant public -genmissing dbwsclientws.jar dbwsclientdb102.jar[/dos]
Die entsprechenden Libaries finden sich hier.

Um auf das Package UTL_DBWS mittels eines „normalen“ Datenbank-Benutzers zugreifen zu können muss der User “SYS” noch ein Public Synonym für dieses erzeugen.

  1. CREATE PUBLIC SYNONYM UTL_DBWS FOR SYS.UTL_DBWS;

Um den bereits oben dargestellten Weather-WebService aufzurufen und Daten einzusammeln, wurde folgende Routine implementiert:

  1. CREATE OR REPLACE FUNCTION GETDATAFROMWEBSERVICE RETURN VARCHAR2 IS
  2.   v_service             UTL_DBWS.SERVICE;
  3.   v_call                UTL_DBWS.CALL;
  4.   v_service_qname       UTL_DBWS.QNAME;
  5.   v_port_qname          UTL_DBWS.QNAME;
  6.   v_operation_qname     UTL_DBWS.QNAME;
  7.   v_string_type_qname   UTL_DBWS.QNAME;
  8.   v_decimal_type_qname  UTL_DBWS.QNAME;
  9.   v_ret                 ANYDATA;
  10.   v_retx_string         VARCHAR2(100);
  11.   v_retx_len            NUMBER;
  12.   v_params              UTL_DBWS.ANYDATA_LIST;
  13. BEGIN
  14.   -- Service-Instanz erzeugen...
  15.   v_service_qname := UTL_DBWS.TO_QNAME('http://www.webserviceX.NET', 'GlobalWeather');
  16.   v_service       := UTL_DBWS.CREATE_SERVICE(v_service_qname);
  17.  
  18.   -- Call-Instanz erzeugen...
  19.   v_port_qname      := UTL_DBWS.TO_QNAME('http://www.webserviceX.NET', 'GlobalWeatherSoap');
  20.   v_operation_qname := UTL_DBWS.TO_QNAME('http://www.webserviceX.NET', 'GetWeather');
  21.   v_call := UTL_DBWS.CREATE_CALL(v_service, v_port_qname, v_operation_qname);
  22.  
  23.   -- Eigenschaften festlegen...
  24.   UTL_DBWS.SET_TARGET_ENDPOINT_ADDRESS(v_call,
  25.            'http://www.webservicex.net/globalweather.asmx');
  26.   UTL_DBWS.SET_PROPERTY(v_call, 'ENCODINGSTYLE_URI', 'http://schemas.xmlsoap.org/soap/encoding/');
  27.  
  28.   -- Parameter hinzufuegen...
  29.   v_string_type_qname := UTL_DBWS.TO_QNAME('http://www.w3.org/2001/XMLSchema', 'string');
  30.   UTL_DBWS.ADD_PARAMETER(v_call, 'param0', v_string_type_qname, 'ParameterMode.IN');
  31.   UTL_DBWS.ADD_PARAMETER(v_call, 'param1', v_string_type_qname, 'ParameterMode.IN');
  32.  
  33.   -- Return-Typ festlegen...
  34.   v_decimal_type_qname := UTL_DBWS.TO_QNAME('http://www.w3.org/2001/XMLSchema', 'string');
  35.   UTL_DBWS.SET_RETURN_TYPE(v_call, v_decimal_type_qname);
  36.  
  37.   -- Web-Service starten...
  38.   v_params(0) := ANYDATA.CONVERTVARCHAR('Hamburg');
  39.   v_params(1) := ANYDATA.CONVERTVARCHAR('Germany');
  40.   v_ret := UTL_DBWS.INVOKE(v_call, v_params);  
  41.   DBMS_OUTPUT.PUT_LINE('Result: ' || v_ret.accessvarchar2 );
  42.   UTL_DBWS.RELEASE_SERVICE(v_service);
  43.   RETURN v_ret.accessvarchar2;
  44. END;
  45. /

Der Aufruf der oben stehende Methodik erfolgt dann mittels einer anderen PL/SQL-Prozedur, welche dann wieder über den Oracle-Scheduler in definierten regelmäßigen Abständen aufgerufen wird. Die als XML zurückgelieferten Daten werden dann mittels der in PL/SQL zur Verfügung gestellten XML-Hilfsmethoden geparst, ausgelesen, angereichert und in die entsprechenden Zieltabellen geschrieben.

Die gleiche Funktionalität zum Abruf der Daten kann dann auch mittels UTL_HTTP wie folgt umgesetzt werden:

  1. CREATE OR REPLACE FUNCTION GETDATAFROMWEBSERVICE RETURN VARCHAR2 IS
  2.   http_req  utl_http.req;
  3.   http_resp utl_http.resp;
  4.   request_env varchar2(32767);
  5.   response_env varchar2(32767);
  6. begin
  7. request_env:='<?xml version="1.0" encoding="UTF-8" standalone="no"?><SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tm="http://microsoft.com/wsdl/mime/textMatching/" xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/" xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/" xmlns:tns="http://www.webserviceX.NET" xmlns:s="http://www.w3.org/2001/XMLSchema" xmlns:soap12="http://schemas.xmlsoap.org/wsdl/soap12/" xmlns:http="http://schemas.xmlsoap.org/wsdl/http/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" ><SOAP-ENV:Body><tns:GetWeather xmlns:tns="http://www.webserviceX.NET"><tns:CityName>Hamburg</tns:CityName><tns:CountryName>Germany</tns:CountryName></tns:GetWeather></SOAP-ENV:Body></SOAP-ENV:Envelope>';
  8. dbms_output.put_line('Length of Request:' || length(request_env));
  9. dbms_output.put_line ('Request: ' || request_env);
  10.  
  11. http_req := utl_http.begin_request('http://www.webservicex.net/globalweather.asmx', 'POST', utl_http.HTTP_VERSION_1_1);
  12. utl_http.set_header(http_req, 'Content-Type', 'text/xml; charset=utf-8');
  13. utl_http.set_header(http_req, 'Content-Length', length(request_env));
  14. --utl_http.set_header(http_req, 'SOAPAction', '"http://www.webserviceX.NET/GetWeather"');
  15. utl_http.write_text(http_req, request_env);
  16.  
  17. dbms_output.put_line('');
  18.  
  19. http_resp := utl_http.get_response(http_req);
  20. dbms_output.put_line ( 'Status: ' || http_resp.status_code );
  21. dbms_output.put_line ( 'Status-Message: ' || http_resp.reason_phrase );
  22.  
  23. utl_http.read_text(http_resp, response_env);
  24. dbms_output.put_line('Response: ');
  25. dbms_output.put_line(response_env);
  26.  
  27. utl_http.end_response(http_resp);
  28. return response_env;
  29. end;
  30. /

3.3 Bereitstellung von WebServices auf Basis von PL/SQL
Damit in PL/SQL geschriebene Routinen als WebService zur Verfügung gestellt werden können, musste bisher ein Java-Wrapper erstellt werden und dieser dann über einen Applikationsserver (wie beispielsweise OC4J oder WebLogic) zur Verfügung gestellt werden. Seit der Version 11g der Oracle-Datenbank ist dies stark vereinfacht worden, so dass kein Applikationsserver mehr benötigt wird. Stattdessen wird nun die sowieso schon vorhandene Funktionalität XML DB genutzt.

Um zu überprüfen, ob das Datenbanksystem bereits Anfragen über einen bestimmten TCP/IP-Port annehmen kann, wird folgender Befehl abgesetzt:

  1. SELECT dbms_xdb.gethttpport FROM dual;

Sollte die Antwort “0” sein, so muss der Port beispielsweise noch mittels:

  1. exec dbms_xdb.sethttpport(7345);

… zunächst gesetzt werden.

Die Konfiguration der von der Oracle Datenbank angebotenen WebServices erfolgt über die Datei xdbconfig.xml. Damit nicht diese Datei editiert werden muss, kann die Konfiguration dann auch wie folgt als User “SYS” auf der Datenbank durchgeführt werden. Dabei wird nachfolgend ein Java-Servlet namens “orawsv” auf “/orawsv/*” gebunden:

  1. DECLARE
  2.   l_servlet_name VARCHAR2(32) := 'orawsv';
  3. BEGIN
  4.   DBMS_XDB.deleteServletMapping(l_servlet_name);
  5.  
  6.   DBMS_XDB.deleteServlet(l_servlet_name);
  7.  
  8.   DBMS_XDB.addServlet(
  9.     name     => l_servlet_name,
  10.     language => 'C',
  11.     dispname => 'Weather WebService',
  12.     descript => 'Bereitstellung eines WebServices',
  13.     schema   => 'XDB');
  14.  
  15.   DBMS_XDB.addServletSecRole(
  16.     servname => l_servlet_name,
  17.     rolename => 'XDB_WEBSERVICES',
  18.     rolelink => 'XDB_WEBSERVICES');
  19.  
  20.   DBMS_XDB.addServletMapping(
  21.     pattern => '/orawsv/*',
  22.     name    => l_servlet_name);
  23. END;
  24. /

Für die entsprechenden Zugriffsberechtigungen benötigt es noch die Zuweisung der Role XDB_WEBSERVICE zur allgemeinen Freischaltung der Nutzung von WebServices sowie der Role XDB_WEBSERVICE_OVER_HTTP damit die angebotenen WebServices auch über HTTP ansprechbar sind:

  1. GRANT CONNECT, CREATE TABLE, CREATE PROCEDURE TO weather;
  2. GRANT XDB_WEBSERVICES TO weather;
  3. GRANT XDB_WEBSERVICES_OVER_HTTP TO weather;

Für das Auslesen der gespeicherten Informationen wird nun folgende Stored-Procedure bereit gestellt. Diese gibt für einen Ort und ein Land die gerade aktuelle Temperatur zurück:

  1. CREATE OR REPLACE PROCEDURE GET_CURRENT_DEGREE (
  2.   v_CITY LOCATION.CITY%TYPE,
  3.   v_COUNTRY LOCATION.COUNTRY%TYPE,
  4.   v_DEGREES OUT WEATHER.DEGREES%TYPE) AS
  5. BEGIN
  6.   SELECT * INTO v_DEGREES FROM
  7.   (SELECT DEGREES
  8.   FROM WEATHER W, LOCATION L
  9.   WHERE W.LOCATION_ID=L.ID
  10.   AND UPPER(L.CITY)=UPPER(v_CITY)
  11.   AND UPPER(L.COUNTRY)=UPPER(v_COUNTRY)
  12.   ORDER BY VALID_FROM DESC)
  13.   WHERE ROWNUM=1;
  14. END;
  15. /

Die WSDL kann nun per einfachem Zugriff auf die Oracle-Datenbank mittels HTTP abgefragt werden: http://192.168.0.54:7345/orawsv/WEATHER/GET_CURRENT_DEGREE?wsdl

Dabei ist interessant, dass bei einer solchen Abfrage grds. das Datenbank-Login und das Datenbank-Passwortes des entsprechenden Benutzers abgefragt wird (HTTP-AUTH). Möchte man dies vermeiden, so kann dies mittels

  1. <definitions name="GET_CURRENT_DEGREE"
  2.     targetNamespace="http://xmlns.oracle.com/orawsv/WEATHER/GET_CURRENT_DEGREE" xmlns="http://schemas.xmlsoap.org/wsdl/"
  3.     xmlns:tns="http://xmlns.oracle.com/orawsv/WEATHER/GET_CURRENT_DEGREEGET_CURRENT_DEGREE"
  4.     xmlns:xsd="http://www.w3.org/2001/XMLSchema"
  5.     xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
  6.   <types>
  7.     <xsd:schema targetNamespace="http://xmlns.oracle.com/orawsv/WEATHER/GET_CURRENT_DEGREE"
  8.      elementFormDefault="qualified">
  9.       <xsd:element name="GET_CURRENT_DEGREEInput">
  10.         <xsd:complexType>
  11.             <xsd:sequence>
  12.               <xsd:element name="V_DEGREES-NUMBER-OUT">
  13.                 <xsd:complexType/>
  14.               </xsd:element>
  15.               <xsd:element name="V_COUNTRY-VARCHAR2-IN" type="xsd:string"/>
  16.               <xsd:element name="V_CITY-VARCHAR2-IN" type="xsd:string"/>
  17.             </xsd:sequence>
  18.           </xsd:complexType>
  19.       </xsd:element>
  20.       <xsd:element name="GET_CURRENT_DEGREEOutput">
  21.         <xsd:complexType>
  22.             <xsd:sequence>
  23.               <xsd:element name="V_DEGREES" type="xsd:double"/>
  24.             </xsd:sequence>
  25.           </xsd:complexType>
  26.       </xsd:element>
  27.    </xsd:schema>
  28.   </types>
  29.   <message name="GET_CURRENT_DEGREEInputMessage">
  30.     <part name="parameters" element="tns:GET_CURRENT_DEGREEInput"/>
  31.   </message>
  32.   <message name="GET_CURRENT_DEGREEOutputMessage">
  33.     <part name="parameters" element="tns:GET_CURRENT_DEGREEOutput"/>
  34.   </message>
  35.   <portType name="GET_CURRENT_DEGREEPortType">
  36.   <operation name="GET_CURRENT_DEGREE">
  37.       <input message="tns:GET_CURRENT_DEGREEInputMessage"/>
  38.       <output message="tns:GET_CURRENT_DEGREEOutputMessage"/>
  39.     </operation>
  40.   </portType>
  41.   <binding name="GET_CURRENT_DEGREEBinding"
  42.            type="tns:GET_CURRENT_DEGREEPortType">
  43.     <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
  44.     <operation name="GET_CURRENT_DEGREE">
  45.       <soap:operation
  46.  soapAction="GET_CURRENT_DEGREE"/>
  47.       <input>
  48.         <soap:body parts="parameters" use="literal"/>
  49.       </input>
  50.       <output>
  51.         <soap:body parts="parameters" use="literal"/>
  52.       </output>
  53.     </operation>
  54.   </binding>
  55.   <service name="GET_CURRENT_DEGREEService">
  56.     <documentation> Weather WebService </documentation>
  57.     <port name="GET_CURRENT_DEGREEPort" binding="tns:GET_CURRENT_DEGREEBinding">
  58.        <soap:address
  59.              location="http://192.168.0.54:7345/orawsv/WEATHER/GET_CURRENT_DEGREE"/>
  60.      </port>
  61.   </service>
  62. </definitions>

Der WebService ist damit entsprechend nun von anderen Systemen nutzbar. Damit nun nicht ständig die Eingabe eines Logins und Passwort notwendig ist, müsste der Oracle-User einen „Anonymous Access“ erhalten. Dies ist leider laut Oracle derzeit nicht vorgesehen, da dies ein massives Sicherheitsleck darstellen würde.

4. Fazit

Oracle 11g stellt mit der Möglichkeit WebServices direkt aus PL/SQL zu konsumieren als auch PL/SQL Routinen direkt und ohne Applikationsserver bereitzustellen eine komfortable Möglichkeit bereit, um auf einfachste Weise mit WebServices arbeiten zu können. Insbesondere das Bereitstellen von WebServices wurde stark vereinfacht und stellt im Gegensatz zu der Vorgängerversion, bei der man nur mit Hilfe eines Applikationsservers einen WebService, der auf einer PL/SQL-Prozedur basiert, bereitstellen konnte, eine signifikante Verbesserung dar.

Vorteile beim Einsatz vor Oracle als WebService-Provider:

Vorteile beim Einsatz von Oracle als WebService-Consumer:

5. Weiterführende Literatur
Bitte werfen Sie einen Blick in Oracle Database Programming using Java and Web Services und Oracle Web Services Manager für weiterführende Informationen zu diesem Thema.

Autor: Christian Hartmann

Be Sociable, Share!


Kommentare

Kommentieren

Weitere Empfehlungen: