Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
Source Code for Apache Log4j API
Apache Log4j API provides the interface that applications should code to and provides the adapter components required for implementers to create a logging implementation. Apache Log4j API is a required module to use Apache Log4j.
Bytecode (Java 8) for Apache Log4j API is provided in a separate JAR file like log4j-api-2.14.1.jar.
Source Code files for Apache Log4j API are provided in both binary packge like apache-log4j-2.14.1-bin.zip and source package like apache-log4j-2.14.1-src.zip. You can download them at Apache Log4j Website.
You can also browse Source Code files for Apache Log4j API 2.14.1 below.
✍: FYIcenter.com
⏎ org/apache/logging/log4j/ThreadContext.java
/* * 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.logging.log4j; import java.io.Serializable; import java.util.AbstractCollection; import java.util.Collection; import java.util.Collections; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.NoSuchElementException; import org.apache.logging.log4j.message.ParameterizedMessage; import org.apache.logging.log4j.spi.DefaultThreadContextMap; import org.apache.logging.log4j.spi.DefaultThreadContextStack; import org.apache.logging.log4j.spi.NoOpThreadContextMap; import org.apache.logging.log4j.spi.ReadOnlyThreadContextMap; import org.apache.logging.log4j.spi.ThreadContextMap; import org.apache.logging.log4j.spi.ThreadContextMap2; import org.apache.logging.log4j.spi.CleanableThreadContextMap; import org.apache.logging.log4j.spi.ThreadContextMapFactory; import org.apache.logging.log4j.spi.ThreadContextStack; import org.apache.logging.log4j.util.PropertiesUtil; /** * The ThreadContext allows applications to store information either in a Map or a Stack. * <p> * <b><em>The MDC is managed on a per thread basis</em></b>. To enable automatic inheritance of <i>copies</i> of the MDC * to newly created threads, enable the {@value org.apache.logging.log4j.spi.DefaultThreadContextMap#INHERITABLE_MAP} * Log4j system property. * </p> * @see <a href="https://logging.apache.org/log4j/2.x/manual/thread-context.html">Thread Context Manual</a> */ public final class ThreadContext { /** * An empty read-only ThreadContextStack. */ private static class EmptyThreadContextStack extends AbstractCollection<String> implements ThreadContextStack { private static final long serialVersionUID = 1L; private static final Iterator<String> EMPTY_ITERATOR = new EmptyIterator<>(); @Override public String pop() { return null; } @Override public String peek() { return null; } @Override public void push(final String message) { throw new UnsupportedOperationException(); } @Override public int getDepth() { return 0; } @Override public List<String> asList() { return Collections.emptyList(); } @Override public void trim(final int depth) { // Do nothing } @Override public boolean equals(final Object o) { // Similar to java.util.Collections.EmptyList.equals(Object) return (o instanceof Collection) && ((Collection<?>) o).isEmpty(); } @Override public int hashCode() { // Same as java.util.Collections.EmptyList.hashCode() return 1; } @Override public ContextStack copy() { return this; } @Override public <T> T[] toArray(final T[] a) { throw new UnsupportedOperationException(); } @Override public boolean add(final String e) { throw new UnsupportedOperationException(); } @Override public boolean containsAll(final Collection<?> c) { return false; } @Override public boolean addAll(final Collection<? extends String> c) { throw new UnsupportedOperationException(); } @Override public boolean removeAll(final Collection<?> c) { throw new UnsupportedOperationException(); } @Override public boolean retainAll(final Collection<?> c) { throw new UnsupportedOperationException(); } @Override public Iterator<String> iterator() { return EMPTY_ITERATOR; } @Override public int size() { return 0; } @Override public ContextStack getImmutableStackOrNull() { return this; } } /** * An empty iterator. Since Java 1.7 added the Collections.emptyIterator() method, we have to make do. * * @param <E> the type of the empty iterator */ private static class EmptyIterator<E> implements Iterator<E> { @Override public boolean hasNext() { return false; } @Override public E next() { throw new NoSuchElementException("This is an empty iterator!"); } @Override public void remove() { // no-op } } /** * Empty, immutable Map. */ // ironically, this annotation gives an "unsupported @SuppressWarnings" warning in Eclipse @SuppressWarnings("PublicStaticCollectionField") // I like irony, so I won't delete it... public static final Map<String, String> EMPTY_MAP = Collections.emptyMap(); /** * Empty, immutable ContextStack. */ // ironically, this annotation gives an "unsupported @SuppressWarnings" warning in Eclipse @SuppressWarnings("PublicStaticCollectionField") public static final ThreadContextStack EMPTY_STACK = new EmptyThreadContextStack(); private static final String DISABLE_MAP = "disableThreadContextMap"; private static final String DISABLE_STACK = "disableThreadContextStack"; private static final String DISABLE_ALL = "disableThreadContext"; private static boolean useStack; private static ThreadContextMap contextMap; private static ThreadContextStack contextStack; private static ReadOnlyThreadContextMap readOnlyContextMap; static { init(); } private ThreadContext() { // empty } /** * <em>Consider private, used for testing.</em> */ static void init() { ThreadContextMapFactory.init(); contextMap = null; final PropertiesUtil managerProps = PropertiesUtil.getProperties(); boolean disableAll = managerProps.getBooleanProperty(DISABLE_ALL); useStack = !(managerProps.getBooleanProperty(DISABLE_STACK) || disableAll); boolean useMap = !(managerProps.getBooleanProperty(DISABLE_MAP) || disableAll); contextStack = new DefaultThreadContextStack(useStack); if (!useMap) { contextMap = new NoOpThreadContextMap(); } else { contextMap = ThreadContextMapFactory.createThreadContextMap(); } if (contextMap instanceof ReadOnlyThreadContextMap) { readOnlyContextMap = (ReadOnlyThreadContextMap) contextMap; } else { readOnlyContextMap = null; } } /** * Puts a context value (the <code>value</code> parameter) as identified with the <code>key</code> parameter into * the current thread's context map. * * <p> * If the current thread does not have a context map it is created as a side effect. * </p> * * @param key The key name. * @param value The key value. */ public static void put(final String key, final String value) { contextMap.put(key, value); } /** * Puts a context value (the <code>value</code> parameter) as identified with the <code>key</code> parameter into * the current thread's context map if the key does not exist. * * <p> * If the current thread does not have a context map it is created as a side effect. * </p> * * @param key The key name. * @param value The key value. * @since 2.13.0 */ public static void putIfNull(final String key, final String value) { if(!contextMap.containsKey(key)) { contextMap.put(key, value); } } /** * Puts all given context map entries into the current thread's * context map. * * <p>If the current thread does not have a context map it is * created as a side effect.</p> * @param m The map. * @since 2.7 */ public static void putAll(final Map<String, String> m) { if (contextMap instanceof ThreadContextMap2) { ((ThreadContextMap2) contextMap).putAll(m); } else if (contextMap instanceof DefaultThreadContextMap) { ((DefaultThreadContextMap) contextMap).putAll(m); } else { for (final Map.Entry<String, String> entry: m.entrySet()) { contextMap.put(entry.getKey(), entry.getValue()); } } } /** * Gets the context value identified by the <code>key</code> parameter. * * <p> * This method has no side effects. * </p> * * @param key The key to locate. * @return The value associated with the key or null. */ public static String get(final String key) { return contextMap.get(key); } /** * Removes the context value identified by the <code>key</code> parameter. * * @param key The key to remove. */ public static void remove(final String key) { contextMap.remove(key); } /** * Removes the context values identified by the <code>keys</code> parameter. * * @param keys The keys to remove. * * @since 2.8 */ public static void removeAll(final Iterable<String> keys) { if (contextMap instanceof CleanableThreadContextMap) { ((CleanableThreadContextMap) contextMap).removeAll(keys); } else if (contextMap instanceof DefaultThreadContextMap) { ((DefaultThreadContextMap) contextMap).removeAll(keys); } else { for (final String key : keys) { contextMap.remove(key); } } } /** * Clears the context map. */ public static void clearMap() { contextMap.clear(); } /** * Clears the context map and stack. */ public static void clearAll() { clearMap(); clearStack(); } /** * Determines if the key is in the context. * * @param key The key to locate. * @return True if the key is in the context, false otherwise. */ public static boolean containsKey(final String key) { return contextMap.containsKey(key); } /** * Returns a mutable copy of current thread's context Map. * * @return a mutable copy of the context. */ public static Map<String, String> getContext() { return contextMap.getCopy(); } /** * Returns an immutable view of the current thread's context Map. * * @return An immutable view of the ThreadContext Map. */ public static Map<String, String> getImmutableContext() { final Map<String, String> map = contextMap.getImmutableMapOrNull(); return map == null ? EMPTY_MAP : map; } /** * Returns a read-only view of the internal data structure used to store thread context key-value pairs, * or {@code null} if the internal data structure does not implement the * {@code ReadOnlyThreadContextMap} interface. * <p> * The {@link DefaultThreadContextMap} implementation does not implement {@code ReadOnlyThreadContextMap}, so by * default this method returns {@code null}. * </p> * * @return the internal data structure used to store thread context key-value pairs or {@code null} * @see ThreadContextMapFactory * @see DefaultThreadContextMap * @see org.apache.logging.log4j.spi.CopyOnWriteSortedArrayThreadContextMap * @see org.apache.logging.log4j.spi.GarbageFreeSortedArrayThreadContextMap * @since 2.8 */ public static ReadOnlyThreadContextMap getThreadContextMap() { return readOnlyContextMap; } /** * Returns true if the Map is empty. * * @return true if the Map is empty, false otherwise. */ public static boolean isEmpty() { return contextMap.isEmpty(); } /** * Clears the stack for this thread. */ public static void clearStack() { contextStack.clear(); } /** * Returns a copy of this thread's stack. * * @return A copy of this thread's stack. */ public static ContextStack cloneStack() { return contextStack.copy(); } /** * Gets an immutable copy of this current thread's context stack. * * @return an immutable copy of the ThreadContext stack. */ public static ContextStack getImmutableStack() { final ContextStack result = contextStack.getImmutableStackOrNull(); return result == null ? EMPTY_STACK : result; } /** * Sets this thread's stack. * * @param stack The stack to use. */ public static void setStack(final Collection<String> stack) { if (stack.isEmpty() || !useStack) { return; } contextStack.clear(); contextStack.addAll(stack); } /** * Gets the current nesting depth of this thread's stack. * * @return the number of items in the stack. * * @see #trim */ public static int getDepth() { return contextStack.getDepth(); } /** * Returns the value of the last item placed on the stack. * * <p> * The returned value is the value that was pushed last. If no context is available, then the empty string "" is * returned. * </p> * * @return String The innermost diagnostic context. */ public static String pop() { return contextStack.pop(); } /** * Looks at the last diagnostic context at the top of this NDC without removing it. * * <p> * The returned value is the value that was pushed last. If no context is available, then the empty string "" is * returned. * </p> * * @return String The innermost diagnostic context. */ public static String peek() { return contextStack.peek(); } /** * Pushes new diagnostic context information for the current thread. * * <p> * The contents of the <code>message</code> parameter is determined solely by the client. * </p> * * @param message The new diagnostic context information. */ public static void push(final String message) { contextStack.push(message); } /** * Pushes new diagnostic context information for the current thread. * * <p> * The contents of the <code>message</code> and args parameters are determined solely by the client. The message * will be treated as a format String and tokens will be replaced with the String value of the arguments in * accordance with ParameterizedMessage. * </p> * * @param message The new diagnostic context information. * @param args Parameters for the message. */ public static void push(final String message, final Object... args) { contextStack.push(ParameterizedMessage.format(message, args)); } /** * Removes the diagnostic context for this thread. * * <p> * Each thread that created a diagnostic context by calling {@link #push} should call this method before exiting. * Otherwise, the memory used by the <b>thread</b> cannot be reclaimed by the VM. * </p> * * <p> * As this is such an important problem in heavy duty systems and because it is difficult to always guarantee that * the remove method is called before exiting a thread, this method has been augmented to lazily remove references * to dead threads. In practice, this means that you can be a little sloppy and occasionally forget to call * {@link #remove} before exiting a thread. However, you must call <code>remove</code> sometime. If you never call * it, then your application is sure to run out of memory. * </p> */ public static void removeStack() { contextStack.clear(); } /** * Trims elements from this diagnostic context. If the current depth is smaller or equal to <code>maxDepth</code>, * then no action is taken. If the current depth is larger than newDepth then all elements at maxDepth or higher are * discarded. * * <p> * This method is a convenient alternative to multiple {@link #pop} calls. Moreover, it is often the case that at * the end of complex call sequences, the depth of the ThreadContext is unpredictable. The <code>trim</code> method * circumvents this problem. * </p> * * <p> * For example, the combination * </p> * * <pre> * void foo() { * final int depth = ThreadContext.getDepth(); * * // ... complex sequence of calls * * ThreadContext.trim(depth); * } * </pre> * * <p> * ensures that between the entry and exit of {@code foo} the depth of the diagnostic stack is conserved. * </p> * * @see #getDepth * @param depth The number of elements to keep. */ public static void trim(final int depth) { contextStack.trim(depth); } /** * The ThreadContext Stack interface. */ public interface ContextStack extends Serializable, Collection<String> { /** * Returns the element at the top of the stack. * * @return The element at the top of the stack. * @throws java.util.NoSuchElementException if the stack is empty. */ String pop(); /** * Returns the element at the top of the stack without removing it or null if the stack is empty. * * @return the element at the top of the stack or null if the stack is empty. */ String peek(); /** * Pushes an element onto the stack. * * @param message The element to add. */ void push(String message); /** * Returns the number of elements in the stack. * * @return the number of elements in the stack. */ int getDepth(); /** * Returns all the elements in the stack in a List. * * @return all the elements in the stack in a List. */ List<String> asList(); /** * Trims elements from the end of the stack. * * @param depth The maximum number of items in the stack to keep. */ void trim(int depth); /** * Returns a copy of the ContextStack. * * @return a copy of the ContextStack. */ ContextStack copy(); /** * Returns a ContextStack with the same contents as this ContextStack or {@code null}. Attempts to modify the * returned stack may or may not throw an exception, but will not affect the contents of this ContextStack. * * @return a ContextStack with the same contents as this ContextStack or {@code null}. */ ContextStack getImmutableStackOrNull(); } }
⏎ org/apache/logging/log4j/ThreadContext.java
Or download all of them as a single archive file:
File name: log4j-api-2.14.1-sources.jar File size: 264773 bytes Release date: 2021-03-06 Download
⇒ Source Code for Apache Log4j Core Implementation
⇐ Downloading Apache Log4j Binary Package
2015-11-17, 34713👍, 0💬
Popular Posts:
JDK 11 jdk.jconsole.jmod is the JMOD file for JDK 11 JConsole tool, which can be invoked by the "jco...
What Is commons-codec-1.4.jar? commons-codec-1.4.jar is the JAR file for Apache Commons Codec 1.4, w...
JDK 11 jdk.aot.jmod is the JMOD file for JDK 11 Ahead-of-Time (AOT) Compiler module. JDK 11 AOT Comp...
Xalan-Java, Version 2.7.1, is an XSLT processor for transforming XML documents into HTML, text, or o...
What Is poi-ooxml-5.2.3.jar? poi-ooxml-5.2.3.jar is one of the JAR files for Apache POI 5.2.3, which...