com.healthy.common.security.social.SocialConfig Maven / Gradle / Ivy

package com.healthy.common.security.social;

import cn.hutool.core.util.StrUtil;
import com.healthy.common.security.properties.*;
import com.healthy.common.security.social.qq.connet.QQOAuth2ConnectionFactory;
import com.healthy.common.security.social.support.HealthySpringSocialConfigurer;
import com.healthy.common.security.social.support.SocialAuthenticationFilterPostProcessor;
import com.healthy.common.security.social.weibo.connet.WeiboOAuth2ConnectionFactory;
import com.healthy.common.security.social.weixin.connet.WeixinOAuth2ConnectionFactory;
import com.healthy.common.security.social.weixinmp.connet.WeixinMpOAuth2ConnectionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.AutoConfigureOrder;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.security.crypto.encrypt.Encryptors;
import org.springframework.social.UserIdSource;
import org.springframework.social.config.annotation.ConnectionFactoryConfigurer;
import org.springframework.social.config.annotation.EnableSocial;
import org.springframework.social.config.annotation.SocialConfigurerAdapter;
import org.springframework.social.connect.*;
import org.springframework.social.connect.jdbc.JdbcUsersConnectionRepository;
import org.springframework.social.connect.web.ConnectController;
import org.springframework.social.connect.web.ProviderSignInUtils;
import org.springframework.social.security.AuthenticationNameUserIdSource;
import org.springframework.social.security.SpringSocialConfigurer;

import javax.sql.DataSource;

/**
 * 社交登录配置主类
 */
@Configuration
@AutoConfigureOrder(Integer.MIN_VALUE)
@EnableSocial
public class SocialConfig extends SocialConfigurerAdapter {

    @Autowired
    private DataSource dataSource;

    @Autowired
    private SecurityProperties securityProperties;

    @Autowired(required = false)
    private ConnectionSignUp connectionSignUp;

    @Autowired(required = false)
    private SocialAuthenticationFilterPostProcessor socialAuthenticationFilterPostProcessor;

    @Override
    public void addConnectionFactories(ConnectionFactoryConfigurer connectionFactoryConfigurer, Environment environment) {

        QQProperties qq = securityProperties.getSocial().getQq();
        if (StrUtil.isNotBlank(qq.getAppId())) {
            QQOAuth2ConnectionFactory qqoAuth2ConnectionFactory = new QQOAuth2ConnectionFactory(qq.getProviderId(), qq.getAppId(), qq.getAppSecret());
            connectionFactoryConfigurer.addConnectionFactory(qqoAuth2ConnectionFactory);
        }

        WeixinProperties weixinProperties = securityProperties.getSocial().getWeixin();
        if (StrUtil.isNotBlank(weixinProperties.getAppId())) {
            WeixinOAuth2ConnectionFactory weixinOAuth2ConnectionFactory = new WeixinOAuth2ConnectionFactory(weixinProperties.getProviderId(), weixinProperties.getAppId(),
                    weixinProperties.getAppSecret());
            connectionFactoryConfigurer.addConnectionFactory(weixinOAuth2ConnectionFactory);
        }

        WeixinMpProperties weixinMpProperties = securityProperties.getSocial().getWeixinmp();
        if (StrUtil.isNotBlank(weixinMpProperties.getAppId())) {
            WeixinMpOAuth2ConnectionFactory weixinMpOAuth2ConnectionFactory = new WeixinMpOAuth2ConnectionFactory(weixinMpProperties.getProviderId(), weixinMpProperties.getAppId(),
                    weixinMpProperties.getAppSecret());
            connectionFactoryConfigurer.addConnectionFactory(weixinMpOAuth2ConnectionFactory);
        }

        WeiboProperties weiboProperties = securityProperties.getSocial().getWeibo();
        if (StrUtil.isNotBlank(weiboProperties.getAppId())) {
            WeiboOAuth2ConnectionFactory weiboOAuth2ConnectionFactory = new WeiboOAuth2ConnectionFactory(weiboProperties.getProviderId(), weiboProperties.getAppId(), weiboProperties.getAppSecret());
            connectionFactoryConfigurer.addConnectionFactory(weiboOAuth2ConnectionFactory);
        }
    }

    @Override
    public UsersConnectionRepository getUsersConnectionRepository(ConnectionFactoryLocator connectionFactoryLocator) {
        JdbcUsersConnectionRepository repository = new JdbcUsersConnectionRepository(dataSource,
                connectionFactoryLocator, Encryptors.noOpText());

        String jdbcTablePrefix = securityProperties.getSocial().getJdbcTablePrefix();
        if (StrUtil.isNotBlank(jdbcTablePrefix)) {
            repository.setTablePrefix(jdbcTablePrefix);
        }
        if (connectionSignUp != null) {
            repository.setConnectionSignUp(connectionSignUp);
        }
        return repository;
    }

    /**
     * 社交登录配置类，供浏览器或app模块引入设计登录配置用。
     *
     * @return
     */
    @Bean
    public SpringSocialConfigurer healthySocialSecurityConfig() {
        String filterProcessesUrl = securityProperties.getSocial().getFilterProcessesUrl();
        HealthySpringSocialConfigurer configurer = new HealthySpringSocialConfigurer(filterProcessesUrl);
        configurer.signupUrl(securityProperties.getBrowser().getSignUpUrl());
        configurer.setSocialAuthenticationFilterPostProcessor(socialAuthenticationFilterPostProcessor);
        return configurer;
    }

    /**
     * 用来处理注册流程的工具类
     *
     * @param connectionFactoryLocator
     * @return
     */
    @Bean
    public ProviderSignInUtils providerSignInUtils(ConnectionFactoryLocator connectionFactoryLocator) {
        return new ProviderSignInUtils(connectionFactoryLocator, getUsersConnectionRepository(connectionFactoryLocator)) {
        };
    }

    /**
     * Constructs a ConnectController.
     *
     * @param connectionFactoryLocator the locator for {@link ConnectionFactory} instances needed to establish connections
     * @param connectionRepository     the current user's {@link ConnectionRepository} needed to persist connections; must be a proxy to a request-scoped bean
     */
    @Bean
    @ConditionalOnMissingBean({ConnectController.class})
    public ConnectController connectController(ConnectionFactoryLocator connectionFactoryLocator, ConnectionRepository connectionRepository) {
        return new ConnectController(connectionFactoryLocator, connectionRepository);
    }

    @Override
    public UserIdSource getUserIdSource() {
        return new AuthenticationNameUserIdSource();
    }
}