Cxf
CXF est implémenté sur la base de XFire.
1) Tout d'abord, c'est toujours le problème des packages. Vous pouvez télécharger la dernière version de CXF à http://cxf.apache.org/download.html. Bien sûr, j'utilise la dernière version. Vient ensuite le non-sens, créez un projet Web et mettez-le dans un package de pot. Nous ne choisissons pas de packages en pot, les mettons tous.
Nous verrons qu'il contient le paquet pot de printemps. Lorsque nous devons déployer CXF en tant que projet Web, nous devons utiliser le fichier de configuration Spring, qui sera discuté plus tard.
Ou classe d'interface et classe d'implémentation:
@WebService Interface publique iReaderservice {Public Reader getReader (@WebParam (name = "name") Nom de chaîne, @ webParam (name = "mot de passe") Mot de passe de chaîne); Liste publique <Deader> getReaders (); } @WebService (endpointInterface = "com.cxf.servlet.irederService", ServiceName = "ReaderService") Public Class ReaderService implémente ireaderservice {public Reader getReader (@webParam (name = "name") String name, @ webParam (name = "passway") String passway) {return new Reader (Name, mot de passe); } public list <Deader> getReaders () {list <nderser> ReaderList = new ArrayList <Dener> (); ReaderList.add (nouveau lecteur ("Shun1", "123")); ReaderList.add (nouveau lecteur ("Shun2", "123")); return ReaderList; }} À l'exception de l'ajout d'annotations, ces deux classes sont les mêmes que celles mentionnées hier. Je n'en parlerai pas ici. Pour des explications des annotations, vous pouvez jeter un œil à la documentation Javaee. Mais il devrait être facile à comprendre selon le sens.
Ensuite, JavaBean, ou la classe de lecture:
lecteur de classe publique {private statique final long SerialVersionUID = 1l; nom de chaîne privé; mot de passe de chaîne privé; Public Reader () {} Public Reader (String Name, String Motword) {this.name = name; this.password = mot de passe; } // get / set Method omet public String toString () {return "name:" + name + ", mot de passe:" + mot de passe; }} Ce qui précède a été écrit.
2) Voulons-nous l'utiliser comme projet Web? Ne vous inquiétez pas, ne l'utilisez pas maintenant. CXF est livré avec un service de conteneurs léger, ce qui équivaut à Spring lui-même à fournir des conteneurs IOC. Nous pouvons l'utiliser pour tester si notre déploiement a réussi.
Prenons simplement un cours de test:
public static void main (String [] args) {System.out.println ("Server commence ..."); ReaderService ReaderService = new ReaderService (); Endpoint.publish ("http: // localhost: 8080 / ReaderService", ReaderService); System.out.println ("Server est démarré ..."); } Très simple. Il est normal de publier directement l'adresse, puis de spécifier l'interface ou la classe. J'utilise des classes ici, mais essayez d'utiliser des interfaces. Après tout, la programmation orientée vers l'interface est l'idée réelle orientée objet.
Commençons à voir les résultats:
Nous voyons que la startup est terminée, puis démarrez le navigateur pour voir si elle réussit.
Entrez directement http: // localhost: 8080 / ReaderService? Wsdl Dans le navigateur, nous pouvons voir:
Il génère le fichier WSDL dont nous avons besoin, indiquant que nous l'avons déployé avec succès.
3) Une fois le déploiement réussi, nous l'appellerons. Son appel est également assez simple. Il est similaire à Xfire. Vous pouvez obtenir l'interface, puis appeler la méthode comme la classe locale.
public static void main (String [] args) {jaxwsproxyfactorybean factoryBean = new JaxWSproxyFactoryBean (); FactoryBean.SetServiceClass (ireaderservice.class); factorybean.setAddress ("http: // localhost: 8080 / ReaderService"); IreArservice ReaderService = (irederservice) factorybean.create (); Reader Reader = ReaderService.getReader ("shun", "123"); System.out.println ("Reader:" + Reader); } C'est très simple ici. Vous pouvez obtenir une classe d'usine, puis définir directement l'interface et l'adresse et créer pour obtenir l'interface correspondante. Comme XFire, vous devez également définir d'abord le prototype d'interface, sinon ces appels n'auront aucun moyen de commencer.
Nous courons pour obtenir le résultat:
Pas de problème, cela est cohérent avec les résultats que nous attendions.
4) Mais dans de nombreux cas, nous ne voulons pas que notre service Web et notre application séparent deux serveurs, mais nous voulons qu'ils soient dans le même conteneur, Tomcat ou JBoss ou autre, nous devons donc déployer le service Web que nous avons terminé plus tôt via le Web.
Notez que nous devons utiliser les fichiers de définition Spring ici.
Premièrement regarder Web.xml:
<? xml version = "1.0" Encoding = "utf-8"?> <web-app xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns = "http://java.sun.com/xml/ns/javaee" 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"> <context-param> <paramor-name> ContextConfigConfigConcolor </ paramage> <Am param-Value> Web-Inf / Beans.xml </ Param-Value> </ Context-Param> <Deurner> <auditeur-CLASS> org.springframework.web.context.contextLoaderListener </ auteur-class> </ auditeur> <vrlet> <Servlet-Name> CXFServlet </vttlet-Name> <Vertlet-Class> org.apache.cxf.transport.servlet.cxfservlet </ servlet-Class> </ Servlet> <Servlet-Mapping> <Servlet-Name> CXFServlet </ Servlet-Name> <Url-Pattern> / WebService / * </ url-Pattern> </ Servlet-Mapping> </pattern
Il est très simple ici, spécifiez simplement l'écouteur Spring et le chemin du fichier de configuration correspondant, et spécifiez la méthode d'interception CXF.
Ensuite, jetez un œil à Beans.xml:
<? xml version = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns: jaxws = "http://cxf.apache.org/jaxws" xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd "> <importer ressource =" classpath: meta-ff / cxf / cxf.xml "/> <importer Resource =" classpath "/> cxf / cxf-extension-SoAP.xml" /> Cxf / Cxf-exTension-SoAp. <importation ressource = "classpath: meta-inf / cxf / cxf-extension-soap.xml" /> <importation royce = "classpath: meta-inf / cxf / cxf-servlet.xml" /> <jaxws: endpoint id = "ReaderServicce2" itimturnor = "com.cxf.servlet.Redersservice" adressa) </fans>
C'est très simple ici, définissez simplement un service Web via Jaxws: Endpoint. L'implémentateur est la classe de traitement du service Web, et l'adresse est son chemin d'accès, similaire au ReaderService que nous avons écrit plus tôt.
À l'heure actuelle, nous pouvons le déployer sur Tomcat et être accessible directement via http: // localhost: 8080 / cxfwebservice / webservice / readerService2? Wsdl.
Certains amis demanderont pourquoi l'URL que vous avez visité cette fois est différente de la précédente. En fait, l'adresse d'accès précédente est définie par nous-mêmes, et l'adresse WebService ici est configurée dans le fichier de configuration et est déployée via un projet Web. Le nom du projet est nécessaire ici, et nous avons configuré le schéma d'URL en tant que service Web dans CXFServlet, donc l'URL finale est la même que ci-dessus.
Nous pouvons voir l'effet:
Cela prouve que notre déploiement a réussi.
Vous pouvez utiliser la classe de test précédente pour tester à nouveau. Notez que vous devez modifier l'adresse à l'URL que nous publions.
CXF est un peu plus concis que xfire. Bien qu'il ajoute quelques annotations, celles-ci sont inoffensives. Il concentre simplement les informations dans les services précédents.xml dans la classe, ce qui est plus pratique à maintenir. Cependant, c'est encore une question d'opinion. Certaines personnes aiment les fichiers de configuration, tandis que d'autres non. De plus, la méthode d'appel de CXF est plus concise, et elle a un volume de code plus petit que XFire, ce qui est une amélioration majeure.
Certains amis ont des problèmes pendant le processus de construction, ils sont donc exemptés de répondre un par un. Le code est publié ici. Les amis dans le besoin peuvent le télécharger.
Tous les packages du répertoire LIB ne sont pas mis, il suffit de mettre tous les packages dans CXF.
Remarque: l'ide utilisée est l'idée et la structure de fichiers n'est pas commune à Eclipse. Si vous devez l'utiliser sous Eclipse, vous pouvez copier directement le code et les fichiers dans le projet nouvellement créé dans Eclipse.
Jersey
Jetons un coup d'œil à son utilisation de base.
Jetons un coup d'œil à un projet. Avant de démarrer le projet, vous devez télécharger le package vous-même: https://maven.java.net/content/repositories/releases/com/sun/jersey/to l'exemple, vous devez télécharger à la fois le serveur et le client. Bien sûr, je ne veux pas en trouver autant, donc je peux télécharger directement ce package zip. https://maven.java.net/service/local/artifact/maven/redirect?r=reases&g=com.sun.jersey&a=jersey-archive&v=1.10&e=zip
1) Faites juste Javabean
@Xmlrootelement public class lecteur implémente serializable {private static final long SerialVersionUID = 1l; nom de chaîne privé; mot de passe de chaîne privé; Public Reader () {} Public Reader (String Name, String Motword) {this.name = name; this.password = mot de passe; } // omettre la méthode get / set public String toString () {return "name:" + name + ", mot de passe:" + mot de passe; }} Une balise est utilisée ici, qui représente le type à son retour, c'est-à-dire que cette classe de lecture peut être utilisée pour le retour XML.
2) Si vous souhaitez utiliser une classe de service, vous n'avez plus besoin d'interface comme CXF et XFire dans le passé. Utilisez simplement une classe directement.
@Path ("/ ReaderService / {name} / {mot de passe}") classe publique ReaderService {@get @produces (mediatype.application_json) lecteur public getReader (@PathParam ("name") String Name, @ pathparam ("mot de passe") String mot de passe) {return new Reader (nom, mot de passe); } public static void main (string [] args) lève illégalArgumentException, ioException, urisyntaxException {httpServer Server = httpServerfactory.create ("http: // localhost: 8080 /"); server.start (); }} À ce moment, plusieurs étiquettes ont été utilisées. Path pense que les amis qui ont utilisé SpringMVC devraient connaître cette façon d'écrire, qui est assorti d'URL. Si vous n'êtes pas clair, vous pouvez aller d'abord un œil. La balise GET indique que cette méthode ne peut être accessible que via la méthode GET, tandis que la production indique le résultat généré, ce qui signifie que le système enfermera l'objet lecteur dans un résultat JSON et le renvoie.
Peu importe si vous ne comprenez pas, vous pouvez le comprendre après un certain temps.
Et pour le moment, il y a une méthode principale, je crois qu'il y a de grandes questions. Il s'agit d'un conteneur interne léger fourni par Jersey. Il peut être temporairement utilisé pour nous déboguer, mais il n'est certainement pas possible de l'utiliser dans une utilisation réelle.
3) Écrivons une classe de test
classe publique ReaderLIENT {public static void main (String [] args) {client client = client.create (); WeBresource Resource = Client.Resource ("http: // localhost: 8080 / ReaderService / shun / 123213"); Reader Reader = Resource.get (Reader.Class); System.out.println (lecteur); }} Code très simple, vous devez le comprendre. Un objet client, demande un service Web, renvoie une ressource, puis la ressource appelle directement la méthode correspondante. Bien sûr, cette méthode est appariée via notre URL.
Ici, nous allons d'abord le tester avec un service léger qui l'accompagne. Exécutez directement ReaderService, qui contient une méthode principale. Après avoir fonctionné, nous exécutons le lecteur de lecture et nous pouvons voir que le résultat est:
Le résultat est correct.
Bien sûr, nous ne voulons pas utiliser le service léger qui l'accompagne comme notre serveur. Nous devons le mettre sur le même serveur que notre projet, comme Tomcat, JBoss, etc.
4) Bien sûr, Web.xml est indispensable pour les projets Web.
<? xml version = "1.0" Encoding = "utf-8"?> <web-app xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xmlns = "http://java.sun.com/xml/ns/javaee" 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 Application web </serflet </ Servile-nom <Servlet-Class> com.sun.jersey.spi.continer.servlet.servletContainer </ servlet-Class> <Loft-on-startup> 1 </ Load-on-Startup> </Servlet> <Serplet-Mapping> <Servlet-Name> Jersey Application web </servlet-name> <url-Pattern> / REST / * * </url-Pattern> </ Servlet-Pattern> / REST / * * </url-Pattern> </ Servlet-Pattern> / REST / * * </url-Pattern> </ Servlet-Pattern> / REST / * * </url-Pattern> </ Servlet-Pattern> / REST / * * </url-Pattern> <Deen wreend-file-list> <leen welcome-file> index.jsp </ bienvenue-file> </ welcome-file-list> </ web-app>
À l'heure actuelle, tout le chemin de repos spécifié sera intercepté par Jersey.
Nous nous déplaçons sur Tomcat et le commençons, puis rédigeons le lecteur de lecture. Notez que nous devons d'abord modifier le chemin de la ressource:
WeBresource Resource = Client.Resource ("http: // localhost: 8080 / jerseywebservice / rest / ReaderService / shun / 123213"); Le nom de mon projet est JerseyWebService, veuillez le modifier en fonction du nom de votre projet.
Après modification, nous le réduisons et les résultats sont les suivants:
Conformément aux résultats ci-dessus, cela signifie que l'effet de déploiement est le même et est également correct.