Home

Prometric Centers

Contact Us

Advertise

TechBreaths

Subscribe Posts | Comments

JavaBeat

Java J2EE raquo

Web Frameworks raquo

XML Technologies raquo

Tools amp IDEs raquo

RIA raquo

Web Servers raquo

Internet raquo

Scripting raquo

Introduction to Spring LDAPMay 5 2011

Spring MVC

laquo raquo

Spring LDAP

Introduction

In this article Spring LDAP which provides a simplified wrapper framework around LDAP implementations is

covered in detail This article assumes that the reader has a basic understanding on Spring framework and

LDAP directory server The first section of the article covers the various operations that can be performed on

LDAP Support for parsing externally stored LDAP data is also covered with the help of LDIF data The ODM

Manager APIs for mapping LDAP objects directly to java objects have also been explored in this article If

you are beginner in learning spring framework please read Introduction to Spring Framework

Download Spring LDAP Sample Code

Source Code for Spring LDAP

LDAP operations

In this section we will illustrate the usage of various operations that can be performed on LDAP directory using Spring The examples given here are tested with

Apache Directory server however the code should work with any LDAP implementations The operations that will be getting covered in the following sections are

Searching

Adding objects

Removing objects

Modifying objects

Searching objects

For illustrating search operations in LDAP we will create objects under the node systemusers We will be creating objects of type person in this node Note that for

having an object oriented access for the person type we will create a java class User that maps to it Have a look at the declaration of this class

12

package netjavabeatarticlesspringldap

Ads by Google Hosting Java Java Download Java Java Tutorial

Nearshore Software

Entwicklung Qualitaumltssicherung Support AMS

etc in Deutschwwwebsromaniacom

AMQP meets JMS

AMQP 10 fully integrated with JMS free AMQP10 Clientwwwswiftmqcom

Sind Sie der Java Hirsch

Gesucht talentierte SW Entwickler inagileminnovativem Umfeldwwwbaloisecomkarriere

Adaxes AD im Griff

benutzerfreundliche Verwaltung von ActiveDirectorywwwsyntlogode

Introduction to Spring LDAP httpwwwjavabeatnet201105introduction-to-spring-ldapall1

1 von 11 27052012 0433

id23894359 pdfMachine by Broadgun Software - a great PDF writer - a great PDF creator - httpwwwpdfmachinecom httpwwwbroadguncom

3456789101112131415161718192021222324252627

public class User

private String commonNameprivate String telephone

public String getCommonName()

return commonName

public void setCommonName(String commonName)

thiscommonName = commonName

public String getTelephone()

return telephone

public void setTelephone(String telephone)

thistelephone = telephone

public String toString()

return commonName + - + telephone

The class definition is pretty simple It defines two simple properties commonName and telephone The search class that makes use of Spring libraries is given below

Go through the following code carefully

123456789101112131415161718192021222324252627282930313233343536373839

package netjavabeatarticlesspringldapoperations import javautilHashSetimport javautilSet import netjavabeatarticlesspringldapUserimport netjavabeatarticlesspringldapUserAttributesMapper import orgspringframeworkcontextApplicationContextimport orgspringframeworkcontextsupportClassPathXmlApplicationContextimport orgspringframeworkldapcoreLdapTemplate public class SimpleSearch

private LdapTemplate ldapTemplate

SuppressWarnings(unchecked)public SetltUsergt getAllUsers()

UserAttributesMapper mapper = new UserAttributesMapper()return new HashSetltUsergt(

ldapTemplatesearch(ou=usersou=system (objectClass=person) mapper))

public void setLdapTemplate(LdapTemplate ldapTemplate)

thisldapTemplate = ldapTemplate

public static void main(String[] args)

ApplicationContext context = new ClassPathXmlApplicationContext(searchxml)

SimpleSearch simpleSearch = new SimpleSearch()simpleSearchsetLdapTemplate(contextgetBean(ldapTemplate LdapTemplateclass))for (User user simpleSearchgetAllUsers())

Systemoutprintln(user)

Note that the class defines an instance of LdapTemplate class This template class follows the template pattern and is very similar to the existing template classes like

JdbcTemplate JmsTemplate etc Performing operations on the LDAP directory becomes simple with this template class Note that before using this template class it

has to be configured with various properties such as username password and the url of the directory server We will see the configuration in the later section of this

Introduction to Spring LDAP httpwwwjavabeatnet201105introduction-to-spring-ldapall1

2 von 11 27052012 0433

article

Carefully examine the method getAllUsers() This method calls the search() method defined on LdapTemplate for searching objects in the directory server Note that this

method takes two parameters the first being the base domain name and the second one defines the filter In our case since the objects are located under the node

systemusers the base domain name happens to be ou=usersou=system here ou stands for organizational unit For the second parameter we have used the value

objectClass=person which means that we want to search objects of type person Note that since LDAP can store objects of any type the return objects have to be

mapped to some implementation representing a custom model and for the same purpose we have used the customized implementation of AttributesMapper

implementation which is UserAttributesMapper

1234567891011121314151617181920212223242526

package netjavabeatarticlesspringldap import javaxnamingNamingExceptionimport javaxnamingdirectoryAttributes import orgspringframeworkldapcoreAttributesMapper public class UserAttributesMapper implements AttributesMapper

Overridepublic User mapFromAttributes(Attributes attributes) throws NamingException

User userObject = new User()

String commonName = (String)attributesget(cn)get()userObjectsetCommonName(commonName)if (attributesget(telephoneNumber) == null)

Systemoutprintln(Telephone is null for + commonName)else

String telephone = attributesget(telephoneNumber)get()toString()userObjectsetTelephone(telephone)

return userObject

Note that in the above class the method mapFromAttributes() is overridden which takes the input as Attributes which represents a general purpose attribute collection

The implementation creates a customized flavor of model implementation by gathering the relevant attributes and then constructs the object accordingly

123456789101112131415161718192021222324252627282930313233

package netjavabeatarticlesspringldapoperations import javautilHashSetimport javautilSet import netjavabeatarticlesspringldapUserimport netjavabeatarticlesspringldapUserAttributesMapper import orgspringframeworkcontextApplicationContextimport orgspringframeworkcontextsupportClassPathXmlApplicationContextimport orgspringframeworkldapcoreLdapTemplateimport orgspringframeworkldapfilterAndFilterimport orgspringframeworkldapfilterEqualsFilter public class DynamicSearch

private LdapTemplate ldapTemplate

SuppressWarnings(unchecked)public SetltUsergt getAllUsers(String surName)

UserAttributesMapper mapper = new UserAttributesMapper()

AndFilter filterObject = new AndFilter()filterObjectand(new EqualsFilter(objectClass person))filterObjectand(new EqualsFilter(sn surName))

return new HashSetltUsergt(

ldapTemplatesearch(ou=usersou=system filterObjectencode() mapper))

public void setLdapTemplate(LdapTemplate ldapTemplate)

thisldapTemplate = ldapTemplate

Introduction to Spring LDAP httpwwwjavabeatnet201105introduction-to-spring-ldapall1

3 von 11 27052012 0433

3435363738394041424344454647

public static void main(String[] args)

ApplicationContext context = new ClassPathXmlApplicationContext(searchxml)

DynamicSearch dynamicSearch = new DynamicSearch()dynamicSearchsetLdapTemplate(contextgetBean(ldapTemplate LdapTemplateclass))for (User user dynamicSearchgetAllUsers(David))

Systemoutprintln(user)

A variation of searching objects dynamically in the directory server is given above In the above code the obvious variation is the search filter being dynamically

constructed using Filter APIs We have dynamically constructed search parameters objectClass sn and have anded them using AndFilter Rest of the code in the

above section remains the same

Adding objects

In this section we will see how to add objects in the LDAP directory For adding objects the bind() defined on LdapTemplate can be used Note that the bind()

methods takes the distinguished name and the list of attributes as parameters Note that the unique distinguished name represents the combination of base name and

the common name The base name is ou=usersou=system in our case and the common name will come as user input

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647

package netjavabeatarticlesspringldapoperations import javaxnamingdirectoryAttributesimport javaxnamingdirectoryBasicAttributeimport javaxnamingdirectoryBasicAttributes import netjavabeatarticlesspringldapUser import orgspringframeworkcontextApplicationContextimport orgspringframeworkcontextsupportClassPathXmlApplicationContextimport orgspringframeworkldapcoreDistinguishedNameimport orgspringframeworkldapcoreLdapTemplate public class AddUser

private LdapTemplate ldapTemplate

public void add(String commonName String surName String telephone)

String baseDn = ou=usersou=systemDistinguishedName distinguisedName = new DistinguishedName(baseDn)distinguisedNameadd(cn commonName)

Attributes userAttributes = new BasicAttributes()userAttributesput(sn surName)userAttributesput(telephoneNumber telephone)

BasicAttribute classAttribute = new BasicAttribute(objectclass)classAttributeadd(top)classAttributeadd(person)userAttributesput(classAttribute)

ldapTemplatebind(distinguisedName null userAttributes)

public void setLdapTemplate(LdapTemplate ldapTemplate)thisldapTemplate = ldapTemplate

public static void main(String[] args)

ApplicationContext context = new ClassPathXmlApplicationContext(searchxml)LdapTemplate ldapTemplate = contextgetBean(ldapTemplate LdapTemplateclass)

AddUser addPerson = new AddUser()addPersonsetLdapTemplate(ldapTemplate)addPersonadd(New User User 12345)

Introduction to Spring LDAP httpwwwjavabeatnet201105introduction-to-spring-ldapall1

4 von 11 27052012 0433

4849505152535455

SimpleSearch simpleSearch = new SimpleSearch()simpleSearchsetLdapTemplate(ldapTemplate)for (User user simpleSearchgetAllUsers())

Systemoutprintln(user)

For adding simple attributes we can use the put() method defined on the BasicAttributes class The attribute objectClass is a multi-valued attribute By default any

object defined in LDAP will have the objectClass set to top Hence in our case the object type for the person objects will be top person Hence for adding a

multi-valued attribute such as objectClass the attribute values have to be packaged as a BasicAttribute object and then have to be added to the main attribute

Removing objects

For removing objects from the directory server the method unbind() can be used Because a distinguished name represents a unique name in the directory server the

unbind() method takes an instance of distinguished name as an argument

123456789101112131415161718192021222324252627282930313233343536373839404142

package netjavabeatarticlesspringldapoperations import netjavabeatarticlesspringldapUser import orgspringframeworkcontextApplicationContextimport orgspringframeworkcontextsupportClassPathXmlApplicationContextimport orgspringframeworkldapcoreDistinguishedNameimport orgspringframeworkldapcoreLdapTemplate public class RemoveUser

private LdapTemplate ldapTemplate

public void remove(String commonName)

String baseDn = ou=usersou=systemDistinguishedName distinguisedName = new DistinguishedName(baseDn)distinguisedNameadd(cn commonName)

ldapTemplateunbind(distinguisedName)

public void setLdapTemplate(LdapTemplate ldapTemplate)thisldapTemplate = ldapTemplate

public static void main(String[] args)

ApplicationContext context = new ClassPathXmlApplicationContext(searchxml)LdapTemplate ldapTemplate = contextgetBean(ldapTemplate LdapTemplateclass)

RemoveUser removePerson = new RemoveUser()removePersonsetLdapTemplate(ldapTemplate)removePersonremove(New User)

SimpleSearch simpleSearch = new SimpleSearch()simpleSearchsetLdapTemplate(ldapTemplate)for (User user simpleSearchgetAllUsers())

Systemoutprintln(user)

The above code tries to remove a person and then queries for the list of person objects in the directory server

Modifying objects

Existing objects can be modified by invoking the method modifyAttributes() defined on the LdapTemplate class Note that the arguments to this method are the

distinguished name and the list of attributes to be modified

Online Dashboard software

Online reporting solution to manage KPIs in web based dashboardswwwbittle-solutionscom

Introduction to Spring LDAP httpwwwjavabeatnet201105introduction-to-spring-ldapall1

5 von 11 27052012 0433

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950

package netjavabeatarticlesspringldapoperations import javaxnamingdirectoryAttributeimport javaxnamingdirectoryBasicAttributeimport javaxnamingdirectoryDirContextimport javaxnamingdirectoryModificationItem import netjavabeatarticlesspringldapUser import orgspringframeworkcontextApplicationContextimport orgspringframeworkcontextsupportClassPathXmlApplicationContextimport orgspringframeworkldapcoreDistinguishedNameimport orgspringframeworkldapcoreLdapTemplate public class ModifyUser

private LdapTemplate ldapTemplate

public void modify(String commonName String telephone)

String baseDn = ou=usersou=systemDistinguishedName distinguisedName = new DistinguishedName(baseDn)distinguisedNameadd(cn commonName)

Attribute telephoneAttribute = new BasicAttribute(telephoneNumber telephone)ModificationItem telephoneItem = new ModificationItem(

DirContextREPLACE_ATTRIBUTE telephoneAttribute)ldapTemplatemodifyAttributes(distinguisedName new ModificationItem[]telephoneItem)

public void setLdapTemplate(LdapTemplate ldapTemplate)thisldapTemplate = ldapTemplate

public static void main(String[] args)

ApplicationContext context = new ClassPathXmlApplicationContext(searchxml)LdapTemplate ldapTemplate = contextgetBean(ldapTemplate LdapTemplateclass)

ModifyUser modifyPerson = new ModifyUser()modifyPersonsetLdapTemplate(ldapTemplate)modifyPersonmodify(Steve David 9999999)

SimpleSearch simpleSearch = new SimpleSearch()simpleSearchsetLdapTemplate(ldapTemplate)for (User user simpleSearchgetAllUsers())

Systemoutprintln(user)

Each attribute to be modified must be represented through a ModificationItem object which specifies the flag whether the value of the existing attribute has to be

replaced or a new attribute can be created of the attribute if it doesnt exist In the above sample for modifying the telephoneNumber attribute we have used the

REPLACE_ATTRIBUTE flag which will replace the existing attribute value for the person object

12345678910111213141516

ltxml version=10 encoding=UTF-8gtltbeans xmlns=httpwwwspringframeworkorgschemabeans xmlnsxsi=httpwwww3org2001XMLSchema-instance xmlnsutil=httpwwwspringframeworkorgschemautil xsischemaLocation=httpwwwspringframeworkorgschemabeans httpwwwspringframeworkorgschemabeansspring-beans-25xsd httpwwwspringframeworkorgschemautil httpwwwspringframeworkorgschemautilspring-util-25xsdgt ltbean id=ldapTemplate class=orgspringframeworkldapcoreLdapTemplategt ltproperty name=contextSource ref=contextSource gt ltbeangt ltbean id=contextSource class=orgspringframeworkldapcoresupportLdapContextSourcegt ltproperty name=url value=ldaplocalhost10389 gt ltproperty name=userDn value=uid=adminou=system gt ltproperty name=password value=secret gt ltproperty name=pooled value=false gt

Introduction to Spring LDAP httpwwwjavabeatnet201105introduction-to-spring-ldapall1

6 von 11 27052012 0433

171819

ltbeangt ltbeansgt

The Spring configuration file for configuring LdapTemplate instance is given below Note that the property contextSource has to be populated The contextSource

property is of type LdapContextSource and the mandatory properties userDn password and url have to be specified

~~~~~~~~~~~~

LDIF Parser

LDIF stands for LDAP Directory Interchange Format and it represents the way of storing LDAP objects information in a flat file so that they can be easily transported to

different machines hosting LDAP servers Spring LDAP framework provides support for parsing LDAP objects available in a text file and this section illustrates the

usage of these APIs

Download Spring LDAP Sample Code

Source Code for Spring LDAP

A simple text file containing sample LDAP object information in a text file is given below

12345678910111213

dn ou=usersou=systemsn SN-1telephoneNumber 33333objectClass personobjectClass topcn CN-1 dn ou=usersou=systemsn SN-2telephoneNumber 77777objectClass personobjectClass topcn CN-2

Now we will see how to make use of LDIF parser The program constructs an instance of LdifParser object and then calls the hasMoreRecords() and getRecord() for

reading all attribute information from the text file A call to getRecord() will retrieve a single record information from the file The method getAll() will return all the attribute

names for the record Since there is a possibility for an attribute to contain multiple values we again call getAll() method to collect the attribute values

123456789101112131415161718192021222324252627282930313233

package netjavabeatarticlesspringldif import javaxnamingNamingEnumerationimport javaxnamingdirectoryAttributeimport javaxnamingdirectoryAttributes import orgspringframeworkcoreioFileSystemResourceimport orgspringframeworkldapldifparserLdifParserimport orgspringframeworkldapldifparserParser public class LdifTest

public static void main(String[] args) throws Exception

Parser parser = new LdifParser()

parsersetResource(new FileSystemResource(binusersldif))parseropen()

while (parserhasMoreRecords())

Attributes attributes = parsergetRecord()String personDetails = getPersonDetails(attributes)Systemoutprintln(personDetails)

private static String getPersonDetails(Attributes attributes) throws Exception

StringBuilder personDetails = new StringBuilder()personDetailsappend()

NamingEnumerationlt extends Attributegt attributeNames = attributesgetAll()

Introduction to Spring LDAP httpwwwjavabeatnet201105introduction-to-spring-ldapall1

7 von 11 27052012 0433

343536373839404142434445464748495051

while (attributeNameshasMoreElements())

Attribute attribute = attributeNamesnext()personDetailsappend([ + attributegetID())

SuppressWarnings(unchecked)NamingEnumerationltStringgt attributeValues = (NamingEnumerationltStringgt) attributegetAll()while (attributeValueshasMoreElements())

String attributeValue = attributeValuesnext()personDetailsappend(()append(attributeValue)append())

personDetailsappend(])

personDetailsappend()return personDetailstoString()

ODM Manager

ODM stands for Object Directory Mapping and this facilitates mapping of the LDAP objects directly to java objects with the help of annotations For this example we will

create a customized type applicationEntity under the node systemconfigurationservices We will start with the java model class ApplicationEntity which will have the

core attributes cn description and presentationAddress

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647

package netjavabeatarticesspringodm import javautilArrayListimport javautilList import javaxnamingName import orgspringframeworkldapodmannotationsAttributeimport orgspringframeworkldapodmannotationsEntryimport orgspringframeworkldapodmannotationsId Entry(objectClasses = applicationEntity top)public class ApplicationEntity

Idprivate Name distinguisedName

Attribute(name=cn)private String cn

Attribute(name=description)private String description

Attribute(name=presentationAddress)private String presentationAddress

Attribute(name=objectClass)private ListltStringgt objectClassNames

public ApplicationEntity()

objectClassNames = new ArrayListltStringgt()

public Name getDistinguisedName()

return distinguisedName

public void setDistinguisedName(Name distinguisedName)

thisdistinguisedName = distinguisedName

public String getCn()

return cn

public void setCn(String cn)

thiscn = cn

Introduction to Spring LDAP httpwwwjavabeatnet201105introduction-to-spring-ldapall1

8 von 11 27052012 0433

484950515253545556575859606162636465666768697071727374757677

public String getDescription() return description

public void setDescription(String description) thisdescription = description

public String getPresentationAddress() return presentationAddress

public void setPresentationAddress(String presentationAddress) thispresentationAddress = presentationAddress

public ListltStringgt getObjectClassNames() return objectClassNames

public void setObjectClassNames(ListltStringgt objectClassNames) thisobjectClassNames = objectClassNames

public String toString()return cn + + description + + objectClassNames + + presentationAddress

To specify that the java class maps directly to some ldap object the annotation Entry has to be used Note that this annotation has to be configured with the list of

object types in our case this happens to be top and applicationEntiy One mandatory attribute of type Name representing the distinguished name has to be defined

and has to be annotated with Id The attributes for this entity can then be defined each annotated with Attribute annotation

12345678910111213141516171819202122232425262728293031323334353637

package netjavabeatarticesspringodm import javautilList import javaxnamingdirectorySearchControls import orgspringframeworkcontextApplicationContextimport orgspringframeworkcontextsupportClassPathXmlApplicationContextimport orgspringframeworkldapcoreDistinguishedNameimport orgspringframeworkldapodmcoreOdmManager public class Main

public static void main(String[] args)

ApplicationContext context = new ClassPathXmlApplicationContext(configxml)OdmManager odmManager = contextgetBean(odmManager OdmManagerclass)

create(odmManager)list(odmManager)read(odmManager)

private static void create(OdmManager odmManager)

ApplicationEntity addressEntity = new ApplicationEntity()

DistinguishedName distinguishedName = new DistinguishedName(ou=servicesou=configurationou=system)distinguishedNameadd(cn Address)addressEntitysetDistinguisedName(distinguishedName)addressEntitysetCn(Address)addressEntitysetDescription(Contains information about the Address entity)addressEntitysetPresentationAddress(Address)

addressEntitygetObjectClassNames()add(top)addressEntitygetObjectClassNames()add(applicationEntity)

Introduction to Spring LDAP httpwwwjavabeatnet201105introduction-to-spring-ldapall1

9 von 11 27052012 0433

38394041424344454647484950515253545556575859606162636465

odmManagercreate(addressEntity)

private static void read(OdmManager odmManager)

String baseDn = ou=servicesou=configurationou=systemDistinguishedName distinguisedName = new DistinguishedName(baseDn)distinguisedNameadd(cn Book)

ApplicationEntity applicationEntity = odmManagerread(ApplicationEntityclass distinguisedName)Systemoutprintln(applicationEntity)

private static void list(OdmManager odmManager)

String baseDn = ou=servicesou=configurationou=systemDistinguishedName distinguisedName = new DistinguishedName(baseDn)

SearchControls searchControls = new SearchControls()

ListltApplicationEntitygt applicationEntityList = odmManagerfindAll(

ApplicationEntityclass distinguisedName searchControls)for (ApplicationEntity applicationEntity applicationEntityList)

Systemoutprintln(applicationEntity)

For creating a new object we can use the method create() defined on OdmManager class An instance of ApplicationEntity is created and the distinguished name is set

by calling the setDistinguishedName() method After that the various attributes like cn address and presentationAddress is populated on the entity object For

reading an entity the method read() can be used by passing in an instance of distinguished name For listing all the objects of a particular object type the method

findAll() defined on OdmManager class can be used This method takes the entity type and the distinguished name as parameters

Conclusion

This article started with covering the basics of Spring LDAP by illustrating the various operations such as search add remove modify etc that can be performed

Lots of samples were also given for the better illustration of these concepts LDAP directory data can be stored externally in a file for easier migration and hence

Spring LDAP supports parsing data from such files with the help of LDIF Parser The final section of the article illustrated the usage of ODM Manager which provides a

directory mapping between ldap objects and java objects through annotations

laquo raquo

Comments

0 comments

Related posts

Introduction to Spring JDBC Framework1

Introduction to Spring OXM2

Introduction to Spring Converters and Formatters3

Introduction to Spring Expression Language (SpEL)4

Introduction to Spring Validation5

Spring LDAP

About krishnas

View all posts by krishnas rarrlarr How to integrate legacy views with designer tools in Griffon

Ads by Google Hosting Java Java Download Java Java Tutorial

Facebook social plugin

Add a comment

Comment using

Introduction to Spring LDAP httpwwwjavabeatnet201105introduction-to-spring-ldapall1

10 von 11 27052012 0433

Like

M Subscribe by email S RSS

Routing Using Camels Implementation of the EIPs rarr

Showing 0 comments

Subscribe

Submit your email id to receive the latest news on Java Technology

Recent Posts

Annotation Based Bean Wiring Autowired in Spring frameworkEnhanced Collections API in Java 8- Supports Lambda expressionsA sneak peak at the Lambda Expressions in Java 8Whats new in Spring 30What are Functional Interfaces and Functional Descriptor

Recent Comments

Annotation Based Bean Wiring Autowired in Spring frameworkJavaBeat on Introduction to Spring Web FrameworkAnnotation Based Bean Wiring Autowired in Spring frameworkJavaBeat on Spring Framework Interview QuestionsEnhanced Collections API in Java 8- Supports Lambda expressionsJavaBeat on Virtual Extension (or Defender) Methods in Java 8Shahjoyful on Mapping Java Objects and XML Documents using JAXB in Java 60Shahjoyful on Mapping Java Objects and XML Documents using JAXB in Java 60

Popular Posts

Spring Framework Interview Questions 6 comment(s) | 111 view(s)Introduction to Spring MVC Framework 2 comment(s) | 74 view(s)File Upload and Download using Java 10 comment(s) | 72 view(s)Introduction to Hibernate Caching 0 comment(s) | 63 view(s)Design Patterns Interview Questions 0 comment(s) | 61 view(s)Spring and Hibernate ORM Framework Integration 2 comment(s) | 52 view(s)

TechBreaths

Greenshot A Free Screenshot Tool for WindowsHow to add Post Statistics link for JetPack pluginDesktop App for Amazon Cloud DriveGoogle Drive offers 5GB Free StorageHow to add author RSS Feed in WordPress Blog

Archives

Categories

May 2011M T W T F S S

laquo Apr Jun raquo

12 3 4 5 6 7 89 10 11 12 13 14 1516 17 18 19 20 21 2223 24 25 26 27 28 2930 31

Recent Posts

Annotation Based Bean Wiring Autowired in Spring frameworkEnhanced Collections API in Java 8- Supports Lambda expressionsA sneak peak at the Lambda Expressions in Java 8Whats new in Spring 30What are Functional Interfaces and Functional Descriptor

JavaBeat Copyright copy 2012 All Rights Reserved

LoginAdd New Comment

Introduction to Spring LDAP httpwwwjavabeatnet201105introduction-to-spring-ldapall1

11 von 11 27052012 0433