If you’re looking to a highly entertaining book, make sure to get your hands on this one. The Author gives a history lesson, an optimistic look on the rapid pace of technology innovation and gives an excellent insight into the future we can expect if present trends continue.

This book will provide a good past history and an idea of what could be coming. I believe this is a must read for serious IT professionals and even business people who want to stay ahead of the competition.

A special thank you to Nicolas Roberge for suggesting me this wonderful reading.

The Big Switch: Rewiring the World, from Edison to Google
Author: Nicholas Carr
Link: http://amzn.to/a7K9EJ

For theses of you who are struggling, like me, trying to deliver
pixel perfect web site. That keeps trying to render exactly the same web page in
IE6, IE7, Firefox, Safari. Then you should take a look at this book.

This book draws a nice history line of CSS. From the dream to the nightmare and
from the nightmare to a possible CSS heaven.

With the arrival of IE8, the author takes you to a tour of CSS2.1 and CSS3, and demonstrates how the table layout can help us design in a more standard way, without the pain caused by the browser’s war.

Author: Rachel Andrew
Publisher: SitePoint
Link to Amazon

Check out this obscure Interface that I’ve found in the Spring API:
org.springframework.aop.framework.Advised

Any AOP proxy obtained from Spring can be cast to this interface to allow manipulation of its AOP advice. With this in mind, you can track down the target object, and get the information you need.

Here’s an example:

Object myBean = yourSpringContext.getBean(beanName);
if(myBean instanceof Advised){
      Advised advised = (Advised) actionBean;
      // Get the target object: The proxied object
      Object myObject = advised.getTargetSource().getTarget();
}

• Clicking more than once on a submit control
• Using Refresh button
• Using the browser back button to resubmit form
• Using Browser history feature and re-submit form.
• Malicious submissions to the server

How this work

The concept basically works around the fact that struts assigns tokens to each page it serves and expecting those token back.

From the book, Sun Core J2EE Patterns:

When that form is submitted, the synchronizer token in the form is compared
to the synchronizer token in the session. The tokens should match the first
time the form is submitted. If the tokens do not match, then the form submission
can be disallowed and an error returned to the user.

On the other hand, if the two token values match, then we are confident that
the flow of control is exactly as expected. At this point, the token value in the session
is modified to a new value and the form submission is accepted.

Struts implementation

The token pattern basically works around the following 3 methods, which can be used within any Action Class:

saveToken(HttpServletRequest req)
The method generates a random token using session id, current time and a MessageDigest and stores it in the session using a key name org.apache.struts.action.TOKEN (org.apache.struts.Globals.TRANSACTION_TOKEN_KEY)

In the JSP, you have to use the token as a hidden form field as follows:
<c:set var=”tokenValue” value=”${sessionScope['org.apache.struts.action.TOKEN']}”
scope=”request” />

<input type=”hidden” name=”<%=org.apache.struts.taglib.html.Constants.TOKEN_KEY%>”
value=”<%= tokenValue %>”>

isTokenValid(HttpServletRequest req)
compares the users session token with the token given as a request parameter through hidden form field.

resetToken(HttpServletRequest req)
removes the token from the session.

Typically when a Struts action is going to forward to a page that will post information the action will call Action.saveToken(HttpServletRequest).

When the client submits the form, the hidden field is also submitted. In the Action that handles the form submission, the token in the form submission is compared with the token in the session by using the isTokenValid() method.  The method compares the two tokens and returns true, if both are same (Be sure to pass reset=”true” in the isTokenValid() method to clear the token from session after comparison).

If the two tokens are equal, the form was submitted for the first time and you can go forward to process the information submitted. However, if the two tokens do not match or if there is no token in the session, then it is a duplicate submission. You should handle it in a way that is acceptable to your users.

Having a traditional cell phone since at least 10 years, switching to a mobile device that have a complete different design concept was a shock at first.

The first question I was asking myself was: “What are you going to do with this, just make some call ?!? Do you really need all that fluff!!” and the geekie answer was obvious: “Hell Ya!!!”

The iPhone is a smart phone and use state of the art technology which is extremely user friendly.

Interactive Voice Mail

The feature I like the most is the voice mail. The time that you need to listen to all your saved voice mails to get to the one that was important is now over. With the IPhone, all the voice messages are displayed like a list of sms (text message). You only need to select the one that you’re interested in and touch play !! Isn’t great!!

Integration with the web

I was searching a phone number in the yellow pages from the Safari web browser.
After some research, I finally found the phone number I was looking for. In the result list, all phone number is an anchor. At my surprise, after clicking the link, the phone asks me if I want to dial it or not!! Wow, that’s a time saver!!!

The user can access the Safari Internet browser which comes with a zoom facility which is activated by the user simply tapping the multi touch screen.

Cool stuff

The iPhone automatically knows when the user lifts the phone to their ear to use and will switch off the display to prevent any touch controls being selected in error and by the fact end your call.

You have the option of moving around all applications icon in the way you want, even span on several screens.

Contact List

Every phone has a contact list that you can manage and configure photo, ring tone and everything. For a single contact, you can enter any phone number, any email, web site and even a photo that you can take on the spot if the person is willing to let you take it.

Again, for the purpose of my post, consider that I use AOP annotations.

Advice Type

Advice comes in many flavours. I will explain in detail and demonstrate the differences that exist between them. Here’s the list that Spring AOP support.

• Before
• After
• After returning
• After throwing
• Around

If defined, this advice will be executed BEFORE the method that has been selected by a pointcut.\

Annotation
@Before(POINTCUT_EXPRESSION OR NAMED_POINTCUT)

Example

// With pointcut expression
@Before(“execution(* com.xyz.service.*(..))”)
public void doMyBeforeAdvice(){
…
}

// With pointcut expression
@Pointcut(“execution(void Spring.MyClass.*Action(..))”)
public void myPointcutExp(){}

@Before(“myPointcutExpr()”)
public void doMyBeforeAdvice(){
…
}

If defined, this advice will be executed AFTER the method that has been selected by a pointcut. This kind of Advice works exactly like the finally in a TRY/CATCH block.
It will be execute regardless of the return condition (normal or exception).

Annotation
@After(POINTCUT_EXPRESSION OR NAMED_POINTCUT)

Example

// With pointcut expression
@After(“execution(* com.xyz.service.*(..))”)
public void doMyAfterAdvice(){
…
}

This kind of advice will only be executed in the case of a successful return (no exception)

Annotation
@After(POINTCUT_EXPRESSION OR NAMED_POINTCUT)
@After(pointcut=”POINTCUT_EXPRESSION OR NAMED_POINTCUT”,
returning=”RETURN_VALUE_PARAM_NAME”)

Example
// With pointcut expression
@ AfterReturning (“execution(* com.xyz.service.*(..))”)
public void doMyAfterReturningAdvice(){
…
}

// With pointcut expression
// pointcut: to associate a pointcut
// throwing: give you access to the actual object returned by the target method
// Using the returning parameter, your advice method must have a parameter
// matching the name of the returning value.
@ AfterReturning (pointcut=”execution(* com.xyz.service.*(..))”,
returning=”retValue” )
public void doMyAfterReturningAdvice(String retValue){
…
}

This kind of advice will only be when a method, which has been selected by a pointcut, throws an exception.

Annotation
@ AfterThrowing (POINTCUT_EXPRESSION OR NAMED_POINTCUT)
@ AfterThrowing (pointcut=”POINTCUT_EXPRESSION OR NAMED_POINTCUT”,
throwing =”EXCEPTION_THROWN”)

Example
// With pointcut expression
@ AfterThrowing (“execution(* com.xyz.service.*(..))”)
public void doMyAfterThrowing Advice(){
…
}

// With annotation parameters
// pointcut: to associate a pointcut
// throwing: give you access to the actual exception object that was thrown
// Using the throwing parameter, your advice method must have a parameter
// matching the name of the throwing value.
@ AfterThrowing (pointcut=”execution(* com.xyz.service.*(..))”,
throwing =”myEx” )
public void doMyAfterThrowingAdvice(String myEx){
…
}

I’m pretty sure; you guessed the meaning of this one. This advice will be executed before and after the method that has been selected by a pointcut. In fact, it’s the only advice that gives you the control over the target method execution. With great power there must also come — great responsibility!

How a single Advice can be called before and after a method ?! Simple !
You have the responsibility to call yourself the target method (See example section).

You must define the first parameter of type ProceedingJoinPoint. This is mandatory when defining an Around advice. From this parameter you’ll be able to execute the proceed() method that will call the target method being advice.

The value return by the Around advice will be the return value for the caller method.

Annotation
@ Around (POINTCUT_EXPRESSION OR NAMED_POINTCUT)

Example
// With pointcut expression
@ Around (“execution(* com.xyz.service.*(..))”)
public void doMyAroundAdvice(ProceedingJoinPoint jp){
…
}

Multiple advices can be selected to perform execution for the same jointpoint at the same time. Two cases can be observe using Spring AOP.

• 2 Advices defined in two DIFFERENT Aspect
  Execution undefined unless the Aspect implements the Ordered interface (org.springframework.core.Ordered) or annotate the Aspect with the Order annotation.

  In this case, the Aspect returning the lower value will have precedence.

• 2 Advices defined in the SAME Aspect
  Execution undefined. The only way to resolve this issue is to fragment the Aspect in two. This way you’ll be able to use the Order mechanism explained above.

Like I said in my post about Core AOP Concepts, Pointcut represent:

An expression that select one or more joint points. In other words, pointcut select joint point that will be advised by an aspect and when the application reaches a join point, advice on that join point may run.

Now, I’ll explain how pointcut actually works and how we can define it.
For the purpose of my post, consider that I use AOP annotations.

Important

Protected and private methods are not intercepted; pointcut will be matched against public methods only!

Pointcut have two important parts that we’ll look in the next points.
POINTCUT_TYPE (EXPRESSION)

POINTCUT EXPRESSION

The pointcut expression is a pattern that will decide which joint point will be select.
The expression is composing of many parts.

POINTCUT_TYPE ([Modifiers?] returnType [ClassType?] MethodName ([Arguments])
[throws ExceptionType]?)

• Modifiers (public, static, …)
• Return Type (void, int , Object, …)
• ClassType (Package, class name)
• Method name
• Input Parameter (..) or (*)
• Throws

Wildcard

In the Arguments part of the expression, theses wildcards can be used:

*: (1) represent exactly one parameter of any kind
.. : (O:N) parameters

In the ClassType part of the expression, theses wildcards can be used:

*: represent anything (com.xyz.service.* [Any joint point in the service package])
.. : represent sub-package (com.xyz.service..* [Any joint point in the service package or a sub-package of service (recursively)])
+: Subtypes (com.xyz.service.MyService+ [Any joint point in MyService class or any subclass of MyService])

Anywhere else you can use these wildcards when permitted
*: represent anything

Chaining expressions

You can chain expressions to combine or narrow the result of the joint point selection, exactly like in a java if statement.

&&: and
||: or
!: Not

POINTCUT TYPE

@pointcut (“POINTCUT_TYPE( EXPRESSION )”)

Pointcut specify the actual join point that should be intercepted/watched. To help us get to the right joint point, many ways are made available to the developer.

Important point: If the execution pointcut expression specifies a declaring class type, the pointcut will only match methods declared in that type, or methods that override methods declared in or inherited by that type.

Example:

execution(void com.xyz.service.MyClass.*())

This pointcut expression will select all method executions for public methods returning void and having no arguments that are either declared in, or inherited by, MyClass, even if those methods are overridden in a subclass of MyClass.

@within: Select joint point that class types have annotation that matches expression.

Example:

within(com.xyz.service.*)

Selection of method joint point within the service package

within(com.xyz.service..*)

Using .. after the service package, will select joint point within the service package or in any sub-package recursively.

Example:

this(com.xyz.service.IAccountService)

Any join point where the proxy implements the IAccountService interface.

@target: Select joint point when the target-object (in our case: the target of the proxy) has an annotation of type expression

Example:

target(com.xyz.service.IAccountService)

Any join point where the target implements the IAccountService interface

@args: Matches joint point where the runtime type of the arguments passed has annotations of type expression.

Example:

args(java.lang.String)

Any join point which takes a single parameter, and, where the argument passed at runtime is a java.lang.String

Important point: This pointcut type work at an instance level

Example:

bean(myBeanName)

Any join point that matches the bean name myBeanName.

Example:

@annotation(org.springframework.transaction.annotation.Transactional)

Any join point method that have a @Transactional annotation

SCHEMA CONFIGURATION

<aop:config>
<aop:pointcut id=”myPointcutName”
expression=”@annotation(com.xyz.annotation.MyAnnotation)”/>
</aop:config>


NAMING A POINTCUT

You can name a pointcut for reuse purpose. The way to do that is simply to declare
a method definition under the pointcut declaration. The method name will be use to refer to that pointcut.

@Pointcut("@within(com.xyz.annotation.MyAnnotation)")
void myTransfertPointcut(){}

@Before(“myTransfertPointcut()“)
private void callMyAdvice(JoinPoint tp){
…
}

It’s the process of inserting aspects logic into the application code at a specific jointpoint.

• Compile time weaving
• Runtime weaving

What about Spring AOP!!

Spring AOP use Runtime weaving and is based on proxies. Spring can generate two kind of proxy:

• JDK Dynamic Proxy (java.lang.reflect.Proxy)
• CGLIB proxy

If the target object implement at least one interface, the JDK Dynamic Proxy will be use and only the methods defined in this interface will be eligible for AOP. In any other case, CGLIB proxy will be use (You’ll need the CGLIB binaries on the classpath).  

How proxy works!!

Method call without proxy.

Method call with proxy.

Configuration

When you declare AOP configuration, JDK Dynamic Proxy, will be use by default when declaring

<aop:config> or <aop:aspectj-autoproxy/> tag

You can always force Spring to use CGLIB proxy simply be adding an
attribute to the <aop:config> tag.

<aop:config proxy-target-class="true" >
. . .
</aop:config>

If you using the AOP annotations use

<aop:aspectj-autoproxy proxy-target-class="true" >

I will define some key AOP concepts to give you a good comprehension that will help you all along my future articles on this subject. However these terms are not Spring specific and really belong to AOP.

• Well-defined point in the execution of an application
• The point where you can insert additional logic to be execute
• Examples of Jointpoint’s
  • Method invocation
  • Exception being thrown
  • Field modification

In Spring AOP a jointpoint always represents a method execution.

Expression that select one or more jointpoints.
In other words, pointcut select jointpoint that will be advised by an aspect and when the application reaches a joinpoint, advice on that joinpoint may run.

Example:

In a class containing different methods, each method have a jointpoint. Pointcut can select all jointpoint that match get*. In this example, all getter method will be advise.

Spring AOP use the AspectJ pointcut expression language.

Code that will be executed at a jointpoint that has been selected by a pointcut.

Types of Advice

• Before advice, this executes before joinpoint
• After advice, this executes after joinpoint
• Around advice, this executes around joinpoint

Aspect

Module that encapsulate pointcuts and advices

Summary

Advice: what & when apply advice code
Poincut: where apply advice (jointpoint selection)
Jointpoint: potential target

However, generic functionalities like logging, security or even transactions are often needed in many places in the application. We can state that those functionalities cross-cut the application, and impact a lot of classes.
The problem

Cross-cutting concerns cannot be captured cleanly inside a single abstraction, and cannot even be reused. Therefore, we’re forced to write the same code over and over again (most of the time we simply copy and paste the code, and slightly adapting it to the context). By doing this, it’s clear that we’re failing to modularize our application, introducing code duplication (ex. logging) and coupling of concerns (ex. security check in an account method).

Of course, the code that handles these concerns can be added to each class separately, but wouldn’t that violates the principle that each class has well-defined responsibilities?

Enter AOP

AOP defines a new programming dimension, called an aspect. Aspects are used to capture cross-cutting functionalities in a separate programmatic entity.

AOP helps to modularize cross-cutting concerns and eliminates coupling and code duplication. With these aspects out of the way, developers can focus on core problems.

Examples of cross-cutting concerns

• Logging & Tracing
• Transaction management
• Security
• Caching
• Locking
• Event handling