客户端调用CXF与spring集成发布的Rest服务

最新推荐文章于 2021-11-20 16:35:10 发布
最新推荐文章于 2021-11-20 16:35:10 发布
阅读量452 收藏 1
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wly926454926632/article/details/88708086
版权

近期，因工作需要，接触到CXF与spring集成发布Rest服务，并实现客户端与服务器端的交互，上网查阅相关资料发现CXF与spring集成发布Rest服务的相关文章较多，但涉及到客户端访问服务器的相关资料确很少，几经周折，整合前人的经验，搭建好此框架之后，觉得有必要记录一下，一方面可以巩固一下流程，另一方面，希望能帮助更多有需要的人！

服务器端的搭建

第一步 Spring 框架环境搭建

1.maven 创建普通 java 工程并调整整体工程环境 

 

2.项目目录：

 

第二步 配置相关文件

1.添加maven依赖（以下没有用到的可以不添加）

<dependencies>
  <!-- 单元测试 -->
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
  </dependency>
  <!--spring-->
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <!-- 数据库相关 -->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.38</version>
  </dependency>
  <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.0.15</version>
  </dependency>
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.2.8</version>
  </dependency>
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.2.5</version>
  </dependency>
  <!-- 日志相关 -->
  <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.26</version>
  </dependency>
  <!--CXF-->
  <dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-rt-rs-service-description</artifactId>
    <version>${cxf.version}</version>
  </dependency>
  <dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-rt-rs-extension-providers</artifactId>
    <version>${cxf.version}</version>
  </dependency>
  <!--Jackdon-->
  <dependency>
    <groupId>org.codehaus.jackson</groupId>
    <artifactId>jackson-jaxrs</artifactId>
    <version>1.9.13</version>
  </dependency>
  <!-- aspectJ AOP 织入器 -->
  <dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.7</version>
  </dependency>
  <!-- apache lang3工具包 -->
  <dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.4</version>
  </dependency>
</dependencies>

2.配置web.xml文件

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
         http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0">

  <!-- Spring -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring.xml</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <!-- CXF -->
  <servlet>
    <servlet-name>cxf</servlet-name>
    <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>cxf</servlet-name>
    <url-pattern>/ws/*</url-pattern>
  </servlet-mapping>

</web-app>

第三步、REST服务接口以及实现类

1.在项目目录下新建bean包，在bean文件夹下创建Product类

package com.spring.rest.bean;

public class Product {
    private long id;
    private String name;
    private int price;

    public Product() {
    }

    public Product(long id, String name, int price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

}

2.在项目目录下新建service包，在service包下新建impl包和inter包，在impl下新建ProductServiceImpl类，在inter包下新建ProductService接口（项目目录如上）

ProductServiceImpl类中内容：

package com.spring.rest.service.impl;

import com.lenovo.rest.bean.Product;
import com.lenovo.rest.service.inter.ProductService;

import java.lang.reflect.Field;
import java.util.*;

public class ProductServiceImpl implements ProductService {
    private static final List<Product> productList = new ArrayList<Product>();
    static {
        productList.add(new Product(1, "iphone63", 5000));
        productList.add(new Product(2, "ipad mini", 2500));
    }

    @Override
    public List<Product> retrieveAllProducts() {

        Collections.sort(productList, new Comparator<Product>() {

            @Override
            public int compare(Product p1, Product p2) {
                return (p1.getId() > p2.getId()) ? -1 : 1;
            }
        });
        return productList;
    }

    @Override
    public Product retrieveProductById(long id) {
        Product targetProduct = null;
        for (Product product : productList) {
            if (product.getId() == id) {
                targetProduct = product;
                break;
            }
        }
        return targetProduct;
    }

    @Override
    public List<Product> retrieveProductsByName_param(String name){
        List<Product> targetList = new ArrayList<Product>();
        for (Product product : productList) {
            if (product.getName().equals(name)) {
                targetList.add(product);
            }
        }
        return targetList;
    }
    @Override
    public List<Product> retrieveProductsByName_form(String name) {
        List<Product> targetList = new ArrayList<Product>();
        for (Product product : productList) {
            if (product.getName().equals(name)) {
                targetList.add(product);
            }
        }
        return targetList;
    }

    @Override
    public Product createProduct(Product product) {
        product.setId(new Date().getTime());
        productList.add(product);
        return product;
    }

    @Override
    public Product createProduct(String name,int price){
        Product product = new Product();
        product.setId(new Date().getTime());
        product.setName(name);
        product.setPrice(price);

        productList.add(product);
        return product;
    }

    @Override
    public Product updateProductById(long id, Map<String, Object> fieldMap) {
        Product product = retrieveProductById(id);
        if (product != null) {
            try {
                for (Map.Entry<String, Object> fieldEntry : fieldMap.entrySet()) {
                    Field field = Product.class.getDeclaredField(fieldEntry
                            .getKey());
                    field.setAccessible(true);
                    field.set(product, fieldEntry.getValue());

                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return product;
    }

    @Override
    public Product updateProduct(Product product){
        if(product != null){
            Product targetProduct = retrieveProductById(product.getId());
            if(targetProduct != null){
                targetProduct.setName(product.getName());
                targetProduct.setPrice(product.getPrice());
            }

            return targetProduct;
        }

        return null;
    }

    @Override
    public Product updateProduct(long id,String name,int price){
        Product product = retrieveProductById(id);
        if(product != null){
            product.setName(name);
            product.setPrice(price);
        }

        return product;
    }

    @Override
    public Product deleteProductById(long id) {
        Product targetProduct = null;
        Iterator<Product> it = productList.iterator();
        while (it.hasNext()) {
            Product product = it.next();
            if (product.getId() == id) {
                targetProduct = product;
                it.remove();
                break;
            }
        }
        return targetProduct;
    }

    @Override
    public Product deleteProductById_param(long id){
        Product targetProduct = null;
        Iterator<Product> it = productList.iterator();
        while (it.hasNext()) {
            Product product = it.next();
            if (product.getId() == id) {
                targetProduct = product;
                it.remove();
                break;
            }
        }
        return targetProduct;
    }
}

ProductService接口中的内容：

package com.spring.rest.service.inter;

import com.spring.rest.bean.Product;

import java.util.List;
import java.util.Map;

import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.FormParam;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;


public interface ProductService {
    @GET
    @Path("/products")
    @Produces(MediaType.APPLICATION_JSON)
    List<Product> retrieveAllProducts();

    @GET
    @Path("/product/{id}")
    @Produces(MediaType.APPLICATION_JSON)
    Product retrieveProductById(@PathParam("id")long id);

    /**
     * 参数查询
     * @param name
     * @return
     */
    @GET
    @Path("/products/name")
    @Produces(MediaType.APPLICATION_JSON)
    List<Product> retrieveProductsByName_param(@QueryParam("name")String name);

    /**
     * 提交表单查询
     * @param name
     * @return
     */
    @POST
    @Path("/products/form/name")
    @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
    @Produces(MediaType.APPLICATION_JSON)
    List<Product> retrieveProductsByName_form(@FormParam("name")String name);


    @POST
    @Path("/product")
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)
    Product createProduct(Product product);

    @POST
    @Path("/product/create")
    @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
    @Produces(MediaType.APPLICATION_JSON)
    Product createProduct(@FormParam("name")String name,@FormParam("price")int price);

    @PUT
    @Path("/product/{id}")
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)
    Product updateProductById(@PathParam("id")long id,Map<String,Object> fieldMap);

    @PUT
    @Path("/product")
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)
    Product updateProduct(Product product);

    @PUT
    @Path("/product/update")
    @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
    @Produces(MediaType.APPLICATION_JSON)
    Product updateProduct(@FormParam("id")long id,@FormParam("name")String name,@FormParam("price")int price);

    @DELETE
    @Path("/product/{id}")
    @Produces(MediaType.APPLICATION_JSON)
    Product deleteProductById(@PathParam("id")long id);

    @DELETE
    @Path("/product")
    @Produces(MediaType.APPLICATION_JSON)
    Product deleteProductById_param(@QueryParam("id")long id);

}

3.配置xml文件

在main文件下新建resources文件，如下图，点击右上角，将resources文件设置成源文件

在resources文件下新建spring.xml和spring-cxf.xml

 

spring.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <bean id="productServiceImpl" class="com.lenovo.rest.service.impl.ProductServiceImpl"></bean>
    <import resource="spring-cxf.xml"/>

</beans>



spring-cxf.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:jaxrs="http://cxf.apache.org/jaxrs"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http://cxf.apache.org/jaxrs
       http://cxf.apache.org/schemas/jaxrs.xsd">


    <jaxrs:server address="/rest">
        <jaxrs:serviceBeans>
            <ref bean="productServiceImpl"/>
        </jaxrs:serviceBeans>
        <jaxrs:providers>
            <bean class="org.codehaus.jackson.jaxrs.JacksonJsonProvider"/>
        </jaxrs:providers>
    </jaxrs:server>



</beans>

 

第四步，调用REST服务

index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Demo</title>
    <link href="http://apps.bdimg.com/libs/bootstrap/3.3.4/css/bootstrap.min.css" rel="stylesheet">
    <link href="http://cdn.bootcss.com/bootstrap/3.2.0/css/colorbox.css" rel="stylesheet" type="text/css" />
    <script src="https://apps.bdimg.com/libs/jquery/2.1.4/jquery.min.js" type="text/javascript"></script>
    <script type="text/javascript" src="http://apps.bdimg.com/libs/bootstrap/3.3.4/js/bootstrap.min.js"></script>
    <script type="text/javascript" src="https://cdn.bootcss.com/handlebars.js/4.1.0/handlebars.js"></script>
</head>
<body>
<br>
<br>
<div class="container">
   <form role="form" id="form_name">
   <div class="form-group">
      <label for="input_name">根据名称检索</label>
      <input type="text" class="form-control" id="input_name" placeholder="名称" name="name"/>
   </div>
   <button id="submit_name" type="button" class="btn btn-default">检索</button>
   </form>
   <form role="form" id="form_create">
   <div class="form-group">
      <label for="input_create_name">名称</label>
      <input type="text" class="form-control" id="input_create_name" placeholder="名称" name="name"/>
   </div>
   <div class="form-group">
      <label for="input_create_price">价格</label>
      <input type="text" class="form-control" id="input_create_price" placeholder="价格" name="price"/>
   </div>
   <button id="submit_create" type="button" class="btn btn-default">添加</button>
   </form>
   <div class="panel panel-default">
      <button id="all" type="button" class="btn btn-default">RetrieveAll</button>
      <button id="byID" type="button" class="btn btn-default">RetrieveByID</button>
      <button id="name" type="button" class="btn btn-default">RetrieveByName</button>
   </div>
    <div class="page-header">
        <h1>Product</h1>
    </div>
    <div class="panel panel-default">
        <div class="panel-heading">Product List</div>
        <div class="panel-body">
            <div id="product"></div>
        </div>
    </div>
</div>

<script type="text/x-handlebars-template" id="product_table_template">
    {{#if data}}
        <table class="table table-hover" id="product_table">
            <thead>
                <tr>
                    <th>ID</th>
                    <th>Product Name</th>
                    <th>Price</th>
                </tr>
            </thead>
            <tbody>
                {{#data}}
                    <tr data-id="{{id}}" data-name="{{name}}">
                        <td>{{id}}</td>
                        <td>{{name}}</td>
                        <td>{{price}}</td>
                    </tr>
                {{/data}}
            </tbody>
        </table>
    {{else}}
        <div class="alert alert-warning">Can not find any data!</div>
    {{/if}}
</script>

<script>
    $(function() {
       //检索所有
       $("#all").click(function(){
          $("#product").html("");
          $.ajax({
                type: 'get',
                url: 'http://localhost:8080/springCxfREST/ws/rest/products',
                dataType: 'json',
                success: function(data) {
                    var template = $("#product_table_template").html();
                    var render = Handlebars.compile(template);
                    var html = render({
                        data: data
                    });
                    $('#product').html(html);
                }
            });
       });

       //根据ID检索
       $("#byID").click(function(){
          $("#product").html("");
          $.ajax({
                type: 'get',
                url: 'http://localhost:8080/springCxfREST/ws/rest/product/1',
                dataType: 'json',
                success: function(data) {
                    var template = $("#product_table_template").html();
                    var render = Handlebars.compile(template);
                    var html = render({
                        data: data
                    });
                    $('#product').html(html);
                }
            });
       });

       //根据名称检索
       $("#name").click(function(){
          $("#product").html("");
          $.ajax({
                type: 'get',
                url: 'http://localhost:8080/springCxfREST/ws/rest/products/name?name=ipad mini',
                dataType: 'json',
                success: function(data) {
                    var template = $("#product_table_template").html();
                    var render = Handlebars.compile(template);
                    var html = render({
                        data: data
                    });
                    $('#product').html(html);
                }
            });
       });

       //提交表单，根据名称检索
       $("#submit_name").click(function(){
          $("#product").html("");
          $.ajax({
                type: 'post',
                url: 'http://localhost:8080/springCxfREST/ws/rest/products/form/name?'+$("#form_name").serialize(),
                dataType: 'json',
                success: function(data) {
                    var template = $("#product_table_template").html();
                    var render = Handlebars.compile(template);
                    var html = render({
                        data: data
                    });
                    $('#product').html(html);
                }
            });
       });

       /* 提交表单，添加数据 */
       $("#submit_create").click(function(){
          $("#product").html("");
          $.ajax({
                type: 'post',
                url: 'http://localhost:8080/springCxfREST/ws/rest/product/create?'+$("#form_create").serialize(),
                dataType: 'json',
                success: function(data) {
                    var template = $("#product_table_template").html();
                    var render = Handlebars.compile(template);
                    var html = render({
                        data: data
                    });
                    $('#product').html(html);
                }
            });
       });
       /*使用jQuery发送基于JSONP的AJAX请求*/
       $.ajax({
            type: 'get',
            url: 'http://localhost:8080/springCxfREST/ws/rest/products',
            dataType: 'jsonp',
            jsonp: '_jsonp',
            jsonpCallback: 'callback',
            success: function(data) {
                var template = $("#product_table_template").html();
                var render = Handlebars.compile(template);
                var html = render({
                    data: data
                });
                $('#product').html(html);
            }
        });


    });

    function goColorBox(){
        $("#goOne").colorbox({ opacity:0.65,width: 500, height:500, close: "关闭", overlayClose: true});
  }
</script>
</body>
</html>

第五步，发布并访问

1.配置tomcat及端口（pom.xml）

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.tomcat.maven</groupId>
      <artifactId>tomcat7-maven-plugin</artifactId>
      <version>2.2</version>
      <configuration>
        <port>8080</port>
        <path>/springCxfREST</path>
        <uriEncoding>UTF-8</uriEncoding>
        <server>tomcat7</server>
      </configuration>
    </plugin>
  </plugins>
</build>

2.将打包的压缩文件设置为.war文件

在pom.xml文件中加入<packaging>war</packaging>

如下：

<groupId>com.spring.REST</groupId>
<artifactId>REST</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>

3.点击右上角，Maven下的install开始打包

 打包成功后开始运行

 

客户端搭建

重新搭建一个spring框架，环境搭建和服务器端一样

1.项目目录：

 

2.配置pom.xml

<!--CXF-->
<dependency>
  <groupId>org.apache.cxf</groupId>
  <artifactId>cxf-rt-rs-service-description</artifactId>
  <version>${cxf.version}</version>
</dependency>
<dependency>
  <groupId>org.apache.cxf</groupId>
  <artifactId>cxf-rt-rs-client</artifactId>
  <version>${cxf.version}</version>
</dependency>
<!--Jackdon-->
<dependency>
  <groupId>org.codehaus.jackson</groupId>
  <artifactId>jackson-jaxrs</artifactId>
  <version>1.9.13</version>
</dependency>

3.将服务器端Product类和ProductService接口复制过来

新建WebClientTest类

package com.spring.rest.client;

import org.apache.cxf.jaxrs.client.JAXRSClientFactory;
import org.codehaus.jackson.jaxrs.JacksonJsonProvider;

import java.util.ArrayList;
import java.util.List;

public class JAXRSClient {

    public static void main(String[] args) {
        JacksonJsonProvider jsonProvider = new JacksonJsonProvider();
        List<Object> providerList = new ArrayList<Object>();
        providerList.add(jsonProvider);
        ProductService us = JAXRSClientFactory.create("http://localhost:8080/springCxfREST/ws/rest",ProductService.class,providerList);
        List<Product> products = us.retrieveAllProducts();
        System.out.println(products.size());
        Product product = us.retrieveProductById(1);
        System.out.println(product.toString());

    }

}

启动服务器端，运行客户端main方法

运行结果

 

wly926454926632
关注
使用Spring Boot整合MyBatis和CXF实现RESTful API和WebService API
JipForth的博客
09-21 180
在现代的软件开发中，构建高效且易于维护的API是至关重要的。使用Spring Boot框架，我们可以轻松地整合MyBatis和CXF，以实现RESTful API和WebService API。通过整合Spring Boot、MyBatis和CXF，我们可以轻松地构建具有RESTful API和WebService API的强大API。这个控制器定义了RESTful API的各种操作，包括获取所有用户、根据ID获取用户、创建用户、更新用户和删除用户。这个类实现了WebService API的各种操作。
接受json格式的CXF+Spring整合的REST的服务完整接口实例
11-19
发布CXF+Spring整合的REST的服务接口完整实例，其中包括数据库连接池，json数据格式传递数据，HttpURLConne的get和post方式调用接口，以及获取访问者ip地址工具类等众多的技术实例。
Spring整合ApacheCXF实现基于Restful风格的WebService（基于jaxrs）
weixin_43472934的博客
11-20 836
1.服务端 1.1 创建web maven项目 1.2 添加依赖pom.xml <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> <
构建一个简单的spring-boot的RESTful Client项目
blinking_cursor_I
02-13 253
概括： 本案例涉及两个项目：restful web service项目和restful Client项目 restful web service项目提供restful服务 restful Client项目消费和使用restful web service项目提供的restful服务 1. 准备restful web service项目 pom.xml依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven
Apache CXF使用JAXRSClientFactoryBean创建Client时的原则及连接管理机制的Bug
witmind的专栏
01-15 2853
创建原则：     每一个JAXRSClientFactoryBean只创建一个Client，不要创建多个，如需要多线程访问则预先调用JAXRSClientFactoryBean的setThreadSafe(true)开启多线程支持     原因：         同一个JAXRSClientFactoryBean对象创建的Client会共用同一个ConduitSelector      
CXF学习笔记三（发布restFul）
lgxzzz的博客
09-16 688
一、概述 JAX-RS是Java提供用于开发RESTful Web服务基于注解(annotation)的API。JAX-RS旨在定义一个统一的规范，使得Java程序员可以使用一套固定的接口来开发REST应用，避免了依赖第三方框架。同时JAX-RS使用POJO编程模型和基于注解的配置并集成JAXB，可以有效缩短REST应用的开发周期。JAX-RS只定义RESTful API，具体实现由第三方提供，如Jersey、Apache CXF等。 JAX-RS包含近五十多个接口、注解和抽象类： javax.w
cxf+spring发布webservice和restservice
12-07
本项目“cxf+spring发布webservice和restservice”专注于利用Apache CXF框架与Spring框架结合，实现这两种服务的发布。Apache CXF是一个开源的、功能丰富的服务栈，它使得开发者能够轻松地构建和部署SOAP和RESTful ...
Apache CXF + Spring3 + REST + JSON配置
09-01
- 可以使用CXF的内置WS-Security审计日志，以及Spring AOP（Aspect-Oriented Programming）进行服务调用的跟踪和性能分析。 - 使用CXF的WS-Addressing和WS-Policy功能增强服务的管理和调试能力。 以上是关于...
CXF整合spring的客户端和服务端
08-23
综上所述，"CXF整合Spring的客户端和服务端"是一个全面的示例，涵盖了从服务创建到客户端调用的全过程，对于理解和实践SOA和Web服务开发具有很高的价值。同时，提供的文档和配置文件可以帮助开发者快速上手，节省了...
spring cxf rest demo
12-21
【Spring CXF REST Demo】项目是一个使用Maven构建的Java应用程序，它展示了如何将Spring框架与Apache CXF集成，以创建RESTful风格的服务。在这个项目中，开发者可以学习到如何利用CXF作为服务端的REST服务提供者，...
使用CXF暴露您的REST服务
12-14
使用CXF暴露您的REST服务 简单的例子，完整的配置过程
springBoot完整整合WebService框架CXF示例
02-27
完整可用的spring整合CXF示例项目,包括服务发布端和调用端两个项目,包括CXF拦截器的实现的简单的授权校验
使用CXF创建WebService
yangyi5211030的博客
03-10 665
最近几天咱倒腾WebService,因为实验室部分项目使用的WebService，但是没有集成Spring，使用jdbc访问数据库，采用最原始的方法，想改变一下这种架构模式，在探索的路上踩了不少的坑，也从网上找过不少例子，但基本上都跑不起来，其中在版本不兼容的问题上耗费了很长的时间。以此来记录防止大家再去踩同样的坑。 工程目录结构 1 pom.xml &lt;properties...
为cxf服务加上wadl描述信息
liyangbing的专栏
03-18 2111
为cxf服务加上wadl描述信息 我们在开发cxf rest服务的时候，往往需要为每个服务添加描述文档，以前我们可能是将描述文档用word或者excel记录，现在介绍一种通过cxf-rt-rs-service-description自动生成wadl描述文档的方法。 1. 首先我们在项目中引入cxf-rt-rs-service-description包，通过maven方式构建
Spring boot 整合CXF开发web service
热门推荐
程序猿开发日志【学习永无止境】
04-12 3万+
前言 说起web service最近几年restful大行其道，大有取代传统soap web service的趋势，但是一些特有或相对老旧的系统依然使用了传统的soap web service，例如银行、航空公司的机票查询接口等。 目前就遇到了这种情况，需要在系统中查询第三方提供的soap web service接口，也就是说要将它整合进现有的系统当中。 Spring整合CXF本
使用CXF开发RESTFul服务
rockiecxh的专栏
02-26 1万+
使用CXF开发RESTFul服务 在各个系统交互领域，Web services逐渐成为主流。有两种主要方式来开发Web Services：Simple Object Access Protocol (SOAP)和Representational State Transfer (REST)   开发基于SOAP的Web Services需要很多的约束， 以便客户端和服务端交互信息，例如，使用W
CXF系列之JAX-RS:CXF发布与调用REST服务
勤劳的SKL
11-30 8814
今天我们将视角集中在 REST 上，它是继 SOAP 以后，另一种广泛使用的 Web 服务。与 SOAP 不同，REST 并没有 WSDL 的概念，也没有叫做“信封”的东西，因为 REST 主张用一种简单粗暴的方式来表达数据，传递的数据格式可以是 JSON 格式，也可以是 XML 格式，这完全由您来决定。 REST 全称是 Representational State Transfer（表述性状
关于jax-rs-client作为客户端的几种访问形式
tm7796的专栏
06-03 735
第一种 public static String sendPost(String param) { try { WebClient client = WebClient.create(host); client.reset(); client.header("Content-Type", "application/json; charset=UTF-8"); client.header("Authorization", "APPCODE " + appcode); c
Apache CXF与Spring集成实战：Tomcat部署WebService教程
本文档详细介绍了如何在Apache CXF与Spring框架的集成下，在Tomcat服务器环境下实现Web服务。首先，确保你的开发环境已配置为JDK1.5.0、Apache Tomcat 6.0.26、Spring 2.5.6以及Apache CXF 2.2.3或更高版本。接下来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值