CXF
CXF wird auf der Grundlage von XFire implementiert.
1) Zunächst einmal ist es immer noch das Problem der Pakete. Sie können die neueste Version von CXF unter http://cxf.apache.org/download.html herunterladen. Natürlich benutze ich die neueste Version. Als nächstes kommt der Unsinn, erstellen Sie ein Webprojekt und stecken Sie es in ein JAR -Paket. Wir wählen keine JAR -Pakete aus, setzen sie alle ein.
Wir werden sehen, dass es das JAR -Paket des Frühlings enthält. Wenn wir CXF als Webprojekt bereitstellen müssen, müssen wir die Feder -Konfigurationsdatei verwenden, die später erörtert wird.
Oder Schnittstellenklasse und Implementierungsklasse:
@WebService Public Interface IreaderService {public reader getReader (@WebParam (name = "name") String -Name,@webparam (name = "password") String Passwort); öffentliche Liste <Leader> getReaders (); } @Webservice (EndpointInterface = "com.cxf.servlet.ireaderService", serviceName = "ReaderService") public class readerService implementiert ireaderService {public readers getReader (@Webparam) (name = "name") Zeichenfolge,@webparam (Name = "Passwort") {Passwort) {name); } publiclist <Leader> getReaders () {list <reader> readerlist = new ArrayList <Leser> (); ReaderList.Add (neuer Leser ("Shun1", "123"); ReaderList.add (neuer Leser ("Shun2", "123"); return readerlist; }} Mit Ausnahme des Hinzufügens von Anmerkungen sind diese beiden Klassen die gleichen wie die gestern erwähnten. Ich werde hier nicht darüber sprechen. Erklärungen zu den Anmerkungen finden Sie in der Javaee -Dokumentation. Aber es sollte leicht zu verstehen sein, je nach Bedeutung.
Als nächstes kommt JavaBean oder die Leserklasse:
public Class Reader {private statische endgültige lange Serialversionuid = 1L; privater Zeichenfolge Name; privates Zeichenfolgenkennwort; public reader () {} public reader (String -Name, String -Passwort) {this.name = name; this.Password = Passwort; } // GET/SET -Methode weggelassen public String toString () {return "Name:"+name+", Passwort:"+Passwort; }} Das obige wurde geschrieben.
2) Möchten wir es als Webprojekt verwenden? Mach dir keine Sorgen, benutze es jetzt nicht. CXF verfügt über einen leichten Containerservice, der dem Frühling selbst ic -Behälter entspricht. Wir können es verwenden, um zu testen, ob unsere Bereitstellung erfolgreich war.
Nehmen wir einfach einen Testkurs an:
public static void main (String [] args) {System.out.println ("Server startet ..."); ReaderService ReaderService = New ReaderService (); Endpoint.Publish ("http: // localhost: 8080/readerService", ReaderService); System.out.println ("Server wird gestartet ..."); } Sehr einfach. Es ist in Ordnung, die Adresse direkt zu veröffentlichen und dann die Schnittstelle oder Klasse anzugeben. Ich verwende hier Klassen, versuche aber, Schnittstellen zu verwenden. Schließlich ist die interface-orientierte Programmierung die reale objektorientierte Idee.
Fangen wir an, die Ergebnisse zu sehen:
Wir sehen, dass das Startup abgeschlossen wurde, und starten Sie dann den Browser, um festzustellen, ob es erfolgreich ist.
Geben Sie direkt http: // localhost: 8080/readerService? WSDL im Browser ein. Wir können sehen:
Es generiert die WSDL -Datei, die wir benötigen, und zeigt an, dass wir sie erfolgreich bereitgestellt haben.
3) Nachdem der Einsatz erfolgreich ist, werden wir es nennen. Sein Anruf ist auch ganz einfach. Es ähnelt Xfire. Sie können die Schnittstelle erhalten und dann die Methode wie die lokale Klasse aufrufen.
public static void main (String [] args) {jaxwSProxyFactoryBean factoryBean = new JaxwSProxyFactoryBean (); factoryBean.setServiceClass (ireaderService.class); factoryBean.setAddress ("http: // localhost: 8080/readerService"); IReaderService readerService = (iReaderService) factoryBean.create (); Reader reader = readerService.getReader ("Shun", "123"); System.out.println ("Reader:"+Reader); } Hier ist es sehr einfach. Sie können eine Fabrikklasse erhalten und dann die Schnittstelle und Adresse direkt festlegen und erstellen, um die entsprechende Schnittstelle zu erhalten. Wie Xfire müssen Sie auch zuerst den Schnittstellenprototyp definieren, da diese Anrufe ansonsten keine Möglichkeit haben, zu beginnen.
Wir rennen, um das Ergebnis zu erzielen:
Kein Problem, es steht im Einklang mit den Ergebnissen, die wir erwartet haben.
4) In vielen Fällen möchten wir jedoch nicht, dass unser Webservice und unsere Bewerbung zwei Server trennen, sondern möchten, dass sie sich im selben Container, Tomcat oder JBoss oder anderen befinden. Daher müssen wir den Webservice, den wir früher über das Web ausgefüllt haben, bereitstellen.
Beachten Sie, dass wir hier Spring -Definitionsdateien verwenden müssen.
Schauen Sie sich zunächst Web.xml an:
<? xmlns: web = "http://java.sun.com/xml/ns/javaee" xmlns: web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi: scheMalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id = "webapp_id" fusion <Param-value> web-inf/beans.xml </param-value> </context-param> <hörer> <hörerklasse> org.springframework.web.Context.ContextLoaderListener </Listener-Class> </Hörer> <servlet> <servlet-name> cxfServlet </servlet-name <Servlet-Class> org.apache.cxf.transport.servlet.cxfServlet </Servlet-Class> </Servlet> <Servlet-Mapping> <Servlet-name> cxfServlet </servlet-name> <url-pattern>/webservice/*</url-patter> </servlet-maping> </web-app>
Hier ist es sehr einfach. Geben Sie einfach den Spring -Listener und den entsprechenden Konfigurationsdateipfad an und geben Sie die CXF -Interception -Methode an.
Schauen Sie sich als nächstes Beans.xml an:
<? xmlns: jaxws = "http://cxf.apache.org/jaxws" xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframe.orge/beans/beans http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd "> <import ressource ressourcen = "classPath: meta-inf/cxf/cxf-extension-soap.xml"/> <import ressource
Hier ist es sehr einfach, definieren Sie einfach einen Webservice über Jaxws: Endpoint. Der Implementierer ist die Verarbeitungsklasse des Webservice, und die Adresse ist der Zugriffspfad, ähnlich wie der zuvor geschriebene Readerservice.
Zu diesem Zeitpunkt können wir es in Tomcat bereitstellen und können direkt über http: // localhost: 8080/cxfwebservice/webservice/readerService2? WSDL zugegriffen werden.
Einige Freunde werden sich fragen, warum die URL, die Sie diesmal besucht haben, von der vorherigen unterscheidet. Tatsächlich wird die vorherige Zugriffsadresse von uns selbst definiert, und die WebService -Adresse wird hier in der Konfigurationsdatei konfiguriert und über ein Webprojekt bereitgestellt. Der Projektname wird hier benötigt, und wir haben das URL-Muster als Webservice im CXFServlet konfiguriert, sodass die endgültige URL dieselbe wie oben ist.
Wir können den Effekt sehen:
Dies beweist, dass unser Einsatz erfolgreich war.
Sie können die vorherige Testklasse verwenden, um erneut zu testen. Beachten Sie, dass Sie die Adresse an die von uns veröffentlichte URL ändern müssen.
CXF ist etwas prägnanter als Xfire. Obwohl es einige Anmerkungen hinzufügt, sind diese harmlos. Es konzentriert nur die Informationen in den vorherigen Diensten.xml in die Klasse, was bequemer zu pflegen ist. Dies ist jedoch immer noch Meinungen. Einige Leute mögen Konfigurationsdateien, andere nicht. Darüber hinaus ist die Call -Methode von CXF prägnanter und hat ein kleineres Codevolumen als XFire, was eine wesentliche Verbesserung darstellt.
Einige Freunde haben während des Bauprozesses einige Probleme, daher sind sie von der Beantwortung nacheinander befreit. Der Code wird hier veröffentlicht. Freunde in Not können es herunterladen.
Alle Pakete im LIB -Verzeichnis werden nicht eingegeben. Setzen Sie einfach alle Pakete in CXF ein.
HINWEIS: Die verwendete IDE ist eine Idee, und die Dateistruktur ist in der Sonnenfinsternis nicht üblich. Wenn Sie es unter Eclipse verwenden müssen, können Sie den Code und die Dateien direkt in das neu erstellte Projekt in Eclipse kopieren.
Jersey
Werfen wir einen Blick auf seine grundlegende Nutzung.
Schauen wir uns ein Projekt an. Bevor Sie das Projekt starten, sollten Sie das Paket selbst herunterladen: https://maven.java.net/content/repositories/releass/com/sun/jersey/to to das Beispiel geben Sie sowohl Server als auch Client herunter. Natürlich möchte ich nicht so viele finden, damit ich dieses Zip -Paket direkt herunterladen kann. https://maven.java.net/service/local/artifact/maven/redirect?r=releases&g=com.sun.jersey&a=jersey-archive&v=1.10&e=zip
1) Machen Sie einfach JavaBean
@Xmlrootelement Public Class Reader implementiert serialisierbar {private statische endgültige long serialversionuid = 1l; privater Zeichenfolge Name; privates Zeichenfolgenkennwort; public reader () {} public reader (String -Name, String -Passwort) {this.name = name; this.Password = Passwort; } // Die GET/SET -Methode public String toString () {return "Name:"+name+", Passwort:"+Passwort; }} Hier wird ein Tag verwendet, der den Typ darstellt, wenn es zurückgibt, dh diese Leserklasse kann für die XML -Rückgabe verwendet werden.
2) Wenn Sie eine Serviceklasse verwenden möchten, müssen Sie in der Vergangenheit keine Schnittstelle mehr wie CXF und XFire haben. Verwenden Sie einfach eine Klasse direkt.
@Path ("/ReaderService/{Name}/{Passwort}") public Class ReaderService {@get @Produces (mydyType.application_json) public reader getReader (@PathParam ("Name") String -Name, @Pathparam ("Passwort") String Password {zurückgeben. } public static void main (String [] args) löst illegalArgumentException, ioException, urisyntaxexception aus {httpserver server = httpserverfactory.create ("http: // localhost: 8080/"); server.start (); }} Zu diesem Zeitpunkt wurden mehrere Tags verwendet. Path glaubt, dass Freunde, die SpringMVC verwendet haben, diese Art des Schreibens kennen sollten, nämlich URL -Matching. Wenn Sie nicht klar sind, können Sie zuerst einen Blick darauf werfen. Das GET -Tag gibt an, dass auf diese Methode nur über die GET -Methode zugegriffen werden kann, während die Erzeugung das generierte Ergebnis angibt, was bedeutet, dass das System das Leserobjekt in ein JSON -Ergebnis einschließt und es zurückgibt.
Es spielt keine Rolle, ob Sie es nicht verstehen, Sie können es nach einer Weile verstehen.
Und zu diesem Zeitpunkt gibt es eine Hauptmethode, ich glaube, es gibt große Fragen. Dies ist ein leichter interner Behälter von Jersey. Es kann vorübergehend für uns verwendet werden, um zu debuggen, aber es ist definitiv nicht möglich, dies in realer Verwendung zu verwenden.
3) Schreiben wir eine Testklasse
public class readerClient {public static void main (String [] args) {Client client = client.create (); Webresource ressource = client.resource ("http: // localhost: 8080/readerService/shun/123213"); Reader reader = ressource.get (reader.class); System.out.println (Leser); }} Sehr einfacher Code, Sie sollten ihn verstehen. Ein Client -Objekt fordert ein Webservice an, gibt eine Ressource zurück und dann ruft die Ressource die entsprechende Methode direkt auf. Natürlich wird diese Methode durch unsere URL übereinstimmt.
Hier testen wir es zuerst mit einem leichten Service, der damit einhergeht. Führen Sie ReaderService direkt aus, der eine Hauptmethode enthält. Nach dem Laufen führen wir ReaderClient aus und können sehen, dass das Ergebnis lautet:
Das Ergebnis ist korrekt.
Natürlich möchten wir den leichten Dienst nicht als Server verwenden. Wir müssen es auf denselben Server wie unser Projekt wie Tomcat, JBoss usw. setzen.
4) Natürlich ist Web.xml für Webprojekte unverzichtbar.
<? xmlns: web = "http://java.sun.com/xml/ns/javaee" xmlns: web = "http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0"> <servlet> <servlet-name>Jersey Web Application</servlet-name> <Servlet-Class> com.sun.jersey.spi.container.servlet.servletContainer </Servlet-Class> <Load-on-Startups> 1 </load-on-Startup> </Servlet> <Dienste-Mapping> <Servlet-Name> Jersey-Webanwendung </Servlet-Name> <url-passing/*</*</*/*</URL-Mupling>/*</*</URL-Luft-Nenne> <Welcome-File-List> <Welcome-File> Index.jsp </Welcome-File> </Welcome-File-List> </web-App>
Zu diesem Zeitpunkt wird der gesamte angegebene Restpfad von Jersey abgefangen.
Wir setzen in Tomcat ein und starten und führen dann den ReaderClient erneut aus. Beachten Sie, dass wir zuerst den Ressourcenpfad ändern müssen:
Webresource ressource = client.resource ("http: // localhost: 8080/jerseywebservice/rest/readerService/shun/123213"); Mein Projektname ist Jerseywebservice. Bitte ändern Sie ihn nach Ihrem Projektnamen.
Nach der Änderung führen wir es erneut aus, und die Ergebnisse sind wie folgt:
In Übereinstimmung mit den obigen Ergebnissen bedeutet dies, dass der Einsatzeffekt gleich ist und auch korrekt ist.