openFein 调用webservice,soap+xml

最新推荐文章于 2024-06-08 11:59:56 发布
最新推荐文章于 2024-06-08 11:59:56 发布
阅读量2.4k 收藏 9
点赞数 2
分类专栏： openFeign 文章标签： java spring boot soap xml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40301204/article/details/121877625
版权

一、服务端：

1.1目录结构：

1.2maven依赖

<?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.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>soapdemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-spring-boot-starter-jaxws</artifactId>
            <version>3.2.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-features-logging</artifactId>
            <version>3.2.5</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.2.4.Final</version>
        </dependency>

    </dependencies>

</project>

1.3WebServiceConfig配置类

package com.soap.config;


import com.soap.service.StudentService;
import org.apache.cxf.Bus;
import org.apache.cxf.ext.logging.LoggingInInterceptor;
import org.apache.cxf.ext.logging.LoggingOutInterceptor;
import org.apache.cxf.jaxws.EndpointImpl;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

/**
 * @author Administrator
 * @date 2019/01/30
 */
@Configuration
public class WebServiceConfig {

    @Resource
    private Bus bus;

    @Resource
    private StudentService studentService;

    @Bean
    public Endpoint endpointStudentService() {
        EndpointImpl endpoint=new EndpointImpl(bus,studentService);
        endpoint.getInInterceptors()
                .add(loggingInInterceptor());
        endpoint.getOutInterceptors()
                .add(loggingOutInterceptor());
        endpoint.publish("/studentService");
        return endpoint;

    }

    @Bean
    public LoggingInInterceptor loggingInInterceptor() {
        return new LoggingInInterceptor();
    }

    @Bean
    public LoggingOutInterceptor loggingOutInterceptor() {
        return new LoggingOutInterceptor();
    }
}

1.3Student实体类

package com.soap.entity;

public class Student {
    private String stuName;
    private Integer stuAge;

    public Student() {}

    public Student(String stuName, Integer stuAge) {
        this.stuName = stuName;
        this.stuAge = stuAge;
    }

    public String getStuName() {
        return stuName;
    }

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public Integer getStuAge() {
        return stuAge;
    }

    public void setStuAge(Integer stuAge) {
        this.stuAge = stuAge;
    }
}

1.4提供服务类

package com.soap.service;

import com.soap.entity.Student;

import javax.jws.WebMethod;
import javax.jws.WebService;
import java.util.List;

@WebService(targetNamespace = "http://service.soap.com")//  命名空间，建议包名倒写
public interface StudentService {

    @WebMethod
    List<Student> getStudentList();
}

1.5服务实现类

package com.soap.service.impl;

import com.soap.entity.Student;
import com.soap.service.StudentService;
import org.springframework.stereotype.Component;
import javax.jws.WebService;
import java.util.Arrays;
import java.util.List;

/**
 * @author Administrator
 * @date 2019/01/30
 */
@WebService(serviceName = "StudentService",
        targetNamespace = "http://service.soap.com",
        endpointInterface = "com.soap.service.StudentService")
@Component
public class StudentServiceImpl implements StudentService {
    @Override
    public List<Student> getStudentList() {
        Student stu1 = new Student("学生1",25);
        Student stu2 = new Student("学生2",30);
        return Arrays.asList(stu1,stu2);
    }
}

1.6启动类

package com.soap;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SoapBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(SoapBootApplication.class,args);
    }
}

1.7 application.yml文件

server:
  port: 8081
  servlet:
    context-path: /

1.8启动后访问地址：http://localhost:8081/services/studentService?wsdl

1.9====================服务端配置完成================================

二、客户端

2.1目录结构

 2.1maven依赖,其他依赖自行添加

<dependency>
            <groupId>io.github.openfeign</groupId>
            <artifactId>feign-jaxb</artifactId>
        </dependency>

        <dependency>
            <groupId>io.github.openfeign</groupId>
            <artifactId>feign-jaxrs</artifactId>
        </dependency>
        <dependency>
            <groupId>io.github.openfeign</groupId>
            <artifactId>feign-soap</artifactId>
            <version>10.2.0</version>
        </dependency>
        <dependency>
            <groupId>io.github.openfeign</groupId>
            <artifactId>feign-httpclient</artifactId>
            <version>10.10.1</version>
        </dependency>

<!--        openfeign远程调用-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

2.2ConvertConfig配置类（解析xml）

package com.example.consumer.config;


import feign.Logger;
import feign.Util;
import feign.codec.Decoder;
import feign.codec.EncodeException;
import feign.codec.Encoder;
import feign.jaxb.JAXBContextFactory;
import org.springframework.context.annotation.Bean;
import org.w3c.dom.Document;

import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.soap.*;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.ws.soap.SOAPFaultException;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;

import static javax.xml.soap.SOAPConstants.DEFAULT_SOAP_PROTOCOL;

public class ConvertConfig {
    private Charset charsetEncoding = StandardCharsets.UTF_8;
    private String soapProtocol = DEFAULT_SOAP_PROTOCOL;

    private static final JAXBContextFactory jaxbContextFactory = new JAXBContextFactory.Builder()
            .withMarshallerJAXBEncoding("UTF-8")
            .build();

    @Bean
    public Encoder feignEncoder() {
        return (object, bodyType, template) -> {
            if (!(bodyType instanceof Class)) {
                throw new UnsupportedOperationException(
                        "SOAP only supports encoding raw types. Found " + bodyType);
            }
            try {
                Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
                Marshaller marshaller = jaxbContextFactory.createMarshaller((Class<?>) bodyType);
                marshaller.marshal(object, document);
                SOAPMessage soapMessage = MessageFactory.newInstance(soapProtocol).createMessage();
                SOAPEnvelope soapEnvelope = soapMessage.getSOAPPart().getEnvelope();
                soapEnvelope.addNamespaceDeclaration("ser", "http://service.soap.com");
                soapMessage.setProperty(SOAPMessage.CHARACTER_SET_ENCODING, charsetEncoding.displayName());
                soapMessage.getSOAPBody().addDocument(document);
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                soapMessage.writeTo(bos);
                template.body(new String(bos.toByteArray()).replaceAll("getStudentList", "ser:getStudentList"));
            } catch (SOAPException | JAXBException | ParserConfigurationException|IOException| TransformerFactoryConfigurationError e) {
                throw new EncodeException(e.toString(), e);
            }
        };
    }

    @Bean
    public Decoder feignDecoder() {
        return (response, type) ->{
            try {
                if (response.status() != 404 && response.status() != 204) {
                    if (response.body() == null) {
                        return null;
                    } else {
                        SOAPMessage message = MessageFactory.newInstance(soapProtocol).createMessage(null,response.body().asInputStream());
                        SOAPBody soapBody = message.getSOAPBody();
                        if (soapBody != null) {
                            if (message.getSOAPBody().hasFault()) {
                                throw new SOAPFaultException(message.getSOAPBody().getFault());
                            }
                            //重要！！！！
                            Class<?> tt =(Class<?>)type;
                            Unmarshaller unmarshaller = jaxbContextFactory.createUnmarshaller(tt);

                            return unmarshaller.unmarshal(soapBody.extractContentAsDocument(),tt).getValue();
                        }
                    }
                } else {
                    return Util.emptyValueOf(type);
                }
            }catch (Exception e){
                e.printStackTrace();
            }
            return Util.emptyValueOf(type);
        };
    }

    @Bean
    feign.Logger.Level feignLoggerLevel() {
        return Logger.Level.FULL;
    }
}

2.3GetStudentList实体类

package com.example.consumer.soap.entity;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class GetStudentList {
}

2.4GetStudentListResponse实体类

package com.example.consumer.soap.entity;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import java.util.List;

@XmlRootElement(name = "getStudentListResponse")
@XmlAccessorType(XmlAccessType.FIELD)
public class GetStudentListResponse {
    @XmlElement(name = "return")
    private List<Student> students;

    public List<Student> getStudents() {
        return students;
    }

    public void setStudents(List<Student> students) {
        this.students = students;
    }
}

2.5 Student实体类

package com.example.consumer.soap.entity;

public class Student {
    private int stuAge;
    private String stuName;

    public String getStuName() {
        return stuName;
    }

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public int getStuAge() {
        return stuAge;
    }

    public void setStuAge(int stuAge) {
        this.stuAge = stuAge;
    }
}

2.6 feign远程调用类

package com.example.consumer.soap.feign;

import com.example.consumer.config.ConvertConfig;
import com.example.consumer.soap.entity.GetStudentList;
import com.example.consumer.soap.entity.GetStudentListResponse;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.PostMapping;


@FeignClient(name = "SoapFeign",url = "http://localhost:8081",configuration = {ConvertConfig.class})
public interface SoapFeign {
    @PostMapping(value = "/services/studentService",consumes = {MediaType.TEXT_XML_VALUE})
    public GetStudentListResponse getStudentList(GetStudentList getStudentList);
}

2.7 启动类

package com.example.consumer;

import com.alibaba.fastjson.JSON;

import com.example.consumer.soap.entity.GetStudentListResponse;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.Unmarshaller;
import javax.xml.soap.MessageFactory;
import javax.xml.soap.SOAPMessage;
import java.io.ByteArrayInputStream;

@SpringBootApplication
@EnableFeignClients(basePackages = {"com.example.consumer.soap.feign"})
public class ConsumerApplication {
    public static void main(String[] args){
        ConsumerApplication consumerApplication=new ConsumerApplication();
//        try {
//            consumerApplication.method();
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
        SpringApplication.run(ConsumerApplication.class, args);
    }
    //可进行测试
    public void method() throws Exception {
        String example ="<soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n" +
                "   <soap:Body>\n" +
                "      <ns2:getStudentListResponse xmlns:ns2=\"http://service.soap.com\">\n" +
                "         <return>\n" +
                "            <stuAge>25</stuAge>\n" +
                "            <stuName>学生1</stuName>\n" +
                "         </return>\n" +
                "         <return>\n" +
                "            <stuAge>30</stuAge>\n" +
                "            <stuName>学生2</stuName>\n" +
                "         </return>\n" +
                "      </ns2:getStudentListResponse>\n" +
                "   </soap:Body>\n" +
                "</soap:Envelope>";
        SOAPMessage message = MessageFactory.newInstance().createMessage(null,
                new ByteArrayInputStream(example.getBytes()));
        Unmarshaller unmarshaller = JAXBContext.newInstance(GetStudentListResponse.class).createUnmarshaller();
        JAXBElement<GetStudentListResponse> unmarshal = unmarshaller.unmarshal(message.getSOAPBody().extractContentAsDocument(), GetStudentListResponse.class);
        GetStudentListResponse value = unmarshal.getValue();
        System.out.println(JSON.toJSONString(value));
    }

}

2.8 开启feign日志

logging:
  level:
    com.example.consumer.soap.feign.SoapFeign: debug

2.9 controller类

  @Resource
    private SoapFeign soapFeign;
    @GetMapping("/soap")
//R类，可以用Map代替
    public R testSoap() {
        GetStudentListResponse response= soapFeign.getStudentList(new GetStudentList());
        return R.success().put("students:",response);
    }

3.0 xml或wsdl文件

<wsdl:definitions xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:tns="http://service.soap.com" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:ns1="http://schemas.xmlsoap.org/soap/http" name="StudentService" targetNamespace="http://service.soap.com">
<wsdl:types>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:tns="http://service.soap.com" elementFormDefault="unqualified" targetNamespace="http://service.soap.com" version="1.0">
<xs:element name="getStudentList" type="tns:getStudentList"/>
<xs:element name="getStudentListResponse" type="tns:getStudentListResponse"/>
<xs:complexType name="getStudentList">
<xs:sequence/>
</xs:complexType>
<xs:complexType name="getStudentListResponse">
<xs:sequence>
<xs:element maxOccurs="unbounded" minOccurs="0" name="return" type="tns:student"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="student">
<xs:sequence>
<xs:element minOccurs="0" name="stuAge" type="xs:int"/>
<xs:element minOccurs="0" name="stuName" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:schema>
</wsdl:types>
<wsdl:message name="getStudentListResponse">
<wsdl:part element="tns:getStudentListResponse" name="parameters"> </wsdl:part>
</wsdl:message>
<wsdl:message name="getStudentList">
<wsdl:part element="tns:getStudentList" name="parameters"> </wsdl:part>
</wsdl:message>
<wsdl:portType name="StudentService">
<wsdl:operation name="getStudentList">
<wsdl:input message="tns:getStudentList" name="getStudentList"> </wsdl:input>
<wsdl:output message="tns:getStudentListResponse" name="getStudentListResponse"> </wsdl:output>
</wsdl:operation>
</wsdl:portType>
<wsdl:binding name="StudentServiceSoapBinding" type="tns:StudentService">
<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
<wsdl:operation name="getStudentList">
<soap:operation soapAction="" style="document"/>
<wsdl:input name="getStudentList">
<soap:body use="literal"/>
</wsdl:input>
<wsdl:output name="getStudentListResponse">
<soap:body use="literal"/>
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="StudentService">
<wsdl:port binding="tns:StudentServiceSoapBinding" name="StudentServiceImplPort">
<soap:address location="http://localhost:8081/services/studentService"/>
</wsdl:port>
</wsdl:service>
</wsdl:definitions>

3.1可用soapUI（soap请求，推荐）、postman（post请求）进行测试

FishOFDreams
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springcloud feign 服务消费者 类似 webservice
02-20
springcloud feign 服务消费者 类似 webservice ====== http://knight-black-bob.iteye.com/blog/2356222
OpenFeign服务调用
微笑的博客
09-28 303
前言 Feign是一个声明式WebService客户端。使用Feign能让编写Web Service客户端更加简单。只需要创建一个接口并在接口上添加注解即可。 它的使用方法是定义一个服务接口然后在上面添加注解。Feign也支持可拔插式的编码器和解码器。Spring Cloud对Feign进行了封装，使其支持了Spring MVC标准注解和HTTPMessageConverters。Feign可以与Eureka和Ribbon组合使用以支持负载均衡。 Feign 能干什么？ Feign旨在使编写Java Htt
SpringCloud入门之声明式web service客户端OpenFeign
最新发布
凡许真的博客
06-08 162
Feign是一个声明式的web service客户端，用它可以更容易编写web服务客户端。它使你调用远程方法就像调用本地方法一样简单，不需要IP和端口，也不需要在单独写一个http请求工具类。并且feign集成了ribbon，实现了负载均衡。OpenFeign虽然集成了Ribbon，但Ribbon已经处于维护模式，应该避免使用Ribbon，官方使用Spring Cloud LoadBalancer。
OpenFeign服务接口调用
...
06-27 742
Feign是一个声明式WebService客户端。使用Feign能让编写WebService客户端更加简单。它的使用方法是定义一个服务接口然后在上面添加注解。Feign也支持可插拔式的编码器和解码器。Spring Cloud对Feign进行了封装，使其支持了Spring MVC标准注解和HttpMessageConverters。Feign可以与Eureka和Ribbon组合使用以支持负载均衡。一句话总结：Feign是一个声明式的Web服务客户端，让编写web服务客户端变得非常容易，只需创建一个接口并在接口
微服务间的远程接口调用：OpenFeign的使用并理解原理
qq_42582773的博客
10-09 4040
Feign
【Spring cloud】OpenFeign详解（超详细）
笑不语的博客
09-11 8445
一、概述 1. OpenFeign是什么？ 下面是关于OpenFeign的一段官方介绍： Feign is a declarative web service client. It makes writing web service clients e asier. To use Feign create an interface and annotate it. It has pluggable annotat ion support including Feign annotations and JAX
OpenFeign和feign使用简介
热门推荐
张三博客
05-19 1万+
1.可插拔的注解支持，包括Feign注解和JAX-RS注解。 2.支持可插拔的HTTP编码器和解码器（Gson，Jackson，Sax，JAXB，JAX-RS，SOAP）。 3.支持Hystrix和它的Fallback。 4.支持Ribbon的负载均衡。 5.支持HTTP请求和响应的压缩。 6.灵活的配置：基于 name 粒度进行配置 7.支持多种客户端：JDK URLConnection、apache httpclient、okhttp，ribbon） 8.支持日志 9.支持错误重试 10.url支持占位
九、OpenFeign 服务接口调用
白羊座的橙子
05-31 846
1、概述 Feign是一个声明式的WebService客户端。使用Feign能让编写Web Service客户端更加简单 它的使用方法是定义一个服务接口，然后在上面添加注解。Feign也支持可拔插式的编码器和解码器。SpringCloud对Feign进行了封装，使其支持Spring MVC标准注解和HttpMessageConverters。Feign可以与Eureka和Ribbon组合使用以支持负载均衡 Feign能干什么？(为什么要使用Feign) Feign旨在使编写Java Http客户端.
openfeint简介
10-10
### OpenFeint简介 OpenFeint是一个非常知名的社交游戏网络平台，主要面向移动设备上的游戏。它提供了一系列的功能和服务，帮助开发者将他们的游戏融入到一个更广泛的社区中，增加了游戏的社交性和互动性。 #### ...
付博：一些典型游戏在OpenFeint上的数据表现
05-29
介绍一些全球，特别是亚洲的典型游戏，在OpenFeint平台的基本数据表现。通过数据分析，挖掘一款成功的游戏，都有哪些具体的数据表现，具体的特征。并给游戏开发者提供一些建议。
Android-IceSoap-简单异步基于注释的SOAPforAndroid
08-13
`Android-IceSoap`支持异步调用，这意味着在执行SOAP请求时不会阻塞UI线程，提高了用户体验。通过使用Android的`AsyncTask`或`Loader`等机制，可以轻松实现后台处理并更新UI。 **3. 基于注释的API** 这个库的核心...
Android游戏源码香港大不同找茬游戏(无法运行)
07-29
香港大不同是一个2011年左右个人开发者开发的找茬类的游戏项目，有米广告SDK使用的是早期的2.2版本，项目还用到了OpenFeint与九城合作的一个SDK，OpenFeint是一个为iOS和andriod系统提供在线游戏竞技的技术平台，...
【SpringCloud10】OpenFeign服务接口调用
qq_45291280的博客
01-13 1701
OpenFeign服务接口调用
OpenFeign详解
m0_63040701的博客
05-06 769
OpenFeign的@Feignclient可以解析SpringMVc的@RequestMapping注解下的接口，并通过动态代理的方式产生实现类，实现类中做负载均衡并调用其他服务。服务消费者在调用服务提供者的时候发生了阻塞、等待的情形，这个时候，服务消费者会一直等待下去。在某个峰值时刻，大呈的请求都在同时请求服务消费者，会造成线程的大呈堆积，势必会造成雪崩。Feign内置了Ribbon，用来做客户端负载均衡，去调用服务注册中心的服务。修改application.yml。NONE：默认的，不显示任何日志;
feign使用_我的Spring Cloud（七）：Feign 声明式接口调用
weixin_39933724的博客
11-30 175
一、什么是Feign Feign也是去实现负载均衡，但是它的使用要比Ribbon更加简化，它实际上是基于Ribbon进行了封装，让我们可以通过调用接口的方式实现负载均衡。Feign和Ribbon都是由Netflix提供的，Feign是一个声明式、模板化的Web Service客户端，它简化了开发者编写Web服务客户端的操作，开发者可以通过简单的接口和注解来调用HTTP API，使得开发变得更...
feign调用soap_SpringBoot2.0+ 声明式服务调用 Feign 0128
weixin_31263419的博客
12-21 437
一、 什么是 Feign Feign 是一种声明式、模板化的 HTTP 客户端(仅在 consumer 中使用)。 二、 什么是声明式，有什么作用，解决什么问题？ 声明式调用就像调用本地方法一样调用远程方法;无感知远程 http 请求。 1，Spring Cloud 的声明式调用, 可以做到使用 HTTP 请求远程服务时能就像调用本地 方法一样的体验，开发者完全感知不到这是远程方法，更感知不到这是...
微服务实战声明式服务调用OpenFeign实践
m0_67393619的博客
07-31 224
一开始，我们使用原生的DiscoveryClient发现服务和使用RestTemplate进行服务间调用，然后我们自己手动开发了一个负载均衡组件，最后介绍了负载均衡组件Ribbon。OpenFeign的设计宗旨式简化JavaHttp客户端的开发。Feign在restTemplate的基础上做了进一步的封装，由其来帮助我们定义和实现依赖服务接口的定义。https。...
openfeign扩展点
04-30
OpenFeign是一个轻量级的RESTful客户端，使得从Java应用程序中调用RESTful API变得更加容易。OpenFeign扩展点，是指OpenFeign框架提供了可扩展的功能点，可以通过覆盖默认实现，自定义实现业务逻辑，满足不同场景下的需求，增强了OpenFeign的灵活性和扩展性。 OpenFeign扩展点常用的有以下几种： 1. Decoder：自定义对返回结果进行解析的逻辑，将json、xml等各种数据格式转换为Java对象。 2. Encoder：自定义对请求参数进行封装的逻辑，将Java对象序列化为json、xml等数据格式。 3. Logger：自定义请求日志打印方式，方便排查问题。 4. Retryer：自定义请求失败时的重试机制，保证高可用性。 5. ErrorDecoder：自定义对服务端返回错误的解析逻辑，将错误码转换为具体异常类型。 6. Contract：自定义请求协议，支持RPC、SOAP等协议的扩展。 通过使用OpenFeign扩展点，我们可以将一些通用的业务逻辑和非标准需求统一抽象封装，降低了代码开发和维护的难度，提高了代码质量和可维护性。更重要的是，OpenFeign扩展点是可插拔的，可以随时加入和移除，使得应用具备更强的适应性和可扩展性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值