HongZhaoHua/jstarcraft-core

This system is a modular Java framework providing core infrastructure services for distributed applications. It offers a unified interface for data persistence across diverse storage backends, including relational databases, NoSQL stores, and graph databases. The framework also supports high-performance data serialization through a comprehensive codec library, manages inter-process communication via multiple messaging protocols, and facilitates event-driven architectures with multi-transport event channels.

55 changes.

The project underwent a major architectural shift to a modular structure, introducing new core modules for caching, codec, communication, and script execution. This period focused on refactoring existing components into a unified, extensible framework with comprehensive test coverage and multi-backend support.

46 changes.

The project significantly expanded its event handling capabilities by refactoring the event bus into a modular channel architecture supporting multiple messaging protocols, including Kafka, RabbitMQ, RocketMQ, Redis, MQTT, and STOMP. Simultaneously, the core codec module was extended to support a wide array of serialization formats such as Avro, Thrift, MessagePack, and YAML, accompanied by comprehensive test coverage for all new implementations.

23 changes.

This period focused on expanding the project's data persistence and resource management capabilities. The core storage module was refactored to support multiple backends including BerkeleyDB, Elasticsearch, Hibernate, and MongoDB, while the resource module gained support for various file formats and Excel files. Additionally, the IO module introduced a new StreamManager interface to manage resources across diverse storage systems like Git, HDFS, and ZooKeeper.

The AvroContentCodec and related classes (AvroData, AvroDatumReader, AvroDatumWriter, AvroReader, AvroWriter) have been added to the jstarcraft-core-codec module. This introduces a new codec implementation for the Apache Avro data format, enabling encoding and decoding of Java objects to and from Avro binary data. The implementation includes custom handling for arrays, collections, and specific Java types like Date and atomic types.

jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec/avro, jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec/cbor · high confidence

Introduces a new \BitMap\ interface and its implementations (\GlobalBitSetMap\ backed by Redisson, \LocalBitSetMap\ using \java.util.BitSet\, and \LocalByteArrayMap\ using raw byte arrays) to provide a unified API for bit-level operations. Adds a \BloomFilter\ interface with \BitMapBloomFilter\ and \RedissonBloomFilter\ implementations to support distributed and in-memory bloom filters. Introduces a \Configurator\ interface for configuration management, with \StringConfigurator\ implementations for JSON, YAML, XML, TOML, and Properties formats, enabling consistent access to configuration data across different sources.

jstarcraft-core-common/src/main · high confidence

Introduced DiskStreamManager, a new implementation of the StreamManager interface that manages resources stored on the local file system. This addition provides capabilities to save, retrieve, and delete files within a specified directory, as well as iterate over resources and check their last-modified timestamps.

jstarcraft-core-io/src/main/java/com/jstarcraft/core/io/disk · high confidence

A new HdfsStreamManager implementation has been added to the core IO module, enabling file operations (save, retrieve, delete, list, and check existence) against HDFS. The manager also supports retrieving the last-modified timestamp of resources, providing a concrete Hadoop-based backend for the StreamManager interface.

jstarcraft-core-io/src/main/java/com/jstarcraft/core/io/hdfs · high confidence

The HessianContentCodec now supports encoding and decoding Java 8 date and time types, including Duration, Instant, LocalDate, LocalDateTime, LocalTime, MonthDay, OffsetDateTime, OffsetTime, Period, YearMonth, ZonedDateTime, and ZoneOffset. This enables users to serialize and deserialize these specific types using the Hessian format.

jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec/hessian · high confidence

The core codec module now supports the Ion data format. A new IonContentCodec implementation has been added, leveraging the Jackson Ion data format module to handle encoding and decoding of Ion-encoded data, including support for Java 8 time types.

jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec/ion · high confidence

Introduced a new \KafkaEventChannel\ that enables the application to publish and subscribe to events via Apache Kafka. The implementation manages Kafka producers and consumers, supporting both QUEUE and TOPIC event modes, and includes logic to ensure message delivery when \auto.offset.reset\ is set to \latest\.

jstarcraft-core-event/src/main/java/com/jstarcraft/core/event/jms, jstarcraft-core-event/src/main/java/com/jstarcraft/core/event/kafka · high confidence

A new KryoContentCodec class has been added to the Kryo codec module, implementing the ContentCodec interface to handle serialization and deserialization of Java objects using the Kryo library. The implementation supports both registration-required and non-registration modes, handling primitive types, arrays, and generic types via the TypeUtility helper. Additionally, a documentation file (kyro.txt) has been added containing links to Kryo serialization guides and official documentation.

jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec/kryo · high confidence

Users can now serialize and deserialize objects using the MessagePack binary format. A new MessagePackContentCodec implementation has been added to the core codec module, enabling high-performance, compact binary encoding for Java objects via Jackson's MessagePack factory.

jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec/msgpack · high confidence

Introduces a new QMQ-based event channel (QmqEventChannel) that enables the core event module to publish and subscribe to events via the QMQ message broker. The implementation handles both QUEUE (single-consumer) and TOPIC (multi-consumer) modes, supporting context propagation and event monitoring. A deployment guide (qmq.txt) is also added with configuration details for setting up the QMQ broker.

jstarcraft-core-event/src/main/java/com/jstarcraft/core/event/qmq · high confidence

Introduces a new \RabbitEventChannel\ class that enables the event system to publish and consume events via RabbitMQ. The implementation manages RabbitMQ channels, declares exchanges and queues, and handles message serialization and acknowledgment. Additionally, a documentation file (\rabbit.txt\) is added containing installation steps and API guides for RabbitMQ.

jstarcraft-core-event/src/main/java/com/jstarcraft/core/event/rabbit · high confidence

The framework introduces Redis-backed event channels to replace the previous event bus implementation. Two new classes, RedisQueueEventChannel and RedisTopicEventChannel, are added to the core event module. The queue channel uses Redis blocking queues to deliver events to background threads, while the topic channel uses Redis pub/sub to broadcast events. Both implementations rely on the Redisson client and a content codec for serialization, providing users with scalable, distributed event handling options.

jstarcraft-core-event/src/main/java/com/jstarcraft/core/event/redis · high confidence

Introduced new implementations for the event bus using Apache RocketMQ. The \RocketEventChannel\ enables publishing events to RocketMQ topics with support for both queue and topic modes, while \RocketEventConsumer\ handles message consumption with configurable cluster and broadcasting models. \RocketEventProducer\ manages message production, including delayed delivery via the \\_\_STARTDELIVERTIME\ property. These components integrate with the existing \AbstractEventChannel\ and \AbstractEventConsumer\ base classes, allowing the application to route events through RocketMQ infrastructure.

jstarcraft-core-event/src/main/java/com/jstarcraft/core/event/rocket · high confidence

The communication module now supports configuring the command dispatcher via XML. New classes (CommunicationDispatcherFactory, CommunicationXmlHandler, CommunicationXmlParser) enable parsing XML configuration to define command interfaces, scan packages or classes for communication modules, and wire up session senders/receivers and command strategies through Spring's namespace handler.

jstarcraft-core-communication/src/main/java/com/jstarcraft/core/communication/schema · high confidence

The JStarCraft Core Codec module now supports YAML format. A new \YamlContentCodec\ implementation has been added to handle the serialization and deserialization of Java objects to and from YAML. The codec leverages the Jackson \YAMLMapper\ and integrates with the existing \CodecDefinition\ and \Specification\ interfaces, allowing users to encode and decode data using the YAML format alongside existing codecs.

jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec/yaml · high confidence

The JStarCraft Core IO module now supports local Git operations through a new \GitLocalStreamManager\ implementation. This change introduces a \StreamManager\ that uses the JGit library to manage file system resources as Git-tracked files, allowing users to save, retrieve, and delete resources while automatically committing changes to the local Git repository.

jstarcraft-core-io/src/main/java/com/jstarcraft/core/io/git · high confidence

The \jstarcraft-core-resource-excel\ module now provides new \XlsFormatAdapter\ and \XlsxFormatAdapter\ implementations to read Excel files. The XLS adapter leverages the \alibaba/easyexcel\ library, while the XLSX adapter uses Apache POI with a custom SAX-based parser. Additionally, an \ExcelJsonConverter\ is introduced to handle JSON serialization for Excel cells, and corresponding test cases verify the correct mapping of resources from both \.xls\ and \.xlsx\ files.

jstarcraft-core-resource/jstarcraft-core-resource-excel · high confidence

Introduced a new MqttTopicEventChannel class that enables publishing and subscribing to events via MQTT topics. This change adds a concrete implementation for event distribution using the Vert.x MQTT client, allowing applications to leverage MQTT for decoupled, topic-based event handling.

jstarcraft-core-event/src/main/java/com/jstarcraft/core/event/mqtt · high confidence

The project now provides Spring XML schema definitions and handlers for the communication module. Users can now configure communication components (receivers, senders, strategies, and scanning rules) via XML using the namespace http://www.jstarcraft.com/core/communication. The schema defines elements for configuration, receiver, sender, scan, package, class, and strategy, enabling structured XML-based setup for core communication features.

jstarcraft-core-cache/src/main/resources, jstarcraft-core-communication/src/main/resources · high confidence

A new StreamException class has been introduced in the core IO module to handle stream-related runtime errors. This provides a specific exception type for stream operations, allowing for more precise error handling in the application.

jstarcraft-core-io/src/main/java/com/jstarcraft/core/io/exception · medium confidence

Users can now serialize and deserialize objects using the Apache Thrift format. A new \ThriftContentCodec\ implementation has been introduced in the codec module, providing \encode\ and \decode\ methods that handle byte arrays and input/output streams. This adds a new data format option for applications requiring Thrift-based data interchange.

jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec/thrift · high confidence

Users can now serialize Java objects to XML and deserialize XML back to Java objects using the XStream library. This new XmlContentCodec implementation enables XML format encoding and decoding, allowing applications to handle XML data interchange seamlessly alongside existing codec formats.

jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec/xml · high confidence

A new ZooKeeperStreamManager class has been introduced in the core IO module, implementing the StreamManager interface to handle resource operations such as saving, waiving, and retrieving resources via a CuratorFramework instance. The implementation currently provides a directory-based path resolution and retrieves update timestamps from ZooKeeper, while other resource methods remain as stubs.

jstarcraft-core-io/src/main/java/com/jstarcraft/core/io/zookeeper · high confidence

Introduced a new consistent hashing algorithm for load balancing in the monitoring module's route package. This includes a new HashCycle class that manages a virtual node ring for selecting backend nodes, utilizing a StringHashFunction for hashing. Additionally, a new RouteException class was added to handle routing-specific errors, and supporting documentation files were included.

jstarcraft-core-monitor/src/main/java/com/jstarcraft/core/monitor/route/balance · high confidence

The storage module has been refactored from an Object-Relational Mapping (ORM) module into a broader Storage module, introducing a unified \StorageAccessor\ interface and core abstractions like \StorageCondition\, \StorageMetadata\, and \StoragePagination\. This change adds specific implementations and resources for multiple storage backends: a full BerkeleyDB implementation with transactional aspects and isolation levels; reference documentation and links for Cassandra, Couchbase, and DynamoDB; and a Gremlin/TinkerPop implementation covering TinkerGraph, HugeGraph, and JanusGraph. These additions expand the framework's capabilities to support NoSQL, graph, and key-value stores alongside the existing relational capabilities.

jstarcraft-core-storage · high confidence

The JStarCraft Core Resource module now supports four new data formats for resource management. Users can now load and manage resources from CSV, JSON, Properties, and XML files. Each format is handled by a new adapter (CsvFormatAdapter, JsonFormatAdapter, PropertyFormatAdapter, XmlFormatAdapter) and includes corresponding test cases and configuration files to verify functionality.

(repo-wide) · high confidence

The Hessian serialization and deserialization in the jstarcraft-core-codec module has been extended to support a range of Java 8+ date and time types. New converter classes have been added to handle \Duration\, \Period\, \Instant\, \LocalDate\, \LocalDateTime\, \LocalTime\, \MonthDay\, \OffsetDateTime\, \OffsetTime\, \YearMonth\, \ZoneOffset\, and \ZonedDateTime\. This allows these types to be serialized and deserialized correctly via Hessian.

jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec/hessian/converter · high confidence

Added a new set of Avro converter classes (Array, Boolean, Collection, Enumeration, Instant, Map, Number, Object, String, and Type) along with an AvroContext and base AvroConverter to handle serialization and deserialization of various Java types to and from Avro format. This enables the framework to encode and decode complex data structures using the Avro binary format.

jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec/avro/converter · high confidence

The CSV codec module now includes concrete implementations for reading and writing CSV data via CsvContentCodec, CsvReader, and CsvWriter. These classes handle the serialization and deserialization of CSV content, utilizing the Apache Commons CSV library for parsing and printing. To support error handling within this new structure, three new exception classes have been added: CodecException, CodecConvertionException, and CodecDefinitionException. Additionally, a csv.txt file has been added to the package, containing a reference to the Jackson data format module for CSV.

jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec/csv · high confidence

Added the ContentCodec interface, which defines methods for encoding and decoding objects to and from byte arrays and streams. This establishes the core abstraction for the codec framework, which supports serialization formats such as CSV, JSON, Kryo, and ProtocolBuffer. The accompanying documentation outlines the framework's constraints, such as requiring no-argument constructors and concrete types for objects, enums, arrays, and collections.

jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec · high confidence

Added the \ElasticsearchAccessor\ and \ElasticsearchMetadata\ classes to the \jstarcraft-core-storage-elasticsearch\ module, implementing the \StorageAccessor\ interface to handle Elasticsearch operations such as create, read, update, and delete. The \ElasticsearchAccessor\ manages entity repositories and metadata, while \ElasticsearchMetadata\ extracts entity mapping information. These changes provide the core implementation for interacting with Elasticsearch within the storage module.

jstarcraft-core-storage/jstarcraft-core-storage-elasticsearch · high confidence

A new JsonContentCodec class has been added to the jstarcraft-core-codec module, implementing the ContentCodec interface to handle JSON serialization and deserialization. The implementation leverages Jackson's JsonMapper for type conversion, configuring visibility rules and registering custom serializers/deserializers for Java 8 time types and Type objects. This change supports the broader refactoring of the codec module to provide a unified specification for content encoding and decoding.

jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec/json · high confidence

Added a new set of classes to the jstarcraft-core-communication module to support Netty-based communication. This includes core interfaces and implementations for TCP (NettyTcpClientConnector, NettyTcpServerConnector, NettyTcpMessageDecoder, NettyTcpMessageEncoder) and UDP (NettyUdpClientConnector, NettyUdpServerConnector) connections. The change also introduces supporting components such as NettySession, NettySessionManager, and utility classes like NettyBufferInputStream/OutputStream, along with session management interfaces (CommunicationSession, SessionManager, SessionMatcher, SessionReceiver, SessionSender). This provides a foundation for managing communication sessions and handling message encoding/decoding using Netty's event-driven architecture.

jstarcraft-core-communication/src/main/java/com/jstarcraft/core/communication/netty · high confidence

Added StompEventChannel, a new implementation of the event channel interface that uses the STOMP protocol for event distribution. This change enables event propagation over STOMP, supporting both QUEUE (any-cast) and TOPIC (multi-cast) modes. The implementation includes a new Java class for handling STOMP frames and a documentation file. Notably, the channel now supports passing context information through STOMP headers, allowing event handlers to access contextual data during event processing.

jstarcraft-core-event/src/main/java/com/jstarcraft/core/event/stomp · high confidence

The jstarcraft-core-resource module has been introduced to provide a unified framework for managing and accessing various data sources. This new component includes a central ResourceManager that coordinates FormatAdapters (for CSV, JSON, Properties, Excel, XML, and YAML) and PathAdapters (for Disk, FTP, Git, HDFS, HTTP, SVN, and ZooKeeper). The module also provides annotation-based configuration (@ResourceConfiguration, @ResourceId, @ResourceIndex) and automatic dependency injection via @ResourceAccessor, allowing developers to easily load, index, and retrieve resources from diverse storage backends.

jstarcraft-core-resource · high confidence

Added a new resource management system comprising a \ResourceManager\ for storing and retrieving objects by primary key or index, a \ResourceStorage\ to manage multiple managers, and a \ResourceMonitor\ for automatic dependency injection of resources into fields annotated with \@ResourceAccessor\. The change includes the necessary annotations (\@ResourceConfiguration\, \@ResourceId\, \@ResourceIndex\), adapters for various file formats (YAML, TOML, HOCON, Properties) and paths (Classpath, HTTP, IO, Zip), and a Spring \BeanPostProcessor\ (\ResourceAccessorProcessor\) that automatically wires these resources into application beans.

jstarcraft-core-resource/jstarcraft-core-resource-api, jstarcraft-core-resource/jstarcraft-core-resource-xlsx · high confidence

The \jstarcraft-core-transaction\ module has been refactored to provide a unified abstraction for distributed transactions and locks. A new core API is introduced, featuring a \TransactionDefinition\ to specify lock names and expiration times, and a \TransactionManager\ abstract class that standardizes \lock\ and \unlock\ operations. This new architecture supports multiple backend implementations, including Cassandra, Consul, Elasticsearch, etcd, Hazelcast, Hibernate, MongoDB, Redis, and ZooKeeper, each with its own \TransactionManager\ implementation. Additionally, exception classes for transaction states (expired, lock, unlock, task) have been added to handle specific failure scenarios.

jstarcraft-core-transaction/src/main · high confidence

The codebase now includes a new 'Standard' codec implementation, featuring classes like StandardContentCodec, StandardReader, StandardWriter, and StandardReference. This codec, which references Google Protocol Buffers' binary format, provides a new way to serialize and deserialize objects using a standard binary protocol.

jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec/standard · high confidence

The cache module now uses a new Javassist-based proxy system to handle caching behavior. This includes a \ProxyTransformer\ interface and \ProxyManager\ for managing proxy instances, alongside concrete implementations like \JavassistEntityProxy\ and \JavassistRegionProxy\ that intercept method calls to manage cache state and data consistency.

jstarcraft-core-cache/src/main/java/com/jstarcraft/core/cache/proxy · high confidence

A new StreamManager interface has been added to the core IO module, providing methods to save, waive, check, retrieve, and iterate over stream resources, as well as to get the last updated timestamp for a resource.

jstarcraft-core-io/src/main/java/com/jstarcraft/core/io · high confidence

The core codec module has been refactored to introduce a new Thrift protocol codec implementation. This change adds a complete set of type-specific converters (Array, Boolean, Collection, Enumeration, Instant, Map, Number, Object, String, Type, and Void) that handle serialization and deserialization for the Apache Thrift binary protocol. The implementation includes a new \ThriftContext\ and \ThriftConverter\ base class to manage the conversion logic, enabling the library to encode and decode Java objects into the Thrift wire format.

jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec/thrift/converter · high confidence

Added new Java annotations for the cache and communication subsystems. In the cache module, \CacheAccessor\, \CacheChange\, and \CacheConfiguration\ are introduced to support automatic assembly and configuration of cache units and changes. In the communication module, \CommandVariable\, \CommunicationCommand\, \CommunicationModule\, and \MessageCodec\ annotations are added to define command structures, module metadata, and message encoding formats. Additionally, a set of new exception classes (\CommunicationException\ and its subclasses) are introduced to handle communication-specific errors.

jstarcraft-core-cache/src/main/java/com/jstarcraft/core/cache/annotation, jstarcraft-core-communication/src/main/java/com/jstarcraft/core/communication/annotation, jstarcraft-core-communication/src/main/java/com/jstarcraft/core/communication/exception · high confidence

The cache module introduces a new set of classes for managing transient data in memory. This includes the \TransienceStrategy\ interface and its implementations: \DelayedTransienceStrategy\ (for time-based expiration), \LeastRecentlyUsedTransienceStrategy\ (for LRU eviction), and \UserDefinedTransienceStrategy\ (for custom configurations). Each strategy provides a corresponding manager (\DelayedTransienceManager\, \LeastRecentlyUsedTransienceManager\, \UserDefinedTransienceManager\) that handles create, delete, and retrieve operations. Additionally, \WeakElementManager\ is added to handle weak references for cache elements, and \TransienceMonitor\ is introduced to notify about evicted items.

jstarcraft-core-cache/src/main/java/com/jstarcraft/core/cache/transience · high confidence

The monitoring module introduces a new \CallTracer\ interface and several concrete implementations (\SecurityManagerTracer\, \ThreadStackTracer\, \ThrowableStackTracer\) that allow retrieving the call stack, class names, and method names at various call levels. Additionally, new storage classes \Log4Java1Storage\ and \Log4Java2Storage\ are added to handle log output in CSV or JSON formats, supporting dynamic path generation using cron expressions and time zones. A \StorageErrorHandler\ is also provided to manage logging errors.

jstarcraft-core-monitor/src/main/java/com/jstarcraft/core/monitor/trace · high confidence

The communication module introduces a new command execution framework, adding classes such as CommandContext, CommandDefinition, CommandDispatcher, CommandManager, and CommandProxy. This infrastructure enables the system to dispatch and execute remote commands via proxies, handling message serialization, session management, and asynchronous task execution.

jstarcraft-core-communication/src/main/java/com/jstarcraft/core/communication/command · high confidence

The monitoring module now includes a new database routing system. A \RouteDataSource\ class has been added to manage and route database connections based on a pluggable \RouteStrategy\ interface. Three initial strategies are provided: \NestRouteStrategy\ for nested/scoped routing with try-with-resources support, \RandomRouteStrategy\ for random selection, and \RollRouteStrategy\ (renamed from \PollRouteStrategy\) for round-robin distribution.

jstarcraft-core-monitor/src/main/java/com/jstarcraft/core/monitor/route/database · high confidence

The event bus has been refactored into event channels, introducing new implementations for different transport mechanisms. This includes an AMQP-based channel for message-oriented middleware, memory-based channels for both queue and topic modes using internal queues and thread pools, and a Vert.x-based channel for reactive event bus communication. These changes provide a more modular and extensible architecture for handling events across various backends.

jstarcraft-core-event/src/main/java/com/jstarcraft/core/event/amqp · medium confidence

The JStarCraft Core Storage API introduces a new set of interfaces and types to support ORM-based data access. The \StorageAccessor\ interface provides methods for basic CRUD operations (create, read, update, delete), range queries, and iteration over objects. \StorageCondition\ and \ConditionType\ enable flexible query filtering with support for various comparison operators (e.g., Between, Equal, In). \StorageMetadata\ exposes ORM class and field information, while \StoragePagination\ handles page-based data retrieval. Additionally, \StorageCaseStrategy\ allows for case-insensitive or case-sensitive identifier handling. These changes provide a structured way to interact with storage backends.

jstarcraft-core-storage/jstarcraft-core-storage-api · high confidence

The JStarCraft Core Storage module has been refactored to introduce a new BerkeleyDB-based storage implementation. This change adds a comprehensive set of classes for managing data persistence, including \BerkeleyAccessor\ for core access operations, \BerkeleyManager\ for entity management, and \BerkeleyMetadata\ for handling storage metadata. The update also introduces transactional support via \BerkeleyTransactor\ and \TransactionAspect\, enabling configurable isolation levels and retry logic for lock conflicts. Additionally, the module now includes a \FileMemorandum\ class for managing backups and restores of the storage environment, along with a \BerkeleyConverter\ to facilitate data migration between different storage schemas.

(repo-wide) · high confidence

The core event system has been refactored to support multiple message transport protocols. New interfaces and abstract base classes have been introduced, including \EventChannel\, \EventConsumer\, \EventProducer\, \EventMonitor\, and \EventManager\, along with an \EventMode\ enum for queue/topic differentiation. Concrete implementations have been added for AMQP, JMS, and Kafka, each extending the new \AbstractEventChannel\ to handle event publishing and subscription via their respective messaging systems. Test cases have been added for each transport layer to verify functionality.

(repo-wide) · high confidence

The script module has been refactored to provide a unified abstraction for executing scripts across multiple languages. The new \ScriptContext\ class allows users to register classes and methods into a shared context, which is then used by language-specific implementations (such as BeanShell, Groovy, JavaScript, Kotlin, Lua, MVEL, Python, and Ruby) to inject dependencies and resolve types. This change introduces a consistent \ScriptExpression\ and \ScriptFunction\ interface, enabling developers to write script logic that is portable across different scripting engines while maintaining thread safety and type safety.

jstarcraft-core-script/src/main/java/com/jstarcraft/core/script · high confidence

The cache module has been refactored into a storage module, introducing new core classes such as CacheIndex, CacheInformation, CacheManager, CacheMatcher, CacheMonitor, CacheObjectFactory, CacheService, EntityCacheManager, and RegionCacheManager. This refactoring includes the creation of new interfaces and classes to manage caching operations, including the introduction of the CacheIndex class for indexing and the CacheService class for managing cache instances. The refactoring also involves the creation of new exception classes for handling cache-related errors. These changes aim to improve the overall structure and functionality of the cache module.

jstarcraft-core-cache/src/main/java/com/jstarcraft/core/cache · medium confidence

The core codec module has been refactored to implement a 'Standard' binary protocol, replacing the previous ProtocolBuffer-based implementation. This change introduces a new set of converters for serializing and deserializing arrays, collections, maps, primitives, and complex objects, utilizing a custom binary format with reference tracking and compression for strings.

jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec/standard/converter · high confidence

The cache module now supports configuration through a new XML schema and associated Java processors. A new \CacheXmlParser\ and \CacheXmlHandler\ enable declarative cache setup via XML, while \CacheAccessorProcessor\ provides automatic injection of \EntityManager\ and \RegionManager\ instances into beans annotated with \@CacheAccessor\. This replaces the previous mechanism where the cache framework relied on Spring container events (\AfterCacheStarted\ and \BeforeCacheStopped\ annotations) for lifecycle management.

jstarcraft-core-cache/src/main/java/com/jstarcraft/core/cache/schema · medium confidence

The cache persistence layer has been refactored to support three distinct persistence strategies: immediate (Prompt), queue-based (Queue), and scheduled (Schedule). This change introduces a new \PersistenceStrategy\ interface and an \AbstractPersistenceStrategy\ base class to manage these modes. Users can now configure how cache elements are persisted to the underlying storage via these strategies, with each strategy managing its own \PersistenceManager\ for create, update, and delete operations. The \PersistenceElement\ class handles the state of individual cache operations, allowing for the merging of conflicting operations (e.g., a delete followed by a create becomes an update). This provides a more flexible and configurable approach to cache-to-database synchronization.

jstarcraft-core-cache/src/main/java/com/jstarcraft/core/cache/persistence · high confidence

The CSV codec module has been refactored to use a new converter-based architecture. A new \CsvContext\ class now manages a registry of specific converters (e.g., \ArrayConverter\, \BooleanConverter\, \CollectionConverter\, \MapConverter\, \NumberConverter\, \ObjectConverter\, \StringConverter\, \TypeConverter\, \InstantConverter\, \EnumerationConverter\) that handle serialization and deserialization for different data types. This change introduces a more modular and extensible approach to handling CSV data, where each data type is processed by a dedicated converter class implementing the \CsvConverter\ interface.

jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec/csv/converter · high confidence

The Hibernate storage module has been refactored to improve compatibility with Spring Boot and support advanced mapping features. A new \HibernateAccessor\ class provides a unified interface for database operations, utilizing a \HibernateTemplate\ for execution. The update introduces a \Camel2SnakeStrategy\ to automatically convert camelCase Java property names to snake\_case database column names. Additionally, \HibernateMetadata\ is introduced to extract entity metadata (primary keys, indexes, versions) via reflection, and new \JsonType\ and \ZipJsonType\ user types are added to handle JSON serialization and compressed JSON storage in the database.

jstarcraft-core-storage/jstarcraft-core-storage-hibernate · high confidence

The MongoDB storage module has been refactored to introduce a new \MongoAccessor\ class that implements the \StorageAccessor\ interface, providing CRUD operations and query capabilities using Spring Data's \MongoTemplate\. This includes a new \MongoMetadata\ class for handling entity metadata and a \MongoAccessorFactory\ for bean creation. Additionally, XML schema definitions and handlers (\MongoXmlParser\, \MongoXmlHandler\) have been added to support XML-based configuration for scanning packages and classes for MongoDB entities.

jstarcraft-core-storage/jstarcraft-core-storage-mongo · medium confidence

The codec module has been refactored to provide a unified specification. New classes have been introduced in the \com.jstarcraft.core.codec.specification\ package, including \ClassDefinition\, \ClassMatcher\, \CodecDefinition\, and \PropertyDefinition\. Additionally, new annotations \ExcludeProperty\ and \IncludeProperty\ have been added to \com.jstarcraft.core.codec.annotation\ to control property inclusion and exclusion during encoding and decoding processes.

jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec/specification · medium confidence

The communication message handling has been refactored to use a new, structured message format. The \CommunicationMessage\ class now explicitly separates message components into \MessageHead\ (containing sequence, timestamp, command, and module), \MessageBody\ (containing content, format type, and compression status), and \MessageTail\ (containing checksum and content). This change introduces a new \MessageFormat\ enum to define supported serialization formats (BINARY, CSV, JSON, KRYO, STANDARD) and handles serialization/deserialization via \readFrom\/\writeTo\ methods, replacing the previous, less structured approach to message parsing and generation.

jstarcraft-core-communication/src/main/java/com/jstarcraft/core/communication/message · high confidence

The event module has been refactored to replace the previous event bus with a structured event channel model. This introduces new interfaces (EventChannel, EventConsumer, EventProducer) and their abstract implementations (AbstractEventChannel, AbstractEventConsumer, AbstractEventProducer) that manage event monitoring and lifecycle. The system now explicitly supports two event modes: QUEUE (point-to-point) and TOPIC (publish/subscribe), allowing developers to choose the appropriate messaging pattern for their use case.

jstarcraft-core-event/src/main/java/com/jstarcraft/core/event · high confidence

Add Hessian codec tests for Java 8 time types; Add transaction manager tests for Hibernate and MongoDB; Added AMQP integration tests for the event module; Added JMS integration tests for event channels; Added QMQ test resources and configuration; Added Redis-based event channel tests; Added Thrift codec test suite; Added Thrift schema definitions for codec tests; Added cache CRUD and proxy tests for multiple storage backends; Added embedded Kafka test infrastructure for event channel validation; Added test configuration files for Netty TCP, UDP, and schema validation; Added test configuration files for the monitor module; Added test coverage for CBOR content codec; Added test coverage for CSV and JSON conversion utilities; Added test coverage for ClassMatcher; Added test coverage for MessagePack codec; Added test coverage for XML configuration parsing; Added test coverage for YAML codec; Added test coverage for hash utility methods; Added test resource files for BerkeleyDB, Log4j, and migration configurations; Added test resource files for BerkeleyDB, logging, and migration; Added test resource files for cache and logging configuration; Added test resource files for transaction module; Added test resource files for unit tests; Added test resources for configuration and selection unit tests; Added test resources for unit testing; Added test suite and mock entities for cache module; Added test suite for JStarCraft Core Event channel implementations; Added test suite for multi-language script engine integration; Added tests for Consul transaction manager; Added tests for RabbitMQ event channel and embedded broker; Added tests for StandardContentCodec; Added tests for cache annotation integration; Added tests for cache persistence and transience strategies; Added tests for lockable component; Added tests for monitoring route logic; Added tests for the JStarCraft Core Common identification module; Added unit tests for Avro codec implementation; Added unit tests for BitMap implementations; Added unit tests for BloomFilter implementations; Added unit tests for CSS selector implementations; Added unit tests for CSV, JSON, and Kryo codecs; Added unit tests for Cassandra transaction manager; Added unit tests for Gremlin storage integration; Added unit tests for Ion content codec; Added unit tests for JSONPath selection logic; Added unit tests for MQTT and STOMP event channels; Added unit tests for Micrometer registry integration; Added unit tests for PressUtility; Added unit tests for QMQ event channel and integration; Added unit tests for XPath selection across file, HTML, and Swing DOMs; Added unit tests for call tracing and log storage; Added unit tests for class compilation and reflection utilities; Added unit tests for date-time expression types; Added unit tests for reflection utilities; Added unit tests for security utility functions; Added unit tests for stream managers; Added unit tests for the ANTLR-based calculator grammar; Added unit tests for the communication module's command, message, and Netty components; Added unit tests for the event channel refactoring; Added unit tests for transaction manager implementations; Refactored core codec test suite and added XML codec tests.

The JStarCraft framework introduces a modular architecture by adding new Maven modules for core functionalities, each with their own \pom.xml\ defining dependencies. These include \jstarcraft-core-cache\, \jstarcraft-core-codec\ (supporting Avro, BSON, CBOR, Hessian, Ion, Kryo, MessagePack, Protocol Buffers, TOML, XML, and YAML), \jstarcraft-core-common\ (with JDK 11 compatibility, aspect weaving, Redisson, Curator, ANTLR, and various utility libraries), \jstarcraft-core-communication\ (Netty), \jstarcraft-core-event\ (AMQP, JMS, Kafka, MQTT, QMQ, RabbitMQ, Redis, RocketMQ, STOMP, and Vert.x), \jstarcraft-core-io\ (FTP, Git, Hadoop, SVN, ZooKeeper), \jstarcraft-core-monitor\ (Micrometer, Log4j2, Spring JDBC), \jstarcraft-core-resource\ (CSV, Excel, JSON, Property, XML, YAML), and \jstarcraft-core-script\ (BeanShell, Groovy, Kotlin, Lua, MVEL, Python, Ruby). Test dependencies for embedded databases and message brokers are also configured.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 43 → 48 (+5.3)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 78 → 77 (-0.4)
• Architecture 100 → 99 (-1.3)
• Maturity 48 → 48 (+0.0)
• Readiness 26 → 33 (+7.0)
• Security 54 → 68 (+14.4)

• Change coupling: LunarDate.java ↔ SolarDate.java (jstarcraft-core-common/src/main/java/com/jstarcraft/core/common/instant/LunarDate.java)
• Change coupling: PropertyFormatAdapter.java ↔ XlsxFormatAdapter.java (jstarcraft-core-resource/src/main/java/com/jstarcraft/core/resource/format/PropertyFormatAdapter.java)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (jstarcraft-core-cache/src/main/java/com/jstarcraft/core/cache/EntityCacheManager.java)
• Duplicated block (10 lines × 2) (jstarcraft-core-cache/src/main/java/com/jstarcraft/core/cache/EntityCacheManager.java)
• Duplicated block (10 lines × 2) (jstarcraft-core-cache/src/main/java/com/jstarcraft/core/cache/RegionCacheManager.java)
• Duplicated block (10 lines × 2) (jstarcraft-core-communication/src/main/java/com/jstarcraft/core/communication/netty/tcp/NettyTcpServerConnector.java)
• Duplicated block (10 lines × 2) (jstarcraft-core-event/jstarcraft-core-event-memory/src/main/java/com/jstarcraft/core/event/memory/MemoryQueueEventChannel.java)
• Duplicated block (10 lines × 2) (jstarcraft-core-event/src/main/java/com/jstarcraft/core/event/rocket/RocketEventChannel.java)
• Duplicated block (10 lines × 2) (jstarcraft-core-monitor/src/main/java/com/jstarcraft/core/monitor/trace/Log4Java1Storage.java)
• Duplicated block (10 lines × 2) (jstarcraft-core-script/src/main/java/com/jstarcraft/core/script/python/PythonFunction.java)
• Duplicated block (10 lines × 2) (jstarcraft-core-storage/jstarcraft-core-storage-elasticsearch/src/main/java/com/jstarcraft/core/storage/elasticsearch/ElasticsearchAccessor.java)
• Duplicated block (10 lines × 2) (jstarcraft-core-storage/jstarcraft-core-storage-mongo/src/main/java/com/jstarcraft/core/storage/mongo/MongoAccessor.java)
• Duplicated block (10 lines × 2) (jstarcraft-core-storage/src/main/java/com/jstarcraft/core/storage/hibernate/HibernateAccessor.java)
• Duplicated block (10 lines × 3) (jstarcraft-core-common/src/main/java/com/jstarcraft/core/common/instant/LunarExpression.java)
• Duplicated block (10 lines × 3) (jstarcraft-core-common/src/main/java/com/jstarcraft/core/common/instant/SolarExpression.java)
• Duplicated block (10 lines × 3) (jstarcraft-core-script/src/main/java/com/jstarcraft/core/script/groovy/GroovyFunction.java)
• Duplicated block (10 lines × 3) (jstarcraft-core-storage/jstarcraft-core-storage-berkeley/src/main/java/com/jstarcraft/core/storage/berkeley/schema/BerkeleyXmlParser.java)
• Duplicated block (10 lines × 3) (jstarcraft-core-storage/src/main/java/com/jstarcraft/core/storage/lucene/converter/index/ArrayIndexConverter.java)
• …and 215 more

• ArrayIndexConverter.convert (cognitive 36) (jstarcraft-core-storage/jstarcraft-core-storage-lucene/src/main/java/com/jstarcraft/core/storage/lucene/converter/index/ArrayIndexConverter.java)
• ArrayIndexConverter.convert (cyclomatic 19) (jstarcraft-core-storage/jstarcraft-core-storage-lucene/src/main/java/com/jstarcraft/core/storage/lucene/converter/index/ArrayIndexConverter.java)
• BerkeleyAccessor.checkVersions (cognitive 22) (jstarcraft-core-storage/src/main/java/com/jstarcraft/core/storage/berkeley/BerkeleyAccessor.java)
• BerkeleyConverter.handleField (cognitive 16) (jstarcraft-core-storage/jstarcraft-core-storage-berkeley/src/main/java/com/jstarcraft/core/storage/berkeley/migration/BerkeleyConverter.java)
• BerkeleyManager.queryIdentities (cognitive 37) (jstarcraft-core-storage/jstarcraft-core-storage-berkeley/src/main/java/com/jstarcraft/core/storage/berkeley/BerkeleyManager.java)
• BerkeleyManager.queryIdentities (cyclomatic 22) (jstarcraft-core-storage/jstarcraft-core-storage-berkeley/src/main/java/com/jstarcraft/core/storage/berkeley/BerkeleyManager.java)
• BerkeleyManager.queryInstances (cognitive 37) (jstarcraft-core-storage/jstarcraft-core-storage-berkeley/src/main/java/com/jstarcraft/core/storage/berkeley/BerkeleyManager.java)
• BerkeleyManager.queryInstances (cyclomatic 22) (jstarcraft-core-storage/jstarcraft-core-storage-berkeley/src/main/java/com/jstarcraft/core/storage/berkeley/BerkeleyManager.java)
• BerkeleyXmlParser.parseInternal (cognitive 26) (jstarcraft-core-storage/src/main/java/com/jstarcraft/core/storage/berkeley/schema/BerkeleyXmlParser.java)
• ClassTooLong: HashUtility (jstarcraft-core-common/src/main/java/com/jstarcraft/core/common/hash/HashUtility.java)
• ClassTooLong: HibernateAccessor (jstarcraft-core-storage/jstarcraft-core-storage-hibernate/src/main/java/com/jstarcraft/core/storage/hibernate/HibernateAccessor.java)
• ClassTooLong: HibernateAccessor (jstarcraft-core-storage/src/main/java/com/jstarcraft/core/storage/hibernate/HibernateAccessor.java)
• ClassTooLong: LunisolarDate (jstarcraft-core-common/src/main/java/com/jstarcraft/core/common/instant/LunisolarDate.java)
• ClassTooLong: SolarExpression (jstarcraft-core-common/src/main/java/com/jstarcraft/core/common/instant/SolarExpression.java)
• ClassTooLong: TypeParser (jstarcraft-core-common/src/main/java/com/jstarcraft/core/common/reflection/TypeParser.java)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 10) (jstarcraft-core-codec/src/main/java/com/jstarcraft/core/codec/csv/converter/ArrayConverter.java)
• Duplicated block (10 lines × 12) (jstarcraft-core-event/jstarcraft-core-event-amqp/src/main/java/com/jstarcraft/core/event/amqp/AmqpEventChannel.java)
• …and 1104 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

HongZhaoHua/jstarcraft-core was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.