封装LDAP 增删改查 方法

封装LDAP的方法，让他可以已实体的方式来进行操作，思路类似于JPA 传入传出最好是实体，在实体里 使用map当作注解映射。
推荐阅读：
RedHat6下构建LDAP服务 http://www.linuxidc.com/Linux/2013-05/84741.htm
Linux 使用pam_LDAP通过ad域认证 http://www.linuxidc.com/Linux/2012-09/71043.htm
Zimbra故障——Unable to determine enabled services from LDAP http://www.linuxidc.com/Linux/2012-07/66869.htm
下面 先上2个代码
第一个封装一个baseDao；
import java.util.HashMap; 
import java.util.List; 
import java.util.Map; 
import javax.naming.Name; 
import javax.naming.directory.SearchControls; 
import org.apache.commons.lang.StringUtils; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.ldap.control.PagedResultsCookie; 
import org.springframework.ldap.control.PagedResultsDirContextProcessor; 
import org.springframework.ldap.core.ContextMapper; 
import org.springframework.ldap.core.DirContextAdapter; 
import org.springframework.ldap.core.DirContextOperations; 
import org.springframework.ldap.core.DistinguishedName; 
import org.springframework.ldap.core.LdapTemplate; 
import org.springframework.ldap.core.simple.ParameterizedContextMapper; 
import org.springframework.ldap.filter.AndFilter; 
import org.springframework.ldap.filter.EqualsFilter; 
import org.springframework.ldap.filter.WhitespaceWildcardsFilter; 
/** 
 * Dao基层 
 * @创建人 PengBo 
 * @创建时间 2013-7-7  下午7:03:49 
 */
@SuppressWarnings("unchecked") 
public class BaseDAO< T extends BaseModel> { 
    @Autowired 
    private LdapTemplate ldapTemplate; 
                                                                                                                                        
    /** 
    * 创建实体 
    * @param t 
    * @创建人 PengBo 
    * @创建时间 2013-7-7  下午6:53:40 
    */
    public void create(T t) { 
          DirContextAdapter context = new DirContextAdapter(buildDn(t)); 
          mapToContext(t.getMap(), context); 
          ldapTemplate.bind(context); 
      } 
    /** 
    * 更新实体 
    * @param t 
    * @创建人 PengBo 
    * @创建时间 2013-7-7  下午6:53:56 
    */
    public void update(T t) { 
          DirContextOperations context = ldapTemplate.lookupContext(buildDn(t)); 
          mapToContext(t.getMap(), context); 
          ldapTemplate.modifyAttributes(context); 
      } 
    /** 
    * 创建更新时使用的属性存储构造器 
    * @param map 
    * @param context 
    * @创建人 PengBo 
    * @创建时间 2013-7-7  下午6:54:16 
    */
    private void mapToContext(Map<String, String> map, DirContextOperations context) { 
            context.setAttributeValue("objectclass", "top"); 
        for(String mkey:map.keySet()){          //获得实体的属性和对应的值 加入属性构造器中 
            if(map.get(mkey) != null) 
            context.setAttributeValue(mkey, map.get(mkey)); 
        } 
    } 
    /** 
    * 删除属性 
    * @param t 
    * @创建人 PengBo 
    * @创建时间 2013-7-7  下午6:54:46 
    */
    public void delete(T t) { 
          ldapTemplate.unbind(buildDn(t)); 
    } 
    /** 
    * 根据唯一DN进行查找 
    * @param t 
    * @return 
    * @创建人 PengBo 
    * @创建时间 2013-7-7  下午6:55:02 
    */
    public T findByPrimaryKey(final T t) { 
        return (T) ldapTemplate.lookup(buildDn(t),  getContextMapper(t)); 
    } 
                                                                                                                                        
    /** 
    * 根据dn直接获取实体信息 
    * @param t 
    * @param dn 
    * @return 
    * @创建人 PengBo 
    * @创建时间 2013-7-29  下午4:39:59 
    */
    public T findByDN(final T t,String dn) { 
        return (T) ldapTemplate.lookup(dn,  getContextMapper(t)); 
    } 
    /** 
    * 根据实体条件精确查找进行查找 
    * @param t 
    * @return  返回查找的集合 
    * @创建人 PengBo 
    * @创建时间 2013-7-7  下午6:55:38 
    */
    public List<T> findByEqualFilter( final T t) { 
        return  ldapTemplate.search(buildDn(t), getEqualFilter(t).encode(), getContextMapper(t)); 
                                                                                                                                                
    } 
                                                                                                                                        
    /** 
    * 根据实体条件进行查找 
    * @param t 
    * @return  返回查找的集合 
    * @创建人 PengBo 
    * @创建时间 2013-7-7  下午6:55:38 
    */
    public List<T> findByFilter( final T t) { 
        return  ldapTemplate.search(buildDn(t), getFilter(t).encode(), getContextMapper(t)); 
                                                                                                                                                
    } 
                                                                                                                                              
    /** 
    * 根据实体类型查找所有实体 
    * @param t 
    * @return  返回实体集合 
    * @创建人 PengBo 
    * @创建时间 2013-7-7  下午6:56:13 
    */
    public List<T> findAll(final T t) { 
        return  ldapTemplate.search(buildDn(t),  getObjectclass(t).encode(), getContextMapper(t)); 
                                                                                                                                          
    } 
    /** 
    * 根据实体的分页属性进行查获早分页信息  
    * @param basePage 
    * @return 
    * @创建人 PengBo 
    * @创建时间 2013-7-7  下午6:57:00 
    */
    public Page<T> getPages(Page<T> basePage,T t){ 
        int totalRow = findByFilter(t).size(); 
        basePage.setContent(getAllPageMap(null,t,(basePage.getPageSize()*basePage.getPage()))); 
        basePage.setTotalRow(totalRow); 
        basePage.setTotalPage((totalRow+basePage.getPageSize()-1)/basePage.getPageSize()); 
        return basePage; 
    } 
    /** 
    * 根据传入记录数查处所需要的信息 
    * @param cookie 
    * @param t 
    * @param pageSize 
    * @return 
    * @创建人 PengBo 
    * @创建时间 2013-7-10  上午9:23:46 
    */
    private List<T> getAllPageMap(PagedResultsCookie cookie,T t,Integer pageSize) { 
        PagedResultsDirContextProcessor  control = new PagedResultsDirContextProcessor (pageSize, cookie); 
        SearchControls searchControls = new SearchControls(); 
          searchControls.setSearchScope(SearchControls.SUBTREE_SCOPE); 
          List<T> mList = ldapTemplate.search(buildDn(t),  getFilter(t).encode(),searchControls, getContextMapper(t), control); 
          return mList; 
        } 
                                                                                                                                        
        /** 
        * 查找全部信息所需要的filter检索方法 
        * @param map 
        * @return 
        * @创建人 PengBo 
        * @创建时间 2013-7-7  下午6:59:38 
        */
        private AndFilter getObjectclass(T t){ 
            Map<String, String> map=t.getMap(); 
            AndFilter filter = new AndFilter(); 
            for(String mkey:map.keySet()){      //根据实体只获得他对应的objectclass的值 
                if ("objectclass".equals(mkey)) { 
                    filter.and(new EqualsFilter(mkey, (String) map.get(mkey))); 
                } 
            } 
        return filter; 
        } 
                                                                                                                                        
    /** 
    * 根据条件模糊查找的条件方法 
    * @param t 
    * @return 
    * @创建人 PengBo 
    * @创建时间 2013-7-7  下午7:00:10 
    */
      private AndFilter getFilter(T t) { 
            AndFilter filter = new AndFilter(); 
            Map<String, String> map=t.getMap(); 
            for(String mkey:map.keySet()){ 
                if ("objectclass".equals(mkey)) { 
                    filter.and(new EqualsFilter(mkey, (String) map.get(mkey))); 
                } 
                if(StringUtils.isNotBlank(map.get(mkey)) && !"objectclass".equals(mkey)) 
                filter.and(new WhitespaceWildcardsFilter(mkey, (String) map.get(mkey))); 
            } 
        return filter; 
        } 
      /** 
        * 根据条件精确查找的条件方法 
        * @param t 
        * @return 
        * @创建人 PengBo 
        * @创建时间 2013-7-8  下午3:10:43 
        */
      private AndFilter getEqualFilter(T t) { 
            AndFilter filter = new AndFilter(); 
            Map<String, String> map=t.getMap(); 
            for(String mkey:map.keySet()){ 
                if ("objectclass".equals(mkey)) { 
                    filter.and(new EqualsFilter(mkey, (String) map.get(mkey))); 
                } 
                if(StringUtils.isNotBlank(map.get(mkey)) && !"objectclass".equals(mkey)) 
                filter.and(new EqualsFilter(mkey, (String) map.get(mkey))); 
            } 
        return filter; 
        } 
        /** 
        * 构造查询实体UUID方法 
        * @param t 
        * @return 
        * @创建人 PengBo 
        * @创建时间 2013-7-7  下午7:00:49 
        */
      private Name buildDn(T t) { 
          String a = t.getDN(); 
              DistinguishedName dn = new DistinguishedName(a); 
                  if(StringUtils.isNotBlank(t.getUuid())){ 
                      dn.add("uid", t.getUuid()); 
                  } 
              return dn; 
          } 
                                                                                                                                          
      /** 
        * 构造查找组织的dn 
        * @param t 
        * @return 
        * @创建人 PengBo 
        * @创建时间 2013-7-16  上午9:45:57 
        */
      public String findDn(T t) { 
            Name dn= buildDn( t); 
              return dn.toString(); 
          } 
    /** 
    * 查询获得实体属性构造器 
    * @param t 
    * @return 
    * @创建人 PengBo 
    * @创建时间 2013-7-7  下午7:01:12 
    */
      private ContextMapper getContextMapper(final T t) { 
              return new ParameterizedContextMapper<T>() { 
                    @Override 
                    public T mapFromContext(Object ctx) { 
                        DirContextAdapter adapter = (DirContextAdapter) ctx; 
                        T newT=null; 
                        try { 
                            newT = (T) t.getClass().newInstance(); 
                        } catch (InstantiationException e) { 
                            e.printStackTrace(); 
                        } catch (IllegalAccessException e) { 
                            e.printStackTrace(); 
                        } 
                        Map<String, String> map= t.getMap(); 
                        Map<String, String> smap=new HashMap<String, String>(); 
                        for(String mkey:map.keySet()){ 
                            if (!"objectclass".equals(mkey)) { 
                                if(!"userPassword".equals(mkey)){ 
                                    if (StringUtils.isNotBlank(adapter.getStringAttribute(mkey))) { 
                                        smap.put(mkey, adapter.getStringAttribute(mkey)); 
                                    }else { 
                                        smap.put(mkey, null); 
                                    } 
                                } 
                            } 
                        } 
                        newT.setMap(smap); 
                        return newT; 
                    } 
              }; 
          } 
}
第二个封装一个baseModel；
import java.util.Map; 
import com.smarcloud.control.util.Constant; 
/** 
 * 实体基层 
 * @创建人 PengBo 
 * @创建时间 2013-7-7  下午7:04:09 
 */
public class BaseModel extends UUIDEntity { 
    private static final long serialVersionUID = -3809593908380530384L; 
    /** 映射实体与LDAP属性*/
    private Map<String, String> map; 
                                                                                                              
    /** 映射实体与LDAPDN*/
    protected String getDN() { 
        return Constant.BASE_DN; 
                                                                                                                  
    } 
    protected Map<String, String> getMap() { 
        return map; 
    } 
    protected void setMap(Map<String, String> map) { 
        this.map = map; 
    } 
                                                                                                              
}
剩下的就就是集成关系了  实体集成baseModel  dao集成baseDao
接下来再给出2个集成的实体和dao
import java.util.HashMap; 
import java.util.Map; 
import org.apache.commons.lang.StringUtils; 
import com.smarcloud.control.base.BaseModel; 
import com.smarcloud.control.model.status.Status; 
import com.smarcloud.control.model.status.DeviceType; 
import com.smarcloud.control.util.Constant; 
/** 
 * 设备对象 
 * @创建人 PengBo 
 * @创建时间 2013-7-2  上午10:17:06 
 */
public class DeviceLDAP extends BaseModel{ 
    private static final long serialVersionUID = 3398977021142608598L; 
    /**设备ID    guid*/
    private String guid; 
    /**设备面膜  userPassword*/
    private String passWord; 
    /**设备名称<deviceType>_<GUID>_<roomNumber>  cn*/
    private String deviceName; 
    /** 状态 (注销、临时、正式 )  status*/
    private Status deviceStatus; 
    /**设备类型 deviceType*/
    private DeviceType deviceType; 
    /**设备所在房间      roomNumber*/
    private String roomId; 
    /**设备所在学校      o*/
    private String schoolCode; 
                                                      
                                                      
    public String getGuid() { 
        return guid; 
    } 
    public void setGuid(String guid) { 
        this.guid = guid; 
    } 
    public String getPassWord() { 
        return passWord; 
    } 
    public void setPassWord(String passWord) { 
        this.passWord = passWord; 
    } 
    public String getDeviceName() { 
        return deviceName; 
    } 
    public void setDeviceName(String deviceName) { 
        this.deviceName = deviceName; 
    } 
    public Status getDeviceStatus() { 
        return deviceStatus; 
    } 
    public void setDeviceStatus(Status deviceStatus) { 
        this.deviceStatus = deviceStatus; 
    } 
    public DeviceType getDeviceType() { 
        return deviceType; 
    } 
    public void setDeviceType(DeviceType deviceType) { 
        this.deviceType = deviceType; 
    } 
    public String getRoomId() { 
        return roomId; 
    } 
    public void setRoomId(String roomId) { 
        this.roomId = roomId; 
    } 
                                                      
    public String getSchoolCode() { 
        return schoolCode; 
    } 
    public void setSchoolCode(String schoolCode) { 
        this.schoolCode = schoolCode; 
    } 
    @Override 
    public Map<String, String> getMap() { 
        Map<String, String> map = new HashMap<String, String>(); 
        map.put("objectclass","smartDevice"); 
        map.put("uid", this.getUuid()); 
        map.put("guid", this.guid); 
        String newCn = null; 
        if(StringUtils.isNotBlank(this.guid)) 
        newCn =this.deviceType==null?null:this.deviceType.toString()+"_"+this.guid+"_"+this.roomId; 
        map.put("cn", newCn); 
        map.put("userPassword", this.passWord); 
        map.put("status", this.deviceStatus==null?null:this.deviceStatus.toString()); 
        map.put("deviceType", this.deviceType==null?null:this.deviceType.toString()); 
        map.put("roomNumber", this.roomId); 
        map.put("o", this.schoolCode); 
        return map; 
    } 
                                                      
    @Override 
    public void setMap(Map<String, String> map) { 
        for(String mkey:map.keySet()){ 
        switch(mkey) { 
            case "uid": 
                this.setUuid(map.get(mkey)); 
                break; 
            case "cn": 
                this.setDeviceName(map.get(mkey)); 
                break; 
            case "guid": 
                this.setGuid(map.get(mkey)); 
                break; 
            case "userPassword": 
                this.setPassWord(map.get(mkey)); 
                break; 
            case "roomNumber": 
                this.setRoomId(map.get(mkey)); 
                break; 
            case "o": 
                this.setSchoolCode(map.get(mkey)); 
                break; 
            case "status": 
                if (StringUtils.isNotBlank(map.get(mkey))) { 
                    this.setDeviceStatus(Status.valueOf(map.get(mkey))); 
                } 
                break; 
            case "deviceType": 
                if (StringUtils.isNotBlank(map.get(mkey))) { 
                    this.setDeviceType(DeviceType.valueOf(map.get(mkey))); 
                } 
                break; 
            } 
        } 
    } 
                                                      
    @Override 
    protected String getDN() { 
                //自定义的组织dn 
        return Constant.DEVICE_BASE_DN; 
    }
使用setmap 和getmap 来映射实体与ldap属性 ；
import org.springframework.stereotype.Repository; 
import com.smarcloud.control.base.BaseDAO; 
import com.smarcloud.control.model.DeviceLDAP; 
/** 
 * 设备Dao实现 
 * @创建人 PengBo 
 * @创建时间 2013-7-2  下午1:54:51 
 */
@Repository 
public class DeviceLDAPDao extends BaseDAO<DeviceLDAP> { 
}
这个DAO空的就可以了 
接下来的使用 就跟大家使用JPA一样一样滴  把你的实体写好 放进去就可以了  不过你在新建时是不返回任何东西的 所以你可以自己去多写一个方法去获得创建好的实体。