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:
JDK 11 java.naming.jmod - Naming Module
JDK 11 java.naming.jmod is the JMOD file for JDK 11 Naming module.
JDK 11 Naming module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\java.naming.jmod.
JDK 11 Naming module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.
JDK 11 Naming module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\java.naming.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ com/sun/jndi/ldap/EventSupport.java
/* * Copyright (c) 1999, 2017, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package com.sun.jndi.ldap; import java.util.Hashtable; import java.util.Vector; import java.util.EventObject; import java.util.Iterator; import java.util.Map; import javax.naming.*; import javax.naming.event.*; import javax.naming.directory.SearchControls; import javax.naming.ldap.UnsolicitedNotificationListener; import javax.naming.ldap.UnsolicitedNotificationEvent; import javax.naming.ldap.UnsolicitedNotification; /** * This is a utility class that can be used by a context that supports * event notification. You can use an instance of this class as a member field * of your context and delegate various work to it. * It is currently structured so that each context should have its own * EventSupport (instead of static version shared by all contexts * of a service provider). *<p> * This class supports two types of listeners: those that register for * NamingEvents, and those for UnsolicitedNotificationEvents (they can be mixed * into the same listener). * For NamingEvent listeners, it maintains a hashtable that maps * registration requests--the key--to * <em>notifiers</em>--the value. Each registration request consists of: *<ul> *<li>The name argument of the registration. *<li>The filter (default is "(objectclass=*)"). *<li>The search controls (default is null SearchControls). *<li>The events that the listener is interested in. This is determined by * finding out which {@code NamingListener} interface the listener supports. *</ul> *<p> *A notifier ({@code NamingEventNotifier}) is a worker thread that is responsible *for gathering information for generating events requested by its listeners. *Each notifier maintains its own list of listeners; these listeners have *all made the same registration request (at different times) and implements *the same {@code NamingListener} interfaces. *<p> *For unsolicited listeners, this class maintains a vector, unsolicited. *When an unsolicited listener is registered, this class adds itself *to the context's LdapClient. When LdapClient receives an unsolicited *notification, it notifies this EventSupport to fire an event to the *the listeners. Special handling in LdapClient is done for the DISCONNECT *notification. [It results in the EventSupport firing also a *NamingExceptionEvent to the unsolicited listeners.] *<p> * *When a context no longer needs this EventSupport, it should invoke *cleanup() on it. *<p> *<h4>Registration</h4> *When a registration request is made, this class attempts to find an *existing notifier that's already working on the request. If one is *found, the listener is added to the notifier's list. If one is not found, *a new notifier is created for the listener. * *<h4>Deregistration</h4> *When a deregistration request is made, this class attempts to find its *corresponding notifier. If the notifier is found, the listener is removed *from the notifier's list. If the listener is the last listener on the list, *the notifier's thread is terminated and removed from this class's hashtable. *Nothing happens if the notifier is not found. * *<h4>Event Dispatching</h4> *The notifiers are responsible for gather information for generating events *requested by their respective listeners. When a notifier gets sufficient *information to generate an event, it creates invokes the *appropriate {@code fireXXXEvent} on this class with the information and list of *listeners. This causes an event and the list of listeners to be added *to the <em>event queue</em>. *This class maintains an event queue and a dispatching thread that dequeues *events from the queue and dispatches them to the listeners. * *<h4>Synchronization</h4> *This class is used by the main thread (LdapCtx) to add/remove listeners. *It is also used asynchronously by NamingEventNotifiers threads and *the context's Connection thread. It is used by the notifier threads to *queue events and to update the notifiers list when the notifiers exit. *It is used by the Connection thread to fire unsolicited notifications. *Methods that access/update the 'unsolicited' and 'notifiers' lists are *thread-safe. * * @author Rosanna Lee */ final class EventSupport { final static private boolean debug = false; private LdapCtx ctx; /** * NamingEventNotifiers; hashed by search arguments; */ private Hashtable<NotifierArgs, NamingEventNotifier> notifiers = new Hashtable<>(11); /** * List of unsolicited notification listeners. */ private Vector<UnsolicitedNotificationListener> unsolicited = null; /** * Constructs EventSupport for ctx. * <em>Do we need to record the name of the target context? * Or can we assume that EventSupport is called on a resolved * context? Do we need other add/remove-NamingListener methods? * package private; */ EventSupport(LdapCtx ctx) { this.ctx = ctx; } /** * Adds {@code l} to list of listeners interested in {@code nm}. */ /* * Make the add/removeNamingListeners synchronized to: * 1. protect usage of 'unsolicited', which may be read by * the Connection thread when dispatching unsolicited notification. * 2. ensure that NamingEventNotifier thread's access to 'notifiers' * is safe */ synchronized void addNamingListener(String nm, int scope, NamingListener l) throws NamingException { if (l instanceof ObjectChangeListener || l instanceof NamespaceChangeListener) { NotifierArgs args = new NotifierArgs(nm, scope, l); NamingEventNotifier notifier = notifiers.get(args); if (notifier == null) { notifier = new NamingEventNotifier(this, ctx, args, l); notifiers.put(args, notifier); } else { notifier.addNamingListener(l); } } if (l instanceof UnsolicitedNotificationListener) { // Add listener to this's list of unsolicited notifiers if (unsolicited == null) { unsolicited = new Vector<>(3); } unsolicited.addElement((UnsolicitedNotificationListener)l); } } /** * Adds {@code l} to list of listeners interested in {@code nm} * and filter. */ synchronized void addNamingListener(String nm, String filter, SearchControls ctls, NamingListener l) throws NamingException { if (l instanceof ObjectChangeListener || l instanceof NamespaceChangeListener) { NotifierArgs args = new NotifierArgs(nm, filter, ctls, l); NamingEventNotifier notifier = notifiers.get(args); if (notifier == null) { notifier = new NamingEventNotifier(this, ctx, args, l); notifiers.put(args, notifier); } else { notifier.addNamingListener(l); } } if (l instanceof UnsolicitedNotificationListener) { // Add listener to this's list of unsolicited notifiers if (unsolicited == null) { unsolicited = new Vector<>(3); } unsolicited.addElement((UnsolicitedNotificationListener)l); } } /** * Removes {@code l} from all notifiers in this context. */ synchronized void removeNamingListener(NamingListener l) { if (debug) { System.err.println("EventSupport removing listener"); } // Go through list of notifiers, remove 'l' from each. // If 'l' is notifier's only listener, remove notifier too. Iterator<NamingEventNotifier> iterator = notifiers.values().iterator(); while (iterator.hasNext()) { NamingEventNotifier notifier = iterator.next(); if (notifier != null) { if (debug) { System.err.println("EventSupport removing listener from notifier"); } notifier.removeNamingListener(l); if (!notifier.hasNamingListeners()) { if (debug) { System.err.println("EventSupport stopping notifier"); } notifier.stop(); iterator.remove(); } } } // Remove from list of unsolicited notifier if (debug) { System.err.println("EventSupport removing unsolicited: " + unsolicited); } if (unsolicited != null) { unsolicited.removeElement(l); } } synchronized boolean hasUnsolicited() { return (unsolicited != null && unsolicited.size() > 0); } /** * package private; * Called by NamingEventNotifier to remove itself when it encounters * a NamingException. */ synchronized void removeDeadNotifier(NotifierArgs info) { if (debug) { System.err.println("EventSupport.removeDeadNotifier: " + info.name); } notifiers.remove(info); } /** * Fire an event to unsolicited listeners. * package private; * Called by LdapCtx when its clnt receives an unsolicited notification. */ synchronized void fireUnsolicited(Object obj) { if (debug) { System.err.println("EventSupport.fireUnsolicited: " + obj + " " + unsolicited); } if (unsolicited == null || unsolicited.size() == 0) { // This shouldn't really happen, but might in case // there is a timing problem that removes a listener // before a fired event reaches here. return; } if (obj instanceof UnsolicitedNotification) { // Fire UnsolicitedNotification to unsolicited listeners UnsolicitedNotificationEvent evt = new UnsolicitedNotificationEvent(ctx, (UnsolicitedNotification)obj); queueEvent(evt, unsolicited); } else if (obj instanceof NamingException) { // Fire NamingExceptionEvent to unsolicited listeners. NamingExceptionEvent evt = new NamingExceptionEvent(ctx, (NamingException)obj); queueEvent(evt, unsolicited); // When an exception occurs, the unsolicited listeners // are automatically deregistered. // When LdapClient.processUnsolicited() fires a NamingException, // it will update its listener list so we don't have to. // Likewise for LdapCtx. unsolicited = null; } } /** * Stops notifier threads that are collecting event data and * stops the event queue from dispatching events. * Package private; used by LdapCtx. */ synchronized void cleanup() { if (debug) System.err.println("EventSupport clean up"); if (notifiers != null) { for (NamingEventNotifier notifier : notifiers.values()) { notifier.stop(); } notifiers = null; } if (eventQueue != null) { eventQueue.stop(); eventQueue = null; } // %%% Should we fire NamingExceptionEvents to unsolicited listeners? } /* * The queue of events to be delivered. */ private EventQueue eventQueue; /** * Add the event and vector of listeners to the queue to be delivered. * An event dispatcher thread dequeues events from the queue and dispatches * them to the registered listeners. * Package private; used by NamingEventNotifier to fire events */ synchronized void queueEvent(EventObject event, Vector<? extends NamingListener> vector) { if (eventQueue == null) eventQueue = new EventQueue(); /* * Copy the vector in order to freeze the state of the set * of EventListeners the event should be delivered to prior * to delivery. This ensures that any changes made to the * Vector from a target listener's method during the delivery * of this event will not take effect until after the event is * delivered. */ @SuppressWarnings("unchecked") // clone() Vector<NamingListener> v = (Vector<NamingListener>)vector.clone(); eventQueue.enqueue(event, v); } // No finalize() needed because EventSupport is always owned by // an LdapCtx. LdapCtx's finalize() and close() always call cleanup() so // there is no need for EventSupport to have a finalize(). }
⏎ com/sun/jndi/ldap/EventSupport.java
Or download all of them as a single archive file:
File name: java.naming-11.0.1-src.zip File size: 461792 bytes Release date: 2018-11-04 Download
⇒ JDK 11 java.net.http.jmod - Net HTTP Module
2020-09-30, 60671👍, 0💬
Popular Posts:
JDK 11 jdk.internal.le.jmod is the JMOD file for JDK 11 Internal Line Editing module. JDK 11 Interna...
ANTLR is a powerful parser generator for multiple programming languages including Java. ANTLR contai...
What Is log4j-1.2.15.jar? I got the JAR file from apache-log4j-1.2.15.zip. log4j-1.2.15.jar is the v...
What Is commons-io-2.11.jar? commons-io-2.11.jar is the JAR file for Commons IO 2.5, which is a libr...
What Is commons-logging-1.2.jar? commons-logging-1.2.jar is the JAR file for Apache Commons Logging ...