Group items tagged

summary of templates used by the generator depending on the kind of Java class it encounters:

these templates are bundled in the granite-generator.jar archive, in the org.granite.generator.template package and accessible as resources via the class loader

class: protocol is used because all standard templates are available in the classpath

Alternatively, you may use the file: protocol to load your template from the filesystem. These templates can be specified either by using absolute paths (eg. file:/absolute/path/to/mytemplate.gsp) or paths relative to your current Eclipse project root directory (eg. path/to/mytemplate.gsp).

ActionScript 3 generator is able to write AS3 typed client proxies for exposed remote services

Compared to the usual Flex RemoteObject, this can greatly help development by bringing

in Flex when using remote services.

replicate validation annotations in order to use the Flex side validation framework

 Known Limitations

Gas3 does not support inner classes

must declare your classes in separated source files if you want them to be correctly handled by the generator

resource (door, file, customer record, etc)

define a permission to any depth

Permissions Defined

Permissions represent what can be done in your application

A well formed permission describes a resource types and what actions are possible when you interact with those resources

Roles Defined

Roles are effectively a collection of permissions

Explicit Roles

An explicit role has permissions explicitly assigned to it and therefore is an explicit collection of permissions

Implicit Roles

Annotation Authorization

@RequiresPermissions(“account:create”)‏

Permission Check

Both Acegi as well as SAF use AspectJ and Spring AOP for Policy Enforcement

JBoss Seam follows a different process when implementing Policy Decision functionality and sets access rules with the help of JBoss Rules [13] the JBoss rules engine

access decision to the domain objects in an application can be based on any number of complex rules

@Restrict annotations

07.2007

15.6.1.1. What is a role? A role is a group, or type, of user that may have been granted certain privileges for performing one or more specific actions within an application

used to create logical groups of users for the convenient assignment of specific application privileges

15.6.1.2. What is a permission? A permission is a privilege (sometimes once-off) for performing a single, specific action. It is entirely possible to build an application using nothing but permissions, however roles offer a higher level of convenience when granting privileges to groups of users

consisting of three "aspects";

An empty @Restrict implies a permission check of componentName:methodName

implied permission required to call the delete() method is account:delete

equivalent of this would be to write @Restrict("#{s:hasPermission('account','delete')}")

@Restrict annotation may reference any objects that exist within a Seam context. This is extremely useful when performing permission checks for a specific object instance.

selectedAccount

selectedAccount

 Identity.instance().checkRestriction

If the expression specified doesn't evaluate to true, either if the user is not logged in, a NotLoggedInException exception is thrown or if the user is logged in, an AuthorizationException exception is thrown.

for GraniteDS users keeping their Java domain model and ActionScript3 domain model in sync via Gas3, the constraints are kept in sync

a couple of gotchas to be aware of

the constraint implementation is in the same class as the constraint declaration (not a problem in a dynamic language) @Pattern has a sightly different semantic because the regexp engine in Flex is a bit different. instead of the features provided by ConstraintValidatorContext, you can define a properties attribute in your constraints to make it belong to several sub-properties. not as flexible but good enough in many cases.

The discussion whether or not to use Spring vs. Java EE for new enterprise Java applications is a no-brainer

Why migrate?

since then fallen a prey to the hungry minds of Venture Capitalists and finally into the hands of a virtualization company called VMware

While the different companies and individuals behind the Spring framework have been doing some work in the JCP their voting behavior on important JSRs is peculiar to say the least

outdated ORM solution like JDBC templates

some developers completely stopped looking at new developments in the Java EE space and might have lost track of the current state of technology

size of the deployment archive

fairly standard Java EE 6 application will take up about 100 kilobytes

comparable Spring application weighs in at a whopping 30 Megabytes!

Lightweight

Firing up the latest JBoss AS 7 Application Server from scratch and deploying a full blown Java EE 6 application into the server takes somewhere between two and five seconds on a standard machine. This is in the same league as a Tomcat / Spring combo

Dependency injection

Java EE 6, the Context and Dependency Injection (CDI) specification was introduced to the Java platform, which has a very powerful contextual DI model adding extensibility of injectable enterprise services

Aspect Oriented Programming

“AOP Light” and this is exactly what Java EE Interceptors do

common pitfall when taking AOP too far is that your code might end up all asymmetric and unreadable. This is due to the fact that the aspect and its implementation are not in the same place. Determining what a piece of code will do at runtime at a glance will be really hard

Testing

With Arquillian we can get rid of mocking frameworks and test Java EE components in their natural environment

Tooling

capabilities comparison matrix below to map Spring’s technology to that of Java EE

Capability Spring JavaEE Dependency Injection Spring Container CDI Transactions AOP / annotations EJB Web framework Spring Web MVC JSF AOP AspectJ (limited to Spring beans) Interceptors Messaging JMS JMS / CDI Data Access JDBC templates / other ORM / JPA JPA RESTful Web Services Spring Web MVC (3.0) JAX-RS Integration testing Spring Test framework Arquillian *