guicedee-inject
Bootstrap and manage the GuicedEE runtime engine: classpath scanning, Guice injector creation, lifecycle hooks, logging configuration, job pools, and module registration. Use when wiring up a GuicedEE application, configuring classpath scanning SPIs, setting up Log4j2 logging with LogUtils or @InjectLogger, managing JobService pools, implementing lifecycle hooks (IGuicePreStartup, IGuiceModule, IGuicePostStartup, IGuicePreDestroy), or troubleshooting the DI bootstrap sequence.
Best use case
guicedee-inject is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Bootstrap and manage the GuicedEE runtime engine: classpath scanning, Guice injector creation, lifecycle hooks, logging configuration, job pools, and module registration. Use when wiring up a GuicedEE application, configuring classpath scanning SPIs, setting up Log4j2 logging with LogUtils or @InjectLogger, managing JobService pools, implementing lifecycle hooks (IGuicePreStartup, IGuiceModule, IGuicePostStartup, IGuicePreDestroy), or troubleshooting the DI bootstrap sequence.
Teams using guicedee-inject should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/guicedee-inject/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How guicedee-inject Compares
| Feature / Agent | guicedee-inject | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Bootstrap and manage the GuicedEE runtime engine: classpath scanning, Guice injector creation, lifecycle hooks, logging configuration, job pools, and module registration. Use when wiring up a GuicedEE application, configuring classpath scanning SPIs, setting up Log4j2 logging with LogUtils or @InjectLogger, managing JobService pools, implementing lifecycle hooks (IGuicePreStartup, IGuiceModule, IGuicePostStartup, IGuicePreDestroy), or troubleshooting the DI bootstrap sequence.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# GuicedEE Inject
The runtime engine that classpath-scans, creates the Guice injector, and manages the full startup/shutdown lifecycle.
## Core Concept
`GuiceContext` is a singleton that orchestrates everything. Call `inject()` once — it discovers SPIs, scans, builds the injector, and runs lifecycle hooks:
```
IGuiceConfigurator → ClassGraph scan → IGuicePreStartup → Injector created → IGuicePostStartup
↓
IGuicePreDestroy (shutdown)
```
## Required Flow
1. Add `com.guicedee:inject` dependency.
2. Register your module for scanning, then bootstrap:
```java
IGuiceContext.registerModuleForScanning.add("my.app");
IGuiceContext.instance().inject();
```
3. Configure `module-info.java`:
- `requires com.guicedee.guicedinjection;`
- `opens` injection packages to `com.google.guice`
- `opens` DTO packages to `com.fasterxml.jackson.databind`
- `provides` every SPI implementation
4. Dual-register all SPIs in `module-info.java` and `META-INF/services/`.
## Providing Guice Modules
Implement `IGuiceModule` and register via SPI:
```java
public class AppModule extends AbstractModule implements IGuiceModule<AppModule> {
@Override
protected void configure() {
bind(Greeter.class).to(DefaultGreeter.class);
}
}
```
```java
// module-info.java
provides com.guicedee.client.services.lifecycle.IGuiceModule with my.app.AppModule;
```
## Lifecycle Hooks
| Hook | When it runs | Return |
|---|---|---|
| `IGuiceConfigurator` | First — configures `GuiceConfig` before scanning | `IGuiceConfig<?>` |
| `IGuicePreStartup` | After scan, before injector — grouped by `sortOrder()` | `List<Future<Boolean>>` |
| `IGuiceModule` | During injector creation — standard Guice module | — |
| `IGuicePostStartup` | After injector is ready — async, grouped by `sortOrder()` | `List<Uni<Boolean>>` |
| `IGuicePreDestroy` | On shutdown — cleanup resources | `void` |
All hooks extend `IDefaultService<J>` (CRTP); override `sortOrder()` to control execution order and `enabled()` to conditionally skip.
## Logging
### `LogUtils` — programmatic setup
```java
LogUtils.addHighlightedConsoleLogger(); // ANSI console (local dev)
LogUtils.addConsoleLogger(Level.INFO); // plain console
LogUtils.addFileRollingLogger("app", "logs"); // rolling file (100 MB / daily)
Logger audit = LogUtils.getSpecificRollingLogger("audit", "logs/audit", null, false);
```
When `CLOUD` env var is set, layouts auto-switch to compact JSON.
### Log level control
Set via environment: `GUICEDEE_LOG_LEVEL`, `LOG_LEVEL`, `DEBUG=true`, or `TRACE=true`.
Programmatic: `GuiceContext.setDefaultLogLevel(Level.INFO)`.
## JobService
Virtual-thread-backed executor pools with graceful shutdown:
```java
JobService jobs = JobService.INSTANCE;
jobs.registerJob("import", 100);
jobs.addJob("import", () -> processFile(file));
jobs.registerPollingJob("heartbeat", () -> ping(), 0, 30, TimeUnit.SECONDS);
```
Pools auto-shutdown via `IGuicePreDestroy`.
## Non-Negotiable Constraints
- Never call `inject()` recursively during build — use `IGuicePostStartup` instead.
- At most one `GuiceContext` instance per JVM.
- Every SPI must be dual-registered (`module-info.java` + `META-INF/services/`).
- Injection packages must `opens` to `com.google.guice`.
- `IGuiceContext.registerModuleForScanning.add("my.module")` must be called before `instance()`.
- Scanning is **off by default** and no built-in configurator enables it — call `IGuiceContext.instance().getConfig().setClasspathScanning(true).setAnnotationScanning(true).setMethodInfo(true).setFieldInfo(true)` (or `setServiceLoadWithClassPath(true)`) **before** `inject()`, or annotation discovery finds nothing. Tests that boot directly must do the same in `@BeforeAll`.
- All lifecycle hooks must extend `IDefaultService<J>` (CRTP) and override `sortOrder()`.
## References
- `references/classpath-scanning.md` — scanner SPI interfaces, `GuiceConfig` options, module/JAR/package filtering.
- `references/lifecycle-logging.md` — lifecycle hook details, `@InjectLogger` attributes, `LogUtils` API, `Log4JConfigurator` SPI, `JobService` full API.Related Skills
guicedee-websockets
RFC 6455 WebSocket support for GuicedEE using Vert.x 5: call-scoped connections, action-based message routing via IWebSocketMessageReceiver SPI, group management and broadcasting, WebSocketServerOptions, and lifecycle hooks. Use when adding WebSocket messaging, implementing real-time communication, managing WebSocket groups, or creating message receivers.
guicedee-webservices
SOAP web services for GuicedEE using Apache CXF conventions: JAX-WS annotations (@WebService, @WebMethod, @WebParam, @WebResult), code-first and WSDL-first approaches, endpoint publishing, CXF interceptors and logging, MTOM, WS-Security (WSS4J), SOAP 1.1/1.2 bindings, and Guice DI integration. Use when creating SOAP services, publishing JAX-WS endpoints, configuring CXF bindings, or adding WS-Security.
guicedee-web
Bootstrap reactive HTTP/HTTPS servers with Vert.x 5 inside GuicedEE: Router setup, BodyHandler configuration, TLS/HTTPS, SPI extension points (VertxRouterConfigurator, VertxHttpServerOptionsConfigurator, VertxHttpServerConfigurator), per-verticle sub-routers, and environment-driven configuration. Use when setting up the Vert.x web server, configuring HTTP/HTTPS, adding custom routes or middleware, or managing server options.
guicedee-vertx
Build reactive services using Vert.x 5 inside the GuicedEE DI lifecycle: event-bus consumers, publishers, verticle deployment, codecs, throttling, clustering, SPI hooks, and JPMS module setup. Use when adding Vert.x event-bus messaging, deploying verticles, wiring reactive endpoints with Guice injection, configuring Vert.x runtime options, or implementing custom codecs and cluster managers.
guicedee-service-registry
Named service registry with health-aware resolution for GuicedEE. Register services by simple name, auto-construct URLs from cloud DNS suffix, monitor health status, resolve services via registry:name prefix or bare name in rest-client @Endpoint. Supports aliases, multiple external URLs, Kubernetes internal URLs, and per-service health paths. Use when registering named services, checking service health, resolving service URLs by name, or integrating with rest-client for service-to-service calls.
guicedee-rest
Build Jakarta REST (JAX-RS) services on Vert.x 5 inside GuicedEE: @Path/@GET/@POST route registration, parameter binding (@PathParam, @QueryParam, @HeaderParam, etc.), Guice-managed resource classes, response handling, content negotiation, and JPMS module setup. Use when creating REST endpoints, configuring Jakarta REST resources, or wiring JAX-RS services with Guice injection.
guicedee-rest-client
Annotation-driven REST client for GuicedEE using Vert.x 5 WebClient: @Endpoint declarations, RestClient<Send, Receive> injection, authentication strategies (Bearer, Basic, API Key, OAuth2, mTLS), path parameters, environment variable overrides, package-level endpoints, service registry integration (bare name or registry: prefix), and RestClientConfigurator SPI. Use when making outbound REST calls, configuring REST client endpoints, or wiring reactive HTTP clients with Guice injection.
guicedee-rabbitmq
Annotation-driven RabbitMQ integration for GuicedEE with Vert.x 5: @RabbitConnectionOptions, @QueueExchange, @QueueDefinition, QueueConsumer/QueuePublisher injection, exchange management, queue options (priority, TTL, prefetch), publisher confirms, environment variable overrides, and verticle-scoped connections. Use when adding RabbitMQ messaging, declaring exchanges and queues, creating consumers and publishers, or configuring AMQP topology.
guicedee-persistence
Reactive JPA persistence with Hibernate Reactive 7, Vert.x 5 SQL clients, and Mutiny sessions inside GuicedEE: DatabaseModule setup, persistence.xml configuration, multi-database support, @EntityManager scoping, and environment variable resolution. Use when adding database persistence, configuring Hibernate Reactive, creating DatabaseModule subclasses, wiring Mutiny.SessionFactory, or managing multiple persistence units.
guicedee-openapi
Automatic OpenAPI 3.1 spec generation and serving for GuicedEE with Vert.x 5: scans Jakarta REST resources at startup, serves /openapi.json and /openapi.yaml endpoints, Swagger annotations support, @OpenAPIDefinition configuration, and companion Swagger UI module. Use when generating API documentation, serving OpenAPI specs, or configuring Swagger annotations on REST resources.
guicedee-metrics
Application metrics for GuicedEE using Vert.x 5 Dropwizard Metrics and MicroProfile Metrics 5.1: @Counted, @Timed, @MetricMethod annotations, Guice AOP interceptors, Prometheus scrape endpoint, Graphite reporting, JMX exposure, @MetricsOptions configuration, environment variable overrides, and Vert.x built-in metrics (event bus, HTTP, pools). Use when adding application metrics, configuring Prometheus endpoints, creating custom counters/timers, or monitoring Vert.x internals.
guicedee-mail-client
Annotation-driven SMTP mail client for GuicedEE with Vert.x 5: @MailConnectionOptions for SMTP server configuration, MailService injection for sending text/HTML/multipart emails with attachments, connection pooling, StartTLS/SSL support, DKIM signing, environment variable overrides, and graceful shutdown. Use when sending emails via SMTP, configuring mail connections, or injecting mail services.