Apache DeltaSpike

Apache DeltaSpike is a collection of portable CDI (Contexts and Dependency Injection) extensions. It provides a core module and several optional modules that add enterprise functionality to Java projects. Because they are 'portable' extensions, they can be used with any spec-compliant CDI implementation, such as JBoss Weld or Apache OpenWebBeans.

Key capabilities include:

• Enhanced Security: Type-safe control over method invocations via annotations.
• Transaction Management: Support for transactions in non-EJB beans (including JTA and resource-local transactions).
• New CDI Scopes: Adds scopes like TransactionScoped, WindowScoped, ViewScoped, ViewAccess, and Grouped conversation scope.
• Java SE Support: Provides boot and shutdown control for CDI containers in Java SE environments.
• JSF Improvements: Multi-window handling, type-safe view configurations, and JSF event broadcasting to CDI.
• Productivity Tools: JMX integration for CDI beans, type-safe i18n messages, and a Data module for entity framework/JDBC support.

The Data module implements the Repository pattern to simplify the repository layer in Java applications. It reduces boilerplate code by allowing developers to define interfaces that automatically handle query logic.

Key capabilities include:

• Method Name Translation: Automatically generating queries from method names (e.g., findByAgeBetween).
• JPQL Queries: Executing custom JPQL strings via annotations.
• Named Queries: Executing pre-defined JPA named queries.
• Automatic Implementation: The CDI extension provides the implementation at runtime, so clients only need to depend on the interface.

@Repository
public interface PersonRepository extends EntityRepository<Person, Long>
{
    List<Person> findByAgeBetweenAndGender(int minAge, int maxAge, Gender gender);

    @Query("select p from Person p where p.ssn = ?1")
    Person findBySSN(String ssn);

    @Query(named=Person.BY_FULL_NAME)
    Person findByFullName(String firstName, String lastName);
}

DeltaSpike JSF module supports several modes for handling multiple browser windows/tabs to enable window-specific scopes:

• CLIENTWINDOW: Uses an intermediate windowhandler.html page to manage windowId. It covers most edge cases but may cause 'flickering'.
• LAZY: Appends windowId to URLs. It avoids a loading screen but can lead to unintentional scope destruction if two tabs share a windowId during a lazy check.
• NONE: Disables window detection. Scopes like @WindowScoped or @ViewAccessScoped will not work.
• DELEGATED: Delegates handling to the JSF 2.2 ClientWindow API.
• CUSTOM: Allows providing a custom org.apache.deltaspike.jsf.spi.scope.window.ClientWindow implementation.

To switch the mode, provide a @Specializes implementation of JsfModuleConfig and override getDefaultWindowMode().

@Specializes
public class MyJsfModuleConfig extends JsfModuleConfig
{
    @Override
    public ClientWindowConfig.ClientWindowRenderMode getDefaultWindowMode()
    {
        return ClientWindowConfig.ClientWindowRenderMode.LAZY;
    }
}

The Simple Interceptor-style API allows you to secure methods using a custom binding annotation. This approach loosely couples the secured method to a predicate method (the authorizer) using @SecurityBindingType.

Workflow:

1. Create a binding annotation: Define an annotation annotated with @SecurityBindingType.
2. Create an authorizer: Create a CDI bean with a method annotated with @Secures and your custom binding annotation. This method returns a boolean indicating if access is granted.
3. Apply to methods/classes: Annotate your business methods or classes with the binding annotation.

Advanced Features:

• Parameter Binding: Use @SecurityParameterBinding on a custom annotation to inject specific method arguments into your authorizer method.
• Return Value Binding: Use @SecuredReturn to perform authorization checks after the method has executed, based on its return value.

// 1. Create binding
@SecurityBindingType
public @interface UserLoggedIn {}

// 2. Create authorizer
@ApplicationScoped
public class LoggedInAuthorizer {
    @Secures
    @UserLoggedIn
    public boolean doSecuredCheck(InvocationContext ctx, Identity identity) {
        return identity.isLoggedIn();
    }
}

// 3. Secure method
@UserLoggedIn
public void doSomething() { ... }

// Using Parameter Binding
@SecurityParameterBinding
public @interface CurrentThing {}

@Secures
@UserLoggedIn
public boolean doSecuredCheck(..., @CurrentThing Thing thing) {
    return thing.hasMember(identity);
}

DeltaSpike Data can translate method names into JPQL queries. The method name must follow a specific pattern: (Prefix)(Property)(Comparator).

Supported Prefixes

• findBy... (or findOptionalBy, findAnyBy, findAll, findFirst, findTop)
• removeBy... (or deleteBy)
• countBy... (returns int or long)

Supported Comparators

Advanced Features

• Ordering: Use OrderBy[Property][Asc|Desc] (e.g., findByLastNameOrderByAgeAsc).
• Limits: Use findFirst[N] or findTop[N] (e.g., findTop20OrderByLastNameDesc).
• Nested Properties: Use an underscore _ to traverse nested properties (e.g., findByCompany_companyName).
• Custom Prefixes: Change the prefix via @Repository(methodPrefix = "...").

@Repository
public interface PersonRepository extends EntityRepository<Person, Long>
{
    // Complex query via name
    List<Person> findByNameLikeAndAgeBetweenAndGender(String name, int minAge, int maxAge, Gender gender);

    // Ordering and Limits
    List<Person> findTop2ByLastNameOrderByAgeAscLastNameDesc(String lastName);

    // Nested properties
    List<Person> findByCompany_companyName(String companyName);
}

A repository can be an abstract class or an interface marked with the @Repository annotation. You must specify the entity it relates to using the forEntity attribute.

Using Interfaces

Interfaces are the most common way to define repositories. You can extend base types like EntityRepository to gain common CRUD operations.

Using Abstract Classes

Use abstract classes if you need to implement custom logic using the typedQuery method provided by AbstractEntityRepository.

Note: Annotations on interfaces do not inherit. If you create a base interface with annotations, concrete implementations must re-apply them.

// Interface approach
@Repository(forEntity = Person.class)
public interface PersonRepository extends EntityRepository<Person, Long> {
    Person findBySsn(String ssn);
}

// Abstract class approach
@Repository
public abstract class PersonRepository extends AbstractEntityRepository<Person, Long> {
    public List<Person> findBySSN(String ssn) {
        return typedQuery("select p from Person p where p.ssn = ?1")
                .setParameter(1, ssn)
                .getResultList();
    }
}