View Javadoc

1   // ========================================================================
2   // Copyright (c) 2004-2009 Mort Bay Consulting Pty. Ltd.
3   // ------------------------------------------------------------------------
4   // All rights reserved. This program and the accompanying materials
5   // are made available under the terms of the Eclipse Public License v1.0
6   // and Apache License v2.0 which accompanies this distribution.
7   // The Eclipse Public License is available at
8   // http://www.eclipse.org/legal/epl-v10.html
9   // The Apache License v2.0 is available at
10  // http://www.opensource.org/licenses/apache2.0.php
11  // You may elect to redistribute this code under either of these licenses.
12  // ========================================================================
13  
14  package org.eclipse.jetty.util.log;
15  
16  import java.lang.reflect.Method;
17  
18  /**
19   *
20   */
21  public class LoggerLog implements Logger
22  {
23      private final Object _logger;
24      private final Method _debugMT;
25      private final Method _debugMAA;
26      private final Method _infoMT;
27      private final Method _infoMAA;
28      private final Method _warnMT;
29      private final Method _warnMAA;
30      private final Method _setDebugEnabledE;
31      private final Method _getLoggerN;
32      private final Method _getName;
33      private volatile boolean _debug;
34  
35      public LoggerLog(Object logger)
36      {
37          try
38          {
39              _logger = logger;
40              Class<?> lc = logger.getClass();
41              _debugMT = lc.getMethod("debug", new Class[]{String.class, Throwable.class});
42              _debugMAA = lc.getMethod("debug", new Class[]{String.class, Object[].class});
43              _infoMT = lc.getMethod("info", new Class[]{String.class, Throwable.class});
44              _infoMAA = lc.getMethod("info", new Class[]{String.class, Object[].class});
45              _warnMT = lc.getMethod("warn", new Class[]{String.class, Throwable.class});
46              _warnMAA = lc.getMethod("warn", new Class[]{String.class, Object[].class});
47              Method _isDebugEnabled = lc.getMethod("isDebugEnabled");
48              _setDebugEnabledE = lc.getMethod("setDebugEnabled", new Class[]{Boolean.TYPE});
49              _getLoggerN = lc.getMethod("getLogger", new Class[]{String.class});
50              _getName = lc.getMethod("getName");
51  
52              _debug = (Boolean)_isDebugEnabled.invoke(_logger);
53          }
54          catch(Exception x)
55          {
56              throw new IllegalStateException(x);
57          }
58      }
59  
60      public String getName()
61      {
62          try
63          {
64              return (String)_getName.invoke(_logger);
65          }
66          catch (Exception e)
67          {
68              e.printStackTrace();
69              return null;
70          }
71      }
72  
73      public void warn(String msg, Object... args)
74      {
75          try
76          {
77              _warnMAA.invoke(_logger, args);
78          }
79          catch (Exception e)
80          {
81              e.printStackTrace();
82          }
83      }
84  
85      public void warn(Throwable thrown)
86      {
87          warn("", thrown);
88      }
89  
90      public void warn(String msg, Throwable thrown)
91      {
92          try
93          {
94              _warnMT.invoke(_logger, msg, thrown);
95          }
96          catch (Exception e)
97          {
98              e.printStackTrace();
99          }
100     }
101 
102     public void info(String msg, Object... args)
103     {
104         try
105         {
106             _infoMAA.invoke(_logger, args);
107         }
108         catch (Exception e)
109         {
110             e.printStackTrace();
111         }
112     }
113 
114     public void info(Throwable thrown)
115     {
116         info("", thrown);
117     }
118 
119     public void info(String msg, Throwable thrown)
120     {
121         try
122         {
123             _infoMT.invoke(_logger, msg, thrown);
124         }
125         catch (Exception e)
126         {
127             e.printStackTrace();
128         }
129     }
130 
131     public boolean isDebugEnabled()
132     {
133         return _debug;
134     }
135 
136     public void setDebugEnabled(boolean enabled)
137     {
138         try
139         {
140             _setDebugEnabledE.invoke(_logger, enabled);
141             _debug = enabled;
142         }
143         catch (Exception e)
144         {
145             e.printStackTrace();
146         }
147     }
148 
149     public void debug(String msg, Object... args)
150     {
151         if (!_debug)
152             return;
153 
154         try
155         {
156             _debugMAA.invoke(_logger, args);
157         }
158         catch (Exception e)
159         {
160             e.printStackTrace();
161         }
162     }
163 
164     public void debug(Throwable thrown)
165     {
166         debug("", thrown);
167     }
168 
169     public void debug(String msg, Throwable th)
170     {
171         if (!_debug)
172             return;
173 
174         try
175         {
176             _debugMT.invoke(_logger, msg, th);
177         }
178         catch (Exception e)
179         {
180             e.printStackTrace();
181         }
182     }
183 
184     public void ignore(Throwable ignored)
185     {
186         if (Log.isIgnored())
187         {
188             warn(Log.IGNORED, ignored);
189         }
190     }
191 
192     public Logger getLogger(String name)
193     {
194         try
195         {
196             Object logger=_getLoggerN.invoke(_logger, name);
197             return new LoggerLog(logger);
198         }
199         catch (Exception e)
200         {
201             e.printStackTrace();
202             return this;
203         }
204     }
205 }