« overload

Spring uses Apache commons-logging as a bridge between different logging implementations.
This way you can change from a logging framework to any other supported loggin mechanism at any time.

The org.springframework.beans.factory.config.CommonsLogFactoryBean will create a "logger bean" and his type will depends on your configuration.

Example for the Log4j implementation:

In your application context, add a CommonsLogFactoryBean and give it a logName.

In your web.xml, add the org.springframework.web.util.Log4jConfigListener listener before the
org.springframework.web.context.ContextLoaderListener

Here, my log4j config is locatedin the WEB-INF/log4j.properties and here is its content:

To make use of your logger in your other beans, add a member variable of type org.apache.commons.logging.Log
and configure Spring to inject the reference to the logger bean. For my part, I choose to do it through annotations because I don't want to have to make this reference in all my beans...
So, in your application context, add the

tag to enable the annotations config.In the targets beans, annotate the member variable as follow:

This little snippet will show you how to get Hibernate Statistics JMX MBean available.

Inside the tomcat startup script (bin/tomcatXw.exe), ensure that the following JAVA_OPTS are set:

JAVA_OPTS="
-Dcom.sun.management.jmxremote.port=9002
-Dcom.sun.management.jmxremote.authenticate=false
-Dcom.sun.management.jmxremote.ssl=false
-Djava.awt.headless=true"

In your Spring config, add:

and then set the hibernate.generate_statistics property:

When you browse the MBeans (using JConsole.exe - which lives in the bin dir of your JDK 1.5 distribution), you should see Hibernate, if you double click on that node, you should see the Statistics Bean.

 

I'll try to explain how it can be easy to create an email service class that uses Spring and Velocity to send mails.
First of all, what do you need in your classpath?

• activation.jar
• mail.jar
• spring.jar
• velocity.jar

I'm using Spring 2.5 and Velocity 1.5.

Pages: 1 2 3 4 5 6 7

Let's say you have a message driven bean in which you want to inject spring beans.

Add an interceptor

Annotate your MDB with the @Interceptors and specify SpringBeanAutowiringInterceptor.class as interceptor. This is an EJB3-compliant interceptor class that injects Spring beans into fields and methods which are annotated with @Autowired. Performs injection after construction as well as after activation of a passivated bean.
The actual BeanFactory to obtain Spring beans from is determined by the getBeanFactory(java.lang.Object) template method. The default implementation obtains the Spring ContextSingletonBeanFactoryLocator, initialized from the default resource location classpath*:beanRefContext.xml, and obtains the single ApplicationContext defined there.
(for more info, see doc)

Pages: 1 2 3

It is now possible to configure Spring's dependency injection with annotations. This means that annotations can be used in Spring to mark fields, methods and classes that need dependency injection. Spring also supports auto-wiring of the bean dependencie. Annotations can also be used to indicate fields that are to be auto-wired. Furthermore, auto-detection of annotated components in the classpath is also supported now. When these capabilities are combined, the amount of configuration and dependency mapping in the Spring configuration files is reduced drastically.

Pages: 1 2 3 4 5

Spring could be an alternative to expose Mbeans (see Spring doc).
The JMX support in Spring provides you with the features to easily and transparently integrate Spring application into a JMX infrastructure.

Specifically, Spring's JMX support provides four core features:

• The automatic registration of any Spring bean as a JMX MBean
• A flexible mechanism for controlling the management interface of your beans
• The declarative exposure of MBeans over remote, JSR-160 connectors
• The simple proxying of both local and remote MBean resources

Pages: 1 2 3 4 5

Apache Tiles is a templating framework built to simplify the development of web application user interfaces.

Requirements

To use Tiles in your application you need:

• a Java Runtime Environment following the Java SE 5.0 specifications;
• a servlet container that supports Servlet 2.4 (or above) and JSP 2.0 (or above).

Pages: 1 2 3 4

Introduction
The aspect-oriented programming (AOP) paradigm attempts to help programmers in the separation of concerns, specifically cross-cutting concerns, as an advance in modularization that comes beside the OO paradigm.

Examples of these "cross-cutting concerns" can be:

• Security
• Transactions
• Logging
• etc.

With the traditional OO approach, these functions have to be implemented in each concerned class (even through method calls) which makes maintenance and evolution not easy.

Pages: 1 2 3 4 5 6

Symfony is an open source web application framework for PHP5 projects. As a framework, it aims to speed up the creation and maintenance of web applications, and to replace the repetitive coding tasks by power, control and pleasure.

Main features

• PHP5 (OO)
• MVC pattern
• Follows the RAD paradigm
• Database agnostic
• ORM layer built on propel
• Internationalization layer
• YAML config files
• Built-in forms validation/repopulation
• Cache management
• Authentication and credential features
• URL rewriting
• Built-in paging, sorting and filtering features
• Plug-ins system
• Ajax ready

The purpose here is not to replace the very complete documentation of Symfony. It's just a kind of "roadmap summary" of what I'have done until now with Symfony.

Installation

Thanks to the large documentation of Symfony, the installation has been very easy on my Linux Gentoo (PHP 5.2.1):

1. Install Symfony core

As I can't use pear on my server, I downloaded the latest version trough SVN:

[[code]]JCBzdm4gY28gaHR0cDovL3N2bi5zeW1mb255LXByb2plY3QuY29tL2JyYW5jaGVzLzEuMCAu[[/code]]

(and that's it!)

2. Setting up a new project

Symfony consists of a hierarchy of 3 pieces:

• a project
• application(s)
• modules

2.1 Create the project

[[code]]Jmd0OyBta2RpciB+L215cHJvamVjdA0KDQomZ3Q7IGNkIH4vbXlwcm9qZWN0DQoNCiZndDsgcGhwIC9wYXRoL3RvL3N5bWZvbnkvZGF0YS9iaW4vc3ltZm9ueSBpbml0LXByb2plY3QgbXlwcm9qZWN0[[/code]]

Symfony will create a (quiet explicit) directory structure that looks like this:

[[code]]YXBwcy8NCg0KYmF0Y2gvDQoNCmNhY2hlLw0KDQpjb25maWcvDQoNCmRhdGEvDQoNCmRvYy8NCg0KbGliLw0KDQpsb2cvDQoNCnBsdWdpbnMvDQoNCnRlc3QvDQoNCndlYi8=[[/code]]

2.2 Create the application

[[code]]Jmd0OyBzeW1mb255IGluaXQtYXBwIG15YXBw[[/code]]

This will create a [

] directory in the [

] folder of the project root, with a default application configuration and a set of directories ready to host the file of your website:

[[code]]YXBwcy8NCg0KbXlhcHAvDQoNCmNvbmZpZy8NCg0KaTE4bi8NCg0KbGliLw0KDQptb2R1bGVzLw0KDQp0ZW1wbGF0ZXMvDQoNCg==[[/code]]

Some PHP files corresponding to the front controllers of each default environment are also created in the project [

] directory:

[[code]]d2ViLw0KDQppbmRleC5waHANCg0KbXlhcHBfZGV2LnBocA0KDQo=[[/code]]

[

] is the production front controller of the new application. To run your application in the development environment, call the front controller [

].

Set up your Apache config:

[[code]]Jmx0O1ZpcnR1YWxIb3N0ICo6ODAmZ3Q7DQoNCiAgU2VydmVyTmFtZSBteWFwcC5leGFtcGxlLmNvbQ0KDQogIERvY3VtZW50Um9vdCAiL2hvbWUvc3RldmUvbXlwcm9qZWN0L3dlYiINCg0KICBEaXJlY3RvcnlJbmRleCBpbmRleC5waHANCg0KICBBbGlhcyAvc2YgLyRzZl9zeW1mb255X2RhdGFfZGlyL3dlYi9zZg0KDQogICZsdDtEaXJlY3RvcnkgIi8kc2Zfc3ltZm9ueV9kYXRhX2Rpci93ZWIvc2YiJmd0Ow0KDQogICAgQWxsb3dPdmVycmlkZSBBbGwNCg0KICAgIEFsbG93IGZyb20gQWxsDQoNCiAgJmx0Oy9EaXJlY3RvcnkmZ3Q7DQoNCiAgJmx0O0RpcmVjdG9yeSAiL2hvbWUvc3RldmUvbXlwcm9qZWN0L3dlYiImZ3Q7DQoNCiAgICBBbGxvd092ZXJyaWRlIEFsbA0KDQogICAgQWxsb3cgZnJvbSBBbGwNCg0KICAmbHQ7L0RpcmVjdG9yeSZndDsNCg0KJmx0Oy9WaXJ0dWFsSG9zdCZndDs=[[/code]]

2.3 Create a module skeleton

To add a [

] module to this application, type the following commands:

[[code]]Jmd0OyBjZCB+L215cHJvamVjdA0KDQomZ3Q7IHN5bWZvbnkgaW5pdC1tb2R1bGUgbXlhcHAgbXltb2R1bGU=[[/code]]

I just want to point this strong open source framework that saves a lot of time for tables sorting, paging and exporting data. The integration is very simple and you can easily customize it and extend it with decorators. Just have a look at displaytag