Java实现微信微博分享全攻略：从零基础到集成SDK的完整指南，解决回调配置与权限验证难题

引言：移动互联网时代的分享功能重要性

在当今的移动互联网应用中，社交分享功能已经成为提升用户活跃度和应用传播能力的核心功能之一。微信和微博作为中国两大主流社交平台，其分享功能的集成对于应用的推广和用户留存具有重要意义。对于Java开发者而言，如何在后端服务中实现稳定、安全的微信和微博分享功能，是一个既常见又充满挑战的技术课题。

本文将从零基础开始，详细讲解如何使用Java实现微信和微博的分享功能，涵盖从前期准备、SDK集成、回调配置到权限验证的完整流程。我们将重点解决开发者在实际集成过程中遇到的回调配置难题和权限验证问题，提供可直接落地的代码示例和最佳实践。

一、前期准备与基础概念

1.1 开发者账号注册与应用创建

在开始代码开发之前，首先需要完成开发者账号的注册和应用的创建。

微信开放平台账号注册：

访问微信开放平台
注册开发者账号（需要企业资质，个人开发者可考虑使用微信公众号平台）
完成开发者资质认证
创建网站应用，获取AppID和AppSecret

微博开放平台账号注册：

访问微博开放平台
注册开发者账号
创建应用，获取App Key和App Secret

1.2 分享功能技术原理

微信和微博的分享功能主要基于OAuth2.0授权机制和SDK封装的API调用。其核心流程如下：

用户授权：用户点击分享按钮，引导用户跳转至微信/微博授权页面
获取授权码：用户授权后，平台回调应用配置的回调地址，并附带授权码
获取访问令牌：应用使用授权码换取Access Token
执行分享操作：使用Access Token调用分享API
处理回调：接收平台的回调通知，处理分享结果

1.3 开发环境要求

Java 8或更高版本
Maven或Gradle构建工具
Spring Boot框架（推荐，非必须）
网络请求库（如OkHttp、Apache HttpClient）

二、微信分享功能实现

2.1 微信开放平台接入流程

2.1.1 应用配置

在微信开放平台创建应用后，需要配置以下信息：

授权回调域：必须填写域名，且与实际部署的域名一致
网页授权域名：用于H5页面授权
JS接口安全域名：用于微信JS-SDK

2.1.2 SDK集成

推荐使用官方提供的微信Java SDK，这是一个功能完善的开源SDK。

Maven依赖配置：

<dependency>
    <groupId>com.github.binarywang</groupId>
    <artifactId>weixin-java-common</artifactId>
    <version>4.4.0</version>
</dependency>
<dependency>
    <groupId>com.github.binarywang</groupId>
    <artifactId>weixin-java-mp</artifactId>
    <version>4.4.0</version>
</dependency>

2.2 微信分享代码实现

2.2.1 配置类创建

首先创建微信配置类，封装AppID和AppSecret等配置信息：

@Configuration
public class WechatConfig {
    
    @Value("${wechat.app-id}")
    private String appId;
    
    @Value("${wechat.app-secret}")
    private String appSecret;
    
    @Value("${wechat.token}")
    private String token;
    
    @Value("${wechat.aes-key}")
    private String aesKey;
    
    @Bean
    public WxMpService wxMpService() {
        WxMpServiceImpl wxMpService = new WxMpServiceImpl();
        wxMpService.setWxMpConfigStorage(new WxMpDefaultConfigImpl() {{
            setAppId(appId);
            setSecret(appSecret);
            setToken(token);
            setAesKey(aesKey);
        }});
        return wxMpService;
    }
}

2.2.2 分享服务类实现

创建微信分享服务类，处理分享逻辑：

@Service
public class WechatShareService {
    
    @Autowired
    private WxMpService wxMpService;
    
    /**
     * 获取微信分享配置参数
     * @param url 当前页面URL
     * @return 微信分享配置
     */
    public Map<String, String> getShareConfig(String url) {
        try {
            // 获取微信JS-SDK的ticket
            String ticket = wxMpService.getJsApiTicket();
            // 生成签名
            String nonceStr = UUID.randomUUID().toString();
            String timestamp = String.valueOf(System.currentTimeMillis() / 1000);
            
            String signature = generateSignature(ticket, nonceStr, timestamp, url);
            
            Map<String, String> config = new HashMap<>();
            config.put("appId", wxMpService.getWxMpConfigStorage().getAppId());
            config.put("timestamp", timestamp);
            config.put("nonceStr", nonceStr);
            config.put("signature", signature);
            
            return config;
        } catch (Exception e) {
            throw new RuntimeException("获取微信分享配置失败", e);
        }
    }
    
    /**
     * 生成微信签名
     */
    private String generateSignature(String ticket, String nonceStr, String timestamp, String url) {
        String string1 = "jsapi_ticket=" + ticket +
                        "&noncestr=" + nonceStr +
                        "&timestamp=" + timestamp +
                        "&url=" + url;
        
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-1");
            byte[] digest = md.digest(string1.getBytes(StandardCharsets.UTF_8));
            return bytesToHex(digest);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("签名生成失败", e);
        }
    }
    
    private String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }
}

2.2.3 控制器层实现

创建控制器处理前端分享请求：

@RestController
@RequestMapping("/api/wechat")
public class WechatShareController {
    
    @Autowired
    private WechatShareService wechatShareService;
    
    /**
     * 获取微信JS-SDK配置
     */
    @GetMapping("/share-config")
    public ResponseEntity<Map<String, String>> getShareConfig(@RequestParam String url) {
        try {
            Map<String, String> config = wechatShareService.getShareConfig(url);
            return ResponseEntity.ok(config);
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(Collections.singletonMap("error", e.getMessage()));
        }
    }
}

2.3 微信回调处理

2.3.1 回调控制器实现

微信回调主要用于接收分享结果通知，需要实现消息接收和验证：

@RestController
@RequestMapping("/api/wechat/callback")
public class WechatCallbackController {
    
    @Autowired
    private WxMpService wxMpService;
    
    /**
     * 微信回调验证接口
     */
    @GetMapping
    public String verifyCallback(@RequestParam String signature,
                                 @RequestParam String timestamp,
                                 @RequestParam String nonce,
                                 @RequestParam String echostr) {
        if (wxMpService.checkSignature(timestamp, nonce, signature)) {
            return echostr;
        }
        return "invalid";
    }
    
    /**
     * 微信回调处理接口
     */
    @PostMapping
    public String handleCallback(HttpServletRequest request) {
        try {
            // 解析微信消息
            String xml = IOUtils.toString(request.getInputStream(), StandardCharsets.UTF_8);
            WxMpXmlMessage message = WxMpXmlMessage.fromXml(xml);
            
            // 处理分享结果消息
            if ("event".equals(message.getMsgType()) && "SHARE".equals(message.getEvent())) {
                handleShareResult(message);
            }
            
            // 返回成功响应
            return "<xml><return_code><![CDATA[SUCCESS]]></return_code></xml>";
        } catch (Exception e) {
            return "<xml><return_code><![CDATA[FAIL]]></return_code></xml>";
        }
    }
    
    private void handleShareResult(WxMpXmlMessage message) {
        // 处理分享结果，记录日志、更新状态等
        String openId = message.getFromUser();
        String shareId = message.getEventKey();
        // TODO: 业务逻辑处理
    }
}

2.4 微信权限验证难题解决方案

2.4.1 签名验证问题

问题描述：前端获取的签名与后端生成的签名不一致，导致JS-SDK初始化失败。

解决方案：

URL标准化：确保前后端使用的URL完全一致，注意#后面的部分
时间戳校验：检查服务器时间是否与微信服务器时间同步
Ticket缓存：合理缓存jsapi_ticket，避免频繁调用

// 优化后的签名生成方法，增加URL标准化处理
public String getNormalizedUrl(String url) {
    // 去除URL中的#及后面的部分
    int hashIndex = url.indexOf("#");
    if (hashIndex != -1) {
        url = url.substring(0, hashIndex);
    }
    // 去除重复的斜杠
    return url.replaceAll("/+", "/");
}

2.4.2 域名验证问题

问题描述：微信提示”无效的域名”或”域名未配置”。

解决方案：

检查域名配置：确保在微信开放平台配置的域名与实际访问域名完全一致
HTTPS要求：微信要求分享页面必须使用HTTPS
子域名处理：如果使用子域名，需要在配置中明确指定

// 域名验证工具类
@Component
public class DomainValidator {
    
    private static final List<String> ALLOWED_DOMAINS = Arrays.asList(
        "yourdomain.com",
        "www.yourdomain.com",
        "api.yourdomain.com"
    );
    
    public boolean isDomainAllowed(String url) {
        try {
            URI uri = new URI(url);
            String host = uri.getHost();
            return ALLOWED_DOMAINS.contains(host);
        } catch (URISyntaxException e) {
            return false;
        }
    }
}

三、微博分享功能实现

3.1 微博开放平台接入流程

3.1.1 应用配置

在微博开放平台创建应用后，需要配置：

授权回调页：必须与代码中配置的回调地址一致
应用领域：根据实际应用场景选择
权限申请：申请分享相关权限

3.1.2 SDK集成

微博官方提供Java SDK，也可以使用开源的weibo4j。

Maven依赖配置：

<dependency>
    <groupId>org.weibo4j</groupId>
    <artifactId>weibo4j</artifactId>
    <version>2.1.1</version>
</dependency>

3.2 微博分享代码实现

3.2.1 配置类创建

@Configuration
public class WeiboConfig {
    
    @Value("${weibo.app-key}")
    private String appKey;
    
    @Value("${weibo.app-secret}")
    private String appSecret;
    
    @Value("${weibo.redirect-uri}")
    private String redirectUri;
    
    @Bean
    public WeiboClient weiboClient() {
        return new WeiboClient(appKey, appSecret, redirectUri);
    }
}

3.2.2 分享服务类实现

@Service
public class WeiboShareService {
    
    @Autowired
    private WeiboClient weiboClient;
    
    /**
     * 获取微博授权URL
     */
    public String getAuthorizeUrl() {
        return weiboClient.getAuthorizeUrl();
    }
    
    /**
     * 使用授权码获取Access Token
     */
    public String getAccessToken(String code) {
        try {
            OAuth2Token token = weiboClient.getOAuth2Token(code);
            return token.getAccessToken();
        } catch (WeiboException e) {
            throw new RuntimeException("获取微博Access Token失败", e);
        }
    }
    
    /**
     * 分享内容到微博
     */
    public void shareToWeibo(String accessToken, String content, String imageUrl) {
        try {
            // 设置Access Token
            weiboClient.setToken(accessToken);
            
            // 创建分享请求
            StatusUpdate statusUpdate = new StatusUpdate(content);
            
            // 如果有图片，上传并绑定
            if (imageUrl != null && !imageUrl.isEmpty()) {
                // 上传图片
                UploadedMedia media = weiboClient.uploadMedia(imageUrl);
                statusUpdate.setMediaIds(media.getMediaId());
            }
            
            // 发布微博
            Status status = weiboClient.updateStatus(statusUpdate);
            
            logger.info("微博分享成功，ID: {}", status.getId());
            
        } catch (WeiboException e) {
            throw new RuntimeException("微博分享失败", e);
        }
    }
    
    /**
     * 分享带链接的内容
     */
    public void shareWithLink(String accessToken, String content, String linkUrl) {
        try {
            weiboClient.setToken(accessToken);
            
            // 微博内容中包含链接
            String fullContent = content + " " + linkUrl;
            
            StatusUpdate statusUpdate = new StatusUpdate(fullContent);
            Status status = weiboClient.updateStatus(statusUpdate);
            
            logger.info("带链接的微博分享成功，ID: {}", status.getId());
            
        } catch (WeiboException e) {
            throw new RuntimeException("微博分享失败", e);
        }
    }
}

3.2.3 控制器层实现

@RestController
@RequestMapping("/api/weibo")
public class WeiboShareController {
    
    @Autowired
    private WeiboShareService weiboShareService;
    
    /**
     * 获取微博授权URL
     */
    @GetMapping("/authorize-url")
    public ResponseEntity<String> getAuthorizeUrl() {
        return ResponseEntity.ok(weiboShareService.getAuthorizeUrl());
    }
    
    /**
     * 微博授权回调处理
     */
    @GetMapping("/callback")
    public ResponseEntity<?> handleCallback(@RequestParam String code) {
        try {
            // 获取Access Token
            String accessToken = weiboShareService.getAccessToken(code);
            
            // 返回Token给前端，前端可存储用于后续分享
            Map<String, String> result = new HashMap<>();
            result.put("accessToken", accessToken);
            
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(Collections.singletonMap("error", e.getMessage()));
        }
    }
    
    /**
     * 执行微博分享
     */
    @PostMapping("/share")
    public ResponseEntity<?> share(@RequestBody ShareRequest request) {
        try {
            if (request.getImageUrl() != null) {
                weiboShareService.shareToWeibo(
                    request.getAccessToken(),
                    request.getContent(),
                    request.getImageUrl()
                );
            } else {
                weiboShareService.shareWithLink(
                    request.getAccessToken(),
                    request.getContent(),
                    request.getLinkUrl()
                );
            }
            
            return ResponseEntity.ok(Collections.singletonMap("success", true));
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(Collections.singletonMap("error", e.getMessage()));
        }
    }
}

// 请求对象
class ShareRequest {
    private String accessToken;
    private String content;
    private String imageUrl;
    private String linkUrl;
    
    // getters and setters
}

3.3 微博回调处理

3.3.1 回调控制器实现

@RestController
@RequestMapping("/api/weibo/callback")
public class WeiboCallbackController {
    
    /**
     * 微博授权回调处理
     */
    @GetMapping
    public String handleAuthorizeCallback(@RequestParam String code,
                                          @RequestParam String state) {
        // 验证state参数，防止CSRF攻击
        if (!validateState(state)) {
            return "Invalid state parameter";
        }
        
        // 这里通常会重定向到前端页面，并携带code
        // 或者直接在后端处理获取Token并返回
        return "授权成功，请使用code获取Access Token";
    }
    
    private boolean validateState(String state) {
        // 实现state验证逻辑
        // 通常与session中的state对比
        return true;
    }
}

3.4 微博权限验证难题解决方案

3.4.1 Access Token过期问题

问题描述：微博Access Token有效期较短（通常30天），过期后无法分享。

解决方案：

Token刷新机制：实现Token自动刷新
Token存储策略：安全存储和管理Token
过期时间检查：调用前检查Token是否过期

@Service
public class WeiboTokenManager {
    
    @Autowired
    private WeiboClient weiboClient;
    
    /**
     * 刷新Access Token
     */
    public String refreshToken(String refreshToken) {
        try {
            OAuth2Token token = weiboClient.refreshOAuth2Token(refreshToken);
            return token.getAccessToken();
        } catch (WeiboException e) {
            throw new RuntimeException("刷新微博Token失败", e);
        }
    }
    
    /**
     * 检查Token是否有效
     */
    public boolean isTokenValid(String accessToken) {
        try {
            weiboClient.setToken(accessToken);
            // 调用一个简单的API验证Token
            weiboClient.verifyCredentials();
            return true;
        } catch (WeiboException e) {
            return false;
        }
    }
}

3.4.2 分享频率限制

问题描述：微博对分享频率有限制，频繁调用会导致接口被封禁。

解决方案：

请求队列：实现请求队列，控制调用频率
指数退避：失败时采用指数退避策略
用户级限流：按用户维度限制分享频率

@Component
public class WeiboRateLimiter {
    
    private final Map<String, Queue<Long>> userRequestMap = new ConcurrentHashMap<>();
    private static final int MAX_REQUESTS_PER_MINUTE = 10;
    private static final long TIME_WINDOW = 60000; // 1分钟
    
    public boolean allowRequest(String userId) {
        long now = System.currentTimeMillis();
        Queue<Long> timestamps = userRequestMap.computeIfAbsent(userId, k -> new LinkedList<>());
        
        // 清理过期的请求记录
        while (!timestamps.isEmpty() && now - timestamps.peek() > TIME_WINDOW) {
            timestamps.poll();
        }
        
        if (timestamps.size() < MAX_REQUESTS_PER_MINUTE) {
            timestamps.offer(now);
            return true;
        }
        
        return false;
    }
}

四、完整集成示例

4.1 统一分享服务接口

为了方便管理，可以创建统一的分享服务接口：

public interface ShareService {
    /**
     * 获取分享配置
     */
    Map<String, String> getShareConfig(String platform, String url);
    
    /**
     * 获取授权URL
     */
    String getAuthorizeUrl(String platform);
    
    /**
     * 处理授权回调
     */
    String handleCallback(String platform, String code);
    
    /**
     * 执行分享
     */
    void share(String platform, String accessToken, String content, String... params);
}

4.2 统一实现类

@Service
public class UnifiedShareServiceImpl implements ShareService {
    
    @Autowired
    private WechatShareService wechatShareService;
    
    @Autowired
    private WeiboShareService weiboShareService;
    
    @Override
    public Map<String, String> getShareConfig(String platform, String url) {
        switch (platform.toLowerCase()) {
            case "wechat":
                return wechatShareService.getShareConfig(url);
            case "weibo":
                // 微博不需要特殊配置，返回空Map
                return new HashMap<>();
            default:
                throw new IllegalArgumentException("不支持的平台: " + platform);
        }
    }
    
    @Override
    public String getAuthorizeUrl(String platform) {
        switch (platform.toLowerCase()) {
            case "wechat":
                // 微信公众号授权URL
                return wechatShareService.getAuthorizeUrl();
            case "weibo":
                return weiboShareService.getAuthorizeUrl();
            default:
                throw new IllegalArgumentException("不支持的平台: " + platform);
        }
    }
    
    @Override
    public String handleCallback(String platform, String code) {
        switch (platform.toLowerCase()) {
            case "wechat":
                return wechatShareService.handleCallback(code);
            case "weibo":
                return weiboShareService.getAccessToken(code);
            default:
                throw new IllegalArgumentException("不支持的平台: " + platform);
        }
    }
    
    @Override
    public void share(String platform, String accessToken, String content, String... params) {
        switch (platform.toLowerCase()) {
            case "wechat":
                // 微信分享通常在前端完成，后端主要提供配置
                throw new UnsupportedOperationException("微信分享请在前端使用JS-SDK");
            case "weibo":
                if (params.length > 0 && params[0] != null) {
                    weiboShareService.shareToWeibo(accessToken, content, params[0]);
                } else {
                    weiboShareService.shareWithLink(accessToken, content, params.length > 1 ? params[1] : null);
                }
                break;
            default:
                throw new IllegalArgumentException("不支持的平台: " + platform);
        }
    }
}

4.3 安全考虑

4.3.1 Token安全存储

@Service
public class TokenStorageService {
    
    /**
     * 使用Redis存储Token（推荐）
     */
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    public void storeToken(String userId, String platform, String accessToken, String refreshToken, long expiresIn) {
        String key = "token:" + platform + ":" + userId;
        
        // 存储Access Token
        redisTemplate.opsForValue().set(key + ":access", accessToken, expiresIn, TimeUnit.SECONDS);
        
        // 存储Refresh Token（如果有）
        if (refreshToken != null) {
            redisTemplate.opsForValue().set(key + ":refresh", refreshToken, 30, TimeUnit.DAYS);
        }
    }
    
    public String getToken(String userId, String platform) {
        String key = "token:" + platform + ":" + userId + ":access";
        return redisTemplate.opsForValue().get(key);
    }
    
    /**
     * 使用数据库存储（备选方案）
     */
    @Autowired
    private UserTokenRepository userTokenRepository;
    
    public void storeTokenInDB(Long userId, String platform, String accessToken, String refreshToken) {
        UserToken token = new UserToken();
        token.setUserId(userId);
        token.setPlatform(platform);
        token.setAccessToken(accessToken);
        token.setRefreshToken(refreshToken);
        token.setExpiresAt(LocalDateTime.now().plusDays(30));
        
        userTokenRepository.save(token);
    }
}

4.3.2 CSRF防护

@Component
public class CsrfProtectionService {
    
    private static final SecureRandom random = new SecureRandom();
    
    /**
     * 生成CSRF Token
     */
    public String generateToken(String sessionKey) {
        byte[] bytes = new byte[32];
        random.nextBytes(bytes);
        String token = Base64.getEncoder().encodeToString(bytes);
        
        // 存储到Redis，有效期1小时
        redisTemplate.opsForValue().set("csrf:" + sessionKey, token, 1, TimeUnit.HOURS);
        
        return token;
    }
    
    /**
     * 验证CSRF Token
     */
    public boolean validateToken(String sessionKey, String token) {
        String storedToken = redisTemplate.opsForValue().get("csrf:" + sessionKey);
        return storedToken != null && storedToken.equals(token);
    }
}

五、常见问题与解决方案

5.1 微信分享问题

5.1.1 “config:invalid signature”错误

可能原因：

URL不正确（包含#部分）
时间戳过期
jsapi_ticket过期
域名未配置

解决方案：

// 完整的签名验证调试方法
public String debugSignature(String url) {
    try {
        String ticket = wxMpService.getJsApiTicket();
        String nonceStr = UUID.randomUUID().toString();
        String timestamp = String.valueOf(System.currentTimeMillis() / 1000);
        
        // 打印调试信息
        System.out.println("Ticket: " + ticket);
        System.out.println("NonceStr: " + nonceStr);
        System.out.println("Timestamp: " + timestamp);
        System.out.println("URL: " + url);
        
        String signature = generateSignature(ticket, nonceStr, timestamp, url);
        System.out.println("Signature: " + signature);
        
        return signature;
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

5.1.2 分享内容不显示或显示错误

解决方案：

检查分享内容格式：微信对分享标题、描述、图片有严格限制
图片URL必须是CDN链接：不能使用本地图片或未备案的域名
HTTPS要求：所有资源必须使用HTTPS

5.2 微博分享问题

5.2.1 “access token expired”错误

解决方案：

// 自动刷新Token的包装类
public class SafeWeiboClient {
    
    private final WeiboClient client;
    private final TokenStorageService tokenStorage;
    
    public <T> T executeWithTokenRefresh(String userId, Supplier<T> operation) {
        try {
            return operation.get();
        } catch (WeiboException e) {
            if (e.getErrorCode() == 21327) { // Token过期错误码
                // 刷新Token
                String refreshToken = tokenStorage.getRefreshToken(userId);
                String newAccessToken = client.refreshOAuth2Token(refreshToken).getAccessToken();
                
                // 更新存储
                tokenStorage.updateAccessToken(userId, newAccessToken);
                
                // 重试操作
                client.setToken(newAccessToken);
                return operation.get();
            }
            throw e;
        }
    }
}

5.2.2 分享内容被过滤

解决方案：

内容合规性检查：分享前检查内容是否包含敏感词
避免频繁相同内容：相同内容连续分享会被限制
添加随机元素：在内容末尾添加随机字符或表情

六、测试与部署

6.1 单元测试

@SpringBootTest
class ShareServiceTest {
    
    @Autowired
    private WechatShareService wechatShareService;
    
    @Autowired
    private WeiboShareService weiboShareService;
    
    @Test
    void testWechatShareConfig() {
        String url = "https://yourdomain.com/share-page";
        Map<String, String> config = wechatShareService.getShareConfig(url);
        
        assertNotNull(config.get("appId"));
        assertNotNull(config.get("signature"));
        assertEquals(4, config.size());
    }
    
    @Test
    void testWeiboShare() {
        // 使用测试Token
        String testToken = "test_access_token";
        
        assertThrows(RuntimeException.class, () -> {
            weiboShareService.shareToWeibo(testToken, "测试分享内容", null);
        });
    }
}

6.2 部署配置

6.2.1 Nginx配置（HTTPS强制）

server {
    listen 80;
    server_name yourdomain.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl;
    server_name yourdomain.com;
    
    ssl_certificate /path/to/cert.pem;
    ssl_certificate_key /path/to/key.pem;
    
    location /api/ {
        proxy_pass http://localhost:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

6.2.2 Spring Boot配置

# application.yml
wechat:
  app-id: ${WECHAT_APP_ID}
  app-secret: ${WECHAT_APP_SECRET}
  token: ${WECHAT_TOKEN}
  aes-key: ${WECHAT_AES_KEY}
  
weibo:
  app-key: ${WEIBO_APP_KEY}
  app-secret: ${WEIBO_APP_SECRET}
  redirect-uri: ${WEIBO_REDIRECT_URI}

# Redis配置（用于Token存储）
spring:
  redis:
    host: localhost
    port: 6379
    timeout: 5000ms

七、最佳实践与性能优化

7.1 缓存策略

@Service
public class CacheService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    /**
     * 缓存微信Ticket
     */
    public void cacheJsApiTicket(String ticket, long expiresIn) {
        redisTemplate.opsForValue().set("wechat:jsapi_ticket", ticket, expiresIn - 300, TimeUnit.SECONDS);
    }
    
    public String get_cachedJsApiTicket() {
        return (String) redisTemplate.opsForValue().get("wechat:jsapi_ticket");
    }
    
    /**
     * 缓存微博Token
     */
    public void cacheWeiboToken(String userId, String accessToken, long expiresIn) {
        String key = "weibo:token:" + userId;
        redisTemplate.opsForValue().set(key, accessToken, expiresIn - 300, TimeUnit.SECONDS);
    }
}

7.2 异步处理

@Service
public class AsyncShareService {
    
    @Async("shareTaskExecutor")
    public CompletableFuture<Void> asyncShareToWeibo(String accessToken, String content) {
        return CompletableFuture.runAsync(() -> {
            try {
                weiboShareService.shareToWeibo(accessToken, content, null);
            } catch (Exception e) {
                logger.error("异步分享失败", e);
                // 记录失败日志，可重试
            }
        });
    }
}

7.3 监控与日志

@Component
public class ShareMetrics {
    
    private final MeterRegistry meterRegistry;
    
    public ShareMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }
    
    public void recordShareSuccess(String platform) {
        meterRegistry.counter("share.success", "platform", platform).increment();
    }
    
    public void recordShareFailure(String platform, String error) {
        meterRegistry.counter("share.failure", "platform", platform, "error", error).increment();
    }
    
    public void recordShareDuration(String platform, long duration) {
        meterRegistry.timer("share.duration", "platform", platform).record(duration, TimeUnit.MILLISECONDS);
    }
}

八、总结

本文详细介绍了使用Java实现微信和微博分享功能的完整流程，从前期准备、SDK集成、回调配置到权限验证，涵盖了开发者可能遇到的各种问题和解决方案。

关键要点总结：

前期准备：确保开发者账号和应用配置正确，特别是回调域和域名配置
SDK选择：推荐使用成熟的开源SDK，如WxJava和weibo4j
回调处理：正确实现回调验证和消息处理，注意安全性
权限验证：处理Token过期、频率限制等常见问题
安全考虑：Token的安全存储、CSRF防护、内容合规性检查
性能优化：合理使用缓存、异步处理、监控告警

通过本文的指导，开发者应该能够独立完成微信和微博分享功能的集成，并解决常见的回调配置和权限验证问题。在实际开发中，建议根据具体业务需求调整实现细节，并持续关注平台API的更新变化。# Java实现微信微博分享全攻略：从零基础到集成SDK的完整指南，解决回调配置与权限验证难题

引言：移动互联网时代的分享功能重要性

一、前期准备与基础概念

1.1 开发者账号注册与应用创建

在开始代码开发之前，首先需要完成开发者账号的注册和应用的创建。

微信开放平台账号注册：

访问微信开放平台
注册开发者账号（需要企业资质，个人开发者可考虑使用微信公众号平台）
完成开发者资质认证
创建网站应用，获取AppID和AppSecret

微博开放平台账号注册：

访问微博开放平台
注册开发者账号
创建应用，获取App Key和App Secret

1.2 分享功能技术原理

微信和微博的分享功能主要基于OAuth2.0授权机制和SDK封装的API调用。其核心流程如下：

用户授权：用户点击分享按钮，引导用户跳转至微信/微博授权页面
获取授权码：用户授权后，平台回调应用配置的回调地址，并附带授权码
获取访问令牌：应用使用授权码换取Access Token
执行分享操作：使用Access Token调用分享API
处理回调：接收平台的回调通知，处理分享结果

1.3 开发环境要求

Java 8或更高版本
Maven或Gradle构建工具
Spring Boot框架（推荐，非必须）
网络请求库（如OkHttp、Apache HttpClient）

二、微信分享功能实现

2.1 微信开放平台接入流程

2.1.1 应用配置

在微信开放平台创建应用后，需要配置以下信息：

授权回调域：必须填写域名，且与实际部署的域名一致
网页授权域名：用于H5页面授权
JS接口安全域名：用于微信JS-SDK

2.1.2 SDK集成

推荐使用官方提供的微信Java SDK，这是一个功能完善的开源SDK。

Maven依赖配置：

<dependency>
    <groupId>com.github.binarywang</groupId>
    <artifactId>weixin-java-common</artifactId>
    <version>4.4.0</version>
</dependency>
<dependency>
    <groupId>com.github.binarywang</groupId>
    <artifactId>weixin-java-mp</artifactId>
    <version>4.4.0</version>
</dependency>

2.2 微信分享代码实现

2.2.1 配置类创建

首先创建微信配置类，封装AppID和AppSecret等配置信息：

@Configuration
public class WechatConfig {
    
    @Value("${wechat.app-id}")
    private String appId;
    
    @Value("${wechat.app-secret}")
    private String appSecret;
    
    @Value("${wechat.token}")
    private String token;
    
    @Value("${wechat.aes-key}")
    private String aesKey;
    
    @Bean
    public WxMpService wxMpService() {
        WxMpServiceImpl wxMpService = new WxMpServiceImpl();
        wxMpService.setWxMpConfigStorage(new WxMpDefaultConfigImpl() {{
            setAppId(appId);
            setSecret(appSecret);
            setToken(token);
            setAesKey(aesKey);
        }});
        return wxMpService;
    }
}

2.2.2 分享服务类实现

创建微信分享服务类，处理分享逻辑：

@Service
public class WechatShareService {
    
    @Autowired
    private WxMpService wxMpService;
    
    /**
     * 获取微信分享配置参数
     * @param url 当前页面URL
     * @return 微信分享配置
     */
    public Map<String, String> getShareConfig(String url) {
        try {
            // 获取微信JS-SDK的ticket
            String ticket = wxMpService.getJsApiTicket();
            // 生成签名
            String nonceStr = UUID.randomUUID().toString();
            String timestamp = String.valueOf(System.currentTimeMillis() / 1000);
            
            String signature = generateSignature(ticket, nonceStr, timestamp, url);
            
            Map<String, String> config = new HashMap<>();
            config.put("appId", wxMpService.getWxMpConfigStorage().getAppId());
            config.put("timestamp", timestamp);
            config.put("nonceStr", nonceStr);
            config.put("signature", signature);
            
            return config;
        } catch (Exception e) {
            throw new RuntimeException("获取微信分享配置失败", e);
        }
    }
    
    /**
     * 生成微信签名
     */
    private String generateSignature(String ticket, String nonceStr, String timestamp, String url) {
        String string1 = "jsapi_ticket=" + ticket +
                        "&noncestr=" + nonceStr +
                        "&timestamp=" + timestamp +
                        "&url=" + url;
        
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-1");
            byte[] digest = md.digest(string1.getBytes(StandardCharsets.UTF_8));
            return bytesToHex(digest);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("签名生成失败", e);
        }
    }
    
    private String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }
}

2.2.3 控制器层实现

创建控制器处理前端分享请求：

@RestController
@RequestMapping("/api/wechat")
public class WechatShareController {
    
    @Autowired
    private WechatShareService wechatShareService;
    
    /**
     * 获取微信JS-SDK配置
     */
    @GetMapping("/share-config")
    public ResponseEntity<Map<String, String>> getShareConfig(@RequestParam String url) {
        try {
            Map<String, String> config = wechatShareService.getShareConfig(url);
            return ResponseEntity.ok(config);
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(Collections.singletonMap("error", e.getMessage()));
        }
    }
}

2.3 微信回调处理

2.3.1 回调控制器实现

微信回调主要用于接收分享结果通知，需要实现消息接收和验证：

@RestController
@RequestMapping("/api/wechat/callback")
public class WechatCallbackController {
    
    @Autowired
    private WxMpService wxMpService;
    
    /**
     * 微信回调验证接口
     */
    @GetMapping
    public String verifyCallback(@RequestParam String signature,
                                 @RequestParam String timestamp,
                                 @RequestParam String nonce,
                                 @RequestParam String echostr) {
        if (wxMpService.checkSignature(timestamp, nonce, signature)) {
            return echostr;
        }
        return "invalid";
    }
    
    /**
     * 微信回调处理接口
     */
    @PostMapping
    public String handleCallback(HttpServletRequest request) {
        try {
            // 解析微信消息
            String xml = IOUtils.toString(request.getInputStream(), StandardCharsets.UTF_8);
            WxMpXmlMessage message = WxMpXmlMessage.fromXml(xml);
            
            // 处理分享结果消息
            if ("event".equals(message.getMsgType()) && "SHARE".equals(message.getEvent())) {
                handleShareResult(message);
            }
            
            // 返回成功响应
            return "<xml><return_code><![CDATA[SUCCESS]]></return_code></xml>";
        } catch (Exception e) {
            return "<xml><return_code><![CDATA[FAIL]]></return_code></xml>";
        }
    }
    
    private void handleShareResult(WxMpXmlMessage message) {
        // 处理分享结果，记录日志、更新状态等
        String openId = message.getFromUser();
        String shareId = message.getEventKey();
        // TODO: 业务逻辑处理
    }
}

2.4 微信权限验证难题解决方案

2.4.1 签名验证问题

问题描述：前端获取的签名与后端生成的签名不一致，导致JS-SDK初始化失败。

解决方案：

URL标准化：确保前后端使用的URL完全一致，注意#后面的部分
时间戳校验：检查服务器时间是否与微信服务器时间同步
Ticket缓存：合理缓存jsapi_ticket，避免频繁调用

// 优化后的签名生成方法，增加URL标准化处理
public String getNormalizedUrl(String url) {
    // 去除URL中的#及后面的部分
    int hashIndex = url.indexOf("#");
    if (hashIndex != -1) {
        url = url.substring(0, hashIndex);
    }
    // 去除重复的斜杠
    return url.replaceAll("/+", "/");
}

2.4.2 域名验证问题

问题描述：微信提示”无效的域名”或”域名未配置”。

解决方案：

检查域名配置：确保在微信开放平台配置的域名与实际访问域名完全一致
HTTPS要求：微信要求分享页面必须使用HTTPS
子域名处理：如果使用子域名，需要在配置中明确指定

// 域名验证工具类
@Component
public class DomainValidator {
    
    private static final List<String> ALLOWED_DOMAINS = Arrays.asList(
        "yourdomain.com",
        "www.yourdomain.com",
        "api.yourdomain.com"
    );
    
    public boolean isDomainAllowed(String url) {
        try {
            URI uri = new URI(url);
            String host = uri.getHost();
            return ALLOWED_DOMAINS.contains(host);
        } catch (URISyntaxException e) {
            return false;
        }
    }
}

三、微博分享功能实现

3.1 微博开放平台接入流程

3.1.1 应用配置

在微博开放平台创建应用后，需要配置：

授权回调页：必须与代码中配置的回调地址一致
应用领域：根据实际应用场景选择
权限申请：申请分享相关权限

3.1.2 SDK集成

微博官方提供Java SDK，也可以使用开源的weibo4j。

Maven依赖配置：

<dependency>
    <groupId>org.weibo4j</groupId>
    <artifactId>weibo4j</artifactId>
    <version>2.1.1</version>
</dependency>

3.2 微博分享代码实现

3.2.1 配置类创建

@Configuration
public class WeiboConfig {
    
    @Value("${weibo.app-key}")
    private String appKey;
    
    @Value("${weibo.app-secret}")
    private String appSecret;
    
    @Value("${weibo.redirect-uri}")
    private String redirectUri;
    
    @Bean
    public WeiboClient weiboClient() {
        return new WeiboClient(appKey, appSecret, redirectUri);
    }
}

3.2.2 分享服务类实现

@Service
public class WeiboShareService {
    
    @Autowired
    private WeiboClient weiboClient;
    
    /**
     * 获取微博授权URL
     */
    public String getAuthorizeUrl() {
        return weiboClient.getAuthorizeUrl();
    }
    
    /**
     * 使用授权码获取Access Token
     */
    public String getAccessToken(String code) {
        try {
            OAuth2Token token = weiboClient.getOAuth2Token(code);
            return token.getAccessToken();
        } catch (WeiboException e) {
            throw new RuntimeException("获取微博Access Token失败", e);
        }
    }
    
    /**
     * 分享内容到微博
     */
    public void shareToWeibo(String accessToken, String content, String imageUrl) {
        try {
            // 设置Access Token
            weiboClient.setToken(accessToken);
            
            // 创建分享请求
            StatusUpdate statusUpdate = new StatusUpdate(content);
            
            // 如果有图片，上传并绑定
            if (imageUrl != null && !imageUrl.isEmpty()) {
                // 上传图片
                UploadedMedia media = weiboClient.uploadMedia(imageUrl);
                statusUpdate.setMediaIds(media.getMediaId());
            }
            
            // 发布微博
            Status status = weiboClient.updateStatus(statusUpdate);
            
            logger.info("微博分享成功，ID: {}", status.getId());
            
        } catch (WeiboException e) {
            throw new RuntimeException("微博分享失败", e);
        }
    }
    
    /**
     * 分享带链接的内容
     */
    public void shareWithLink(String accessToken, String content, String linkUrl) {
        try {
            weiboClient.setToken(accessToken);
            
            // 微博内容中包含链接
            String fullContent = content + " " + linkUrl;
            
            StatusUpdate statusUpdate = new StatusUpdate(fullContent);
            Status status = weiboClient.updateStatus(statusUpdate);
            
            logger.info("带链接的微博分享成功，ID: {}", status.getId());
            
        } catch (WeiboException e) {
            throw new RuntimeException("微博分享失败", e);
        }
    }
}

3.2.3 控制器层实现

@RestController
@RequestMapping("/api/weibo")
public class WeiboShareController {
    
    @Autowired
    private WeiboShareService weiboShareService;
    
    /**
     * 获取微博授权URL
     */
    @GetMapping("/authorize-url")
    public ResponseEntity<String> getAuthorizeUrl() {
        return ResponseEntity.ok(weiboShareService.getAuthorizeUrl());
    }
    
    /**
     * 微博授权回调处理
     */
    @GetMapping("/callback")
    public ResponseEntity<?> handleCallback(@RequestParam String code) {
        try {
            // 获取Access Token
            String accessToken = weiboShareService.getAccessToken(code);
            
            // 返回Token给前端，前端可存储用于后续分享
            Map<String, String> result = new HashMap<>();
            result.put("accessToken", accessToken);
            
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(Collections.singletonMap("error", e.getMessage()));
        }
    }
    
    /**
     * 执行微博分享
     */
    @PostMapping("/share")
    public ResponseEntity<?> share(@RequestBody ShareRequest request) {
        try {
            if (request.getImageUrl() != null) {
                weiboShareService.shareToWeibo(
                    request.getAccessToken(),
                    request.getContent(),
                    request.getImageUrl()
                );
            } else {
                weiboShareService.shareWithLink(
                    request.getAccessToken(),
                    request.getContent(),
                    request.getLinkUrl()
                );
            }
            
            return ResponseEntity.ok(Collections.singletonMap("success", true));
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(Collections.singletonMap("error", e.getMessage()));
        }
    }
}

// 请求对象
class ShareRequest {
    private String accessToken;
    private String content;
    private String imageUrl;
    private String linkUrl;
    
    // getters and setters
}

3.3 微博回调处理

3.3.1 回调控制器实现

@RestController
@RequestMapping("/api/weibo/callback")
public class WeiboCallbackController {
    
    /**
     * 微博授权回调处理
     */
    @GetMapping
    public String handleAuthorizeCallback(@RequestParam String code,
                                          @RequestParam String state) {
        // 验证state参数，防止CSRF攻击
        if (!validateState(state)) {
            return "Invalid state parameter";
        }
        
        // 这里通常会重定向到前端页面，并携带code
        // 或者直接在后端处理获取Token并返回
        return "授权成功，请使用code获取Access Token";
    }
    
    private boolean validateState(String state) {
        // 实现state验证逻辑
        // 通常与session中的state对比
        return true;
    }
}

3.4 微博权限验证难题解决方案

3.4.1 Access Token过期问题

问题描述：微博Access Token有效期较短（通常30天），过期后无法分享。

解决方案：

Token刷新机制：实现Token自动刷新
Token存储策略：安全存储和管理Token
过期时间检查：调用前检查Token是否过期

@Service
public class WeiboTokenManager {
    
    @Autowired
    private WeiboClient weiboClient;
    
    /**
     * 刷新Access Token
     */
    public String refreshToken(String refreshToken) {
        try {
            OAuth2Token token = weiboClient.refreshOAuth2Token(refreshToken);
            return token.getAccessToken();
        } catch (WeiboException e) {
            throw new RuntimeException("刷新微博Token失败", e);
        }
    }
    
    /**
     * 检查Token是否有效
     */
    public boolean isTokenValid(String accessToken) {
        try {
            weiboClient.setToken(accessToken);
            // 调用一个简单的API验证Token
            weiboClient.verifyCredentials();
            return true;
        } catch (WeiboException e) {
            return false;
        }
    }
}

3.4.2 分享频率限制

问题描述：微博对分享频率有限制，频繁调用会导致接口被封禁。

解决方案：

请求队列：实现请求队列，控制调用频率
指数退避：失败时采用指数退避策略
用户级限流：按用户维度限制分享频率

@Component
public class WeiboRateLimiter {
    
    private final Map<String, Queue<Long>> userRequestMap = new ConcurrentHashMap<>();
    private static final int MAX_REQUESTS_PER_MINUTE = 10;
    private static final long TIME_WINDOW = 60000; // 1分钟
    
    public boolean allowRequest(String userId) {
        long now = System.currentTimeMillis();
        Queue<Long> timestamps = userRequestMap.computeIfAbsent(userId, k -> new LinkedList<>());
        
        // 清理过期的请求记录
        while (!timestamps.isEmpty() && now - timestamps.peek() > TIME_WINDOW) {
            timestamps.poll();
        }
        
        if (timestamps.size() < MAX_REQUESTS_PER_MINUTE) {
            timestamps.offer(now);
            return true;
        }
        
        return false;
    }
}

四、完整集成示例

4.1 统一分享服务接口

为了方便管理，可以创建统一的分享服务接口：

public interface ShareService {
    /**
     * 获取分享配置
     */
    Map<String, String> getShareConfig(String platform, String url);
    
    /**
     * 获取授权URL
     */
    String getAuthorizeUrl(String platform);
    
    /**
     * 处理授权回调
     */
    String handleCallback(String platform, String code);
    
    /**
     * 执行分享
     */
    void share(String platform, String accessToken, String content, String... params);
}

4.2 统一实现类

@Service
public class UnifiedShareServiceImpl implements ShareService {
    
    @Autowired
    private WechatShareService wechatShareService;
    
    @Autowired
    private WeiboShareService weiboShareService;
    
    @Override
    public Map<String, String> getShareConfig(String platform, String url) {
        switch (platform.toLowerCase()) {
            case "wechat":
                return wechatShareService.getShareConfig(url);
            case "weibo":
                // 微博不需要特殊配置，返回空Map
                return new HashMap<>();
            default:
                throw new IllegalArgumentException("不支持的平台: " + platform);
        }
    }
    
    @Override
    public String getAuthorizeUrl(String platform) {
        switch (platform.toLowerCase()) {
            case "wechat":
                // 微信公众号授权URL
                return wechatShareService.getAuthorizeUrl();
            case "weibo":
                return weiboShareService.getAuthorizeUrl();
            default:
                throw new IllegalArgumentException("不支持的平台: " + platform);
        }
    }
    
    @Override
    public String handleCallback(String platform, String code) {
        switch (platform.toLowerCase()) {
            case "wechat":
                return wechatShareService.handleCallback(code);
            case "weibo":
                return weiboShareService.getAccessToken(code);
            default:
                throw new IllegalArgumentException("不支持的平台: " + platform);
        }
    }
    
    @Override
    public void share(String platform, String accessToken, String content, String... params) {
        switch (platform.toLowerCase()) {
            case "wechat":
                // 微信分享通常在前端完成，后端主要提供配置
                throw new UnsupportedOperationException("微信分享请在前端使用JS-SDK");
            case "weibo":
                if (params.length > 0 && params[0] != null) {
                    weiboShareService.shareToWeibo(accessToken, content, params[0]);
                } else {
                    weiboShareService.shareWithLink(accessToken, content, params.length > 1 ? params[1] : null);
                }
                break;
            default:
                throw new IllegalArgumentException("不支持的平台: " + platform);
        }
    }
}

4.3 安全考虑

4.3.1 Token安全存储

@Service
public class TokenStorageService {
    
    /**
     * 使用Redis存储Token（推荐）
     */
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    public void storeToken(String userId, String platform, String accessToken, String refreshToken, long expiresIn) {
        String key = "token:" + platform + ":" + userId;
        
        // 存储Access Token
        redisTemplate.opsForValue().set(key + ":access", accessToken, expiresIn, TimeUnit.SECONDS);
        
        // 存储Refresh Token（如果有）
        if (refreshToken != null) {
            redisTemplate.opsForValue().set(key + ":refresh", refreshToken, 30, TimeUnit.DAYS);
        }
    }
    
    public String getToken(String userId, String platform) {
        String key = "token:" + platform + ":" + userId + ":access";
        return redisTemplate.opsForValue().get(key);
    }
    
    /**
     * 使用数据库存储（备选方案）
     */
    @Autowired
    private UserTokenRepository userTokenRepository;
    
    public void storeTokenInDB(Long userId, String platform, String accessToken, String refreshToken) {
        UserToken token = new UserToken();
        token.setUserId(userId);
        token.setPlatform(platform);
        token.setAccessToken(accessToken);
        token.setRefreshToken(refreshToken);
        token.setExpiresAt(LocalDateTime.now().plusDays(30));
        
        userTokenRepository.save(token);
    }
}

4.3.2 CSRF防护

@Component
public class CsrfProtectionService {
    
    private static final SecureRandom random = new SecureRandom();
    
    /**
     * 生成CSRF Token
     */
    public String generateToken(String sessionKey) {
        byte[] bytes = new byte[32];
        random.nextBytes(bytes);
        String token = Base64.getEncoder().encodeToString(bytes);
        
        // 存储到Redis，有效期1小时
        redisTemplate.opsForValue().set("csrf:" + sessionKey, token, 1, TimeUnit.HOURS);
        
        return token;
    }
    
    /**
     * 验证CSRF Token
     */
    public boolean validateToken(String sessionKey, String token) {
        String storedToken = redisTemplate.opsForValue().get("csrf:" + sessionKey);
        return storedToken != null && storedToken.equals(token);
    }
}

五、常见问题与解决方案

5.1 微信分享问题

5.1.1 “config:invalid signature”错误

可能原因：

URL不正确（包含#部分）
时间戳过期
jsapi_ticket过期
域名未配置

解决方案：

// 完整的签名验证调试方法
public String debugSignature(String url) {
    try {
        String ticket = wxMpService.getJsApiTicket();
        String nonceStr = UUID.randomUUID().toString();
        String timestamp = String.valueOf(System.currentTimeMillis() / 1000);
        
        // 打印调试信息
        System.out.println("Ticket: " + ticket);
        System.out.println("NonceStr: " + nonceStr);
        System.out.println("Timestamp: " + timestamp);
        System.out.println("URL: " + url);
        
        String signature = generateSignature(ticket, nonceStr, timestamp, url);
        System.out.println("Signature: " + signature);
        
        return signature;
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

5.1.2 分享内容不显示或显示错误

解决方案：

检查分享内容格式：微信对分享标题、描述、图片有严格限制
图片URL必须是CDN链接：不能使用本地图片或未备案的域名
HTTPS要求：所有资源必须使用HTTPS

5.2 微博分享问题

5.2.1 “access token expired”错误

解决方案：

// 自动刷新Token的包装类
public class SafeWeiboClient {
    
    private final WeiboClient client;
    private final TokenStorageService tokenStorage;
    
    public <T> T executeWithTokenRefresh(String userId, Supplier<T> operation) {
        try {
            return operation.get();
        } catch (WeiboException e) {
            if (e.getErrorCode() == 21327) { // Token过期错误码
                // 刷新Token
                String refreshToken = tokenStorage.getRefreshToken(userId);
                String newAccessToken = client.refreshOAuth2Token(refreshToken).getAccessToken();
                
                // 更新存储
                tokenStorage.updateAccessToken(userId, newAccessToken);
                
                // 重试操作
                client.setToken(newAccessToken);
                return operation.get();
            }
            throw e;
        }
    }
}

5.2.2 分享内容被过滤

解决方案：

内容合规性检查：分享前检查内容是否包含敏感词
避免频繁相同内容：相同内容连续分享会被限制
添加随机元素：在内容末尾添加随机字符或表情

六、测试与部署

6.1 单元测试

@SpringBootTest
class ShareServiceTest {
    
    @Autowired
    private WechatShareService wechatShareService;
    
    @Autowired
    private WeiboShareService weiboShareService;
    
    @Test
    void testWechatShareConfig() {
        String url = "https://yourdomain.com/share-page";
        Map<String, String> config = wechatShareService.getShareConfig(url);
        
        assertNotNull(config.get("appId"));
        assertNotNull(config.get("signature"));
        assertEquals(4, config.size());
    }
    
    @Test
    void testWeiboShare() {
        // 使用测试Token
        String testToken = "test_access_token";
        
        assertThrows(RuntimeException.class, () -> {
            weiboShareService.shareToWeibo(testToken, "测试分享内容", null);
        });
    }
}

6.2 部署配置

6.2.1 Nginx配置（HTTPS强制）

server {
    listen 80;
    server_name yourdomain.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl;
    server_name yourdomain.com;
    
    ssl_certificate /path/to/cert.pem;
    ssl_certificate_key /path/to/key.pem;
    
    location /api/ {
        proxy_pass http://localhost:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

6.2.2 Spring Boot配置

# application.yml
wechat:
  app-id: ${WECHAT_APP_ID}
  app-secret: ${WECHAT_APP_SECRET}
  token: ${WECHAT_TOKEN}
  aes-key: ${WECHAT_AES_KEY}
  
weibo:
  app-key: ${WEIBO_APP_KEY}
  app-secret: ${WEIBO_APP_SECRET}
  redirect-uri: ${WEIBO_REDIRECT_URI}

# Redis配置（用于Token存储）
spring:
  redis:
    host: localhost
    port: 6379
    timeout: 5000ms

七、最佳实践与性能优化

7.1 缓存策略

@Service
public class CacheService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    /**
     * 缓存微信Ticket
     */
    public void cacheJsApiTicket(String ticket, long expiresIn) {
        redisTemplate.opsForValue().set("wechat:jsapi_ticket", ticket, expiresIn - 300, TimeUnit.SECONDS);
    }
    
    public String get_cachedJsApiTicket() {
        return (String) redisTemplate.opsForValue().get("wechat:jsapi_ticket");
    }
    
    /**
     * 缓存微博Token
     */
    public void cacheWeiboToken(String userId, String accessToken, long expiresIn) {
        String key = "weibo:token:" + userId;
        redisTemplate.opsForValue().set(key, accessToken, expiresIn - 300, TimeUnit.SECONDS);
    }
}

7.2 异步处理

@Service
public class AsyncShareService {
    
    @Async("shareTaskExecutor")
    public CompletableFuture<Void> asyncShareToWeibo(String accessToken, String content) {
        return CompletableFuture.runAsync(() -> {
            try {
                weiboShareService.shareToWeibo(accessToken, content, null);
            } catch (Exception e) {
                logger.error("异步分享失败", e);
                // 记录失败日志，可重试
            }
        });
    }
}

7.3 监控与日志

@Component
public class ShareMetrics {
    
    private final MeterRegistry meterRegistry;
    
    public ShareMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }
    
    public void recordShareSuccess(String platform) {
        meterRegistry.counter("share.success", "platform", platform).increment();
    }
    
    public void recordShareFailure(String platform, String error) {
        meterRegistry.counter("share.failure", "platform", platform, "error", error).increment();
    }
    
    public void recordShareDuration(String platform, long duration) {
        meterRegistry.timer("share.duration", "platform", platform).record(duration, TimeUnit.MILLISECONDS);
    }
}

八、总结

关键要点总结：

前期准备：确保开发者账号和应用配置正确，特别是回调域和域名配置
SDK选择：推荐使用成熟的开源SDK，如WxJava和weibo4j
回调处理：正确实现回调验证和消息处理，注意安全性
权限验证：处理Token过期、频率限制等常见问题
安全考虑：Token的安全存储、CSRF防护、内容合规性检查
性能优化：合理使用缓存、异步处理、监控告警

通过本文的指导，开发者应该能够独立完成微信和微博分享功能的集成，并解决常见的回调配置和权限验证问题。在实际开发中，建议根据具体业务需求调整实现细节，并持续关注平台API的更新变化。