Spring Boot整合CXF发布、调用WebService接口

最新推荐文章于 2024-07-17 03:50:34 发布
最新推荐文章于 2024-07-17 03:50:34 发布
阅读量5.6k 收藏 15
点赞数 6
分类专栏： # Spring Boot 文章标签： java spring boot cxf webservice soap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38361800/article/details/111308218
版权

WebService的概念

Web 是使应用程序可以与平台和编程语言无关的方式进行相互通信的一项技术。Web 服务是一个软件接口，它描述了一组可以在网络上通过标准化的 XML 消息传递访问的操作。它使用基于 XML 语言的协议来描述要执行的操作或者要与另一个 Web 服务交换的数据。一组以这种方式交互的 Web 服务在面向服务的体系结构（Service-Oriented Architecture，SOA）中定义了特殊的 Web 服务应用程序。

简单的说WebService是一个SOA（面向服务的编程）的架构，它是不依赖于语言，不依赖于平台，可以实现不同的语言（通过 xml 描述）间的相互调用，通过Internet进行基于Http协议的网络应用间的交互。通过SOAP在Web上提供的软件服务，使用WSDL文件进行说明，并通过UDDI进行注册。

  • XML：(Extensible Markup Language)扩展型可标记语言。面向短期的临时数据处理、面向万维网络，是Soap的基础。
  • Soap：(Simple Object Access Protocol)简单对象存取协议。是XML Web Service 的通信协议。当用户通过UDDI找到你的WSDL描述文档后，他通过可以SOAP调用你建立的Web服务中的一个或多个操作。SOAP是XML文档形式的调用方法的规范，它可以支持不同的底层接口，像HTTP(S)或者SMTP。
  • WSDL：(Web Services Description Language) WSDL 文件是一个 XML 文档，用于说明一组 SOAP 消息以及如何交换这些消息。大多数情况下由软件自动生成和使用。
  • UDDI (Universal Description, Discovery, and Integration) 是一个主要针对Web服务供应商和使用者的新项目。在用户能够调用Web服务之前，必须确定这个服务内包含哪些商务方法，找到被调用的接口定义，还要在服务端来编制软件，UDDI是一种根据描述文档来引导系统查找相应服务的机制。UDDI利用SOAP消息机制（标准的XML/HTTP）来发布，编辑，浏览以及查找注册信息。它采用XML格式来封装各种不同类型的数据，并且发送到注册中心或者由注册中心来返回需要的数据。

整合

pom

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.cxf/cxf-spring-boot-starter-jaxws -->
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-spring-boot-starter-jaxws</artifactId>
            <version>3.4.0</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web-services</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/net.sf.json-lib/json-lib -->
        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.4</version>
            <classifier>jdk15</classifier>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.73</version>
        </dependency>

yml

server:
  port: 80
  servlet:
    contest-path: /
spring:
  application:
    name: springboot-cxf
cxf:
  path: /user

接口

package com.dev.cxf.service;

import com.dev.cxf.model.DataResult;
import com.dev.cxf.model.MapAdapter;
import com.dev.cxf.model.MapListAdapter;
import com.dev.cxf.model.User;

import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @Description :  webservice接口 //描述
 */
@WebService(
        //服务名
        name = "management",
        //命名空间,一般是接口的包名倒序
        targetNamespace = "http://service.cxf.dev.com"
)
public interface Management {

    @WebMethod
    public String getName(@WebParam(name = "ip") String ip);

    @WebMethod
    public User getUser(@WebParam(name = "name") String name);

    @WebMethod
    public ArrayList<User> getUserList(@WebParam(name = "name") String name);

    @WebMethod
    public DataResult getDataResult();

    @WebMethod
    @XmlJavaTypeAdapter(MapAdapter.class)
    public Map<String, User> getUserMap();

    @WebMethod
    @XmlJavaTypeAdapter(MapListAdapter.class)
    public Map<String, List<User>> getUserMapListUser();

    @WebMethod
    public Map<String, Object> getMap(@WebParam(name = "user") User user);
}

实现

package com.dev.cxf.service.impl;

import com.dev.cxf.model.DataResult;
import com.dev.cxf.model.User;
import com.dev.cxf.service.Management;
import org.springframework.stereotype.Component;

import javax.jws.WebService;
import java.util.*;

/**
 * @Description : webservice接口实现类  //描述
 */
@Component
@WebService(
        //与接口中的命名空间一致
        targetNamespace = "http://service.cxf.dev.com",
        //接口地址
        endpointInterface = "com.dev.cxf.service.Management"
)
public class ManagementImpl implements Management {

    @Override
    public String getName(String ip) {
        return "hello world!";
    }

    @Override
    public User getUser(String name) {
        System.out.println(name);
        User user = new User();
        user.setName("cxf demo");
        user.setIp("127.0.0.1");
        return user;
    }

    @Override
    public ArrayList<User> getUserList(String name) {
        System.out.println(name);
        ArrayList<User> list = new ArrayList<User>();
        list.add(new User("ip","127.0.0.1"));
        list.add(new User("ip","127.0.0.2"));
        list.add(new User("ip","127.0.0.3"));
        return list;
    }

    @Override
    public DataResult getDataResult() {
        DataResult dataResult = new DataResult();
        List<User> list = new ArrayList<User>();
        list.add(new User("ip","127.0.0.1"));
        list.add(new User("ip","127.0.0.2"));
        Map<String, User> s = new HashMap<String, User>();
        s.put("name", new User("ip","127.0.0.1"));
        dataResult.setUserMap(s);
        dataResult.setUserList(list);
        return dataResult;
    }

    @Override
    public Map<String, User> getUserMap() {
        HashMap<String, User> s = new HashMap<String, User>();
        s.put("name",new User("ip","127.0.0.1"));
        s.put("name2",new User("ip","127.0.0.2"));
        s.put("name3",new User("ip","127.0.0.3"));
        return s;
    }

    @Override
    public Map<String, List<User>> getUserMapListUser() {
        Map<String, List<User>> s = new HashMap<String, List<User>>();
        List<User> list = new ArrayList<User>();
        list.add(new User("ip","127.0.0.1"));
        list.add(new User("ip","127.0.0.2"));
        s.put("name",list);
        s.put("name2",list);
        s.put("name3",list);
        return s;
    }

    @Override
    public HashMap<String, Object> getMap(User user) {
        System.out.println(user);
        HashMap<String, Object> s = new HashMap<String, Object>();
        s.put("ip1", "127.0.0.1");
        s.put("ip2", "127.0.0.1");
        return s;
    }
}

发布

package com.dev.cxf.config;

import com.dev.cxf.model.User;
import com.dev.cxf.service.Management;
import org.apache.cxf.Bus;
import org.apache.cxf.bus.spring.SpringBus;
import org.apache.cxf.jaxws.EndpointImpl;
import org.apache.cxf.transport.servlet.CXFServlet;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;
import javax.xml.ws.Endpoint;

/**
 * @Description :  webservice发布配置 //描述
 * @Author :   //作者
 */
@Configuration
public class WebServiceConfig {

    @Resource
    private Management management;

    @Bean(name = Bus.DEFAULT_BUS_ID)
    public SpringBus springBus(){
        return new SpringBus();
    }

    /**
     * JAX-WS
     */
    @Bean
    public Endpoint endpoint(){
        EndpointImpl endpoint = new EndpointImpl(springBus(), management);
        endpoint.publish("/test");
        return endpoint;
    }

    /**
     * 访问地址 http://127.0.0.1:80/user/test?wsdl
     *
     * 但cxf 2.0.4之后的版本不需再配置此项内容，只需在application中配置
     * cxf.path=/user
     * 或者
     * cxf:
     *   path: /user
     */
//    @Bean()
//    public ServletRegistrationBean registrationBean(){
//        return new ServletRegistrationBean(new CXFServlet(),"/user/*");
//    }
}

复杂参数解析

这里以Map<String，List<User>>为例介绍，剩下的大家可以去github上项目中查看

MapListUser

package com.dev.cxf.model;

import javax.xml.bind.annotation.*;
import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName : MapListUser  //类名
 * @Description :   //描述
 */
@XmlType(name = "MapListUser")
@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement
@XmlSeeAlso({User.class})
public class MapListUser {

    private List<ListEntry> listEntry;

    static class ListEntry{
        private String key;
        private List<User> userList = new ArrayList<User>();

        public ListEntry() {
        }

        public ListEntry(String key, List<User> userList) {
            this.key = key;
            this.userList = userList;
        }

        public String getKey() {
            return key;
        }

        public void setKey(String key) {
            this.key = key;
        }

        public List<User> getUserList() {
            return userList;
        }

        public void setUserList(List<User> value) {
            this.userList = value;
        }
    }

    public List<ListEntry> getListEntry() {
        return listEntry;
    }

    public void setListEntry(List<ListEntry> listEntry) {
        this.listEntry = listEntry;
    }
}

User

package com.dev.cxf.model;

import lombok.Data;

import java.io.Serializable;

/**
 * @ClassName : User  //类名
 * @Description :   //描述
 */
@Data
public class User implements Serializable {
    private String name;
    private String ip;

    public User() {
    }

    public User(String name, String ip) {
        this.name = name;
        this.ip = ip;
    }
}

MapListAdapter

package com.dev.cxf.model;

import javax.xml.bind.ValidationEventHandler;
import javax.xml.bind.annotation.adapters.XmlAdapter;
import java.util.*;

/**
 * @Description :   //描述
 */
public class MapListAdapter extends XmlAdapter<MapListUser, Map<String, List<User>>> {
    /**
     * Convert a value type to a bound type.
     *
     * @param v The value to be converted. Can be null.
     * @throws Exception if there's an error during the conversion. The caller is responsible for
     *                   reporting the error to the user through {@link ValidationEventHandler}.
     */
    @Override
    public Map<String, List<User>> unmarshal(MapListUser v) throws Exception {
        Map<String, List<User>> map = new HashMap<>();
        for (MapListUser.ListEntry listEntry : v.getListEntry()) {
            map.put(listEntry.getKey(), listEntry.getUserList());
        }
        return map;
    }

    /**
     * Convert a bound type to a value type.
     *
     * @param v The value to be convereted. Can be null.
     * @throws Exception if there's an error during the conversion. The caller is responsible for
     *                   reporting the error to the user through {@link ValidationEventHandler}.
     */
    @Override
    public MapListUser marshal(Map<String, List<User>> v) throws Exception {
        MapListUser mapListUser = new MapListUser();
        List<MapListUser.ListEntry> listEntries = new ArrayList<>();
        for (String s : v.keySet()) {
            MapListUser.ListEntry listEntry= new MapListUser.ListEntry();
            listEntry.setKey(s);
            listEntry.setUserList(v.get(s));
            listEntries.add(listEntry);
        }
        mapListUser.setListEntry(listEntries);
        return mapListUser;
    }
}

配置完成启动项目

启动浏览器输入：http://127.0.0.1:80/user/test?wsdl或者http://localhost/user/test?wsdl

 client

客户端使用JaxWsDynamicClientFactory动态调用

CxfClientUtil

package com.dev.cxf.client;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.ParserConfig;
import com.dev.cxf.model.DataResult;
import com.dev.cxf.model.User;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.sun.xml.bind.v2.runtime.unmarshaller.XsiNilLoader;
import lombok.extern.slf4j.Slf4j;
import org.apache.cxf.endpoint.Client;
import org.apache.cxf.jaxws.endpoint.dynamic.JaxWsDynamicClientFactory;
import org.apache.cxf.transport.http.HTTPConduit;
import org.apache.cxf.transports.http.configuration.HTTPClientPolicy;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.support.PropertiesLoaderUtils;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Method;
import java.security.Key;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @Description :  cxf操作类 //描述
 */
@Slf4j
public class CxfClientUtil {

    private static Client client = null;

    /**
     * 获取yml中配置
     * @param name 配置文件名 如：application.yml
     * @param key 配置文件名 如：cxf
     */
    public static Hashtable getYml(String name,String key){
        //"application.yml"
        ClassPathResource resource = new ClassPathResource(File.separator + name);
        try {
            Hashtable props = PropertiesLoaderUtils.loadProperties(resource);
            return props;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 创建client
     * @param wsdlUrl webservice地址
     */
    public static boolean create(String wsdlUrl){
        try {
            JaxWsDynamicClientFactory dcf = JaxWsDynamicClientFactory.newInstance();
            client = dcf.createClient(wsdlUrl);
            // 如果返回的address不是远程服务地址，重新制定地址
            client.getEndpoint().getEndpointInfo().setAddress(wsdlUrl);
            // 策略
            HTTPClientPolicy httpClientPolicy = new HTTPClientPolicy();
            // 连接超时
            httpClientPolicy.setConnectionTimeout(6000000);
            httpClientPolicy.setAllowChunking(false);
            // 接收超时
            httpClientPolicy.setReceiveTimeout(6000000);
            HTTPConduit http = (HTTPConduit) client.getConduit();
            http.getClient().setReceiveTimeout(0);
            http.setClient(httpClientPolicy);
            if (null != client) {
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.error(e.toString());
            return false;
        }
        return false;
    }

    /**
     * 返回String
     * @param wsdlUrl 地址
     * @param method 方法名
     * @param parm 入参
     *
     * @return String 字符串
     */
    public static String transferToString(String wsdlUrl, String method, String parm) {
        if (create(wsdlUrl)) {
            Object[] objects = null;
            try {
                objects = client.invoke(method, parm);
                if (objects.length > 0){
                    return objects[0].toString();
                } else {
                    return "";
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return "调用失败!";
    }

    /**
     * 返回实体类
     * @param wsdlUrl 地址
     * @param method 方法名
     * @param parm 入参
     *
     * @return User 实体类
     */
    public static User transferToEntity(String wsdlUrl, String method, String parm) {
        if (create(wsdlUrl)) {
            Object[] objects = null;
            User user = null;
            try {
                objects = client.invoke(method, parm);
                if (objects.length > 0){
                    user = JSON.parseObject(JSON.toJSONString(objects[0]), User.class);
                    return user;
                }
            } catch (Exception e) {
                e.printStackTrace();
                return user;
            }
        }
        return new User();
    }

    /**
     * 返回List<User>
     * @param wsdlUrl 地址
     * @param method 方法名
     * @param parm 入参
     *
     * @return List<User> 实体类
     */
    public static ArrayList<User> transferToList(String wsdlUrl, String method, String parm) {
        if (create(wsdlUrl)) {
            Object[] objects = null;
            ArrayList<User> list = null;
            try {
                objects = client.invoke(method, parm);
                if (objects.length > 0){
                    list = (ArrayList<User>) JSON.parseArray(JSON.toJSONString(objects[0]), User.class);
                    return list;
                }
            } catch (Exception e) {
                e.printStackTrace();
                return list;
            }
        }
        return new ArrayList<User>();
    }

    /**
     * 返回List<User>与Map<String,User>
     *
     * @param wsdlUrl 地址
     * @param method 方法名
     * @param parm 入参
     *
     * @return DataResult 实体类
     */
    public static DataResult transferToDataResult(String wsdlUrl, String method) {
        if (create(wsdlUrl)) {
            Object[] objects = null;
            DataResult dataResult = null;
            try {
                objects = client.invoke(method);
                if (objects.length > 0){
                    // https://www.cnblogs.com/tfxz/p/12621560.html
                    Map<String, Class<?>> classMap = new HashMap<String, Class<?>>();
                    classMap.put("userList",User.class);
                    dataResult = (DataResult) net.sf.json.JSONObject.toBean(net.sf.json.JSONObject.fromObject(JSONObject.toJSONString(objects[0])), DataResult.class, classMap);
                    return dataResult;
                }
            } catch (Exception e) {
                e.printStackTrace();
                return dataResult;
            }
        }
        return new DataResult();
    }

    public static Map<String, User> transferToUserMap(String wsdlUrl, String method) {
        if (create(wsdlUrl)) {
            Object[] objects = null;
            Map<String, User> map = new HashMap<>();
            try {
                objects = client.invoke(method);
                if (objects.length > 0) {
                    JSONArray entries = JSON.parseObject(JSON.toJSONString(objects[0])).getJSONArray("entries");
                    //https://www.cnblogs.com/tfxz/p/12621560.html
                    Map<String, Class<?>> classMap = new HashMap<String, Class<?>>();
                    for (Object object : entries) {
                        net.sf.json.JSONObject jsonObject1 = net.sf.json.JSONObject.fromObject(object);
                        User table = (User) net.sf.json.JSONObject.toBean(net.sf.json.JSONObject.fromObject(jsonObject1.getString("value")), User.class, classMap);
                        map.put(jsonObject1.getString("key"), table);
                    }
                    return map;
                }
            } catch (Exception e) {
                e.printStackTrace();
                return map;
            }
        }
        return new HashMap<String, User>();
    }

    public static Map<String, Object> transferToMap(String wsdlUrl, String method,Map<String, Object> m) {
        if (create(wsdlUrl)) {
            Object[] objects = null;
            Map<String, Object> map = new HashMap<>();
            try {
                //CXF传入复杂参数：调用服务器端实体类->调用set方法->提交参数
                Object ajjySjth = Thread.currentThread().getContextClassLoader().loadClass("com.dev.cxf.service.User").getDeclaredConstructor().newInstance();// 加载类为服务端自定义对象命名空间
                Method setIp = ajjySjth.getClass().getMethod("setIp", String.class);// 调用set方法设置参数
                Method setName = ajjySjth.getClass().getMethod("setName", String.class);// 调用set方法设置参数
                setIp.invoke(ajjySjth, m.get("ip"));
                setName.invoke(ajjySjth, m.get("name"));
                objects = client.invoke(method, ajjySjth);
                if (objects.length > 0){
                    net.sf.json.JSONObject jsonObject = net.sf.json.JSONObject.fromObject(objects[0]);
                    net.sf.json.JSONArray entry = jsonObject.getJSONArray("entry");
                    for (Object o : entry) {
                        JSONObject object = JSON.parseObject(JSON.toJSONString(o));
                        map.put(object.getString("key"), object.getString("value"));
                    }
                    return map;
                }
            } catch (Exception e) {
                e.printStackTrace();
                return map;
            }
        }
        return new HashMap<String, Object>();
    }

    public static Map<String, List<User>> transferToUserMapListUser(String wsdlUrl, String method) {
        if (create(wsdlUrl)) {
            Object[] objects = null;
            Map<String, List<User>> map = new HashMap<>();
            try {
                objects = client.invoke(method);
                if (objects.length > 0) {
                    JSONArray listEntry = JSON.parseObject(JSON.toJSONString(objects[0])).getJSONArray("listEntry");
                    for (Object o : listEntry) {
                        JSONObject object = JSON.parseObject(JSON.toJSONString(o));
                        map.put(object.getString("key"), JSON.parseObject(JSON.toJSONString(object.getJSONArray("userList")), List.class));
                    }
                    return map;
                }
            } catch (Exception e) {
                e.printStackTrace();
                return map;
            }
        }
        return new HashMap<String, List<User>>();
    }
}

Test

package com.dev.cxf.client;

import lombok.extern.slf4j.Slf4j;
import java.util.*;

/**
 * @Description : client端测试  //描述
 */
@Slf4j
public class Test {
    private static final String wsdlUrl = "http://127.0.0.1:80/user/test?wsdl";
    public static void main(String[] args) {
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("name","zhansgan");
        map.put("ip","127.0.0.1");
        //string
//        System.out.println(CxfClientUtil.transferToString(wsdlUrl, "getName", map.get("ip").toString()));
        //entity
//        System.out.println(CxfClientUtil.transferToEntity(wsdlUrl,"getUser",map.get("name").toString()));
        //list
//        System.out.println(CxfClientUtil.transferToList(wsdlUrl,"getUserList",map.get("name").toString()));
        //list + map
//        System.out.println(CxfClientUtil.transferToDataResult(wsdlUrl,"getDataResult"));
        //map<String,User>
//        System.out.println(CxfClientUtil.transferToUserMap(wsdlUrl, "getUserMap"));
        //map<String,Object>
        System.out.println(CxfClientUtil.transferToMap(wsdlUrl, "getMap", map));
        //map<String,List<User>>
//        System.out.println(CxfClientUtil.transferToUserMapListUser(wsdlUrl, "getUserMapListUser"));
    }
}

运行Test这里调用的是"getMap"接口，实现类中传入参数User对象，返回是HashMap<String，Object>类型数据ip1和ip2

getMap打印

 Test打印

项目中写的例子有：

  • String
  • List<User>
  • User
  • DataResult(List + Map)
  • Map<String，Object>
  • Map<String，List<User>>
  • Map<String，User>

问题

java.lang.IllegalStateException: Unable to create schema compiler

这个问题相信不少人都遇到过，动态编译时找不到tools.jar报错导致

 

解决方式： 将引用的jre换为jdk，或者将tools.jar复制到你引用jre目录下

 

参考链接：

https://www.cnblogs.com/tfxz/p/12621560.html

https://www.cnblogs.com/zhengyuanyuan/p/9277059.html

GitHub：传送门

链接另一篇传递复杂类型参数：传送门

真是适合睡觉的天气
关注
专栏目录
springboot实现webservice
现役码农的博客
06-02 2万+
项目中需要调用一个webservice的接口获取数据，为了更好的实现功能，自己学习了一下，先总结如下，jdk1.6及以上maven中pom文件主要内容    &lt;dependencies&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; ...
SpringBoot整合cxf发布WebService接口
Blue_Smail的博客
09-04 466
SpringBoot整合WebService 导入cxf依赖 <!-- cxf --> <dependency> <groupId>org.apache.cxf</groupId> <artifactId>cxf-spring-boot-starter-jaxws</artifactId> <ver...
SpringBoot项目中使用CXF发布和调用webservice接口
hdn_kb的博客
11-18 2395
文章目录1. 服务端发布webservice接口1.1. 引入依赖1.2. 编写接口1.3. 实现接口1.4. 发布webservice接口1.5. 发布多个webservice接口1.6. 测试1.7. 问题2. 客户端调用webservice接口2.1. 问题 1. 服务端发布webservice接口 1.1. 引入依赖 <!-- CXF webservice --> <dependency> <groupId>org.apache.cxf&l
实战：Spring Boot与Apache CXF构建企业级服务SOAP
最新发布
为无为，事无事，味无味。
07-17 945
通过结合使用 SpringBoot 和 Apache CXF，开发者可以快速、高效地构建和部署高性能、可扩展的 Web 服务。SpringBoot 简化了配置和依赖管理，而 Apache CXF 提供了强大的 Web 服务功能和灵活性，使得构建现代企业级应用变得更加容易。通过 SpringBoot 的自动配置和依赖管理功能，开发者可以快速构建基于 Apache CXF 的 Web 服务应用。它通过自动配置、独立运行和生产就绪的功能，使开发者能够专注于业务逻辑，而无需处理繁杂的配置和依赖管理。
spring boot整合cxf发布webservice服务和spring boot整合cxf客户端调用webservice服务
dbeautifulLife的博客
11-22 2521
一.前言     说起web service最近几年restful大行其道，大有取代传统soap web service的趋势，但是一些特有或相对老旧的系统依然使用了传统的soap web service，例如银行、航空公司的机票查询接口等。本博客主要讲解得是spring boot整合cxf发布webservice服务和spring boot整合cxf客户端调用webservice服务 本案例
SpringBoot——实现WebService接口服务端以及客户端开发
热门推荐
weixin_42924812的博客
11-23 1万+
文章目录实现WebService接口的发布以及调用一、服务端代码开发1、pom依赖2、接口类3、接口实现类4、webservice配置文件2、客户端开发 实现WebService接口的发布以及调用 我们经常需要在两个系统之间进行一些数据的交互，这时候我们就需要开发数据交互接口。 一般来说，遇到比较多的接口有HTTP接口、WebService接口、FTP文件传输。今天我要来学习一下在SpringBoot框架下进行简单的webservice接口的开发。 在网上跟着好多个教程做了好多遍，终于能走通。 一、服务端代
springBoot下调用webservice服务
pure_light's Blog
09-27 1万+
引入解析 Webservice服务的 jar包。 下面给出pom坐标 <!-- 解析WebService JAR包 CXF --> <dependency> <groupId>org.apache.cxf</groupId> <artifactId>cxf-...
springboot调用WebService接口方法
pjy___的博客
07-29 1万+
使用场景 最近在项目中涉及到和其他部门（Sap）对接数据，因为该部门所用语言不是java，而WebService具有跨语言的特性，最后决定使用WebService来完成对接，下面上干货。 通过wsdl文件生成java代码 1、在项目中创建一个新的文件夹，将wsdl文件下载后保存到该文件夹中 文件下载方法：通用浏览器访问wsdl地址 进入页面 右键另存为到新建的文件夹中，注意将格式改为.wsdl格式 2、在idea中右键新建的文件夹 选择WebServices->Generate Java Code
spring boot cxf
【轰炸机】的博客
04-07 301
pom.xml <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-parent</artifactId> <version>1.4.5.RELEASE</version> </parent...
SpringBoot发布WebService接口（整合CXF）
盐焗味的小星球的博客
10-14 602
写了两天，出现各种bug，终于搞出来了，记录一下。 1.导入相关依赖（我用的parent是2.1.3.RELEASE版本） <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web-se...
springboot整合cxf发布webservice以及调用的方法
08-27
<artifactId>cxf-spring-boot-starter-jaxws <version>3.1.11 ``` 接下来，我们需要定义一个公共的返回实体类`BaseResult`： ```java public class BaseResult { private String isSuccess; private String ...
springboot整合CXF发布webservice和客户端调用
04-10
springboot整合CXF发布webservice和客户端调用 项目中每个类都有详细的注释，保证都能看懂，不失为一个学习springboot整合cxf来学习webservice发布调用的好例子
Springboot整合CXF发布Web service和客户端调用（用户和密码验证）
10-16
总结起来，Spring Boot整合CXF发布Web服务和实现用户密码验证的客户端调用主要包括以下步骤： 1. 引入CXF和Spring Security依赖。 2. 定义并实现Web服务接口。 3. 配置Spring Security以实现认证。 4. 使用CXF生成...
jeecg-boot 整合cxf实现SOAP WebService
Lie_with的博客
05-12 1784
jeecg-boot 整合cxf实现SOAP WebService （一）引入依赖 Pom.xml <!-- cxf webservice （暂时注释掉提高平台性能，需要此功能，可以放开注释）--> <dependency> <groupId>org.apache.cxf</groupId> <artifactId>cxf-rt-frontend-jaxws</artifactId> <version>
springboot整合cxf实现webservice接口
ganhaiqiang420的博客
04-06 680
springboot整合cxf实现webservice接口
springBoot with cxf
谁说学美术将来只能卖画了，我也有自己的梦想。
11-19 2051
下载安装cxf，Intelij Setting中有webservice设置 选择安装的cxf路径，否则无法根据WSDL生成server端代码 根据wsdl生成server端代码，Intelij直接可以选择生成client or server 然后在springboot 启动添加endpoint 参考地址： https://github.com/jonashackt/tutorial-soap
SpringBoot_WebService_cxf
一叶知秋
10-18 152
SpringBoot_WebService_cxf服务端依赖pom.xml配置源码实体类服务接口服务实现类配置类客户端依赖pom.xml源码 Springboot版本对应： Spring boot 1.4.x ------>cxf-spring-boot-starter-jaxws 3.1.x Spring boot 1.5.x------->cxf-spring-boot-start...
springboot使用cxf
yang03_26的博客
07-26 1718
springboot使用cxf
SpringBoot使用CXF框架
kxj19980524的博客
09-06 356
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apac...
springboot整合cxf实现webservice
08-25
Spring Boot是一种基于Spring框架的开发工具，它帮助我们快速构建和部署基于Java的应用程序。CXF是一个开源的Web服务框架，它支持SOAP和RESTful风格的Web服务。将Spring Boot和CXF整合起来，可以方便地实现基于CXF的Web服务。 要实现Spring Boot整合CXF，首先需要添加相应的依赖。在pom.xml文件中，引入spring-boot-starter-web和cxf-rt-frontend-jaxws等依赖。 接下来，创建一个WebService的实现类。在实现类上使用注解```@WebService``和```@Component```，分别标识该类为WebService和Spring组件。 在实现类中，编写具体的WebService方法，并使用注解```@WebMethod```和```@WebParam```标注方法和参数。 在Spring Boot的启动类上，使用注解```@EnableWs```启用WebService支持，并将WebService实现类作为一个Bean注入到Spring容器中。 最后，在application.properties文件中配置CXF相关的属性，如端口号和WebService的路径。 完成以上步骤后，启动Spring Boot应用程序即可访问WebService服务。可以使用SOAPUI或浏览器等工具发送请求，调用相应的WebService方法。 总之，通过Spring Boot整合CXF，我们可以轻松地构建和部署基于CXF的Web服务。这种整合方式简化了配置和部署过程，提高了开发效率，使得我们可以快速搭建可靠的Web服务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值