devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Http请求封装的三进阶_封装http请求

作者：小蓝xlanll | 2024-03-18 01:23:28

赞

踩

封装http请求

       系统与系统之间的交互往往会使用到http请求，而我们发起http请求过程繁琐；因此我们需要对Http请求进行封装以方便使用；

最近项目中接触到了一个经常被其他项目调用的项目主体，研究其演进架构，将其精髓记录下来

       首先我们来看一看最原始的Http请求的代码书写

  1. /**
  2.  * http请求第一个版本（直接发起Http请求）
  3.  *
  4.  * @author hzm ${2020-06-20 17:57}
  5.  */
  6. public class Http {
  7.  
  8. 	/**
  9. 	 * http请求版本1
  10. 	 * @param param
  11. 	 * @return
  12. 	 */
  13. 	public Object excute(Map<String,String> param){
  14. 		String url = "www.baidu.com/key/user/getUserById";
  15. 		HttpClient client = new DefaultHttpClient();
  16. 		HttpPost post = new HttpPost(url);
  17. 		List<NameValuePair> nvps = new ArrayList<NameValuePair>();
  18. 		for (String key : param.keySet()) {
  19. 			nvps.add(new BasicNameValuePair(key, param.get(key)));
  20. 		}
  21. 		try {
  22. 			post.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8));
  23. 			HttpResponse response = client.execute(post);
  24. 			return EntityUtils.toString(response.getEntity());
  25. 		} catch (IOException e) {
  26. 			return "";
  27. 		}
  28. 	}
  29. }

         缺点：每次都使用Http的创建不方便，且书写Http请求过程复杂容易出错；   

     

        方案2：封装Http工具类进行调用

  1. /**
  2.  * http请求封账工具类
  3.  *     1，将通用变量抽离成私有变量
  4.  *     2，参数则通过外部参数信息传入
  5.  *     3，对返回结果进行处理
  6.  *
  7.  * @author hzm ${2020-06-20 17:57}
  8.  */
  9. public class Http1 {
  10.  
  11. 	private String domainUrl = "www.baidu.com";
  12. 	private String serviceName = "user";
  13. 	private String serviceInterface = "getUserById";
  14.  
  15. 	/**
  16. 	 * http请求版本1
  17. 	 * @param param
  18. 	 * @return
  19. 	 */
  20. 	public static Object excute(Map<String,String> param){
  21. 		String url = domainUrl + "/key/" +  serviceName + "/" + serviceInterface;
  22. 		HttpClient client = new DefaultHttpClient();
  23. 		HttpPost post = new HttpPost(url);
  24. 		List<NameValuePair> nvps = new ArrayList<NameValuePair>();
  25. 		for (String key : param.keySet()) {
  26. 			nvps.add(new BasicNameValuePair(key, param.get(key)));
  27. 		}
  28. 		try {
  29. 			post.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8));
  30. 			HttpResponse response = client.execute(post);
  31. 			return EntityUtils.toString(response.getEntity());
  32. 		} catch (IOException e) {
  33. 			return "";
  34. 		}
  35. 	}
  36. }

        缺点：1，对请求入参参数没有约定，容易超出边界；

                   2，返回结果数据可变化性不强，需调用者手动处理加工，加大了代码的开发难度； 

 

       方案3：通过代理模式封装Http请求类，由代理类统一执行器进行调用；

       第一步：定义Http请求接口

  1. package com.example.http.http2;
  2.  
  3. /**
  4.  * http发起请求的客户端
  5.  *
  6.  * @author hzm ${2020-06-20 19:01}
  7.  */
  8. public interface HttpClient2 {
  9.  
  10.  
  11. 	/**
  12. 	 * 执行http请求接口封装：  将请求入参封装为HttpRequest、返回参数封装为HttpResponse
  13.      *      实现统一调用和结果返回；
  14. 	 * @param request 请求对象
  15. 	 * @param <T>
  16. 	 * @return HttpResponse 响应对象
  17. 	 */
  18. 	public <T extends HttpResponse> T excute(HttpRequest<T> request);
  19.  
  20.  
  21. }

        第二步：实现Http请求接口，并可以提供多种接口方式进行调用

  1. package com.example.http.http2;
  2.  
  3. /**
  4.  * 基本http客户端实现类
  5.  *		相对封装工具类，入参和返回的封装容易出现问题
  6.  * @author hzm ${2020-06-24 19:01}
  7.  */
  8. public class BaseHttpClient2  implements HttpClient2{
  9.  
  10. 	//todo 属性可以封装一些执行请求的指令参数：
  11. 	//   超时时间、   请求令牌    请求支持格式等；
  12.  
  13. 	@Override
  14. 	public <T extends HttpResponse> T excute(HttpRequest<T> request) {
  15. 		//第一步：将请求参数解析出来：{
  16. 		// 		1，header信息
  17. //				2、请求参数信息
  18. //				3、请求APP信息
  19. //              可扩展流程：参数校验/  信息解析；
  20. 		// }
  21.  
  22. 		//第二步：封装Http请求，
  23.  
  24. 		//第三步：执行http请求调用结果
  25.  
  26. 		//第四步：封装返回结果为指定的Resopnse结果值；
  27.  
  28. 		//其他：异常处理
  29.  
  30. 		return null;
  31. 	}
  32.  
  33.  
  34. }

        第三步：封装Request接口和实现、以及Response接口和实现

             HttpRequest实现基础参数封装；

             BaseHttpRequest 进一步封装常用参数信息（Header信息及其他公用信息）

             UserSearchRequest  ：封装该请求的接口参数入参及接口号信息

  1. package com.example.http.http2;
  2.  
  3. import java.util.Map;
  4.  
  5. /**
  6.  * 我是谁
  7.  *
  8.  * @author hzm ${2020-06-20 18:18}
  9.  */
  10. public interface HttpRequest<T extends HttpResponse> {
  11.  
  12. 	/**
  13. 	 * 获取应用
  14. 	 * @return
  15. 	 */
  16. 	public String getAppKey();
  17.  
  18. 	/**
  19. 	 * 获取方法
  20. 	 * @return
  21. 	 */
  22. 	public String getMethod();
  23.  
  24. 	/**
  25. 	 * 获取参数
  26. 	 * @return
  27. 	 */
  28. 	public Map<String,String> getParam();
  29.  
  30. 	/**
  31. 	 * 获取请求头信息
  32. 	 * @return
  33. 	 */
  34. 	public Map<String,String> getHeader();
  35.  
  36.  
  37. 	/**
  38. 	 * 检查参数信息
  39. 	 * @return
  40. 	 */
  41. 	public boolean check();
  42. }
  43.  
  44.  
  45.  
  46.  
  47. package com.example.http.http2.Request;
  48.  
  49. import com.example.http.http2.HttpRequest;
  50. import com.example.http.http2.HttpResponse;
  51.  
  52. import java.util.HashMap;
  53. import java.util.Map;
  54.  
  55. /**
  56.  * 我是谁
  57.  *
  58.  * @author hzm ${Date}
  59.  */
  60. public abstract class BaseHttpRequest<T extends HttpResponse> implements HttpRequest {
  61. 	protected Map<String,String> headerStringMap;
  62. 	protected Map<String,String> paramMap;
  63. 	protected String appKey;
  64.  
  65.  
  66. 	public void putHeaderParam(String key, String value){
  67. 		if(this.headerStringMap == null){
  68. 			this.headerStringMap = new HashMap<>();
  69. 		}
  70. 		headerStringMap.put(key,value);
  71. 	}
  72.  
  73. 	public Map<String, String> getHeaderStringMap() {
  74. 		if(this.headerStringMap == null){
  75. 			this.headerStringMap = new HashMap<>();
  76. 		}
  77. 		return this.headerStringMap;
  78. 	}
  79.  
  80. 	public void setHeaderStringMap(Map<String, String> headerStringMap) {
  81. 		this.headerStringMap = headerStringMap;
  82. 	}
  83.  
  84. 	public Map<String, String> getParamMap() {
  85. 		if(this.paramMap == null){
  86. 			this.paramMap = new HashMap<>();
  87. 		}
  88. 		return this.paramMap;
  89. 	}
  90.  
  91. 	public void setParamMap(Map<String, String> paramMap) {
  92. 		this.paramMap = paramMap;
  93. 	}
  94.  
  95. 	@Override
  96. 	public String getAppKey() {
  97. 		return appKey;
  98. 	}
  99.  
  100. 	public void setAppKey(String appKey) {
  101. 		this.appKey = appKey;
  102. 	}
  103. }
  104.  
  105.  
  106.  
  107.  
  108.  
  109. package com.example.http.http2.Request;
  110.  
  111. import com.example.http.http2.Response.UserSearchResponse;
  112.  
  113. import java.util.Map;
  114.  
  115. /**
  116.  * 我是谁
  117.  *
  118.  * @author hzm ${Date}
  119.  */
  120. public class UserSearchRequest extends BaseHttpRequest<UserSearchResponse> {
  121. 	/**用户id  姓名  地址*/
  122. 	private String id;
  123. 	private String name;
  124. 	private String adds;
  125.  
  126. 	@Override
  127. 	public String getMethod() {
  128. 		return "getUserByContion";
  129. 	}
  130.  
  131. 	@Override
  132. 	public Map<String, String> getParam() {
  133. 		//将参数设置进去
  134. 		return this.paramMap;
  135. 	}
  136.  
  137. 	@Override
  138. 	public Map<String, String> getHeader() {
  139. 		return this.headerStringMap;
  140. 	}
  141.  
  142. 	@Override
  143. 	public boolean check() {
  144. 		//todo 参数校验
  145. 		return false;
  146. 	}
  147.  
  148. 	//get and set
  149.  
  150.  
  151. 	public String getId() {
  152. 		return id;
  153. 	}
  154.  
  155. 	public void setId(String id) {
  156. 		this.id = id;
  157. 	}
  158.  
  159. 	public String getName() {
  160. 		return name;
  161. 	}
  162.  
  163. 	public void setName(String name) {
  164. 		this.name = name;
  165. 	}
  166.  
  167. 	public String getAdds() {
  168. 		return adds;
  169. 	}
  170.  
  171. 	public void setAdds(String adds) {
  172. 		this.adds = adds;
  173. 	}
  174.  
  175. 	@Override
  176. 	public String toString() {
  177. 		return "UserSearchRequest{" +
  178. 				"id='" + id + '\'' +
  179. 				", name='" + name + '\'' +
  180. 				", adds='" + adds + '\'' +
  181. 				'}';
  182. 	}
  183. }
  184.

        HttpResponse：  

                 HttpResponse，封装响应的消息、响应执行情况，响应结果信息

                 UserSearchResponse，  封装请求返回参数信息

  1. package com.example.http.http2;
  2.  
  3. import java.io.Serializable;
  4. import java.util.Map;
  5.  
  6. /**
  7.  * 基础httpResponse属性封装
  8.  *
  9.  * @author hzm ${2020-06-20 18:00}
  10.  */
  11. public abstract class HttpResponse  implements Serializable {
  12.  
  13. 	/**
  14. 	 * 执行信息（正确/错误）
  15. 	 */
  16. 	private String message;
  17.  
  18. 	/**
  19. 	 * 响应结果：转换为字符串；
  20. 	 */
  21. 	private String response;
  22.  
  23. 	/**
  24. 	 * 是否成功
  25. 	 */
  26. 	private boolean isSuccess;
  27.  
  28. 	/**
  29. 	 * 请求入参参数
  30. 	 */
  31. 	private Map<String,String> params;
  32.  
  33.  
  34. 	//get and set
  35. 	public String getMessage() {
  36. 		return message;
  37. 	}
  38.  
  39. 	public void setMessage(String message) {
  40. 		this.message = message;
  41. 	}
  42.  
  43. 	public String getResponse() {
  44. 		return response;
  45. 	}
  46.  
  47. 	public void setResponse(String response) {
  48. 		this.response = response;
  49. 	}
  50.  
  51. 	public boolean isSuccess() {
  52. 		return isSuccess;
  53. 	}
  54.  
  55. 	public void setSuccess(boolean success) {
  56. 		isSuccess = success;
  57. 	}
  58.  
  59. 	public Map<String, String> getParams() {
  60. 		return params;
  61. 	}
  62.  
  63. 	public void setParams(Map<String, String> params) {
  64. 		this.params = params;
  65. 	}
  66. }
  67.  
  68.  
  69.  
  70.  
  71. package com.example.http.http2.Response;
  72.  
  73.  
  74. import com.example.http.http2.HttpResponse;
  75.  
  76. /**
  77.  * 我是谁
  78.  *
  79.  * @author hzm ${Date}
  80.  */
  81. public class UserSearchResponse  extends HttpResponse {
  82.  
  83. 	private Long id;
  84. 	private String  name;
  85. 	private String adds;
  86.  
  87. 	//get  and set
  88.  
  89. 	public Long getId() {
  90. 		return id;
  91. 	}
  92.  
  93. 	public void setId(Long id) {
  94. 		this.id = id;
  95. 	}
  96.  
  97. 	public String getName() {
  98. 		return name;
  99. 	}
  100.  
  101. 	public void setName(String name) {
  102. 		this.name = name;
  103. 	}
  104.  
  105. 	public String getAdds() {
  106. 		return adds;
  107. 	}
  108.  
  109. 	public void setAdds(String adds) {
  110. 		this.adds = adds;
  111. 	}
  112.  
  113. 	@Override
  114. 	public String toString() {
  115. 		return "UserGetResponse{" +
  116. 				"id=" + id +
  117. 				", name='" + name + '\'' +
  118. 				", adds='" + adds + '\'' +
  119. 				'}';
  120. 	}
  121. }

       缺点：新增加一个接口都需要实现这个接口的Request实现类+  Response实现类，工作量较大，且重复冗余；

       设计模式：利用接口封装，将请求、入参、返参、其他解析、异常处理都通过接口封装的方式进行封装，

                实现动态变量的扩展使用，且参数实现统一的约定；

 

 

        方案4：AOP实现，代理进行AOP代理的各个方法的无感知调用并可加入权鉴信息在代理类中；

           设计模式：利用MethodInterceptor实现对   

            ProxyFactory.getProxy(this.serviceInterface,this) 类的方法级别动态代理；将http请求信息封装在Invoke()方法中；

                       FactoryBean介绍：  https://mp.csdn.net/console/editor/html/107254969

                       MethodInterceptor介绍：https://blog.csdn.net/Munger6/article/details/106695421

              1、HttpApiMethodInterceptor  ： 实现MethodInterceptor  动态代理调用invoke方法走Http请求统一封装

  1. package com.example.http.http3;
  2.  
  3. import org.aopalliance.intercept.MethodInterceptor;
  4. import org.aopalliance.intercept.MethodInvocation;
  5. import org.apache.http.client.HttpClient;
  6. import org.apache.http.impl.client.DefaultHttpClient;
  7. import org.springframework.beans.factory.InitializingBean;
  8.  
  9. /**
  10.  * 我是谁
  11.  *
  12.  * @author hzm ${2020-07-02 19:50}
  13.  */
  14. public class HttpApiMethodInterceptor implements MethodInterceptor , InitializingBean {
  15. 	//http请求客户端
  16. 	HttpClient client;
  17.  
  18. 	//请求url地址
  19. 	protected String url;
  20.  
  21. 	//可设置其他的权限，密令等信息
  22.  
  23.  
  24.  
  25. 	@Override
  26. 	public Object invoke(MethodInvocation methodInvocation) throws Throwable {
  27. 		//执行拦截到方法调用之后的请求逻辑
  28. 		/***第一步：构建httpRequest: 根据GET  /POST 进行不同的请求创建  通过方法的注解写入***/
  29. //		methodInvocation.getMethod().getAnnotation(RequestMethod.class).value();  获取请求方式
  30. //		methodInvocation.getMethod().getDeclaringClass().getSimpleName()   获取服务名
  31. //		methodInvocation.getMethod().getName()  获取方法
  32. //		methodInvocation.getArguments()   获取参数
  33. //		methodInvocation.getMethod().getGenericReturnType()   获取返回参数
  34. 		/***第二步：构建httpRequest: 添加header信息（命令  权限等信息）***/
  35.  
  36. 		/***第三步：执行请求***/
  37.  
  38. 		/***第四步：将请求结果进行解析封装成对应的返回结果bean***/
  39.  
  40. 		return null;
  41. 	}
  42.  
  43.  
  44. 	@Override
  45. 	public void afterPropertiesSet() throws Exception {
  46. 		//属性自动注入之后调用该方法， 创建http请求
  47. 		client = new DefaultHttpClient();
  48. 	}
  49. }

                  2、HttpApiProxyFactoryBean，封装动态代理对象交给getObject()方法给真实调用

  1. package com.example.http.http3;
  2.  
  3. import org.springframework.aop.framework.ProxyFactory;
  4. import org.springframework.beans.factory.FactoryBean;
  5. import org.springframework.beans.factory.InitializingBean;
  6.  
  7. /**
  8.  * 优势：大量的方法暴露使用简便；
  9.  * factoryBean 交给容器管理
  10.  *  <bean id="userSearchFacade" class="com.alibaba.ak.base.openapi.HttpApiProxyFactoryBean">
  11. *         <property name="serviceInterface" value="com.example.http.http3.UserSearchFacade"/>
  12. *         <property name="url" value="www.baidu.com"/>
  13. *     </bean>
  14.  * @author hzm ${Date}
  15.  */
  16. public class HttpApiProxyFactoryBean extends HttpApiMethodInterceptor
  17. 		implements FactoryBean<Object>, InitializingBean {
  18.  
  19. 	private Object proxy;
  20.  
  21. 	private Class<?> serviceInterface;
  22.  
  23.  
  24. 	@Override
  25. 	public void afterPropertiesSet() throws Exception {
  26. 		super.afterPropertiesSet();
  27. 		this.proxy = ProxyFactory.getProxy(this.serviceInterface,this);
  28. 	}
  29.  
  30.  
  31. 	@Override
  32. 	public Object getObject() throws Exception {
  33. 		return this.proxy;
  34. 	}
  35.  
  36. 	@Override
  37. 	public Class<?> getObjectType() {
  38. 		return this.serviceInterface;
  39. 	}
  40.  
  41. 	@Override
  42. 	public boolean isSingleton() {
  43. 		return true;
  44. 	}
  45.  
  46. 	public Class<?> getServiceInterface() {
  47. 		return serviceInterface;
  48. 	}
  49.  
  50. 	public void setServiceInterface(Class<?> serviceInterface) {
  51. 		this.serviceInterface = serviceInterface;
  52. 	}
  53.  
  54. 	// get and set 父类的属性
  55. 	public String getUrl() {
  56. 		return url;
  57. 	}
  58.  
  59. 	public void setUrl(String url) {
  60. 		this.url = url;
  61. 	}
  62. }

                    3、Facade封装调用的方法与接口

  1. package com.example.http.http3;
  2.  
  3. /**
  4.  * 用户搜索门面
  5.  *
  6.  * @author hzm ${2020-07-02 10:26}
  7.  */
  8. public interface UserSearchFacade {
  9.  
  10.  
  11. 	@RequestMethod("POST")
  12. 	Result<User> resetRelatedProjectSets(@Param("projectId") Integer var1, @Param("projectSetIds") List<Integer> var2, @Param("modifier") String var3);
  13.  
  14.  
  15. }
  1.   <bean id="userSearchFacade" class="com.example.http.http3.OpenApiProxyFactoryBean">
  2.         <property name="serviceInterface" value="com.example.http.http3.UserSearchFacade"/>
  3.         <property name="serviceUrl" value="www.baidu.com"/>
  4.     </bean>

              xml配置注入代理类信息

              这一实现方式我们就可以很方便的仅定义一个门面类即可；大大提升了代码的易维护性和参数的安全性

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/259355
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号