tessl/maven-org-jboss-shrinkwrap--shrinkwrap-impl-base

Common base implementations for the ShrinkWrap project enabling declarative assembly of Java archives (JAR, WAR, EAR, RAR) in code

—

Pending

Overview

Eval results

Files

Container Implementations

Name: tessl/maven-org-jboss-shrinkwrap--shrinkwrap-impl-base
Author: tessl

Container implementations provide complete functionality for managing archive contents including classes, resources, libraries, and metadata. These classes form the backbone of ShrinkWrap's container-based API.

Base Container Classes

ContainerBase<T>

The foundational container implementation providing comprehensive archive management capabilities.

public abstract class ContainerBase<T extends Archive<T>> extends MemoryMapArchiveBase<T> 
    implements Archive<T>, ManifestContainer<T>, ServiceProviderContainer<T>, 
               ResourceContainer<T>, ClassContainer<T>, LibraryContainer<T>

Core Container Operations:

Class Management:

public T addClass(Class<?> clazz)
public T addClass(String fullyQualifiedClassName) 
public T addClasses(Class<?>... classes)
public T addPackage(Package pack)
public T addPackages(boolean recursive, Package... packages)

Resource Management:

public T addAsResource(String resourceName)
public T addAsResource(String resourceName, String target)
public T addAsResource(Asset asset, String target)
public T addAsResource(URL resource, String target)

Library Management:

public T addAsLibrary(Archive<?> archive)
public T addAsLibrary(String path)
public T addAsLibraries(Archive<?>... archives)

Manifest Operations:

public T addAsManifestResource(String resourceName)
public T addAsManifestResource(Asset asset, String target)
public T setManifest(Asset asset)
public T setManifest(String manifest)

Service Provider Configuration:

public T addAsServiceProvider(Class<?> serviceInterface, Class<?>... serviceImpls)
public T addAsServiceProvider(String serviceInterface, String... serviceImpls)

WebContainerBase<T>

Specialized container for web archives (WAR files) with web-specific operations.

public abstract class WebContainerBase<T extends Archive<T>> extends ContainerBase<T> 
    implements WebContainer<T>

Web-Specific Operations:

Web Resources:

public T addAsWebResource(String resourceName)
public T addAsWebResource(Asset asset, String target)
public T addAsWebResource(URL resource, String target)

Web Infrastructure:

public T addAsWebInfResource(String resourceName)
public T addAsWebInfResource(Asset asset, String target)
public T setWebXML(Asset asset)
public T setWebXML(String webXml)

EnterpriseContainerBase<T>

Container implementation for enterprise archives (EAR files) with module management.

public abstract class EnterpriseContainerBase<T extends Archive<T>> extends ContainerBase<T> 
    implements EnterpriseContainer<T>

Enterprise Operations:

Module Management:

public T addAsModule(Archive<?> archive)
public T addAsLibrary(Archive<?> archive)
public T addAsApplicationResource(String resourceName)
public T addAsApplicationResource(Asset asset, String target)

Application Configuration:

public T setApplicationXML(Asset asset)
public T setApplicationXML(String applicationXml)

ResourceAdapterContainerBase<T>

Container for resource adapter archives (RAR files) with JCA-specific functionality.

public abstract class ResourceAdapterContainerBase<T extends Archive<T>> extends ContainerBase<T> 
    implements ResourceAdapterContainer<T>

Resource Adapter Operations:

public T setResourceAdapterXML(Asset asset)
public T addAsResourceAdapterResource(String resourceName)

Implementation Classes

MemoryMapArchiveImpl

Complete memory-based archive implementation.

public class MemoryMapArchiveImpl extends MemoryMapArchiveBase<MemoryMapArchive> 
    implements MemoryMapArchive

Constructors:

public MemoryMapArchiveImpl(String archiveName)

ConfigurableArchiveImpl

Configurable archive implementation with runtime customization support.

public class ConfigurableArchiveImpl extends MemoryMapArchiveBase<ConfigurableArchive> 
    implements ConfigurableArchive

Configuration Methods:

public ConfigurableArchiveImpl configure(Configuration configuration)
public Configuration getConfiguration()

GenericArchiveImpl

Generic archive implementation for unknown or custom archive formats.

public class GenericArchiveImpl extends ContainerBase<GenericArchive> 
    implements GenericArchive

Usage:

// Create generic archive for custom formats
GenericArchiveImpl archive = new GenericArchiveImpl("custom.archive");
archive.addClass(MyClass.class);
archive.addAsResource("config.xml");

Advanced Container Features

Content Filtering

All container implementations support content filtering during operations:

// Add classes with filtering
archive.addPackages(true, 
    Filters.exclude(TestClass.class), 
    "com.example.core");

// Add resources selectively  
archive.addAsResource("config/", 
    Filters.include(".*\\.properties"));

Bulk Operations

Container classes provide efficient bulk operations:

// Bulk class addition
archive.addClasses(UserService.class, OrderService.class, ProductService.class);

// Bulk library addition
archive.addAsLibraries(hibernateJar, springJar, commonsJar);

// Package scanning with recursion
archive.addPackages(true, "com.example.service", "com.example.dao");

Archive Merging

Containers support merging content from other archives:

// Merge entire archive
targetArchive.merge(sourceArchive);

// Merge with filtering
targetArchive.merge(sourceArchive, Filters.exclude(".*Test.*"));

// Merge specific paths
targetArchive.merge(sourceArchive, "/lib", "/META-INF/services");

Container Patterns

Builder Pattern Support

Container implementations work seamlessly with builder patterns:

JavaArchive archive = ShrinkWrap.create(JavaArchive.class, "app.jar")
    .addClass(Application.class)
    .addPackage("com.example.core")
    .addAsResource("META-INF/persistence.xml")
    .addAsManifestResource("META-INF/MANIFEST.MF");

Service Provider Pattern

Easy service provider configuration:

// Single service implementation
archive.addAsServiceProvider(MyService.class, MyServiceImpl.class);

// Multiple implementations
archive.addAsServiceProvider(Plugin.class, 
    DatabasePlugin.class, 
    CachePlugin.class, 
    LoggingPlugin.class);

Manifest Customization

Flexible manifest handling:

// Simple manifest setting
archive.setManifest(new StringAsset(
    "Manifest-Version: 1.0\n" +
    "Main-Class: com.example.Application\n"));

// Manifest from resource
archive.setManifest("META-INF/MANIFEST.MF");

// Additional manifest resources
archive.addAsManifestResource("permissions.xml")
       .addAsManifestResource("beans.xml");

Thread Safety

Container implementations maintain thread safety through:

Synchronized access to internal archive maps
Immutable path and asset references
Thread-safe collection operations
Atomic content modification operations

Performance Considerations

Memory Usage: Container base uses memory mapping for efficient content storage
Lazy Loading: Assets are loaded on-demand rather than eagerly
Content Deduplication: Identical content is shared across archive entries
Bulk Operations: Optimized for adding multiple items simultaneously

Install with Tessl CLI

npx tessl i tessl/maven-org-jboss-shrinkwrap--shrinkwrap-impl-base

docs