☕ JAVA在线测试 →

DeepSeek

实时查看 AI 助手的流式响应

工具效率

DeepSeek 智能助手

个人简历-英文

关于我

📄 Resume

👨‍💻 Personal Information

  • Name: Guojun Wu
  • Gender: Male
  • Age: 33 years old
  • Phone: 18091983163
  • Email: blowizer@qq.com
  • Experience: 10 Years
  • Target Role: Java Developer
  • Expected Salary: 20-25K
  • Target City: Beijing

✨ Core Competencies

  1. Proficient in programming languages including C/C++, Java, Go, PHP, Perl, Python, and Vuejs.
  2. Skilled in the development ecosystem of Spring Boot, Spring Cloud, MyBatisPlus, Maven, and Git.
  3. Expertise in open-source frameworks such as Dubbo, RocketMQ, Redis, ES (Elasticsearch), Docker, and K8s (Kubernetes).
  4. Mastery of the Linux operating system with a profound understanding of the Linux kernel.
  5. Possesses efficient team coordination ability, extensive technical depth, and the capability to quickly and flexibly utilize the latest technologies, with a keen insight into the root cause of problems.

🚀 Work Experience

Longying Zhida (Beijing) Technology Co., Ltd. (Java Developer)

  • Duration: September 2023 - Present [cite: 17, 38]
  • Responsibilities:
    • Responsible for the application development of the Remote Banking System, ensuring system stability and high efficiency to meet customer needs.
    • Participated in requirements analysis, development, functional testing, and system optimization; coordinated project resources to ensure on-time delivery.
    • Managed and optimized project processes, improving team collaboration efficiency and promoting smooth project execution.
  • Achievements:
    • The Remote Banking Work Order System achieved staged breakthroughs in centralized and unified management of customer work orders across the entire bank, cross-system collaborative processing, intelligent analysis, and data compliance.
    • The system capabilities gradually shifted from “scattered information and passive handling” to “unified authority, intelligent collaboration, and full visibility,” laying a solid foundation for building a customer-centric consumer protection management system.

Shanghai Zhongruan Huateng Software System Co., Ltd. (Java Developer)

  • Duration: October 2016 - August 2023
  • Responsibilities:
    • Primarily responsible for business requirement analysis, development, testing, and maintenance of banking functions.
    • Involved in business channels including ATM, POS acquiring, UnionPay, Second-Generation Payment (二代支付), City Commercial Banks (城商), and negotiable instruments (票据).
    • Applied technology stack included C/C++, Java, Spring Boot, MyBatis, Oracle, and Vuejs.

Beijing Biomarker Technologies Co., Ltd. (Operations Engineer)

  • Duration: October 2015 - August 2016
  • Responsibilities:
    • Operation and maintenance of Linux HPA (High Performance Application) high-performance clusters.
    • Construction of an automated O&M monitoring system.
    • Installation and troubleshooting of basic OA software.
  • Achievements:
    • Implemented statistics and alert notifications for computing and storage resources based on phpAdmin.
    • Completed data center migration and upgrade, including computing core storage NAS storage RAID 5 upgrade to RAID 10, and network bandwidth improvement.
    • Built the foundation for cloud computing using Prometheus, Zabbix, Ansible, and OpenStack.
    • Established the Jira task tracking and management system.

📂 Project Experience

Remote Banking System (Full-Stack Engineer)

  • Duration: September 2023 - Present
  • Description:
    • The system is built on Huaxia Bank’s AICC (Intelligent Customer Service) platform, supporting the unified access and processing of customer requests from multiple channels like voice, video, and online chat.
    • Achieved full-channel acceptance, intelligent dispatch, process tracking, and closed-loop management of customer requests.
  • Achievements:
    • Cross-System Interconnection: Implemented the “12378 One-Click Work Order Transfer” function, connecting work order flows and status between the Credit Card Center and the Remote Banking System, ensuring consistency and validity of complaint reporting data.
    • Enterprise WeChat Mobile Processing: Supported convenient work order handling on the Enterprise WeChat mobile application, customized sensitive information desensitization permissions, and allowed offline forms to automatically link call information.
    • Customer Suggestion Linkage to ITIL: Real-time integration of customer suggestion work orders with the internal ITIL system, achieving rapid evaluation and closed-loop implementation of customer suggestions.
    • Customer Service & Branch Linkage: Introduced a new mechanism for CS-Branch collaboration, using an embedded Enterprise WeChat application for task notification, transfer, and status queries.
    • Data Analysis & Intelligent Quality Inspection: The work order report system supports three-month data queries and is integrated with the intelligent customer service robot subsystem for intelligent quality inspection and customer intent analysis.

Digital RMB Acquiring System (Front & Back-end Developer)

  • Duration: December 2022 - June 2023
  • Description:
    • A multi-module, multi-application system developed based on Spring Cloud, covering merchant management, payment, operations analysis, and risk control.
  • Achievements:
    • Integrated Spring Security for comprehensive permission control.
    • Integrated the Flowable workflow engine.
    • Connected to imaging, SMS, and identity authentication components via the client’s financial gateway.

Intelligent Teller Machine P-side System (Back-end Developer)

  • Duration: January 2022 - December 2022
  • Description:
    • The internal back-end management system for Intelligent Teller Machines, supporting C-side transactions (debit/credit, wealth management, identity recognition), terminal management, security verification, and data reports.
  • Achievements:
    • Responsible for integrating the encryption platform (encryption API upgrade).
    • Provided technical guidance for the transaction system development.
    • Managed the migration of business data (outflow and inflow).
    • Executed the system deployment and launch.

UnionPay Front-end System (Developer)

  • Duration: October 2016 - December 2020
  • Description:
    • The interbank payment transaction system, including transactions like deposits and withdrawals from the bank’s POS, ATM, card-less, QR code, and counter middle-office platform.
    • Handled functions such as UnionPay interface, system security, message forwarding, and business control.
  • Achievements:
    • Developed business functions for UnionPay standard upgrades.
    • Completed the city-to-city active-active deployment of the application system.
    • Migrated the credit card direct connection cutoff system.

🎓 Education

  • University: Ankang University
  • Degree: Bachelor
  • Major: Computer Science and Technology
  • Duration: 2011-2015

🏆 Certifications

  • PMP Project Management Professional Certification

剑法篇

C语言-列表

编程语言

◀ 返回

线性表

  • 顺序表
  • 链式表

线性表的本质

定义：
	由0个或多个数据元素的集合
	数据元素之间是有顺序的
	数据元素的个数是有限个
	数据元素的类型必须相同
	
专业的定义：
	线性表是具有相同类型的n(n>=0)个数据元素的有限序列
	(a0,a1,a2,..an)
	ai是表项，n是长度
	
性质：
	a0为线性表的第一个元素，只有一个后继
	an为线性表的最后一个元素，只有一个前驱
	除a0和an以外的其他元素ai，既有前驱也有后继.

线性表的操作

	创建
	销毁
	插入
	删除
	获得表中某个位置的元素
	获得线性表的长度
	清空

线性表的操作对应于我们程序中的一组函数

List *List_Create(void);
void List_Destroy(List *list);
void List_Clear(List *list);
int List_Insert(List *list, ListNode *node, int pos)
ListNode * List_Delete(List *list, int pos)
ListNode * List_Get(List *list, int pos)
int List_Length(List *list)

线性表的顺序存储结构

线性表的顺序存储结构是指用一段地址连续的存储单元依次存储线性表的数据元素 看成C语言的数组，用C语言的一维数组实现顺序存储结构

	#define MAXSIZE 20 //线性表的最大容量
	typedef struct _list {
		char node[MAXSIE]; //存储空间的起始地址是node
		int length; //表示线性表的当前长度
	}List;

获得元素的操作

	char Get(List *list, int pos) {
		char ret = -1;
		
		// 1. 判断list的合法性
		// 2. 判断位置的合法性
		if ( (list!=NULL) &&(0<=pos) && (pos<list->length) )
			// 3. 获得元素	
			ret = list->node[pos];
		return ret;
	}

插入元素的操作

算法：
	1.判断线性表的合法性	
	2.判断插入位置的合法性
	3.把最后一个元素到插入位置的元素依次后移一个位置
	4.将新元素插入
	5.将长度加1

int Insert(List *list, char c, int pos) {
		int ret = (list!=NULL);
		int i = 0;
		
		ret = ret && (list->length <= MAXSIZE);
		ret = ret && (0<=pos);	

		if ( ret ) {
			if ( pos > list->length)
				pos = list->length;
			
			for (i=list->length; i>pos; i--)
				list->node[i] = list->node[i-1]; 
			
			list->node[i] = c;
			list->length++;
		}

		return ret;
	}

删除元素操作

算法：
	1.判断线性表的合法性	
	2.判断删除位置的合法性
	3.将元素取出
	4.将删除位置之后的所有元素都向前移动一个位置
	5.顺序表的长度-1

har Delete(List *list, int pos) {
			char ret = -1;
			int i = 0;
			
			if ( (list!=NULL)&&(0<=pos)&&(pos<list->length) ){
				ret = list->node[pos];
				for (i=pos+1; i<list->length; i++)
					list->node[i-1] = list->node[i];
				list->length--;
			}
		
			return ret;
		}

优点：可以快速的获取表中合法位置的元素 缺点：插入和删除的时候需要移动大量的元素

剑法篇

C源码加壳解析

编程语言

◀ 返回

问题描述

字符串被显示为acssi码, 数值被hex加减

源码

转换思路

字符: acssi 转 string 数值: 计算出值

贴代码

#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#define setnull(x) memset(&(x), 0, sizeof(x))
#define CAL(x, y, z) x + y - z
#define ERR_EXIT(m) \
    do { \
        fprintf(stderr, "[%s][%d]:%s %s \n" ,__FILE__, __LINE__, m, strerror(errno));\
        exit(EXIT_FAILURE); \
        }while(0)


int main( int argc, char **argv){
    int i,j,len,varLen,ilen ;
    char buf[1024];
    char temp[2];
    char var[64],var1[64];
    char ascii[2];
    char hexBuf[1024];
    char fbuf[1024];
    char tobuf[1024];
    int begin = 0, end = 0; 
    char *data;
    char *pstr;
    char *pstr1;
    int retlen;
    char varBuf[20];
    char varRet;
    char srcfile[256],destfile[256];

    setnull(srcfile);
    setnull(destfile);
    sprintf(srcfile,"%s", argv[1]);
    sprintf(destfile,"%s", argv[2]);
    //printf("%s\n",argv[1]);
    //printf("%s\n",srcfile);
    //printf("%s\n",argv[2]);
    //printf("%s\n",destfile);
    //strcpy(hexBuf, argv[1]);
    FILE* fd = fopen(srcfile,"r");
    FILE* fdw = fopen(destfile,"w");
    if(fd){
        while(!feof(fd)){
           memset(fbuf, 0x00, sizeof(fbuf));
           data = fgets(fbuf,sizeof(fbuf)-1,fd);
           if(data){
                memset(tobuf, 0x00, sizeof(tobuf));
                len = strlen(data);
                for (i = 0, j = 0; i < len;){
                   if(!memcmp(data + i,"\\x",2)){
                       memset(ascii, 0x00, 2);
                       memcpy(temp, data + i + 2, 2);
                       //printf("temp: %s\n", temp);
                       hex2ascii(temp, ascii);
                       //printf("ascii: %s\n", ascii);
                       memcpy(tobuf + j, ascii, 1);
                       i += 4;
                       j++;
                       //printf("find \\x string offset %d\n", i); 

                   }else if(!memcmp(data + i,"(0x",3)){
                        memset(var, 0x00, sizeof(var));
                        memset(var1, 0x00, sizeof(var1));
                        memset(varBuf, 0x00, sizeof(varBuf));

                        memcpy(var, data + i, sizeof(var));  
                        //printf("var: %s \n", var);

                        pstr = strchr(var, '(');
                        if ( pstr != NULL)
                        {
                            if( pstr1 = strstr(var, ")")){
                                //printf("find ),\n");
                                varLen = pstr1 - pstr ;
                                //printf("%d\n", varLen);
                                memcpy(var1, var+1,varLen -1);
                                varRet = cal(var1);
                                sprintf(varBuf,"%d",varRet);
                                //printf("%s,%d\n",varBuf,varRet);
                                ilen = strlen(varBuf);
                                memcpy(tobuf + j, varBuf , ilen);
                                j += ilen ;
                                i += varLen + 1;
                            }
                           //else if( pstr1 = strstr(var, ");")){
                           //     printf("find );\n");
                           //     int varLen = pstr1 - pstr ;
                           //     printf("%d\n", varLen);
                           //     memcpy(var1, var+1,varLen -1);
                           //     varRet = cal(var1);
                           //     sprintf(varBuf,"%d;",varRet);
                           //     printf("%s,%d\n",varBuf,varRet);
                           //     int ilen = strlen(varBuf);
                           //     memcpy(tobuf + j, varBuf , ilen + 1);
                           //     j += ilen + 1;
                           //     i += varLen + 1 + 1;
                           // }
                           //else if( pstr1 = strstr(var, ")")){
                           //     printf("find )\n");
                           //     int varLen = pstr1 - pstr ;
                           //     printf("%d\n", varLen);
                           //     memcpy(var1, var+1,varLen -1);
                           //     varRet = cal(var1);
                           //     sprintf(varBuf,"%d",varRet);
                           //     printf("%s,%d\n",varBuf,varRet);
                           //     int ilen = strlen(varBuf);
                           //     memcpy(tobuf + j, varBuf , ilen );
                           //     j += ilen;
                           //     i += varLen + 1;
                           //// }
                        }
                   }else{

                       tobuf[j] = data[i];
                       i++;
                       j++;
                   }

                }
                //printf("%s", data);
                fprintf(fdw,"%s",tobuf);
            }
        }
    }else{
        ERR_EXIT("open file failure");
    }
    fclose(fd);
    //for( i = 0; i < strlen(argv[1]); i++){ 
    //    printf("%c\n", argv[i]);
    //}
    //int ret =  hex2ascii(hexBuf,buf);
    //for( i = 0; i < strlen(buf); i++){ 
    //    printf("%c", buf[i]);
    //}
    //printf("\n");
}

int hex2ascii(char *hex, char *ascii)
{
    int len = strlen(hex), tlen, cnt , i;

    for( i = 0, cnt = 0 ,tlen =0; i < len; i++){
        char c = toupper(hex[i]);

        if(( c >= '0' && c <='9') || ( c >= 'A' && c <= 'F'))
        {
            int  t = ( c >='A') ? c - 'A' + 10 : c - '0';

            if(cnt)
                ascii[tlen++] += t, cnt =0;
            else 
                ascii[tlen] = t << 4, cnt = 1;
                
        }
    }
    return tlen;
}
int cal(char *exprs){

    int x,y,z;
    //printf("%s\n", exprs);
    sscanf(exprs,"%x + %d - %x",&x,&y,&z);
    return CAL(x,y,z); 
}

编译

gcc -o hex2ascii hex2ascii.c

剑法篇

以模式为纲，化复杂为简

编程语言

◀ 返回

单一职责原则(SRP:Single Responsibility Principle)

一个类只负责完成一个职责或者功能，不要存在多于一种导致类变更的原因。单一职责原则通过避免设计大而全的类，避免将不相关的功能耦合在一起，来提高类的内聚性。同时，类职责单一，类依赖的和被依赖的其他类也会变少，减少了代码的耦合性，以此来实现代码的高内聚、松耦合。但是，如果拆分得过细，实际上会适得其反，反倒会降低内聚性，也会影响代码的可维护性。

假设你在构建一个应用程序，其中有个模块是根据条件搜索顾客并以Excel形式导出。随着业务的发展，搜索条件会不断增加，导出数据的分类也会不断增加。如果此时将搜索与数据导出功能放在同一个类中，势必会变的笨重起来，即使是微小的改动，也可能影响其他功能。所以根据单一职责原则，一个类只有一个职责，故创建两个单独的类，分别处理搜索以及导出数据。

开放-关闭原则(OCP:Open Closed Principle)

添加一个新的功能，应该是通过在已有代码基础上扩展代码（新增模块、类、方法、属性等），而非修改已有代码（修改模块、类、方法、属性等）的方式来完成。

开闭原则并不是说完全杜绝修改，而是以最小的修改代码的代价来完成新功能的开发。

很多设计原则、设计思想、设计模式，都是以提高代码的扩展性为最终目的的。特别是 23 种经典设计模式，大部分都是为了解决代码的扩展性问题而总结出来的，都是以开闭原则为指导原则的。最常用来提高代码扩展性的方法有：多态、依赖注入、基于接口而非实现编程，以及大部分的设计模式（比如，装饰、策略、模板、职责链、状态）。

假设你现在正在开发一个 Web 应用程序，包括一个在线纳税计算器。用户可以访问Web 页面,指定他们的收入和费用的细节,并使用一些数学公式来计算应纳税额。考虑到这一点，你创建了如下类：

public class TaxCalculator
{
    public decimal Calculate(decimal income, decimal deduction, string country)
    {
        decimal taxAmount = 0;
        decimal taxableIncome = income - deduction;
        switch (country)
        {
            case "India":
                //Todo calculation
                break;
            case "USA":
                //Todo calculation 
                break;
            case "UK":
                //Todocalculation
                break;
        }
        return taxAmount;
    }
}

这个方法非常简单，通过指定收入和支出，可以动态切换不同的国家计算不同的纳税额。但这里隐含了一个问题，它只考虑了3个国家。当这个 Web 应用变得越来越流行时，越来越多的国家将被加进来，你不得不去修改 Calculate 方法。这违反了开放封闭原则，有可能你的修改会导致系统其他模块的崩溃。

让我们对这个功能进行重构，以符合对扩展是开放，对修改是封闭的。

根据类图，可以看到通过继承实现横向的扩展，并且不会引发对其他不相关类的修改。这时 TaxCalculator 类中的 Calculate 方法会异常简单：