0
# SLF4J Reload4j Binding
1
2
SLF4J Reload4j Binding provides a bridge between the SLF4J (Simple Logging Facade for Java) API and the Reload4j logging framework (successor to Log4j 1.2.x). This binding allows applications using SLF4J to delegate logging operations to Reload4j as the underlying logging implementation.
3
4
## Package Information
5
6
- **Package Name**: org.slf4j:slf4j-reload4j
7
- **Package Type**: maven
8
- **Language**: Java
9
- **Installation**: `<dependency><groupId>org.slf4j</groupId><artifactId>slf4j-reload4j</artifactId><version>1.7.36</version></dependency>`
10
11
## Core Imports
12
13
```java
14
import org.slf4j.Logger;
15
import org.slf4j.LoggerFactory;
16
import org.slf4j.MDC;
17
import org.slf4j.Marker;
18
import org.slf4j.ILoggerFactory;
19
import org.slf4j.spi.MDCAdapter;
20
import org.slf4j.spi.LocationAwareLogger;
21
import org.slf4j.event.LoggingEvent;
22
```
23
24
## Basic Usage
25
26
```java
27
import org.slf4j.Logger;
28
import org.slf4j.LoggerFactory;
29
import org.slf4j.MDC;
30
31
public class Example {
32
private static final Logger logger = LoggerFactory.getLogger(Example.class);
33
34
public void demonstrateLogging() {
35
// Basic logging at different levels
36
logger.trace("Trace level message");
37
logger.debug("Debug level message");
38
logger.info("Info level message");
39
logger.warn("Warning message");
40
logger.error("Error message");
41
42
// Parameterized logging (avoids string concatenation)
43
String username = "alice";
44
int userId = 123;
45
logger.info("User {} logged in with ID {}", username, userId);
46
47
// Exception logging
48
try {
49
// some operation
50
} catch (Exception e) {
51
logger.error("Operation failed for user {}", username, e);
52
}
53
54
// MDC (Mapped Diagnostic Context) usage
55
MDC.put("requestId", "req-456");
56
logger.info("Processing request");
57
MDC.remove("requestId");
58
}
59
}
60
```
61
62
## Architecture
63
64
The SLF4J Reload4j Binding operates through several key components:
65
66
- **Service Provider Interface**: Implements SLF4J's service provider pattern through static binder classes
67
- **Logger Adapter**: Wraps Reload4j loggers to provide SLF4J interface compatibility
68
- **Factory Pattern**: Manages logger instances with caching for performance
69
- **MDC Integration**: Bridges SLF4J's MDC with Reload4j's native MDC implementation
70
- **Location-Aware Logging**: Supports advanced logging features like caller location information
71
72
## Capabilities
73
74
### Logger Factory Management
75
76
Central factory for creating and managing logger instances with efficient caching.
77
78
```java { .api }
79
public class StaticLoggerBinder implements LoggerFactoryBinder {
80
/**
81
* Returns the singleton instance of the logger binder.
82
* @return StaticLoggerBinder singleton
83
*/
84
public static final StaticLoggerBinder getSingleton();
85
86
/**
87
* SLF4J API version this binding was compiled against.
88
*/
89
public static String REQUESTED_API_VERSION;
90
91
/**
92
* Returns the logger factory instance.
93
* @return ILoggerFactory implementation
94
*/
95
public ILoggerFactory getLoggerFactory();
96
97
/**
98
* Returns the class name of the logger factory.
99
* @return String representation of factory class
100
*/
101
public String getLoggerFactoryClassStr();
102
}
103
104
public class Reload4jLoggerFactory implements ILoggerFactory {
105
/**
106
* Returns a logger instance for the given name.
107
* @param name Logger name (typically class name)
108
* @return Logger instance
109
*/
110
public Logger getLogger(String name);
111
}
112
```
113
114
### Core Logging Operations
115
116
Complete logging interface supporting all standard levels with parameterized messages and exception handling.
117
118
```java { .api }
119
public final class Reload4jLoggerAdapter extends MarkerIgnoringBase
120
implements LocationAwareLogger, Serializable {
121
122
// Level checking methods
123
public boolean isTraceEnabled();
124
public boolean isDebugEnabled();
125
public boolean isInfoEnabled();
126
public boolean isWarnEnabled();
127
public boolean isErrorEnabled();
128
129
// TRACE level logging
130
public void trace(String msg);
131
public void trace(String format, Object arg);
132
public void trace(String format, Object arg1, Object arg2);
133
public void trace(String format, Object... arguments);
134
public void trace(String msg, Throwable t);
135
136
// DEBUG level logging
137
public void debug(String msg);
138
public void debug(String format, Object arg);
139
public void debug(String format, Object arg1, Object arg2);
140
public void debug(String format, Object... arguments);
141
public void debug(String msg, Throwable t);
142
143
// INFO level logging
144
public void info(String msg);
145
public void info(String format, Object arg);
146
public void info(String format, Object arg1, Object arg2);
147
public void info(String format, Object... argArray);
148
public void info(String msg, Throwable t);
149
150
// WARN level logging
151
public void warn(String msg);
152
public void warn(String format, Object arg);
153
public void warn(String format, Object arg1, Object arg2);
154
public void warn(String format, Object... argArray);
155
public void warn(String msg, Throwable t);
156
157
// ERROR level logging
158
public void error(String msg);
159
public void error(String format, Object arg);
160
public void error(String format, Object arg1, Object arg2);
161
public void error(String format, Object... argArray);
162
public void error(String msg, Throwable t);
163
164
// Location-aware logging
165
public void log(Marker marker, String callerFQCN, int level, String msg, Object[] argArray, Throwable t);
166
public void log(LoggingEvent event);
167
}
168
```
169
170
### Mapped Diagnostic Context (MDC)
171
172
Thread-local storage for contextual information that appears in log messages.
173
174
```java { .api }
175
public class StaticMDCBinder {
176
/**
177
* Singleton instance for MDC binding.
178
*/
179
public static final StaticMDCBinder SINGLETON;
180
181
/**
182
* Returns the singleton instance.
183
* @return StaticMDCBinder singleton
184
*/
185
public static final StaticMDCBinder getSingleton();
186
187
/**
188
* Returns the MDC adapter instance.
189
* @return MDCAdapter implementation
190
*/
191
public MDCAdapter getMDCA();
192
193
/**
194
* Returns the class name of the MDC adapter.
195
* @return String representation of MDC adapter class
196
*/
197
public String getMDCAdapterClassStr();
198
}
199
200
public class Reload4jMDCAdapter implements MDCAdapter {
201
/**
202
* Clear all entries in the MDC for the current thread.
203
*/
204
public void clear();
205
206
/**
207
* Get the context value for the given key.
208
* @param key Context key
209
* @return Context value or null if not found
210
*/
211
public String get(String key);
212
213
/**
214
* Put a context value for the given key.
215
* @param key Context key (cannot be null)
216
* @param val Context value (cannot be null for Log4j)
217
*/
218
public void put(String key, String val);
219
220
/**
221
* Remove the context value for the given key.
222
* @param key Context key to remove
223
*/
224
public void remove(String key);
225
226
/**
227
* Get a copy of the current thread's context map.
228
* @return Map containing all context entries, or null if empty
229
*/
230
public Map getCopyOfContextMap();
231
232
/**
233
* Set the current thread's context map.
234
* @param contextMap Map of context entries to set
235
*/
236
public void setContextMap(Map contextMap);
237
}
238
```
239
240
### Marker Support
241
242
Marker factory binding for structured logging markers.
243
244
```java { .api }
245
public class StaticMarkerBinder implements MarkerFactoryBinder {
246
/**
247
* Singleton instance for marker binding.
248
*/
249
public static final StaticMarkerBinder SINGLETON;
250
251
/**
252
* Returns the singleton instance.
253
* @return StaticMarkerBinder singleton
254
*/
255
public static StaticMarkerBinder getSingleton();
256
257
/**
258
* Returns the marker factory instance.
259
* @return IMarkerFactory implementation (BasicMarkerFactory)
260
*/
261
public IMarkerFactory getMarkerFactory();
262
263
/**
264
* Returns the class name of the marker factory.
265
* @return String representation of marker factory class
266
*/
267
public String getMarkerFactoryClassStr();
268
}
269
```
270
271
## Types
272
273
Core type definitions referenced in the API:
274
275
```java { .api }
276
// From SLF4J API
277
interface ILoggerFactory {
278
Logger getLogger(String name);
279
}
280
281
interface MDCAdapter {
282
void clear();
283
String get(String key);
284
void put(String key, String val);
285
void remove(String key);
286
Map getCopyOfContextMap();
287
void setContextMap(Map contextMap);
288
}
289
290
interface LoggerFactoryBinder {
291
ILoggerFactory getLoggerFactory();
292
String getLoggerFactoryClassStr();
293
}
294
295
interface MarkerFactoryBinder {
296
IMarkerFactory getMarkerFactory();
297
String getMarkerFactoryClassStr();
298
}
299
300
interface LocationAwareLogger extends Logger {
301
int TRACE_INT = 0;
302
int DEBUG_INT = 10;
303
int INFO_INT = 20;
304
int WARN_INT = 30;
305
int ERROR_INT = 40;
306
307
void log(Marker marker, String fqcn, int level, String message, Object[] argArray, Throwable t);
308
}
309
310
interface LoggingEvent {
311
Level getLevel();
312
Marker getMarker();
313
String getLoggerName();
314
String getMessage();
315
String getThreadName();
316
Object[] getArgumentArray();
317
long getTimeStamp();
318
Throwable getThrowable();
319
}
320
321
enum Level {
322
ERROR, WARN, INFO, DEBUG, TRACE;
323
324
int toInt();
325
String toString();
326
}
327
328
// Standard Java types used
329
import java.util.Map;
330
import java.io.Serializable;
331
```
332
333
## Usage Examples
334
335
### Performance-Optimized Logging
336
337
```java
338
// Efficient parameterized logging (recommended)
339
logger.debug("Processing user {} with {} items", userId, itemCount);
340
341
// Avoid string concatenation (inefficient)
342
// logger.debug("Processing user " + userId + " with " + itemCount + " items");
343
344
// Level checking for expensive operations
345
if (logger.isDebugEnabled()) {
346
String expensiveDebugInfo = computeExpensiveDebugInfo();
347
logger.debug("Debug info: {}", expensiveDebugInfo);
348
}
349
```
350
351
### Exception Logging
352
353
```java
354
try {
355
performDatabaseOperation();
356
} catch (SQLException e) {
357
// Log exception with context
358
logger.error("Database operation failed for user {}", userId, e);
359
}
360
```
361
362
### MDC Usage
363
364
```java
365
// Set context information
366
MDC.put("userId", String.valueOf(userId));
367
MDC.put("sessionId", sessionId);
368
369
try {
370
// All log messages in this thread will include MDC context
371
logger.info("Starting user operation");
372
performUserOperation();
373
logger.info("User operation completed successfully");
374
} finally {
375
// Clean up MDC to prevent memory leaks
376
MDC.clear();
377
}
378
```
379
380
## Dependencies
381
382
This binding requires the following dependencies:
383
384
- **org.slf4j:slf4j-api** - SLF4J API interfaces
385
- **ch.qos.reload4j:reload4j** - Reload4j logging framework implementation
386
387
## OSGi Support
388
389
The binding includes OSGi metadata and functions as a fragment bundle:
390
391
- **Bundle-SymbolicName**: slf4j.reload4j
392
- **Export-Package**: org.slf4j.impl
393
- **Fragment-Host**: slf4j.api
394
395
## Configuration
396
397
This binding delegates all configuration to the underlying Reload4j framework. Configure logging behavior through standard Reload4j configuration files (log4j.properties or log4j.xml).