import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
private AttributesMapper getAttributeMapper(final Object... baseArgs) {
	return new AttributesMapper() {

		@Override
		public Object mapFromAttributes(Attributes attrs) throws NamingException {
			LdapEntryVO entry = new LdapEntryVO();
			entry.setUsername((String) attrs.get(USERNAME_ATTRIBUTE_ID).get());
			DistinguishedName dn = new DistinguishedName(getBase(baseArgs));
			dn.add(USERNAME_ATTRIBUTE_ID, entry.getUsername());
			entry.setAbsoluteDn(dn.encode());
			Map<String, Object> attributes = new LinkedHashMap<String, Object>();
			if (searchResultAttributes != null) {
				for (int i = 0; i < searchResultAttributes.length; i++) {
					Attribute attr = attrs.get(searchResultAttributes[i]);
					if (attr != null) {
						attributes.put(searchResultAttributes[i], attr.get());
					}
				}
			}
			entry.setAttributes(attributes);
			return entry;
		}
	};
}
 

import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
@Test
public void testSearch() throws Exception {
    String dn = "some dn";
    String filter = "filter";
    Integer scope = SearchControls.SUBTREE_SCOPE;

    Exchange exchange = new DefaultExchange(context);
    Message in = new DefaultMessage();

    Map<String, Object> body = new HashMap<String, Object>();
    body.put(SpringLdapProducer.DN, dn);
    body.put(SpringLdapProducer.FILTER, filter);

    when(ldapEndpoint.getOperation()).thenReturn(LdapOperation.SEARCH);
    when(ldapEndpoint.scopeValue()).thenReturn(scope);

    processBody(exchange, in, body);
    verify(ldapTemplate).search(eq(dn), eq(filter), eq(scope),
            any(AttributesMapper.class));
}
 

import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
/**
 * Creates and LDAP filter from the DAO search filter. Currently only "property = value" filters are supported.
 *
 * @param filter
 * @return
 */
public static String createLDAPFilter(Filter filter, AttributesMapper mapper)
{
    // TODO add other filter types
    if (filter.getOperator() == Filter.OP_EQUAL) {
        String propertyName = filter.getProperty();
        if (mapper instanceof LdapAttributesMapper) {
            propertyName = ((LdapAttributesMapper) mapper)
                    .getLdapAttribute(propertyName);
        }
        return propertyName + "=" + filter.getValue().toString();
    } else {
        LOGGER.error("MISSING IMPLEMENTATION FOR " + filter);
    }
    return null;
}
 

import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
/**
 * Produces a set of DN's of all users that are a member of the CDS group in LDAP.
 * 
 * @return The DN's of all members of the CDS group in LDAP.
 */
@SuppressWarnings("unchecked")
private Set<DistinguishedName> getUserDns () {
	return (Set<DistinguishedName>)ldapTemplate.lookup (
		getLdapGroupDn (),
		new AttributesMapper () {
			@Override
			public Object mapFromAttributes (final Attributes attributes) throws NamingException {
				final Attribute attribute = attributes.get ("member");
				final Set<DistinguishedName> values = new HashSet<DistinguishedName> ();
				
				for (int i = 0; i < attribute.size (); ++ i) {
					values.add (new DistinguishedName (attribute.get (i).toString ()));
				}
				
				return values;
			}
		});
	
}
 

import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
@Test
public void testServerStartup() throws Exception {
    ctx = new ClassPathXmlApplicationContext("/applicationContext-testContextSource.xml");
    LdapTemplate ldapTemplate = ctx.getBean(LdapTemplate.class);
    assertThat(ldapTemplate).isNotNull();

    List<String> list = ldapTemplate.search(
            LdapQueryBuilder.query().where("objectclass").is("person"),
            new AttributesMapper<String>() {
                public String mapFromAttributes(Attributes attrs)
                        throws NamingException {
                    return (String) attrs.get("cn").get();
                }
            });
    assertThat(list.size()).isEqualTo(5);
}
 

import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
@Test
public void testServerStartup() throws Exception {
    ctx = new ClassPathXmlApplicationContext("/applicationContext-ldifPopulator.xml");
    LdapTemplate ldapTemplate = ctx.getBean(LdapTemplate.class);
    assertThat(ldapTemplate).isNotNull();

    List<String> list = ldapTemplate.search(
            LdapQueryBuilder.query().where("objectclass").is("person"),
            new AttributesMapper<String>() {
                public String mapFromAttributes(Attributes attrs)
                        throws NamingException {
                    return (String) attrs.get("cn").get();
                }
            });
    assertThat(list.size()).isEqualTo(5);
}
 

import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
@Test
public void testUpdateWithException() {
	String dn = "cn=Some Person,ou=company1,ou=Sweden";
	try {
		dummyDao.updateWithException(dn, "Some Person", "Updated Person", "Updated description");
		fail("DummyException expected");
	}
	catch (DummyException expected) {
		assertThat(true).isTrue();
	}

	log.debug("Verifying result");

	Object ldapResult = ldapTemplate.lookup(dn, new AttributesMapper() {
		public Object mapFromAttributes(Attributes attributes) throws NamingException {
			assertThat(attributes.get("sn").get()).isEqualTo("Person");
			assertThat(attributes.get("description").get()).isEqualTo("Sweden, Company1, Some Person");
			return new Object();
		}
	});

	assertThat(ldapResult).isNotNull();
}
 

import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
@Test
public void testUpdate() {
	String dn = "cn=Some Person,ou=company1,ou=Sweden";
	dummyDao.update(dn, "Some Person", "Updated Person", "Updated description");

	log.debug("Verifying result");
	Object ldapResult = ldapTemplate.lookup(dn, new AttributesMapper() {
		public Object mapFromAttributes(Attributes attributes) throws NamingException {
			assertThat(attributes.get("sn").get()).isEqualTo("Updated Person");
			assertThat(attributes.get("description").get()).isEqualTo("Updated description");
			return new Object();
		}
	});

	assertThat(ldapResult).isNotNull();

	dummyDao.update(dn, "Some Person", "Person", "Sweden, Company1, Some Person");
}
 

import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
@Test
public void testUpdateAndRename() {
	String dn = "cn=Some Person2,ou=company1,ou=Sweden";
	String newDn = "cn=Some Person2,ou=company2,ou=Sweden";
	// Perform test
	dummyDao.updateAndRename(dn, newDn, "Updated description");

	// Verify that entry was moved and updated.
	Object object = ldapTemplate.lookup(newDn, new AttributesMapper() {
		public Object mapFromAttributes(Attributes attributes) throws NamingException {
			assertThat(attributes.get("description").get()).isEqualTo("Updated description");
			return new Object();
		}
	});

	assertThat(object).isNotNull();
	dummyDao.updateAndRename(newDn, dn, "Sweden, Company1, Some Person2");
}
 

import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
@Test
public void testModifyAttributesWithException() {
	String dn = "cn=Some Person,ou=company1,ou=Sweden";
	try {
		// Perform test
		dummyDao.modifyAttributesWithException(dn, "Updated lastname", "Updated description");
		fail("DummyException expected");
	}
	catch (DummyException expected) {
		assertThat(true).isTrue();
	}

	// Verify result - check that the operation was properly rolled back
	Object result = ldapTemplate.lookup(dn, new AttributesMapper() {
		public Object mapFromAttributes(Attributes attributes) throws NamingException {
			assertThat(attributes.get("sn").get()).isEqualTo("Person");
			assertThat(attributes.get("description").get()).isEqualTo("Sweden, Company1, Some Person");
			return new Object();
		}
	});

	assertThat(result).isNotNull();
}
 

import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
@Test
public void testModifyAttributes() {
	String dn = "cn=Some Person,ou=company1,ou=Sweden";
	// Perform test
	dummyDao.modifyAttributes(dn, "Updated lastname", "Updated description");

	// Verify result - check that the operation was not rolled back
	Object result = ldapTemplate.lookup(dn, new AttributesMapper() {
		public Object mapFromAttributes(Attributes attributes) throws NamingException {
			assertThat(attributes.get("sn").get()).isEqualTo("Updated lastname");
			assertThat(attributes.get("description").get()).isEqualTo("Updated description");
			return new Object();
		}
	});

	assertThat(result).isNotNull();
}
 

import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
@Test
public void testUnbindWithException() {
	String dn = "cn=Some Person,ou=company1,ou=Sweden";
	try {
		// Perform test
		dummyDao.unbindWithException(dn, "Some Person");
		fail("DummyException expected");
	}
	catch (DummyException expected) {
		assertThat(true).isTrue();
	}

	// Verify result - check that the operation was properly rolled back
	Object ldapResult = ldapTemplate.lookup(dn, new AttributesMapper() {
		public Object mapFromAttributes(Attributes attributes) throws NamingException {
			// Just verify that the entry still exists.
			return new Object();
		}
	});

	assertThat(ldapResult).isNotNull();
}
 

import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
@Test
public void testUpdate() {
	String dn = "cn=Some Person,ou=company1,ou=Sweden";
	OrgPerson person = (OrgPerson) this.hibernateTemplate.load(OrgPerson.class, new Integer(1));
	person.setLastname("Updated Person");
	person.setDescription("Updated description");

	dummyDao.update(person);

	log.debug("Verifying result");
	Object ldapResult = ldapTemplate.lookup(dn, new AttributesMapper() {
		public Object mapFromAttributes(Attributes attributes) throws NamingException {
			assertThat(attributes.get("sn").get()).isEqualTo("Updated Person");
			assertThat(attributes.get("description").get()).isEqualTo("Updated description");
			return new Object();
		}
	});

	OrgPerson updatedPerson = (OrgPerson) this.hibernateTemplate.load(OrgPerson.class, new Integer(1));
	assertThat(updatedPerson.getLastname()).isEqualTo("Updated Person");
	assertThat(updatedPerson.getDescription()).isEqualTo("Updated description");
	assertThat(ldapResult).isNotNull();
}
 

import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
@Test
public void testUpdateAndRename() {
	String dn = "cn=Some Person2,ou=company1,ou=Sweden";
	String newDn = "cn=Some Person2,ou=company2,ou=Sweden";
	// Perform test
	dummyDao.updateAndRename(dn, newDn, "Updated description");

	// Verify that entry was moved and updated.
	Object object = ldapTemplate.lookup(newDn, new AttributesMapper() {
		public Object mapFromAttributes(Attributes attributes) throws NamingException {
			assertThat(attributes.get("description").get()).isEqualTo("Updated description");
			return new Object();
		}
	});

	assertThat(object).isNotNull();
}
 

import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
@Test
public void testModifyAttributes() {
	String dn = "cn=Some Person,ou=company1,ou=Sweden";
	// Perform test
	dummyDao.modifyAttributes(dn, "Updated lastname", "Updated description");

	// Verify result - check that the operation was not rolled back
	Object result = ldapTemplate.lookup(dn, new AttributesMapper() {
		public Object mapFromAttributes(Attributes attributes) throws NamingException {
			assertThat(attributes.get("sn").get()).isEqualTo("Updated lastname");
			assertThat(attributes.get("description").get()).isEqualTo("Updated description");
			return new Object();
		}
	});

	assertThat(result).isNotNull();
	dummyDao.update(dn, "Some Person", "Person", "Sweden, Company1, Some Person");
}
 

import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
/**
 * Demonstrates how to retrieve all values of a multi-value attribute.
 * 
 * @see LdapTemplateContextMapperITest#testSearch_ContextMapper_MultiValue()
 */
@Test
public void testSearch_AttributesMapper_MultiValue() throws Exception {
	AttributesMapper mapper = new AttributesMapper() {
		public Object mapFromAttributes(Attributes attributes) throws NamingException {
			LinkedList list = new LinkedList();
			NamingEnumeration enumeration = attributes.get("uniqueMember").getAll();
			while (enumeration.hasMoreElements()) {
				String value = (String) enumeration.nextElement();
				list.add(value);
			}
			String[] members = (String[]) list.toArray(new String[0]);
			return members;
		}
	};
	List result = tested.search("ou=groups", "(&(objectclass=groupOfUniqueNames)(cn=ROLE_USER))", mapper);

	assertThat(result).hasSize(1);

	assertThat(((String[]) result.get(0)).length).isEqualTo(4);
}
 

import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
@Test
  public void testServerStartup() throws Exception {
      ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
      LdapTemplate ldapTemplate = ctx.getBean(LdapTemplate.class);
      assertNotNull(ldapTemplate);

List<String> list = ldapTemplate.search(
		LdapQueryBuilder.query().where("objectclass").is("person"),
		new AttributesMapper<String>() {
			public String mapFromAttributes(Attributes attrs)
					throws NamingException {
				return (String) attrs.get("cn").get();
			}
		});
      assertEquals(5, list.size());
  }
 

import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
/**
 * Determine owf groups from the list of groups. Translates into OwfGroup
 * objects
 * 
 * @param dn
 *            the user's dn
 * @return GrantedAuthority array
 */
   @SuppressWarnings("unchecked")
protected Collection<OwfGroup> determineOwfGroups(final String dn) {
       return (Collection<OwfGroup>) ldapTemplate.search(searchBase, 
           //fill in the filter string
           MessageFormat.format(filter, LdapEncoder.filterEncode(dn + "," + contextSource.getBaseLdapPath().toString())),
               new AttributesMapper() {
                   public Object mapFromAttributes(Attributes attrs) throws NamingException {
                       //our sample ldap data does not include all of these fields
                       return new OwfGroupImpl((String)attrs.get("cn").get(), null, null, true);
                   }   
               });
}
 

import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
@Test
public void testLookup_AttributesMapper() {
	AttributesMapper mapper = new PersonAttributesMapper();
	Person person = (Person) tested.lookup("cn=Some Person2, ou=company1,ou=Sweden", mapper);

	assertThat(person.getFullname()).isEqualTo("Some Person2");
	assertThat(person.getLastname()).isEqualTo("Person2");
	assertThat(person.getDescription()).isEqualTo("Sweden, Company1, Some Person2");
}
 

import org.springframework.ldap.core.AttributesMapper; //导入依赖的package包/类
@Test
public void testLookup_AttributesMapper_LdapName() {
	AttributesMapper mapper = new PersonAttributesMapper();
	Person person = (Person) tested.lookup(LdapUtils.newLdapName("cn=Some Person2, ou=company1,ou=Sweden"), mapper);

	assertThat(person.getFullname()).isEqualTo("Some Person2");
	assertThat(person.getLastname()).isEqualTo("Person2");
	assertThat(person.getDescription()).isEqualTo("Sweden, Company1, Some Person2");
}