开源项目

2 6

gitee

最伟大的架构=1%的想法+99%的代码。Talk is cheap，show me the code。

2023开源项目

chatgpt-java（+前端项目）

OpenAI ChatGPT 的逆向工程SDK。可扩展用于聊天机器人等。demo展示http://hoppinzq.com/chat/index.html

20 305 128

打开开源地址

这是1月份到2月份的产物。很荣幸，如果你在几个月前在gitee上搜索chatGPT，那么第一个就是这个项目。这是我今年的第二个项目，是今年第一个开源的项目。
其实聊天机器人这个功能很久之前就做了一个，也集成在微信（对话开放平台——好菜一只猫）里，当时直接调的开源的api，纯属娱乐，简直是人工智障，也没有什么技术含量。
chatGPT是22年末的产物，当时只能翻墙访问，且没有公开API，我只能通过国外服务器代理并且伪造请求来调用chatGPT的聊天接口。这就是这个项目的核心原理，直到现在，除了登录接口，其他伪造的请求还是可用的。
chatGPT最火是从3月份开始，当时openAI公开了他们的接口，你只需会模拟Http请求就能调用他们，当然需要在国外搭建代理服务。后面国内“自研”套壳chatGPT应用如雨后春笋诞生，我的这个项目狠狠地火了一把，以至于那段时间微信都被加爆了。没办法，我在4月中旬做了一个后台代理服务和一个聊天demo页面点我跳转来介绍如何使用SSE技术实现及时响应的对话，如何使用上下文，如何设置系统提示词，embedding优化，图片生成模型，代码生成模型，Key池，使用数据集训练。
后面直到6月份，程序还能平稳运行，我就编写了月度总结，统计了4月底到5月底的所有数据。当时我签发了2.8w个永久性token（因为http是无状态的，需要使用这个token维护与用户连接，用户无需在我的统一权限平台注册登录），预计大约2w个用户，要是每个人给我50块钱，那我就是百万富翁。互联网真的是普通人实现财富自由最近的一条路，每一个热点都将颠覆整个行业。我身边卖号的人都赚得盆满钵满。我就靠着网站上挂着的打赏，维持服务器和apikey的购买费用，也算小小地赚了一笔。
由于后台代理服务跟我的网关模块强绑定，导致很多小伙伴不会部署，这是我的问题，就先让他们部署前端。后面我就剥离出来，这时候很多小伙伴就可以部署了。能看出他们真的很开心，我也很享受这个过程。
后面经历各种封号，导致了我的网站也要跟着瘫痪，现在对话我目前是不维护了，只能说是可用。因为现在数据库数据量有千万级，即使加了索引，各种慢SQL监控把我搞烦了。目前只维护embedding接口，用以实现推荐系统。 SSE核心代码：展开代码


@GetMapping("/stream-sse3")
public SseEmitter streamSSE3(String message,String chatId,String apikey,String context_number,String system) throws IOException {
    SseEmitter emitter = new SseEmitter(300000L);// 设置 keep-alive 的时间为 6 分钟
    String logid= UUIDUtil.getUUID();
    List<ChatMessage> messages = new ArrayList<>();
    if(chatId!=null){
        //context_number与system可以通过chatId查出，这个接口采用传参的方式。
        int context_num;
        try{
            context_num=Integer.parseInt(context_number);
            if(context_num<2){
                emitter.send("500sse_error_zq_no:"+logid+",上下文的数目不能小于2");return emitter;
            }
            if(context_num>18){
                emitter.send("500sse_error_zq_no:"+logid+",上下文的数目不能大于18");return emitter;
            }
        }catch (Exception ex){context_num=contextNumber;}
        List<com.hoppinzq.bean.ChatMessage> chatMessageList=chatGptService.getChatMessageByChatId(chatId);
        //设置系统提示词、prompt
        if(!"".equals(system)){
            ChatMessage systemMessage = new ChatMessage("system", system);
            messages.add(systemMessage);
        }
        //设置上下文
        for(int i=0;i<chatMessageList.size();i++){
            if(chatMessageList.size()-i>=context_num)
                continue;
            com.hoppinzq.bean.ChatMessage chatMessage=chatMessageList.get(i);
            ChatMessage chatMessage1 = new ChatMessage(chatMessage.getMessage_role(), chatMessage.getMessage());
            messages.add(chatMessage1);
        }
    }
    try{
        ChatMessage systemMessage = new ChatMessage(ChatMessageRole.USER.value(), message);
        messages.add(systemMessage);
        OpenAiService service=new OpenAiService(token,Duration.ofSeconds(60));
        ChatCompletionRequest chatCompletionRequest = ChatCompletionRequest.builder().model(model).messages(messages).build();
        service.streamChatCompletion(chatCompletionRequest)
                .doOnError(msg->{
                    logger.error("sse服务错误");
                    service.shutdownExecutor();
                }).subscribeOn(Schedulers.io()).observeOn(Schedulers.computation())
                .doOnCancel(() -> {
                    logger.info("停止对话");
                    service.shutdownExecutor();
                }).subscribe(msg -> {
                    emitter.send(SseEmitter.event().name("message").data(msg));
                }, err -> {
                    logger.error("sse服务错误，"+err);
                    emitter.completeWithError(err);
                }, () -> {
                    logger.debug("完成");
                    emitter.complete();
                });
    }catch (Exception ex){
        logger.error("logid，"+logid+"，错误信息:"+ex.getMessage());
        emitter.send("500sse_error_zq:"+logid);
    }
    return emitter;
}

https-api

2022年末签发了我的SSL证书，我可以用https和搭建CDN啦。由于之前用的都是http协议，所以很多接口都是基于http的，然后我现在有CDN，就把所有静态资源包括前端页面都放在了CDN里，所以这之后的项目全部都是前后端分离的。CDN带来的页面响应速度和静态资源加载速度的提升是很明显的，之前我的博客页面是前后端不分离的，静态资源都是Jetty和Tomcat加载的，首页进去得加载5s左右。上CDN后，除第一次加载慢，后面是秒开。
言归正传，由于前端是https下的，自然之前的http接口就不能用了。就做了这个代理转发服务，用来使用https代理之前的http接口，这就是这个项目的初衷。
由于我之前做了一个短视频网站，用来分享我自己的录屏高光操作，现在我想把它做成前后端分离的，我就把视频的代码迁到了这个服务下。后面突然想做一个直播的功能，就把代码都写在这里了，也集成了OBS，原理你可以在我的视频网站找到。
后面我用这个项目申请了一个软著，也没开源，没开源的原因是这个本来就不是直播项目，是做https代理http的。视频项目在gitee上有，只不过直播管理功能做到这里面了！
全文检索（视频搜素）代码：展开代码

                                                
@ApiMapping(value = "getVideo", title = "获取视频列表", description = "视频列表根据查询条件查询")
public List<Map> getVideo(VideoEntity entity) throws ParseException, IOException {
    if(entity.getVideo_name()!=null&&!"".equals(entity.getVideo_name())){
        int pageIndex = entity.getVideo_page_num();
        int pageSize=entity.getVideo_page_size();
        Integer start =0;Integer end = 0;
        if(pageIndex!=0){
            start = pageIndex;
            end = pageIndex + pageSize;
        }
        Analyzer analyzer = new IKAnalyzer();
        BooleanQuery.Builder query = new BooleanQuery.Builder();
        //用户搜索历史
//            JSONObject user= (JSONObject) LoginUser.getUserHold();
//            blogService.insertSearchKey(blogVo.getSearch(),user);
        String[] fields = {"video_name","user_name", "video_miaoshu", "video_fenlei_name"};
        //设置影响排序的权重, 这里设置域的权重
        Map<String, Float> boots = new HashMap<>();
        boots.put("video_name", 1000000f);
        boots.put("user_name", 100000f);
        boots.put("video_miaoshu", 10000f);
        boots.put("video_fenlei_name", 50000f);
        //从多个域查询对象
        //query1 = queryParser.parse("*:*");
        MultiFieldQueryParser multiFieldQueryParser = new MultiFieldQueryParser(fields, analyzer, boots);
        Query querySearch = multiFieldQueryParser.parse(entity.getVideo_name());
        query.add(querySearch, BooleanClause.Occur.MUST);
        String os = System.getProperty("os.name").toLowerCase();
        String indexPath="";
        if(os.contains("windows")) {
            indexPath="D:/index/video";
        }else{
            indexPath="/home/index/video";
        }
        Directory dir = FSDirectory.open(Paths.get(indexPath));
        IndexReader indexReader = DirectoryReader.open(dir);
        IndexSearcher indexSearcher = new IndexSearcher(indexReader);
        TopDocs topDocs = indexSearcher.search(query.build(),end);
        ScoreDoc[] scoreDocs = topDocs.scoreDocs;
        List<Map> videos=new ArrayList<>();
        if (scoreDocs != null) {
            for (int i = start; i < end; i ++) {
                if(start>topDocs.totalHits||topDocs.totalHits==i){
                    break;
                }
                //获取查询到的文档唯一标识, 文档id, 这个id是lucene在创建文档的时候自动分配的
                int docID = scoreDocs[i].doc;
                Document doc = indexReader.document(docID);
                Map video=new HashMap();
                //... 这里省略设值
                videos.add(video);
            }
        }
        indexReader.close();
        return videos;
    }else{
        int n=entity.getVideo_page_num();
        if(n>0){
            entity.setVideo_page_num(n-1);
        }
        return videoDao.getVideo(entity);
    }
}

短视频网站

hoppinzq-gateway网关

你发誓你在22年见过我的网关，但是现在它更强大了。你在访问我的chatgpt年度总结的时候看到一份报告，内容是关于请求数、请求地域、响应状态码等的统计，让你来设计这个需求，你会怎么实现呢？答案就是通过网关，那么经过一年的迭代，23年的hoppinzq-gateway网关已经可以完美融合nginx了。这不是骇人听闻，因为nginx本身支持用Java进行拓展，我将在之后写一篇博客来介绍这项功能。
不知道你们是如何部署nginx的呢？作为程序员，我不建议你去安装（或用docker安装）现成的nginx软件，我建议你通过编译源代码的方式去部署。因为这样我们就可以修改源代码啦，这很酷，但你通常不会有这样的需求。
话又说回来了，hoppinzq-gateway网关是如何完成上面工作的？实际上我说一个简单的案例你就知道了：如何统计请求的IP地址？这个问题的答案很简单，但做起来不容易。以前的做法是：nginx获取请求头的IP设置到自定义请求头（如：x-nginx-ip），然后网关先去判断请求头有无携带x-nginx-ip，有的话就保存起来，无的话就直接获取请求头的IP，然后就可以再次透传这个IP到各个业务模块去了。
现在的做法就很简单了，我可以直接在nginx层面上写一个拦截器，在nginx配置让其生效。我直接在拦截器就能拿到请求头里的IP，然后写到日志里就行了。下课！这个做法就很简单，nginx提供了拓展它的Java类库nginx-clojure，然后实现NginxJavaRingHandler接口重写方法即可。
值得注意的是，这样做有点危险，因为nginx是所有请求的入口（包括静态资源），在这个层面记录日志可能会有性能上的影响。
最后，因为有CDN层，所以在nginx统计的数据就不可靠了，但是思想最重要，思想。
下面简单重写nginx的用户认证过程，了解一下？展开代码


public class BasicAuthHandler implements NginxJavaRingHandler {
    @Override
    public Object[] invoke(Map<String, Object> request) {
        // 从header中获取authorization字段
        String auth = (String) ((Map)request.get(HEADERS)).get("authorization");
        // 如果header中没有authorization，就返回401错误，并带上body
        if (auth == null) {
            return new Object[] { 401, ArrayMap.create("www-authenticate", "Basic realm=\"Secure Area\""),
                    "<html><body><h1>401 没有权限。</h1></body></html>" };
        }
        // authorization应该是 : Basic zhang:qi!
        String[] up = auth.substring("Basic ".length()).split(":");
        // 只是为了演示，所以账号和密码的检查逻辑在代码中是写死的，
        // 如果账号等于"zhang"，并且密码等于"qi!"，就返回PHASE_DONE，这样nginx-clojure就会继续执行后面的content handler
        if ("zhang".equals(up[0]) && "qi!".equals(up[1])) {
            return PHASE_DONE;
        }
        // 如果账号密码校验不过，就返回401，body内容是提示账号密码不过
        return new Object[] { 401, ArrayMap.create("www-authenticate", "Basic realm=\"Secure Area\""),
                "<html><body><h1>401 用户名密码不正确。</h1></body></html>" };
    }
}

Java服务管理系统

从我的剑来框架那个开源项目复制进来的，想独立作为一个开源项目，在线访问https://hoppinzq.com/manager/index.html

3 13 18

打开开源地址

这是一个没有readme的项目，如你所见，我现在有很多后台服务，每次部署服务都很费事，这导致了我产生一个独特的能力：我都可以闭着眼部署它们了(笑。
这个项目是3月份完成的，我经过chatGPT的指导，完成了这个牛逼的项目，我先说说它能干啥：首先管理Linux的文件系统，刷新CDN缓存，可以用来部署jar包，实时打印日志和堆栈信息。一键开启或者停用服务，一键配置jmx监控或者远程调试，一键gc。还有类似宝塔的功能，可以一键开启nginx，redis等服务，而无需进入Linux终端。
牛逼，这是怎么实现的？chatGPT说：jsch。它提供了Java操作ssh的全部api，你只需对Linux指令有足够的了解，就能实现上面的功能。
然而不幸的是，虽然这个项目的功能很强大，但是部署上去我就很少使用了。在线访问：点我跳转
部署Jar包核心代码：展开代码

                                                
@ApiMapping(value = "jarfile", title = "jar包上传", description = "上传jar包并生成文件",type = ApiMapping.Type.POST)
public void jarFile(MultipartFile file, String projectName, String ms,String version,int port ,String userno,Boolean isJMX,Boolean isDebugger) throws Exception {
    //检查端口号情况
    checkPort(port);
    SSHBean sshBean= new SSHBean();
    sshBean.sshRemoteLogin();
    Session sshSession=sshBean.getSession();
    SSHCache.sshMap.put(UUIDUtil.getUUID(),sshBean);
    ChannelSftp channelSftp = (ChannelSftp) sshSession.openChannel("sftp");
    // 远程连接
    channelSftp.connect();
    //判断是否有文件夹
    String remoteDirPath = "/home/hoppinzq/";
    Vector<ChannelSftp.LsEntry> lsEntries = channelSftp.ls(remoteDirPath);
    boolean folderExists = false;
    for (ChannelSftp.LsEntry entry : lsEntries) {
        if (entry.getFilename().equals(projectName)) {
            folderExists = true;
            break;
        }
    }
    if (folderExists) {
        //文件夹存在，不进行任何操作
    } else {
        //文件夹不存在，新建文件夹
        channelSftp.mkdir(remoteDirPath+projectName);
    }
    String jarName=file.getOriginalFilename();
    String jarFileName=jarName.substring(0,jarName.lastIndexOf(".jar"));
    String dst = remoteDirPath+projectName+"/"+jarName; // 目标文件名
    InputStream inputStream = file.getInputStream();
    long fileSize = file.getSize();
    webSocketProcess.setMark("file_upload");
    //jar包存储
    channelSftp.put(inputStream, dst, new FileProgressMonitor(fileSize,webSocketProcess,userno));
    //sh文件生成
    String shName = remoteDirPath+projectName+"/"+"deploy_"+jarFileName+".sh";
    int jmxPort=0;String jmxsh="";int debuggerPort=0;String debuggersh="";
    if(isJMX){
        jmxPort=port+12311;
        jmxsh=" -Djava.rmi.server.hostname=hoppin.cn -Dcom.sun.management.jmxremote.port="+jmxPort+" -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false ";
    }
    if(isDebugger){
        debuggerPort=port+12312;
        debuggersh=" -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address="+debuggerPort+" ";
    }
    String shContent = "SERVER_NAME="+jarName+" #服务jar包名称\n" +
            "pid=$(ps -ef|grep $SERVER_NAME|grep -v grep|awk '{print $2}');\n" +
            "if [  -n  \"$pid\"  ];  then\n" +
            "  kill  -9  $pid;\n" +
            "fi\n" +
            "nohup java -jar "+jmxsh+"  -Dspring.profiles.active=dev "+debuggersh+" $SERVER_NAME  >  rezhi.log &\n" +
            " \n";
    channelSftp.put(new ByteArrayInputStream(shContent.getBytes()), shName);
    JarServiceBean jarServiceBean = new JarServiceBean();
    //...这里我省略了set方法
    jarServiceMapper.insert(jarServiceBean);
    redisUtils.del("manager:all_jar");
    channelSftp.exit();
    channelSftp.quit();
}

hoppin推荐系统

这是5月份的产物，我是聪明逼。感谢openAI提供的embedding接口。
说实话我说原理你们可能也不太懂，看我这个博客，反正就是牛逼，这套系统除了没有相关度排序外，基本可以完美而准确的按照预期推荐。你们可以看看我的视频网站和博客网站，有人可能看到视频网站的推荐内容了，有人感觉推荐的很慢。这是我的错，因为推荐过程实际上是向量之间的余弦相似度计算，属于CPU密集型任务。而视频网站推荐接口运行在单核的服务器上，理论上只能跑一个线程，我还傻傻地用线程池一顿优化，我是傻逼。
视频推荐相关代码（省略了若干方法）：展开代码

                                            
//余弦相似度算法
private static double cosineSimilarity(double[] vector1, double[] vector2) {
    RealVector realVector1 = new ArrayRealVector(vector1);
    RealVector realVector2 = new ArrayRealVector(vector2);
    double dotProduct = realVector1.dotProduct(realVector2);
    double norm = realVector1.getNorm() * realVector2.getNorm();
    double similarity = dotProduct / norm;
    return similarity;
}
@ApiMapping(value = "getVideoSimilar", title = "获取推荐视频", description = "获取推荐视频")
public List getVideoSimilar(String video_name){
    boolean exists = redisUtils.hasKey("video:embeddings");
    if(!exists){
        List<Map> video_similar1=serviceAsync.queryVideoBytypeAndNumber(1,7,null,video_name.substring(0,video_name.length()-1));
        if(video_similar1.size()<7){
            List<Map> video_similar2=serviceAsync.queryVideoBytypeAndNumber(1,7,null,video_name.substring(0,1));
            List<Map> video_similar3=diff(video_similar2,video_similar1);
            video_similar1.addAll(video_similar3);
            if(video_similar1.size()<7){
                List<Map> video_similar4=serviceAsync.queryVideoBytypeAndNumber(1,7,null,"");
                List<Map> video_similar5=diff(video_similar4,video_similar1);
                video_similar1.addAll(video_similar5);
            }
        }
        return video_similar1;
    }

    double[] embedding=null;
    String redisVideoNameKey="video:videoname:"+ EncryptUtil.MD5(video_name);
    if(redisUtils.hasKey(redisVideoNameKey)){
        String embeddingStr=redisUtils.getString(redisVideoNameKey);
        embeddingStr=embeddingStr.substring(1,embeddingStr.length()-1);
        String[] embeddingS=embeddingStr.split(",");
        embedding=new double[embeddingS.length];
        for(int j=0;j<embeddingS.length;j++){
            embedding[j]=Double.valueOf(embeddingS[j]);
        }
    }else{
        Embed embedVideo=Embedding.getEmbed(video_name);
        embedding=embedVideo.getData()[0].getEmbedding();
        redisUtils.set(redisVideoNameKey,embedding);
    }
    List<Object> videos=redisUtils.lGet("video:embeddings", 0, -1);
    List<JSONObject> videoSimilarity=new ArrayList<>();
    ThreadPoolManager.createThreadPool();
    List<List<Object>> videoss = Embedding.divideList(videos, 10);
    for(int i=0;i<videoss.size();i++){
        Callable callableR = new SimlarityVideoCall(videoss.get(i),embedding);
        Future<Object> future=ThreadPoolManager.submitTask(callableR);
        try{
            List<JSONObject> videoEmbeddings=(List<JSONObject>)future.get(10,TimeUnit.SECONDS);
            videoSimilarity.addAll(videoEmbeddings);
        }catch (TimeoutException e) {
            future.cancel(true);
            videoSimilarity.addAll(Collections.emptyList());
        } catch (Exception ex){
            videoSimilarity.addAll(Collections.emptyList());
        }
    }
    ThreadPoolManager.destroyThreadPool();
    Comparator<JSONObject> comparator = new Comparator<JSONObject>() {
        @Override
        public int compare(JSONObject o1, JSONObject o2) {
            try {
                double embedding1 = o1.getDouble("embedding");
                double embedding2 = o2.getDouble("embedding");
                if (embedding1 > embedding2) {
                    return -1;
                } else if (embedding1 < embedding2) {
                    return 1;
                } else {
                    return 0;
                }
            } catch (JSONException e) {
                e.printStackTrace();
                return 0;
            }
        }
    };
    Collections.sort(videoSimilarity, comparator);
    return videoSimilarity.subList(0,10);
}

（开发中）springhoppinzq

基于SpringBoot的微服务框架，你永远见不到这么牛逼的项目，它应该被用金框裱起来。
首先，这是对标的SpringCloud的微服务框架，拥有自己的框架、协议和中间件。这很牛逼，但是它的诞生是一个偶然。这个框架的起源是21年7月份的一个报错而产生的，这个报错就是EOFException，即End Of File Exception。这个报错非常的有趣，也是非常罕见的，程序在读取输入流的时候，由于结束标记位的混乱（如：在流里插入一个null或-1），导致程序读取到结束标记位的时候，不确定是否真的到达了输入流的末尾。这个时候，程序一旦读到结束标记位的字符，就会抛出这个异常。
我不确定你是否对它感兴趣，反正通过这个报错，我了解了序列化和反序列化，进而了解了RPC原理，进而编写了第一个垃圾的框架——剑来RPC框架。
看，从0到1就这么突破了，后面一发而不可收，陆陆续续完成了自己的网关中间件，统一权限认证平台，爬虫框架，以及第一个使用剑来框架编写的博客系统。
目前框架能按照预期工作，拓展接口非常之多。您目前访问我的所有网站，其后台全部都是基于剑来框架和网关搭建而成。
这套框架已有的功能，大家可以打开文档查看，目前有：注册中心，负载均衡，断路器，网关等中间件。
远程服务调用核心代码：展开代码

                                        
public static <T> T createProxy(Class<? extends T> serviceInterface, String serviceURI, Serializable credentials, Map headers, String serviceName) {
    Future<Object> f = serviceCache.get(serviceInterface.getName());
    if(f==null){
        logger.debug("创建"+serviceInterface.getName()+"服务的代理对象，服务地址是:"+serviceURI);
        Callable<Object> eval = new Callable<Object>() {
            @Override
            public Object call() {
                return Proxy.newProxyInstance(serviceInterface.getClassLoader(), new Class[]{serviceInterface}, new MethodInvocationHandler(serviceInterface, serviceURI, credentials, serviceName));
            }
        };
        FutureTask<Object> ft = new FutureTask(eval);
        f =ft;
        serviceCache.putIfAbsent(serviceInterface.getName(),ft);
        ft.run();
    }else{
        logger.debug("命中"+serviceInterface.getName()+"服务代理对象的缓存！，服务地址是:"+serviceURI);
    }
    try{
        return (T)f.get();
    }catch (Exception ex){
        serviceCache.remove(serviceInterface.getName());
        ex.printStackTrace();
    }
    return null;
}

@Override
public Object invoke(Object obj, Method method, Object[] args) throws Throwable {
    RPCBean rpcBean= RpcTemplate.getRpcBean();
    rpcBean.setProxy(obj);
    rpcBean.setMethod(method.getName());
    rpcBean.setArgs(args);
    Map requestHeader= RpcTemplate.getRequestRequest();
    if(method.isAnnotationPresent(HttpHeaders.class)|| method.isAnnotationPresent(HttpHeader.class)){
        HttpHeader[] httpHeaders = method.getAnnotationsByType(HttpHeader.class);
        for(HttpHeader httpHeader:httpHeaders){
            requestHeader.put(httpHeader.key(),httpHeader.value());
        }
    }
    HoppinInvocationRequest request=null;
    HoppinInvocationResponse response = null;
    TransportProvider currentProvider = transportProvider != null ? transportProvider : defaultTransportProvider;
    TransportSession session = currentProvider.createSession(this);
    //负载均衡模块，需要动态改变serviceURI
    currentProvider.loadBalance(this);
    rpcBean.setSession(session);
    rpcBean.setProvider(currentProvider);
    try {
        request = new HoppinInvocationRequest(method, args, getCredentials());
        rpcBean.setInvocationRequest(request);
        request.setHeaders(requestHeader);
        // 扫描标记接口HoppinInputStreamArgument，确定参数是否为输入流（即文件上传RPC接口）
        // 查找作为输入流的第一个参数，从参数数组中删除参数数据
        // 并准备在序列化调用请求后通过ConnectionOutputStream传输数据。
        InputStream streamArgument = null;
        if (args != null) {
            for (int i = 0; i < args.length; i++) {
                if (args[i] != null && InputStream.class.isAssignableFrom(args[i].getClass())) {
                    streamArgument = (InputStream) args[i];
                    args[i] = new HoppinInputStreamArgument();
                    break;
                }
            }
        }

        InputStream inputStream = session.sendInvocationRequest(method, request, streamArgument);
        if (!method.getReturnType().equals(Object.class) && method.getReturnType().isAssignableFrom(InputStream.class)) {
            return inputStream;
        }
        //  反序列化开始
        HessionSerializer hessionSerializer=new HessionSerializer();
        response=hessionSerializer.deserialize(inputStream,HoppinInvocationResponse.class);
        //  反序列化结束
        response.setHeaders(rpcBean.getHeaders());
        rpcBean.setInvocationResponse(response);
        if(method.isAnnotationPresent(ExceptionCatch.class) || method.isAnnotationPresent(ExceptionContainer.class)
                || method.isAnnotationPresent(ExceptionCatchRemote.class)){
            ExceptionCatchRemote exceptionCatchRemote=method.getAnnotation(ExceptionCatchRemote.class);
            ExceptionCatch[] exceptionCatches={};
            if(exceptionCatchRemote!=null){
                exceptionCatches=exceptionCatchRemote.annotationType().getAnnotationsByType(ExceptionCatch.class);
            }else{
                exceptionCatches = method.getAnnotationsByType(ExceptionCatch.class);
            }
            for(ExceptionCatch exceptionCatch:exceptionCatches){
                if(response.getStatus()==exceptionCatch.code() &&
                        exceptionCatch.value().getSimpleName().equals(response.getException().getClass().getSimpleName())){
                    if(response.getException() instanceof Exception){
                        exceptionCatch.handler().newInstance().handleException((Exception) response.getException());
                    }

                }
            }
        }
        RpcTemplate.setResponse(response);
        ModificationList[] modifications=response.getModifications();
        if (modifications != null) {
            for (int i = 0; i < modifications.length; i++){
                ModificationList mods = modifications[i];
                if (mods != null) {
                    for (Map.Entry<String, Object> entry : mods.getModifiedProperties().entrySet()) {
                        try {
                            setModifiedValue(entry.getKey(), entry.getValue(), args[i]);
                        } catch (Exception ignored) {
                        }
                    }
                }
            }
        }
    } catch (IOException e) {
        rpcBean.setException(e.getMessage());
        throw new RemotingException(e);
    } finally {
        currentProvider.endSession(session, this);
        RpcTemplate.remove();
    }

    if (response.getException() != null) {
        throw response.getException();
    }
    return response.getResult();
}

打开使用文档(旧)

（集成在springhoppinzq的）http声明式调用

你是如何模拟http请求的呢？是用现成的库如httpClient？还是用原生的网络传输？先不说我的答案，首先现有的库httpClient、okhttp3等都很强大，封装的也很全面。我的chatGPT代理服务就是基于okhttp3的。URL对象是偏底层的东西，是Web开发中最主流的资源定位方式。
我们通常在后台调用其他http接口，往往都是通过写一个工具类，来对httpClient或者URL对象进行封装。这没问题，往往我们都是把请求的url写死在一个字符串，然后调用工具类来模拟调用并处理响应。每一个url都要写一个调用的方法，因为不同的url要求调用的细节是不一样的，有的要求post请求，有的要求添加某些请求头。。。
那么，能不能将不同的调用细节统一抽象出来做一个配置呢？答案是可以的，你如果用过Feign，就知道Feign就是一种声明式的调用，这很优雅，且拓展性非常高，你可以先看看springhoppinzq的下面的代码：

    
public interface ExampleApi {
    @HttpHeaders({
        @HttpHeader(key = "x-zhang0",value = "qi0"),
        @HttpHeader(key = "x-zhang1",value = "qi1"),
        @HttpHeader(key = "x-zhang2",value = "qi2")
    })
    @HttpHeader(key = "x-zhang",value = "getToken")
    @HttpApi(url = "http://127.0.0.1:8801/service/hoppinzq?method=getGatewayMapping¶ms={}")
    @ResponseBody
    String getData();

    @ZQGatewayMethod("getGatewayMapping")
    @HttpApi(url = "http://127.0.0.1:8801/service/hoppinzq")
    String getData1(@ZQGatewayParam String param);

    @HttpHeader(key = "x-encode",value = "true")
    @HttpApi(url = "http://127.0.0.1:8801/service/hoppinzq?method=${param1}¶ms=${param2}&token=${param3}")
    String getData2(String param1,String param2,String param3,@HttpHeader(key = "token") String header);

    @UsingRequest
    @HttpApi(url = "http://127.0.0.1:8801/service/hoppinzq?method=id",method="post")
    String getId(@RequestBody String params);
}

我们不会在这里探讨任何细节和工作原理，因为时间是宝贵的，字数是有限的。它被集成在springhoppinzq，并为zq网关开发了特定的注解，已适配它独特的请求体。你看源代码的时候可能会有很多困惑，感兴趣可以微信：HOPPIN_HAZZ

（开发中）hoppinAI

这是一个令人振奋的项目，每个人都可以有的小ai。hoppin出品，必属精品。目前已经完全地迈出了第一步——切分词服务的实现和数据结构的设计。我很乐意分享我的想法和其中的工作原理，但你有没有一双乐意倾听的耳朵呢？
啊哈哈哈没有掉一根头发。
切词核心算法：展开代码


public List<String> cut(String text) {
    Map<Character, Map> tree_temp = this.dictTree;
    int ln = text.length();
    int index1 = ln;int index2 = 0;int index3 = ln;
    Boolean isExist = false;
    List<String> recognised = new ArrayList();
    Integer[] mem = null;
    Integer[] mem2 = null;
    while(true) {
        while(true) {
            while(index1 - index2 > 0) {
                Character t = Character.toLowerCase(text.charAt(index1 - 1 - index2));
                List unreg_tmp;
                if (!tree_temp.containsKey(t)) {
                    if (mem == null && mem2 == null) {
                        index2 = 0;
                        --index1;
                        tree_temp = this.dictTree;
                    } else {
                        if (mem != null) {
                            index1 = mem[0];index2 = mem[1];index3 = mem[2];
                            mem = null;
                        } else if (mem2 != null) {
                            int delta = mem2[0] - index1;
                            if (delta >= 1) {
                                if (delta < 5 && Pattern.matches("[\\w\\u2E80-\\u9FFF]", t.toString())) {
                                    Character pre = text.charAt(index1 - index2);
                                    if (!this.stopWords.contains(pre)) {
                                        index1 = mem2[0];index2 = mem2[1];index3 = mem2[2];
                                        int q1 = mem2[3];
                                        while(recognised.size() > q1) {
                                            recognised.remove(recognised.size() - 1);
                                        }
                                    }
                                }
                                mem2 = null;
                            }
                        }
                        tree_temp = this.dictTree;
                        if (index1 < ln && index1 < index3) {
                            unreg_tmp = this._pro_unreg(text.substring(index1, index3));
                            recognised.addAll(unreg_tmp);
                        }
                        recognised.add(text.substring(index1 - index2, index1));
                        index1 -= index2;index3 = index1;index2 = 0;
                    }
                } else {
                    tree_temp = (Map)tree_temp.get(t);
                    ++index2;
                    if (tree_temp.containsKey('\u000b')) {
                        if (index2 <= 2) {
                            mem = new Integer[]{index1, index2, index3};
                            Character xsuffix = text.charAt(index1 - 1);
                            if (index3 - index1 < 2 && this.stopWords.contains(xsuffix) && (mem2 == null || mem2 != null && mem2[0] - i > 1)) {
                                mem = null;
                                mem2 = new Integer[]{index1, index2, index3, recognised.size()};
                                tree_temp = this.dictTree;
                                --index1;
                                index2 = 0;
                            }
                        } else {
                            tree_temp = this.dictTree;
                            if (index1 < ln && index1 < index3) {
                                unreg_tmp = this._pro_unreg(text.substring(index1, index3));
                                recognised.addAll(unreg_tmp);
                            }
                            recognised.add(text.substring(index1 - index2, index1));
                            index1 -= index2;index3 = index1;index2 = 0;
                            mem = null;mem2 = null;
                        }
                    }
                }
            }
            if (mem != null) {
                index1 = mem[0];index2 = mem[1];index3 = mem[2];
                recognised.addAll(this._pro_unreg(text.substring(index1, index3)));
                recognised.add(text.substring(index1 - index2, index1));
            } else {
                recognised.addAll(this._pro_unreg(text.substring(index1 - index2, index3)));
            }
            return recognised.stream().filter(key -> !this.stopWords.contains(key.length()>0?key.charAt(0):key)).collect(Collectors.toList());
        }
    }
}

或许你应该从组装一棵字典树开始？
组装字典树部分核心代码：展开代码


private Map<Character, Map> dictTree = new TreeMap(); //字典树
private Set<Character> stopWords = new HashSet(); //停用词
private Set<Character> extraWords = new HashSet(); //拓展词
public void set(List<String> words) {
    Map<Character, Map> dictTree_temp = this.dictTree;
    Map<Character, Map> q = null;
    Character c = null;
    Iterator it = words.iterator();
    while(it.hasNext()) {
        String word = (String)it.next();
        word = '\u000b' + word;
        dictTree_temp = this.dictTree;
        for(int i = word.length() - 1; i >= 0; --i) {
            Character cc = Character.toLowerCase(word.charAt(i));
            if (dictTree_temp == null) {
                q.put(c, new TreeMap());
                dictTree_temp = (Map)c.get(c);
            }
            if (!p.containsKey(cc)) {
                dictTree_temp.put(cc,null);
                q = dictTree_temp;
                c = cc;
            }
            dictTree_temp = (Map)dictTree_temp.get(cc);
        }
    }
}

看不懂？别着急，因为这算是断章取义，我并不指望你能看懂。毕竟这并不是一个分享代码的好地方，这只是用来告诉我：我做了，而且我是一个行动派。

gitee指数，今年不统计，因为chatgpt那个项目太火了，数据波动太大。

游戏

应用了高清渲染管线HDRP的demo，效果拔群！

这是一个伟大的飞跃，因为这个画质已经可以够看了。这是一个箱庭式地图，将是我们魂游的开始。展开代码


private void FixedUpdate()
{
    switch (CurrentState)
    {
        case CharacterState.Normal:
            if (IsPlayer){
                //玩家
                if (_playerInput.MouseButtonDown && _cc.isGrounded)
                {
                    SwitchStateTo(CharacterState.Attacking);
                    return;
                }
                else if (_playerInput.SpaceKeyDown && _cc.isGrounded)
                {
                    SwitchStateTo(CharacterState.Slide);
                    return;
                }
                _movementVelocity.Set(_playerInput.HorizontalInput, 0f, _playerInput.verticalInput);
                _movementVelocity.Normalize();
                _movementVelocity = Quaternion.Euler(0, -45f, 0) * _movementVelocity;
                _animator.SetFloat("Speed", _movementVelocity.magnitude);
                _movementVelocity *= MoveSpeed * Time.deltaTime;
                if (_movementVelocity != Vector3.zero)
                    transform.rotation = Quaternion.LookRotation(_movementVelocity);
                _animator.SetBool("AirBorne", !_cc.isGrounded);
            }
            else
            {
                //敌人行为
                if (Vector3.Distance(TargetPlayer.position, transform.position) >= _navMeshAgent.stoppingDistance)
                {
                    _navMeshAgent.SetDestination(TargetPlayer.position);
                    _animator.SetFloat("Speed", 0.2f);
                }
                else
                {
                    _navMeshAgent.SetDestination(transform.position);
                    _animator.SetFloat("Speed", 0f);
                    SwitchStateTo(CharacterState.Attacking);
                }
            break;
        case CharacterState.Attacking:
            if (IsPlayer)
            {
                if (Time.time < attackStartTime + AttackSlideDuration)
                {
                    float timePassed = Time.time - attackStartTime;
                    float lerpTime = timePassed / AttackSlideDuration;
                    _movementVelocity = Vector3.Lerp(transform.forward * AttackSlideSpeed, Vector3.zero, lerpTime);
                }
                if (_playerInput.MouseButtonDown && _cc.isGrounded)
                {
                    string currentClipName = _animator.GetCurrentAnimatorClipInfo(0)[0].clip.name;
                    attackAnimationDuration = _animator.GetCurrentAnimatorStateInfo(0).normalizedTime;
                    if (currentClipName != "LittleAdventurerAndie_ATTACK_03" && attackAnimationDuration > 0.5f && attackAnimationDuration < 0.7f)
                    {
                        _playerInput.MouseButtonDown = false;
                        SwitchStateTo(CharacterState.Attacking);
                    }
                }
            }
            break;

        case CharacterState.Dead:
            return;

        case CharacterState.BeingHit:
            break;

        case CharacterState.Slide:
            _movementVelocity = transform.forward * SlideSpeed * Time.deltaTime;
            break;

        case CharacterState.Spawn:
            currentSpawnTime -= Time.deltaTime;
            if (currentSpawnTime <= 0)
            {
                SwitchStateTo(CharacterState.Normal);
            }
            break;
    }
    if (impactOnCharacter.magnitude > 0.2f)
    {
        _movementVelocity = impactOnCharacter * Time.deltaTime;
    }
    impactOnCharacter = Vector3.Lerp(impactOnCharacter, Vector3.zero, Time.deltaTime * 5);

    if (IsPlayer)
    {
        if (_cc.isGrounded == false)
            _verticalVelocity = Gravity;
        else
            _verticalVelocity = Gravity * 0.3f;

        _movementVelocity += _verticalVelocity * Vector3.up * Time.deltaTime;

        _cc.Move(_movementVelocity);
        _movementVelocity = Vector3.zero;
    }
    else
    {
        if (CurrentState != CharacterState.Normal)
        {
            _cc.Move(_movementVelocity);
            _movementVelocity = Vector3.zero;
        }
    }
}

返回上一页

展望未来展望未来

100%

HoppinZQ HoppinZQ

你想搜索什么？

我猜你想搜索张祺是谁？

蜘蛛页面在哪？

开源项目

最伟大的架构=1%的想法+99%的代码。Talk is cheap，show me the code。

2023开源项目

chatgpt-java（+前端项目）

https-api

hoppinzq-gateway网关

Java服务管理系统

hoppin推荐系统

（开发中）springhoppinzq

（集成在springhoppinzq的）http声明式调用

（开发中）hoppinAI

看不懂？别着急，因为这算是断章取义，我并不指望你能看懂。毕竟这并不是一个分享代码的好地方，这只是用来告诉我：我做了，而且我是一个行动派。

应用了高清渲染管线HDRP的demo，效果拔群！

展望未来展望未来

HoppinZQ HoppinZQ

你想搜索什么？

我猜你想搜索张祺是谁？

蜘蛛页面在哪？

chatgpt-java（+前端项目）

https-api

hoppinzq-gateway网关

Java服务管理系统

hoppin推荐系统

（开发中）springhoppinzq

（集成在springhoppinzq的）http声明式调用

（开发中）hoppinAI

看不懂？别着急，因为这算是断章取义，我并不指望你能看懂。 毕竟这并不是一个分享代码的好地方，这只是用来告诉我：我做了，而且我是一个行动派。

应用了高清渲染管线HDRP的demo，效果拔群！

展望未来 展望未来

看不懂？别着急，因为这算是断章取义，我并不指望你能看懂。毕竟这并不是一个分享代码的好地方，这只是用来告诉我：我做了，而且我是一个行动派。

展望未来展望未来