@Kevin: What I liked about Programming Pearls is that it teaches by example how the first solution that comes to mind can always be improved a *lot*.

I’m not sure how relevant this is after Burt’s very helpful suggestion, but I noticed that your second code snippet is exactly the same as the first. You meant to include some code from SecurityConfig.groovy there, right?

–Matt

There are now a huge number of frameworks offering the use of annotations for configuration (Hibernate, Spring, JAX-WS etc.) Use all their annotations and your domain objects will be decorated like the outside of a Minnesotan house at Christmas (visit Minnesota any December to find out just how garish that is). Not only does it obscure the code rather than enhancing it, it means that code is changed much more frequently than it should.

Annotations should be intrinsically meaningful to the objects they adorn, so that any code you write can make intelligent use of them, or they should be meaningful in contexts so widely understood that their purpose will not be lost . This often means that the only useful annotations are those meaningful to the Java compiler, but other annotations can be valid *if* the annotated object will only be used in a context where those annotations are universally understood. Security for Grails controllers is a good candidate for the second, but since the use of annotations for security isn’t part of the Grails core, which would encourage every security-plugin developer to adopt a single standard, they fail.

The whole Java world and their pets seem to be gleefully ignoring this and adopting annotation-based configuration like crazy. It’s wrong, it will bite them and maybe they’ll learn.

”
Stick to Java as you will face problems related to data type.

Eg: Can you tell me what types are passed here in the function argument

public void runMyFunc(dob, favy)
{

}
”

While your argument is one that I would agree with (loss of legibility due to lack of types) Scala does not suffer from this problem - your example would have to look something like the following:

def runMyFunc(dob: Date, favy: Int) {}

Looks pretty statically typed to me!

Later you make this comment:

”
What is this type-safe way they mentioned? you know better
”

Exactly *what* are you talking about? Do you have a different definition of type safety than everybody else? Perhaps it would interest you to know that Scala is *more* strict about types than is Java.

Next time use The Google. It is your friend.

This is used to secure URL patterns that can’t be annotated, i.e. static resources (JavaScript, CSS, etc.) and controllers that you can’t edit for whatever reason:

controllerAnnotationStaticRules = [
'/blurb/**': ['ROLE_ADMIN'],
‘/setting/**’: ['ROLE_ADMIN']
]

This has the advantage over the filter approach of being fully integrated into the plugin and Spring Security, in that when navigating to a secured controller the requested URL will be remembered, and after a successful login you’ll be redirected to that URL.