springboot集成Feign调用第三方接口

springboot   2.1.7.RELEASE

feign的版本:

<spring-cloud.version>Greenwich.SR2</spring-cloud.version>

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/io.github.openfeign/feign-okhttp -->
<dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-okhttp</artifactId>
    <version>10.2.3</version>
</dependency>

 

使用时,配置config类

package com.young.springdemo.config;

import feign.Feign;
import okhttp3.ConnectionPool;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Bean;
import org.springframework.cloud.openfeign.FeignAutoConfiguration;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.TimeUnit;

@Configuration
@ConditionalOnClass(Feign.class)
@AutoConfigureBefore(FeignAutoConfiguration.class)
public class FeignConfig {

    @Bean
    public okhttp3.OkHttpClient okHttpClient(){
        return new okhttp3.OkHttpClient.Builder()
                .readTimeout(60, TimeUnit.SECONDS)
                .connectTimeout(60, TimeUnit.SECONDS)
                .writeTimeout(120, TimeUnit.SECONDS)
                .connectionPool(new ConnectionPool())
                .build();
    }
}

springapplication主类上添加注解

@EnableFeignClients

 

编写feign调用接口

@FeignClient(name = "feignSerive", url = "192.168.100.52:16010/myapi")
public interface FeignService {

url可以配置文件编写;

 

接口形式为下面:

    @RequestMapping(value = "/test", method = RequestMethod.GET)
    @ResponseBody
    ResponseData<String> invoke();

  @Component
    class DefaultFallback implements FeignService {
        @Override
        public ResponseData<String> invoke() {
            throw new RuntimeException();
//            return new ResponseData<String>().setCode("40004").setDesc("服务异常").setData(null);
        }

调用时,直接在controller中,注入该接口,此时,还需要实现该接口,抛出异常处理.可以内部类,可以外部都可以..

 

再看下192.168.100.52:16010/myapi/test 对应的接口,

    @RequestMapping(value = "test",method = RequestMethod.GET)
    public  void getTest(){
        System.out.println("无参GET方法，调用成功");
        return;
    }

很简单,只是暴露简单的业务来执行.

 

东西不多,坑很多,要调用的类型也很多,所以将所有的代码贴出来,大家参考就行,我也是参考别人的....

两个通用实体类

package com.young.springdemo.utils.domain;

public class ResponseData<T> {

    private String code;
    private String desc;
    private T data;

    public String getCode() {
        return code;
    }

    public ResponseData<T> setCode(String code) {
        this.code = code;
        return this;
    }

    public String getDesc() {
        return desc;
    }

    public ResponseData<T> setDesc(String desc) {
        this.desc = desc;
        return this;
    }

    public T getData() {
        return data;
    }

    public ResponseData<T> setData(T data) {
        this.data = data;
        return this;
    }
}

package com.young.springdemo.utils.domain;


public class DemoResp {

    private String name;
    private String age;

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
}

 

外部被调用接口实现:

package com.young.springdemo.utils.domain;


import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping(value = "myapi")
@ResponseBody
public class TestController {

    @RequestMapping(value = "test",method = RequestMethod.GET)
    public  void getTest(){
        System.out.println("无参GET方法，调用成功");
        return;
    }

    @RequestMapping(value = "getParam",method = RequestMethod.GET)
    @ResponseBody
    public String getParam(@RequestParam String name,@RequestParam String age) {
        System.out.println("有参GET,获取到的参数name位：" + name+"==== age:"+age);
        return name;
    }

    @RequestMapping(value = "getPost",method = RequestMethod.POST)
    @ResponseBody
    public String getPost(){
        System.out.println("调用无参post成功");
        return "SUCCESS";
    }

    @RequestMapping(value = "getPostParam",method = RequestMethod.POST)
    @ResponseBody
    public String getPostParam(@RequestParam("name")String name){
        System.out.println("调用有参成功，name："+name);
        DemoResp demoResp = new DemoResp();
        demoResp.setName(name);
        return name;
    }

    @RequestMapping(value = "getPostResult",method = RequestMethod.POST)
    @ResponseBody
    public ResponseData getPostResult(){
        System.out.println("调用无参post成功");
        return new ResponseData<DemoResp>().setCode("200");
    }

    @RequestMapping(value = "getPostParamResult",method = RequestMethod.POST)
    @ResponseBody
    public ResponseData<DemoResp> getPostParamResult(@RequestParam("name")String name){
        System.out.println("调用有参成功，name："+name);
        DemoResp demoResp = new DemoResp();
        demoResp.setName(name);
        return new ResponseData<DemoResp>().setCode("200").setData(demoResp);
    }


    @RequestMapping(value = "getPostParamEntityResult",method = RequestMethod.POST)
    @ResponseBody
    public ResponseData<DemoResp> getPostParamResult(@RequestBody DemoResp resParam){
        System.out.println("调用有参成功，name："+resParam.toString());
        return new ResponseData<DemoResp>().setCode("200").setData(resParam);
    }
}

 

内部feign接口调用

package com.young.springdemo.service.feign;


import com.sun.org.apache.regexp.internal.RE;
import com.young.springdemo.utils.DemoResp;
import com.young.springdemo.utils.ResponseData;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.*;

@FeignClient(name = "feignSerive", url = "192.168.100.52:16010/myapi")
public interface FeignService {

    @RequestMapping(value = "/test", method = RequestMethod.GET)
    @ResponseBody
    ResponseData<String> invoke();

    @RequestMapping(value = "getParam",method = RequestMethod.GET)
    String getParam(@RequestParam(value = "name") String name,@RequestParam(value = "age")String age);

    @RequestMapping(value = "getPost",method = RequestMethod.POST)
    String getPost();

    @RequestMapping(value = "getPostParam",method = RequestMethod.POST)
    String getPostParam(@RequestParam(value = "name")String name);

    @RequestMapping(value = "getPostResult",method = RequestMethod.POST)
    ResponseData<DemoResp> getPostResult();

    @RequestMapping(value = "getPostParamResult",method = RequestMethod.POST)
    ResponseData<DemoResp> getPostParamResult(@RequestParam(value = "name")String name);

    @RequestMapping(value = "getPostParamEntityResult",method = RequestMethod.POST)
    ResponseData<DemoResp> getPostParamEntityResult(@RequestBody DemoResp resp);



    @Component
    class DefaultFallback implements FeignService {
        @Override
        public ResponseData<String> invoke() {
            throw new RuntimeException();
//            return new ResponseData<String>().setCode("40004").setDesc("服务异常").setData(null);
        }

        @Override
        public String getParam(String name,String age) {
            throw new RuntimeException();
        }

        @Override
        public String getPost() {
            throw new RuntimeException();
        }

        @Override
        public String getPostParam(String name) {
            throw new RuntimeException();
        }

        @Override
        public ResponseData<DemoResp> getPostResult() {
            throw new RuntimeException();
        }

        @Override
        public ResponseData<DemoResp> getPostParamResult(String name) {
            throw new RuntimeException();
        }

        @Override
        public ResponseData<DemoResp> getPostParamEntityResult(DemoResp resp) {

            throw new RuntimeException();
        }
    }
}

 

自身调用接口

package com.young.springdemo.controller;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.young.springdemo.AsyncService.StudentServiceAsync;
import com.young.springdemo.service.feign.FeignService;
import com.young.springdemo.utils.DemoResp;
import com.young.springdemo.utils.ResponseData;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.web.bind.annotation.*;

import java.io.*;

@RestController
@RequestMapping("/myapi")
public class StudentController {
    private final static Logger logger = LoggerFactory.getLogger(StudentController.class);

    @Autowired
    private StudentServiceAsync studentServiceAsync;



    @RequestMapping(value = "getStu", method = RequestMethod.GET)
    @ResponseBody
    public void getStudent() {
        logger.info("开始执行接口");
        for (int i = 0; i < 5; i++) {
            studentServiceAsync.getStudent();
            studentServiceAsync.getStu();
        }
        logger.info("结束执行接口");
    }

    @RequestMapping(value = "testPy", method = RequestMethod.GET)
    @ResponseBody
    public void testPy() {

    }

    public static void main(String[] args) {
        String line;
        try {
            //创建读取python的必要条件.
            // 数组1:必须是"python",指定文件格式
            //数组2:该python的文件的路径,可以是绝对路径,也可以是相对路径
            //数组3及以后:是对python调用的方式的传递参数的方式
            String[] params = new String[]
                    {"python", "D:\\py\\project\\hello_py.py", "小明", "20"};
            //给调用python分配一个进程,并执行py文件
            Process process = Runtime.getRuntime().exec(params); //执行py文件
            //读取python写的数据
            BufferedReader in = new BufferedReader(new InputStreamReader(process.getInputStream(), "GBK"));
            while ((line = in.readLine()) != null) {
                //todo 输出处理python传输数据
                System.out.println(line);
            }
            in.close();//关闭字节流
            //java代码中的process.waitFor()返回值为0表示我们调用python脚本成功，
            //返回值为1表示调用python脚本失败
            int re = process.waitFor();//0:执行成功;1:执行失败;2:调用失败
            switch (re) {
                case 0:
                    //todo :执行成功
                    System.out.println("调用python,执行成功");
                    break;
                case 1:
                    //todo :执行失败
                    System.out.println("调用python,执行失败");
                    break;
                case 2:
                    //todo: 调用失败
                    System.out.println("调用python文件失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    //测试Feign


    @Autowired
    private FeignService feignClientProxy;

    @RequestMapping(value = "test")
    @ResponseBody
    public String testFeign(@RequestParam(name = "name") String name) throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        System.out.println("开始执行");
        ResponseData<String> respResponseBody = feignClientProxy.invoke();
        System.out.println("执行结束");
        return "调用结果:"+ objectMapper.writeValueAsString(respResponseBody);
    }

    @RequestMapping(value = "getParam",method =RequestMethod.GET)
    @ResponseBody
    public String getParam(@RequestParam(name = "name") String name) throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        System.out.println("开始执行");
        String obj = feignClientProxy.getParam(name,"12");
        System.out.println("执行结束");
        return "调用结果:"+ objectMapper.writeValueAsString(obj.toString());
    }

    @RequestMapping(value = "getPost",method =RequestMethod.POST)
    @ResponseBody
    public String getPost() throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        System.out.println("开始执行");
        String obj = feignClientProxy.getPost();
        System.out.println("执行结束");
        return "调用结果:"+ objectMapper.writeValueAsString(obj.toString());
    }

    @RequestMapping(value = "getPostParam",method =RequestMethod.POST)
    @ResponseBody
    public String getPostParam(@RequestParam(name = "name") String name) throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        System.out.println("开始执行");
        String obj = feignClientProxy.getPostParam(name);
        System.out.println("执行结束");
        return "调用结果:"+ objectMapper.writeValueAsString(obj.toString());
    }


    @RequestMapping(value = "getPostParamResult",method =RequestMethod.POST)
    @ResponseBody
    public String getPostParamResult(@RequestParam(name = "name") String name) throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        ResponseData<DemoResp> postParamResult = feignClientProxy.getPostParamResult(name);

        System.out.println("执行结束,"+postParamResult.toString());
        return "调用结果:"+ objectMapper.writeValueAsString(postParamResult.toString());
    }

    @RequestMapping(value = "getPostResult",method =RequestMethod.POST)
    @ResponseBody
    public String getPostResult(@RequestParam(name = "name") String name) throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        System.out.println("开始执行");
        ResponseData<DemoResp> postParamResult = feignClientProxy.getPostResult();
        System.out.println("执行结束,"+postParamResult.toString());
        return "调用结果:"+ objectMapper.writeValueAsString(postParamResult.toString());
    }

    @RequestMapping(value = "getPostParamEntityResult",method =RequestMethod.POST)
    @ResponseBody
    public ResponseData getPostParamEntityResult(@RequestParam(name = "name") String name) throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        DemoResp demoResp = new DemoResp();
        demoResp.setName(name);
        ResponseData<DemoResp> postParamResult = feignClientProxy.getPostParamEntityResult(demoResp);
        return postParamResult;
//        System.out.println("执行结束,"+postParamResult.toString());
//        return "调用结果:"+ objectMapper.writeValueAsString(postParamResult.toString());
    }

}