|
JNDI overview, Part 1: An introduction to naming services
The Java Naming and Directory InterfaceTM (JNDI) is a standard extension to the JavaTM platform, providing Java technology-enabled applications with a unified interface to multiple naming and directory services in the enterprise. As part of the Java Enterprise API set, JNDI enables seamless connectivity to heterogeneous enterprise naming and directory services. Developers can now build powerful and portable directory-enabled applications using this industry standard.
|
|
JNDI overview, Part 2: An introduction to directory services
As applications become more distributed, the efficient management and distribution of the information upon which they depend becomes more and more of a problem. Directory services such as LDAP (the Lightweight Directory Access Protocol) address this problem. For Java applications, the Java Naming and Directory Interface (JNDI) provides a generic interface to LDAP and other directory services. This month, Todd Sundsted introduces you to JNDI directory services.
|
|
JNDI overview, Part 3: Advanced JNDI
A JNDI service can be much more than a computerized card catalog. JNDI's object-storage capabilities allow it to play the role of resource administrator in your distributed applications and to provide simple, manageable object persistence. In recognition of its potential, the architects of key Java technologies such as JDBC and EJB built JNDI into their specifications. This month Todd Sundsted shows you how to store objects in a JNDI service
|
|
JNDI overview, Part 4: the Doc-u-Matic, a JNDI application
You've read each lesson and learned the material -- now it's time to play. In order to demonstrate clearly the strength of JNDI, Todd Sundsted takes you on a tour of Doc-u-Matic, a JNDI-enabled document publication and distribution infrastructure. You'll see how a naming and directory service, combined with JNDI's ability to store Java objects, leads to simpler -- yet more powerful -- distributed applications
|
|
J2EE or J2SE? JNDI works with both
JNDI, the Java Naming and Directory Interface, is a fundamental component of J2EE (Java 2 Platform, Enterprise Edition) and any J2EE application. However, since JNDI does not depend on any other J2EE technologies, and the JNDI client interfaces are part of the J2SE (Java 2 Platform, Standard Edition) distribution, J2SE applications can also exploit JNDI's benefits. In this article, Brian Goetz explores basic JNDI concepts, how JNDI is commonly used, and how to configure a free JNDI provider for use with J2SE applications.
|
|
Find a way out of the ClassLoader maze
Although not frequently asked, this question is rather tough to correctly answer. It usually comes up during framework programming, when a good deal of dynamic class and resource loading goes on. In general, when loading a resource dynamically, you can choose from at least three classloaders: the system (also referred to as the application) classloader, the current classloader, and the current thread context classloader. The question above refers to the latter. Which classloader is the right one?
|
|
LDAP and JNDI: Together forever
In this article Sameer Tyagi takes a look at the Java Naming and Directory Interface (JNDI), explaining how you can manipulate Java objects on an LDAP server. He'll show you examples that demonstrate how you can store objects, search for objects, see event handling in LDAP, and much more
|
|
|
JAVA NAMING AND DIRECTORY INTERFACETM (JNDI)
The Java Naming and Directory InterfaceTM (JNDI) is a standard extension to the JavaTM platform, providing Java technology-enabled applications with a unified interface to multiple naming and directory services in the enterprise. As part of the Java Enterprise API set, JNDI enables seamless connectivity to heterogeneous enterprise naming and directory services. Developers can now build powerful and portable directory-enabled applications using this industry standard.
|
|
Locating CORBA objects using Java IDL
Implementing CORBA objects is no trivial matter. In fact, it's a feat worthy of a round of high fives. Once the celebration subsides and everyone has left your cube suitably impressed with your coding talents, you must figure out how to publish your new object so that any computer on the enterprise can easily locate it. What else would you use but a naming service?
|
|
The JNDI Tutorial
The Java Naming and Directory InterfaceTM (JNDI) is an application programming interface (API) that provides naming and directory functionality to applications written using the JavaTM programming language. It is defined to be independent of any specific directory service implementation. Thus a variety of directories--new, emerging, and already deployed--can be accessed in a common way.
|
|
Use JNDI to share objects between different virtual machines
Imagine the following: Process A on machine B puts an object into a Hashtable. Now, a separate process C on a different machine D can access that object from its own local copy of the Hashtable -- even after process A terminates and the virtual machine unloads! Now imagine all this is achieved without the use of RMI, and without involving an ORB, CORBA, EJB, or a database. What's the secret? The Java Naming and Directory Interface (JNDI). This month's tool is the JNDIHashtable -- which, as its name reveals, uses JNDI to do its thing
|
|
Java Naming and Directory Interface (JNDI) FAQ
The Java Naming and Directory Interface (JNDI) is an application programming interface (API) for accessing different kinds of naming and directory services. JNDI is not specific to a particular naming or directory service, it can be used to access many different kinds of systems including file systems; distributed objects systems like CORBA, Java RMI, and EJB; and directory services like LDAP, Novell NetWare, and NIS+.
|
|
Using WebLogic JNDI
In the enterprise, naming and directory services -- the ability of your application to locate an object or service that may be anywhere on the network -- play an important part in building a distributed application. Particularly in a clustered environment, where clients may connect arbitrarily to any machine, the environment must have a naming service that can be depended upon to locate any service object requested no matter its physical location.
|
|
JNDI Explorer for Eclipse
The Java Naming and Directory Interface™ (JNDI) is a standard extension to the Java™ platform, providing Java applications with a unified interface to multiple naming and directory services in the enterprise. As part of the Java Enterprise API set, JNDI enables seamless connectivity to heterogeneous enterprise naming and directory services. Thus a JNDI client such as this plug-in is able to view and edit LDAP directories, Corba or RMI registries, and even the Windows registry!
|
|
Using the WLE SPI Implementations for JNDI
In the enterprise, naming and directory services provide the means for your application to locate objects on the network. These services are key to building distributed applications. A naming service provides a mechanism to name objects and retrieve objects by name. A directory service is a naming service that also allows for attributes to be associated with each object, and provides a way to retrieve an object by its attributes instead of its name.
|
|
Using the JNDI Service Provider
The Java Naming and Directory Interface (JNDI) allows Java applications to use a single set of methods to access multiple naming and directory services such as LDAP and NIS. JNDI was developed by the JavaSoft division of Sun Microsystems along with several industry partners, including Netscape.
|
|
Developing a Simple JMS Example
Now that you understand Message-Oriented Middleware and some JMS concepts, you are ready to write your first JMS application. This chapter provides a gentle introduction to JMS using the publish-and-subscribe messaging model. You will get your feet wet with JMS and learn some of the basic classes and interfaces. Chapter 4, Publish-and-Subscribe Messaging, covers publish-and-subscribe in detail, and Chapter 5, Point-to-Point Messaging, covers the point-to-point message model.
|
|
JNDI FREQUENTLY ASKED QUESTIONS
Any JavaTM application that needs to access information about users, machines, networks, and services. User information includes security credentials, phone numbers, electronic and postal mail addresses, and application preferences. Machine information includes network addresses, machine configurations, etc. In addition, any Java application that needs to either export objects or access objects exported by other applications and services. Examples include printers, calendars, and networked file systems.
|
|
COS Naming Service Provider for the
Java Naming and Directory InterfaceTM (JNDI)
The Common Object Services (COS) Name Server is the name server for storing Common Object Request Broker Architecture (CORBA) object references. It can be accessed from CORBA applications by using the COS Naming package (org.omg.CORBA.CosNaming).
|
|
Industrial-strength JNDI optimization
Brett McLaughlin continues his EJB best practices with an examination of JNDI lookups, which are an essential and frequent part of almost all EJB interactions. Unfortunately, JNDI operations almost always exact a performance toll. In this tip, Brett shows you how a home-interface factory can reduce the overhead of JNDI lookups in your EJB applications.
|
|
Create forward-compatible beans in EJB, Part 1
Enterprise JavaBeans has undergone several changes in its new 1.1 version. Many of the changes hinder the forward compatibility of beans originally developed for EJB 1.0 containers. In other words, beans developed for EJB 1.0 will not work in EJB 1.1 containers. This article is the first in a two-part series that provides strategies to ease such forward compatibility and ensure that your beans port smoothly to the EJB 1.1 platform.
|
|
Create forward-compatible beans in EJB, Part 2
In the first part of this series, Richard Monson-Haefel covered the environment-naming context and implementation of an abstraction that hides the differences between EJB 1.0 and EJB 1.1 when accessing bean properties, Java Database Connectivity (JDBC), and other beans. This second installment addresses security issues, changes specific to entity beans, and changes to the deployment descriptor.
|
|
Integrate EJBs with CORBA
Interoperability between EJBs (Enterprise JavaBeans) and CORBA is important for integrating Java- and non-Java-based applications. This article shows how to achieve integration between an EJB and a CORBA C++ application. It points to several important integration areas, particularly those in which EJBs use methods with Java built-in or user-defined objects as their parameters and return values.
|
|
JNDI DOCUMENTATION
The Java Naming and Directory InterfaceTM (JNDI) 1.2 is a major new upgrade release that adds new functionality to the basic naming and directory support offered in the 1.1.x releases. New features include event notification, and LDAPv3 extensions and controls. This release contains valuable contributions from the following companies: Netscape, Novell, SCO, Sun, BEA.
|
|
Archives of JNDI-INTEREST@JAVA.SUN.COM
A mailing list for discussing Java Naming and Directory Interface (JNDI)
|
|
List archives at JAVA.SUN.COM
|
|
Develop n-tier applications using J2EE
In this article, Steven Gould introduces the 13 core technologies of the Java 2 Platform, Enterprise Edition (J2EE): JDBC, JNDI, EJBs, RMI, JSP, Java servlets, XML, JMS, Java IDL, JTS, JTA, JavaMail, and JAF. To ground things in the real world, Gould explains J2EE in context of one of the its major implementations, BEA Systems' WebLogic Server.
|
|
Dive into connection pooling with J2EE
Connection pooling is a technique used for sharing server resources among requesting clients. This article focuses on support for connection pooling of both database resources and nondatabase resources in a J2EE environment. Siva examines the JDBC 2.0, JMS 1.02, JNDI 1.2 Standard Extension APIs with regard to connection pooling and looks at some existing vendor implementations of those APIs. He then looks at the upcoming J2EE Connector Architecture 1.0 that would support a vendor-independent/pluggable approach to managing resource connections
|
|
Java Naming and Directory InterfaceTM
The Java Naming and Directory InterfaceTM (JNDI) provides naming and directory functionality to applications written in the JavaTM programming language. It is designed to be independent of any specific naming or directory service implementation. Thus a variety of services--new, emerging, and already deployed ones--can be accessed in a common way.
|
|
Best Practice: Using java:comp to locate EJBs and increase application portability
If you deploy the same J2EE application on multiple application servers with a shared JNDI namespace, problems will occur as JNDI names in a namespace must be unique. J2EE applications deployed in the WebSphere Application Server environment should use the java:comp/env environment naming context (ENC) to lookup EJBs and not use the JNDI name. With this naming context, conflicts will be avoided and applications will be much more portable.
|
|
Using JNDI with the WebSphere Application Server J2EE Thin Application Client
The IBM Java Application thin client provides a lightweight environment that can access J2EE resources externally via Java Naming and Directory Interface (JNDI), thus avoiding the overhead of a J2EE platform on the client machine. This article shows you how to use the thin client to locate a remote object via a simple Java application.
|
|
Implementing vendor-independent JMS solutions : JNDI's role in creating vendor-neutral code
The popularity of the Java Message Service has been on an upswing lately, perhaps bolstered by the support of several major players in the world of real-time messaging. As an increasing number of vendors jump on the JMS bandwagon, it makes sense to ensure that your JMS code will work unmodified across multiple proprietary implementations. With a few simple steps, Java architect Nicholas Whitehead shows you how to combine JMS, the Java Naming and Directory Interface, and a well-made properties file to build vendor-neutral JMS solutions.
|
|
Dive into connection pooling with J2EE
Connection pooling is a technique used for sharing server resources among requesting clients. This article focuses on support for connection pooling of both database resources and non-database resources in a J2EE environment. Siva examines the JDBC 2.0, JMS 1.02, JNDI 1.2 Standard Extension APIs with regard to connection pooling and looks at some existing vendor implementations of those APIs. He then looks at the upcoming J2EE Connector Architecture 1.0 that would support a vendor-independent/pluggable approach to managing resource connections.
|
|
Configure database business measures with WebSphere Business Integration Monitor V4.2.4
This article walks you through the configuration steps for WebSphere® Application Server V5 and WebSphere Business Integration Monitor V4.2.4 to enable you add business metrics to your business monitoring solution. It shows you how to set up JNDI Data Sources in WebSphere Application Server and configure WebSphere Business Integration Monitor to access data in databases described in the data sources.
|
|
Co-hosting multiple versions of J2EE applications : JNDI name space conflicts
This article identifies and addresses key issues that need to be resolved to enable co-hosting of multiple versions of J2EE applications in a single WebSphere® Application Server instance.
|
|
Deploying multiple applications in J2EE 1.2
If you are developing with EJB technology, you are creating potentially reusable components. Unfortunately, plans to deal with reuse are often not put into place until it's too late. In this article, IBM enterprise developers Kyle Brown and Keys Botzum examine a common reuse scenario and explore some considerations that arise from it. They'll show you how to make the best choices for packaging and deploying your applications. They also offer details on an implementation using IBM WebSphere Application Server as an example.
|