java 操作AD域代码（跳过证书版）

最新推荐文章于 2024-04-28 17:17:04 发布
最新推荐文章于 2024-04-28 17:17:04 发布
阅读量850 收藏
点赞数
分类专栏： java ad域 文章标签： java jvm servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012690202/article/details/127266216
版权

1、AD域操作类 

@Slf4j
public class ADOperator {
    private final DomainConfigModel adConfig;
    private static final int ADS_UF_ACCOUNTDISABLE = 0x00000002;//账号禁用位
    private static final int ADS_UF_NORMAL_ACCOUNT = 0x0200;//普通账号

    /**
     * 构造函数
     *
     * @param adConfig AD域配置信息
     */
    public ADOperator(DomainConfigModel adConfig) {
        this.adConfig = adConfig;
    }

    /**
     * 构造函数
     *
     * @param path       AD域路径
     * @param adminUser  AD域用户名
     * @param adminPwd   AD域密码
     * @param suffixPath AD域根路径
     */
    public ADOperator(String path, String adminUser, String adminPwd, String suffixPath) {
        this.adConfig = new DomainConfigModel(adminUser, adminPwd, path, suffixPath);
    }

    /**
     * 添加用户
     *
     * @param userInfo 域用户信息
     * @return
     */
    public String addUser(DomainUser userInfo) {
        StringBuilder message = new StringBuilder();
        if (!createOrg(userInfo.getDepartment()))
            return message.append("组织创建失败").toString();
        message.append("组织创建成功;");
        if (!createGroup(userInfo.getDepartment(), userInfo.getDepartment()))
            return message.append("用户组创建失败").toString();
        message.append("用户组创建成功;");
        try {
            DirContext ldapContext = getLdapContext();
            if (!existsUser(userInfo.getAdUserName())) {
                BasicAttributes attrs = new BasicAttributes(true);
                attrs.put("objectClass", "user");
                attrs.put("displayName", userInfo.getName());// 显示名称
                attrs.put("sAMAccountName", userInfo.getAdUserName());
                attrs.put("mail", userInfo.getEmail());
                attrs.put("telephoneNumber", userInfo.getMobile());
                ldapContext.createSubcontext("CN=" + userInfo.getUserName() + "," + getOrgADPath(userInfo.getDepartment()), attrs);
            }
            message.append("用户账号创建成功;");

            if (disabledOrOnUser(userInfo.getAdUserName(), false))
                message.append("用户账号启用成功;");
            else
                message.append("用户账号启用失败;");

            SearchResult result = findObject(adConfig.getSuffixPath(), "person", userInfo.getAdUserName());
            assert result != null;
            //设置密码
            if (StringUtils.isNotEmpty(userInfo.getPwd())) {
                ModificationItem[] mods1 = new ModificationItem[1];
                mods1[0] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE,
                        new BasicAttribute("unicodePwd", createUnicodePassword(userInfo.getPwd())));
                ldapContext.modifyAttributes(result.getName() + "," + adConfig.getSuffixPath(), mods1);
            }
            message.append("用户账号密码设置成功;");

            //添加用户至用户组
            ModificationItem[] mods2 = new ModificationItem[1];
            mods2[0] = new ModificationItem(DirContext.ADD_ATTRIBUTE, new BasicAttribute("member", result.getName() + "," + adConfig.getSuffixPath()));
            ldapContext.modifyAttributes("CN=" + userInfo.getDepartment() + "," + getOrgADPath(userInfo.getDepartment()), mods2);
            message.append("添加用户至组成功;正常");
        } catch (NamingException e) {
            log.error("创建用户过程中出错,用户信息为{},错误为{}", JSON.toJSONString(userInfo), e.getMessage());
            message.append("失败");
        }
        return message.toString();
    }

    /** 更新AD用户信息(只能更新组织、手机号、邮箱)
     * @param userInfo 需要更新的用户信息
     * @return
     */
    public boolean updateUser(DomainUser userInfo) {
        if (!createOrg(userInfo.getDepartment()))
            throw new SyncDataException("创建组织失败");

        if (!createGroup(userInfo.getDepartment(), userInfo.getDepartment()))
            throw new SyncDataException("创建用户组失败");
        SearchResult result = findObject(adConfig.getSuffixPath(), "person", userInfo.getAdUserName());
        assert result != null;
        DirContext ldapContext = null;
        try {
            ldapContext = getLdapContext();
            ModificationItem[] mods = new ModificationItem[2];
            mods[0] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE, new BasicAttribute("telephoneNumber", userInfo.getMobile()));
            mods[1] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE, new BasicAttribute("mail", userInfo.getEmail()));
            ldapContext.modifyAttributes(result.getName() + "," + adConfig.getSuffixPath(), mods);

            //添加用户至用户组
            ModificationItem[] mods1 = new ModificationItem[1];
            mods1[0] = new ModificationItem(DirContext.ADD_ATTRIBUTE, new BasicAttribute("member", result.getName() + "," + adConfig.getSuffixPath()));
            ldapContext.modifyAttributes("CN=" + userInfo.getDepartment() + "," + getOrgADPath(userInfo.getDepartment()), mods1);

            ldapContext.rename(result.getName() + "," + adConfig.getSuffixPath(), "CN=" + userInfo.getUserName() + "," + getOrgADPath(userInfo.getDepartment()));
            return true;
        } catch (NamingException e) {
            log.error("更新用户过程中出错,用户信息为{},错误为{}", JSON.toJSONString(userInfo), e.getMessage());
            return false;
        }
    }

    /**
     * 禁用/启用账号
     *
     * @param account  用户ad账号
     * @param disabled 是否禁用
     * @return
     */
    public boolean disabledOrOnUser(String account, boolean disabled) {
        if (!existsUser(account))
            return false;
        SearchResult result = findObject(adConfig.getSuffixPath(), "person", account);//根据账号查找到用户信息
        try {
            assert result != null;
            Attributes attr = result.getAttributes();
            Attribute controlAttr = attr.get("userAccountControl");//获取“账号选项”属性
            ModificationItem[] mods = new ModificationItem[1];
            if (null != controlAttr) {//若存在该属性,则替换,否则新增
                int newControlVal;
                if (disabled)//若禁用账号,则设置禁用标志位,否则取消禁用标志位
                    newControlVal = Integer.parseInt(controlAttr.get().toString()) | ADS_UF_ACCOUNTDISABLE;
                else
                    newControlVal = Integer.parseInt(controlAttr.get().toString()) & ~ADS_UF_ACCOUNTDISABLE;
                mods[0] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE, new BasicAttribute("userAccountControl", Integer.toString(newControlVal)));
            } else {
                if (disabled)//若禁用账号,则设置禁用标志位,否则不操作
                    mods[0] = new ModificationItem(DirContext.ADD_ATTRIBUTE, new BasicAttribute("userAccountControl", Integer.toString(ADS_UF_ACCOUNTDISABLE)));
            }

            getLdapContext().modifyAttributes(result.getName() + "," + adConfig.getSuffixPath(), mods);
            return true;
        } catch (NamingException e) {
            log.error("禁用/启用用户过程中出错,用户账号为{},错误为{}", account, e.getMessage());
            return false;
        }
    }

    /**
     * 删除用户
     *
     * @param account 用户ad账号
     * @return
     */
    public boolean deleteUser(String account) {
        if (!existsUser(account))
            return true;
        SearchResult result = findObject(adConfig.getSuffixPath(), "person", account);
        try {
            assert result != null;
            getLdapContext().destroySubcontext(result.getName());
            return true;
        } catch (NamingException e) {
            log.error("删除用户过程中出错,用户账号为{},错误为{}", account, e.getMessage());
            return false;
        }
    }

    /**
     * 判断ad账号是否在AD域内
     *
     * @param account AD账号
     * @return
     */
    public boolean existsUser(String account) {
        SearchResult result = findObject(adConfig.getSuffixPath(), "person", account);
        return null != result;
    }

    /**
     * 创建组织
     *
     * @param orgFullPath 组织全路径（父子路径间以-分隔）
     * @return
     */
    public boolean createOrg(String orgFullPath) {
        String parentOrgPath = "";
        String org = "";
        if (orgFullPath.indexOf('-') > -1) {
            int lastIndexOf = orgFullPath.lastIndexOf('-');
            parentOrgPath = orgFullPath.substring(0, lastIndexOf);
            org = orgFullPath.substring(lastIndexOf + 1);
        } else
            org = orgFullPath;
        return createOrg(parentOrgPath, org);
    }

    /**
     * 创建组织
     *
     * @param parentOrgPath 父组织全路径（父子路径间以-分隔）,为空则表示父组织为根路径
     * @param org           当前组织
     * @return
     */
    public boolean createOrg(String parentOrgPath, String org) {
        if (existsOrg(parentOrgPath, org))
            return true;
        if (StringUtils.isNotEmpty(parentOrgPath)) {
            String parent_parentOrgPath = "";
            String parentOrg = "";
            if (parentOrgPath.indexOf('-') > -1) {
                int lastIndexOf = parentOrgPath.lastIndexOf('-');
                parent_parentOrgPath = parentOrgPath.substring(0, lastIndexOf);
                parentOrg = parentOrgPath.substring(lastIndexOf + 1);
            } else
                parentOrg = parentOrgPath;
            if (existsOrg(parent_parentOrgPath, parentOrg) || createOrg(parent_parentOrgPath, parentOrg)) {
                try {
                    DirContext ldapContext = getLdapContext();
                    Attributes attr = new BasicAttributes(true);
                    attr.put("objectClass", "organizationalUnit");
                    ldapContext.createSubcontext("OU=" + org + "," + getOrgADPath(parentOrgPath), attr);
                    return true;
                } catch (NamingException e) {
                    log.error("创建组织过程中出错,父组织信息为{},当前组织信息为{},错误信息为{}", parentOrgPath, org, e.getMessage());
                    return false;
                }
            } else
                return false;
        } else {
            if (existsOrg("", parentOrgPath))
                return true;
            else {
                return createOrg("", parentOrgPath);
            }
        }
    }

    /**
     * 判断父组织中是否存在该组织
     *
     * @param parentOrg 父组织全路径（父子路径间以-分隔）,为空则表示父组织为根路径
     * @param org       当前组织
     * @return
     */
    public boolean existsOrg(String parentOrg, String org) {
        SearchResult result = findObject(getOrgADPath(parentOrg), "org", org);
        return null != result;
    }

    /**
     * 创建用户组
     *
     * @param orgPath   用户组所在组织全路径
     * @param groupName 组名
     * @return
     */
    public boolean createGroup(String orgPath, String groupName) {
        if (existsGroup(orgPath, groupName))
            return true;
        try {
            DirContext ldapContext = getLdapContext();
            Attributes attr = new BasicAttributes(true);
            attr.put("objectClass", "group");
            ldapContext.createSubcontext("CN=" + groupName + "," + getOrgADPath(orgPath), attr);
            return true;
        } catch (NamingException e) {
            log.error("创建用户组过程中出错,组织路径为{},用户组名为{},错误为{}", orgPath, groupName, e.getMessage());
            return false;
        }
    }

    /**
     * 判断组织中是否存在该组
     *
     * @param orgPath 组织全路径（父子路径间以-分隔）,为空则表示组织路径为根路径
     * @param group   组名
     * @return
     */
    public boolean existsGroup(String orgPath, String group) {
        SearchResult result = findObject(getOrgADPath(orgPath), "group", group);
        return null != result;
    }

    /**
     * 密码加密
     *
     * @param password 密码
     * @return
     */
    private byte[] createUnicodePassword(String password) {
        String quotedPassword = "\"" + password + "\"";
        return quotedPassword.getBytes(StandardCharsets.UTF_16LE);
    }

    /**
     * 根据组织路径生成AD组织路径
     *
     * @param orgPath 组织全路径（父子路径间以-分隔）,为空则表示组织路径为根路径
     * @return
     */
    private String getOrgADPath(String orgPath) {
        StringBuilder sb = new StringBuilder();
        if (StringUtils.isNotEmpty(orgPath)) {
            if (orgPath.indexOf('-') < 0) {
                sb.append("OU=").append(orgPath).append(",");
            } else {
                String[] split = orgPath.split("-");
                for (int i = split.length - 1; i >= 0; i--) {
                    if (StringUtils.isNotEmpty(split[i]))
                        sb.append("OU=").append(split[i]).append(",");
                }
            }
        }
        sb.append(adConfig.getSuffixPath());
        return sb.toString();
    }

    /**
     * 根据分类和用户名查找AD域下的项
     *
     * @param searchBase 查找节点
     * @param category   分类(person、group、org)
     * @param name       用户名
     * @return
     */
    private SearchResult findObject(String searchBase, String category, String name) {
        SearchControls controls = new SearchControls();
        controls.setSearchScope(SearchControls.SUBTREE_SCOPE);
        String filter = "";
        if (category.equals("person"))
            filter = String.format("(&(objectCategory=%s)(sAMAccountName=%s))", category, name);
        else if (category.equals("group"))
            filter = String.format("(&(objectCategory=%s)(cn=%s))", category, name);
        else if (category.equals("org"))
            filter = String.format("(&(objectCategory=organizationalUnit)(ou=%s))", name);
        try {
            DirContext ldapContext = getLdapContext();
            NamingEnumeration<SearchResult> search = ldapContext.search(searchBase, filter, controls);
            if (search.hasMoreElements())
                return search.next();
        } catch (NamingException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取ldap操作上下文
     *
     * @return
     * @throws NamingException
     */
    private DirContext getLdapContext() throws NamingException {
        //解决No subject alternative DNS name xxxxx的错误
        Security.setProperty("jdk.tls.disabledAlgorithms", "");
        System.setProperty("com.sun.jndi.ldap.object.disableEndpointIdentification", "true");
        Properties prop = new Properties();
        prop.setProperty(Context.SECURITY_PROTOCOL, "ssl");
        prop.setProperty(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
        prop.setProperty(Context.SECURITY_AUTHENTICATION, "simple");
        prop.setProperty(Context.SECURITY_PRINCIPAL, adConfig.getAdminUser());
        prop.setProperty(Context.SECURITY_CREDENTIALS, adConfig.getAdminPwd());
        prop.setProperty(Context.PROVIDER_URL, adConfig.getPath());
        prop.setProperty("java.naming.ldap.factory.socket", "com.simon.common.utils.AD.DummySSLSocketFactory");//注意，此处的com.simon.common.utils.AD.DummySSLSocketFactory指的是你本地的DummySSLSocketFactory类所在的路径
        return new InitialLdapContext(prop, null);
    }
}

2、跳过证书的配置类

public class DummySSLSocketFactory extends SSLSocketFactory {
    private SSLSocketFactory factory;

    public DummySSLSocketFactory() {
        try {
            SSLContext sslcontext = SSLContext.getInstance("TLS");
            sslcontext.init(null, new TrustManager[]{new DummyTrustManager()}, new java.security.SecureRandom());
            factory = (SSLSocketFactory) sslcontext.getSocketFactory();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    public static SocketFactory getDefault() {
        return new DummySSLSocketFactory();
    }
    public Socket createSocket(Socket socket, String s, int i, boolean flag) throws IOException {
        return factory.createSocket(socket, s, i, flag);
    }
    public Socket createSocket(InetAddress inaddr, int i, InetAddress inaddr1, int j) throws IOException {
        return factory.createSocket(inaddr, i, inaddr1, j);
    }
    public Socket createSocket(InetAddress inaddr, int i) throws IOException {
        return factory.createSocket(inaddr, i);
    }
    public Socket createSocket(String s, int i, InetAddress inaddr, int j) throws IOException {
        return factory.createSocket(s, i, inaddr, j);
    }
    public Socket createSocket(String s, int i) throws IOException {
        return factory.createSocket(s, i);
    }
    public String[] getDefaultCipherSuites() {
        return factory.getSupportedCipherSuites();
    }
    public String[] getSupportedCipherSuites() {
        return factory.getSupportedCipherSuites();
    }
}
public class DummyTrustManager implements X509TrustManager {
    public void checkClientTrusted(X509Certificate[] cert, String authType) {
        return;
    }

    public void checkServerTrusted( X509Certificate[] cert, String authType) {
        return;
    }

    public X509Certificate[] getAcceptedIssuers() {
        return new X509Certificate[0];
    }
}

3、AD域配置信息类

注意：

1、账号和密码必须是管理员账号

2、path为ldap路径，例如：LDAP://ip地址/

3、suffixPath为域组织的根路径，即所有域组织单位的公共路径。例如：OU=***,DC=***,DC=***

@Data
@AllArgsConstructor
public class DomainConfigModel {
    /**
     * 域服务器账号
     */
    private String adminUser;
    /**
     * 域服务器密码
     */
    private String adminPwd;
    /**
     * 域服务器地址
     */
    private String path;
    /**
     * 域根路径
     */
    private String suffixPath;
}

明豆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用JAVA控制AD域进行基本的操作详解
RYCookie的博客
05-10 1万+
前段时间，我接到一个任务：使用JAVA控制AD域进行基本的操作。经几天摸索也看来多位博友的代码，现在摸索出了一套详细的Java操控AD域的方法。废话不多说，现进入正题》》》 一、安装域控服务器 什么是域控服务器我就不多说了，请各位自行百度，安装的教程在下面的连接里：http://www.jb51.net/os/windows/win2008/69883.html 二、安装证书控制服务
java 修改ad密码_不需要证书修改ad域密码
weixin_39651488的博客
02-21 578
前一段时间接到一个修改windows ad域密码的需求，也是第一次接触ad域操作的需求，特记录在博客以备后需，也希望能给有需要的朋友提供一点点解决问题的思路。在实现的过程中，先通过将证书到java证书库，然后使用ssl认证方式修改密码报异常，最后才选择修改socket连接信任所有证书的形式。一、主要代码1.自定义socket连接信任所有证书类import java.io.IOException;i...
JAVA通过AD域实现统一账户验证的方法
最新发布
xu11410的博客
04-28 1205
我们在实际的系统开发中，往往企业自己应用了一整套的账户密码策略，会要求我们通过验证对方现有的域账户与密码来实现信息系统的登陆与用户管理，以下是一个简单的范例，来帮助大家很好的理解。
AD域学习并使用Java接入AD域验证
weixin_44762522的博客
06-06 4407
当然首先要说明是哪一棵树（dc，相当于MYSQL的DB），然后是从树根到那个苹果所经过的所有“分叉”（ou），最后就是这个苹果的名字（uid，相当于MySQL表主键id）。域中包含着大量的域对象，如：组织单位(Organizational Unit)，组(Group)，用户(User)，计算机(Computer)，联系人(Contact),打印机，安全策略等。AD中域用户是最小的管理单位，域用户最容易管理又最难管理，如果赋予域用户的权限过大，将带来安全隐患，如果权限过小域用户无法正常工作。
java 实现对ad域的操作
qq_46042132的博客
10-31 1756
Java操作ad域
rc4 java 1.8_SSL握手失败 – Java 1.8
weixin_36025345的博客
02-13 243
只是让人们知道我升级到Java 1.8后似乎已经遇到的一个问题.并非所有解决方案都相同,因此发布了我如何解决这个问题.但首先……由于安全性正在被有效降级,因此这不是一个值得生产系统的解决方案.但是,如果你被阻止测试等,它可能是非常合适的.我的问题是无论我做了什么……启用SSLv3等我总是收到"javax.net.ssl.SSLHandshakeException: Received fatal a...
JAVA ldap AD 域 免证书 查询 修改 删除 新增 启用 禁用 修改密码
11-15
JAVA ldap AD 域 免证书 查询 修改 删除 新增 启用 禁用 修改密码
JAVA使用Ldap操作AD域的方法示例
08-26
在本文中，我们将深入探讨如何使用Java通过Ldap与Active Directory (AD)域...通过以上介绍和示例代码，你应该能够开始编写自己的AD域操作功能。记得在实际工作中根据具体需求和环境进行调整，以确保安全性和可靠性。
Java AD域插入用户和密码修改
07-30
1. **导入AD域证书**：在Java应用中使用AD域服务之前，必须先导入AD域的证书，以建立安全的SSL/TLS连接。这通常涉及将证书导入到Java的信任库（cacerts），可以通过`keytool`命令行工具完成。 2. **配置环境**：...
JAVA修改AD域密码_免证书
01-27
1. **禁用SSL验证**：在Java代码中，我们可以设置`java.security.properties`文件，关闭SSL证书检查。这可以通过以下代码实现： ```java System.setProperty("java.security.properties", "path/to/your/security....
java验证AD域用户登录
01-09
验证AD域用户登录 ,传入用户名(userName)和密码(password)进行验证。
AD域用户密码修改（SSL）
06-24
使用ssl keystore 证书修改AD域用户密码
JAVA JNDI免证书修改AD域密码.zip
03-19
JAVA JNDI免证书修改AD域密码
Ad域证书申请导出，导入java秘钥库，实现ssl修改用户密码以及禁用启用 整个流程
05-13
介绍Ad域服务器证书如何申请，如何导出，如何导入到java秘钥库，地址：https://blog.csdn.net/hc1017/article/details/81293323 实现ssl 修改ad用户密码，禁用启用用户。有两个demo测试文
java通过ad域校验用户密码是否正确
fishermanMr
01-28 778
host 域 如何知道自己属于那个域 ipconfig/all 端口一致 //post 端口 String post = "389"; 用户名 username username@***.com 源码 package org.jeecg.modules.to.util; import java.util.Hashtable; import javax.naming.AuthenticationException; import javax.naming.Context; i
Java实现AD域登录认证
热门推荐
Pnoker
08-04 3万+
web项目中有时候客户要求我们使用ad域进行身份确认，不再另外做一套用户管理系统。其实客户就是只要一套账号可以访问所有的OA，CRM等办公系统。 这就是第三方验证。一般有AD域,Ldap,Radius,邮件服务器等。最常用的要数AD域了。因为window系统在国内占据了大量的江山。做起来也很方便。 我这篇文章就是写，如何用java去实现AD域的身份验证。好了，直接看代码吧：
java 修改ad密码_JAVA修改AD域密码_免证书认证
weixin_32867357的博客
02-12 728
更改用户账户密码，必须要使用ssl方式登录到AD。网上大部分教程使用TrustStore的方式连接，Hashtable env = newHashtable();System.setProperty("javax.net.ssl.trustStore", KEYSTORE);System.setProperty("javax.net.ssl.trustStorePassword", KEYSTOR...
java ad域的开发文档
12-02
Java Ad域的开发文档主要涵盖了与Active Directory（AD）域相关的Java开发知识和技术。该文档首先介绍了AD域的基本概念，包括域控制器、用户、组、权限等，以便开发人员对AD域有一个清晰的认识。接着，文档详细介绍了如何使用Java编程语言来与AD域进行交互，涵盖了以下几个方面的内容： 1. 连接与认证：介绍了如何通过Java代码来连接到AD域，并进行用户身份认证的方法和技巧。 2. 用户管理：包括了如何使用Java来实现对AD域用户的增删改查操作，比如创建用户、重置密码、禁用用户等。 3. 组管理：介绍了如何通过Java代码来管理AD域中的用户组，包括创建组、添加用户到组、从组中移除用户等操作。 4. 权限管理：涵盖了如何通过Java代码来管理AD域中的权限，包括授予用户特定权限、管理用户的访问控制列表（ACL）等内容。 另外，文档还包括了一些实用的代码示例和最佳实践，帮助开发人员快速上手并正确地使用Java与AD域进行开发。此外，文档还介绍了一些常见的问题与解决方案，帮助开发人员在开发过程中遇到问题时能够快速定位并解决。总的来说，Java AD域的开发文档是一份全面而实用的指南，对于希望使用Java来进行AD域开发的开发人员来说，是一份非常有价值的文档。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值