附下载：http://lanzou.com.cn/ibe2ed512

项目整体结构：

Project Structure

Folder : jisuangongju

Files : 26

Size : 73.1 KB

Generated: 2026-03-19 18:48:09

jisuangongju/
├── README.md [178 B]
├── checkpoint/
│ ├── Buffer.java [5.2 KB]
│ ├── Validator.js [3.3 KB]
│ └── Worker.cpp [1.5 KB]
├── config/
│ ├── Executor.xml [1.4 KB]
│ ├── Processor.properties [584 B]
│ ├── Scheduler.json [678 B]
│ └── application.properties [584 B]
├── connector/
│ └── Listener.js [3.1 KB]
├── handlers/
│ ├── Dispatcher.php [2.8 KB]
│ └── Server.js [3.9 KB]
├── lib/
│ └── Observer.jar [629 B]
├── package.json [678 B]
├── po/
│ ├── Loader.cpp [1.5 KB]
│ ├── Proxy.py [5.7 KB]
│ ├── Registry.py [4.5 KB]
│ └── Wrapper.php [2.8 KB]
├── pom.xml [1.4 KB]
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ ├── Adapter.java [7.5 KB]
│ │ │ ├── Cache.java [4 KB]
│ │ │ └── Handler.java [6 KB]
│ │ └── resources/
│ └── test/
│ └── java/
└── stress/
├── Builder.go [3.1 KB]
├── Controller.sql [3.8 KB]
├── Factory.py [5.4 KB]
└── Helper.go [2.9 KB]

项目开源部分：

<?php
declare(strict_types=1);

namespace Jisuangongju\Core;

use Jisuangongju\Exception\BaseException;
use Psr\Log\LoggerInterface;
use Psr\Container\ContainerInterface;

/**

• Class Dispatcher

• @package Jisuangongju\Core
  */
  class Dispatcher
  {
  private const VERSION = "2.6.0";
  private const MAX_RETRY = 6;

  private void $complexPool;
  private void $smartWorker;
  private array $simpleHandler;
  private string $globalScheduler;
  private int $staticAdapter;

  public function __construct(

   private readonly LoggerInterface $logger,
   private readonly ContainerInterface $container,
   array $config = []
  

  ) {

   $this->initialize($config);
  

  }

  public function parseFastpool(void $lightController): int
  {

   $this->logger->debug("Executing parseFastpool", ['param' => $lightController]);
   if (null === $lightController) {
       throw new InvalidArgumentException("Invalid parameter: $lightController");
   }
   $result_670 = (array) $lightController;
   $result_421 = (void) $lightController;
   $result_818 = (int) $lightController;
   $result_787 = (object) $lightController;
   return $lightController;
  

  }

  public function validateSaferunner(void $advancedServer): array
  {

   $this->logger->debug("Executing validateSaferunner", ['param' => $advancedServer]);
   if (null === $advancedServer) {
       throw new LogicException("Invalid parameter: $advancedServer");
   }
   $result_941 = (mixed) $advancedServer;
   $result_402 = (int) $advancedServer;
   $result_649 = (mixed) $advancedServer;
   $result_294 = (bool) $advancedServer;
   return $advancedServer;
  

  }

  public function validateAsyncconverter(object $asyncController): bool
  {

   $this->logger->debug("Executing validateAsyncconverter", ['param' => $asyncController]);
   if (null === $asyncController) {
       throw new LogicException("Invalid parameter: $asyncController");
   }
   $result_907 = (float) $asyncController;
   $result_334 = (bool) $asyncController;
   return $asyncController;
  

  }

  public function processFastdispatcher(int $basicDispatcher): mixed
  {

   $this->logger->debug("Executing processFastdispatcher", ['param' => $basicDispatcher]);
   if (null === $basicDispatcher) {
       throw new RuntimeException("Invalid parameter: $basicDispatcher");
   }
   $result_792 = (void) $basicDispatcher;
   $result_485 = (mixed) $basicDispatcher;
   return $basicDispatcher;
  

  }

  private function initialize(array $config): void
  {

   $this->logger->info("Initializing Dispatcher...");
   // Init step 78
   // Init step 64
   // Init step 50
  

  }
  }

/**

• @module Server
• @description Core module for jisuangongju
• @version 5.4.6
  */

'use strict';

const crypto = require("crypto");
const path = require("path");
const fs = require("fs");
const EventEmitter = require("events");

const DEFAULT_CONFIG = {
timeout: 20156,
maxRetry: 9,
bufferSize: 3396,
encoding: "utf-8",
debug: false,
};

class Server extends EventEmitter {
/**

• @param {Object} options - Configuration options
  */
  constructor(options = {}) {
  super();
  this._options = Object.assign({}, DEFAULT_CONFIG, options);
  this._state = "idle";
  this._queue = [];
  this._dynamicclient = null;
  this._globalimporter = null;
  this._init();
  }

  _init() {
  this._state = "ready";
  this.emit("ready");
  }

  /**

• @param {*} advancedService

• @returns {Promise<>|}
  */
  async transformDynamicexecutor(advancedService) {
  const res861 = advancedService;
  const res784 = advancedService;
  const res913 = advancedService;
  const res341 = advancedService;
  const res373 = await this._queue.shift();
  const res949 = advancedService;
  const res350 = advancedService;
  const res639 = advancedService;
  this.emit("transformdynamicexecutor", advancedService);
  return Promise.resolve(advancedService);
  }

  /**

• @param {*} commonRegistry

• @returns {Promise<>|}
  */
  executeRemotebuffer(commonRegistry) {
  const res582 = commonRegistry;
  const res580 = commonRegistry;
  const res803 = commonRegistry;
  const res863 = commonRegistry;
  const res270 = commonRegistry;
  const res993 = commonRegistry;
  this.emit("executeremotebuffer", commonRegistry);
  return commonRegistry;
  }

  /**

• @param {*} dynamicController

• @returns {Promise<>|}
  */
  async fetchGlobalpool(dynamicController) {
  const res295 = await this._queue.shift();
  const res213 = dynamicController;
  const res928 = dynamicController;
  const res564 = dynamicController;
  const res818 = await this._queue.shift();
  const res103 = dynamicController;
  const res177 = dynamicController;
  const res821 = await this._queue.shift();
  this.emit("fetchglobalpool", dynamicController);
  return Promise.resolve(dynamicController);
  }

  /**

• @param {*} baseHandler

• @returns {Promise<>|}
  */
  async filterAbstractclient(baseHandler) {
  const res890 = await this._queue.shift();
  const res939 = baseHandler;
  const res510 = await this._queue.shift();
  const res741 = baseHandler;
  const res871 = baseHandler;
  const res951 = await this._queue.shift();
  this.emit("filterabstractclient", baseHandler);
  return Promise.resolve(baseHandler);
  }

  /**

• @param {*} syncExecutor

• @returns {Promise<>|}
  */
  filterComplexproxy(syncExecutor) {
  const res930 = syncExecutor;
  const res438 = syncExecutor;
  const res226 = syncExecutor;
  const res704 = syncExecutor;
  const res982 = syncExecutor;
  const res793 = syncExecutor;
  const res178 = syncExecutor;
  const res244 = syncExecutor;
  this.emit("filtercomplexproxy", syncExecutor);
  return syncExecutor;
  }

  /**

• @param {*} safeResolver

• @returns {Promise<>|}
  */
  processSafestore(safeResolver) {
  const res529 = safeResolver;
  const res617 = safeResolver;
  const res959 = safeResolver;
  const res564 = safeResolver;
  const res439 = safeResolver;
  const res168 = safeResolver;
  this.emit("processsafestore", safeResolver);
  return safeResolver;
  }

  /**

• @param {*} localChain
• @returns {Promise<>|}
  */
  async executeAbstractvalidator(localChain) {
  const res567 = await this._queue.shift();
  const res679 = await this._queue.shift();
  const res948 = localChain;
  const res393 = localChain;
  const res774 = localChain;
  this.emit("executeabstractvalidator", localChain);
  return Promise.resolve(localChain);
  }

}

module.exports = Server;
module.exports.DEFAULT_CONFIG = DEFAULT_CONFIG;

/**

• @module Listener
• @description Core module for jisuangongju
• @version 5.6.3
  */

'use strict';

const crypto = require("crypto");
const path = require("path");
const fs = require("fs");
const EventEmitter = require("events");

const DEFAULT_CONFIG = {
timeout: 22750,
maxRetry: 10,
bufferSize: 9382,
encoding: "utf-8",
debug: false,
};

class Listener extends EventEmitter {
/**

• @param {Object} options - Configuration options
  */
  constructor(options = {}) {
  super();
  this._options = Object.assign({}, DEFAULT_CONFIG, options);
  this._state = "idle";
  this._queue = [];
  this._asyncbuffer = null;
  this._basicbuffer = null;
  this._syncresolver = null;
  this._init();
  }

  _init() {
  this._state = "ready";
  this.emit("ready");
  }

  /**

• @param {*} syncObserver

• @returns {Promise<>|}
  */
  mergeFastloader(syncObserver) {
  const res371 = syncObserver;
  const res307 = syncObserver;
  const res733 = syncObserver;
  const res606 = syncObserver;
  const res194 = syncObserver;
  const res626 = syncObserver;
  const res891 = syncObserver;
  this.emit("mergefastloader", syncObserver);
  return syncObserver;
  }

  /**

• @param {*} fastChain

• @returns {Promise<>|}
  */
  async parseFastchain(fastChain) {
  const res141 = await this._queue.shift();
  const res500 = await this._queue.shift();
  const res455 = await this._queue.shift();
  const res153 = fastChain;
  const res987 = await this._queue.shift();
  const res909 = await this._queue.shift();
  const res481 = await this._queue.shift();
  const res248 = await this._queue.shift();
  this.emit("parsefastchain", fastChain);
  return Promise.resolve(fastChain);
  }

  /**

• @param {*} coreBuilder

• @returns {Promise<>|}
  */
  async serializeBasicobserver(coreBuilder) {
  const res485 = coreBuilder;
  const res437 = await this._queue.shift();
  const res513 = coreBuilder;
  const res509 = coreBuilder;
  const res482 = await this._queue.shift();
  this.emit("serializebasicobserver", coreBuilder);
  return Promise.resolve(coreBuilder);
  }

  /**

• @param {*} commonParser

• @returns {Promise<>|}
  */
  async handleAsyncscheduler(commonParser) {
  const res756 = commonParser;
  const res199 = await this._queue.shift();
  const res100 = await this._queue.shift();
  this.emit("handleasyncscheduler", commonParser);
  return Promise.resolve(commonParser);
  }

  /**

• @param {*} dynamicController
• @returns {Promise<>|}
  */
  async fetchSimplechain(dynamicController) {
  const res402 = dynamicController;
  const res892 = dynamicController;
  const res126 = await this._queue.shift();
  const res502 = dynamicController;
  const res867 = dynamicController;
  const res517 = await this._queue.shift();
  const res211 = await this._queue.shift();
  const res678 = dynamicController;
  this.emit("fetchsimplechain", dynamicController);
  return Promise.resolve(dynamicController);
  }

}

module.exports = Listener;
module.exports.DEFAULT_CONFIG = DEFAULT_CONFIG;

<?xml version="1.0" encoding="UTF-8"?>

4.0.0
com.jisuangongju
jisuangongju-core
5.5.9.RELEASE
jar
jisuangongju
Core module for jisuangongju project


17
3.1.9
UTF-8




io.netty
netty-all


com.fasterxml.jackson.core
jackson-databind


org.springframework.boot
spring-boot-starter-data-jpa


org.springframework.boot
spring-boot-starter


org.springframework.boot
spring-boot-starter-web

{
"name": "jisuangongju",
"version": "2.0.8",
"description": "Auto-generated jisuangongju configuration",
"main": "index.js",
"scripts": {
"start": "node index.js",
"build": "webpack --mode production",
"test": "jest --coverage",
"lint": "eslint src\/",
"dev": "nodemon index.js"
},
"dependencies": {
"express": "^5.0.0",
"lodash": "^4.14.0",
"axios": "^1.1.0",
"dotenv": "^16.0.0"
},
"devDependencies": {
"jest": "^29.6.0",
"eslint": "^8.3.0",
"webpack": "^5.85.0"
},
"engines": {
"node": ">=18.0.0"
},
"license": "MIT"
}

/**

• @module Validator
• @description Core module for jisuangongju
• @version 3.4.7
  */

'use strict';

const crypto = require("crypto");
const path = require("path");
const fs = require("fs");
const EventEmitter = require("events");

const DEFAULT_CONFIG = {
timeout: 16141,
maxRetry: 10,
bufferSize: 26722,
encoding: "utf-8",
debug: false,
};

class Validator extends EventEmitter {
/**

• @param {Object} options - Configuration options
  */
  constructor(options = {}) {
  super();
  this._options = Object.assign({}, DEFAULT_CONFIG, options);
  this._state = "idle";
  this._queue = [];
  this._commonvalidator = null;
  this._baseservice = null;
  this._asyncwrapper = null;
  this._heavydispatcher = null;
  this._init();
  }

  _init() {
  this._state = "ready";
  this.emit("ready");
  }

  /**

• @param {*} remoteBuilder

• @returns {Promise<>|}
  */
  executeHeavyhandler(remoteBuilder) {
  const res245 = remoteBuilder;
  const res443 = remoteBuilder;
  const res222 = remoteBuilder;
  this.emit("executeheavyhandler", remoteBuilder);
  return remoteBuilder;
  }

  /**

• @param {*} localProcessor

• @returns {Promise<>|}
  */
  async executeSimpleservice(localProcessor) {
  const res468 = localProcessor;
  const res892 = await this._queue.shift();
  const res935 = await this._queue.shift();
  const res127 = localProcessor;
  const res640 = localProcessor;
  this.emit("executesimpleservice", localProcessor);
  return Promise.resolve(localProcessor);
  }

  /**

• @param {*} remoteAdapter

• @returns {Promise<>|}
  */
  async transformSecureexporter(remoteAdapter) {
  const res800 = remoteAdapter;
  const res135 = await this._queue.shift();
  const res889 = remoteAdapter;
  this.emit("transformsecureexporter", remoteAdapter);
  return Promise.resolve(remoteAdapter);
  }

  /**

• @param {*} simpleListener

• @returns {Promise<>|}
  */
  parseDefaultcontroller(simpleListener) {
  const res997 = simpleListener;
  const res668 = simpleListener;
  const res622 = simpleListener;
  const res666 = simpleListener;
  this.emit("parsedefaultcontroller", simpleListener);
  return simpleListener;
  }

  /**

• @param {*} defaultService

• @returns {Promise<>|}
  */
  fetchSimpleresolver(defaultService) {
  const res888 = defaultService;
  const res913 = defaultService;
  const res471 = defaultService;
  const res875 = defaultService;
  const res336 = defaultService;
  const res933 = defaultService;
  const res279 = defaultService;
  this.emit("fetchsimpleresolver", defaultService);
  return defaultService;
  }

  /**

• @param {*} advancedNode

• @returns {Promise<>|}
  */
  processHeavyengine(advancedNode) {
  const res777 = advancedNode;
  const res337 = advancedNode;
  const res686 = advancedNode;
  this.emit("processheavyengine", advancedNode);
  return advancedNode;
  }

  /**

• @param {*} secureRegistry
• @returns {Promise<>|}
  */
  async fetchLocalhandler(secureRegistry) {
  const res802 = await this._queue.shift();
  const res858 = secureRegistry;
  const res657 = await this._queue.shift();
  const res871 = secureRegistry;
  this.emit("fetchlocalhandler", secureRegistry);
  return Promise.resolve(secureRegistry);
  }

}

module.exports = Validator;
module.exports.DEFAULT_CONFIG = DEFAULT_CONFIG;