动态与公告

产品动态

公告

产品简介

产品概述

基本概念

应用场景

功能介绍

账号系统

用户资料与关系链

消息管理

群组相关

公众号系统

音视频通话 Call

使用限制

购买指南

计费概述

价格说明

购买指引

续费指引

停服说明

退费说明

开发指引

Demo 专区

开通服务

体验 Demo

快速跑通

下载中心

SDK & Demo 源码

更新日志

聊天互动（含 UI）

TUIKit 组件介绍

快速开始

全功能接入

单功能接入

AI 集成

构建基础界面

更多特性

定义外观

国际化界面语言

推送服务（Push）

服务概述

名词解释

开通服务

快速跑通

厂商通道

数据统计

排查工具

客户端 API

服务端 API

推送回调

高级功能

更新日志

错误码

常见问题

智能客服

功能概述

快速入门

集成指引

管理员操作手册

客服操作手册

更多实践

直播间搭建

AI 聊天机器人方案

超大娱乐协作社群

Discord 实现指南

游戏内集成 Chat 指南

类 WhatsApp Channel 搭建方案

发送红包

Chat 应对防火墙限制相关

无 UI 集成

快速开始

集成 SDK

初始化

登录登出

消息相关

会话相关

群组相关

社群话题

用户管理

离线推送

云端搜索

本地搜索

公众号

客户端 API

JavaScript

Android

iOS & macOS

Swift

Flutter

Electron

Unity

React Native

C 接口

C++

服务端 API

生成 UserSig

REST API

第三方回调

控制台指南

新版控制台介绍

创建并升级应用

基本配置

功能配置

账号管理

群组管理

公众号管理

回调配置

用量统计

资源包查看指南

实时监控

开发辅助工具

访问管理

高级功能

常见问题

uni-app 常见问题

购买相关问题

SDK 相关问题

账号鉴权相关问题

用户资料与关系链相关问题

消息相关问题

群组相关问题

直播群相关问题

昵称头像相关问题

协议与认证

服务等级协议

安全合规认证

IM 政策

隐私政策

数据隐私和安全协议

平滑迁移方案

平滑迁移完整版

平滑迁移简化版

错误码

联系我们

Android&iOS&Windows&Mac

PDF

聚焦模式

字号

最后更新时间： 2025-11-18 20:54:41

功能描述
关注功能允许用户选择他们感兴趣的其他用户，以便及时获取这些用户最新的动态、发布或活动信息，系统可以根据用户的关注列表提供个性化的内容推荐。
粉丝功能是指用户被其他人关注的状态，当用户 A  关注用户 B 时，A 就成为了 B 的粉丝。用户可以在自己的个人资料页面上查看粉丝数量、粉丝列表或者粉丝的资料信息等。
通过关注和粉丝功能，社交应用和网站能够创建一个活跃的、相互连接的用户网络，促进信息的传播和社区的构建。
说明：
增强版 7.8 及以上版本支持。
此功能为高阶功能，需要您购买 专业版、专业版 Plus 或 企业版 解锁。
功能演示
﻿
关注用户
您可以调用 followUser (Java / Swift / Objective-C / C++) 接口来关注指定的用户。
示例代码如下：
Java
Swift
Objective-C
C++
List<String> userIDList = Arrays.asList("useridA", "useridB");
V2TIMManager.getFriendshipManager().followUser(userIDList, new V2TIMValueCallback<List<V2TIMFollowOperationResult>>() {
    @Override
    public void onSuccess(List<V2TIMFollowOperationResult> followOperationResultList) {
        // 关注用户操作成功
    }
﻿
    @Override
    public void onError(int code, String desc) {
        // 关注用户操作失败
    }
});
V2TIMManager.shared.followUser(userIDList: ["user1", "user2"]) { resultList in
    print( "followUser succ")
    resultList.forEach { item in
        print( item.description)
    }
} fail: { code, desc in
    print( "followUser fail, \\(code), \\(desc)")
}
NSArray *useridList = @[@"useridA", @"useridB"];
[[V2TIMManager sharedInstance] followUser:userIDList succ:^(NSArray<V2TIMFollowOperationResult *> *resultList) {
        // 关注用户操作成功
    } fail:^(int code, NSString *desc) {
        // 关注用户操作失败
    }];
template <class T>
class ValueCallback final : public V2TIMValueCallback<T> {
public:
    using SuccessCallback = std::function<void(const T&)>;
    using ErrorCallback = std::function<void(int, const V2TIMString&)>;
﻿
    ValueCallback() = default;
    ~ValueCallback() override = default;
﻿
    void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
        success_callback_ = std::move(success_callback);
        error_callback_ = std::move(error_callback);
    }
﻿
    void OnSuccess(const T& value) override {
        if (success_callback_) {
            success_callback_(value);
        }
    }
    void OnError(int error_code, const V2TIMString& error_message) override {
        if (error_callback_) {
            error_callback_(error_code, error_message);
        }
    }
﻿
private:
    SuccessCallback success_callback_;
    ErrorCallback error_callback_;
};
﻿
V2TIMStringVector userIDList;
userIDList.PushBack(u8"useridA");
userIDList.PushBack(u8"useridB");
﻿
auto callback = new ValueCallback<V2TIMFollowOperationResultVector>{};
callback->SetCallback(
    [=](const V2TIMFollowOperationResultVector& followOperationResultList) {
        // 关注用户操作成功
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 关注用户操作失败
        delete callback;
    });
﻿
V2TIMManager::GetInstance()->GetFriendshipManager()->FollowUser(userIDList, callback);
说明：
该接口一次最多支持关注 20 个用户（除了自己之外，其他用户都可以关注）。
每个用户的关注用户数量上限为 5000 人，粉丝用户数量无上限。
取消关注用户
您可以调用 unfollowUser (Java / Swift / Objective-C / C++) 接口来取消关注指定的用户。
示例代码如下：
Java
Swift
Objective-C
C++
List<String> userIDList = Arrays.asList("useridA", "useridB");
V2TIMManager.getFriendshipManager().unfollowUser(userIDList, new V2TIMValueCallback<List<V2TIMFollowOperationResult>>() {
    @Override
    public void onSuccess(List<V2TIMFollowOperationResult> followOperationResultList) {
        // 取消关注用户操作成功
    }
﻿
    @Override
    public void onError(int code, String desc) {
        // 取消关注用户操作失败
    }
});
V2TIMManager.shared.unfollowUser(userIDList: ["user1", "user2"]) { resultList in
    print( "unfollowUser succ")
    resultList.forEach { item in
        print( item.description)
    }
} fail: { code, desc in
    print( "unfollowUser fail, \\(code), \\(desc)")
}
NSArray *useridList = @[@"useridA", @"useridB"];
[[V2TIMManager sharedInstance] unfollowUser:userIDList succ:^(NSArray<V2TIMFollowOperationResult *> *resultList) {
        // 取消关注用户操作成功
    } fail:^(int code, NSString *desc) {
        // 取消关注用户操作失败
    }];
template <class T>
class ValueCallback final : public V2TIMValueCallback<T> {
public:
    using SuccessCallback = std::function<void(const T&)>;
    using ErrorCallback = std::function<void(int, const V2TIMString&)>;
﻿
    ValueCallback() = default;
    ~ValueCallback() override = default;
﻿
    void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
        success_callback_ = std::move(success_callback);
        error_callback_ = std::move(error_callback);
    }
﻿
    void OnSuccess(const T& value) override {
        if (success_callback_) {
            success_callback_(value);
        }
    }
    void OnError(int error_code, const V2TIMString& error_message) override {
        if (error_callback_) {
            error_callback_(error_code, error_message);
        }
    }
﻿
private:
    SuccessCallback success_callback_;
    ErrorCallback error_callback_;
};
﻿
V2TIMStringVector userIDList;
userIDList.PushBack(u8"useridA");
userIDList.PushBack(u8"useridB");
﻿
auto callback = new ValueCallback<V2TIMFollowOperationResultVector>{};
callback->SetCallback(
    [=](const V2TIMFollowOperationResultVector& followOperationResultList) {
        // 取消关注用户操作成功
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 取消关注用户操作失败
        delete callback;
    });
﻿
V2TIMManager::GetInstance()->GetFriendshipManager()->UnfollowUser(userIDList, callback);
说明：
一次最多支持取消关注 20 个用户。
获取我的关注用户列表
您可以调用getMyFollowingList (Java / Swift / Objective-C / C++) 接口来拉取已经关注的用户列表。
示例代码如下：
Java
Swift
Objective-C
C++
{
    ...
    String nextCursor = "";
    getMyFollowingList(nextCursor);
    ...
}
﻿
public void getMyFollowingList(String nextCursor) {
    V2TIMManager.getFriendshipManager().getMyFollowingList(nextCursor, new V2TIMValueCallback<V2TIMUserInfoResult>() {
        @Override
        public void onSuccess(V2TIMUserInfoResult v2TIMUserInfoResult) {
            StringBuilder stringBuilder = new StringBuilder();
            // 拉取成功
            if (v2TIMUserInfoResult.getNextCursor().length() > 0) {
                // 继续分页拉取
                getMyFollowingList(v2TIMUserInfoResult.getNextCursor());
                ...
            } else {
                // 拉取结束
            }
        }
﻿
        @Override
        public void onError(int code, String desc) {
            // 拉取失败
        }
    });
}
func getMyFollowingList(cursor: String) {
    V2TIMManager.shared.getMyFollowingList(nextCursor: cursor, succ: { nextCursor, userInfoList in
        if nextCursor.count > 0 {
            // 继续分页拉取
            self.getMyFollowingList(cursor: nextCursor)
            //...
        } else {
            // 拉取结束
        }
    }, fail: { code, desc in
        // 拉取失败
    })
}
- (void)getMyFollowingList:(NSString *)cursor {
    [[V2TIMManager sharedInstance] getMyFollowingList:cursor succ:^(NSString *nextCursor, NSArray<V2TIMUserFullInfo *> *userInfoList) {
        if (nextCursor.length > 0) {
            // 继续分页拉取
            [self getMyFollowingList:nextCursor];
            //...
        } else {
            // 拉取结束
        }
    } fail:^(int code, NSString *desc) {
        // 拉取失败
    }];
}
template <class T>
class ValueCallback final : public V2TIMValueCallback<T> {
public:
    using SuccessCallback = std::function<void(const T&)>;
    using ErrorCallback = std::function<void(int, const V2TIMString&)>;
﻿
    ValueCallback() = default;
    ~ValueCallback() override = default;
﻿
    void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
        success_callback_ = std::move(success_callback);
        error_callback_ = std::move(error_callback);
    }
﻿
    void OnSuccess(const T& value) override {
        if (success_callback_) {
            success_callback_(value);
        }
    }
    void OnError(int error_code, const V2TIMString& error_message) override {
        if (error_callback_) {
            error_callback_(error_code, error_message);
        }
    }
﻿
private:
    SuccessCallback success_callback_;
    ErrorCallback error_callback_;
};
﻿
V2TIMString nextCursor = u8"";
﻿
void GetMyFollowingList(const V2TIMString& nextCursor) {
    auto callback = new ValueCallback<V2TIMUserInfoResult>{};
    callback->SetCallback(
        [=](const V2TIMUserInfoResult& userInfoResult) {
            // 拉取成功
            if (userInfoResult.nextCursor.Length() > 0) {
                // 继续分页拉取
                GetMyFollowingList(userInfoResult.nextCursor);
                ...
            } else {
                // 拉取结束
            }
﻿
            delete callback;
        },
        [=](int error_code, const V2TIMString& error_message) {
            // 拉取失败
            delete callback;
        });
﻿
    V2TIMManager::GetInstance()->GetFriendshipManager()->GetMyFollowingList(nextCursor, callback);
}
说明：
该接口每次最多返回 500 个用户。
首次拉取时，可以将接口的 nextCursor 参数填写为 "", 回调成功后如果返回的 nextCursor 不为 ""，可以传入该值再次拉取，直至 nextCursor 返回为 ""，表示全部拉取完成。
获取我的粉丝用户列表
您可以调用getMyFollowersList (Java / Swift / Objective-C / C++) 接口来拉取自己的粉丝用户列表。
示例代码如下：
Java
Swift
Objective-C
C++
{
    ...
    String nextCursor = "";
    getMyFollowingList(nextCursor);
    ...
}
﻿
public void getMyFollowingList(String nextCursor) {
    V2TIMManager.getFriendshipManager().getMyFollowingList(nextCursor, new V2TIMValueCallback<V2TIMUserInfoResult>() {
        @Override
        public void onSuccess(V2TIMUserInfoResult v2TIMUserInfoResult) {
            StringBuilder stringBuilder = new StringBuilder();
            // 拉取成功
            if (v2TIMUserInfoResult.getNextCursor().length() > 0) {
                // 继续分页拉取
                getMyFollowingList(v2TIMUserInfoResult.getNextCursor());
                ...
            } else {
                // 拉取结束
            }
        }
﻿
        @Override
        public void onError(int code, String desc) {
            // 拉取失败
        }
    });
}
func getMyFollowersList(cursor: String) {
    V2TIMManager.shared.getMyFollowersList(nextCursor: cursor, succ: { nextCursor, userInfoList in
        if nextCursor.count > 0 {
            // 继续分页拉取
            self.getMyFollowersList(cursor: nextCursor)
            //...
        } else {
            // 拉取结束
        }
    }, fail: { code, desc in
        // 拉取失败
    })
}
- (void)getMyFollowingList:(NSString *)cursor {
    [[V2TIMManager sharedInstance] getMyFollowingList:cursor succ:^(NSString *nextCursor, NSArray<V2TIMUserFullInfo *> *userInfoList) {
        if (nextCursor.length > 0) {
            // 继续分页拉取
            [self getMyFollowingList:nextCursor];
            //...
        } else {
            // 拉取结束
        }
    } fail:^(int code, NSString *desc) {
        // 拉取失败
    }];
}
template <class T>
class ValueCallback final : public V2TIMValueCallback<T> {
public:
    using SuccessCallback = std::function<void(const T&)>;
    using ErrorCallback = std::function<void(int, const V2TIMString&)>;
﻿
    ValueCallback() = default;
    ~ValueCallback() override = default;
﻿
    void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
        success_callback_ = std::move(success_callback);
        error_callback_ = std::move(error_callback);
    }
﻿
    void OnSuccess(const T& value) override {
        if (success_callback_) {
            success_callback_(value);
        }
    }
    void OnError(int error_code, const V2TIMString& error_message) override {
        if (error_callback_) {
            error_callback_(error_code, error_message);
        }
    }
﻿
private:
    SuccessCallback success_callback_;
    ErrorCallback error_callback_;
};
﻿
V2TIMString nextCursor = u8"";
﻿
void GetMyFollowingList(const V2TIMString& nextCursor) {
    auto callback = new ValueCallback<V2TIMUserInfoResult>{};
    callback->SetCallback(
        [=](const V2TIMUserInfoResult& userInfoResult) {
            // 拉取成功
            if (userInfoResult.nextCursor.Length() > 0) {
                // 继续分页拉取
                GetMyFollowingList(userInfoResult.nextCursor);
                ...
            } else {
                // 拉取结束
            }
﻿
            delete callback;
        },
        [=](int error_code, const V2TIMString& error_message) {
            // 拉取失败
            delete callback;
        });
﻿
    V2TIMManager::GetInstance()->GetFriendshipManager()->GetMyFollowingList(nextCursor, callback);
}
说明：
该接口每次最多返回 500 个用户。
首次拉取时，可以将接口的 nextCursor 参数填写为 "", 回调成功后如果返回的 nextCursor 不为 ""，可以传入该值再次拉取，直至 nextCursor 返回为 ""，表示全部拉取完成。
获取与我互相关注的用户列表
您可以调用getMutualFollowersList (Java / Swift / Objective-C / C++) 接口来拉取与自己互相关注的用户列表（互相关注的用户都可以在彼此的关注用户列表和粉丝用户列表中找到对方）。
示例代码如下：
Java
Swift
Objective-C
C++
{
    ...
    String nextCursor = "";
    getMutualFollowersList(nextCursor);
    ...
}
﻿
public void getMutualFollowersList(String nextCursor) {
    V2TIMManager.getFriendshipManager().getMutualFollowersList(nextCursor, new V2TIMValueCallback<V2TIMUserInfoResult>() {
        @Override
        public void onSuccess(V2TIMUserInfoResult v2TIMUserInfoResult) {
            StringBuilder stringBuilder = new StringBuilder();
            // 拉取成功
            if (v2TIMUserInfoResult.getNextCursor().length() > 0) {
                // 继续分页拉取
                getMutualFollowersList(v2TIMUserInfoResult.getNextCursor());
                ...
            } else {
                // 拉取结束
            }
        }
﻿
        @Override
        public void onError(int code, String desc) {
            // 拉取失败
        }
    });
}
func getMutualFollowersList(cursor: String) {
    V2TIMManager.shared.getMutualFollowersList(nextCursor: cursor, succ: { nextCursor, userInfoList in
        if nextCursor.count > 0 {
            // 继续分页拉取
            self.getMutualFollowersList(cursor: nextCursor)
            //...
        } else {
            // 拉取结束
        }
    }, fail: { code, desc in
        // 拉取失败
    })
}
﻿
- (void)getMutualFollowersList:(NSString *)cursor {
    [[V2TIMManager sharedInstance] getMutualFollowersList:cursor succ:^(NSString *nextCursor, NSArray<V2TIMUserFullInfo *> *userInfoList) {
        if (nextCursor.length > 0) {
            // 继续分页拉取
            [self getMutualFollowersList:nextCursor];
            //...
        } else {
            // 拉取结束
        }
    } fail:^(int code, NSString *desc) {
        // 拉取失败
    }];
}
template <class T>
class ValueCallback final : public V2TIMValueCallback<T> {
public:
    using SuccessCallback = std::function<void(const T&)>;
    using ErrorCallback = std::function<void(int, const V2TIMString&)>;
﻿
    ValueCallback() = default;
    ~ValueCallback() override = default;
﻿
    void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
        success_callback_ = std::move(success_callback);
        error_callback_ = std::move(error_callback);
    }
﻿
    void OnSuccess(const T& value) override {
        if (success_callback_) {
            success_callback_(value);
        }
    }
    void OnError(int error_code, const V2TIMString& error_message) override {
        if (error_callback_) {
            error_callback_(error_code, error_message);
        }
    }
﻿
private:
    SuccessCallback success_callback_;
    ErrorCallback error_callback_;
};
﻿
V2TIMString nextCursor = u8"";
﻿
void GetMutualFollowersList(const V2TIMString& nextCursor) {
    auto callback = new ValueCallback<V2TIMUserInfoResult>{};
    callback->SetCallback(
        [=](const V2TIMUserInfoResult& userInfoResult) {
            // 拉取成功
            if (userInfoResult.nextCursor.Length() > 0) {
                // 继续分页拉取
                GetMutualFollowersList(userInfoResult.nextCursor);
                ...
            } else {
                // 拉取结束
            }
﻿
            delete callback;
        },
        [=](int error_code, const V2TIMString& error_message) {
            // 拉取失败
            delete callback;
        });
﻿
    V2TIMManager::GetInstance()->GetFriendshipManager()->GetMutualFollowersList(nextCursor, callback);
}
说明：
该接口每次最多返回 500 个用户。
首次拉取时，可以将接口的 nextCursor 参数填写为 "", 回调成功后如果返回的 nextCursor 不为 ""，可以传入该值再次拉取，直至 nextCursor 返回为 ""，表示全部拉取完成。
获取用户的关注/粉丝/互关用户数量
您可以调用 getUserFollowInfo (Java / Swift /  Objective-C / C++) 接口来获取指定用户的关注/粉丝/互关用户的数量信息 。
在回调信息中，您可以从 V2TIMFollowInfo (Java / Swift / Objective-C / C++) 的 followingCount、followersCount 和 mutualFollowersCount 来获取指定用户的关注、粉丝和互关用户数量。
示例代码如下：
Java
Swift
Objective-C
C++
List<String> userIDList = Arrays.asList("useridA", "useridB");
V2TIMManager.getFriendshipManager().getUserFollowInfo(userIDList, new V2TIMValueCallback<List<V2TIMFollowInfo>>() {
    @Override
    public void onSuccess(List<V2TIMFollowInfo> followInfoList) {
        // 获取成功
        for (V2TIMFollowInfo followInfo : V2TIMFollowInfoList) {
            if (followInfo.getResultCode() == 0) {
                // 此处可以获取到用户 followInfo.getUserID() 对应的关注/粉丝/互关用户的数量信息
                // 也即 followInfo.getFollowingCount(), followInfo.getFollowersCount() 和 followInfo.getMutualFollowersCount()
            }
        }
    }
﻿
    @Override
    public void onError(int code, String desc) {
        // 获取失败
    }
});
V2TIMManager.shared.getUserFollowInfo(userIDList: ["user1", "user2"]) { resultList in
    print( "getUserFollowInfo succ")
    resultList.forEach { item in
        print( item.description)
    }
} fail: { code, desc in
    print( "getUserFollowInfo fail, \\(code), \\(desc)")
}
NSArray *useridList = @[@"useridA", @"useridB"];
[[V2TIMManager sharedInstance] getUserFollowInfo:userIDList succ:^(NSArray<V2TIMFollowInfo *> *resultList) {
        // 获取成功
        for (V2TIMFollowInfo *result in resultList) {
            if (result.resultCode == 0) {
                // 此处可以获取到用户 result.userID 对应的关注/粉丝/互关用户的数量信息
                // 也即 result.followingCount, result.followersCount 以及 result.mutualFollowersCount 信息
            }
        }
    } fail:^(int code, NSString *desc) {
        // 获取失败
    }];
template <class T>
class ValueCallback final : public V2TIMValueCallback<T> {
public:
    using SuccessCallback = std::function<void(const T&)>;
    using ErrorCallback = std::function<void(int, const V2TIMString&)>;
﻿
    ValueCallback() = default;
    ~ValueCallback() override = default;
﻿
    void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
        success_callback_ = std::move(success_callback);
        error_callback_ = std::move(error_callback);
    }
﻿
    void OnSuccess(const T& value) override {
        if (success_callback_) {
            success_callback_(value);
        }
    }
    void OnError(int error_code, const V2TIMString& error_message) override {
        if (error_callback_) {
            error_callback_(error_code, error_message);
        }
    }
﻿
private:
    SuccessCallback success_callback_;
    ErrorCallback error_callback_;
};
﻿
V2TIMStringVector userIDList;
userIDList.PushBack(u8"useridA");
userIDList.PushBack(u8"useridB");
﻿
auto callback = new ValueCallback<V2TIMFollowInfoVector>{};
callback->SetCallback(
    [=](const V2TIMFollowInfoVector& followInfoList) {
        // 获取成功
        for (size_t i = 0; i < followInfoList.Size(); ++i) {
            if (followInfoList[i].resultCode == 0) {
                // 此处可以获取到用户 followInfoList[i].userID 对应的关注/粉丝/互关用户的数量信息
                // 也即 followInfoList[i].followingCount, followInfoList[i].followersCount 和 followInfoList[i].mutualFollowersCount
            }
        }
﻿
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 获取失败
        delete callback;
    });
﻿
V2TIMManager::GetInstance()->GetFriendshipManager()->GetUserFollowInfo(userIDList, callback);
检查关注关系
您可以调用 checkFollowType (Java / Swift / Objective-C / C++) 接口用来检查自己与指定用户的关注关系。
在回调信息中，您可以通过 V2TIMFollowTypeCheckResult (Java / Swift / Objective-C / C++) 的 followType 字段来获取自己与该用户的关系：
V2TIMFollowTypeCheckResult.followType
与自己的关系
﻿V2TIM_FOLLOW_TYPE_NONE
﻿
无任何关系
﻿V2TIM_FOLLOW_TYPE_IN_MY_FOLLOWING_LIST
﻿
对方仅在我的关注列表中
﻿V2TIM_FOLLOW_TYPE_IN_MY_FOLLOWERS_LIST
﻿
对方仅在我的粉丝列表中
﻿V2TIM_FOLLOW_TYPE_IN_BOTH_FOLLOWERS_LIST
﻿
对方与我互相关注（对方既在我的关注列表，也在我的粉丝列表）
示例代码如下：
Java
Swift
Objective-C
C++
List<String> userIDList = Arrays.asList("useridA", "useridB");
V2TIMManager.getFriendshipManager().checkFollowType(userIDList, new V2TIMValueCallback<List<V2TIMFollowTypeCheckResult>>() {
    @Override
    public void onSuccess(List<V2TIMFollowTypeCheckResult> followTypeCheckResultList) {
        // 检查关注关系成功
        for (V2TIMFollowTypeCheckResult followTypeCheckResult : followTypeCheckResultList) {
            if (followTypeCheckResult.getResultCode() == 0) {
                // 此处可以获取到自己与用户 followTypeCheckResult.getUserID() 的关系 followTypeCheckResult.getFollowType()
            }
        }
    }
﻿
    @Override
    public void onError(int code, String desc) {
        // 检查关注关系失败
    }
});
V2TIMManager.shared.checkFollowType(userIDList: ["user1", "user2"]) { resultList in
    print( "checkFollowType succ")
    resultList.forEach { item in
        print( item.description)
    }
} fail: { code, desc in
    print( "checkFollowType fail, \\(code), \\(desc)")
}
NSArray *useridList = @[@"useridA", @"useridB"];
[[V2TIMManager sharedInstance] checkFollowType:userIDList succ:^(NSArray<V2TIMFollowTypeCheckResult *> *resultList) {
        // 检查关注关系成功
        for (V2TIMFollowTypeCheckResult *result in resultList) {
            if (result.resultCode == 0) {
                // 此处可以获取到自己与用户 result.userID 的关系 result.followType
            }
        }
    } fail:^(int code, NSString *desc) {
        // 检查关注关系失败
    }];
template <class T>
class ValueCallback final : public V2TIMValueCallback<T> {
public:
    using SuccessCallback = std::function<void(const T&)>;
    using ErrorCallback = std::function<void(int, const V2TIMString&)>;
﻿
    ValueCallback() = default;
    ~ValueCallback() override = default;
﻿
    void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
        success_callback_ = std::move(success_callback);
        error_callback_ = std::move(error_callback);
    }
﻿
    void OnSuccess(const T& value) override {
        if (success_callback_) {
            success_callback_(value);
        }
    }
    void OnError(int error_code, const V2TIMString& error_message) override {
        if (error_callback_) {
            error_callback_(error_code, error_message);
        }
    }
﻿
private:
    SuccessCallback success_callback_;
    ErrorCallback error_callback_;
};
﻿
V2TIMStringVector userIDList;
userIDList.PushBack(u8"useridA");
userIDList.PushBack(u8"useridB");
﻿
auto callback = new ValueCallback<V2TIMFollowTypeCheckResultVector>{};
callback->SetCallback(
    [=](const V2TIMFollowTypeCheckResultVector& followTypeCheckResultList) {
        // 检查关注关系成功
        for (size_t i = 0; i < followTypeCheckResultList.Size(); ++i) {
            if (followTypeCheckResultList[i].resultCode == 0) {
                // 此处可以获取到自己与用户 followTypeCheckResultList[i].userID 的关系 followTypeCheckResultList[i].followType
            }
        }
﻿
        delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
        // 检查关注关系失败
        delete callback;
    });
﻿
V2TIMManager::GetInstance()->GetFriendshipManager()->FollowUser(userIDList, callback);
说明：
该接口限频为每 5s 内最多调用 20 次，且每次最多支持传入 100 个用户 。
关注/粉丝/互关列表变更通知
具体的列表变更通知如下：
列表变更通知
说明
关注列表变更通知 onMyFollowingListChanged
 (Java / Swift / Objective-C / C++) 
当通知中的isAdd 为 true 时，表示列表新增用户的通知，此时会返回完整的用户资料
当通知中的isAdd 为 false 时，表示列表删除用户的通知，此时返回的用户资料中仅有用户 ID
粉丝列表变更通知 onMyFollowersListChanged
 (Java / Swift / Objective-C / C++) 
﻿
互关列表变更通知 onMutualFollowersListChanged
 (Java / Swift / Objective-C / C++) 
﻿
说明：
您需要预先调用 addFriendListener (Java / Swift / Objective-C / C++) 添加关系链事件监听器，之后才能收到上述相关事件的通知。
列表新增用户通知的场景示例
假设有两个没有任何关系用户 Alice 和 Bob，这两个用户相互关注过程中，相关列表变更通知和关系变更如下：
事件
Alice
﻿
Bob
﻿
﻿
收到的通知
与 Bob 的关系
收到的通知
与 Alice 的关系
Alice 关注 Bob
﻿关注列表新增用户通知 
﻿关注﻿
﻿粉丝列表新增用户通知﻿
﻿粉丝﻿
Bob 关注 Alice
﻿粉丝列表新增用户通知﻿
﻿互关列表新增用户通知﻿
﻿互相关注﻿
﻿关注列表新增用户通知
互关列表新增用户通知﻿
﻿互相关注﻿
列表删除用户通知的场景示例
假设有两个已经互相关注的用户 Alice 和 Bob, 这两个用户相互取消关注过程中，相关列表变更通知和关系变更如下：
事件
Alice
﻿
Bob
﻿
﻿
收到的通知
与 Bob 的关系
收到的通知
与 Alice 的关系
Alice 取消关注 Bob
﻿关注列表删除用户通知﻿
﻿互关列表删除用户通知﻿
﻿粉丝﻿
﻿粉丝列表删除用户通知﻿
﻿互关列表删除用户通知﻿
﻿关注﻿
Bob 取消关注 Alice
﻿粉丝列表删除用户通知﻿
﻿无任何关系﻿
﻿关注列表删除用户通知﻿
﻿无任何关系﻿
示例代码如下：
Java
Swift
Objective-C
C++
V2TIMFriendshipListener v2TIMFriendshipListener = new V2TIMFriendshipListener() {
    @Override
    public void onMyFollowingListChanged(List<V2TIMUserFullInfo> userInfoList, boolean isAdd) {
        if (isAdd) {
            // 关注列表新增用户的通知
        } else {
            // 关注列表删除用户的通知
        }
    }
﻿
    @Override
    public void onMyFollowersListChanged(List<V2TIMUserFullInfo> userInfoList, boolean isAdd) {
        if (isAdd) {
            // 粉丝列表新增用户的通知
        } else {
            // 粉丝列表删除用户的通知
        }
    }
﻿
    @Override
    public void onMutualFollowersListChanged(List<V2TIMUserFullInfo> userInfoList, boolean isAdd) {
        if (isAdd) {
            // 互关列表新增用户的通知
        } else {
            // 互关列表删除用户的通知
        }
    }
};
﻿
// 添加关系链监听器
V2TIMManager.getFriendshipManager().addFriendListener(v2TIMFriendshipListener);
V2TIMManager.shared.addFriendListener(listener: self)
func onMyFollowingListChanged(userInfoList: Array<V2TIMUserFullInfo>, isAdd: Bool) {
    print( "isAdd: \\(isAdd)|userInfoList: \\(userInfoList)")
}
func onMyFollowersListChanged(userInfoList: Array<V2TIMUserFullInfo>, isAdd: Bool) {
    print( "isAdd: \\(isAdd)|userInfoList: \\(userInfoList)")
}
func onMutualFollowersListChanged(userInfoList: Array<V2TIMUserFullInfo>, isAdd: Bool) {
    print( "isAdd: \\(isAdd)|userInfoList: \\(userInfoList)")
}
// 添加关系链监听器
[[V2TIMManager sharedInstance] addFriendListener:self];
﻿
- (void)onMyFollowingListChanged:(NSArray<V2TIMUserFullInfo *> *)userInfoList isAdd:(BOOL)isAdd {
    if (isAdd) {
        // 关注列表新增用户的通知
    } else {
        // 关注列表删除用户的通知
    }
}
﻿
- (void)onMyFollowersListChanged:(NSArray<V2TIMUserFullInfo *> *)userInfoList isAdd:(BOOL)isAdd {
    if (isAdd) {
        // 粉丝列表新增用户的通知
    } else {
        // 粉丝列表删除用户的通知
    }
}
﻿
- (void)onMutualFollowersListChanged:(NSArray<V2TIMUserFullInfo *> *)userInfoList isAdd:(BOOL)isAdd {
    if (isAdd) {
        // 互关列表新增用户的通知
    } else {
        // 互关列表删除用户的通知
    }
}
class FriendshipListener final : public V2TIMFriendshipListener {
public:
    FriendshipListener() = default;
    ~FriendshipListener() override = default;
﻿
    void OnMyFollowingListChanged(const V2TIMUserFullInfoVector &userInfoList, bool isAdd) override {
        if (isAdd) {
            // 关注列表新增用户的通知
        } else {
            // 关注列表删除用户的通知
        }
    }
﻿
    void OnMyFollowersListChanged(const V2TIMUserFullInfoVector &userInfoList, bool isAdd) override {
        if (isAdd) {
            // 粉丝列表新增用户的通知
        } else {
            // 粉丝列表删除用户的通知
        }
    }
﻿
    void OnMutualFollowersListChanged(const V2TIMUserFullInfoVector &userInfoList, bool isAdd) override {
        if (isAdd) {
            // 互关列表新增用户的通知
        } else {
            // 互关列表删除用户的通知
        }
    }
﻿
    // 其他成员函数 ...
};
﻿
// 添加关系链事件监听器，注意在移除监听器之前需要保持 friendshipListener 的生命期，以免接收不到事件回调
FriendshipListener friendshipListener;
V2TIMManager::GetInstance()->GetFriendshipManager()->AddFriendListener(&friendshipListener);
﻿
﻿

帮助和支持

本页内容是否解决了您的问题？

您也可以联系销售或提交工单以寻求帮助。

填写满意度调查问卷，共创更好文档体验。

文档反馈

列表变更通知	说明
关注列表变更通知 `onMyFollowingListChanged` (Java / Swift / Objective-C / C++)	当通知中的`isAdd` 为 `true` 时，表示列表新增用户的通知，此时会返回完整的用户资料当通知中的`isAdd` 为 `false` 时，表示列表删除用户的通知，此时返回的用户资料中仅有用户 ID
粉丝列表变更通知 `onMyFollowersListChanged` (Java / Swift / Objective-C / C++)
互关列表变更通知 `onMutualFollowersListChanged` (Java / Swift / Objective-C / C++)

tencent cloud

即时通信 IM

Android&iOS&Windows&Mac

功能描述

功能演示

关注用户

取消关注用户

获取我的关注用户列表

获取我的粉丝用户列表

获取与我互相关注的用户列表

获取用户的关注/粉丝/互关用户数量

检查关注关系

关注/粉丝/互关列表变更通知

列表新增用户通知的场景示例

列表删除用户通知的场景示例

帮助和支持

`V2TIMFollowTypeCheckResult.followType`	与自己的关系
`V2TIM_FOLLOW_TYPE_NONE`	无任何关系
`V2TIM_FOLLOW_TYPE_IN_MY_FOLLOWING_LIST`	对方仅在我的关注列表中
`V2TIM_FOLLOW_TYPE_IN_MY_FOLLOWERS_LIST`	对方仅在我的粉丝列表中
`V2TIM_FOLLOW_TYPE_IN_BOTH_FOLLOWERS_LIST`	对方与我互相关注（对方既在我的关注列表，也在我的粉丝列表）

事件	`Alice`			`Bob`
事件		收到的通知	与 `Bob` 的关系	收到的通知	与 `Alice` 的关系
`Alice` 关注 `Bob`	关注列表新增用户通知	关注	粉丝列表新增用户通知	粉丝
`Bob` 关注 `Alice`	粉丝列表新增用户通知互关列表新增用户通知	互相关注	关注列表新增用户通知互关列表新增用户通知	互相关注