/
WebappLoader.java
554 lines (439 loc) · 17.8 KB
/
WebappLoader.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
/*
* 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.
*/
package org.apache.catalina.loader;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.io.File;
import java.lang.reflect.Constructor;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.charset.StandardCharsets;
import javax.management.ObjectName;
import jakarta.servlet.ServletContext;
import org.apache.catalina.Context;
import org.apache.catalina.Globals;
import org.apache.catalina.LifecycleException;
import org.apache.catalina.LifecycleState;
import org.apache.catalina.Loader;
import org.apache.catalina.util.LifecycleMBeanBase;
import org.apache.catalina.util.ToStringUtil;
import org.apache.juli.logging.Log;
import org.apache.juli.logging.LogFactory;
import org.apache.tomcat.jakartaee.ClassConverter;
import org.apache.tomcat.jakartaee.EESpecProfile;
import org.apache.tomcat.jakartaee.EESpecProfiles;
import org.apache.tomcat.util.ExceptionUtils;
import org.apache.tomcat.util.buf.UDecoder;
import org.apache.tomcat.util.compat.JreCompat;
import org.apache.tomcat.util.modeler.Registry;
import org.apache.tomcat.util.res.StringManager;
/**
* Classloader implementation which is specialized for handling web applications in the most efficient way, while being
* Catalina aware (all accesses to resources are made through {@link org.apache.catalina.WebResourceRoot}). This class
* loader supports detection of modified Java classes, which can be used to implement auto-reload support.
* <p>
* This class loader is configured via the Resources children of its Context prior to calling <code>start()</code>. When
* a new class is required, these Resources will be consulted first to locate the class. If it is not present, the
* system class loader will be used instead.
*
* @author Craig R. McClanahan
* @author Remy Maucherat
*/
public class WebappLoader extends LifecycleMBeanBase implements Loader {
private static final Log log = LogFactory.getLog(WebappLoader.class);
// ----------------------------------------------------- Instance Variables
/**
* The class loader being managed by this Loader component.
*/
private WebappClassLoaderBase classLoader = null;
/**
* The Context with which this Loader has been associated.
*/
private Context context = null;
/**
* The "follow standard delegation model" flag that will be used to configure our ClassLoader.
*/
private boolean delegate = false;
/**
* The profile name which will be used by the converter, or null if not used. Any invalid profile value will default
* to the TOMCAT profile, which converts all packages used by Tomcat.
*/
private String jakartaConverter = null;
/**
* The Java class name of the ClassLoader implementation to be used. This class should extend WebappClassLoaderBase,
* otherwise, a different loader implementation must be used.
*/
private String loaderClass = ParallelWebappClassLoader.class.getName();
/**
* The string manager for this package.
*/
protected static final StringManager sm = StringManager.getManager(WebappLoader.class);
/**
* The property change support for this component.
*/
protected final PropertyChangeSupport support = new PropertyChangeSupport(this);
/**
* Classpath set in the loader.
*/
private String classpath = null;
// ------------------------------------------------------------- Properties
@Override
public ClassLoader getClassLoader() {
return classLoader;
}
@Override
public Context getContext() {
return context;
}
@Override
public void setContext(Context context) {
if (this.context == context) {
return;
}
if (getState().isAvailable()) {
throw new IllegalStateException(sm.getString("webappLoader.setContext.ise"));
}
// Process this property change
Context oldContext = this.context;
this.context = context;
support.firePropertyChange("context", oldContext, this.context);
}
@Override
public boolean getDelegate() {
return this.delegate;
}
@Override
public void setDelegate(boolean delegate) {
boolean oldDelegate = this.delegate;
this.delegate = delegate;
support.firePropertyChange("delegate", Boolean.valueOf(oldDelegate), Boolean.valueOf(this.delegate));
}
/**
* @return a non null String if the loader will attempt to use the Jakarta converter. The String is the name of the
* profile used for conversion.
*/
public String getJakartaConverter() {
return jakartaConverter;
}
/**
* Set the Jakarta converter.
*
* @param jakartaConverter The profile name which will be used by the converter Any invalid profile value will
* default to the TOMCAT profile, which converts all packages used by Tomcat.
*/
public void setJakartaConverter(String jakartaConverter) {
String oldJakartaConverter = this.jakartaConverter;
this.jakartaConverter = jakartaConverter;
support.firePropertyChange("jakartaConverter", oldJakartaConverter, this.jakartaConverter);
}
/**
* @return the ClassLoader class name.
*/
public String getLoaderClass() {
return this.loaderClass;
}
/**
* Set the ClassLoader class name.
*
* @param loaderClass The new ClassLoader class name
*/
public void setLoaderClass(String loaderClass) {
this.loaderClass = loaderClass;
}
/**
* Set the ClassLoader instance, without relying on reflection This method will also invoke
* {@link #setLoaderClass(String)} with {@code loaderInstance.getClass().getName()} as an argument
*
* @param loaderInstance The new ClassLoader instance to use
*/
public void setLoaderInstance(WebappClassLoaderBase loaderInstance) {
this.classLoader = loaderInstance;
setLoaderClass(loaderInstance.getClass().getName());
}
// --------------------------------------------------------- Public Methods
@Override
public void addPropertyChangeListener(PropertyChangeListener listener) {
support.addPropertyChangeListener(listener);
}
@Override
public void backgroundProcess() {
Context context = getContext();
if (context != null) {
if (context.getReloadable() && modified()) {
Thread currentThread = Thread.currentThread();
ClassLoader originalTccl = currentThread.getContextClassLoader();
try {
currentThread.setContextClassLoader(WebappLoader.class.getClassLoader());
context.reload();
} finally {
currentThread.setContextClassLoader(originalTccl);
}
}
}
}
public String[] getLoaderRepositories() {
if (classLoader == null) {
return new String[0];
}
URL[] urls = classLoader.getURLs();
String[] result = new String[urls.length];
for (int i = 0; i < urls.length; i++) {
result[i] = urls[i].toExternalForm();
}
return result;
}
public String getLoaderRepositoriesString() {
String repositories[] = getLoaderRepositories();
StringBuilder sb = new StringBuilder();
for (String repository : repositories) {
sb.append(repository).append(':');
}
return sb.toString();
}
/**
* Classpath, as set in org.apache.catalina.jsp_classpath context property
*
* @return The classpath
*/
public String getClasspath() {
return classpath;
}
@Override
public boolean modified() {
return classLoader != null ? classLoader.modified() : false;
}
@Override
public void removePropertyChangeListener(PropertyChangeListener listener) {
support.removePropertyChangeListener(listener);
}
@Override
public String toString() {
return ToStringUtil.toString(this, context);
}
/**
* Start associated {@link ClassLoader} and implement the requirements of
* {@link org.apache.catalina.util.LifecycleBase#startInternal()}.
*
* @exception LifecycleException if this component detects a fatal error that prevents this component from being
* used
*/
@Override
protected void startInternal() throws LifecycleException {
if (log.isDebugEnabled()) {
log.debug(sm.getString("webappLoader.starting"));
}
if (context.getResources() == null) {
log.info(sm.getString("webappLoader.noResources", context));
setState(LifecycleState.STARTING);
return;
}
// Construct a class loader based on our current repositories list
try {
classLoader = createClassLoader();
classLoader.setResources(context.getResources());
classLoader.setDelegate(this.delegate);
// Set Jakarta class converter
if (getJakartaConverter() != null) {
MigrationUtil.addJakartaEETransformer(classLoader, getJakartaConverter());
}
// Configure our repositories
setClassPath();
classLoader.start();
String contextName = context.getName();
if (!contextName.startsWith("/")) {
contextName = "/" + contextName;
}
ObjectName cloname =
new ObjectName(context.getDomain() + ":type=" + classLoader.getClass().getSimpleName() + ",host=" +
context.getParent().getName() + ",context=" + contextName);
Registry.getRegistry(null, null).registerComponent(classLoader, cloname, null);
} catch (Throwable t) {
t = ExceptionUtils.unwrapInvocationTargetException(t);
ExceptionUtils.handleThrowable(t);
throw new LifecycleException(sm.getString("webappLoader.startError"), t);
}
setState(LifecycleState.STARTING);
}
/**
* Stop associated {@link ClassLoader} and implement the requirements of
* {@link org.apache.catalina.util.LifecycleBase#stopInternal()}.
*
* @exception LifecycleException if this component detects a fatal error that prevents this component from being
* used
*/
@Override
protected void stopInternal() throws LifecycleException {
if (log.isDebugEnabled()) {
log.debug(sm.getString("webappLoader.stopping"));
}
setState(LifecycleState.STOPPING);
// Remove context attributes as appropriate
ServletContext servletContext = context.getServletContext();
servletContext.removeAttribute(Globals.CLASS_PATH_ATTR);
// Throw away our current class loader if any
if (classLoader != null) {
try {
classLoader.stop();
} finally {
classLoader.destroy();
}
// classLoader must be non-null to have been registered
try {
String contextName = context.getName();
if (!contextName.startsWith("/")) {
contextName = "/" + contextName;
}
ObjectName cloname =
new ObjectName(context.getDomain() + ":type=" + classLoader.getClass().getSimpleName() +
",host=" + context.getParent().getName() + ",context=" + contextName);
Registry.getRegistry(null, null).unregisterComponent(cloname);
} catch (Exception e) {
log.warn(sm.getString("webappLoader.stopError"), e);
}
}
classLoader = null;
}
// ------------------------------------------------------- Private Methods
/**
* Create associated classLoader.
*/
private WebappClassLoaderBase createClassLoader() throws Exception {
if (classLoader != null) {
return classLoader;
}
if (ParallelWebappClassLoader.class.getName().equals(loaderClass)) {
return new ParallelWebappClassLoader(context.getParentClassLoader());
}
Class<?> clazz = Class.forName(loaderClass);
WebappClassLoaderBase classLoader = null;
ClassLoader parentClassLoader = context.getParentClassLoader();
Class<?>[] argTypes = { ClassLoader.class };
Object[] args = { parentClassLoader };
Constructor<?> constr = clazz.getConstructor(argTypes);
classLoader = (WebappClassLoaderBase) constr.newInstance(args);
return classLoader;
}
/**
* Set the appropriate context attribute for our class path. This is required only because Jasper depends on it.
*/
private void setClassPath() {
// Validate our current state information
if (context == null) {
return;
}
ServletContext servletContext = context.getServletContext();
if (servletContext == null) {
return;
}
StringBuilder classpath = new StringBuilder();
// Assemble the class path information from our class loader chain
ClassLoader loader = getClassLoader();
if (delegate && loader != null) {
// Skip the webapp loader for now as delegation is enabled
loader = loader.getParent();
}
while (loader != null) {
if (!buildClassPath(classpath, loader)) {
break;
}
loader = loader.getParent();
}
if (delegate) {
// Delegation was enabled, go back and add the webapp paths
loader = getClassLoader();
if (loader != null) {
buildClassPath(classpath, loader);
}
}
this.classpath = classpath.toString();
// Store the assembled class path as a servlet context attribute
servletContext.setAttribute(Globals.CLASS_PATH_ATTR, this.classpath);
}
private boolean buildClassPath(StringBuilder classpath, ClassLoader loader) {
if (loader instanceof URLClassLoader) {
URL repositories[] = ((URLClassLoader) loader).getURLs();
for (URL url : repositories) {
String repository = url.toString();
if (repository.startsWith("file://")) {
repository = UDecoder.URLDecode(repository.substring(7), StandardCharsets.UTF_8);
} else if (repository.startsWith("file:")) {
repository = UDecoder.URLDecode(repository.substring(5), StandardCharsets.UTF_8);
} else {
continue;
}
if (repository == null) {
continue;
}
if (classpath.length() > 0) {
classpath.append(File.pathSeparator);
}
classpath.append(repository);
}
} else if (loader == ClassLoader.getSystemClassLoader()) {
// From Java 9 the internal class loaders no longer extend
// URLCLassLoader
String cp = System.getProperty("java.class.path");
if (cp != null && cp.length() > 0) {
if (classpath.length() > 0) {
classpath.append(File.pathSeparator);
}
classpath.append(cp);
}
return false;
} else {
// Ignore Graal "unknown" classloader
if (!JreCompat.isGraalAvailable()) {
log.info(sm.getString("webappLoader.unknownClassLoader", loader, loader.getClass()));
}
return false;
}
return true;
}
@Override
protected String getDomainInternal() {
return context.getDomain();
}
@Override
protected String getObjectNameKeyProperties() {
StringBuilder name = new StringBuilder("type=Loader");
name.append(",host=");
name.append(context.getParent().getName());
name.append(",context=");
String contextName = context.getName();
if (!contextName.startsWith("/")) {
name.append('/');
}
name.append(contextName);
return name.toString();
}
/**
* Implemented in a sub-class so EESpecProfile and EESpecProfiles are not loaded unless a profile is configured.
* Otherwise, tomcat-embed-core.jar has a runtime dependency on the migration tool whether it is used or not.
*/
private static class MigrationUtil {
public static void addJakartaEETransformer(WebappClassLoaderBase webappClassLoader, String profileName) {
EESpecProfile profile = null;
try {
profile = EESpecProfiles.valueOf(profileName);
} catch (IllegalArgumentException ignored) {
// Use default value
log.warn(sm.getString("webappLoader.unknownProfile", profileName));
}
webappClassLoader.addTransformer(profile != null ? new ClassConverter(profile) : new ClassConverter());
}
}
}