Cxf
O CXF é implementado com base no XFire.
1) Primeiro de tudo, ainda é o problema dos pacotes. Você pode baixar a versão mais recente do CXF em http://cxf.apache.org/download.html. Claro, eu uso a versão mais recente. Em seguida, é o absurdo, construa um projeto da web e coloque -o em um pacote JAR. Não escolhemos pacotes de jar, colocamos todos eles.
Veremos que ele contém o pacote JAR da primavera. Quando precisamos implantar o CXF como um projeto da Web, precisamos usar o arquivo de configuração do Spring, que será discutido posteriormente.
Ou classe de interface e classe de implementação:
@WebService Public Interface IRADERSERVICE {public Reader GetReader (@WebParam (name = "name") Nome da string,@webparam (name = "senha") senha); Lista pública <Leoter> getReaders (); } @WebService (endpointInterface = "com.cxf.servlet.ireaderService", serviceName = "ReaderService") Classe public ReaderService implementa IReaderService {public Reader getReader (@webparam (name = "name") Nome,@webparam (name = "") } Lista pública <LeerDer> getReaders () {list <erader> leitorList = new ArrayList <erader> (); leitorlist.add (novo leitor ("shun1", "123")); leitorlist.add (novo leitor ("shun2", "123")); Retornar Readerlist; }} Exceto pela adição de anotações, essas duas classes são as mesmas mencionadas ontem. Eu não vou falar sobre isso aqui. Para explicações das anotações, você pode dar uma olhada na documentação do Javaee. Mas deve ser fácil entender de acordo com o significado.
Em seguida é Javabean, ou a classe do leitor:
public class Reader {private estático final serialversionuid = 1L; nome de string privado; senha de sequência privada; public reader () {} public leitor (nome da string, senha da string) {this.name = name; this.password = senha; } // Método Get/Set omite public String tostring () {return "Name:"+Name+", senha:"+senha; }} O acima foi escrito.
2) Queremos usá -lo como um projeto da web? Não se preocupe, não use agora. O CXF vem com um serviço de contêiner leve, que é equivalente ao próprio Spring, fornecendo contêineres do IOC. Podemos usá -lo para testar se nossa implantação foi bem -sucedida.
Vamos apenas fazer uma aula de teste:
public static void main (string [] args) {System.out.println ("Servidor está começando ..."); ReaderService ReaderService = new ReaderService (); Endpoint.publish ("http: // localhost: 8080/leitorService", leitura); System.out.println ("O servidor é iniciado ..."); } Muito simples. Não há problema em publicar diretamente o endereço e especificar a interface ou classe. Estou usando aulas aqui, mas tente usar interfaces. Afinal, a programação orientada para a interface é a verdadeira idéia orientada a objetos.
Vamos começar a ver os resultados:
Vemos que a startup foi concluída e, em seguida, iniciamos o navegador para ver se é bem -sucedido.
Digite diretamente http: // localhost: 8080/ReaderService? WSDL no navegador, podemos ver:
Ele gera o arquivo WSDL de que precisamos, indicando que o implantamos com sucesso.
3) Depois que a implantação for bem -sucedida, chamaremos. Sua chamada também é bastante simples. É semelhante ao Xfire. Você pode obter a interface e depois chamar o método como a classe local.
public static void main (string [] args) {JaxwsProxyFactoryBean FactoryBean = new JaxwsProxyFactoryBean (); FactoryBean.SetServiceClass (IRADERSERVICE.CLASS); FactoryBean.SetAddress ("http: // localhost: 8080/leitorService"); IRADERERSERVICE READERSERVICE = (IRADERSERVICE) FactoryBean.create (); Leitor leitor = leitorservice.getReader ("shun", "123"); System.out.println ("leitor:"+leitor); } É muito simples aqui. Você pode obter uma classe de fábrica, definir diretamente a interface e o endereço e criar para obter a interface correspondente. Como o XFire, você também precisa definir o protótipo da interface primeiro, caso contrário, essas chamadas não terão como iniciar.
Corremos para obter o resultado:
Não tem problema, é consistente com os resultados que esperávamos.
4) Mas, em muitos casos, não queremos que nosso Serviço da Web e nosso aplicativo separe dois servidores, mas queremos que eles estejam no mesmo contêiner, Tomcat ou JBoss ou outro, por isso devemos implantar o serviço da Web que concluímos anteriormente na Web.
Observe que precisamos usar arquivos de definição de primavera aqui.
Primeiro veja 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.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" = "3.0">>> <xectlent> <xtembel> <xtembel> <xtembel> <xectlent> <xectlent> <xectlent> <xtembel> <xectlent> <xectlent> <xectlent> " <amam-value> web-inf/beans.xml </param-value> </context-param> <lister> <lister-class> org.springframework.web.context.contextloaderListener </irvier-class> </irister> <Verportleame> <Vertlet-Name> CXFSERVlet </ouvinte> <Servlet-class-class> org.apache.cxf.transport.servlet.cxfservlet </servlet-class> </servlet> <Verlet-Mapping> <Verlet-name> cxfservlet </ervlet-name> <url-stattern>/webvice/*</url-tattern> </servlet-Mapping>
É muito simples aqui, basta especificar o ouvinte da mola e o caminho do arquivo de configuração correspondente e especificar o método de interceptação CXF.
Em seguida, dê uma olhada no Beans.xml:
<? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xmlns:jaxws="http://cxf.apache.org/jaxws" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd "> <importação Resource =" ClassPath: meta-infemMemn/cxf/cxf.xm Resource = "Classpath: meta-inf/cxf/cxf-extension-soap.xml"/> <importar recursos = "classpath: meta-inf/cxf/cxf -servlet.xml"/> <jaxws: endpoint id = "readervicce2" implement = "com.cxf.Servlet.ServErSeReReRSICE.Fread.2)
É muito simples aqui, basta definir um serviço da web através do JAXWS: ENDPONS. O implementador é a classe de processamento do WebService, e o endereço é seu caminho de acesso, semelhante ao Serviço Leitor que escrevemos anteriormente.
Neste momento, podemos implantá -lo no tomcat e pode ser acessado diretamente através do http: // localhost: 8080/cxfwebService/web Service/ReaderService2? WSDL.
Alguns amigos perguntarão por que o URL que você visitou desta vez é diferente do anterior. De fato, o endereço de acesso anterior é definido por nós mesmos, e o endereço do WebService aqui está configurado no arquivo de configuração e é implantado por meio de um projeto da Web. O nome do projeto é necessário aqui e configuramos o padrão de URL como um serviço da web no CXFServlet, portanto o URL final é o mesmo que acima.
Podemos ver o efeito:
Isso prova que nossa implantação foi bem -sucedida.
Você pode usar a classe de teste anterior para testar novamente. Observe que você precisa modificar o endereço para o URL que publicamos.
O CXF é um pouco mais conciso que o XFire. Embora acrescente algumas anotações, elas são inócuas. Ele apenas concentra as informações nos serviços anteriores.xml na classe, o que é mais conveniente de manter. No entanto, isso ainda é uma questão de opinião. Algumas pessoas gostam de arquivos de configuração, enquanto outras não. Além disso, o método de chamada de CXF é mais conciso e possui um volume menor de código que o XFire, o que é uma grande melhoria.
Alguns amigos têm alguns problemas durante o processo de construção, por isso estão isentos de responder um por um. O código foi lançado aqui. Amigos necessitados podem baixá -lo.
Todos os pacotes no diretório Lib não são colocados, basta colocar todos os pacotes no CXF.
Nota: O IDE usado é a ideia e a estrutura do arquivo não é comum ao eclipse. Se você precisar usá -lo no Eclipse, poderá copiar diretamente o código e os arquivos para o projeto recém -criado no Eclipse.
Jersey
Vamos dar uma olhada em seu uso básico.
Vamos dar uma olhada em um projeto. Antes de iniciar o projeto, você deve fazer o download do pacote: https://maven.java.net/content/repositories/releases/com/sun/jersey/to executar o exemplo, você precisa baixar o servidor e o cliente. É claro que não quero encontrar tantos, para que eu possa baixar diretamente este pacote 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) Basta fazer Javabean
@XmlrootElement public classe leitor implementa serializável {private estático final serialversionuid = 1L; nome de string privado; senha de sequência privada; public reader () {} public leitor (nome da string, senha da string) {this.name = name; this.password = senha; } // omita o método get/set public string tostring () {return "nome:"+nome+", senha:"+senha; }} Uma tag é usada aqui, que representa o tipo quando retorna, ou seja, essa classe do leitor pode ser usada para retorno XML.
2) Se você deseja usar uma classe de serviço, não precisa mais interface como CXF e XFire no passado. Basta usar uma classe diretamente.
@Path ("/ReaderService/{name}/{senha}") public class ReaderService {@get @produces (mediatype.application_json) public leitor getReader (@pathparam ("name") string name, @pathparam ("senha") senha) {return New Reader (name "); } public static void main (string [] args) lança ilegalArgumentException, IoException, urisyntoxException {httpServer server = httpServerFactory.create ("http: // localhost: 8080/"); server.start (); }} Neste momento, várias tags foram usadas. Path acredita que os amigos que usaram o SpringMVC devem saber essa maneira de escrever, que é a correspondência de URL. Se você não estiver claro, pode ir e dar uma olhada primeiro. A tag get indica que esse método só pode ser acessado através do método GET, enquanto produz o resultado gerado, o que significa que o sistema envolverá o objeto do leitor em um resultado JSON e o retornará.
Não importa se você não entende, pode entender depois de um tempo.
E neste momento há um método principal, acredito que há grandes questões. Este é um contêiner interno leve fornecido por Jersey. Ele pode ser usado temporariamente para depurar, mas definitivamente não é possível usar isso em uso real.
3) Vamos escrever uma aula de teste
classe pública ReadClient {public static void main (string [] args) {client client.cruste.create (); WebResource Resource = client.resource ("http: // localhost: 8080/leitorService/shun/123213"); Leitor leitor = resource.get (leitor.class); System.out.println (leitor); }} Código muito simples, você deve entender. Um objeto cliente, solicita um serviço da web, retorna um recurso e, em seguida, o recurso chama diretamente o método correspondente. Obviamente, esse método é comparado com o nosso URL.
Aqui vamos testá -lo primeiro com um serviço leve que o acompanha. Execute o ReaderService diretamente, que contém um método principal. Depois de correr, corremos o ReadClient e podemos ver que o resultado é:
O resultado está correto.
É claro que não queremos usar o serviço leve que o acompanha como servidor. Precisamos colocá -lo no mesmo servidor que nosso projeto, como Tomcat, Jboss, etc.
4) Obviamente, o web.xml é indispensável para projetos da 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.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" = "3.0">> <er Sertlet> <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>Jersey Web Application</servlet-name> <url-pattern>/rest/*</url-pattern> </servlet-mapping> <lorde-arquivo de boas-vindas> <lmed-fil-bile> index.jsp </chailt-fil-bile> </list-list> </web-app>
Neste momento, todo o caminho especificado será interceptado por Jersey.
Implantamos para o Tomcat e o iniciamos e depois executamos novamente o ReadClient. Observe que precisamos modificar o caminho dos recursos primeiro:
WebResource Resource = client.resource ("http: // localhost: 8080/jerseywebservice/REST/ReaderService/Shun/123213"); O nome do meu projeto é JerseywebService, modifique -o de acordo com o nome do seu projeto.
Após a modificação, nós a executamos e os resultados são os seguintes:
Consistente com os resultados acima, significa que o efeito de implantação é o mesmo e também está correto.