Guice Injection allows you to access multiple Guice Binders and Modules across separate archives as well as run EE functionality in a tiny, super-fast, easy to use MicroServices ready injection framework. That's a lot of adjectives.
Allowing you to configure your applications with injection from multiple dependencies, and granting you
Out of the box JTA (Using BTM) and Direct Injection for Request Scoped Transactions, Units of work and complete multi-persistence units compatible with Annotated Qualifiers no other container comes close.
This framework provides you with Servlets, EJB's, JMS, and Stand-Alone - All Supported. Requires JDK 8. Tested on TomEE, Tomcat8, Glassfish4, Payara4, JBoss5, WildFly, Undertow and Standalone.
This framework automatically Binds into all the above.
Supports all MicroProfile 1.x.
Finally inject across multiple JARS inside of EAR's and WAR's and run the tests in the exact same manner as if it were actually your production! Even JCache is provided and fully utilized.
Separate your service finder across each module/microservice for simple testing and program development, with the full power of Guice on your fingertips! (https://github.com/google/guice)
A Java Guice Assistant that allows you to perform multiple and dynamic binding, using the fast-classpath-scanner from Luke Hutch (https://github.com/lukehutch/).
<repository>
<snapshots/>
<id>snapshots</id>
<name>libs-snapshot</name>
<url>https://jwebmp/artifactory/libs-snapshot</url>
</repository>
<dependency>
<groupId>com.jwebmp</groupId>
M<artifactId>guiced-injection</artifactId>
<version>LATEST</version><type>jar</type>
</dependency>
Teamcity : https://jwebmp/teamcity/viewType.html?buildTypeId=JWebMPCore_BuildGuiceInjection
SonarQube Quality Gate : https://jwebmp/sonar/overview?id=1
Artifactory : https://jwebmp/artifactory/webapp/#/artifacts/browse/tree/General/libs-snapshot-local/za/co/mmagon/guice-injection
- JDK 8
- JPA 2.1
This is due to the convertor pattern being standardized in JPA 2.1 as well as a few other things. As an extension of the google-guice DI framework this project uses the latest dependencies available as much as possible.
https://www.thoughts-on-java.org/jpa-21-overview/
- Google Guice 4.2 (guice-servlet,guice-persist,guice-jndi,guice-jms)
- Fast-Classpath-Scanner 2.9.4
- JPA 2.1
- H2 (testing)
- Jackson JSON 2.9.4
- JCache 1.0 (Optional)
Packing scanning allows you to white list the packages that must be scanned for operation. This vastly decreases the search time required in large classpath EE editions. By default all Guice Injection libraries white list themselves.
Package scanning utilizes the Service Loader pattern (https://docs.oracle.com/javase/tutorial/ext/basics/spi.html)
Create a file in the direcory META-INF/services/ com.guicedee.guicedinjection.scanners.PackageContentsScanner
Add an entry for your class that implements PackageContentsScanner.
Below is the Guice Injection example
public class GuiceInjectionPackageDefaultInclusions implements PackageContentsScanner
{
@Override
public Set<String> searchFor()
{
Set<String> strings = new HashSet<>();
strings.add("META-INF");
strings.add("com.jwebmp.guiceinjection");
return strings;
}
}
Guice Injection allows you to specify files that must be scanned on the complete classpath for loading. This becomes very handy for loading configuration injections, finding files on the classpath, and specifying any additional propeties or needs that should occur before Guice even starts up the PreStartup procedures. Guice Injection uses File Contents Scanning to find any persistence.xml files (JPA2.1) and loads up the guice-persistence extension with the given annotations for these Jar modules
Create a file in the direcory META-INF/services/ com.guicedee.guicedinjection.scanners.PackageContentsScanner
Add an entry for your class that implements FileContentsScanner.
Below is the Guice Injection example (That loads the persistence units asynchronously)
public class PersistenceFileHandler implements FileContentsScanner, PackageContentsScanner
{
@Override
public Map<String, FileMatchContentsProcessorWithContext> onMatch()
{
Map<String, FileMatchContentsProcessorWithContext> map = new HashMap<>();
log.config("Persistence Units Loading... ");
FileMatchContentsProcessorWithContext processor = (classpathElt, relativePath, fileContents) ->
{
log.config("Found " + relativePath + " - " + classpathElt.getCanonicalPath());
if (!GuiceContext.getAsynchronousPersistenceFileLoader().isShutdown())
{
GuiceContext.getAsynchronousPersistenceFileLoader().shutdown();
try
{
GuiceContext.getAsynchronousPersistenceFileLoader().awaitTermination(5, TimeUnit.SECONDS);
}
catch (InterruptedException e)
{
log.log(Level.SEVERE, "Unable to wait for persistence jaxb context to load..", e);
}
}
persistenceUnits.addAll(getPersistenceUnitFromFile(fileContents));
};
map.put("persistence.xml", processor);
return map;
}
The combination of the package contents scanner and the file contents scanner allows ignoring the com.oracle package for any persistence unit scanning
Guice Injection allows you to use the complete library of Google Guice (guice-inject,guice-persist,guice-jms,guice-jndi). Bindings are specified in classes that are in white-listed packages using either the GuiceDefaultBinder or GuiceSiteBinder.
public class CustomerBinderJar1 extends GuiceDefaultBinder
{
@Override
public void onBind(GuiceInjectorModule module)
{
}
}
public class CustomeSiteBinderJar1 extends GuiceSiteBinder
{
@Override
public void onBind(GuiceSiteInjectorModule module)
{
}
}
The Guice Site Injector should be specified in WAR files or Servlet 3.0 Enabled Applications, while the Guice Default Binder should be specified for JARS such as EJB's, Client Jar's, and the such.
You utilize complete AOP provided by Guice. Get a quick and easy handle on annotated development! See https://github.com/google/guice/wiki/AOP for the complete supported operations
module.bindInterceptor$(Matchers.any(), Matchers.annotatedWith(SiteInterception.class),
new SiteIntercepters());
Servlets, Filters and the Servlet 3.x API completely supported using the guice-servlet structure. Paired with the persistence layer you are free to enabled request levelled transactions across multiple persistence units. The entire guice-servlet api is supported out the box. https://github.com/google/guice/wiki/Servlets
module.serveRegex$("(" + JAVASCRIPT_LOCATION + ")" + QUERY_PARAMETERS_REGEX).with(JavaScriptServlet.class);
log.log(Level.INFO, "Serving JavaScripts at {0}", JAVASCRIPT_LOCATION);
This framework comes built in with the BTM Transaction Manager, and a complete JPA 2.1 Persistence Unit with JNDI. This ensures that your production and your testing environment all run and operate on the same level. Completely supporting JCache and second level caching.