`
yang_min
  • 浏览: 341669 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

封装JNDI操作LDAP服务器的工具类(3)

log4jDAO 
阅读更多 
package com.common.ldapconnection; 

import java.util.List; 
import java.util.Vector; 

/** 
 * 
 * <p>功能描述：ldap的处理类，提供了各种操作ldap的方法。</p> 
 * @author liaowufeng 
 * @version 1.0 
 */ 
public class LdapOperUtils { 

    // 调用log4j的日志，用于输出 
    private static Logger log = Logger.getLogger(LdapOperUtils.class.getName()); 

    /** 
     * 根据连接Env信息，取得Ldap DirContext 
     * @param env 连接Env的连接信息 
     * @return Ldap连接的DirContext 
     * @throws BaseException 
     */ 
    private static DirContext getLdapDirContext(Env env) throws BaseException { 
        // 参数为空 
        if (env == null) { 
            String[] args = { 
                            "env"}; 
            // 打印错误日志 
            StringBuffer msglog = new StringBuffer( 
                    "empty invoke parameter env NULL "); 
            log.error(msglog.toString()); 
            throw new BaseException("error.common.parameter.empty", args); 

        } 
        // 定义DirContext 
        DirContext dirContext = null; 
        // 从Ldap连接工厂中，取得Ldap连接 
        dirContext = LdapConnectionFactory.getDirContext(env); 
        return dirContext; 
    } 

    /** 
     * 根据在ldappool.properties文件定义的Ldap DirContext池名，取得Ldap DirContext 
     * @param dirContextName Ldap DirContext池名 
     * @return 返回操作Ldap 的 DirContext 
     * @throws BaseException 
     */ 
     private static DirContext getLdapDirContext(String dirContextName,Env env) 
      throws BaseException { 
            // 参数为空 
            if (StringUtils.isEmpty(dirContextName)) { 
                String[] args = { 
                                "dirContextName"}; 
                // 打印错误日志 
                StringBuffer msglog = new StringBuffer( 
                        "empty invoke parameter dirContextName NULL "); 
                log.error(msglog.toString()); 
                throw new BaseException("error.common.parameter.empty", args); 

            } 
            // 定义DirContext 
            DirContext dirContext = null; 
            // 从Ldap连接工厂中，取得Ldap连接 
            dirContext = LdapConnectionFactory.getDirContext(dirContextName,env); 

            return dirContext; 

        } 

        /** 
         * 关闭LDAP连接 
         * @param dirContext DirContext 
         * @throws BaseException 
         */ 
        public static void closeEnvLdapDirContext(DirContext dirContext) 
        throws BaseException { 
            // 关闭LDAP连接 
            closeLdapDirContext(dirContext); 
    } 

    /** 
    * 关闭Ldap 的DirContext 
    * @param dirContext 连接Ldap的DirContext 
    * @throws BaseException 
    */ 
   private static void closeLdapDirContext(DirContext dirContext) throws 
           BaseException { 
       // 如果参数为NULL 
       if (dirContext == null) { 
           String[] args = { 
                           "dirContext"}; 
           // 打印错误日志 
           StringBuffer msglog = new StringBuffer( 
                   "empty invoke parameter conn NULL "); 
           log.error(msglog.toString()); 
           throw new BaseException("error.common.parameter.empty", args); 
       } 

       try { 
           // 关闭 
           dirContext.close(); 
       } catch (NamingException ex) { 
           // 关闭不成功，再次关闭 
           if (log.isDebugEnabled()) { 
               log.debug("Not close DirContext " + ex); 
           } 
           // 记录日志 
           log.error("Not close DirContext " + ex); 
           ex.printStackTrace(); 
           try { 
               //再次关闭 
               dirContext.close(); 
           } catch (NamingException ex1) { 
               // 再次关闭失败 
               if (log.isDebugEnabled()) { 
                   log.debug("Not again close DirContext " + ex); 
               } 
               // 记录日志 
               log.error("Not again close DirContext " + ex); 
               ex.printStackTrace(); 
               // 抛出异常 
               throw new BaseException("error.common.dao.ldap.closedircontext", null); 
           } 
       } 
   } 


    /** 
     * 构造函数私有，防止实例化 
     */ 
    private LdapOperUtils() { 
    } 

    /** 
     * 在当前的Context 添加一个子Context 
     * @param context 连接DirContext 
     * @param cn 创建的子Context 
     * @param attMap Context 的属性，Map 包含 List ,key = 属性名, 
     * 当属性值为多值时，为list,为单值时，为String 
     * @throws NamingException 
     * @throws BaseException 
     */ 
    public static void addContext(DirContext context, String cn, Map attMap) throws 
            NamingException, BaseException { 

        // 参数为空 
        if (context == null) { 
            String[] args = { 
                            "context"}; 
            // 打印错误日志 
            StringBuffer msglog = new StringBuffer( 
                    "empty invoke parameter context NULL "); 
            log.error(msglog.toString()); 
            throw new BaseException("error.common.parameter.empty", args); 
        } 

        // 参数为空 
        if (StringUtils.isEmpty(cn)) { 
            String[] args = { 
                            "cn"}; 
            // 打印错误日志 
            StringBuffer msglog = new StringBuffer( 
                    "empty invoke parameter cn NULL "); 
            log.error(msglog.toString()); 
            throw new BaseException("error.common.parameter.empty", args); 
        } 

        // 参数为空 
        if (attMap == null) { 
            String[] args = { 
                            "attMap"}; 
            // 打印错误日志 
            StringBuffer msglog = new StringBuffer( 
                    "empty invoke parameter attMap NULL "); 
            log.error(msglog.toString()); 
            throw new BaseException("error.common.parameter.empty", args); 
        } 

        // 为空，则退出 
        if (attMap.isEmpty()) { 
            return; 
        } 

        // 取所有的属性key 
        Set keySet = attMap.keySet(); 
        Iterator keyIterator = keySet.iterator(); 
        Attributes attrs = new BasicAttributes(); 
        // 迭代所有的属性key 
        while (keyIterator.hasNext()) { 

            // 取下一个属性 
            String key = (String) keyIterator.next(); 
            Attribute att = null; 
            Object valueObj = attMap.get(key); 
            // 判断属性类型 
            if (valueObj instanceof String) { 
                // 为字符串，为单值属性 
                att = new BasicAttribute(key, valueObj); 
            } else if (valueObj instanceof List) { 
                // 为List ,为多值属性 
                att = new BasicAttribute(key); 
                List valueList = (List) valueObj; 
                // 加入多值属性 
                for (int i = 0; i < valueList.size(); i++) { 
                    att.add(valueList.get(i)); 
                } 
            } else { 
                // 其它类型，都加入，如字节类型 （密码） 
                att = new BasicAttribute(key,valueObj); 
            } 
            // 加入 
            attrs.put(att); 
        } 
        // 创建子Context 
        context.createSubcontext(cn, attrs); 
        // context.close(); 
    } 

    /** 
     * 在当前的Context 删除一个子Context 
     * @param context 连接的DirContext 
     * @param cn   要删除的Context的名称 
     * @throws NamingException 
     * @throws BaseException 
     */ 
    public static void deleteContext(DirContext context, String cn) throws 
            NamingException, BaseException { 

        // 参数为空 
        if (context == null) { 
            String[] args = { 
                            "context"}; 
            // 打印错误日志 
            StringBuffer msglog = new StringBuffer( 
                    "empty invoke parameter context NULL "); 
            log.error(msglog.toString()); 
            throw new BaseException("error.common.parameter.empty", args); 
        } 

        // 参数为空 
        if (StringUtils.isEmpty(cn)) { 
            String[] args = { 
                            "cn"}; 
            // 打印错误日志 
            StringBuffer msglog = new StringBuffer( 
                    "empty invoke parameter cn NULL "); 
            log.error(msglog.toString()); 
            throw new BaseException("error.common.parameter.empty", args); 
        } 

        // 删除一个子Context 
        context.destroySubcontext(cn); 
        //   context.close(); 

    } 

    /** 
     * 根据当前的连接DirContext 重命名Context 
     * @param context 连接后的DirContext 
     * @param cn    原Context的名称 
     * @param newCn 新的Context名称 
     * @throws NamingException 
     * @throws BaseException 
     */ 
    public static void reNameContext(DirContext context, String cn, 
                                     String newCn) throws NamingException, 
            BaseException { 

        // 参数为空 
        if (context == null) { 
            String[] args = { 
                            "context"}; 
            // 打印错误日志 
            StringBuffer msglog = new StringBuffer( 
                    "empty invoke parameter context NULL "); 
            log.error(msglog.toString()); 
            throw new BaseException("error.common.parameter.empty", args); 
        } 

        // 参数为空 
        if (StringUtils.isEmpty(cn)) { 
            String[] args = { 
                            "cn"}; 
            // 打印错误日志 
            StringBuffer msglog = new StringBuffer( 
                    "empty invoke parameter cn NULL "); 
            log.error(msglog.toString()); 
            throw new BaseException("error.common.parameter.empty", args); 
        } 

        // 参数为空 
        if (context == null) { 
            String[] args = { 
                            "context"}; 
            // 打印错误日志 
            StringBuffer msglog = new StringBuffer( 
                    "empty invoke parameter context NULL "); 
            log.error(msglog.toString()); 
            throw new BaseException("error.common.parameter.empty", args); 
        } 

        // 参数为空 
        if (StringUtils.isEmpty(newCn)) { 
            String[] args = { 
                            "newCn"}; 
            // 打印错误日志 
            StringBuffer msglog = new StringBuffer( 
                    "empty invoke parameter newCn NULL "); 
            log.error(msglog.toString()); 
            throw new BaseException("error.common.parameter.empty", args); 
        } 
        context.rename(cn, newCn); 
        // context.close(); 
    } 

    /** 
     * 在当前连接的DirContext 指定的Context 添加一个 / 多个属性 
     * @param context 连接的DirContext 
     * @param cn     指定的Context 
     * @param attMap Map 包含 List ,key为属性名称， 
     * value 属性值, 当为多值时，存为List,当为单值时，为String类型 
     * @throws BaseException 
     * @throws NamingException 
     */ 
    public static void addAttributes(DirContext context, String cn, Map attMap) throws 
            BaseException, NamingException { 

        // 参数为空 
        if (context == null) { 
            String[] args = { 
                            "context"}; 
            // 打印错误日志 
            StringBuffer msglog = new StringBuffer( 
                    "empty invoke parameter context NULL "); 
            log.error(msglog.toString()); 
            throw new BaseException("error.common.parameter.empty", args); 
        } 

        // 参数为空 
        if (attMap == null) { 
            String[] args = { 
                            "attMap"}; 
            // 打印错误日志 
            StringBuffer msglog = new StringBuffer( 
                    "empty invoke parameter attMap NULL "); 
            log.error(msglog.toString()); 
            throw new BaseException("error.common.parameter.empty", args); 
        } 
        // 参数为空 
        if (StringUtils.isEmpty(cn)) { 
            String[] args = { 
                            "cn"}; 
            // 打印错误日志 
            StringBuffer msglog = new StringBuffer( 
                    "empty invoke parameter cn NULL "); 
            log.error(msglog.toString()); 
            throw new BaseException("error.common.parameter.empty", args); 
        } 

        // 为空，退出 
        if (attMap.isEmpty()) { 
            return; 
        } 

        // 取所有的属性key 
        Set keySet = attMap.keySet(); 
        Iterator keyIterator = keySet.iterator(); 
        Attributes attrs = new BasicAttributes(); 
        // 迭代所有的属性key 
        while (keyIterator.hasNext()) { 

            // 取下一个属性 
            String key = (String) keyIterator.next(); 
            Attribute att = null; 
            Object valueObj = attMap.get(key); 
            // 判断属性类型 
            if (valueObj instanceof String) { 
                // 为字符串，为单值属性 
                att = new BasicAttribute(key, valueObj); 
            } else if (valueObj instanceof List) { 
                // 为List ,为多值属性 
                att = new BasicAttribute(key); 
                List valueList = (List) valueObj; 
                // 加入多值属性 
                for (int i = 0; i < valueList.size(); i++) { 
                    att.add(valueList.get(i)); 
                } 
            } 
            // 加入 
            attrs.put(att); 
        } 

        context.modifyAttributes(cn, DirContext.ADD_ATTRIBUTE, attrs); 
        // context.close(); 
    } 

    /** 
     * 在当前的连接DirContext 删除 指定Context 下的 一个 / 多个属性 
     * @param context 连接后的DirContext 
     * @param cn 指定Context的名称 
     * @param attList 包含要删除的属性的名称,为List类型 
     * @throws BaseException 
     * @throws NamingException 
     */ 
    public static void deleteAttributes(DirContext context, String cn, 
                                        List attList) throws BaseException, 
            NamingException { 
        // 参数为空 
        if (context == null) { 
            String[] args = { 
                            "context"}; 
            // 打印错误日志 
            StringBuffer msglog = new StringBuffer( 
                    "empty invoke parameter context NULL "); 
            log.error(msglog.toString()); 
            throw new BaseException("error.common.parameter.empty", args); 
        } 

        // 参数为空 
        if (attList == null) { 
            String[] args = { 
                            "attList"}; 
            // 打印错误日志 
            StringBuffer msglog = new StringBuffer( 
                    "empty invoke parameter attList NULL "); 
            log.error(msglog.toString()); 
            throw new BaseException("error.common.parameter.empty", args); 
        } 
        // 参数为空 
        if (StringUtils.isEmpty(cn)) { 
            String[] args = { 
                            "cn"}; 
            // 打印错误日志 
            StringBuffer msglog = new StringBuffer( 
                    "empty invoke parameter cn NULL "); 
            log.error(msglog.toString()); 
            throw new BaseException("error.common.parameter.empty", args); 
        } 

        // 为空，退出 
        if (attList.isEmpty()) { 
            return; 
        } 

        Attributes attrs = new BasicAttributes(); 

        for (int i = 0; i < attList.size(); i++) { 
            Attribute att = null; 
            att = new BasicAttribute((String) attList.get(i)); 
            // 加入 
            attrs.put(att); 
        } 
        context.modifyAttributes(cn, DirContext.REMOVE_ATTRIBUTE, attrs); 
        // context.close(); 
    } 
   }
分享到：
| 封装JNDI操作LDAP服务器的工具类(2)
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    封装JNDI的LDAP服务器的工具类

    本篇内容将深入探讨如何封装JNDI操作，以便更方便地与LDAP服务器进行交互。 首先，我们要理解封装的目标：简化 LDAP 操作，使得用户只需熟悉 List 和 Map 数据结构，而无需直接处理复杂的 JNDI API。为此，我们创建...

    封装jndi操作ldap服务器的工具类

    【封装JNDI操作LDAP】 在Java开发中，直接使用JNDI API操作LDAP可能会涉及很多底层细节，包括连接设置、安全配置等，这增加了代码的复杂性和出错的可能性。因此，为了简化这一过程，通常会创建一个工具类来封装这些...

    使用Java操作LDAP案例

    在IT行业中，LDAP（Lightweight Directory Access Protocol）是一种用于访问和管理分布式目录服务的标准协议，常用于企业身份验证...在实际项目中，为了提高代码的可维护性和安全性，通常会封装成专门的服务或工具类。

    LDAP以及JAVA方法操作详解.doc

    1. **连接LDAP服务器**：使用`InitialDirContext`类建立与LDAP服务器的连接。首先，创建一个环境属性对象，配置服务器地址、端口、用户名和密码，然后通过`new InitialDirContext(environment)`初始化上下文。 2. *...

    java操作Ldap，支持建立开启状态的用户，支持修改密码，放入eclipse测试即用

    在Java中，我们通常使用JNDI（Java Naming and Directory Interface）来与LDAP服务器交互。JNDI是一个API，它为多种命名和目录服务提供了统一的接口，包括LDAP。在本项目中，可能包含了一个或多个Java类，这些类封装...

    JAVA LDAP

    为了简化这些操作，你可以创建一个名为`LdapUtil`的工具类，封装连接、查询、添加、修改和删除的方法。这样可以使代码更易于理解和维护。 总结，Java LDAP操作涉及连接LDAP服务器、执行查询、添加、修改和删除条目...

    LDAP学习资料

    - "ldapUtil"可能是这个压缩包中包含的Java工具类，它封装了对LDAP的各种操作，便于开发人员调用。 - 这个工具类可能包含连接LDAP服务器的方法，执行查询、增加、删除和修改操作的函数，以及异常处理逻辑。 学习...

    JNDI-Injection-Exploit-1.0-SNAPSHOT-all.zip

    Java Naming and Directory Interface (JNDI) 是Java平台中用于访问命名和目录服务的API，它允许程序查找和操作各种命名和目录服务，如 Lightweight Directory Access Protocol (LDAP)、Java Database Connectivity ...

    spring ldap 1.3.0下载

    3. **强大的查询支持**：通过LdapTemplate类，开发者可以使用XPath或LDIF（LDAP Data Interchange Format）进行复杂查询，同时提供了安全性和性能优化。 4. **事务管理**：Spring LDAP 支持LDAP操作的事务管理，使得...

    com.sun.jndi.providerutil.jar

    `providerutil`组件则是这些提供者的辅助工具，它包含了一些通用的工具类和方法，帮助实现JNDI服务提供者的基本功能，比如上下文管理、属性处理等。 二、`com.sun.jndi.providerutil.jar`的功能 1. **提供者注册**...

    Ldap增删改查

    在实际项目中，这些通常会被封装到配置类或工具类中，以提高代码的可重用性和安全性。 在压缩包文件"LdapCRUDTest"中，可能包含了实现上述功能的测试代码。这些代码会展示如何在Java中使用JNDI进行具体的LDAP操作，...

    spring-ldap-1.3.0

    它封装了JNDI（Java Naming and Directory Interface）API，使得开发者能够以更简洁的方式进行目录操作。 2. **ContextSource**：用于配置与 LDAP 服务器的连接。它可以设置URL、基础DN（Distinguished Name）、...

    jndi 反射 耦合

    更重要的是，反射操作往往破坏了封装性，可能导致安全风险，因此在使用反射时需要特别小心，遵循最小权限原则。 最后，耦合性是衡量软件模块之间相互依赖程度的一个度量。低耦合意味着模块之间的关系简单，易于理解...

    Java-J2EE Job Interview

    - 类与对象：类的概念、对象的创建过程、封装、继承、多态的基本原理。 - 构造器：构造器的作用、构造器重载、构造器链调用。 - 继承：继承的概念、super关键字的使用、继承中的构造器调用规则。 - 多态：多态性...

    基于java网上书城

    1. **Java基础**：Java是该项目的基础语言，学习者需要掌握Java面向对象编程的基本概念，包括类、对象、封装、继承、多态等。此外，对异常处理、输入输出流、集合框架（如ArrayList、HashMap）的理解也是必要的。 2...

    Java/J2EE Job Interview Companion

    ### Java/J2EE核心概念与关键领域 ... - **并发工具类**：熟悉ConcurrentHashMap等并发容器的使用方法。 通过以上知识点的学习，读者可以全面掌握Java/J2EE的核心概念和技术细节，为即将到来的技术面试做好充分准备。

    JDirectory-开源

    总的来说，`JDirectory`是Java开发者处理LDAP目录服务的强大工具，它通过简化JNDI的使用，使得开发人员能更专注于应用逻辑，提高了开发效率和代码质量。了解并掌握`JDirectory`，对于从事相关领域开发的人员来说，...

    Core Java, Volume II--Advanced Features (9th Edition).pdf

    5. JNDI/LDAP目录集成：本书还会介绍如何利用Java命名和目录接口（JNDI）以及轻量级目录访问协议（LDAP）进行企业级服务的发现和集成。 6. 国际化：随着现代软件越来越注重全球市场，本节将说明如何利用Java的国际...

    JAVA J2EE JOB INTERVIEW COMPANION PREVIEW

    这部分内容涵盖了变量、数据类型、运算符、控制结构、类与对象、封装、继承、多态等基本概念。 #### Swing Swing是Java中用于构建图形用户界面（GUI）的一套组件库。了解Swing可以帮助开发者创建美观且功能丰富的...

    JAVA上百实例源码以及开源项目源代码

    Java二进制IO类与文件复制操作实例 16个目标文件 内容索引:Java源码,初学实例,二进制,文件复制 Java二进制IO类与文件复制操作实例，好像是一本书的例子，源代码有的是独立运行的，与同目录下的其它代码文件互不联系...

Magicbox
Global site tag (gtag.js) - Google Analytics