CXF
CXF se implementa sobre la base de XFIRE.
1) En primer lugar, sigue siendo el problema de los paquetes. Puede descargar la última versión de CXF en http://cxf.apache.org/download.html. Por supuesto, uso la última versión. El siguiente es la tontería, construya un proyecto web y lo ponga en un paquete JAR. No elegimos paquetes de jar, colocarlos todos.
Veremos que contiene el paquete jar de primavera. Cuando necesitamos implementar CXF como un proyecto web, necesitamos usar el archivo de configuración de Spring, que se discutirá más adelante.
O clase de interfaz y clase de implementación:
@WebService Public Interface IReaderservice {Public Reader GetReader (@Webparam (name = "name") Nombre de cadena,@webParam (name = "Password") String Password); Lista pública <Re Reader> getReaders (); } @WebService (endPointInterface = "com.cxf.servlet.ireaderservice", serviceName = "Readerservice") public class Readerservice Implementa Ireaderservice {public lector getReader (@webparam (name = "name") name de cadena,@webParam (nombre = "contraseña") Cadena) {return New Reader (name, contraseña); } Public List <Re Reader> getReaders () {List <Re Reader> ReaderList = New ArrayList <Reader> (); ReaderList.Add (nuevo lector ("shun1", "123")); ReaderList.Add (nuevo lector ("shun2", "123")); return ReaderList; }} Excepto por agregar anotaciones, estas dos clases son las mismas que las mencionadas ayer. No hablaré de eso aquí. Para explicaciones de las anotaciones, puede echar un vistazo a la documentación de Javaee. Pero debería ser fácil de entender según el significado.
El siguiente es Javabean o la clase del lector:
Lector de clase pública {Private static final Long SerialVersionUid = 1L; nombre de cadena privada; contraseña de cadena privada; public lerer () {} public lector (nombre de cadena, contraseña de cadena) {this.name = name; this.password = contraseña; } // get/set Method omite public String toString () {return "name:"+name+", contraseña:"+contraseña; }} Lo anterior ha sido escrito.
2) ¿Queremos usarlo como un proyecto web? No te preocupes, no lo uses ahora. CXF viene con un servicio de contenedor ligero, que es equivalente a la primavera que proporciona contenedores COI. Podemos usarlo para probar si nuestra implementación fue exitosa.
Vamos a tomar una clase de prueba:
public static void main (string [] args) {system.out.println ("El servidor está comenzando ..."); ReaderService ReaderService = new ReaderService (); Endpoint.Publish ("http: // localhost: 8080/readerservice", ReaderService); System.out.println ("El servidor se inicia ..."); } Muy simple. Está bien publicar directamente la dirección y luego especificar la interfaz o clase. Estoy usando clases aquí, pero trate de usar interfaces. Después de todo, la programación orientada a la interfaz es la idea real orientada a objetos.
Empecemos a ver los resultados:
Vemos que la inicio se ha completado y luego inicia el navegador para ver si es exitoso.
Ingrese directamente http: // localhost: 8080/readerservice? Wsdl En el navegador, podemos ver:
Genera el archivo WSDL que necesitamos, lo que indica que lo hemos implementado con éxito.
3) Después de que la implementación sea exitosa, lo llamaremos. Su llamada también es bastante simple. Es similar a xfire. Puede obtener la interfaz y luego llamar al método como la clase local.
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 (); Lector lector = readerservice.getReader ("shun", "123"); System.out.println ("Reader:"+Reader); } Es muy simple aquí. Puede obtener una clase de fábrica, luego establecer directamente la interfaz y la dirección y crear para obtener la interfaz correspondiente. Al igual que XFire, también debe definir primero el prototipo de interfaz, de lo contrario, estas llamadas no tendrán forma de comenzar.
Corremos para obtener el resultado:
No hay problema, es consistente con los resultados que esperábamos.
4) Pero en muchos casos, no queremos que nuestro servicio web y nuestra aplicación separen dos servidores, pero queremos que estén en el mismo contenedor, Tomcat o JBoss u otro, por lo que debemos implementar el servicio web que completamos anteriormente a través de la web.
Tenga en cuenta que necesitamos usar archivos de definición de Spring aquí.
Primero mira a Web.xml:
<? xml versión = "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: schemalocatation = "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"> <aux-param> <Amam-Value> Web-INF/Beans.xml </param-value> </textend-param> <Oyerer> <Oyerer-class> org.springframework.web.context.contextloaderListener </ oyinger-class> </oyeyer> <ervlet> <ervlet-name> cxfservlet </servlet-name> <Servlet-class> org.apache.cxf.transport.servlet.cxfservlet </servlet-class> </servlet> <ervlet-mapping> <ervlet-name> cxfservlet </servlet-name> <url-pattern>/webservice/*</ url-pattern> </servlet-mapping> </web-app>
Aquí es muy simple, solo especifique el Spring Listener y la ruta del archivo de configuración correspondiente, y especifique el método de intercepción CXF.
A continuación, eche un vistazo a los frijoles.xml:
<? xml versión = "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/spring-beanss. http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd "> <import croce =" classpath: metainf/cxf/cxf.xml "/> <importe =" classpath: metainf/cxf/cxf-exp.xml resource = "classpath: meta -inf/cxf/cxf-extension-soap.xml"/> <import crocle = "classpath: meta -inf/cxf/cxf-servlet.xml"/> <jaxws: endpoint id = "Readerservicce2" implementer = "com.cxf.servlet.eServlet.Readerservice" Dirección "/" Dirección "/" Dirección "/" Dirección "/" Dirección "/" Dirección/"Dirección/" Dirección " </frijoles>
Es muy simple aquí, solo defina un servicio web a través de Jaxws: Endpoint. El implementador es la clase de procesamiento del servicio web, y la dirección es su ruta de acceso, similar al servicio de lectura que escribimos anteriormente.
En este momento, podemos implementarlo en Tomcat y se puede acceder directamente a través de http: // localhost: 8080/cxfwebService/WebService/Readerservice2? WSDL.
Algunos amigos preguntarán por qué la URL que visitó esta vez es diferente de la anterior. De hecho, la dirección de acceso anterior está definida por nosotros mismos, y la dirección de servicio web aquí está configurada en el archivo de configuración y se implementa a través de un proyecto web. El nombre del proyecto se necesita aquí, y configuramos el patrón URL como servicio web en CXFServlet, por lo que la URL final es la misma que la anterior.
Podemos ver el efecto:
Esto demuestra que nuestra implementación fue exitosa.
Puede usar la clase de prueba anterior para probar nuevamente. Tenga en cuenta que debe modificar la dirección a la URL que publicamos.
CXF es un poco más conciso que xfire. Aunque agrega algunas anotaciones, estas son inocuas. Simplemente concentra la información en los servicios anteriores.xml en la clase, lo cual es más conveniente de mantener. Sin embargo, esto sigue siendo una cuestión de opinión. A algunas personas les gustan los archivos de configuración, mientras que otras no. Además, el método de llamadas de CXF es más conciso, y tiene un volumen de código más pequeño que XFIRS, lo cual es una mejora importante.
Algunos amigos tienen algunos problemas durante el proceso de construcción, por lo que están exentos de responder uno por uno. El código se publica aquí. Los amigos necesitados pueden descargarlo.
No se colocan todos los paquetes en el directorio LIB, solo coloque todos los paquetes en CXF.
NOTA: El IDE utilizado es idea, y la estructura del archivo no es común al eclipse. Si necesita usarlo en Eclipse, puede copiar directamente el código y los archivos al proyecto recién creado en Eclipse.
Jersey
Echemos un vistazo a su uso básico.
Echemos un vistazo a un proyecto. Antes de comenzar el proyecto, debe descargar el paquete usted mismo: https://maven.java.net/content/repositories/releases/com/sun/jersey/to ejecutar el ejemplo, debe descargar tanto el servidor como el cliente. Por supuesto, no quiero encontrar tantos, así que puedo descargar directamente este paquete ZIP. https://maven.java.net/service/local/artifact/maven/redirect?r=releases&g=com.sun.jersey&a=jersey-archive&v=1.10&e=zip
1) Solo haz Javabean
@Xmlrootelement public class Reader implementa serializable {private static final long serialversionUid = 1l; nombre de cadena privada; contraseña de cadena privada; public lerer () {} public lector (nombre de cadena, contraseña de cadena) {this.name = name; this.password = contraseña; } // omitir el método get/set public string toString () {return "name:"+name+", contraseña:"+contraseña; }} Aquí se usa una etiqueta, que representa el tipo cuando regresa, es decir, esta clase de lector se puede usar para la devolución XML.
2) Si desea utilizar una clase de servicio, ya no necesita interactuar como CXF y XFIRE en el pasado. Simplemente use una clase directamente.
@Path ("/ReaderService/{name}/{Password}") public class Readerservice {@get @produce (mediAtype.application_json) lector público getReader (@pathparam ("name") name de cadena, @pathparam ("contraseña") cadena contraseña) {return New lector (nombre, contraseña); } public static void main (string [] args) lanza ilegalargumentException, ioexception, urisyntaxException {httpserver servidor = httpserverFactory.create ("http: // localhost: 8080/"); servidor.start (); }} En este momento, se usaron varias etiquetas. Path cree que los amigos que han usado SpringMVC deberían conocer esta forma de escribir, lo cual es una coincidencia de URL. Si no está claro, puede ir y echar un vistazo primero. La etiqueta GET indica que este método solo se puede acceder a través del método GET, mientras que Produce indica el resultado generado, lo que significa que el sistema encerrará el objeto del lector en un resultado JSON y lo devolverá.
No importa si no entiendes, puedes entenderlo después de un tiempo.
Y en este momento hay un método principal, creo que hay grandes preguntas. Este es un contenedor interno ligero proporcionado por Jersey. Se puede usar temporalmente para que debugemos, pero definitivamente no es posible usar esto en uso real.
3) Escribamos una clase de prueba
public class ReadClient {public static void main (string [] args) {client cliente = client.create (); Webresource recurso = Client.Resource ("http: // localhost: 8080/readerservice/shun/123213"); Lector lector = resource.get (lector.class); System.out.println (lector); }} Código muy simple, debe entenderlo. Un objeto cliente, solicita un servicio web, devuelve un recurso y luego el recurso llama directamente al método correspondiente. Por supuesto, este método coincide con nuestra URL.
Aquí lo probaremos primero con un servicio liviano que viene con él. Ejecute ReaderService directamente, que contiene un método principal. Después de ejecutar, ejecutamos ReaderClient y podemos ver que el resultado es:
El resultado es correcto.
Por supuesto, no queremos usar el servicio liviano que viene con él como nuestro servidor. Necesitamos ponerlo en el mismo servidor que nuestro proyecto, como Tomcat, JBoss, etc.
4) Por supuesto, Web.xml es indispensable para proyectos web.
<? xml versión = "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"> <ervlet> <ervlet-name> <Servlet-class> com.sun.jersey.spi.container.servlet.servletContainer </servlet-class> <load-on-startup> 1 </load-on-startup> </servlet> <servlet-mapping> <ervlet-name> jersey aplicación web </servlet-name> <uRl-pattern>/rest/*</rl-pattern> </servlet> <velceed-file-list> <Welcome-file> index.jsp </leadde-file> </le bienvenido-file-list> </beb-app>
En este momento, toda la ruta del resto especificada será interceptada por Jersey.
Nos desplegamos en Tomcat y lo iniciamos y luego volvemos a ejecutar el ReaderClient. Tenga en cuenta que primero debemos modificar la ruta de recursos:
Webresource Resource = Client.Resource ("http: // localhost: 8080/jerseywebservice/REST/readerservice/shun/123213"); El nombre de mi proyecto es JerseyWebService, por favor modifíquelo de acuerdo con el nombre de su proyecto.
Después de la modificación, lo volvemos a ejecutar, y los resultados son los siguientes:
De acuerdo con los resultados anteriores, significa que el efecto de implementación es el mismo y también es correcto.