I am super proud to announce our newest member of the ColdBox Platform: WireBox.
WireBox is our new addition to the family. It is our enterprise dependency injection and AOP framework for ColdFusion 8 and above. This project has been part of ColdBox since its early version 2.0 releases but now it has been released as a standalone framework that can be used in any ColdFusion application. WireBox's inspiration has been based on the idea of rapid workflows when building object oriented ColdFusion applications, programmatic configurations and simplicity. With that motivation we introduced dependency injection by annotations and conventions, which has been the core foundation of WireBox. We have definitely been influenced by great DI projects like Google Guice, Grails Framework, Spring and ColdSpring so we thank them for their contributions and inspiration.
Here are a simple listing of features WireBox brings to the table that set it apart from any other ColdFusion dependency injection framework:
- Professional open source project with world class support, architecture, design and development services via Ortus Solutions.
- Annotation driven dependency injection
- 0 configuration mode or a programmatic binder configuration approach via ColdFusion (No XML!)
- Creation and Wiring of or by:
- ColdFusion Components
- Java Classes
- RSS Feeds
- WebService objects
- Constant values
- DSL string building
- Factory Methods
- Multiple Injection Styles:
- Automatic Package/Directory object scanning and registration
- Multiple object life persistence scopes:
- No Scope (Transients)
- Request Scoped
- Session Scoped
- Application Scoped
- Server Scoped
- CacheBox Scoped
- Integrated logging via LogBox, never try to figure out what in the world the DI engine is doing
- Parent Factories
- Factory Method Object Creations
- Object life cycle events via WireBox Listeners/Interceptors
- Built in adapters for integrating:
- ColdSpring 2
- Autowiring Injection DSL
- Customizable injection DSL
- Create your own injection DSL annotations
- WireBox object providers to avoid scope-widening issues on time/volatile persisted objects
- When requesting an instance you can pass a structure of arguments to passthrough to the object's constructor when initialized.
WireBox alleviates the need for custom object factories or manual object creation in your ColdFusion applications. It provides a standardized approach to object construction and assembling that will make your code easier to adapt to changes, easier to test, mock and extend. As software developers we are always challanged with maintenance and one ever occurring annoyance, change.
Therefeore, the more sustainable and maintainable our software, the more we can concentrate on real problems and make our lives more productive. WireBox leverages an array of object, function, and property metadata annotations to make your object assembling, storage and creation easy as pie! We have leveraged the power of event driven architecture via object listeners or interceptors so you can extend not only WireBox but the way objects are analyzed, created, wired and much more. To the extent that our AOP capabilities are all driven by our AOP listener which decouples itself from WireBox code and makes it extremely flexible. We have also seen the value of a central location for object descriptions and behavior so we created our very own WireBox Programmatic Mapping DSL (Domain Specific Language) that you can use to define object construction and relationships in pure ColdFusion (No XML!). WireBox has been running and powering mission critical ColdFusion applications since 2009 and now you can too. We truly hope you enjoy WireBox!