This is an automated email from the ASF dual-hosted git repository.
jamesbognar pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/juneau.git
The following commit(s) were added to refs/heads/master by this push:
new c622d402e4 Create new shaded modules.
c622d402e4 is described below
commit c622d402e4218def2bb62883cd3299a314811263
Author: James Bognar <[email protected]>
AuthorDate: Mon Oct 13 10:32:04 2025 -0400
Create new shaded modules.
---
.gitignore | 3 +
README.md | 4 +-
juneau-all/.gitignore | 6 -
juneau-all/src/assembly/all.xml | 36 --
.../main/ConfigurablePropertyCodeGenerator.java | 280 -------------
juneau-all/src/java/main/FieldSorter.java | 27 --
juneau-distrib/pom.xml | 46 +-
juneau-docs/docs/release-notes/9.2.0.md | 109 +++++
.../topics/01.01.00.JuneauEcosystemOverview.md | 19 +-
.../docs/topics/19.01.00.JuneauAllBasics.md | 63 ---
.../docs/topics/19.01.00.JuneauShadedOverview.md | 466 +++++++++++++++++++++
.../docs/topics/19.02.00.JuneauShadedCore.md | 196 +++++++++
.../docs/topics/19.03.00.JuneauShadedRestClient.md | 283 +++++++++++++
.../docs/topics/19.04.00.JuneauShadedRestServer.md | 388 +++++++++++++++++
.../19.05.00.JuneauShadedRestServerSpringboot.md | 436 +++++++++++++++++++
.../docs/topics/19.06.00.JuneauShadedAll.md | 384 +++++++++++++++++
juneau-docs/src/pages/downloads.md | 9 +-
juneau-shaded/README.md | 261 ++++++++++++
.../juneau-shaded-all}/pom.xml | 101 +++--
.../juneau-shaded-core}/pom.xml | 77 ++--
juneau-shaded/juneau-shaded-rest-client/pom.xml | 79 ++++
.../juneau-shaded-rest-server-springboot/pom.xml | 69 +++
.../juneau-shaded-rest-server}/pom.xml | 77 +---
juneau-shaded/pom.xml | 105 +++++
pom.xml | 2 +-
25 files changed, 2935 insertions(+), 591 deletions(-)
diff --git a/.gitignore b/.gitignore
index 290448ec4d..19cb8c068b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,6 +9,9 @@ derby.log
# Temporary cursor assistant scripts
cursor-*
+# Maven Shade Plugin generated files
+**/dependency-reduced-pom.xml
+
# Note: Maven site generation creates target/site/ (already ignored by
**/target/ above)
/juneau.code-workspace
/create-mvn-site.log
diff --git a/README.md b/README.md
index 213c6f75bd..45bd4100fb 100644
--- a/README.md
+++ b/README.md
@@ -68,7 +68,7 @@ Apache Juneau™ excels in the following scenarios:
```xml
<dependency>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau-all</artifactId>
+ <artifactId>juneau-shaded-all</artifactId>
<version>9.1.0</version>
</dependency>
```
@@ -292,7 +292,7 @@ Apache Juneau™ is a single cohesive Java ecosystem
consisting of the following
* **juneau-examples-rest-jetty** - Jetty microservice examples.
* **juneau-examples-rest-springboot** - Spring Boot examples.
* **juneau-petstore** - Complete REST application example.
-* **juneau-all** - Convenience dependency combining all core Juneau modules.
+* **juneau-shaded** - Shaded (uber) JARs combining multiple Juneau modules for
simplified dependency management, especially useful for Bazel builds.
Questions via email to [email protected] are always welcome.
diff --git a/juneau-all/.gitignore b/juneau-all/.gitignore
deleted file mode 100644
index 34acf885cb..0000000000
--- a/juneau-all/.gitignore
+++ /dev/null
@@ -1,6 +0,0 @@
-/target/
-**/.DS_Store
-.classpath
-.project
-/.settings/
-/bin/
diff --git a/juneau-all/src/assembly/all.xml b/juneau-all/src/assembly/all.xml
deleted file mode 100644
index c011c64075..0000000000
--- a/juneau-all/src/assembly/all.xml
+++ /dev/null
@@ -1,36 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
- Licensed to the Apache Software Foundation (ASF) under one or more
- contributor license agreements. See the NOTICE file distributed with
- this work for additional information regarding copyright ownership.
- The ASF licenses this file to You under the Apache License, Version 2.0
- (the "License"); you may not use this file except in compliance with
- the License. You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
--->
-<assembly
-
xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3";
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance";
-
xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.3
https://maven.apache.org/xsd/assembly-1.1.3.xsd";>
- <id>all</id>
- <formats>
- <format>dir</format>
- <format>zip</format>
- </formats>
- <includeBaseDirectory>false</includeBaseDirectory>
- <dependencySets>
- <dependencySet>
- <includes>
- <include>*</include>
- </includes>
- <outputDirectory></outputDirectory>
- </dependencySet>
- </dependencySets>
-</assembly>
\ No newline at end of file
diff --git a/juneau-all/src/java/main/ConfigurablePropertyCodeGenerator.java
b/juneau-all/src/java/main/ConfigurablePropertyCodeGenerator.java
deleted file mode 100644
index d2271e38ec..0000000000
--- a/juneau-all/src/java/main/ConfigurablePropertyCodeGenerator.java
+++ /dev/null
@@ -1,280 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import static org.apache.juneau.common.internal.IOUtils.*;
-import static org.apache.juneau.common.internal.Utils.*;
-import static org.apache.juneau.internal.CollectionUtils.*;
-
-import java.io.*;
-import java.lang.reflect.*;
-import java.nio.file.*;
-import java.util.*;
-import java.util.stream.*;
-
-import org.apache.juneau.*;
-import org.apache.juneau.common.internal.*;
-import org.apache.juneau.internal.*;
-import org.apache.juneau.reflect.*;
-
-public class ConfigurablePropertyCodeGenerator {
-
- static Set<Class<?>> IGNORE_CLASSES = Utils.set(
- org.apache.http.entity.AbstractHttpEntity.class,
- org.apache.http.entity.BasicHttpEntity.class,
- org.apache.http.message.AbstractHttpMessage.class,
- org.apache.http.message.BasicHttpResponse.class,
- BeanSession.class,
- ArrayList.class,
- RuntimeException.class,
- Writer.class
- );
-
- private static String[] SOURCE_PATHS = {
- "juneau-core/juneau-assertions",
- "juneau-core/juneau-common",
- "juneau-core/juneau-config",
- "juneau-core/juneau-bean",
- "juneau-core/juneau-marshall",
- "juneau-core/juneau-marshall-rdf",
- "juneau-rest/juneau-rest-common",
- "juneau-rest/juneau-rest-client",
- "juneau-rest/juneau-rest-server",
- "juneau-rest/juneau-rest-mock",
- };
-
- public static void main(String[] args) throws Exception {
-
- Set<Class<?>> ignoreClasses = new HashSet<>();
- for (Class<?> ic : IGNORE_CLASSES) {
- while (ic != null) {
- ignoreClasses.add(ic);
- ic = ic.getSuperclass();
- }
- }
-
- Map<Class<?>, Set<Method>> configMethods = new HashMap<>();
-
- Map<Class<?>,File> classMap = map();
- for (String sp : SOURCE_PATHS) {
- File f = new File("../"+sp+"/src/main/java");
- Path p = f.toPath();
- try (Stream<Path> walkStream = Files.walk(p)) {
- walkStream
- .filter(x -> x.toFile().isFile())
- .map(x -> x.toFile())
- .filter(x ->
x.getName().endsWith(".java"))
- .filter(x -> hasFluentSetters(x))
- .forEach(x -> classMap.put(toClass(x),
x));
- }
- }
-
- System.out.println("Found " + classMap.size() + " classes with
fluent setters:");
- classMap.keySet().forEach(x -> System.out.println("\t" + x));
-
- for (Class<?> c : classMap.keySet()) {
- System.out.println("Seaching " + c.getName());
- Set<Method> s = new TreeSet<>(new MethodComparator());
- for (Method m : c.getDeclaredMethods()) {
- if (m.getAnnotation(FluentSetter.class) !=
null) {
- s.add(m);
- System.out.println("\tFound: " +
m.getName());
- }
- }
- configMethods.put(c, s);
- }
-
- for (Map.Entry<Class<?>,File> e : classMap.entrySet()) {
- Class<?> c = e.getKey();
- File f = e.getValue();
-
- if (! c.isAnnotationPresent(FluentSetters.class))
- System.err.println("@FluentSetters not present
on class " + c.getName());
-
- System.out.println("Processing " + f.getName());
- String s = read(f);
-
- int i1 = s.indexOf("<FluentSetters>"), i2 =
s.indexOf("</FluentSetters>");
- String cpSection = null;
- if (i1 != -1 && i2 != -1) {
- cpSection = s.substring(i1+15, i2);
- } else {
- System.err.println("...<FluentSetters> not
found: " + f.getName());
- continue;
- }
-
- Map<String,String> docs =
Stream.of(cpSection.split("[\n]{2,}"))
- .map(x -> x.trim())
- .filter(x -> x.startsWith("/*"))
- .map(x -> x.split("(?s)\\*\\/.*public"))
- .collect(Collectors.toMap(x ->
("\n\tpublic"+x[1].substring(0, x[1].indexOf("\n"))), x -> ("\t"+x[0]+"*/\n")));
-
- StringBuilder sb = new StringBuilder();
- ClassInfo ci = ClassInfo.of(c);
- String cName = ci.getSimpleName();
- Set<String> ignore = Utils.set();
- FluentSetters fs =
ci.getAnnotation(FluentSetters.class);
- if (! fs.returns().isEmpty())
- cName = fs.returns();
- for (String i : fs.ignore())
- ignore.add(i);
-
- String indent = c.getDeclaringClass() != null ? "\t\t"
: "\t";
- Set<String> sigsAdded = new HashSet<>();
-
- List<ClassInfo> l = ClassInfo.of(c).getParents();
- for (int i = l.size()-1; i>=0; i--) {
- ClassInfo pc = l.get(i);
- Class<?> pcc = pc.inner();
- if (pcc != c) {
- Set<Method> ms = configMethods.get(pcc);
- if (ms != null) {
- for (Method m : ms) {
-
- // Don't render
deprecated methods.
- if
(m.getAnnotation(Deprecated.class) != null)
- continue;
-
- String mSig = new
StringBuilder(m.getName()).append("(").append(getArgs(m)).append(")").toString();
-
- // Don't render ignored
methods.
- if
(ignore.contains(m.getName()) || ignore.contains(mSig) ||
sigsAdded.contains(mSig))
- continue;
-
- sigsAdded.add(mSig);
-
- StringBuilder sigLine =
new StringBuilder();
-
sigLine.append("\n").append(indent).append("public ");
- if
(m.getTypeParameters().length > 0)
-
sigLine.append("<").append(alist(m.getTypeParameters()).stream().map(x ->
x.getName()).collect(Collectors.joining(", "))).append("> ");
-
sigLine.append(cName).append(" ").append(mSig).append(" ");
- if (
m.getExceptionTypes().length > 0)
-
sigLine.append("throws ").append(alist(m.getExceptionTypes()).stream().map(x ->
x.getSimpleName()).collect(Collectors.joining(", ")));
- sigLine.append("{");
- String sigLine2 =
sigLine.toString();
-
- sb.append("\n\n");
-
- // Overridden javadocs
- String javadoc =
docs.get(sigLine2);
- if (javadoc != null) {
-
sb.append(javadoc);
- }
-
- // Line 1
- sb.append(indent)
-
.append(m.getAnnotation(Deprecated.class) == null ? "" : "@Deprecated ")
-
.append("@Override /* GENERATED - ").append(pcc.getCanonicalName()).append("
*/")
- ;
-
- if (m.isVarArgs()) {
- Type t =
m.getParameters()[m.getParameterCount()-1].getParameterizedType();
- if
(t.toString().contains(" extends ")) {
-
sb.append("\n").append(indent).append("@SuppressWarnings(\"unchecked\")");
- }
- }
-
- // Line 2
- sb.append(sigLine2);
-
- // Body
-
sb.append("\n").append(indent).append("\tsuper.").append(m.getName()).append("(").append(getArgVals(m)).append(");");
-
sb.append("\n").append(indent).append("\treturn this;");
-
sb.append("\n").append(indent).append("}");
-
- }
- } else {
- if (!
ignoreClasses.contains(pc.inner()))
-
System.err.println("Parent " + pc.inner().getSimpleName() + " not found for
class " + c.getName());
- }
- }
- }
-
- s = s.substring(0, i1+15) + sb.toString() +
"\n\n"+indent+"// " + s.substring(i2);
- pipe(new StringReader(s), f);
- }
-
- System.out.println("DONE");
- }
-
- private static boolean hasFluentSetters(File f) {
- try (BufferedReader br = new BufferedReader(new
InputStreamReader(new FileInputStream(f)))) {
- String line;
- while ((line = br.readLine()) != null)
- if (line.contains("@FluentSetter") ||
line.contains("<FluentSetter>"))
- return true;
- } catch (IOException e) {
- e.printStackTrace();
- }
- return false;
- }
-
- private static Class<?> toClass(File f) {
- try {
- String n = f.getAbsolutePath();
- Class<?> c =
Class.forName(n.substring(n.indexOf("/src/main/java/")+15).replace(".java","").replace('/','.'));
- if (! c.isAnnotationPresent(FluentSetters.class)) {
- for (Class<?> c2 : c.getClasses()) {
- if
(c2.isAnnotationPresent(FluentSetters.class))
- return c2;
- }
- }
- return c;
- } catch (Throwable e) {
- System.err.println("Couldn't find class for file " +
f.getAbsolutePath());
- e.printStackTrace();
- return null;
- }
- }
-
- private static String getArgs(Method m) {
- StringBuilder sb = new StringBuilder();
- for (Parameter p : m.getParameters()) {
- if (sb.length() > 0)
- sb.append(", ");
- ClassInfo pi = ClassInfo.of(p.getParameterizedType());
- if (p.isVarArgs())
-
sb.append(pi.getShortName().replace("[]","...").replace('$','.') + p.getName());
- else
- sb.append(pi.getShortName().replace('$','.') +
" " + p.getName());
- }
- return sb.toString();
- }
-
- private static String getArgVals(Method m) {
- StringBuilder sb = new StringBuilder();
- for (Parameter p : m.getParameters()) {
- if (sb.length() > 0)
- sb.append(", ");
- sb.append(p.getName());
- }
- return sb.toString();
- }
-
- private static class MethodComparator implements Comparator<Method> {
- @Override
- public int compare(Method m1, Method m2) {
- int i = m1.getName().compareTo(m2.getName());
- if (i == 0)
- i = Integer.compare(m1.getParameterCount(),
m2.getParameterCount());
- if (i == 0 && m1.getParameterCount() > 0)
- i =
m1.getParameterTypes()[0].getName().compareTo(m2.getParameterTypes()[0].getName());
- if (i == 0 && m1.getParameterCount() > 1)
- i =
m1.getParameterTypes()[1].getName().compareTo(m2.getParameterTypes()[1].getName());
- return i;
- }
- }
-}
\ No newline at end of file
diff --git a/juneau-all/src/java/main/FieldSorter.java
b/juneau-all/src/java/main/FieldSorter.java
deleted file mode 100644
index 72800fbbf6..0000000000
--- a/juneau-all/src/java/main/FieldSorter.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import static org.apache.juneau.common.internal.Utils.*;
-
-import java.util.stream.*;
-
-public class FieldSorter {
-
- public static void main(String[] args) {
- String in = "properties, p, excludeProperties, x,
readOnlyProperties, ro, writeOnlyProperties, wo, example, typeName,
typePropertyName";
-
System.err.println(alist(in.split("[\\s\\,]+")).stream().sorted().collect(Collectors.joining(",
")));
- }
-}
\ No newline at end of file
diff --git a/juneau-distrib/pom.xml b/juneau-distrib/pom.xml
index 3ed2f01ea6..0ac437353d 100644
--- a/juneau-distrib/pom.xml
+++ b/juneau-distrib/pom.xml
@@ -45,21 +45,37 @@
<configuration>
<artifactItems>
- <!-- juneau-all
-->
- <artifactItem>
-
<outputDirectory>${project.build.directory}/src</outputDirectory>
-
<groupId>org.apache.juneau</groupId>
-
<artifactId>juneau-all</artifactId>
-
<version>${project.version}</version>
-
<type>jar</type>
-
<classifier>sources</classifier>
- </artifactItem>
- <artifactItem>
-
<outputDirectory>${project.build.directory}/bin</outputDirectory>
-
<groupId>org.apache.juneau</groupId>
-
<artifactId>juneau-all</artifactId>
-
<version>${project.version}</version>
- </artifactItem>
+ <!-- Shaded artifacts -->
+ <artifactItem>
+
<outputDirectory>${project.build.directory}/bin/shaded</outputDirectory>
+
<groupId>org.apache.juneau</groupId>
+
<artifactId>juneau-shaded-core</artifactId>
+
<version>${project.version}</version>
+ </artifactItem>
+ <artifactItem>
+
<outputDirectory>${project.build.directory}/bin/shaded</outputDirectory>
+
<groupId>org.apache.juneau</groupId>
+
<artifactId>juneau-shaded-rest-client</artifactId>
+
<version>${project.version}</version>
+ </artifactItem>
+ <artifactItem>
+
<outputDirectory>${project.build.directory}/bin/shaded</outputDirectory>
+
<groupId>org.apache.juneau</groupId>
+
<artifactId>juneau-shaded-rest-server</artifactId>
+
<version>${project.version}</version>
+ </artifactItem>
+ <artifactItem>
+
<outputDirectory>${project.build.directory}/bin/shaded</outputDirectory>
+
<groupId>org.apache.juneau</groupId>
+
<artifactId>juneau-shaded-rest-server-springboot</artifactId>
+
<version>${project.version}</version>
+ </artifactItem>
+ <artifactItem>
+
<outputDirectory>${project.build.directory}/bin/shaded</outputDirectory>
+
<groupId>org.apache.juneau</groupId>
+
<artifactId>juneau-shaded-all</artifactId>
+
<version>${project.version}</version>
+ </artifactItem>
<!--
juneau-marshall -->
<artifactItem>
diff --git a/juneau-docs/docs/release-notes/9.2.0.md
b/juneau-docs/docs/release-notes/9.2.0.md
index 936afed5d7..210d2766a4 100644
--- a/juneau-docs/docs/release-notes/9.2.0.md
+++ b/juneau-docs/docs/release-notes/9.2.0.md
@@ -15,6 +15,7 @@ Juneau 9.2.0 is a minor release focused on enhancements and
bug fixes.
Major changes include:
+- **New Module**: Introduced `juneau-shaded` with five shaded (uber) JAR
artifacts for simplified dependency management, especially useful for Bazel
- JSON Schema beans upgraded to Draft 2020-12 specification with backward
compatibility for Draft 04
- Comprehensive enhancements to HTML5 beans with improved javadocs and
`HtmlBuilder` integration
- Standardized license headers across all Java files
@@ -22,6 +23,7 @@ Major changes include:
- Removed `final` modifiers from many classes to improve testability with
Mockito and other mocking frameworks
- Improved `RestRequest` and `RestResponse` to work cleanly with
try-with-resources blocks
- **New Module**: Introduced `juneau-bct` (Bean-Centric Testing) with fluent
APIs for comprehensive bean testing
+- Deprecated and removed `juneau-all` in favor of `juneau-shaded-all`
### juneau-dto
@@ -241,6 +243,86 @@ void testSwaggerDocument() {
See the module documentation for complete API reference and examples.
+### juneau-shaded (NEW MODULE)
+
+#### Shaded Artifacts for Simplified Dependency Management
+
+Introduced a new `juneau-shaded` module that provides five shaded (uber) JAR
artifacts. These artifacts bundle multiple Juneau modules into single JARs,
making them ideal for:
+- **Bazel and strict dependency build systems** - Eliminates the need to
manually declare all transitive Juneau dependencies
+- **Simplified Maven/Gradle projects** - One dependency instead of many
+- **Standalone applications** - Convenient uber JAR deployment
+- **Quick prototyping** - Get started faster with fewer dependency decisions
+
+#### Available Shaded Artifacts
+
+| Artifact | Size | Contents |
+|----------|------|----------|
+| **juneau-shaded-core** | 2.1 MB | Core marshalling and configuration modules
|
+| **juneau-shaded-rest-client** | 3.8 MB | Core + REST client functionality |
+| **juneau-shaded-rest-server** | 3.8 MB | Core + REST server functionality |
+| **juneau-shaded-rest-server-springboot** | 3.8 MB | REST server + Spring
Boot integration |
+| **juneau-shaded-all** | 4.0 MB | Complete Juneau framework in one JAR |
+
+#### Maven Usage
+
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-all</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+```
+
+#### Bazel Usage
+
+```python
+maven_jar(
+ name = "juneau_all",
+ artifact = "org.apache.juneau:juneau-shaded-all:${juneau.version}",
+)
+
+java_library(
+ name = "my_lib",
+ srcs = ["MyCode.java"],
+ deps = ["@juneau_all//jar"],
+)
+```
+
+#### Key Features
+
+- **Bundles all Juneau modules** - No need to declare transitive Juneau
dependencies
+- **External dependencies still required** - Apache HttpClient, Jakarta
Servlet API, etc. must be declared separately
+- **No code changes needed** - All imports and APIs remain the same
+- **Maven Shade Plugin** - Uses industry-standard plugin for creating uber JARs
+- **Service file merging** - Automatically merges `META-INF/services` files
+- **Dependency-reduced POMs** - Shows exactly which external dependencies are
needed
+
+#### Included in Distribution
+
+All five shaded artifacts are now included in the binary distribution under
`/shaded/`:
+- `juneau-shaded-core-${version}.jar`
+- `juneau-shaded-rest-client-${version}.jar`
+- `juneau-shaded-rest-server-${version}.jar`
+- `juneau-shaded-rest-server-springboot-${version}.jar`
+- `juneau-shaded-all-${version}.jar`
+
+#### Documentation
+
+- **[Shaded Artifacts Overview](/docs/topics/JuneauShadedOverview)** -
Complete guide with Bazel examples
+- **[juneau-shaded-core](/docs/topics/JuneauShadedCore)** - Core functionality
+- **[juneau-shaded-rest-client](/docs/topics/JuneauShadedRestClient)** - REST
client
+- **[juneau-shaded-rest-server](/docs/topics/JuneauShadedRestServer)** - REST
server
+-
**[juneau-shaded-rest-server-springboot](/docs/topics/JuneauShadedRestServerSpringboot)**
- Spring Boot
+- **[juneau-shaded-all](/docs/topics/JuneauShadedAll)** - Complete framework
+
+#### Deprecation of juneau-all
+
+The previous `juneau-all` module has been deprecated and removed in favor of
`juneau-shaded-all`. The shaded version provides the same functionality with
better support for modern build systems like Bazel.
+
+**Migration:**
+- Replace `juneau-all` with `juneau-shaded-all` in your dependencies
+- No code changes required - all imports remain the same
+
### juneau-rest-client
#### RestRequest and RestResponse
@@ -279,6 +361,33 @@ None at this time.
#### Migration Notes
+- **juneau-all → juneau-shaded-all**: The `juneau-all` module has been
removed. Update your dependencies:
+
+ **Before:**
+ ```xml
+ <dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-all</artifactId>
+ <version>${juneau.version}</version>
+ </dependency>
+ ```
+
+ **After:**
+ ```xml
+ <dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-all</artifactId>
+ <version>${juneau.version}</version>
+ </dependency>
+ ```
+
+ No code changes are required - all imports and APIs remain the same.
+
+ Alternatively, consider using a more specific shaded artifact if you don't
need the full framework:
+ - `juneau-shaded-core` - For marshalling/config only (2.1 MB)
+ - `juneau-shaded-rest-client` - For REST client work (3.8 MB)
+ - `juneau-shaded-rest-server` - For REST server work (3.8 MB)
+
- **JsonSchema**: Code using `JsonSchema` beans will continue to work without
changes. For Draft 2020-12 features:
- Use `$id` instead of `id` for new schemas
- Use `$defs` instead of `definitions` for new schemas
diff --git a/juneau-docs/docs/topics/01.01.00.JuneauEcosystemOverview.md
b/juneau-docs/docs/topics/01.01.00.JuneauEcosystemOverview.md
index cc59cdb3a5..eef3456941 100644
--- a/juneau-docs/docs/topics/01.01.00.JuneauEcosystemOverview.md
+++ b/juneau-docs/docs/topics/01.01.00.JuneauEcosystemOverview.md
@@ -30,7 +30,11 @@ The Juneau ecosystem consists of the following parts:
| | [juneau‑microservice‑jetty](/docs/topics/JuneauMicroserviceJettyBasics) |
Jetty-based microservice implementation | • Jetty 9.4+ |
| **juneau-petstore** | [juneau‑petstore](/docs/topics/JuneauPetstoreBasics) |
Complete REST application example | • Spring Boot 2.0+ |
| **juneau-examples** |
[juneau‑examples‑core](/docs/topics/JuneauExamplesCore)<br/>[juneau‑examples‑rest](/docs/topics/JuneauExamplesRest)<br/>[juneau‑examples‑rest‑jetty](/docs/topics/JuneauExamplesRestJetty)<br/>[juneau‑examples‑rest‑springboot](/docs/topics/JuneauExamplesRestSpringboot)
| Code examples and tutorials | |
-| **juneau‑all** | [juneau‑all](/docs/topics/JuneauAllBasics) | Convenience
dependency combining all core Juneau modules | • Servlet 3.1+<br/>• Apache
HttpClient 4.5+ |
+| **juneau-shaded** | [juneau‑shaded‑core](/docs/topics/JuneauAllBasics) |
Core marshalling and configuration in one JAR (2.1 MB) | • *None* |
+| | [juneau‑shaded‑rest‑client](/docs/topics/JuneauAllBasics) | Core + REST
client functionality (3.8 MB) | • Apache HttpClient 5.x |
+| | [juneau‑shaded‑rest‑server](/docs/topics/JuneauAllBasics) | Core + REST
server functionality (3.8 MB) | • Servlet API 6.1+ |
+| | [juneau‑shaded‑rest‑server‑springboot](/docs/topics/JuneauAllBasics) |
REST server + Spring Boot integration (3.8 MB) | • Spring Boot 3.x |
+| | [juneau‑shaded‑all](/docs/topics/JuneauAllBasics) | Complete framework in
one JAR (4.0 MB)<br/>*Ideal for Bazel and simplified dependency management* | •
Servlet API 6.1+<br/>• Apache HttpClient 5.x |
The current version of Juneau is `9.1.0`.
@@ -39,11 +43,22 @@ The easiest way to pull in the library is through the
following maven dependency
```xml
<dependency>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau‑all</artifactId>
+ <artifactId>juneau‑shaded‑all</artifactId>
<version>${juneau.version}</version>
</dependency>
```
+Or for Bazel:
+
+```python
+maven_jar(
+ name = "juneau_all",
+ artifact = "org.apache.juneau:juneau-shaded-all:${juneau.version}",
+)
+```
+
+For more specific use cases, consider using one of the other shaded artifacts
listed above, or individual modules from `juneau-core` and `juneau-rest`.
+
If you would like to work with the bleeding-edge code, you can access the
`9.2.0-SNAPSHOT` version through the
following repository:
diff --git a/juneau-docs/docs/topics/19.01.00.JuneauAllBasics.md
b/juneau-docs/docs/topics/19.01.00.JuneauAllBasics.md
deleted file mode 100644
index e8d7d8c76b..0000000000
--- a/juneau-docs/docs/topics/19.01.00.JuneauAllBasics.md
+++ /dev/null
@@ -1,63 +0,0 @@
----
-title: "juneau-all"
-slug: JuneauAllBasics
----
-
-The `juneau-all` artifact is a convenience dependency that includes all the
core Juneau modules in a single JAR file. This makes it easy to get started
with Juneau by adding just one dependency to your project.
-
-## What's Included
-
-The `juneau-all` artifact combines the following modules:
-
-- **[juneau-marshall](/docs/topics/JuneauMarshallBasics)** - Serializers and
parsers for JSON, XML, HTML, URL-Encoding, UON, OpenAPI, PlainText, CSV, SOAP,
and MessagePack
-- **[juneau-bean-atom](/docs/topics/JuneauBeanAtom)** - ATOM Data Transfer
Object Beans
-- **[juneau-bean-common](/docs/topics/JuneauBeanCommon)** - Common Data
Transfer Object Beans
-- **[juneau-bean-html5](/docs/topics/JuneauBeanHtml5)** - HTML5 Data Transfer
Object Beans
-- **[juneau-bean-jsonschema](/docs/topics/JuneauBeanJsonSchema)** - JSON
Schema Data Transfer Object Beans
-- **[juneau-bean-openapi-v3](/docs/topics/JuneauBeanOpenApi3)** - OpenAPI 3
Data Transfer Object Beans
-- **[juneau-config](/docs/topics/JuneauConfigBasics)** - Configuration File API
-- **[juneau-assertions](/docs/topics/JuneauAssertionBasics)** - Fluent-style
assertions API
-- **[juneau-bct](/docs/topics/JuneauBctBasics)** - Bean-Centric Testing
framework
-- **[juneau-rest-common](/docs/topics/JuneauRestCommonBasics)** - REST APIs
common to client and server side
-- **[juneau-rest-server](/docs/topics/JuneauRestServerBasics)** - REST Servlet
API
-- **[juneau-rest-client](/docs/topics/JuneauRestClientBasics)** - REST Client
API
-
-## Maven Dependency
-
-To use `juneau-all`, add the following dependency to your `pom.xml`:
-
-```xml
-<dependency>
- <groupId>org.apache.juneau</groupId>
- <artifactId>juneau-all</artifactId>
- <version>${juneau.version}</version>
-</dependency>
-```
-
-## When to Use juneau-all
-
-Use `juneau-all` when you want to:
-
-- **Get started quickly** - Add one dependency and have access to all Juneau
functionality
-- **Build a complete application** - You need marshalling, REST server, and
REST client capabilities
-- **Simplify dependency management** - Avoid managing multiple individual
Juneau dependencies
-
-## When NOT to Use juneau-all
-
-Consider using individual modules instead when you:
-
-- **Want minimal dependencies** - Your application only needs specific Juneau
functionality
-- **Have size constraints** - The `juneau-all` JAR is larger than individual
modules
-- **Need specific versions** - You want to use different versions of
individual modules
-
-## Prerequisites
-
-- **Servlet 3.1+** (for REST server functionality)
-- **Apache HttpClient 4.5+** (for REST client functionality)
-
-## Next Steps
-
-- **[Getting Started Guide](/docs/topics/JuneauEcosystemOverview)** - Learn
how to get started with Juneau
-- **[REST Server Basics](/docs/topics/JuneauRestServerBasics)** - Learn how to
create REST APIs
-- **[REST Client Basics](/docs/topics/JuneauRestClientBasics)** - Learn how to
consume REST APIs
-- **[Marshalling Basics](/docs/topics/JuneauMarshallBasics)** - Learn how to
serialize and parse objects
diff --git a/juneau-docs/docs/topics/19.01.00.JuneauShadedOverview.md
b/juneau-docs/docs/topics/19.01.00.JuneauShadedOverview.md
new file mode 100644
index 0000000000..e308ab42ab
--- /dev/null
+++ b/juneau-docs/docs/topics/19.01.00.JuneauShadedOverview.md
@@ -0,0 +1,466 @@
+---
+title: "Juneau Shaded Artifacts"
+slug: JuneauShadedOverview
+---
+
+Juneau provides **shaded (uber) JAR artifacts** that bundle multiple Juneau
modules into single JAR files. These artifacts simplify dependency management
and are especially useful for build systems like Bazel that require explicit
dependency declarations.
+
+## What Are Shaded Artifacts?
+
+Shaded artifacts use the [Maven Shade
Plugin](https://maven.apache.org/plugins/maven-shade-plugin/) to:
+- Bundle multiple Juneau modules into a single JAR
+- Merge service provider files automatically
+- Eliminate the need to declare transitive Juneau dependencies
+- Maintain all original functionality without modification
+
+**Important**: Shaded artifacts only bundle Juneau modules. External
dependencies (like Apache HttpClient, Jakarta Servlet API, etc.) must still be
declared separately.
+
+## Available Shaded Artifacts
+
+| Artifact | Size | Description | Details |
+|----------|------|-------------|---------|
+| [juneau-shaded-core](/docs/topics/JuneauShadedCore) | 2.1 MB | Core
marshalling and configuration functionality | [Learn more
→](/docs/topics/JuneauShadedCore) |
+| [juneau-shaded-rest-client](/docs/topics/JuneauShadedRestClient) | 3.8 MB |
Core + REST client functionality | [Learn more
→](/docs/topics/JuneauShadedRestClient) |
+| [juneau-shaded-rest-server](/docs/topics/JuneauShadedRestServer) | 3.8 MB |
Core + REST server functionality | [Learn more
→](/docs/topics/JuneauShadedRestServer) |
+|
[juneau-shaded-rest-server-springboot](/docs/topics/JuneauShadedRestServerSpringboot)
| 3.8 MB | REST server + Spring Boot integration | [Learn more
→](/docs/topics/JuneauShadedRestServerSpringboot) |
+| [juneau-shaded-all](/docs/topics/JuneauShadedAll) | 4.0 MB | Complete Juneau
framework in one JAR | [Learn more →](/docs/topics/JuneauShadedAll) |
+
+## When to Use Shaded Artifacts
+
+### ✅ Use Shaded Artifacts When:
+
+- **Using Bazel or similar build systems** - These require explicit dependency
declarations; shaded artifacts simplify this significantly
+- **Wanting simplified dependency management** - One dependency instead of many
+- **Building standalone applications** - Uber JARs are convenient for
deployment
+- **Getting started quickly** - Fewer decisions about which modules to include
+
+### ❌ Consider Individual Modules When:
+
+- **Building a library** - Other projects may need fine-grained control over
dependencies
+- **Minimizing JAR size** - Individual modules allow excluding unused
functionality
+- **Avoiding classpath conflicts** - In complex applications with many
dependencies
+- **Needing different module versions** - Though this is rarely necessary
+
+## Quick Start
+
+### Maven
+
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-all</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+```
+
+### Bazel
+
+```python
+maven_jar(
+ name = "juneau_all",
+ artifact = "org.apache.juneau:juneau-shaded-all:${juneau.version}",
+)
+```
+
+## Why Shaded Artifacts for Bazel?
+
+Bazel enforces **strict dependency management** where you must explicitly
declare every direct dependency your code uses. Unlike Maven, which
automatically resolves transitive dependencies, Bazel requires you to know and
declare all dependencies.
+
+### The Problem with Regular Juneau in Bazel
+
+When using regular Juneau modules in Bazel:
+
+```python
+# This is incomplete and will fail!
+maven_jar(
+ name = "juneau_marshall",
+ artifact = "org.apache.juneau:juneau-marshall:9.2.0-SNAPSHOT",
+)
+
+java_library(
+ name = "my_lib",
+ srcs = ["MyCode.java"],
+ deps = ["@juneau_marshall//jar"], # Missing juneau-common!
+)
+```
+
+**Problem**: Your code can't compile because `juneau-marshall` depends on
`juneau-common`, but you didn't declare it.
+
+### Solution with Shaded Artifacts
+
+Just one dependency declaration!
+
+```python
+maven_jar(
+ name = "juneau_core",
+ artifact = "org.apache.juneau:juneau-shaded-core:9.2.0-SNAPSHOT",
+)
+
+java_library(
+ name = "my_lib",
+ srcs = ["MyCode.java"],
+ deps = ["@juneau_core//jar"], # Everything included!
+)
+```
+
+## Complete Bazel Examples
+
+### Example 1: REST Client
+
+**Scenario**: Build a REST client application.
+
+**WORKSPACE**:
+```python
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+# Add Maven dependencies
+maven_jar(
+ name = "juneau_rest_client",
+ artifact = "org.apache.juneau:juneau-shaded-rest-client:9.2.0-SNAPSHOT",
+ repository =
"https://repository.apache.org/content/repositories/snapshots/";,
+)
+
+# External dependencies (still need these)
+maven_jar(
+ name = "httpclient5",
+ artifact = "org.apache.httpcomponents.client5:httpclient5:5.2.1",
+)
+
+maven_jar(
+ name = "httpcore5",
+ artifact = "org.apache.httpcomponents.core5:httpcore5:5.2.1",
+)
+```
+
+**BUILD**:
+```python
+java_binary(
+ name = "my_rest_client",
+ srcs = ["MyRestClient.java"],
+ deps = [
+ "@juneau_rest_client//jar",
+ "@httpclient5//jar",
+ "@httpcore5//jar",
+ ],
+ main_class = "com.example.MyRestClient",
+)
+```
+
+### Example 2: REST Server
+
+**Scenario**: Build a REST server application.
+
+**WORKSPACE**:
+```python
+maven_jar(
+ name = "juneau_rest_server",
+ artifact = "org.apache.juneau:juneau-shaded-rest-server:9.2.0-SNAPSHOT",
+ repository =
"https://repository.apache.org/content/repositories/snapshots/";,
+)
+
+maven_jar(
+ name = "jakarta_servlet_api",
+ artifact = "jakarta.servlet:jakarta.servlet-api:6.1.0",
+)
+
+maven_jar(
+ name = "jetty_server",
+ artifact = "org.eclipse.jetty:jetty-server:12.0.5",
+)
+```
+
+**BUILD**:
+```python
+java_library(
+ name = "my_rest_server",
+ srcs = ["MyRestServer.java"],
+ deps = [
+ "@juneau_rest_server//jar",
+ "@jakarta_servlet_api//jar",
+ "@jetty_server//jar",
+ ],
+)
+```
+
+### Example 3: Spring Boot Integration
+
+**Scenario**: Build a Spring Boot + Juneau application.
+
+**WORKSPACE**:
+```python
+maven_jar(
+ name = "juneau_rest_server_springboot",
+ artifact =
"org.apache.juneau:juneau-shaded-rest-server-springboot:9.2.0-SNAPSHOT",
+ repository =
"https://repository.apache.org/content/repositories/snapshots/";,
+)
+
+maven_jar(
+ name = "spring_boot_starter_web",
+ artifact = "org.springframework.boot:spring-boot-starter-web:3.2.0",
+)
+```
+
+**BUILD**:
+```python
+java_library(
+ name = "my_spring_app",
+ srcs = glob(["src/**/*.java"]),
+ deps = [
+ "@juneau_rest_server_springboot//jar",
+ "@spring_boot_starter_web//jar",
+ ],
+)
+```
+
+### Example 4: Core Marshalling Only
+
+**Scenario**: Use Juneau for JSON/XML/etc. serialization without REST features.
+
+**WORKSPACE**:
+```python
+maven_jar(
+ name = "juneau_core",
+ artifact = "org.apache.juneau:juneau-shaded-core:9.2.0-SNAPSHOT",
+ repository =
"https://repository.apache.org/content/repositories/snapshots/";,
+)
+
+# Optional: For RDF support
+maven_jar(
+ name = "jena_core",
+ artifact = "org.apache.jena:jena-core:4.10.0",
+)
+```
+
+**BUILD**:
+```python
+java_library(
+ name = "my_serialization_lib",
+ srcs = ["MySerializer.java"],
+ deps = [
+ "@juneau_core//jar",
+ "@jena_core//jar", # Only if using RDF
+ ],
+)
+```
+
+### Example 5: Everything (Complete Framework)
+
+**Scenario**: You want access to all Juneau features.
+
+**WORKSPACE**:
+```python
+maven_jar(
+ name = "juneau_all",
+ artifact = "org.apache.juneau:juneau-shaded-all:9.2.0-SNAPSHOT",
+ repository =
"https://repository.apache.org/content/repositories/snapshots/";,
+)
+
+# Still need external dependencies
+maven_jar(
+ name = "jakarta_servlet_api",
+ artifact = "jakarta.servlet:jakarta.servlet-api:6.1.0",
+)
+
+maven_jar(
+ name = "httpclient5",
+ artifact = "org.apache.httpcomponents.client5:httpclient5:5.2.1",
+)
+```
+
+**BUILD**:
+```python
+java_library(
+ name = "my_full_app",
+ srcs = glob(["src/**/*.java"]),
+ deps = [
+ "@juneau_all//jar",
+ "@jakarta_servlet_api//jar",
+ "@httpclient5//jar",
+ ],
+)
+```
+
+## Finding External Dependencies
+
+Shaded JARs **only bundle Juneau modules**. External dependencies (like Apache
HttpClient, Jakarta Servlet API, etc.) must still be declared separately.
+
+### Method 1: Check the dependency-reduced-pom.xml
+
+After building a shaded module, examine:
+```bash
+cat juneau-shaded/juneau-shaded-rest-client/dependency-reduced-pom.xml
+```
+
+This file lists all external dependencies that the shaded JAR still requires.
+
+### Method 2: Use Maven dependency:tree
+
+```bash
+cd juneau-shaded/juneau-shaded-rest-client
+mvn dependency:tree
+```
+
+### Method 3: Common External Dependencies
+
+Here's a quick reference:
+
+| Juneau Shaded Artifact | Common External Dependencies |
+|------------------------|------------------------------|
+| `juneau-shaded-core` | `jakarta.xml.bind-api`, `jena-core` (for RDF) |
+| `juneau-shaded-rest-client` | `httpclient5`, `httpcore5`,
`jakarta.servlet-api` |
+| `juneau-shaded-rest-server` | `jakarta.servlet-api`, `jetty-server` |
+| `juneau-shaded-rest-server-springboot` | `spring-boot-starter-web`,
`jakarta.servlet-api` |
+| `juneau-shaded-all` | All of the above |
+
+## Advanced: Using rules_jvm_external
+
+For more sophisticated Bazel builds, use `rules_jvm_external`:
+
+**WORKSPACE**:
+```python
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+RULES_JVM_EXTERNAL_TAG = "5.3"
+RULES_JVM_EXTERNAL_SHA =
"d31e369b854322ca5098ea12c69d7175ded971435e55c18dd9dd5f29cc5249ac"
+
+http_archive(
+ name = "rules_jvm_external",
+ strip_prefix = "rules_jvm_external-%s" % RULES_JVM_EXTERNAL_TAG,
+ sha256 = RULES_JVM_EXTERNAL_SHA,
+ url =
"https://github.com/bazelbuild/rules_jvm_external/releases/download/%s/rules_jvm_external-%s.tar.gz";
% (RULES_JVM_EXTERNAL_TAG, RULES_JVM_EXTERNAL_TAG),
+)
+
+load("@rules_jvm_external//:defs.bzl", "maven_install")
+
+maven_install(
+ artifacts = [
+ "org.apache.juneau:juneau-shaded-rest-client:9.2.0-SNAPSHOT",
+ "org.apache.httpcomponents.client5:httpclient5:5.2.1",
+ "org.apache.httpcomponents.core5:httpcore5:5.2.1",
+ ],
+ repositories = [
+ "https://repository.apache.org/content/repositories/snapshots/";,
+ "https://repo1.maven.org/maven2";,
+ ],
+ fetch_sources = True,
+)
+```
+
+**BUILD**:
+```python
+java_binary(
+ name = "my_app",
+ srcs = ["MyApp.java"],
+ deps = [
+ "@maven//:org_apache_juneau_juneau_shaded_rest_client",
+ "@maven//:org_apache_httpcomponents_client5_httpclient5",
+ "@maven//:org_apache_httpcomponents_core5_httpcore5",
+ ],
+ main_class = "com.example.MyApp",
+)
+```
+
+## Bazel Troubleshooting
+
+### Build fails with "package X does not exist"
+
+**Cause**: You're missing an external dependency.
+
+**Solution**: Check the `dependency-reduced-pom.xml` for the shaded module and
add the missing dependency to your WORKSPACE.
+
+### Conflicting versions of dependencies
+
+**Cause**: Multiple artifacts depend on different versions of the same library.
+
+**Solution**: Use `rules_jvm_external` with version resolution:
+
+```python
+maven_install(
+ artifacts = [
+ "org.apache.juneau:juneau-shaded-rest-client:9.2.0-SNAPSHOT",
+ "org.apache.httpcomponents.client5:httpclient5:5.2.1",
+ ],
+ version_conflict_policy = "pinned", # Use specific versions
+)
+```
+
+### Shaded JAR is too large
+
+**Cause**: You're using `juneau-shaded-all` when you only need a subset.
+
+**Solution**: Use a more specific shaded artifact:
+- For client only: `juneau-shaded-rest-client`
+- For server only: `juneau-shaded-rest-server`
+- For core only: `juneau-shaded-core`
+
+## Bazel Best Practices
+
+1. **Start with the smallest shaded artifact** that meets your needs
+2. **Always check `dependency-reduced-pom.xml`** for external dependencies
+3. **Use `rules_jvm_external`** for production Bazel builds
+4. **Pin dependency versions** to ensure reproducible builds
+5. **Document external dependencies** in your project's README
+
+## Performance Considerations
+
+### Build Time
+- **Shaded JARs**: Faster builds due to fewer dependency declarations
+- **Individual Modules**: More explicit control but slower due to transitive
resolution
+
+### Runtime
+- No runtime difference between shaded and non-shaded artifacts
+- Same classes, same performance characteristics
+
+### JAR Size
+- Shaded JARs are larger but self-contained
+- For microservices, this is usually acceptable
+- For libraries, consider using individual modules
+
+## Architecture
+
+The shaded modules form a dependency hierarchy:
+
+```
+juneau-shaded-core (2.1 MB)
+ ↓
+ ├─→ juneau-shaded-rest-client (3.8 MB)
+ │
+ └─→ juneau-shaded-rest-server (3.8 MB)
+ ↓
+ └─→ juneau-shaded-rest-server-springboot (3.8 MB)
+
+juneau-shaded-all (4.0 MB)
+ = juneau-shaded-rest-server-springboot
+ + juneau-rest-client
+ + all bean modules
+ + all microservice modules
+```
+
+## Distribution
+
+All shaded artifacts are included in the binary distribution under the
`/shaded` directory:
+
+```
+apache-juneau-${version}-bin.zip
+└── shaded/
+ ├── juneau-shaded-core-${version}.jar
+ ├── juneau-shaded-rest-client-${version}.jar
+ ├── juneau-shaded-rest-server-${version}.jar
+ ├── juneau-shaded-rest-server-springboot-${version}.jar
+ └── juneau-shaded-all-${version}.jar
+```
+
+## Learn More
+
+### Individual Shaded Artifacts
+- **[Juneau Shaded Core](/docs/topics/JuneauShadedCore)** - Core marshalling
and configuration
+- **[Juneau Shaded REST Client](/docs/topics/JuneauShadedRestClient)** - REST
client development
+- **[Juneau Shaded REST Server](/docs/topics/JuneauShadedRestServer)** - REST
server development
+- **[Juneau Shaded REST Server Spring
Boot](/docs/topics/JuneauShadedRestServerSpringboot)** - Spring Boot integration
+- **[Juneau Shaded All](/docs/topics/JuneauShadedAll)** - Complete framework
+
+### Additional Resources
+- **[Shaded Module README](/juneau-shaded/README.md)** - Complete technical
documentation
+- **[Juneau Documentation](https://juneau.apache.org)** - Official Juneau docs
+- **[Bazel Documentation](https://bazel.build)** - Learn more about Bazel
+- **[Apache Juneau Mailing List](mailto:[email protected])** - Get help
from the community
diff --git a/juneau-docs/docs/topics/19.02.00.JuneauShadedCore.md
b/juneau-docs/docs/topics/19.02.00.JuneauShadedCore.md
new file mode 100644
index 0000000000..53e0e01427
--- /dev/null
+++ b/juneau-docs/docs/topics/19.02.00.JuneauShadedCore.md
@@ -0,0 +1,196 @@
+---
+title: "juneau-shaded-core"
+slug: JuneauShadedCore
+---
+
+The `juneau-shaded-core` artifact bundles all core Juneau modules for general
marshalling and configuration work. At 2.1 MB, it's the smallest shaded
artifact and ideal for applications that don't need REST functionality.
+
+## What's Included
+
+This artifact includes the following Juneau modules:
+
+- **juneau-common** - Core utilities and common classes
+- **juneau-assertions** - Fluent-style assertions API
+- **juneau-bct** - Bean-Centric Testing framework
+- **juneau-config** - Configuration file API
+- **juneau-marshall** - Serializers and parsers (JSON, XML, HTML, MessagePack,
etc.)
+- **juneau-marshall-rdf** - RDF serializers and parsers
+
+### Serialization Formats Supported
+
+- **JSON** - Multiple flavors (standard, simplified, lax)
+- **XML** - Standard and namespaced XML
+- **HTML** - HTML5 and table-based serialization
+- **RDF** - RDF/XML, N3, N-Triple, Turtle
+- **URL-Encoding** - URL-encoded form data
+- **UON** - URL-Encoded Object Notation
+- **OpenAPI** - OpenAPI-style serialization
+- **MessagePack** - Binary serialization
+- **PlainText** - Simple text serialization
+- **CSV** - Comma-separated values
+- **SOAP/XML** - SOAP-style XML
+
+## Use Cases
+
+Use `juneau-shaded-core` when you need:
+
+- **Serialization/Deserialization** - Convert POJOs to/from various formats
+- **Configuration Management** - Use the Config API for application settings
+- **Testing** - Use the assertion and BCT frameworks for unit tests
+- **Data Transformation** - Convert between different data formats
+- **No REST APIs** - You don't need REST client or server functionality
+
+## Maven Dependency
+
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-core</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+```
+
+## Bazel Dependency
+
+```python
+maven_jar(
+ name = "juneau_core",
+ artifact = "org.apache.juneau:juneau-shaded-core:${juneau.version}",
+)
+
+# Add to your java_library or java_binary
+java_library(
+ name = "my_lib",
+ srcs = ["MyCode.java"],
+ deps = ["@juneau_core//jar"],
+)
+```
+
+## External Dependencies
+
+`juneau-shaded-core` requires the following external dependencies:
+
+### Required
+- **Jakarta XML Bind API 3.0+** - For XML serialization support
+
+### Optional (for RDF support)
+- **Apache Jena Core 2.7.1+** - RDF parsing and serialization
+- **Apache Jena IRI 0.9.4+** - IRI validation
+- **Xerces 2.10.0+** - XML parsing
+- **SLF4J 1.6.4+** - Logging (used by Jena)
+
+If you don't need RDF support, you can exclude the RDF-related classes or
simply not use them.
+
+## Example Usage
+
+### Basic Serialization
+
+```java
+import org.apache.juneau.json.*;
+import org.apache.juneau.xml.*;
+
+public class SerializationExample {
+ public static void main(String[] args) throws Exception {
+ Person person = new Person("John Smith", 42);
+
+ // Serialize to JSON
+ String json = Json.of(person);
+ System.out.println(json);
+ // Output: {name:"John Smith",age:42}
+
+ // Serialize to XML
+ String xml = Xml.of(person);
+ System.out.println(xml);
+ // Output: <object><name>John Smith</name><age>42</age></object>
+
+ // Parse back from JSON
+ Person p2 = Json.to(json, Person.class);
+ }
+}
+```
+
+### Configuration Management
+
+```java
+import org.apache.juneau.config.*;
+
+public class ConfigExample {
+ public static void main(String[] args) throws Exception {
+ Config config = Config.create("myapp.cfg").build();
+
+ // Get values with defaults
+ String host = config.get("Server/host").orElse("localhost");
+ int port = config.get("Server/port").asInteger().orElse(8080);
+
+ // Set values
+ config.set("Server/host", "example.com");
+ config.commit();
+ }
+}
+```
+
+### Bean-Centric Testing
+
+```java
+import static org.apache.juneau.junit.bct.BctAssertions.*;
+
+public class BctExample {
+ @Test
+ public void testPerson() {
+ Person person = new Person("John", 42);
+
+ assertBean(person)
+ .is("name", "John")
+ .is("age", 42);
+
+ assertBean(person).asJson()
+ .is("{name:'John',age:42}");
+ }
+}
+```
+
+## Performance Characteristics
+
+- **Serialization**: Fast, memory-efficient
+- **Parsing**: Safe from deserialization attacks
+- **JAR Size**: 2.1 MB (smallest shaded artifact)
+- **Startup Time**: Minimal - no classpath scanning or code generation
+
+## Migration from Individual Modules
+
+If you're currently using individual core modules:
+
+**Before:**
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-marshall</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-config</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+<!-- ... more dependencies -->
+```
+
+**After:**
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-core</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+```
+
+All imports and API usage remain exactly the same!
+
+## Next Steps
+
+- **Need REST client functionality?** Use
[juneau-shaded-rest-client](/docs/topics/JuneauShadedRestClient)
+- **Need REST server functionality?** Use
[juneau-shaded-rest-server](/docs/topics/JuneauShadedRestServer)
+- **Need everything?** Use [juneau-shaded-all](/docs/topics/JuneauShadedAll)
+- **Learn about marshalling:** See [Marshalling
Basics](/docs/topics/JuneauMarshallBasics)
+- **Learn about configuration:** See [Config
Basics](/docs/topics/JuneauConfigBasics)
+
diff --git a/juneau-docs/docs/topics/19.03.00.JuneauShadedRestClient.md
b/juneau-docs/docs/topics/19.03.00.JuneauShadedRestClient.md
new file mode 100644
index 0000000000..a9088ec408
--- /dev/null
+++ b/juneau-docs/docs/topics/19.03.00.JuneauShadedRestClient.md
@@ -0,0 +1,283 @@
+---
+title: "juneau-shaded-rest-client"
+slug: JuneauShadedRestClient
+---
+
+The `juneau-shaded-rest-client` artifact bundles all core Juneau modules plus
REST client functionality. At 3.8 MB, it provides everything needed for
building REST client applications.
+
+## What's Included
+
+This artifact includes:
+
+- **All modules from [juneau-shaded-core](/docs/topics/JuneauShadedCore)**
(marshalling, config, testing)
+- **juneau-rest-common** - REST APIs common to client and server
+- **juneau-rest-client** - Full-featured REST client API
+- **juneau-rest-mock** - REST testing utilities
+
+## Use Cases
+
+Use `juneau-shaded-rest-client` when you need:
+
+- **REST API consumption** - Call external REST services
+- **Type-safe clients** - Use remote interfaces and proxies
+- **Advanced HTTP features** - Interceptors, authentication, retries
+- **Serialization flexibility** - Automatic content negotiation
+- **Testing REST endpoints** - Use the mock REST framework
+
+## Maven Dependency
+
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-rest-client</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+```
+
+## Bazel Dependency
+
+```python
+maven_jar(
+ name = "juneau_rest_client",
+ artifact = "org.apache.juneau:juneau-shaded-rest-client:${juneau.version}",
+)
+
+# External dependencies
+maven_jar(
+ name = "httpclient5",
+ artifact = "org.apache.httpcomponents.client5:httpclient5:5.2.1",
+)
+
+maven_jar(
+ name = "httpcore5",
+ artifact = "org.apache.httpcomponents.core5:httpcore5:5.2.1",
+)
+
+java_binary(
+ name = "my_client",
+ srcs = ["MyClient.java"],
+ deps = [
+ "@juneau_rest_client//jar",
+ "@httpclient5//jar",
+ "@httpcore5//jar",
+ ],
+)
+```
+
+## External Dependencies
+
+`juneau-shaded-rest-client` requires:
+
+### Required
+- **Apache HttpClient 5.2+** - HTTP client implementation
+- **Apache HttpCore 5.2+** - HTTP core functionality
+
+### Optional
+- **Jakarta XML Bind API 3.0+** - For XML serialization
+- **Apache Jena** - For RDF support
+
+## Example Usage
+
+### Basic REST Call
+
+```java
+import org.apache.juneau.rest.client.*;
+
+public class RestClientExample {
+ public static void main(String[] args) {
+ try (RestClient client = RestClient.create().build()) {
+ // GET request
+ Person person = client.get("http://api.example.com/person/1";)
+ .run()
+ .getContent().as(Person.class);
+
+ System.out.println(person.getName());
+ }
+ }
+}
+```
+
+### POST with JSON
+
+```java
+try (RestClient client = RestClient.create().json().build()) {
+ Person newPerson = new Person("John Smith", 42);
+
+ // POST JSON
+ Person created = client.post("http://api.example.com/person";)
+ .content(newPerson)
+ .run()
+ .getContent().as(Person.class);
+
+ System.out.println("Created: " + created.getId());
+}
+```
+
+### Remote Proxies
+
+```java
+// Define interface
+@Remote(path="/petstore")
+public interface PetStore {
+ @RemoteGet("/pet/{petId}")
+ Pet getPet(@Path("petId") long id);
+
+ @RemotePost("/pet")
+ Pet createPet(@Content Pet pet);
+}
+
+// Use it
+try (RestClient client = RestClient.create().build()) {
+ PetStore store = client.getRemote(PetStore.class);
+
+ Pet pet = store.getPet(123);
+ System.out.println(pet.getName());
+}
+```
+
+### Try-With-Resources Pattern
+
+```java
+RestClient client = RestClient.create().build();
+
+try (RestRequest req = client.get("/api/data")) {
+ String response = req.run().getContent().asString();
+ System.out.println(response);
+} // Request and response are automatically closed
+```
+
+### Authentication
+
+```java
+// Basic authentication
+RestClient client = RestClient.create()
+ .basicAuth("user", "password")
+ .build();
+
+// Bearer token
+RestClient client = RestClient.create()
+ .headerData("Authorization", "Bearer " + token)
+ .build();
+
+// OAuth2
+RestClient client = RestClient.create()
+ .oauth2Bearer(tokenSupplier)
+ .build();
+```
+
+### Interceptors
+
+```java
+RestClient client = RestClient.create()
+ .interceptors(
+ // Log requests
+ (req) -> System.out.println("Calling: " + req.getUri()),
+
+ // Add custom headers
+ (req) -> req.header("X-Custom", "value"),
+
+ // Retry logic
+ RetryInterceptor.create().maxAttempts(3).build()
+ )
+ .build();
+```
+
+### Mock Testing
+
+```java
+import org.apache.juneau.rest.mock.*;
+
+@Test
+public void testRestClient() throws Exception {
+ MockRestClient client = MockRestClient.create(MyRestApi.class).build();
+
+ // Call the mocked API
+ String response = client.get("/test")
+ .run()
+ .getContent().asString();
+
+ assertEquals("expected", response);
+}
+```
+
+## Features
+
+### Content Negotiation
+Automatic serialization/deserialization based on `Accept` and `Content-Type`
headers:
+
+```java
+// Request JSON, get POJO
+Person person = client.get("/person/1")
+ .accept("application/json")
+ .run()
+ .getContent().as(Person.class);
+```
+
+### Error Handling
+
+```java
+try (RestClient client = RestClient.create().build()) {
+ String response = client.get("/api/data")
+ .run()
+ .assertStatus().is(200) // Assert successful
+ .getContent().asString();
+} catch (RestCallException e) {
+ System.err.println("HTTP " + e.getResponseCode());
+ System.err.println(e.getResponseMessage());
+}
+```
+
+### Request/Response Assertions
+
+```java
+client.get("/api/data")
+ .run()
+ .assertStatus().is(200)
+ .assertHeader("Content-Type").is("application/json")
+ .assertContent().contains("expected");
+```
+
+## Performance Characteristics
+
+- **Connection Pooling**: Built-in via Apache HttpClient
+- **Keep-Alive**: Automatic connection reuse
+- **Streaming**: Efficient memory usage for large responses
+- **Async Support**: Non-blocking operations available
+
+## Migration from Individual Modules
+
+**Before:**
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-marshall</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-rest-client</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-rest-common</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+```
+
+**After:**
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-rest-client</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+```
+
+## Next Steps
+
+- **Need server functionality too?** Use
[juneau-shaded-all](/docs/topics/JuneauShadedAll)
+- **Learn about REST client:** See [REST Client
Basics](/docs/topics/JuneauRestClientBasics)
+- **Learn about remote proxies:** See [Remote
Proxies](/docs/topics/RemoteProxies)
+- **Learn about marshalling:** See [Marshalling
Basics](/docs/topics/JuneauMarshallBasics)
+
diff --git a/juneau-docs/docs/topics/19.04.00.JuneauShadedRestServer.md
b/juneau-docs/docs/topics/19.04.00.JuneauShadedRestServer.md
new file mode 100644
index 0000000000..61b35ae75c
--- /dev/null
+++ b/juneau-docs/docs/topics/19.04.00.JuneauShadedRestServer.md
@@ -0,0 +1,388 @@
+---
+title: "juneau-shaded-rest-server"
+slug: JuneauShadedRestServer
+---
+
+The `juneau-shaded-rest-server` artifact bundles all core Juneau modules plus
REST server functionality. At 3.8 MB, it provides everything needed for
building REST server applications.
+
+## What's Included
+
+This artifact includes:
+
+- **All modules from [juneau-shaded-core](/docs/topics/JuneauShadedCore)**
(marshalling, config, testing)
+- **juneau-rest-common** - REST APIs common to client and server
+- **juneau-rest-server** - Full-featured REST servlet API
+- **juneau-rest-server-rdf** - RDF support for REST servers
+- **juneau-rest-mock** - REST testing utilities
+
+## Use Cases
+
+Use `juneau-shaded-rest-server` when you need:
+
+- **REST API development** - Create RESTful web services
+- **Servlet-based applications** - Deploy to any Servlet 6.1+ container
+- **Automatic content negotiation** - Support multiple formats automatically
+- **Swagger/OpenAPI integration** - Built-in API documentation
+- **Testing REST services** - Use the mock framework
+
+## Maven Dependency
+
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-rest-server</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+```
+
+## Bazel Dependency
+
+```python
+maven_jar(
+ name = "juneau_rest_server",
+ artifact = "org.apache.juneau:juneau-shaded-rest-server:${juneau.version}",
+)
+
+# External dependencies
+maven_jar(
+ name = "jakarta_servlet_api",
+ artifact = "jakarta.servlet:jakarta.servlet-api:6.1.0",
+)
+
+maven_jar(
+ name = "jetty_server",
+ artifact = "org.eclipse.jetty:jetty-server:12.0.5",
+)
+
+java_library(
+ name = "my_rest_api",
+ srcs = glob(["src/**/*.java"]),
+ deps = [
+ "@juneau_rest_server//jar",
+ "@jakarta_servlet_api//jar",
+ "@jetty_server//jar",
+ ],
+)
+```
+
+## External Dependencies
+
+`juneau-shaded-rest-server` requires:
+
+### Required
+- **Jakarta Servlet API 6.1+** - Servlet specification
+
+### Optional
+- **Jakarta XML Bind API 3.0+** - For XML serialization
+- **Apache Jena** - For RDF support
+- **Servlet Container** - Jetty, Tomcat, etc. (runtime dependency)
+
+## Example Usage
+
+### Basic REST Resource
+
+```java
+import org.apache.juneau.rest.annotation.*;
+import org.apache.juneau.rest.servlet.*;
+
+@Rest(
+ path="/petstore",
+ title="Petstore API",
+ description="Sample REST API"
+)
+public class PetStoreResource extends BasicRestServlet {
+
+ @RestGet(path="/pets")
+ public List<Pet> getPets() {
+ return petService.getAllPets();
+ }
+
+ @RestGet(path="/pets/{id}")
+ public Pet getPet(@Path int id) {
+ return petService.getPet(id);
+ }
+
+ @RestPost(path="/pets")
+ public Pet createPet(@Content Pet pet) {
+ return petService.createPet(pet);
+ }
+
+ @RestPut(path="/pets/{id}")
+ public Pet updatePet(@Path int id, @Content Pet pet) {
+ return petService.updatePet(id, pet);
+ }
+
+ @RestDelete(path="/pets/{id}")
+ public void deletePet(@Path int id) {
+ petService.deletePet(id);
+ }
+}
+```
+
+### Automatic Content Negotiation
+
+Juneau automatically serializes responses based on the `Accept` header:
+
+```java
+@RestGet(path="/person/{id}")
+public Person getPerson(@Path int id) {
+ return new Person("John Smith", 42);
+}
+
+// GET /person/1
+// Accept: application/json → {"name":"John Smith","age":42}
+// Accept: text/xml → <object><name>John
Smith</name><age>42</age></object>
+// Accept: text/html → <table>...</table>
+// Accept: text/plain → name=John Smith, age=42
+```
+
+### Request Body Parsing
+
+```java
+@RestPost(path="/person")
+public Person createPerson(@Content Person person) {
+ // person is automatically parsed from JSON, XML, etc.
+ return personService.create(person);
+}
+
+// POST /person
+// Content-Type: application/json
+// Body: {"name":"John","age":42}
+```
+
+### Path Parameters
+
+```java
+@RestGet(path="/users/{userId}/posts/{postId}")
+public Post getUserPost(
+ @Path("userId") int userId,
+ @Path("postId") int postId
+) {
+ return postService.getPost(userId, postId);
+}
+```
+
+### Query Parameters
+
+```java
+@RestGet(path="/search")
+public List<Result> search(
+ @Query("q") String query,
+ @Query("limit") @Default("10") int limit,
+ @Query("offset") @Default("0") int offset
+) {
+ return searchService.search(query, limit, offset);
+}
+
+// GET /search?q=juneau&limit=20&offset=40
+```
+
+### Request/Response Headers
+
+```java
+@RestGet(path="/data")
+public String getData(
+ @Header("User-Agent") String userAgent,
+ RestResponse res
+) {
+ res.setHeader("X-Custom", "value");
+ return "data";
+}
+```
+
+### Swagger/OpenAPI Integration
+
+```java
+@Rest(
+ path="/api",
+ swagger=@Swagger(
+ title="My API",
+ version="1.0",
+ description="API Description",
+ contact=@Contact(name="Support", email="[email protected]")
+ )
+)
+public class MyApi extends BasicRestServlet {
+
+ @RestGet(
+ path="/items",
+ summary="Get all items",
+ description="Returns a list of all items"
+ )
+ public List<Item> getItems() {
+ return itemService.getAll();
+ }
+}
+
+// Swagger UI available at: /api/swagger
+// OpenAPI JSON at: /api/openapi.json
+```
+
+### Exception Handling
+
+```java
+@RestGet(path="/person/{id}")
+public Person getPerson(@Path int id) throws NotFound {
+ Person person = personService.getPerson(id);
+ if (person == null)
+ throw new NotFound("Person not found: {0}", id);
+ return person;
+}
+
+// Returns HTTP 404 with error message
+```
+
+### Guards and Matchers
+
+```java
+@Rest(path="/admin")
+@RestGuard(AdminGuard.class) // Require admin role
+public class AdminResource extends BasicRestServlet {
+
+ @RestGet(path="/users")
+ public List<User> getUsers() {
+ return userService.getAllUsers();
+ }
+}
+
+public class AdminGuard extends RestGuard {
+ @Override
+ public boolean guard(RestRequest req, RestResponse res) {
+ return req.isUserInRole("admin");
+ }
+}
+```
+
+### Converters
+
+```java
+@Rest(
+ path="/api",
+ converters={Queryable.class, Introspectable.class}
+)
+public class MyApi extends BasicRestServlet {
+
+ @RestGet(path="/people")
+ public List<Person> getPeople() {
+ return personService.getAll();
+ }
+
+ // GET /people?s=age>21&v=name,age&o=age
+ // Returns filtered, sorted, and projected results
+}
+```
+
+### Configuration
+
+```java
+@Rest(
+ path="/api",
+ config="myapi.cfg", // External config file
+ defaultAccept="application/json",
+ defaultContentType="application/json",
+ maxInput="10M" // Limit request size
+)
+public class MyApi extends BasicRestServlet {
+ // ...
+}
+```
+
+## Features
+
+### Built-in Serializers/Parsers
+- JSON (multiple flavors)
+- XML
+- HTML (with customizable styling)
+- URL-Encoding
+- MessagePack
+- OpenAPI
+- Plain Text
+- CSV
+
+### Automatic Features
+- Content negotiation
+- Character encoding detection
+- GZIP compression
+- Request/response logging
+- Exception mapping
+- Bean validation
+
+### Advanced Features
+- Role-based security
+- Method-level guards
+- Request/response interceptors
+- Custom converters
+- File uploads/downloads
+- Server-sent events
+- HTTP/2 support (via container)
+
+## Testing with Mock Framework
+
+```java
+@Test
+public void testRestEndpoint() throws Exception {
+ MockRestClient client = MockRestClient.create(MyRestApi.class)
+ .json()
+ .build();
+
+ // Test GET
+ Person person = client.get("/person/1")
+ .run()
+ .assertStatus().is(200)
+ .getContent().as(Person.class);
+
+ assertEquals("John", person.getName());
+
+ // Test POST
+ Person newPerson = new Person("Jane", 30);
+ client.post("/person")
+ .content(newPerson)
+ .run()
+ .assertStatus().is(201);
+}
+```
+
+## Performance Characteristics
+
+- **Streaming**: Efficient memory usage for large requests/responses
+- **Thread-Safe**: All serializers/parsers are thread-safe
+- **Caching**: Bean metadata is cached for performance
+- **Minimal Overhead**: No reflection during serialization/parsing
+
+## Migration from Individual Modules
+
+**Before:**
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-marshall</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-rest-server</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-rest-common</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+```
+
+**After:**
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-rest-server</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+```
+
+## Next Steps
+
+- **Need Spring Boot?** Use
[juneau-shaded-rest-server-springboot](/docs/topics/JuneauShadedRestServerSpringboot)
+- **Need client functionality too?** Use
[juneau-shaded-all](/docs/topics/JuneauShadedAll)
+- **Learn about REST server:** See [REST Server
Basics](/docs/topics/JuneauRestServerBasics)
+- **Learn about Swagger integration:** See [Swagger
Integration](/docs/topics/SwaggerIntegration)
+
diff --git
a/juneau-docs/docs/topics/19.05.00.JuneauShadedRestServerSpringboot.md
b/juneau-docs/docs/topics/19.05.00.JuneauShadedRestServerSpringboot.md
new file mode 100644
index 0000000000..44848cb940
--- /dev/null
+++ b/juneau-docs/docs/topics/19.05.00.JuneauShadedRestServerSpringboot.md
@@ -0,0 +1,436 @@
+---
+title: "juneau-shaded-rest-server-springboot"
+slug: JuneauShadedRestServerSpringboot
+---
+
+The `juneau-shaded-rest-server-springboot` artifact bundles REST server
functionality plus Spring Boot integration. At 3.8 MB, it provides everything
needed for building Juneau REST services with Spring Boot.
+
+## What's Included
+
+This artifact includes:
+
+- **All modules from
[juneau-shaded-rest-server](/docs/topics/JuneauShadedRestServer)** (core + REST
server)
+- **juneau-rest-server-springboot** - Spring Boot auto-configuration and
integration
+
+## Use Cases
+
+Use `juneau-shaded-rest-server-springboot` when you need:
+
+- **Spring Boot applications** - Leverage Spring Boot's ecosystem
+- **Auto-configuration** - Automatic Juneau setup with Spring Boot
+- **Spring dependency injection** - Use `@Autowired` in REST resources
+- **Spring Security integration** - Leverage Spring's security framework
+- **Spring ecosystem** - Access to Spring Data, Spring Cloud, etc.
+
+## Maven Dependency
+
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-rest-server-springboot</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+```
+
+## Bazel Dependency
+
+```python
+maven_jar(
+ name = "juneau_rest_server_springboot",
+ artifact =
"org.apache.juneau:juneau-shaded-rest-server-springboot:${juneau.version}",
+)
+
+# External dependencies
+maven_jar(
+ name = "spring_boot_starter_web",
+ artifact = "org.springframework.boot:spring-boot-starter-web:3.2.0",
+)
+
+java_library(
+ name = "my_spring_api",
+ srcs = glob(["src/**/*.java"]),
+ deps = [
+ "@juneau_rest_server_springboot//jar",
+ "@spring_boot_starter_web//jar",
+ ],
+)
+```
+
+## External Dependencies
+
+`juneau-shaded-rest-server-springboot` requires:
+
+### Required
+- **Spring Boot Starter Web 3.0+** - Spring Boot web support
+- **Jakarta Servlet API 6.1+** - Servlet specification (transitively from
Spring Boot)
+
+### Optional
+- **Spring Boot Starter Security** - For Spring Security integration
+- **Jakarta XML Bind API 3.0+** - For XML serialization
+- **Apache Jena** - For RDF support
+
+## Example Usage
+
+### Spring Boot Application
+
+```java
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class MyApplication {
+ public static void main(String[] args) {
+ SpringApplication.run(MyApplication.class, args);
+ }
+}
+```
+
+### REST Resource with Spring Integration
+
+```java
+import org.apache.juneau.rest.annotation.*;
+import org.apache.juneau.rest.springboot.*;
+import org.springframework.beans.factory.annotation.Autowired;
+
+@Rest(
+ path="/api/pets",
+ title="Pet Store API"
+)
+public class PetResource extends SpringRestServlet {
+
+ @Autowired
+ private PetService petService; // Spring bean injection
+
+ @RestGet
+ public List<Pet> getAllPets() {
+ return petService.findAll();
+ }
+
+ @RestGet(path="/{id}")
+ public Pet getPet(@Path long id) {
+ return petService.findById(id)
+ .orElseThrow(() -> new NotFound("Pet not found"));
+ }
+
+ @RestPost
+ public Pet createPet(@Content Pet pet) {
+ return petService.save(pet);
+ }
+}
+```
+
+### Spring Configuration
+
+```java
+import org.springframework.context.annotation.Configuration;
+import org.apache.juneau.rest.springboot.JuneauRestInitializer;
+
+@Configuration
+public class JuneauConfig implements JuneauRestInitializer {
+
+ @Override
+ public void init(SpringRestServletBuilder builder) {
+ builder
+ .defaultAccept("application/json")
+ .defaultContentType("application/json")
+ .maxInput("10M");
+ }
+}
+```
+
+### Application Properties
+
+```properties
+# application.properties
+
+# Juneau settings
+juneau.defaultAccept=application/json
+juneau.defaultContentType=application/json
+juneau.maxInput=10M
+
+# Server settings
+server.port=8080
+server.servlet.context-path=/
+
+# Logging
+logging.level.org.apache.juneau=DEBUG
+```
+
+### Spring Security Integration
+
+```java
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import
org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.web.SecurityFilterChain;
+
+@Configuration
+public class SecurityConfig {
+
+ @Bean
+ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception
{
+ http
+ .authorizeHttpRequests(auth -> auth
+ .requestMatchers("/api/public/**").permitAll()
+ .requestMatchers("/api/admin/**").hasRole("ADMIN")
+ .anyRequest().authenticated()
+ )
+ .httpBasic();
+
+ return http.build();
+ }
+}
+```
+
+### Accessing Security Context
+
+```java
+@Rest(path="/api/users")
+public class UserResource extends SpringRestServlet {
+
+ @RestGet(path="/me")
+ public User getCurrentUser() {
+ Authentication auth = SecurityContextHolder.getContext()
+ .getAuthentication();
+
+ String username = auth.getName();
+ return userService.findByUsername(username);
+ }
+}
+```
+
+### Spring Data Integration
+
+```java
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface PetRepository extends JpaRepository<Pet, Long> {
+ List<Pet> findBySpecies(String species);
+}
+
+@Rest(path="/api/pets")
+public class PetResource extends SpringRestServlet {
+
+ @Autowired
+ private PetRepository petRepository;
+
+ @RestGet
+ public List<Pet> getAllPets(
+ @Query("species") String species
+ ) {
+ if (species != null)
+ return petRepository.findBySpecies(species);
+ return petRepository.findAll();
+ }
+}
+```
+
+### Transaction Management
+
+```java
+import org.springframework.transaction.annotation.Transactional;
+
+@Rest(path="/api/orders")
+public class OrderResource extends SpringRestServlet {
+
+ @Autowired
+ private OrderService orderService;
+
+ @RestPost
+ @Transactional
+ public Order createOrder(@Content Order order) {
+ // Transactional operation
+ return orderService.create(order);
+ }
+}
+```
+
+### Exception Handling with Spring
+
+```java
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+
+@ControllerAdvice
+public class GlobalExceptionHandler {
+
+ @ExceptionHandler(EntityNotFoundException.class)
+ public ResponseEntity<ErrorResponse> handleNotFound(
+ EntityNotFoundException ex
+ ) {
+ return ResponseEntity
+ .status(HttpStatus.NOT_FOUND)
+ .body(new ErrorResponse(ex.getMessage()));
+ }
+}
+```
+
+### Swagger Integration
+
+```java
+@Rest(
+ path="/api",
+ swagger=@Swagger(
+ title="Pet Store API",
+ version="1.0",
+ description="REST API for Pet Store",
+ contact=@Contact(
+ name="Support Team",
+ email="[email protected]"
+ ),
+ license=@License(
+ name="Apache 2.0",
+ url="http://www.apache.org/licenses/LICENSE-2.0.html";
+ )
+ )
+)
+public class PetStoreApi extends SpringRestServlet {
+ // Swagger UI at: http://localhost:8080/api/swagger
+ // OpenAPI JSON at: http://localhost:8080/api/openapi.json
+}
+```
+
+### Multi-Module Spring Boot Application
+
+```java
+// Main application
+@SpringBootApplication
+@ComponentScan(basePackages = {
+ "com.example.api",
+ "com.example.service"
+})
+public class MyApplication {
+ public static void main(String[] args) {
+ SpringApplication.run(MyApplication.class, args);
+ }
+}
+
+// REST resources in com.example.api
+@Rest(path="/users")
+@Component
+public class UserResource extends SpringRestServlet {
+ @Autowired
+ private UserService userService;
+ // ...
+}
+
+// Services in com.example.service
+@Service
+public class UserService {
+ @Autowired
+ private UserRepository userRepository;
+ // ...
+}
+```
+
+## Features
+
+### Spring Boot Auto-Configuration
+- Automatic servlet registration
+- Property-based configuration
+- Actuator integration
+- Metrics and health checks
+
+### Spring Ecosystem Integration
+- **Spring Data** - Database access
+- **Spring Security** - Authentication/authorization
+- **Spring Cloud** - Microservices patterns
+- **Spring Cache** - Caching abstraction
+- **Spring Scheduling** - Task scheduling
+
+### Juneau Features
+All features from
[juneau-shaded-rest-server](/docs/topics/JuneauShadedRestServer) plus:
+- Spring bean injection in REST resources
+- Access to Spring ApplicationContext
+- Integration with Spring's exception handling
+- Spring's AOP capabilities
+
+## Testing
+
+### Spring Boot Test
+
+```java
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+
+@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
+@ExtendWith(SpringExtension.class)
+public class PetResourceTest {
+
+ @Autowired
+ private TestRestTemplate restTemplate;
+
+ @Test
+ public void testGetAllPets() {
+ ResponseEntity<Pet[]> response = restTemplate
+ .getForEntity("/api/pets", Pet[].class);
+
+ assertEquals(HttpStatus.OK, response.getStatusCode());
+ assertTrue(response.getBody().length > 0);
+ }
+}
+```
+
+### MockMvc Integration
+
+```java
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.test.web.servlet.MockMvc;
+import static
org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static
org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+@WebMvcTest(PetResource.class)
+public class PetResourceMockMvcTest {
+
+ @Autowired
+ private MockMvc mockMvc;
+
+ @MockBean
+ private PetService petService;
+
+ @Test
+ public void testGetPet() throws Exception {
+ Pet pet = new Pet(1L, "Fluffy", "cat");
+ when(petService.findById(1L))
+ .thenReturn(Optional.of(pet));
+
+ mockMvc.perform(get("/api/pets/1"))
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.name").value("Fluffy"));
+ }
+}
+```
+
+## Migration from Individual Modules
+
+**Before:**
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-rest-server</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-rest-server-springboot</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+```
+
+**After:**
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-rest-server-springboot</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+```
+
+## Next Steps
+
+- **Need client functionality too?** Use
[juneau-shaded-all](/docs/topics/JuneauShadedAll)
+- **Learn about REST server:** See [REST Server
Basics](/docs/topics/JuneauRestServerBasics)
+- **Learn about Spring Boot integration:** See [Spring Boot
Integration](/docs/topics/SpringBootIntegration)
+- **Learn about Spring Security:** See [Spring Security
Integration](/docs/topics/SpringSecurityIntegration)
+
diff --git a/juneau-docs/docs/topics/19.06.00.JuneauShadedAll.md
b/juneau-docs/docs/topics/19.06.00.JuneauShadedAll.md
new file mode 100644
index 0000000000..ae7f2b9f32
--- /dev/null
+++ b/juneau-docs/docs/topics/19.06.00.JuneauShadedAll.md
@@ -0,0 +1,384 @@
+---
+title: "juneau-shaded-all"
+slug: JuneauShadedAll
+---
+
+The `juneau-shaded-all` artifact is the complete Juneau framework bundled in a
single 4.0 MB JAR file. It includes all core modules, REST client, REST server,
Spring Boot integration, bean DTOs, and microservice modules.
+
+## What's Included
+
+This artifact includes **everything**:
+
+### Core Modules
+- **juneau-common** - Core utilities
+- **juneau-assertions** - Fluent assertions API
+- **juneau-bct** - Bean-Centric Testing framework
+- **juneau-config** - Configuration file API
+- **juneau-marshall** - All serializers/parsers (JSON, XML, HTML, MessagePack,
etc.)
+- **juneau-marshall-rdf** - RDF serializers/parsers
+
+### REST Modules
+- **juneau-rest-common** - Common REST APIs
+- **juneau-rest-client** - REST client API
+- **juneau-rest-server** - REST server API
+- **juneau-rest-server-rdf** - RDF support for servers
+- **juneau-rest-server-springboot** - Spring Boot integration
+- **juneau-rest-mock** - REST testing utilities
+
+### Bean DTOs
+- **juneau-bean-common** - Common bean utilities
+- **juneau-bean-atom** - ATOM feed beans
+- **juneau-bean-html5** - HTML5 element beans
+- **juneau-bean-jsonschema** - JSON Schema beans (Draft 2020-12)
+- **juneau-bean-openapi-v3** - OpenAPI 3.0 beans
+- **juneau-bean-swagger-v2** - Swagger 2.0 beans
+
+### Microservice Modules
+- **juneau-microservice-core** - Core microservice functionality
+- **juneau-microservice-jetty** - Jetty-based microservice
+
+## Use Cases
+
+Use `juneau-shaded-all` when you:
+
+- **Want everything** - Need full access to all Juneau features
+- **Are getting started** - Simplest way to explore Juneau
+- **Build complete applications** - Need both client and server functionality
+- **Use Bazel or similar build systems** - Simplifies strict dependency
management
+- **Develop microservices** - Includes microservice support
+- **Need maximum flexibility** - Have all features available without
additional dependencies
+
+## Maven Dependency
+
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-all</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+```
+
+## Bazel Dependency
+
+```python
+maven_jar(
+ name = "juneau_all",
+ artifact = "org.apache.juneau:juneau-shaded-all:${juneau.version}",
+)
+
+# Common external dependencies
+maven_jar(
+ name = "httpclient5",
+ artifact = "org.apache.httpcomponents.client5:httpclient5:5.2.1",
+)
+
+maven_jar(
+ name = "jakarta_servlet_api",
+ artifact = "jakarta.servlet:jakarta.servlet-api:6.1.0",
+)
+
+java_binary(
+ name = "my_app",
+ srcs = glob(["src/**/*.java"]),
+ deps = [
+ "@juneau_all//jar",
+ "@httpclient5//jar",
+ "@jakarta_servlet_api//jar",
+ ],
+ main_class = "com.example.MyApp",
+)
+```
+
+## External Dependencies
+
+`juneau-shaded-all` requires the following external dependencies:
+
+### For REST Client
+- **Apache HttpClient 5.2+**
+- **Apache HttpCore 5.2+**
+
+### For REST Server
+- **Jakarta Servlet API 6.1+**
+- **Servlet Container** (Jetty, Tomcat, etc.)
+
+### For Spring Boot
+- **Spring Boot Starter Web 3.0+**
+
+### Optional
+- **Jakarta XML Bind API 3.0+** - For XML serialization
+- **Apache Jena** - For RDF support
+- **Spring Boot Starter Security** - For Spring Security integration
+
+## Example: Complete Microservice
+
+```java
+import org.apache.juneau.microservice.jetty.*;
+import org.apache.juneau.rest.annotation.*;
+import org.apache.juneau.rest.servlet.*;
+
+// Main application
+public class MyMicroservice {
+ public static void main(String[] args) throws Exception {
+ JettyMicroservice
+ .create()
+ .args(args)
+ .servlet(RootResource.class)
+ .build()
+ .start()
+ .join();
+ }
+}
+
+// Root resource
+@Rest(
+ path="/",
+ title="My Microservice",
+ description="Complete REST API example"
+)
+public class RootResource extends BasicRestServlet {
+
+ @RestGet(path="/")
+ public String home() {
+ return "Welcome to My Microservice!";
+ }
+
+ @RestGet(path="/api/data")
+ public List<Data> getData() {
+ return dataService.getAll();
+ }
+
+ @RestPost(path="/api/data")
+ public Data createData(@Content Data data) {
+ return dataService.create(data);
+ }
+}
+```
+
+## Example: Full-Stack Application
+
+```java
+// Server-side REST API
+@Rest(path="/api")
+public class MyApi extends BasicRestServlet {
+
+ @RestGet(path="/users")
+ public List<User> getUsers() {
+ return userService.getAllUsers();
+ }
+
+ @RestPost(path="/users")
+ public User createUser(@Content User user) {
+ return userService.createUser(user);
+ }
+}
+
+// Client-side consumption
+public class MyClient {
+ public static void main(String[] args) {
+ try (RestClient client = RestClient.create()
+ .json()
+ .rootUrl("http://localhost:8080";)
+ .build()) {
+
+ // GET users
+ List<User> users = client.get("/api/users")
+ .run()
+ .getContent().as(User[].class);
+
+ // POST new user
+ User newUser = new User("John", "[email protected]");
+ User created = client.post("/api/users")
+ .content(newUser)
+ .run()
+ .getContent().as(User.class);
+
+ System.out.println("Created: " + created.getName());
+ }
+ }
+}
+```
+
+## Example: Spring Boot Application
+
+```java
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class MySpringBootApp {
+ public static void main(String[] args) {
+ SpringApplication.run(MySpringBootApp.class, args);
+ }
+}
+
+@Rest(path="/api/products")
+@Component
+public class ProductResource extends SpringRestServlet {
+
+ @Autowired
+ private ProductRepository productRepository;
+
+ @RestGet
+ public List<Product> getAllProducts() {
+ return productRepository.findAll();
+ }
+
+ @RestGet(path="/{id}")
+ public Product getProduct(@Path long id) {
+ return productRepository.findById(id)
+ .orElseThrow(() -> new NotFound("Product not found"));
+ }
+
+ @RestPost
+ @Transactional
+ public Product createProduct(@Content Product product) {
+ return productRepository.save(product);
+ }
+}
+```
+
+## Example: Testing with All Features
+
+```java
+import static org.apache.juneau.junit.bct.BctAssertions.*;
+import org.apache.juneau.rest.mock.*;
+
+@Test
+public void testCompleteWorkflow() throws Exception {
+ // Bean testing
+ User user = new User("John", "[email protected]");
+ assertBean(user)
+ .is("name", "John")
+ .is("email", "[email protected]");
+
+ // Serialization testing
+ assertBean(user).asJson()
+ .is("{name:'John',email:'[email protected]'}");
+
+ // REST API testing
+ MockRestClient client = MockRestClient.create(MyApi.class)
+ .json()
+ .build();
+
+ User created = client.post("/users")
+ .content(user)
+ .run()
+ .assertStatus().is(201)
+ .getContent().as(User.class);
+
+ assertBean(created).is("name", "John");
+}
+```
+
+## Features at a Glance
+
+### Serialization
+- JSON, XML, HTML, RDF, MessagePack, CSV, SOAP, UON, OpenAPI, PlainText
+- Automatic content negotiation
+- Streaming support
+- Custom serializers/parsers
+
+### REST Client
+- Fluent API
+- Remote proxies
+- Authentication (Basic, Bearer, OAuth2, Custom)
+- Interceptors and retries
+- Connection pooling
+
+### REST Server
+- Annotation-based routing
+- Swagger/OpenAPI integration
+- Guards and matchers
+- Converters and validators
+- File uploads/downloads
+- Server-sent events
+
+### Configuration
+- Hierarchical config files
+- Variable resolution
+- Listeners and watchers
+- Multiple formats
+
+### Testing
+- Fluent assertions
+- Bean-centric testing
+- Mock REST clients/servers
+- Deep property navigation
+
+### Microservices
+- Jetty integration
+- Configuration management
+- Lifecycle hooks
+- Health checks and metrics
+
+## Performance
+
+- **JAR Size**: 4.0 MB (all features included)
+- **Memory**: Efficient bean introspection with caching
+- **Serialization**: Fast, memory-efficient
+- **Thread-Safe**: All components are thread-safe
+- **Startup**: Minimal - no classpath scanning or code generation
+
+## When NOT to Use
+
+Consider using more specific shaded artifacts if:
+
+- **Building a library** - Other projects may not need all features
+- **Size constraints** - Use `juneau-shaded-core` (2.1 MB) for core-only
+- **Client only** - Use `juneau-shaded-rest-client` (3.8 MB)
+- **Server only** - Use `juneau-shaded-rest-server` (3.8 MB)
+
+## Comparison with Other Shaded Artifacts
+
+| Artifact | Size | Use When |
+|----------|------|----------|
+| [juneau-shaded-core](/docs/topics/JuneauShadedCore) | 2.1 MB | Only need
marshalling/config |
+| [juneau-shaded-rest-client](/docs/topics/JuneauShadedRestClient) | 3.8 MB |
Building REST clients |
+| [juneau-shaded-rest-server](/docs/topics/JuneauShadedRestServer) | 3.8 MB |
Building REST servers |
+|
[juneau-shaded-rest-server-springboot](/docs/topics/JuneauShadedRestServerSpringboot)
| 3.8 MB | Using Spring Boot |
+| **juneau-shaded-all** | **4.0 MB** | **Need everything** |
+
+## Migration from Individual Modules
+
+**Before** (managing many dependencies):
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-marshall</artifactId>
+</dependency>
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-rest-client</artifactId>
+</dependency>
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-rest-server</artifactId>
+</dependency>
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-rest-server-springboot</artifactId>
+</dependency>
+<!-- ... many more -->
+```
+
+**After** (one dependency):
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-all</artifactId>
+ <version>${juneau.version}</version>
+</dependency>
+```
+
+All imports and API usage remain exactly the same!
+
+## Next Steps
+
+- **[Juneau Ecosystem Overview](/docs/topics/JuneauEcosystemOverview)** -
Explore all Juneau modules
+- **[REST Server Basics](/docs/topics/JuneauRestServerBasics)** - Build REST
APIs
+- **[REST Client Basics](/docs/topics/JuneauRestClientBasics)** - Consume REST
APIs
+- **[Marshalling Basics](/docs/topics/JuneauMarshallBasics)** -
Serialize/deserialize objects
+- **[Microservice Basics](/docs/topics/JuneauMicroserviceCoreBasics)** - Build
microservices
+- **[Spring Boot Integration](/docs/topics/SpringBootIntegration)** - Use with
Spring Boot
+- **[Bazel Usage Guide](/juneau-shaded/BAZEL_USAGE_EXAMPLES.md)** - Detailed
Bazel examples
+
diff --git a/juneau-docs/src/pages/downloads.md
b/juneau-docs/src/pages/downloads.md
index b0e18e146a..f2efddf132 100644
--- a/juneau-docs/src/pages/downloads.md
+++ b/juneau-docs/src/pages/downloads.md
@@ -11,7 +11,12 @@
### What's Included
#### Binaries
-- **`juneau-all.jar`** - Everything (except RDF, JAX/RS, and Microservice)
+- **`/shaded`** - Shaded (uber) JARs for simplified dependency management
+ - `juneau-shaded-core.jar` - Core marshalling and configuration (2.1 MB)
+ - `juneau-shaded-rest-client.jar` - Core + REST client functionality (3.8 MB)
+ - `juneau-shaded-rest-server.jar` - Core + REST server functionality (3.8 MB)
+ - `juneau-shaded-rest-server-springboot.jar` - REST server + Spring Boot
integration (3.8 MB)
+ - `juneau-shaded-all.jar` - Complete framework in one JAR (4.0 MB)
- **`/lib`** - Individual Jars
- `juneau-marshall.jar` - Marshalling
- `juneau-marshall-rdf.jar` - Marshalling RDF extension (requires Apache
Jena 2.7.1+)
@@ -61,7 +66,7 @@
</dependency>
<!-- ...where the artifactId is typically... -->
-<artifactId>juneau-all</artifactId>
+<artifactId>juneau-shaded-all</artifactId>
<!-- ...but can also be any of the following... -->
<artifactId>juneau-marshall</artifactId>
diff --git a/juneau-shaded/README.md b/juneau-shaded/README.md
new file mode 100644
index 0000000000..7bc79d5246
--- /dev/null
+++ b/juneau-shaded/README.md
@@ -0,0 +1,261 @@
+# Apache Juneau Shaded Artifacts
+
+This module contains shaded (uber) JAR artifacts that bundle multiple Juneau
modules together. These artifacts are useful for:
+
+1. **Bazel Build System**: Bazel requires explicit declaration of all
dependencies. Shaded JARs simplify this by bundling transitive dependencies.
+2. **Simplified Dependency Management**: Projects can include one shaded JAR
instead of managing multiple Juneau dependencies.
+3. **Reduced Build Configuration**: Less configuration needed in build files.
+
+## Available Shaded Artifacts
+
+### juneau-shaded-core
+**Artifact ID**: `juneau-shaded-core`
+**Description**: All core Juneau modules for general marshalling and
configuration work.
+
+**Includes**:
+- juneau-common
+- juneau-assertions
+- juneau-bct (Bean-Centric Testing)
+- juneau-config
+- juneau-marshall
+- juneau-marshall-rdf
+
+**Maven Usage**:
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-core</artifactId>
+ <version>9.2.0-SNAPSHOT</version>
+</dependency>
+```
+
+**Bazel Usage**:
+```python
+maven_jar(
+ name = "juneau_core",
+ artifact = "org.apache.juneau:juneau-shaded-core:9.2.0-SNAPSHOT",
+)
+```
+
+---
+
+### juneau-shaded-rest-client
+**Artifact ID**: `juneau-shaded-rest-client`
+**Description**: Everything needed for REST client development.
+
+**Includes**:
+- All modules from juneau-shaded-core
+- juneau-rest-common
+- juneau-rest-client
+- juneau-rest-mock
+
+**Maven Usage**:
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-rest-client</artifactId>
+ <version>9.2.0-SNAPSHOT</version>
+</dependency>
+```
+
+**Bazel Usage**:
+```python
+maven_jar(
+ name = "juneau_rest_client",
+ artifact = "org.apache.juneau:juneau-shaded-rest-client:9.2.0-SNAPSHOT",
+)
+```
+
+---
+
+### juneau-shaded-rest-server
+**Artifact ID**: `juneau-shaded-rest-server`
+**Description**: Everything needed for REST server development.
+
+**Includes**:
+- All modules from juneau-shaded-core
+- juneau-rest-common
+- juneau-rest-server
+- juneau-rest-server-rdf
+- juneau-rest-mock
+
+**Maven Usage**:
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-rest-server</artifactId>
+ <version>9.2.0-SNAPSHOT</version>
+</dependency>
+```
+
+**Bazel Usage**:
+```python
+maven_jar(
+ name = "juneau_rest_server",
+ artifact = "org.apache.juneau:juneau-shaded-rest-server:9.2.0-SNAPSHOT",
+)
+```
+
+---
+
+### juneau-shaded-rest-server-springboot
+**Artifact ID**: `juneau-shaded-rest-server-springboot`
+**Description**: Everything needed for REST server development with Spring
Boot integration.
+
+**Includes**:
+- All modules from juneau-shaded-rest-server
+- juneau-rest-server-springboot
+
+**Maven Usage**:
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-rest-server-springboot</artifactId>
+ <version>9.2.0-SNAPSHOT</version>
+</dependency>
+```
+
+**Bazel Usage**:
+```python
+maven_jar(
+ name = "juneau_rest_server_springboot",
+ artifact =
"org.apache.juneau:juneau-shaded-rest-server-springboot:9.2.0-SNAPSHOT",
+)
+```
+
+---
+
+### juneau-shaded-all
+**Artifact ID**: `juneau-shaded-all`
+**Description**: The complete Juneau framework in a single JAR (excludes unit
tests, examples, and distribution artifacts).
+
+**Includes**:
+- All modules from juneau-shaded-rest-server-springboot
+- juneau-rest-client
+- All juneau-bean modules (atom, html5, jsonschema, openapi-v3, swagger-v2)
+- All juneau-microservice modules (core, jetty)
+
+**Maven Usage**:
+```xml
+<dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-all</artifactId>
+ <version>9.2.0-SNAPSHOT</version>
+</dependency>
+```
+
+**Bazel Usage**:
+```python
+maven_jar(
+ name = "juneau_all",
+ artifact = "org.apache.juneau:juneau-shaded-all:9.2.0-SNAPSHOT",
+)
+```
+
+---
+
+## Important Notes
+
+### External Dependencies
+These shaded JARs **only** bundle Juneau modules. External dependencies (like
Apache HttpClient, Jakarta Servlet API, Spring Boot, etc.) are still declared
as transitive dependencies and must be managed separately.
+
+### Maven Dependency Resolution
+When using shaded artifacts in Maven, transitive dependencies are
automatically resolved. The generated `dependency-reduced-pom.xml` in each
shaded module shows the actual external dependencies that will be pulled in.
+
+### Bazel Dependency Resolution
+When using shaded artifacts in Bazel, you **must** explicitly declare all
external dependencies. To find out what external dependencies are needed:
+
+1. Check the `dependency-reduced-pom.xml` in the shaded module's target
directory after building
+2. Or use `mvn dependency:tree` on the shaded module
+3. Or refer to the individual Juneau module POMs to see their dependencies
+
+Example Bazel configuration with external dependencies:
+```python
+maven_jar(
+ name = "juneau_rest_client",
+ artifact = "org.apache.juneau:juneau-shaded-rest-client:9.2.0-SNAPSHOT",
+)
+
+maven_jar(
+ name = "httpclient",
+ artifact = "org.apache.httpcomponents.client5:httpclient5:5.2.1",
+)
+
+maven_jar(
+ name = "httpcore",
+ artifact = "org.apache.httpcomponents.core5:httpcore5:5.2.1",
+)
+
+# ... other external dependencies
+```
+
+### Service Files
+The Maven Shade Plugin automatically merges `META-INF/services` files from all
included modules, ensuring that service providers are properly registered.
+
+### Signatures
+JAR signature files (`*.SF`, `*.DSA`, `*.RSA`) are excluded from shaded JARs
to prevent signature validation errors.
+
+---
+
+## Building
+
+To build all shaded artifacts:
+
+```bash
+cd juneau-shaded
+mvn clean install
+```
+
+To build a specific shaded artifact:
+
+```bash
+cd juneau-shaded/juneau-shaded-core
+mvn clean install
+```
+
+---
+
+## Module Dependencies
+
+The shaded modules form a dependency hierarchy:
+
+```
+juneau-shaded-core
+ ↓
+juneau-shaded-rest-client
+ ↓ (separate branch)
+juneau-shaded-rest-server
+ ↓
+juneau-shaded-rest-server-springboot
+ ↓
+juneau-shaded-all (also includes rest-client + bean modules + microservice)
+```
+
+This hierarchy means:
+- `juneau-shaded-rest-client` depends on `juneau-shaded-core`
+- `juneau-shaded-rest-server` depends on `juneau-shaded-core`
+- `juneau-shaded-rest-server-springboot` depends on `juneau-shaded-rest-server`
+- `juneau-shaded-all` depends on `juneau-shaded-rest-server-springboot` plus
additional modules
+
+---
+
+## When to Use
+
+### Use Shaded JARs When:
+- Using Bazel or another build system with strict dependency requirements
+- You want simplified dependency management
+- You're building a standalone application
+- You want to minimize build configuration
+
+### Use Individual Modules When:
+- You need fine-grained control over dependencies
+- You're building a library that will be used by others
+- You want to minimize JAR size by excluding unused modules
+- You need to avoid potential classpath conflicts in complex applications
+
+---
+
+## License
+
+All shaded artifacts are licensed under the Apache License 2.0, same as the
rest of Apache Juneau.
+
diff --git a/juneau-all/pom.xml b/juneau-shaded/juneau-shaded-all/pom.xml
similarity index 51%
copy from juneau-all/pom.xml
copy to juneau-shaded/juneau-shaded-all/pom.xml
index 57a9ea8905..7bf7b97eae 100644
--- a/juneau-all/pom.xml
+++ b/juneau-shaded/juneau-shaded-all/pom.xml
@@ -21,95 +21,94 @@
<parent>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau</artifactId>
+ <artifactId>juneau-shaded</artifactId>
<version>9.2.0-SNAPSHOT</version>
</parent>
- <artifactId>juneau-all</artifactId>
- <name>juneau/all</name>
- <description>Apache Juneau UberJar</description>
- <packaging>jar</packaging>
+ <artifactId>juneau-shaded-all</artifactId>
+ <name>Apache Juneau All (Shaded)</name>
+ <description>
+ Shaded JAR containing all Juneau modules (excluding unit tests,
examples, and distribution artifacts).
+ Includes: juneau-core, juneau-bean, juneau-rest-client,
juneau-rest-server, juneau-rest-server-springboot, and juneau-microservice.
+ This artifact provides the complete Juneau framework in a
single JAR for maximum convenience.
+ </description>
<dependencies>
+ <!-- Use shaded rest-server-springboot which includes core and
server -->
<dependency>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau-marshall</artifactId>
+
<artifactId>juneau-shaded-rest-server-springboot</artifactId>
<version>${project.version}</version>
</dependency>
+
+ <!-- Also include rest-client separately (not part of server
chain) -->
<dependency>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau-rest-server</artifactId>
+ <artifactId>juneau-rest-client</artifactId>
<version>${project.version}</version>
</dependency>
+
+ <!-- Bean modules -->
<dependency>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau-rest-client</artifactId>
+ <artifactId>juneau-bean-common</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-bean-atom</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-bean-html5</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-bean-jsonschema</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau-rest-mock</artifactId>
+ <artifactId>juneau-bean-openapi-v3</artifactId>
<version>${project.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-bean-swagger-v2</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+
+ <!-- Microservice modules -->
<dependency>
<groupId>org.apache.juneau</groupId>
<artifactId>juneau-microservice-core</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
- <groupId>jakarta.servlet</groupId>
- <artifactId>jakarta.servlet-api</artifactId>
- <version>6.1.0</version>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-microservice-jetty</artifactId>
+ <version>${project.version}</version>
</dependency>
</dependencies>
<build>
<plugins>
-
- <!-- Creates our juneau-all jar file that's a combo of
our 4 modules. -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<configuration>
-
<createDependencyReducedPom>false</createDependencyReducedPom>
- <artifactSet>
- <includes>
-
<include>org.apache.juneau:juneau-common</include>
-
<include>org.apache.juneau:juneau-marshall</include>
-
<include>org.apache.juneau:juneau-svl</include>
-
<include>org.apache.juneau:juneau-config</include>
-
<include>org.apache.juneau:juneau-bean-atom</include>
-
<include>org.apache.juneau:juneau-bean-common</include>
-
<include>org.apache.juneau:juneau-bean-html5</include>
-
<include>org.apache.juneau:juneau-bean-jsonschema</include>
-
<include>org.apache.juneau:juneau-bean-openapi-v3</include>
-
<include>org.apache.juneau:juneau-bean-swagger-v2</include>
-
<include>org.apache.juneau:juneau-rest-server</include>
-
<include>org.apache.juneau:juneau-rest-client</include>
-
<include>org.apache.juneau:juneau-rest-mock</include>
-
<include>org.apache.juneau:juneau-microservice-core</include>
-
<include>org.apache.httpcomponents:httpcore</include>
- </includes>
- </artifactSet>
+ <transformers combine.children="append">
+ <transformer
implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+ <manifestEntries>
+
<Automatic-Module-Name>org.apache.juneau.all</Automatic-Module-Name>
+ </manifestEntries>
+ </transformer>
+ </transformers>
</configuration>
- <executions>
- <execution>
- <phase>package</phase>
- <goals>
- <goal>shade</goal>
- </goals>
- </execution>
- <execution>
- <id>source-jar</id>
- <goals>
- <goal>shade</goal>
- </goals>
- <configuration>
-
<createSourcesJar>true</createSourcesJar>
- </configuration>
- </execution>
- </executions>
</plugin>
</plugins>
</build>
</project>
+
diff --git a/juneau-all/pom.xml b/juneau-shaded/juneau-shaded-core/pom.xml
similarity index 50%
copy from juneau-all/pom.xml
copy to juneau-shaded/juneau-shaded-core/pom.xml
index 57a9ea8905..2ec38ecf7a 100644
--- a/juneau-all/pom.xml
+++ b/juneau-shaded/juneau-shaded-core/pom.xml
@@ -21,95 +21,68 @@
<parent>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau</artifactId>
+ <artifactId>juneau-shaded</artifactId>
<version>9.2.0-SNAPSHOT</version>
</parent>
- <artifactId>juneau-all</artifactId>
- <name>juneau/all</name>
- <description>Apache Juneau UberJar</description>
- <packaging>jar</packaging>
+ <artifactId>juneau-shaded-core</artifactId>
+ <name>Apache Juneau Core (Shaded)</name>
+ <description>
+ Shaded JAR containing all juneau-core submodules for general
marshalling work.
+ Includes: juneau-common, juneau-assertions, juneau-bct,
juneau-config, juneau-marshall, and juneau-marshall-rdf.
+ This artifact is useful for projects that need core Juneau
functionality without managing multiple dependencies.
+ </description>
<dependencies>
+ <!-- Include all juneau-core submodules -->
<dependency>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau-marshall</artifactId>
+ <artifactId>juneau-common</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau-rest-server</artifactId>
+ <artifactId>juneau-assertions</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau-rest-client</artifactId>
+ <artifactId>juneau-bct</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau-rest-mock</artifactId>
+ <artifactId>juneau-config</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau-microservice-core</artifactId>
+ <artifactId>juneau-marshall</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
- <groupId>jakarta.servlet</groupId>
- <artifactId>jakarta.servlet-api</artifactId>
- <version>6.1.0</version>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-marshall-rdf</artifactId>
+ <version>${project.version}</version>
</dependency>
</dependencies>
<build>
<plugins>
-
- <!-- Creates our juneau-all jar file that's a combo of
our 4 modules. -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<configuration>
-
<createDependencyReducedPom>false</createDependencyReducedPom>
- <artifactSet>
- <includes>
-
<include>org.apache.juneau:juneau-common</include>
-
<include>org.apache.juneau:juneau-marshall</include>
-
<include>org.apache.juneau:juneau-svl</include>
-
<include>org.apache.juneau:juneau-config</include>
-
<include>org.apache.juneau:juneau-bean-atom</include>
-
<include>org.apache.juneau:juneau-bean-common</include>
-
<include>org.apache.juneau:juneau-bean-html5</include>
-
<include>org.apache.juneau:juneau-bean-jsonschema</include>
-
<include>org.apache.juneau:juneau-bean-openapi-v3</include>
-
<include>org.apache.juneau:juneau-bean-swagger-v2</include>
-
<include>org.apache.juneau:juneau-rest-server</include>
-
<include>org.apache.juneau:juneau-rest-client</include>
-
<include>org.apache.juneau:juneau-rest-mock</include>
-
<include>org.apache.juneau:juneau-microservice-core</include>
-
<include>org.apache.httpcomponents:httpcore</include>
- </includes>
- </artifactSet>
+ <transformers combine.children="append">
+ <transformer
implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+ <manifestEntries>
+
<Automatic-Module-Name>org.apache.juneau.core.all</Automatic-Module-Name>
+ </manifestEntries>
+ </transformer>
+ </transformers>
</configuration>
- <executions>
- <execution>
- <phase>package</phase>
- <goals>
- <goal>shade</goal>
- </goals>
- </execution>
- <execution>
- <id>source-jar</id>
- <goals>
- <goal>shade</goal>
- </goals>
- <configuration>
-
<createSourcesJar>true</createSourcesJar>
- </configuration>
- </execution>
- </executions>
</plugin>
</plugins>
</build>
</project>
+
diff --git a/juneau-shaded/juneau-shaded-rest-client/pom.xml
b/juneau-shaded/juneau-shaded-rest-client/pom.xml
new file mode 100644
index 0000000000..b83abefe0e
--- /dev/null
+++ b/juneau-shaded/juneau-shaded-rest-client/pom.xml
@@ -0,0 +1,79 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0";
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance";
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
https://maven.apache.org/xsd/maven-4.0.0.xsd";>
+
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded</artifactId>
+ <version>9.2.0-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>juneau-shaded-rest-client</artifactId>
+ <name>Apache Juneau REST Client (Shaded)</name>
+ <description>
+ Shaded JAR containing juneau-core modules plus
juneau-rest-common, juneau-rest-client, and juneau-rest-mock.
+ This artifact provides everything needed for REST client
development with Juneau.
+ </description>
+
+ <dependencies>
+ <!-- Use shaded core for all core modules -->
+ <dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-core</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+
+ <!-- REST client modules -->
+ <dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-rest-common</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-rest-client</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-rest-mock</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-shade-plugin</artifactId>
+ <configuration>
+ <transformers combine.children="append">
+ <transformer
implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+ <manifestEntries>
+
<Automatic-Module-Name>org.apache.juneau.rest.client.all</Automatic-Module-Name>
+ </manifestEntries>
+ </transformer>
+ </transformers>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+</project>
+
diff --git a/juneau-shaded/juneau-shaded-rest-server-springboot/pom.xml
b/juneau-shaded/juneau-shaded-rest-server-springboot/pom.xml
new file mode 100644
index 0000000000..38da333614
--- /dev/null
+++ b/juneau-shaded/juneau-shaded-rest-server-springboot/pom.xml
@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0";
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance";
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
https://maven.apache.org/xsd/maven-4.0.0.xsd";>
+
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded</artifactId>
+ <version>9.2.0-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>juneau-shaded-rest-server-springboot</artifactId>
+ <name>Apache Juneau REST Server Spring Boot (Shaded)</name>
+ <description>
+ Shaded JAR containing juneau-shaded-rest-server plus
juneau-rest-server-springboot.
+ This artifact provides everything needed for REST server
development with Juneau and Spring Boot.
+ </description>
+
+ <dependencies>
+ <!-- Use shaded rest-server for all server modules -->
+ <dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-shaded-rest-server</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+
+ <!-- Spring Boot integration -->
+ <dependency>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau-rest-server-springboot</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-shade-plugin</artifactId>
+ <configuration>
+ <transformers combine.children="append">
+ <transformer
implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+ <manifestEntries>
+
<Automatic-Module-Name>org.apache.juneau.rest.server.springboot.all</Automatic-Module-Name>
+ </manifestEntries>
+ </transformer>
+ </transformers>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+</project>
+
diff --git a/juneau-all/pom.xml
b/juneau-shaded/juneau-shaded-rest-server/pom.xml
similarity index 51%
rename from juneau-all/pom.xml
rename to juneau-shaded/juneau-shaded-rest-server/pom.xml
index 57a9ea8905..40e8acf1b4 100644
--- a/juneau-all/pom.xml
+++ b/juneau-shaded/juneau-shaded-rest-server/pom.xml
@@ -21,95 +21,64 @@
<parent>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau</artifactId>
+ <artifactId>juneau-shaded</artifactId>
<version>9.2.0-SNAPSHOT</version>
</parent>
- <artifactId>juneau-all</artifactId>
- <name>juneau/all</name>
- <description>Apache Juneau UberJar</description>
- <packaging>jar</packaging>
+ <artifactId>juneau-shaded-rest-server</artifactId>
+ <name>Apache Juneau REST Server (Shaded)</name>
+ <description>
+ Shaded JAR containing juneau-core modules plus
juneau-rest-common, juneau-rest-server, juneau-rest-server-rdf, and
juneau-rest-mock.
+ This artifact provides everything needed for REST server
development with Juneau.
+ </description>
<dependencies>
+ <!-- Use shaded core for all core modules -->
<dependency>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau-marshall</artifactId>
+ <artifactId>juneau-shaded-core</artifactId>
<version>${project.version}</version>
</dependency>
+
+ <!-- REST server modules -->
<dependency>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau-rest-server</artifactId>
+ <artifactId>juneau-rest-common</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau-rest-client</artifactId>
+ <artifactId>juneau-rest-server</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau-rest-mock</artifactId>
+ <artifactId>juneau-rest-server-rdf</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.apache.juneau</groupId>
- <artifactId>juneau-microservice-core</artifactId>
+ <artifactId>juneau-rest-mock</artifactId>
<version>${project.version}</version>
</dependency>
- <dependency>
- <groupId>jakarta.servlet</groupId>
- <artifactId>jakarta.servlet-api</artifactId>
- <version>6.1.0</version>
- </dependency>
</dependencies>
<build>
<plugins>
-
- <!-- Creates our juneau-all jar file that's a combo of
our 4 modules. -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<configuration>
-
<createDependencyReducedPom>false</createDependencyReducedPom>
- <artifactSet>
- <includes>
-
<include>org.apache.juneau:juneau-common</include>
-
<include>org.apache.juneau:juneau-marshall</include>
-
<include>org.apache.juneau:juneau-svl</include>
-
<include>org.apache.juneau:juneau-config</include>
-
<include>org.apache.juneau:juneau-bean-atom</include>
-
<include>org.apache.juneau:juneau-bean-common</include>
-
<include>org.apache.juneau:juneau-bean-html5</include>
-
<include>org.apache.juneau:juneau-bean-jsonschema</include>
-
<include>org.apache.juneau:juneau-bean-openapi-v3</include>
-
<include>org.apache.juneau:juneau-bean-swagger-v2</include>
-
<include>org.apache.juneau:juneau-rest-server</include>
-
<include>org.apache.juneau:juneau-rest-client</include>
-
<include>org.apache.juneau:juneau-rest-mock</include>
-
<include>org.apache.juneau:juneau-microservice-core</include>
-
<include>org.apache.httpcomponents:httpcore</include>
- </includes>
- </artifactSet>
+ <transformers combine.children="append">
+ <transformer
implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+ <manifestEntries>
+
<Automatic-Module-Name>org.apache.juneau.rest.server.all</Automatic-Module-Name>
+ </manifestEntries>
+ </transformer>
+ </transformers>
</configuration>
- <executions>
- <execution>
- <phase>package</phase>
- <goals>
- <goal>shade</goal>
- </goals>
- </execution>
- <execution>
- <id>source-jar</id>
- <goals>
- <goal>shade</goal>
- </goals>
- <configuration>
-
<createSourcesJar>true</createSourcesJar>
- </configuration>
- </execution>
- </executions>
</plugin>
</plugins>
</build>
</project>
+
diff --git a/juneau-shaded/pom.xml b/juneau-shaded/pom.xml
new file mode 100644
index 0000000000..2708a078be
--- /dev/null
+++ b/juneau-shaded/pom.xml
@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0";
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance";
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
https://maven.apache.org/xsd/maven-4.0.0.xsd";>
+
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.apache.juneau</groupId>
+ <artifactId>juneau</artifactId>
+ <version>9.2.0-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>juneau-shaded</artifactId>
+ <packaging>pom</packaging>
+ <name>Apache Juneau Shaded Artifacts</name>
+ <description>
+ Parent module for shaded (uber) JAR artifacts that bundle
multiple Juneau modules together.
+ These artifacts are useful for build systems like Bazel that
require explicit dependencies,
+ or for simplified dependency management in projects that need
multiple Juneau modules.
+ </description>
+
+ <modules>
+ <module>juneau-shaded-core</module>
+ <module>juneau-shaded-rest-client</module>
+ <module>juneau-shaded-rest-server</module>
+ <module>juneau-shaded-rest-server-springboot</module>
+ <module>juneau-shaded-all</module>
+ </modules>
+
+ <build>
+ <pluginManagement>
+ <plugins>
+ <!-- Common shade plugin configuration for all
submodules -->
+ <plugin>
+
<groupId>org.apache.maven.plugins</groupId>
+
<artifactId>maven-shade-plugin</artifactId>
+ <version>3.5.1</version>
+ <executions>
+ <execution>
+ <phase>package</phase>
+ <goals>
+
<goal>shade</goal>
+ </goals>
+ <configuration>
+
<createDependencyReducedPom>true</createDependencyReducedPom>
+
<promoteTransitiveDependencies>true</promoteTransitiveDependencies>
+
+ <!-- Include
all Juneau dependencies -->
+ <artifactSet>
+
<includes>
+
<include>org.apache.juneau:*</include>
+
</includes>
+ </artifactSet>
+
+ <!-- Merge
service files and preserve manifests -->
+ <transformers>
+
<transformer
implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
+
<transformer
implementation="org.apache.maven.plugins.shade.resource.ApacheLicenseResourceTransformer"/>
+
<transformer
implementation="org.apache.maven.plugins.shade.resource.ApacheNoticeResourceTransformer">
+
<addHeader>false</addHeader>
+
</transformer>
+
<transformer
implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+
<manifestEntries>
+
<Implementation-Title>${project.name}</Implementation-Title>
+
<Implementation-Version>${project.version}</Implementation-Version>
+
<Implementation-Vendor>Apache Software
Foundation</Implementation-Vendor>
+
</manifestEntries>
+
</transformer>
+ </transformers>
+
+ <!-- Filter out
signature files -->
+ <filters>
+ <filter>
+
<artifact>*:*</artifact>
+
<excludes>
+
<exclude>META-INF/*.SF</exclude>
+
<exclude>META-INF/*.DSA</exclude>
+
<exclude>META-INF/*.RSA</exclude>
+
</excludes>
+
</filter>
+ </filters>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </pluginManagement>
+ </build>
+</project>
+
diff --git a/pom.xml b/pom.xml
index 26bf5f959e..0b69b7176f 100644
--- a/pom.xml
+++ b/pom.xml
@@ -55,7 +55,7 @@
<module>juneau-examples</module>
<module>juneau-utest</module>
<module>juneau-bean</module>
- <module>juneau-all</module>
+ <module>juneau-shaded</module>
<module>juneau-distrib</module>
</modules>
