findAll(), findRange() and count() take an optional argument to enhance the queries, which can add additional JPA clauses, enhancements and hints. This parameter takes a form of QueryEnhancement interface, which extends BiConsumer interface. There are a number of accept convenience methods in QueryEnhancement interface that can be passed via a method reference. This enables composition of different QueryEnhancement instances.

Full Demo on GitHub

Full Demo on GitHub

There are many ways to implement the Data-Access-Object pattern in Java. Most of them require to implement an interface, have some kind of bytecode generation magic or inherit from a base class. FlowLogix takes a different approach. The amount of magic is totally up to the developers. If none of the below approaches work, your DAO can simply inherit from InheritableDaoHelper, and initialize the jpaFinder protected field in your @PostConstruct method.

You can leverage Project Lombok @Delegate annotation to transparently implement Data Access Objects without any specific requirements. Alternatively, developers can write manual forwarder methods, dynamic proxies, or other bytecode generators to delegate to JPAFinder from an interface.

Recommended approach is to use Lombok’s @Delegate annotation. This introduces the fewest amount of magic, results in the least amount of code, and absolute minimum (if any) boilerplate.

JPAFinder can also be @Inject ed and it will infer the EntityManager via CDI. If default CDI producer for the EntityManager is insufficient, @EntityManagerSelector annotation can be used to specify qualifiers for non-default EntityManager producer

JPAFinder is Serializable and thus can be used inside @ViewScoped beans, for example.

Fluent Builder pattern can be used to create DaoHelper object, which requires EntityManager Supplier and entity Class.

That’s Because EntityManager is not initialized when the object is created. Supplier lets you delay the initialization of DaoHelper until EntityManager is actually needed at run-time and is already initialized. This is why InheritableDAOHelper needs to be initialized in @PostConstruct method instead of the constructor.

These methods are built into the EntityManager and can be accessed that way (see the "more complete" example below). There is no need for JPAFinder to provide them. If more functionality related to find() is desired, Jakarta Data or Apache DeltaSpike project is a wonderful addition to your architecture and will satisfy those needs.

Full Demos on GitHub

The example above works well if @RequestScope is unavailable and may work better because of EJB bean pooling optimizations.

JPANativeQuery interface has a convenience method createNativeQuery() which will return TypedNativeQuery object. This is a thin wrapper over JPA’s Query object, however it’s getResult*() methods return typed results via generics, which avoids casting and makes the results easier and safer to use.

Jakarta Faces runs in production mode by default. However, most applications set up development mode by modifiying web.xml. Traditionally, it’s been difficult to set up environment-based switching from development to production mode. FlowLogix sets this up automatically via web-fragment.xml and allows JNDI-based switch to production mode.

Below is an example of setting up production mode with Payara and GlassFish with Jakarta EE 9 or later:

With Jakarta EE or Java EE 8 and earlier, replace faces/ with jsf/.

Most front-end applications want to use minified versions of their assets, such as JavaScript and CSS files in production (i.e. any non-development) modes. FlowLogix allows this via MinimizedHandler which will automatically insert min prefix into the appropriate assets, for example resource.js → resource.min.js and resource.css → resource.min.css. This is configurable via web.xml parameters com.flowlogix.MINIMIZED_PREFIX and com.flowlogix.MINIMIZED_FILE_TYPES

MinimizedHandler works with build tools that generate minified versions of resources automatically, such as maven minify plugin.

Any configured Jakarta Faces resources are resolved to their minified versions

By default, only resources with css and js extensions are resolved to their minified versions. The min extension is inserted prior to their original extension.

The above example changes resolution from mycss.css → mycss.min.css to mycss.css → mycss.minimized.css

In order to initialize OmniFaces' UnmappedResourceHandler, both web.xml servlet-mapping and faces-config.xml entries are ordinarily required. FlowLogix automates more complicated web.xml requirements by configuring the servlet container to include all unmapped resources. This alleviates requirement to specify Faces Servlet mapping in your web.xml file at all. In order to enable this, add the below context parameter in web.xml:

PrimeFaces automatically includes fonts as part of the application. However, the file extensions of these fonts are not usually included in most servlet containers by default. FlowLogix adds those mime types automatically and prevents the warnings such as below from appearing in log files:

This way, no extra mime-mapping entries are required in web.xml

Most classes that can be constructed from String include valueOf(String) method by convention. TypeConverter class uses this to generically convert a String to any type specified, thus dramatically reducing the code required. If unable to convert the class, an exception is thrown.
TypeConverter specifically does not support custom converters for simplicity. If those are desired, other libraries do a great job of handling custom converters, including Jakarta Faces' Converters.

FlowLogix provides a convenience method for converting strings from javax to jakarta namespace:

FlowLogix automatically detects which environment it’s in, and converts javax-based names into jakarta-based namespace accordingly. Keep in mind that the environment check occurs at run-time, and not compile time. This method works not only for classes, but also for error messages and other strings.

The jakartify() utility is particularly useful in scenarios where maven shade plugin is used to produce both javax and jakarta-based JAR artifacts. It allows to use same source code for both and dynamically produce correct strings without additional shade plugins or complex regular expressions.

Generic serializeAndDeserialize() method can be used to check the true ability to serialize a class. It returns the result of the input going through serialization and deserialization, so the new object’s state can be checked for correctness.

FlowLogix provides an easy way to read a String from any input stream:

ShrinkWrapManupulator class has a few utility methods that make testing tricky behaviors easier.

Some tests require TLS/SSL to execute properly. Arquillian uses plain http by default. To facilitate tests that require TLS/SSL, toHttpsURL(url) takes a URL and converts it to it’s https equivalent, taking the httpsPort system property into account. Default TLS port is 8181. A more complete method toHttpURL(url, sslPortPropertyName, defaultPort) is available if the default system property and port are not suitable for your needs.

webXmlXPath() takes a List<Action> and will manipulate archive’s web.xml to achieve the desired test configuration. For example, if Jakarta Faces production mode is desired for a particular archive, web.xml context-param can be changed below:

Full Demo on GitHub

getContextParamValue() is a shorthand to produce XPath for web.xml context parameter (<context-param>) element:

The second parameter is DOM Node class Consumer lambda, which allows for manipulation of the DOM element directly by the user.
Above, we also combine web.xml manipulation with jakartify to be compatible with both Jakarta EE 8 or 9, if desired.

ShrinkWrapManipulator can also easily manipulate persistence.xml file. Even though maven filtering can be used to resolve a versioned entities JAR in persistence.xml, ShrinkWrap will not do the filtering because it uses its own mechanism to create the archive. Another way is needed to create the substitution inside the deploy() method in ShirkWrap:

Full Demo on GitHub

Developers can transform any XML file from the archive by using the generic manipulateXml() method, which both webXmlXPath() and persistenceXmlXPath() methods utilize to do their job.