SPRINGBOOT整合CXF发布WEB SERVICE和客户端调用（用户和密码验证）

已于 2023-11-09 14:25:39 修改
阅读量585 收藏 2
点赞数
文章标签： java spring boot 后端 网络
于 2023-11-09 14:03:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43844189/article/details/134310198
版权

主要分为客户端和服务端

服务端

  1. pom配置
<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>webservice-service</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>webservice-service</name>
    <description>webservice-client</description>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

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

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- HTTP -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.4</version>
        </dependency>

        <!-- Fast Json -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.1.41</version>
        </dependency>
        <!-- CXF webservice -->
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-spring-boot-starter-jaxws</artifactId>
            <version>3.3.3</version>
            <exclusions>
                <exclusion>
                    <groupId>javax.validation</groupId>
                    <artifactId>validation-api</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
  1. Config配置
@Configuration
public class CxfConfig {
    
    @Autowired
    private Bus bus;
    
    @Autowired
    private ServiceMaster serviceMaster;

    //------------------------------------------  默认是services ------------------------------------------
    @Bean
    public ServletRegistrationBean cxfServlet(){
        return new ServletRegistrationBean( new CXFServlet(), "/services/*");
    }
    @Bean
    public Endpoint endpoint(){
        EndpointImpl endpoint = new EndpointImpl(bus, serviceMaster);
        endpoint.publish("/ServiceMaster");
        endpoint.getInInterceptors().add(new ClientLoginInterceptor());
        endpoint.getInInterceptors().add(new AuthInterceptor());
        return endpoint;
    }

}

3.WebService拦截器验证

package com.example.webserviceclient.intercptor;

import org.apache.cxf.binding.soap.SoapMessage;
import org.apache.cxf.binding.soap.saaj.SAAJInInterceptor;
import org.apache.cxf.interceptor.Fault;
import org.apache.cxf.phase.AbstractPhaseInterceptor;
import org.apache.cxf.phase.Phase;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.NodeList;

import javax.xml.soap.Name;
import javax.xml.soap.SOAPException;
import javax.xml.soap.SOAPHeader;
import javax.xml.soap.SOAPMessage;

/**
 * 定义拦截器用户用户验证
 */
public class AuthInterceptor extends AbstractPhaseInterceptor<SoapMessage> {
    private static final Logger logger = LoggerFactory.getLogger(AuthInterceptor.class);
    private SAAJInInterceptor saa = new SAAJInInterceptor();
    private static final String USER_NAME = "guanguan";
    private static final String USER_PASSWORD = "sailing2018!";
    public AuthInterceptor() {
        super(Phase.PRE_PROTOCOL);
        getAfter().add(SAAJInInterceptor.class.getName());
    }
    @Override
    public void handleMessage(SoapMessage message) throws Fault {
        System.out.println("来了哟！"+message);
        SOAPMessage mess = message.getContent(SOAPMessage.class);
        if(mess==null){
            saa.handleMessage(message);
            mess=message.getContent(SOAPMessage.class);
        }
        SOAPHeader header =null;
        try {
            header = mess.getSOAPHeader();
        } catch (SOAPException e) {
            logger.error("getSOAPheader error:{}",e.getMessage(),e);
            e.printStackTrace();
        }
        if(header==null){
            throw new Fault(new IllegalAccessException("找不到Header,无法验证用户信息"));
        }
        NodeList username = header.getElementsByTagName("username");
        NodeList password = header.getElementsByTagName("password");
        if(username.getLength()<1){
            throw new Fault(new IllegalAccessException("找不到Header,无法验证用户信息"));
        }
        if(password.getLength()<1){
            throw new Fault(new IllegalAccessException("找不到Header,无法验证用户信息"));
        }
        String userName = username.item(0).getTextContent().trim();
        String passWord = password.item(0).getTextContent().trim();
        if(USER_NAME.equals(userName)&&USER_PASSWORD.equals(passWord)){
            System.out.println("admin auth success");
            logger.info("admin auth success");
        }else {
            SOAPException soapException = new SOAPException("认证错误");
            logger.info("admin auth failed");
            throw new Fault(soapException);
        }
    }
}

4.客户端用户密码登录验证

package com.example.webserviceclient.intercptor;

import org.apache.cxf.binding.soap.SoapMessage;
import org.apache.cxf.headers.Header;
import org.apache.cxf.helpers.DOMUtils;
import org.apache.cxf.interceptor.Fault;
import org.apache.cxf.phase.AbstractPhaseInterceptor;
import org.apache.cxf.phase.Phase;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

import javax.xml.namespace.QName;
import java.util.List;

public class ClientLoginInterceptor extends AbstractPhaseInterceptor<SoapMessage> {
    private String username;
    private String password;
    public ClientLoginInterceptor() {
        super(Phase.PREPARE_SEND);
    }
    public ClientLoginInterceptor(String username, String password) {
        //super();
        super(Phase.PREPARE_SEND);
        this.username = username;
        this.password = password;
    }

    @Override
    public void handleMessage(SoapMessage soap) throws Fault {
        List<Header> headers = soap.getHeaders();
        Document doc = DOMUtils.createDocument();
        Element auth = doc.createElement("authrity");
        Element username = doc.createElement("username");
        Element password = doc.createElement("password");
        username.setTextContent(this.username);
        password.setTextContent(this.password);
        auth.appendChild(username);
        auth.appendChild(password);
        headers.add(0, new Header(new QName("timamaes"), auth));
    }
}

5.service处理类

import com.example.webserviceclient.service.ServiceMaster;
import org.springframework.stereotype.Service;
import javax.jws.WebService;

@Service
@WebService(serviceName = "ServiceMaster", targetNamespace = "http://service.webserviceclient.example.com", endpointInterface = "com.example.webserviceclient.service.ServiceMaster")
public class ServiceMasterImpl implements ServiceMaster {

    @Override
    public String sendMessage(String username) {
        System.out.println("---------------------"+username);
        return "收到消息啦！" + username;
    }
}

import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebResult;
import javax.jws.WebService;

@WebService(name = "ServiceMaster", targetNamespace = "http://service.webserviceclient.example.com")//采用的是包的反向地址
public interface ServiceMaster {

    @WebMethod
    @WebResult(name = "String", targetNamespace = "http://service.webserviceclient.example.com")//采用的是包的反向地址
    String sendMessage(@WebParam(name = "username") String username);

}

客户端

1.pom

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>webservice-client</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>webservice-client</name>
    <description>webservice-client</description>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- HTTP -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.4</version>
        </dependency>

        <!-- Fast Json -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.1.41</version>
        </dependency>

        <!-- Web Service - cxf -->
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-transports-http</artifactId>
            <version>3.3.3</version>
        </dependency>

        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-frontend-jaxws</artifactId>
            <version>3.3.3</version>
        </dependency>

        <!-- Junit -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

2.测试代码

import com.example.webserviceclient.interceptor.ClientLoginInterceptor;
import org.apache.cxf.endpoint.Client;
import org.apache.cxf.jaxws.endpoint.dynamic.JaxWsDynamicClientFactory;
import org.junit.Test;

public class WebController {

     @Test
     public void TestClient(){
         //----------------------------------------  创建动态客户端  ----------------------------------------

         JaxWsDynamicClientFactory dcf = JaxWsDynamicClientFactory.newInstance();
         Client client = dcf.createClient("http://localhost:8080/services/ServiceMaster?wsdl");
//此地址为服务端请求地址，端口配置文件中没有指定，默认为8080
        //-------------------------------  需要密码的情况需要加上用户名和密码  -----------------------------

         client.getOutInterceptors().add(new ClientLoginInterceptor("guanguan", "sailing2018!"));
         Object[] objects = new Object[0];

         try {
             // invoke("方法名",参数一,参数二,参数三....);
             objects = client.invoke("sendMessage", "天黑请闭眼。。。");
             System.out.println("返回数据:" + objects[0]);
         } catch (java.lang.Exception e) {
             e.printStackTrace();
         }

     }

}

认证通过时服务端后台打印
在这里插入图片描述
客服端打印
在这里插入图片描述
当认证不通过时
服务端
在这里插入图片描述
客户端
在这里插入图片描述

天黑请丶写代码
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
SpringBoot整合CXF发布WebService接口，及动态调用（用户名和密码验证）
SuperSunnyBoy的博客
03-25 7435
服务端继承AbstractPhaseInterceptor<T>，来实现AuthInterceptor的权限控制功能
Springboot整合CXF发布Web service和客户端调用（用户和密码验证）
10-16
Springboot整合CXF发布Web service和客户端调用（用户和密码验证）打开及用
SpringBoot集成CXF完成webservice服务实例（包括用户验证）
lvhu123的博客
11-07 3726
最近接到了一个对外发布接口的需求，所以找到CXF写了一个简单例子仅供参考。考虑到方便调用，服务端数据采用JSONArray封装，这样不需要客户端创建相关实体类就可以拿到目标数据。 一、项目目录 二、pom.xml依赖引入 依赖查询：https://mvnrepository.com/ 注意： 依赖版本不同，代码也会有不同之处：springboot版本2.0.1，CXF版本3.2.4，...
SpringBoot中写webService接口和调用
weixin_50003028的博客
06-21 1782
webservice的定义和调用
springboot（十）集成CXF发布webservice以及客户端调用
南城老猫
03-25 1114
概述： Web service是一个pin独立的，低耦合的，自包含的、基于可编程的web的应用程序，可使用开放的XML（标准通用标记语言下的一个子集）标准来描述、发布、发现、协调和配置这些应用程序，用于开发分布式的互操作的应用程序。 更多理论知识请自行百度一下。 sprinboot集成cxf： 新建项目：springboot-webservice，pom....
springboot整合cxf调用websrevice，带上用户名和密码验证。
qq_29554309的博客
12-25 8046
公司项目要与外部的webservice对接接口，网上看过很多springboot调用webservice的帖子，经过自己成功调用，现在分享推荐cxf的调用方式。 首先在pom文件中引入cxf的包。这里用的3.1.11，springboot的版本是1.4.0 引入包后就可以直接调用了。具体调用方法如下： JaxWsDynamicClientFactory dcf = JaxWsDy
springboot整合CXF发布webService和动态调用
justdoit_potato的博客
05-17 2479
不说闲话，直接附上所有源码。 1.pom文件引入jar包 <dependency> <groupId>org.apache.cxf</groupId> <artifactId>cxf-rt-frontend-jaxws</artifactId> ...
springboot集成CXF开发webservice，并向外发布，调用接口
不经意的博客
06-27 4068
先复制一段说明： Apache CXF = Celtix + XFire，CXF 继承了 Celtix 和 XFire 两大开源项目的精华，提供了对 JAX-WS 全面的支持，并且提供了多种 Binding 、DataBinding、Transport 以及各种 Format 的支持，并且可以根据实际项目的需要，采用代码优先（Code First）或 者 WSDL 优先（WSDL First）来轻松地实现 Web Services 的发布和使用。 CXF 包含了大量的功能特性，但...
Springboot 基于CXF构建WebService服务
蜀道难，难于上青天。
04-13 1874
前言 最近因为系统需要接入了一个新的支付通道，一般来说都是使用RestApi 来接入，但是本次接入的支付通道为境外支付，使用的WebService，对于WS我们在实际业务中基本上不会用到，所以查阅了一些资料，记录一下自己项目中使用的WS。 WebService概述 什么是WebService Web Service技术，能使得运行在不同机器上的不同应用无须借助附加的、专门的第三方软件或硬件， 就可相互交换数据或集成。依据Web Service规范实施的应用之间，无论它们所使用的语言、平台或内部协议是什么，
springboot整合CXF发布webservice和客户端调用
04-10
通过这个项目，开发者不仅可以了解SpringBoot和CXF的基本概念，还能掌握两者如何协同工作，发布和调用Web服务。同时，对于SpringBoot应用的打包、部署和测试也有了一定的认识。这个例子是一个理想的实践项目，对于...
springboot整合cxf发布webservice以及调用的方法
08-27
SpringBoot整合CXF发布WebService以及调用的方法 SpringBoot是一款流行的Java框架，而CXF（Apache CXF）是一款开源的WebService框架。今天，我们将介绍如何使用SpringBoot整合CXF发布WebService，以及如何调用它。 ...
springBoot整合CXF并实现用户名密码校验的方法
08-27
SpringBoot整合CXF并实现用户名密码校验的方法 SpringBoot是一个流行的Java框架，CXF是一个流行的WebService框架。今天，我们将介绍如何将SpringBoot与CXF集成，并实现用户名密码校验的方法。 一、准备工作 首先...
SpringBoot+mybatis+CXF开发web service接口.rar
12-15
8. **启动和测试服务**：运行SpringBoot应用，通过测试工具或客户端代码调用Web Service接口，验证服务功能是否正常。 以上就是基于SpringBoot、MyBatis和CXF开发Web Service接口的基本步骤和涉及的关键知识点。这...
golang 接口
m0_70982551的博客
07-24 868
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 454
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 542
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 471
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
springboot整合cxf
07-02
### 回答1： Spring Boot是一个开发框架，它提供了很多便利的功能来简化Spring应用程序的开发。CXF是一个用于构建和部署Web服务的开源框架。整合Spring Boot和CXF可以让我们更容易地开发和部署Web服务。 要在Spring Boot中整合CXF，我们需要首先添加CXF的依赖。可以在pom.xml文件中添加以下代码来引入CXF的依赖： ```xml <dependency> <groupId>org.apache.cxf</groupId> <artifactId>cxf-spring-boot-starter-jaxws</artifactId> <version>3.3.1</version> </dependency> ``` 接下来，我们需要创建一个配置类来配置CXF。可以创建一个名为CxfConfig的类，并使用@Configuration注解进行标注。在该类中，我们可以配置CXF的一些属性，例如请求路径和服务实现类等。 ```java @Configuration public class CxfConfig { @Autowired private Bus bus; @Bean public Endpoint endpoint() { EndpointImpl endpoint = new EndpointImpl(bus, new YourServiceImpl()); endpoint.publish("/your-service"); return endpoint; } } ``` 在上面的配置类中，我们使用@Autowired注解将Spring Boot的默认总线注入进来，并且创建了一个名为endpoint的bean。通过EndpointImpl类，我们可以将我们的服务实现类（YourServiceImpl）和请求路径（/your-service）与CXF进行绑定。 最后，我们需要在主应用类上添加@EnableWebServices注解，使得Spring Boot能够自动注册和部署我们的Web服务。 ```java @SpringBootApplication @EnableWebServices public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } ``` 通过以上步骤，我们就完成了Spring Boot和CXF的整合。现在我们可以启动应用程序，并通过访问相应的路径来调用我们的Web服务了。 总结起来，Spring Boot整合CXF可以让我们更方便地开发和部署Web服务。我们只需要添加相关的依赖和配置类，并使用@EnableWebServices注解来注册和部署服务即可。整合CXF后，我们可以更加高效地构建和处理Web服务。 ### 回答2： Spring Boot是一个开源的Java开发框架，可以快速构建独立的、可运行的、生产级别的基于Spring框架的应用程序。而Apache CXF是一个Web服务框架，可以用于构建和开发SOAP和RESTful风格的Web服务。 在Spring Boot中整合CXF可以实现基于Java的Web服务的开发和部署。首先，我们需要引入CXF的依赖项，可以在pom.xml文件中添加相关的依赖。然后，我们可以创建一个配置类，使用CXF提供的注解配置Web服务的相关信息，例如服务地址、端口等。在配置类中，可以使用@Endpoint注解来标注Web服务的具体实现类。接下来，我们可以创建一个Spring Boot启动类，使用@EnableAutoConfiguration注解启用Spring Boot的自动配置功能，并使用@ImportResource注解导入CXF的配置文件。 通过以上步骤，我们就可以在Spring Boot应用中集成CXF。当应用启动时，CXF将根据配置类和注解，自动发布Web服务，并根据接口和实现类自动生成相关的WSDL文件和SOAP消息。此时，我们可以使用SOAPUI等工具来测试和调用这些Web服务。另外，CXF还提供了一些扩展点和配置选项，可以用于定制和优化Web服务的性能和安全性。 总的来说，Spring Boot整合CXF可以帮助我们快速、高效地开发和部署基于Java的Web服务。通过使用Spring Boot的自动配置功能和CXF的注解配置，我们可以简化Web服务的开发过程，并提供可靠和高性能的Web服务。同时，Spring Boot还支持其他的Web服务框架，例如Jersey、Axis等，可以根据实际需求选择合适的框架。 ### 回答3： Spring Boot是一个开发框架，可以帮助开发者快速搭建基于Spring的Java应用程序。而Apache CXF是一个开源的Web服务框架，可以用来构建和部署SOAP和RESTful服务。 在Spring Boot中整合CXF可以使用以下步骤： 1.添加依赖：首先，在项目的pom.xml文件中添加CXF的依赖，以便能够使用CXF的相关功能。 2.配置CXF的Web服务：在Spring Boot的配置文件中，添加CXF的相关配置，包括服务地址、请求拦截器等。 3.创建Web服务接口：在项目中创建Web服务接口，定义服务的方法、参数和返回值。 4.实现Web服务接口：实现接口，并在实现类中编写具体的业务逻辑。 5.发布Web服务：使用CXF的相关注解，将实现类发布为Web服务，使其能够被外部访问。 6.启动应用程序：启动Spring Boot应用程序，让CXF的Web服务开始监听请求。 通过以上步骤，我们就可以使用Spring Boot来整合CXF，从而搭建一个可以提供SOAP或RESTful服务的应用程序。在这个应用程序中，我们可以使用CXF的一些特性，如拦截器和异常处理等，来增加应用程序的功能和稳定性。 总而言之，Spring Boot整合CXF能够大大简化CXF的配置过程，并使开发者能够更快地构建和部署Web服务。通过这种方式，我们可以更加高效地开发和管理我们的应用程序，提供更好的用户体验。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值