Allow Parametrized Types for FeignClient

[iamgollum]

Originally mentioned in this chat: https://gitter.im/OpenFeign/feign?at=5fc95092a8af805088fdf356

Observe:

@FeignClient(name = "queueKeeperClient", url = "${queueKeeper.api.url}", configuration = QueueKeeperFeignConfiguration.class)
public interface QueueKeeperClient<M> {

    @PostMapping(path = "messages/raw/{queue}")
    void publish(@PathVariable("queue") String queue,
                 @RequestHeader("correlationId") String correlationId,
                 @RequestHeader("msgId") String msgId,
                 @RequestBody M msgBody);
}

Throws parametrized types are not supported!

Generics is a core concept to an OOP language such as Java.
Why was this feature not considered for this when this is compile time checked and optimized?
I presume that this was done for simplicity and to force developers to avoid over engineering ...

Temporary Solution:

@FeignClient(name = "queueKeeperClient", url = "${queueKeeper.api.url}", configuration = QueueKeeperFeignConfiguration.class)
public interface QueueKeeperClient {

    class QueueMessage {}

    @PostMapping(path = "messages/raw/{queue}")
    void publish(@PathVariable("queue") String queue,
                 @RequestHeader("correlationId") String correlationId,
                 @RequestHeader("msgId") String msgId,
                 @RequestBody QueueMessage msgBody);
}

Object could work too and maybe the best fit in most cases.
This is really a 'tag' class similar to Serializable.

If I have the time I would consider trying to solve this or work with someone else on this...seems like an exciting project..

[kdavisk6]

This is intentional. If you want to use parameterized types, you must use it through inheritance:

See: #133

In this issue, it explains that, since we need concrete types in order to correctly process and determine which method should be invoked, by our use of JDK proxies, if you want to use Generics this way, you must first create a base interface that contains the parameterized values, then create a concrete interface:

@Headers("Accept: application/json") 
interface BaseApi<V> {
  
   @RequestLine("GET /api/{key}") 
   V get(@Param("key") String);  

   @RequestLine("GET /api")
   List<V> list();  

   @Headers("Content-Type: application/json") 
   @RequestLine("PUT /api/{key}") 
   void put(@Param("key") String, V value); 
}  

interface FooApi extends BaseApi<Foo> { }  
interface BarApi extends BaseApi<Bar> { } 

Using the above example you would create a new FeignClient using either FooApi or BarApi, but not BaseApi

This usage is outlined on our README: https://github.com/OpenFeign/feign#base-apis

[alamhubb]

+1

[alamhubb]

This is intentional. If you want to use parameterized types, you must use it through inheritance:

See: #133

In this issue, it explains that, since we need concrete types in order to correctly process and determine which method should be invoked, by our use of JDK proxies, if you want to use Generics this way, you must first create a base interface that contains the parameterized values, then create a concrete interface:

@Headers("Accept: application/json") 
interface BaseApi<V> {
  
   @RequestLine("GET /api/{key}") 
   V get(@Param("key") String);  

   @RequestLine("GET /api")
   List<V> list();  

   @Headers("Content-Type: application/json") 
   @RequestLine("PUT /api/{key}") 
   void put(@Param("key") String, V value); 
}  

interface FooApi extends BaseApi<Foo> { }  
interface BarApi extends BaseApi<Bar> { } 

Using the above example you would create a new FeignClient using either FooApi or BarApi, but not BaseApi

This usage is outlined on our README: https://github.com/OpenFeign/feign#base-apis

hello, I followed the above method to modify my code, and then I got this error

Caused by: java.lang.IllegalStateException: Method SocialuniLoginAPI#providerLogin(SocialProviderLoginQO) not annotated with HTTP method type (ex. GET, POST)
Warnings:
- 
	at feign.Util.checkState(Util.java:129) ~[feign-core-10.10.1.jar:na]
	at feign.Contract$BaseContract.parseAndValidateMetadata(Contract.java:100) ~[feign-core-10.10.1.jar:na]

Below is my code

baseAPI

@RequestMapping("login")
public interface SocialLoginAPI<T extends SocialUserDetailRO> {

    //三方渠道登录，qq、wx、社交联盟，兼容各平台，h5、app、mp
    @PostMapping("providerLogin")
    ResultRO<SocialLoginRO<T>> providerLogin(@RequestBody SocialProviderLoginQO loginData);

    @PostMapping("phoneLogin")
    ResultRO<SocialLoginRO<T>> phoneLogin(@RequestBody SocialPhoneNumQO socialPhoneNumQO);
}

project 1

@FeignClient(name = "login", url = "${socialuni.server-url:https://api.socialuni.com}")
public interface SocialuniLoginAPI extends SocialLoginAPI<CenterUserDetailRO> {

    //三方渠道登录，qq、wx、社交联盟，兼容各平台，h5、app、mp
    ResultRO<SocialLoginRO<CenterUserDetailRO>> providerLogin(SocialProviderLoginQO loginData);

    ResultRO<SocialLoginRO<CenterUserDetailRO>> phoneLogin(SocialPhoneNumQO socialPhoneNumQO);
}

project 2

@RestController
public class LoginController implements SocialLoginAPI<MineUserDetailRO> {
    @Resource
    private LoginService loginService;

    //三方渠道登录，qq、wx、社交联盟，兼容各平台，h5、app、mp
    public ResultRO<SocialLoginRO<MineUserDetailRO>> providerLogin(@RequestBody SocialProviderLoginQO loginData) {
        SocialLoginRO<MineUserDetailRO> socialUserDetailRO = loginService.providerAndPhoneLogin(loginData, null);
        return new ResultRO<>(socialUserDetailRO);
    }

    public ResultRO<SocialLoginRO<MineUserDetailRO>> phoneLogin(@RequestBody SocialPhoneNumQO socialPhoneNumQO) {
        SocialLoginRO<MineUserDetailRO> socialUserDetailRO = loginService.providerAndPhoneLogin(null, socialPhoneNumQO);
        return new ResultRO<>(socialUserDetailRO);
    }
}

Of course, compared to the above code, I hope feign can support the following way, thank you

@FeignClient(name = "login", url = "${socialuni.server-url:https://api.socialuni.com}")
@RequestMapping("login")
public interface SocialuniLoginAPI<T extends SocialUserDetailRO> {

    //三方渠道登录，qq、wx、社交联盟，兼容各平台，h5、app、mp
    @PostMapping("providerLogin")
    ResultRO<SocialLoginRO<T>> providerLogin(SocialProviderLoginQO loginData);

    @PostMapping("phoneLogin")
    ResultRO<SocialLoginRO<T>> phoneLogin(SocialPhoneNumQO socialPhoneNumQO);
}

[velo]

Of course, compared to the above code, I hope feign can support the following way, thank you

Hi @social-uni , I would be more than happy to review any proposal/PR on how to get this done. Please lemme know if you can assist.

[alamhubb]

Of course, compared to the above code, I hope feign can support the following way, thank you

Hi @social-uni , I would be more than happy to review any proposal/PR on how to get this done. Please lemme know if you can assist.

Sorry, I think this is a good learning opportunity, but I cannot submit pr to you in the near future. I am mainly a front-end programmer and I am not very proficient in java. I estimate that it will take about a week to study this technology. And I’m currently developing my own open source social software. I’m currently at an important stage. I can’t spare a week to submit pr. I apologize for that and thank you very much for your contribution.

[velo]

All good, project is run on volunteer work, do it when you can.

[mepeisen]

Maybe the following site helps: https://javax0.wordpress.com/2014/02/26/syntethic-and-bridge-methods/

In JVM level this is done by providing two methods with same signature. They are flagged with modifier "BRIDGE". I noticed that getMethods() returns two variants: The first has flags PUBLIC, BRIDGE, SYNTHETIC and misses any annotation. The second one has flags ABSTRACT, PUBLIC and contains all annotations. So maybe the solution is simple: Ignore any method marked as BRIDGE as these will be the duplicates for jvm.

Simple example to show the problem will be the following:

public class Foo {

@Retention(RetentionPolicy.RUNTIME)
@interface Annot {
	
}

interface A<T> {
	@Annot
	T foo();
}

interface B extends A<Foo> {
	@Annot
	Foo foo();
}

public static void main(String[] args) {
	for (Method method : B.class.getMethods()) {
		System.out.println(method.getName() + "/" + method.getModifiers() + "/" + method.getAnnotation(Annot.class));
	}
}

}

You will get the following output:

  foo/1025/@Foo$Annot()
  foo/4161/null

[nicat-as]

Hi, I had the same issue. I've used parameterized default method and inside it called actual method.

@FeignClient(name = "queueKeeperClient", url = "${queueKeeper.api.url}", configuration = QueueKeeperFeignConfiguration.class)
public interface QueueKeeperClient {

    default <M> void wrapPublish(String queue,
                                 String correlationId,
                                 String msgId,
                                 M msgBody) {
        publish(queue, correlationId, msgId, msgBody);
    }

    @PostMapping(path = "messages/raw/{queue}")
    void publish(@PathVariable("queue") String queue,
                 @RequestHeader("correlationId") String correlationId,
                 @RequestHeader("msgId") String msgId,
                 @RequestBody Object msgBody);
}