Please contact me if you have any comments, doubts, or any kind of feedback. Send an email to: marcelog@gmail.com

Checkout the api (phpdoc) at: http://marcelog.github.com/Ding/php-doc/html/index.html

In the homepage, you can find the user manual: http://marcelog.github.com/Ding

Ding is also the winner of the 2011 Binpress programming contest :)

See these articles for a complete application example:

• http://marcelog.github.com/articles/php_applications_with_doctrine2_orm_and_ding_di_container.html
• http://marcelog.github.com/articles/php_asterisk_listener_example_using_pami_and_ding.html
• Some more articles can be found here http://marcelog.github.com/articles/articles.html

Supported Dependency Injection annotations:

• JSR-250: @PostConstruct, @PreDestroy, @Resouce
• JSR-330: @Inject, @Named, @Singleton
• Spring specific: @Configuration, @Primary, @Value, @Scope, @Component, @Aspect, @Required, @Bean, @Controller, @RequestMapping
• Own specific: @Prototype, @InitMethod, @DestroyMethod, @ListensOn, @MethodInterceptor, @ExceptionInterceptor

You can now easily install Ding by issuing:

or

just replace 1.6.3 by the release version you'd like to install :) See: http://pear.marcelog.name/

• XML
• YAML
• Annotations (like JSR 250 and 330)

Remember that using annotations is completely optional. Not using them will benefit performance. Annotations CAN be cached. Use the 'annotations' cache with any of the implementations below ;)

See these: http://marcelog.github.com/articles/ding_component_bean_annotations.html http://marcelog.github.com/articles/ding_component_bean_annotations_di_dependency_injection.html

• @Configuration and @Bean just like Java Configuration. So you dont even need a beans.xml (@Scope, @InitMethod, @DestroyMethod) for this annotated bean definitions.
• @Component (used in classes, supports same annotations as @Bean)
• @Required
• @Resource
• @Named
• @Inject
• @Singleton
• @Prototype
• @Scope
• @PostConstruct
• @PreDestroy
• @Value
• @Bean
• @Primary
• @Controller (When using the MVC through http).
• @RequestMapping (When using the MVC through http).
• @InitMethod(method=xxx)
• @DestroyMethod(method=xxx)
• @Aspect for classes and @ExceptionInterceptor/@MethodInterceptor for methods.
• @ListensOn

Ding supports this cache implementations out of the box.

• APC.
• File.
• Zend Cache.
• Memcache through memcached php extension (needs libmemcached).
• DUMMY.

• Import other beans.xml files anywhere inside your already existant files. This let you split your beans among several configuration files.
• Setter injection (php evaluated code, arrays, values, and/or references to other beans).
• Constructor injection (php evaluated code, arrays, values, and/or references to other beans).
• Method injection (ala spring lookup-method) allows you to have singletons that can deliver prototypes scoped beans.
• A bean can be: singleton or prototype (multiple instances).
• Can create beans by specifying a static method of the bean class itself.
• Can create beans by specifying another bean (and its method) as a factory.
• Properties for your beans.xml, like: ${log.dir}/alog.log. You can also have the container setup any php options by specifying a property with the name "php." (i.e: php.date.timezone).
• Optional init-method will be called right after assembling a bean. (Can also be specified via the @InitMethod(method=xxx) annotation).
• Optional destroy-method will be called when the container is shutting down. (Can also be specified via the @DestroyMethod(method=xxx) annotation).
• Supports bean inheritance, via OOP and via xml and yaml definitions.
• Supports bean aliasing, via xml, yaml, and annotations.

IContainerAware: Whenever ding is going to instantiate a bean whose class implements IContainerAware interface, it will inject the container instace to this bean.

IBeanNameAware: Whenever ding is going to instantiate a bean whose class implements IBeanNameAware interface, it will inject the bean name.

IAspectManagerAware: Whenever ding is going to instantiate a bean whose class implements IAspectManagerAware interface, it will inject the current instance of the aspect manager (giving the ability to inject pointcuts, aspects, and general aop management).

IResourceLoaderAware: Whenever ding is going to instantiate a bean whose class implements IResourceLoaderAware interface, it will inject the instance of the resource loader in use, which is usually the container itself.

ILoggerAware: Whenever ding is going to instantiate a bean whose class implements ILoggerAware interface, it will inject the instance of the logger (log4php) in use by the container, so you can log there. The returned logger will be of class CLASS (where \ are replaced with .).

IReflectionFactoryAware: Whenever ding is going to instantiate a bean whose class implements IReflectionFactoryAware interface, it will inject the instance of the reflection factory in use.

You can easily hook in the bean lifecycle by just implementing one of:

• Ding\Bean\Lifecycle\IAfterDefinition
• Ding\Bean\Lifecycle\IBeforeCreate
• Ding\Bean\Lifecycle\IAfterCreate
• Ding\Bean\Lifecycle\IBeforeAssemble
• Ding\Bean\Lifecycle\IAfterAssemble
• Ding\Bean\Lifecycle\IAfterConfig This will allow you to extend the container functionality as much as you like :)

If you want to provider beans yourself, just have a bean implement the Ding\Bean\IBeanDefinitionProvider interface, it will automatically be registered in the container and will be called whenever a new bean definition is demanded.

If you want to provide aspects and pointcuts, just implement one or all of:

• Ding\Aspect\IAspectProvider
• Ding\Aspect\IPointcutProvider

The container natively supports events. This means that you can register beans (either programatically or via the xml, yaml, or annotations drivers) and then asynchronously trigger (dispatch) these events along some data object. The container will then instantiate the needed beans (the listeners) and notify them. Please see docs/examples/events for an example using xml, yaml, and annotations.

Aspects work via an implementation of the interceptor pattern. There are 2 available interceptors, both of them available in xml, yaml, and annotation drivers.

• Method: Use this one to be called before every method execution (use proceed() to continue the chained execution), resuming your own afterwards.

• Exception: Use this one to be called when an aspected method throws an exception.

• Can apply aspects to parent classes

The mvc is work in progress, but you can sneak peek it in docs/examples/mvc. You will need a rewrite rule, like (for lighttpd):

url.rewrite-if-not-file = ( ".?(.)$" => "/example.php?$1", "" => "/example.php" )

For Apache: RewriteRule ^(.*)$ /example.php/$1

The example is mapped to /Some/Mapped/Path/MyController/some (hint: try it with ?optional=value). If you press the button, the form will be submitted and handled by another action that will print the same data, but now for the post instead of the initial get.

Also, if you want to trigger an exception to see the exception handler in action, point your browser to: /Some/Mapped/Path/MyController/someException

To try a redirect (no view render, just headers sent), point your browser to /Some/Mapped/Path/MyController/redirect This uses an http header 302.

To try an internal redirect (forward), point your browser to /Some/Mapped/Path/MyController/forward. This will internally forward the request to another controller/action.

To try annotated controllers (see below), point your browser to /Some/Mapped/Path/MyAnnotatedController/an.

You can use @Controller and @RequestMapping in your classes and not declare them in beans.xml file. see docs/examples/mvc/annotatedController

You can also use Twig to render the views. see docs/examples/mvc-twig You can also use Smarty to render the views. see docs/examples/mvc-smarty

You can hook before dispatching a request to a controller and also after. A dispatcher will chain all preHandle() and postHandle() from all the IHandlerInterceptor you configure.

A preHandle() interceptor returning true will continue the chain execution. To stop the chained execution, false can be returned, and also a ModelAndView (thus, triggering redirects, view renders, etc).

You can use the helper TCPClientHelper as just another bean. Via callbacks and combining the helpers for error and signal handling, you can easily create a very complete tcp client, using non blocking sockets. Available callbacks:

• Before the connection.
• As soon as the connection establishes
• If the connection failed because of a timeout.
• When data is available to be read.
• When the connection is closed by either one of the peers.

You can specify the connection timeout, the read timeout (both in milliseconds) and the minimum needed bytes in the socket before considering it as available data to be read.

see docs/examples/tcp for an example of use.

You can use the helper TCPServerHelper as just another bean. Via callbacks and combining the helpers for error and signal handling, you can easily create a very complete tcp server, using non blocking sockets. Available callbacks:

• Before opening the socket.
• Before binding and listening the socket.
• As soon as a connection establishes or closes.
• When data is available to be read.
• When the connection is closed by either one of the peers.
• When there is a read timeout on any of the clients.

You can specify the connection timeout, the read timeout (both in milliseconds) and the minimum needed bytes in the socket before considering it as available data to be read.

This helper integrates PAMI (https://github.com/marcelog/PAMI) with Ding, offering a quick, easy, and effective way to access and manager asterisk installations via the asterisk manager interface (ami).

This helper integrates PAGI (https://github.com/marcelog/PAGI) with Ding, offering a quick, easy, and effective way to make agi (Asterisk Gateway Interface) applications (PrePaid systems, voicemail's, etc).

See: docs/examples/pagi

In order to run the example, you need something like this in your dialplan:

[default] exten => _X,1,AGI(/tmp/Ding/docs/examples/pagi/run.sh,a,b,c,d) exten => _X,n,Hangup

• build.xml is a phing build file, not ant.
• It's very possible that you may need to edit build.properties.
• Available main targets: all, build, test, report.
• Tools run: phpdoc, phploc, phpcs, phpmd, phpcpd, phpdepend, phpunit.
• Setup your installation by editing pear and php paths in build.properties
• Run phing install-dependencies this will install pear and everything needed to run ding tests and metrics.
• Run phing all

You need log4php (http://logging.apache.org/log4php/). Just make sure you copy it to the include_path and Ding will pick it up from there.

• Try to have small include paths. Ding will use the include path for finding resources and autoload your own classes.
• Configure the rootLogger and ding logger in ERROR level.
• If your code is running on the php module for apache or iis, use apc for all the cache subsytems. Otherwise, use memcached or file.
• Do not use annotations at all. Only use the XML or even better, YAML.
• If you are using annotations (good for you! just dont abuse ;)) use the annotations cache with apc or memcached or file (in that order).
• Do not abuse the aop feature.