如标题所说，我不知道大家怎么看待这句话？

        拿一个正常的程序员举个例子，18开始上大学学习写代码，22岁大学毕业，一直干到30岁就需要考虑程序员的中年危机。

        小编身边很多程序员都不喜欢写代码，感觉写代码没有意思， 每天围绕着业务写来写去，除了CURD就是CURD，写完DAO层、写Service，写完Service，在创建一个Controller去调一下Service。

        小编我不否定，很多中小型公司都是业务来推动技术，技术就是实现服务公司业务，从而给公司带来收益。不是每家公司都像阿里，华为那些大厂一样，有专门研究技术、写中间价、写开源的团队。

        久而久之，所以很多公司就开始裁员一些年纪偏大的程序员，用成本小、年纪轻的人来代替。

        今天不跑题，我们来聊聊平时在工作中，小编是如何写代码。

        小编从2017步入社会开始写代码，对代码质量的要求，是从2019年开始的，19年的时候又重新开始学习软件设计7大原则、设计模式。 

        那个时候是有想法去提升，但是学习完之后，根本就不能去理解其中的含义，就感觉学了，但又感觉什么没学到。

       再后来就是慢慢开始学习框架源码，看一个开源框架，里面就有很多灵活运用设计模式的例子，这样就会每次加深对某个设计模式的理解和使用方式。

        小编最近在写一个业务网关功能，网关有接入、接出的能力。

        接入一家新的第三方，需要按照第三方要求来对数据进行加解密，之前公司实现有一点不能让我理解是，我需要一步步找到网关最底层，竟然是一个HttpClientUtils的类，然后在里面doPost方法中，在写一个if判断，如果code=新公司的code，就调用新公司加解密的逻辑。

        当然不排除最开始的研发人员，可能要求段时间内完成，所以就这么简单的进行了实现，然后之后的伙伴也是图方便就直接在后面写if判断，就导致的后果，大家都懂得。

        我不知道小伙伴们在设计代码的时候，有没有模块化的概念，这个也是小编之前总监对我说的，在写代码的时候，不要把全部的逻辑都写在一个方法里，要学会拆分，把一件事拆成几件事。一个方法里面上百、上千行的代码，相信大家应该都见过吧，不管是写的人，还是后面接手的人，看这代码，谁心里都不好受哇。

        很多公司对于Http的请求，可能也只是利用一个HttpClient工具类，里面有post、get静态方法，传递url、data、header等参数，完成http请求就完事了。对于没有负责的业务逻辑来说，确实就行了，一旦有一些特殊化处理的，就不太好扩展了。

        小编先是定义了两个接口类，设计功能，底层一定要是抽象的，而绝对不能是具体的代码实现，抽象往往会使系统更加稳定。

/*** Http 请求** @author IT贱男* @version v1.0.0* @date 2022/10/08 09:48*/
public interface HttpClientRequest extends Closeable {/*** 执行http请求** @param uri               请求地址* @param httpMethod        请求类型* @param requestHttpEntity 包装参数* @return* @throws Exception*/HttpClientResponse execute(URI uri, String httpMethod, RequestHttpEntity requestHttpEntity) throws Exception;}

/*** HTTP 返回处理** @author IT贱男* @version v1.0.0* @date 2022/9/30 14:00*/
public interface HttpClientResponse extends Closeable {/*** 获取请求头** @return*/Header getHeaders();/*** 获取输入流** @return* @throws IOException*/InputStream getBody() throws IOException;/*** 设置String 类型的body** @param body* @throws IOException*/void setBodyString(String body);/*** 获取String body** @param* @throws IOException*/String getBodyString();/*** 获取http请求状态码** @return* @throws IOException*/int getStatusCode() throws IOException;/*** 获取http请求状态码 字符串类型** @return* @throws IOException*/String getStatusText() throws IOException;/*** 关闭输入流*/@Overridevoid close();
}

        HttpClientRequest中定义了一个execute方法，然后交给子类去实现，比如说小编公司固定使用的就是RSA加解密，小编就创建RSAHttpClientRequest的类，去实现对参数进行RSA加解密的操作。DefaultHttpClientRequest就是默认的http请求，CustomHttpClientRequest就是为了满足新的接入方，就自己去创建一个新的HttpClient，去实现自己的业务逻辑。

        RSAClient、CustomClient都是在DefaultClient基础之上做一些自己额外的功能，所以继承了DefaultClient，为了代码复用。        

        Response就不多说了，只是为了响应请求做的一层包装。

        这样我们就把请求、响应的模块定义好了，那怎么使用？

        在上层只需要传入请求地址、请求头、请求参数，然后调用get、post方法就行，是不需要关心具体代码细节实现，所以肯定还会有一层包装类，包装类里面就是我们很熟悉的使用方式了。

@Slf4j
public class HttpClientRestTemplate extends AbstractHttpRestTemplate {private final HttpClientRequest requestClient;public HttpClientRestTemplate(HttpClientRequest requestClient) {this.requestClient = requestClient;}public  HttpRestResult get(String url, Object query) throws Exception {return execute(url, HttpMethodConstants.GET, new RequestHttpEntity(this.buildHead(), conversionObj(query)), String.class);}private  HttpRestResult execute(String url, String httpMethod, RequestHttpEntity requestEntity,Type responseType) throws Exception {URI uri = HttpUtils.buildUri(url, requestEntity.getQuery());// 获取response handler 处理类ResponseHandler responseHandler = super.selectResponseHandler(responseType);HttpClientResponse response = null;try {response = this.requestClient().execute(uri, httpMethod, requestEntity);} catch (Exception e) {log.error("HttpClientRestTemplate Http 请求失败", e);throw new BusinessException("HttpClientRestTemplate Http 请求失败", ErrorCodeEnum.SERVICE_EXCEPTION_500);}try {return responseHandler.handle(response);} catch (Exception e) {log.error("HttpClientRestTemplate handler 处理失败", e);throw new BusinessException("HttpClientRestTemplate handler 处理失败", ErrorCodeEnum.SERVICE_EXCEPTION_500);} finally {if (response != null) {response.close();}}}}

        包装类有了，怎么灵活去使用，应该是A公司就需要使用A公司的HttpClient、B公司就需要使用B公司的HttpClient，那这个时候工厂模式就派上使用了，交给工厂去生产相对应的HttpClient。

/*** HTTP 工厂类** @author IT贱男* @version v1.0.0* @date 2022/10/11 10:01*/
public interface HttpClientFactory {/*** 创建HttpClient** @return*/HttpClientRestTemplate createHttpClientRestTemplate();}

        小编拿了一个基于Config配置类的工厂为例子，Config配置是可以在Web后台有对应的页面进行配置，根据配置信息创建对应的HttpClient。

/*** 基于配置类创建HttpClient工厂** @author IT贱男* @version v1.0.0* @date 2022/10/11 13:19*/
@Slf4j
public class ConfigHttpClientFactory implements HttpClientFactory {// API后台配置信息private OpenapiKeyOutConfigDO openapiKeyOutConfigDO;public ConfigHttpClientFactory(OpenapiKeyOutConfigDO openapiKeyOutConfigDO) {this.openapiKeyOutConfigDO = openapiKeyOutConfigDO;}@Overridepublic HttpClientRestTemplate createHttpClientRestTemplate() {// 获取请求客户端CloseableHttpClient closeableHttpClient = getCloseableHttpClient();// 判断是否加密，不加密走DefaultClientif (OpenFlagEnum.CLOSE.getCode().equals(openapiKeyOutConfigDO.getIsEncryption())) {// 使用默认的 DefaultHttpClientRequestreturn new HttpClientRestTemplate(new DefaultHttpClientRequest(closeableHttpClient));}// 判断加密方式是不是RSAif (OpenFlagEnum.OPEN.getCode().equals(openapiKeyOutConfigDO.getIsEncryption())&& EncryptionTypeEnum.RSA.getCode().equals(openapiKeyOutConfigDO.getEncryptionType())) {// 使用默认的 RSAHttpClientRequestreturn new HttpClientRestTemplate(new RSAHttpClientRequest(closeableHttpClient, openapiKeyOutConfigDO.getTheirPublicKey(), openapiKeyOutConfigDO.getSelfPrivateKey()));}// 判断是不是自定义类加密if (OpenFlagEnum.OPEN.getCode().equals(openapiKeyOutConfigDO.getIsEncryption())&& EncryptionTypeEnum.CUSTOM_CLASS.getCode().equals(openapiKeyOutConfigDO.getEncryptionType())) {try {if (StringUtils.isEmpty(openapiKeyOutConfigDO.getRequestClientImplClassName())) {throw new BusinessException("创建自定义请求类错误，requestClientImplClassName参数为空", ErrorCodeEnum.SERVICE_EXCEPTION_500);}// 通过反射创建对应的HttpClient，代码省略} catch (Exception e) {log.error(e.getMessage(), e);}}throw new BusinessException("createHttpClientRestTemplate 失败", ErrorCodeEnum.SERVICE_EXCEPTION_500);}}

        在其他地方想要使用网关的话，只需要把相对应的配置告诉我，工厂就可以创建出你要想的HttpClient对象出来。

        这样以后接一家新的第三方，程序员只需要创建一个HttpClient，专注自己的业务逻辑，其他细节可以不用去考虑，这样也不需要去改之前原来的代码，符合开闭原则。

        为了扩展，小编设计了，有些第三方请求完成之后，需要做一些额外的特殊处理，最常见的就是字段映射，或者对象类型转换。

/*** response 处理结果转换** @param */
public interface ResponseHandler {void setResponseType(Type responseType);/*** 处理response 转换成对应自己所需要的内容** @param response* @return* @throws Exception*/HttpRestResult handle(HttpClientResponse response) throws Exception;
}

        首先会有一个公共处理的对象，比如说请求失败了，可以在这个类中做统一处理，如果没报错就调用convertResult方法，当然这个方法也是交给子类去实现。

        这个扩展是放在了HttpClientRestTemplate类中execute方法中去了

/*** 公用处理对象** @author IT贱男* @version v1.0.0* @date 2022/10/11 10:08*/
public abstract class AbstractResponseHandler implements ResponseHandler {private Type responseType;@Overridepublic final void setResponseType(Type responseType) {this.responseType = responseType;}@Overridepublic final HttpRestResult handle(HttpClientResponse response) throws Exception {// 请求失败就进行错误处理if (HttpStatus.SC_OK != response.getStatusCode()) {return handleError(response);}// 结果转换return convertResult(response, this.responseType);}private HttpRestResult handleError(HttpClientResponse response) throws Exception {Header headers = response.getHeaders();String message = IoUtils.toString(response.getBody(), headers.getCharset());return new HttpRestResult(headers, response.getStatusCode(), null, message);}/*** 把请求结果进行转换** @param response     http client response* @param responseType responseType* @return HttpRestResult* @throws Exception ex*/public abstract HttpRestResult convertResult(HttpClientResponse response, Type responseType) throws Exception;}

/*** 把结果处理成String类型** @author IT贱男* @version v1.0.0* @date 2022/10/11 10:06*/
public class StringResponseHandler extends AbstractResponseHandler {@Overridepublic HttpRestResult convertResult(HttpClientResponse response, Type responseType) throws Exception {final Header headers = response.getHeaders();if (StringUtils.isNotEmpty(response.getBodyString())) {String extractBody = ParameterRequestWrapper.jsonStringTrim(response.getBodyString());return new HttpRestResult<>(headers, response.getStatusCode(), extractBody, null);}String extractBody = ParameterRequestWrapper.jsonStringTrim(IoUtils.toString(response.getBody(), headers.getCharset()));return new HttpRestResult<>(headers, response.getStatusCode(), extractBody, null);}
}

        其实这一套设计下来，代码结构上，小编觉得是很清晰的，在扩展上也是互不影响的，代码维护上也更加直观了，直接定位到类。

        小编平时也是在写这些业务代码，但是在写的时候，小编尽量做到可扩展、代码清爽、维护性高的方向去设计。当然不是吹捧小编写代码有多好，只是想提醒大家，写代码就应该去考虑这些问题，而不是一股脑的吧功能实现好了就行了。

        只有这样慢慢去锻炼自己，写出来的代码质量才会越来越好，写代码也才会越来越有意思。

        文章回到标题，“没有十几年的积累，你还真写不出什么好的代码”

        这句话是小编逛BOSS的时候看到的，所以想来说说，其实吧，在中小型公司，技术往上走，多多少少都会带点管理。

        标题中的话，小编也是觉得有道理，喜欢写代码的程序员，自然就会去考虑自己的代码该怎么写才是最好，这样累计起来的经验，代码质量才会越来越好。

        行吧，有感而发，到这里结束了，对于标题中的话，小伙伴们怎么看？