0
# Servlet Integration
1

2
Web application integration components for servlet containers, providing lifecycle management, context initialization, and request-based logging enhancements for Java web applications.
3

4
## Capabilities
5

6
### Servlet Context Listener
7

8
Servlet container lifecycle integration for proper Logback initialization and cleanup.
9

10
```java { .api }
11
/**
12
 * Servlet context listener for Logback lifecycle management
13
 */
14
public class LogbackServletContextListener implements ServletContextListener {
15
    
16
    /**
17
     * Initialize Logback when servlet context starts
18
     */
19
    @Override
20
    public void contextInitialized(ServletContextEvent sce);
21
    
22
    /**
23
     * Cleanup Logback when servlet context stops
24
     */
25
    @Override
26
    public void contextDestroyed(ServletContextEvent sce);
27
}
28
```
29

30
**Usage Examples:**
31

32
```xml
33
<!-- web.xml configuration -->
34
<web-app>
35
    <listener>
36
        <listener-class>ch.qos.logback.classic.servlet.LogbackServletContextListener</listener-class>
37
    </listener>
38
</web-app>
39
```
40

41
```java
42
// Programmatic registration (Servlet 3.0+)
43
@WebListener
44
public class MyLogbackListener extends LogbackServletContextListener {
45
    // Inherits all functionality
46
}
47
```
48

49
### Servlet Container Initializer
50

51
Automatic servlet container initialization using the SPI mechanism.
52

53
```java { .api }
54
/**
55
 * Servlet container initializer for automatic Logback setup
56
 */
57
@HandlesTypes({})
58
public class LogbackServletContainerInitializer implements ServletContainerInitializer {
59
    
60
    /**
61
     * Automatically called by servlet container during startup
62
     */
63
    @Override
64
    public void onStartup(Set<Class<?>> c, ServletContext ctx) throws ServletException;
65
}
66
```
67

68
This initializer is automatically discovered and invoked by Servlet 3.0+ containers through the `ServiceLoader` mechanism, requiring no manual configuration.
69

70
### Context Selectors for Web Applications
71

72
Specialized context selectors for multi-webapp environments.
73

74
```java { .api }
75
/**
76
 * Context detaching servlet context listener for proper cleanup
77
 */
78
public class ContextDetachingSCL implements ServletContextListener {
79
    
80
    @Override
81
    public void contextInitialized(ServletContextEvent sce);
82
    
83
    @Override
84
    public void contextDestroyed(ServletContextEvent sce);
85
}
86

87
/**
88
 * Logger context filter for web applications
89
 */
90
public class LoggerContextFilter implements Filter {
91
    
92
    @Override
93
    public void init(FilterConfig filterConfig) throws ServletException;
94
    
95
    @Override
96
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
97
            throws IOException, ServletException;
98
    
99
    @Override
100
    public void destroy();
101
}
102
```
103

104
### Status Servlet
105

106
Web interface for viewing Logback status and configuration information.
107

108
```java { .api }
109
/**
110
 * Servlet for viewing Logback status messages via web interface
111
 */
112
public class ViewStatusMessagesServlet extends HttpServlet {
113
    private static final long serialVersionUID = 443878494348593337L;
114
    
115
    @Override
116
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
117
            throws ServletException, IOException;
118
    
119
    @Override
120
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) 
121
            throws ServletException, IOException;
122
}
123
```
124

125
**Usage Examples:**
126

127
```xml
128
<!-- web.xml servlet configuration -->
129
<servlet>
130
    <servlet-name>ViewStatusMessages</servlet-name>
131
    <servlet-class>ch.qos.logback.classic.ViewStatusMessagesServlet</servlet-class>
132
</servlet>
133
<servlet-mapping>
134
    <servlet-name>ViewStatusMessages</servlet-name>
135
    <url-pattern>/logback-status</url-pattern>
136
</servlet-mapping>
137
```
138

139
### MDC Servlet Filter
140

141
Servlet filter for automatically populating MDC with request information.
142

143
```java { .api }
144
/**
145
 * Servlet filter that populates MDC with request information
146
 */
147
public class MDCInsertingServletFilter implements Filter {
148
    
149
    @Override
150
    public void init(FilterConfig filterConfig) throws ServletException;
151
    
152
    @Override
153
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
154
            throws IOException, ServletException;
155
    
156
    @Override
157
    public void destroy();
158
}
159
```
160

161
This filter automatically adds the following keys to the MDC:
162
- `req.remoteHost` - Remote host address
163
- `req.userAgent` - User agent string
164
- `req.requestURI` - Request URI
165
- `req.queryString` - Query string
166
- `req.requestURL` - Full request URL
167
- `req.method` - HTTP method
168
- `req.xForwardedFor` - X-Forwarded-For header
169

170
**Usage Examples:**
171

172
```xml
173
<!-- web.xml filter configuration -->
174
<filter>
175
    <filter-name>MDCInsertingFilter</filter-name>
176
    <filter-class>ch.qos.logback.classic.helpers.MDCInsertingServletFilter</filter-class>
177
</filter>
178
<filter-mapping>
179
    <filter-name>MDCInsertingFilter</filter-name>
180
    <url-pattern>/*</url-pattern>
181
</filter-mapping>
182
```
183

184
```java
185
// Programmatic registration (Servlet 3.0+)
186
@WebFilter("/*")
187
public class CustomMDCFilter extends MDCInsertingServletFilter {
188
    // Can override methods to customize behavior
189
}
190
```
191

192
### Context Configuration
193

194
Web application specific context configuration and initialization.
195

196
```java { .api }
197
/**
198
 * Utility methods for web application context configuration
199
 */
200
public class WebLoggerContextUtils {
201
    
202
    /**
203
     * Get the logger context for a web application
204
     */
205
    public static LoggerContext getLoggerContext(ServletContext servletContext);
206
    
207
    /**
208
     * Initialize logger context for a web application
209
     */
210
    public static void initializeLoggerContext(ServletContext servletContext);
211
    
212
    /**
213
     * Destroy logger context for a web application
214
     */
215
    public static void destroyLoggerContext(ServletContext servletContext);
216
}
217
```
218

219
## Configuration Examples
220

221
### Complete Web Application Setup
222

223
```xml
224
<!-- web.xml - Complete Logback servlet integration -->
225
<web-app xmlns="http://java.sun.com/xml/ns/javaee" version="3.0">
226
    
227
    <!-- Context parameters for Logback configuration -->
228
    <context-param>
229
        <param-name>logbackConfigLocation</param-name>
230
        <param-value>classpath:logback-web.xml</param-value>
231
    </context-param>
232
    
233
    <!-- Logback servlet context listener -->
234
    <listener>
235
        <listener-class>ch.qos.logback.classic.servlet.LogbackServletContextListener</listener-class>
236
    </listener>
237
    
238
    <!-- MDC inserting filter (must be first) -->
239
    <filter>
240
        <filter-name>MDCInsertingFilter</filter-name>
241
        <filter-class>ch.qos.logback.classic.helpers.MDCInsertingServletFilter</filter-class>
242
    </filter>
243
    <filter-mapping>
244
        <filter-name>MDCInsertingFilter</filter-name>
245
        <url-pattern>/*</url-pattern>
246
    </filter-mapping>
247
    
248
    <!-- Status viewing servlet -->
249
    <servlet>
250
        <servlet-name>ViewStatusMessages</servlet-name>
251
        <servlet-class>ch.qos.logback.classic.ViewStatusMessagesServlet</servlet-class>
252
    </servlet>
253
    <servlet-mapping>
254
        <servlet-name>ViewStatusMessages</servlet-name>
255
        <url-pattern>/admin/logback</url-pattern>
256
    </servlet-mapping>
257
    
258
</web-app>
259
```
260

261
### Servlet 3.0+ Annotation-Based Configuration
262

263
```java
264
import ch.qos.logback.classic.servlet.LogbackServletContextListener;
265
import ch.qos.logback.classic.helpers.MDCInsertingServletFilter;
266

267
@WebListener
268
public class MyLogbackListener extends LogbackServletContextListener {
269
    // Automatic registration and lifecycle management
270
}
271

272
@WebFilter(filterName = "mdcFilter", urlPatterns = {"/*"})
273
public class MyMDCFilter extends MDCInsertingServletFilter {
274
    // Automatic MDC population for all requests
275
}
276

277
@WebServlet(name = "logbackStatus", urlPatterns = {"/admin/logback-status"})
278
public class MyStatusServlet extends ViewStatusMessagesServlet {
279
    // Web interface for viewing Logback status
280
}
281
```
282

283
### Spring Boot Integration
284

285
```java
286
import org.springframework.boot.web.servlet.FilterRegistrationBean;
287
import org.springframework.boot.web.servlet.ServletListenerRegistrationBean;
288
import org.springframework.context.annotation.Bean;
289
import org.springframework.context.annotation.Configuration;
290

291
@Configuration
292
public class LogbackWebConfig {
293
    
294
    @Bean
295
    public ServletListenerRegistrationBean<LogbackServletContextListener> logbackListener() {
296
        ServletListenerRegistrationBean<LogbackServletContextListener> listener = 
297
            new ServletListenerRegistrationBean<>();
298
        listener.setListener(new LogbackServletContextListener());
299
        return listener;
300
    }
301
    
302
    @Bean
303
    public FilterRegistrationBean<MDCInsertingServletFilter> mdcFilter() {
304
        FilterRegistrationBean<MDCInsertingServletFilter> filter = 
305
            new FilterRegistrationBean<>();
306
        filter.setFilter(new MDCInsertingServletFilter());
307
        filter.addUrlPatterns("/*");
308
        filter.setOrder(1); // Ensure it's first
309
        return filter;
310
    }
311
    
312
    @Bean
313
    public ServletRegistrationBean<ViewStatusMessagesServlet> statusServlet() {
314
        ServletRegistrationBean<ViewStatusMessagesServlet> servlet = 
315
            new ServletRegistrationBean<>();
316
        servlet.setServlet(new ViewStatusMessagesServlet());
317
        servlet.addUrlMappings("/admin/logback-status");
318
        return servlet;
319
    }
320
}
321
```
322

323
### Web-specific Logback Configuration
324

325
```xml
326
<!-- logback-web.xml - Web application specific configuration -->
327
<configuration>
328
    
329
    <!-- Use servlet context name in logs -->
330
    <contextName>${CONTEXT_NAME}</contextName>
331
    
332
    <!-- Web-specific appender with request information -->
333
    <appender name="WEB_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
334
        <file>${catalina.base}/logs/webapp.log</file>
335
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
336
            <fileNamePattern>${catalina.base}/logs/webapp.%d{yyyy-MM-dd}.%i.log.gz</fileNamePattern>
337
            <maxFileSize>100MB</maxFileSize>
338
            <maxHistory>30</maxHistory>
339
            <totalSizeCap>1GB</totalSizeCap>
340
        </rollingPolicy>
341
        <encoder>
342
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} [%X{req.requestURI}] [%X{req.remoteHost}] - %msg%n</pattern>
343
        </encoder>
344
    </appender>
345
    
346
    <!-- Separate appender for access logs -->
347
    <appender name="ACCESS_LOG" class="ch.qos.logback.core.rolling.RollingFileAppender">
348
        <file>${catalina.base}/logs/access.log</file>
349
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
350
            <fileNamePattern>${catalina.base}/logs/access.%d{yyyy-MM-dd}.log.gz</fileNamePattern>
351
            <maxHistory>90</maxHistory>
352
        </rollingPolicy>
353
        <encoder>
354
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %X{req.remoteHost} "%X{req.method} %X{req.requestURI} %X{req.queryString}" %X{req.userAgent}%n</pattern>
355
        </encoder>
356
    </appender>
357
    
358
    <!-- Access logger -->
359
    <logger name="access" level="INFO" additivity="false">
360
        <appender-ref ref="ACCESS_LOG" />
361
    </logger>
362
    
363
    <!-- Root logger -->
364
    <root level="INFO">
365
        <appender-ref ref="WEB_FILE" />
366
    </root>
367
    
368
</configuration>
369
```
370

371
### Usage in Web Application Code
372

373
```java
374
import org.slf4j.Logger;
375
import org.slf4j.LoggerFactory;
376
import org.slf4j.MDC;
377

378
@WebServlet("/user")
379
public class UserServlet extends HttpServlet {
380
    private static final Logger logger = LoggerFactory.getLogger(UserServlet.class);
381
    private static final Logger accessLogger = LoggerFactory.getLogger("access");
382
    
383
    @Override
384
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
385
            throws ServletException, IOException {
386
        
387
        // MDC is automatically populated by MDCInsertingServletFilter
388
        // Additional custom MDC values can be added
389
        String userId = req.getParameter("userId");
390
        if (userId != null) {
391
            MDC.put("userId", userId);
392
        }
393
        
394
        try {
395
            logger.info("Processing user request");
396
            
397
            // Business logic here
398
            processUserRequest(req, resp);
399
            
400
            // Access log entry
401
            accessLogger.info("Request processed successfully");
402
            
403
        } catch (Exception e) {
404
            logger.error("Error processing user request", e);
405
            resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
406
        } finally {
407
            // Clean up custom MDC values
408
            MDC.remove("userId");
409
            // Note: Request-related MDC values are automatically cleaned up
410
        }
411
    }
412
    
413
    private void processUserRequest(HttpServletRequest req, HttpServletResponse resp) {
414
        // Implementation
415
    }
416
}
417
```
418

419
### Context Separation in Multi-Webapp Environment
420

421
```java
422
// Custom context selector for webapp isolation
423
public class WebAppContextSelector extends ContextJNDISelector {
424
    
425
    @Override
426
    public LoggerContext getLoggerContext() {
427
        // Return context specific to current web application
428
        return getLoggerContext(getCurrentWebAppName());
429
    }
430
    
431
    private String getCurrentWebAppName() {
432
        // Implementation to determine current webapp context
433
        return Thread.currentThread().getContextClassLoader().toString();
434
    }
435
}
436

437
// System property to enable custom selector
438
// -Dlogback.ContextSelector=com.example.WebAppContextSelector
439
```
440

441
This servlet integration provides:
442

443
1. **Automatic Lifecycle Management** - Proper initialization and cleanup of Logback contexts
444
2. **Request Context Logging** - Automatic population of request-related information in MDC
445
3. **Web Interface** - Status servlet for monitoring and debugging
446
4. **Multi-Webapp Support** - Context isolation in enterprise environments
447
5. **Container Integration** - Seamless integration with servlet containers like Tomcat, Jetty, etc.