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 package org.slf4j.bridge;
33
34 import java.text.MessageFormat;
35 import java.util.MissingResourceException;
36 import java.util.ResourceBundle;
37 import java.util.logging.Handler;
38 import java.util.logging.Level;
39 import java.util.logging.LogManager;
40 import java.util.logging.LogRecord;
41
42 import org.slf4j.Logger;
43 import org.slf4j.LoggerFactory;
44 import org.slf4j.spi.LocationAwareLogger;
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 public class SLF4JBridgeHandler extends Handler {
99
100
101 private static final String FQCN = java.util.logging.Logger.class.getName();
102 private static final String UNKNOWN_LOGGER_NAME = "unknown.jul.logger";
103
104 private static final int TRACE_LEVEL_THRESHOLD = Level.FINEST.intValue();
105 private static final int DEBUG_LEVEL_THRESHOLD = Level.FINE.intValue();
106 private static final int INFO_LEVEL_THRESHOLD = Level.INFO.intValue();
107 private static final int WARN_LEVEL_THRESHOLD = Level.WARNING.intValue();
108
109
110
111
112
113
114
115
116
117
118 public static void install() {
119 LogManager.getLogManager().getLogger("").addHandler(
120 new SLF4JBridgeHandler());
121 }
122
123
124
125
126
127
128
129
130
131
132 public static void uninstall() throws SecurityException {
133 java.util.logging.Logger rootLogger = LogManager.getLogManager().getLogger(
134 "");
135 Handler[] handlers = rootLogger.getHandlers();
136 for (int i = 0; i < handlers.length; i++) {
137 if (handlers[i] instanceof SLF4JBridgeHandler) {
138 rootLogger.removeHandler(handlers[i]);
139 }
140 }
141 }
142
143
144
145
146
147
148 public static boolean isInstalled() throws SecurityException {
149 java.util.logging.Logger rootLogger = LogManager.getLogManager().getLogger(
150 "");
151 Handler[] handlers = rootLogger.getHandlers();
152 for (int i = 0; i < handlers.length; i++) {
153 if (handlers[i] instanceof SLF4JBridgeHandler) {
154 return true;
155 }
156 }
157 return false;
158 }
159
160
161
162
163
164
165 public SLF4JBridgeHandler() {
166 }
167
168
169
170
171 public void close() {
172
173 }
174
175
176
177
178 public void flush() {
179
180 }
181
182
183
184
185 protected Logger getSLF4JLogger(LogRecord record) {
186 String name = record.getLoggerName();
187 if (name == null) {
188 name = UNKNOWN_LOGGER_NAME;
189 }
190 return LoggerFactory.getLogger(name);
191 }
192
193 protected void callLocationAwareLogger(LocationAwareLogger lal,
194 LogRecord record) {
195 int julLevelValue = record.getLevel().intValue();
196 int slf4jLevel;
197
198 if (julLevelValue <= TRACE_LEVEL_THRESHOLD) {
199 slf4jLevel = LocationAwareLogger.TRACE_INT;
200 } else if (julLevelValue <= DEBUG_LEVEL_THRESHOLD) {
201 slf4jLevel = LocationAwareLogger.DEBUG_INT;
202 } else if (julLevelValue <= INFO_LEVEL_THRESHOLD) {
203 slf4jLevel = LocationAwareLogger.INFO_INT;
204 } else if (julLevelValue <= WARN_LEVEL_THRESHOLD) {
205 slf4jLevel = LocationAwareLogger.WARN_INT;
206 } else {
207 slf4jLevel = LocationAwareLogger.ERROR_INT;
208 }
209 String i18nMessage = getMessageI18N(record);
210 lal.log(null, FQCN, slf4jLevel, i18nMessage, null, record.getThrown());
211 }
212
213 protected void callPlainSLF4JLogger(Logger slf4jLogger, LogRecord record) {
214 String i18nMessage = getMessageI18N(record);
215 int julLevelValue = record.getLevel().intValue();
216 if (julLevelValue <= TRACE_LEVEL_THRESHOLD) {
217 slf4jLogger.trace(i18nMessage, record.getThrown());
218 } else if (julLevelValue <= DEBUG_LEVEL_THRESHOLD) {
219 slf4jLogger.debug(i18nMessage, record.getThrown());
220 } else if (julLevelValue <= INFO_LEVEL_THRESHOLD) {
221 slf4jLogger.info(i18nMessage, record.getThrown());
222 } else if (julLevelValue <= WARN_LEVEL_THRESHOLD) {
223 slf4jLogger.warn(i18nMessage, record.getThrown());
224 } else {
225 slf4jLogger.error(i18nMessage, record.getThrown());
226 }
227 }
228
229
230
231
232
233
234
235 private String getMessageI18N(LogRecord record) {
236 String message = record.getMessage();
237
238 if (message == null) {
239 return null;
240 }
241
242 ResourceBundle bundle = record.getResourceBundle();
243 if (bundle != null) {
244 try {
245 message = bundle.getString(message);
246 } catch (MissingResourceException e) {
247 }
248 }
249 Object[] params = record.getParameters();
250 if (params != null) {
251 message = MessageFormat.format(message, params);
252 }
253 return message;
254 }
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269 public void publish(LogRecord record) {
270
271 if (record == null) {
272 return;
273 }
274
275 Logger slf4jLogger = getSLF4JLogger(record);
276 String message = record.getMessage();
277
278
279
280
281 if (message == null) {
282 message = "";
283 }
284 if (slf4jLogger instanceof LocationAwareLogger) {
285 callLocationAwareLogger((LocationAwareLogger) slf4jLogger, record);
286 } else {
287 callPlainSLF4JLogger(slf4jLogger, record);
288 }
289 }
290
291 }