程序员你为什么这么累【续】：编写简陋的接口调用框架 - 动态代理学习

导读:

前些时间写了很多编码习惯的帖子，今天写一点简单的技术贴。其实我个人觉得编码习惯是最主要的，比技术重要，但初学者还是喜欢看技术贴，今天就写一个小Demo，也加深自己的理解。

JDK的动态代理是非常重要的技术，使用的地方很多，用于代理接口，Spring的AOP也会用到。技术细节这里不贴了，我不是技术高手，大家可以上网搜索一下一大把，今天我们结合spring编写一个简陋的“框架”。

完整代码已经上传到GITHUB，地址在最后面。

最终效果

假设我们需要调用另外一个系统提供了的GET请求 http://localhost:8081/test/get2?key=somekey**

我们只需要定义一个接口：

1. import cn.xiaowenjie.myrestutil.http.GET;

2. import cn.xiaowenjie.myrestutil.http.Param;

3. import cn.xiaowenjie.myrestutil.http.Rest;

4. import cn.xiaowenjie.retrofitdemo.beans.ResultBean;

5. @Rest("http://localhost:8081/test")

6. public interface IRequestDemo {

7.  @GET

8.  ResultBean get1();

9.  @GET("/get2")

10.  ResultBean getWithKey(@Param("key") String key);

11. }

然后直接注入该接口即可：

1. @Service

2. public class TestService{

3.  @Autowired

4.  IRequestDemo demo;

5.  public void test() {

6.    // 调用接口，得到结果

7.    ResultBean get1 = demo.get1();

8.    ResultBean get2 = demo.getWithKey("key-------");

9.  }

10. }

这就是今天Demo的效果，看着还行，有点类似restfeign，当然离真正应用还有一段差距。我们这里主要是学习动态代理和基本的spring应用。

总共不到200行代码，很容易阅读，逐一说明实现过程。

定义注解

这里定义三个注解

• Rest作用表示这是一个Rest的接口，主要属性是要调用的Rest服务器信息。

• GET作用表示这个方法是GET方法，主要属性是调用的URL信息

• Param作用是映射参数名称

定义Rest服务器信息Bean

扫描Rest注解后生成，这里包含了被调用的服务器的信息。Demo里面只有一个Host信息。

1. /**

2. * 包装服务器信息类，目前只有host，其他自己配置即可。

3. */

4. @Data

5. public class RestInfo {

6.  private String host;

7. }

定义请求信息的包装Bean

扫描GET请求生成，主要包括请求是URL，参数等。

1. /**

2. * 请求信息包装类

3. */

4. @Data

5. public class RequestInfo {

6.  private String url;

7.  private Class<?> returnType;

8.  private LinkedHashMap<String, String> params;

9. }

定义处理请求的接口

使用它来处理扫描生成的请求

1. /**

2. * 处理网络请求接口

3. */

4. public interface IRequestHandle {

5.  Object handle(RestInfo restInfo, RequestInfo request);

6. }

扫描所有Rest接口生成动态代理类

Spring启动的时候，扫描所有的带Rest注解的接口。如下这种

1. ＠Rest("http://localhost:8081/test")

2. public interface IRequestDemo

定义一个工具Bean，Bean注册的时候使用Reflections扫描工程里面属于带Rest注解的接口。

1. ＠Component

2. public class RestUtilInit {

3.  @Autowired

4.  IRequestHandle requestHandle;

5.  @PostConstruct

6.  public void init() {

7.    Set<Class<?>> requests = new Reflections("cn.xiaowenjie").getTypesAnnotatedWith(Rest.class);

8.    for (Class<?> cls : requests) {

9.      createProxyClass(cls);

10.    }

11.  }

12. }

创建动态代理实现如下：

1. private void createProxyClass(Class<?> cls) {

2.  System.err.println("\tcreate proxy for class:" + cls);

3.  // rest服务器相关信息

4.  final RestInfo restInfo = extractRestInfo(cls);

5.  InvocationHandler handler = new InvocationHandler() {

6.    @Override

7.    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

8.      RequestInfo request = extractRequestInfo(method, args);

9.      return requestHandle.handle(restInfo, request);

10.    }

11.  };

12.  // 创建动态代理类

13.  Object proxy = Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class<?>[] { cls }, handler);

14.  registerBean(cls.getName(), proxy);

15. }

其实就是把请求包装成RestInfo和RequestInfo，然后创建 一个InvocationHandler实现接口代理，在里面调用IRequestHandle接口处理请求。不复杂，就几行代码。

把代理类注册到Spring容器

注册到Spring容器后，然后就可以在Controll等出直接注入使用。

1. ＠Autowired

2. ApplicationContext ctx;

3. public void registerBean(String name, Object obj) {

4.  // 获取BeanFactory

5.  DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) ctx

6.      .getAutowireCapableBeanFactory();

7.  // 动态注册bean.

8.  defaultListableBeanFactory.registerSingleton(name, obj);

9. }

定义默认的RestTemplate处理请求类

需要先在容器里面注册自己的RestTemplate。然后实现IRequestHandle

1. /**

2. * 实现了IRequestHandle，基于resttemplate处理rest请求。

3. * 需要在spring容器中注册RestTemplate。

4. */

5. @Component

6. public class RestTemplateRequestHandle implements IRequestHandle {

7.  @Autowired

8.  RestTemplate rest;

9.  @Override

10.  public Object handle(RestInfo restInfo, RequestInfo request) {

11.    System.err.println("\n\n\thandle request,  restInfo=" + restInfo);

12.    System.err.println("\thandle request,  request=" + request);

13.    String url = extractUrl(restInfo, request);

14.    System.err.println("\thandle url:" + url);

15.    //TODO 目前只写了get请求，需要支持post等在这里增加

16.    //TODO 需要在这里增加异常处理，如登录失败，链接不上

17.    Object result = rest.getForObject(url, request.getReturnType());

18.    return result;

19.  }

20.  /**

21.   * 生成真实的url

22.   *

23.   * @param restInfo

24.   * @param request

25.   * @return

26.   */

27.  private String extractUrl(RestInfo restInfo, RequestInfo request) {

28.    String url = restInfo.getHost() + request.getUrl();

29.    if (request.getParams() == null) {

30.      return url;

31.    }

32.    Set<Entry<String, String>> entrySet = request.getParams().entrySet();

33.    String params = "";

34.    for (Iterator<Entry<String, String>> iterator = entrySet.iterator(); iterator.hasNext();) {

35.      Entry<String, String> entry = iterator.next();

36.      params += entry.getKey() + '=' + entry.getValue() + '&';

37.    }

38.    return url + '?' + params.substring(0, params.length() - 1);

39.  }

40. }

JUNIT简单测试

先启动被调用的服务。然后跑junit。直接注入IRequestDemo接口。

1. @RunWith(SpringRunner.class)

2. @SpringBootTest(classes = MyRestUtilApplication.class)

3. public class MyRestUtilApplicationTests {

4.  @Autowired

5.  IRequestDemo demo;

6.  @Test

7.  public void test() {

8.    ResultBean get1 = demo.get1();

9.    System.out.println(get1);

10.  }

11.  @Test

12.  public void test2() {

13.    ResultBean get2 = demo.getWithKey("2332323");

14.    System.out.println(get2);

15.  }

16. }

测试正常，接口调用正常。

如何加入认证

举例最简单的HttpBasic认证，可以在RestTemplate设置

1. @ComponentScan("cn.xiaowenjie")

2. @SpringBootApplication

3. public class MyRestUtilApplication {

4.  public static void main(String[] args) {

5.    SpringApplication.run(MyRestUtilApplication.class, args);

6.  }

7.  @Autowired(required = false)

8.  List<ClientHttpRequestInterceptor> interceptors;

9.  @Bean

10.  public RestTemplate restTemplate() {

11.    System.out.println("-------restTemplate-------");

12.    RestTemplate restTemplate = new RestTemplate();

13.    // 设置拦截器，用于http basic的认证等

14.    restTemplate.setInterceptors(interceptors);

15.    return restTemplate;

16.  }

17. }

拦截器把认证信息放在头里面。

1. @Component

2. public class HttpBasicRequestInterceptor implements ClientHttpRequestInterceptor {

3.  @Override

4.  public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution)

5.      throws IOException {

6.    // TODO 需要得到当前用户

7.    System.out.println("---------需要得到当前用户，然后设置账号密码-----------");

8.    String plainCreds = "xiaowenjie:admin";

9.    byte[] plainCredsBytes = plainCreds.getBytes();

10.    byte[] base64CredsBytes = Base64.encodeBase64(plainCredsBytes);

11.    String headerValue = new String(base64CredsBytes);

12.    HttpRequestWrapper requestWrapper = new HttpRequestWrapper(request);

13.    requestWrapper.getHeaders().add("Authorization", "Basic " + headerValue);

14.    return execution.execute(requestWrapper, body);

15.  }

16. }

总结

过程比较简单，步骤如下

• 使用 org.reflections.Reflections 得到所有配置了 @Rest 的接口列表

• 根据 @Rest 得到服务器配置信息 RestInfo

• 使用 Proxy.newProxyInstance 生成接口的代理类，invoke 方法中根据 @GET 得到该方法请求信息 RequestInfo，调用 IRequestHandle 接口处理请求，。

• 把生成的代理类注入到spring容器中。

DEMO GITHUB地址

源码在这里：xwjie/MyRestUtil**，欢迎加星。框架代码在单独的 MyRestUtil\myrestutil\restutil 目录中，主要逻辑都在 RestUtilInit 上，代码非常精简，一看就明白，总共200行左右吧。

后话

本示例只实现了GET请求，也没有支持REST风格的很多特性，工作中一般使用RestFeign这类框架，如果这些框架不满足需要自己写一个可以参考这个代码。我觉得他已经可以算一个乞丐版的框架了！技术简单，我觉得我的编码习惯比技术更有价值，嘿嘿。

由于个人技术水平有限，代码如有错误或者好的实现方式请大家务必指出，一起学习进步。大家有什么建议也请留言区留言，谢谢阅读。

点击阅读原文关注作者的知乎专栏

https://zhuanlan.zhihu.com/c_120823325

如果您也有好文章想分享，请见菜单中的“干货投稿”

推荐阅读

SpringCloud系列文章

长按指纹

一键关注