企业内部应用(阿里商旅)集成 钉钉 与 微信 实现SSO单点登陆

已于 2022-10-13 11:07:18 修改
阅读量3k 收藏 8
点赞数 2
分类专栏： SpringBoot 文章标签： 微信 mybatis java
于 2022-10-09 17:19:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JAVAlife2021/article/details/127230440
版权

1.钉钉准备工作

(1) 创建应用

https://open-dev.dingtalk.com/fe/app#/corp/app

img

(2)获取应用凭证

记录 AgentId AppKey AppSecret

img

(3)开通权限

开通需要的权限,并指定范围

img

(4)设置应用首页

构建单点登陆连接可参考 https://open.dingtalk.com/document/orgapp-server/logon-free-third-party-websites

img

(5)发布应用

img

2.微信准备工作

(1)添加应用

img

(2)获取应用凭证

img

并在我的企业中记录企业的CorpIDID

img

(3)设置可信域名

img

(4)设置工作台应用主页

此处设置的即为跳转的连接,将会携带当前授权的用户code

img

3.代码

(1)项目依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>Alibtrip_Sso</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>Alibtrip_Sso</name>
  <description>Alibtrip_Sso</description>

  <properties>
    <java.version>1.8</java.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>com.baomidou</groupId>
      <artifactId>mybatis-plus-boot-starter</artifactId>
      <version>3.4.2</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <optional>true</optional>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
      <exclusions>
        <exclusion>
          <groupId>org.junit.vintage</groupId>
          <artifactId>junit-vintage-engine</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

    <dependency>
      <groupId>com.aliyun</groupId>
      <artifactId>btripopen20220520</artifactId>
      <version>1.0.13</version>
    </dependency>

    <dependency>
      <groupId>com.aliyun</groupId>
      <artifactId>dingtalk</artifactId>
      <version>1.4.43</version>
    </dependency>
    <dependency>
      <groupId>com.aliyun</groupId>
      <artifactId>alibaba-dingtalk-service-sdk</artifactId>
      <version>2.0.0</version>
    </dependency>
    <dependency>
      <groupId>com.github.ben-manes.caffeine</groupId>
      <artifactId>caffeine</artifactId>
      <version>2.9.3</version>
    </dependency>

    <dependency>
      <groupId>commons-httpclient</groupId>
      <artifactId>commons-httpclient</artifactId>
      <version>3.1</version>
    </dependency>
    <dependency>
      <groupId>org.apache.httpcomponents</groupId>
      <artifactId>httpclient</artifactId>
      <version>4.5.13</version>
    </dependency>
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>2.0.13</version>
    </dependency>
    </dependencies>

      <dependencyManagement>
      <dependencies>
      <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-dependencies</artifactId>
      <version>${spring-boot.version}</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
    </dependencies>
    </dependencyManagement>

    </project>

(2)application.properties 配置文件

# 应用名称
spring.application.name=alibtrip_sso

spring.profiles.active=dev

logging.level.root=INFO
logging.level.org.springframework=WARN
logging.level.org.spring.springboot.dao=DEBUG
logging.level.com.accenture.fssc.hdl.mapper=DEBUG
logging.config=classpath:logback-dev.xml
logging.path=./log/alitrip

# 应用服务 WEB 访问端口
server.port=9712

#阿里商旅配置
alibtrip.appKey=
alibtrip.appSecret=
#类型，0-自营 1-分销
alibtrip.corpTokenType=
#企业代理id，值可以在开放平台中的关联企业查看企业代理id。
alibtrip.corpTokenCorpId=


#钉钉配置
dingding.url=
#应用id
dingding.app.agentid=
#应用key
dingding.app.key=
#应用秘钥
dingding.app.secret=


#微信配置
wechat.corpid=
wechat.corpsecret=
wechat.getTokenUri=
wechat.getUserIdUri=
wechat.readUserUri=

(3)Controller 层

AlibtripController
@Slf4j
@RequestMapping("/alibtrip")
@Controller
public class AlibtripController {

    private static final String URL_GET_USERINFO_BY_CODE = "https://oapi.dingtalk.com/sns/getuserinfo_bycode";


    @RequestMapping("/dingding2TripCode")
    public void dingding2TripCode(@RequestParam("code")String code,HttpServletResponse response) {

        try {
            AlibTripService dingdingAlibTrip = (AlibTripService) SpringBeanUtils.getBean("dingdingAlibTrip");
            String redirectUrl = dingdingAlibTrip.invokeAddressGet(code);
            response.sendRedirect(redirectUrl);
        } catch (Exception e) {
            log.error("dingding  重定向 trip出错 {}", e);
        }
    }

    @RequestMapping("/dingding2TripWX")
    public void dingding2TripWX(@RequestParam("code")String code,HttpServletResponse response) {
        try {
            AlibTripService wxAlibTrip = (AlibTripService) SpringBeanUtils.getBean("wxAlibTrip");
            String redirectUrl = wxAlibTrip.invokeAddressGet(code);
            response.sendRedirect(redirectUrl);
        } catch (Exception e) {
            log.error("WX  重定向 trip出错 {}", e);
        }
    }

}

(4)Service层

AbstractDingDing
public abstract class AbstractDingDing {

    public abstract String getAccessToken(String code);

    public abstract String getUserId(String token, String code);
}
AlibTripService
public interface AlibTripService {
    String invokeAddressGet(String param);
}
AlibTripServiceAbstract
@Slf4j
@Component
public abstract class AlibTripServiceAbstract implements AlibTripService{


    @Autowired
    private ClientUtils clientUtils;
    @Autowired
    private CorpTokenUtils corpTokenUtils;

    public abstract String getUserId(String param);

    @Override
    public String invokeAddressGet(String param) {
        String empId = getUserId(param);
        String addressGetUrl = null;
        Client client = clientUtils.getClient();
        String cropToken = corpTokenUtils.getToken();
        AddressGetHeaders addressGetHeaders = new AddressGetHeaders();
        addressGetHeaders.setXAcsBtripSoCorpToken(cropToken);
        AddressGetRequest addressGetRequest = new AddressGetRequest();
        addressGetRequest.setUserId(empId);
        addressGetRequest.setActionType(4);
        try {
            AddressGetResponse addressGetResponse = client.addressGetWithOptions(addressGetRequest, addressGetHeaders, new RuntimeOptions());
            AddressGetResponseBody body = addressGetResponse.body;
            //success的场景
            addressGetUrl = body.module.getUrl();
        } catch (
                TeaException e) {
            String code = e.getCode();
            String msg = e.getMessage();
            Map<String, Object> data = e.getData();
            //failed的场景
        } catch (Exception e) {
            //其他异常处理
            log.error("invokeAddressGet 出错 {}",e);
        }
        return addressGetUrl;
    }
}
AlibTripServiceImpl
@Slf4j
@Service
public class AlibTripServiceImpl implements AlibTripService {

    @Autowired
    private ClientUtils clientUtils;
    @Autowired
    private CorpTokenUtils corpTokenUtils;
    @Autowired
    private WeChatUtil weChatUtil;

    @Autowired
    @Qualifier("oldDingDing")
    private AbstractDingDing abstractDingDing;



    public String dingding2Trip(String code) {
        String accessToken = abstractDingDing.getAccessToken(code);
        String userId = abstractDingDing.getUserId(accessToken, code);
        String addressGet = invokeAddressGet(userId);
        return addressGet;
    }

    public String dingding2TripWX(String code) {
        String accessToekn = weChatUtil.getAccessToekn();
        String userId = weChatUtil.getUserId(accessToekn, code);
        String empId = weChatUtil.getEmpId(accessToekn, userId);
        String addressGet = invokeAddressGet(empId);
        return addressGet;
    }


    @Override
    public String invokeAddressGet(String empId) {
        String addressGetUrl = null;
        Client client = clientUtils.getClient();
        String cropToken = corpTokenUtils.getToken();

        AddressGetHeaders addressGetHeaders = new AddressGetHeaders();
        addressGetHeaders.setXAcsBtripSoCorpToken(cropToken);
        AddressGetRequest addressGetRequest = new AddressGetRequest();
        addressGetRequest.setUserId(empId);
        addressGetRequest.setActionType(4);
        try {
            AddressGetResponse addressGetResponse = client.addressGetWithOptions(addressGetRequest, addressGetHeaders, new RuntimeOptions());
            AddressGetResponseBody body = addressGetResponse.body;
            //success的场景
            addressGetUrl = body.module.getUrl();
        } catch (
                TeaException e) {
            String code = e.getCode();
            String msg = e.getMessage();
            Map<String, Object> data = e.getData();
            //failed的场景
        } catch (Exception e) {
            //其他异常处理
            log.error("invokeAddressGet 出错 {}",e);
        }
        return addressGetUrl;
    }

}
DingDingAlibTripService
@Service("dingdingAlibTrip")
public class DingDingAlibTripService extends AlibTripServiceAbstract {


    @Autowired
    @Qualifier("oldDingDing")
    private AbstractDingDing abstractDingDing;


    @Override
    public String getUserId(String code) {
        String accessToken = abstractDingDing.getAccessToken(code);
        String userId = abstractDingDing.getUserId(accessToken, code);
        return userId;
    }
}
WXAlibTripSevice
@Service("wxAlibTrip")
public class WXAlibTripSevice extends AlibTripServiceAbstract {

    @Autowired
    private WeChatUtil weChatUtil;

    @Override
    public String getUserId(String code) {
        String accessToekn = weChatUtil.getAccessToekn();
        String userId = weChatUtil.getUserId(accessToekn, code);
        String empId = weChatUtil.getEmpId(accessToekn, userId);
        return empId;
    }

}

(5)工具类

AccessTokenUtils
@Slf4j
@Component
public class AccessTokenUtils {

    @Value("${alibtrip.appKey}")
    private String appKey;
    @Value("${alibtrip.appSecret}")
    private String appSecret;

    @Autowired
    private ClientUtils clientUtils;

    private AccessTokenUtils() {
    }

    ;

    private final String key = CacheKeyEnum.ACCESS_TOKEN_KEY.key;

    public String getToken() {
        Object ifPresent = accessTokenCache.getIfPresent(key);
        if (ifPresent == null) {
            synchronized (AccessTokenUtils.class) {
                if (ifPresent == null) {
                    String accessToken = initAccessToken();
                    accessTokenCache.put(key, accessToken);
                    return accessToken;
                }
            }
        }
        return (String) ifPresent;
    }

    private Cache<Object, Object> accessTokenCache = Caffeine.newBuilder().refreshAfterWrite(
            7000000, TimeUnit.MILLISECONDS
    ).build(new CacheLoader<Object, Object>() {
        @Override
        public @Nullable Object reload(@NonNull Object key, @NonNull Object oldValue) throws Exception {
            String corpToken = initAccessToken();
            if (corpToken == null) {
                return accessTokenCache.get(key, null);
            }
            return corpToken;
        }

        @Override
        public @Nullable Object load(Object key) throws Exception {
            String corpToken = initAccessToken();
            if (corpToken == null) {
                return accessTokenCache.get(key, null);
            }
            return corpToken;
        }
    });


    private String initAccessToken() {
        Client client = clientUtils.getClient();
        try {
            AccessTokenRequest accessTokenCache = new AccessTokenRequest();
            accessTokenCache.setAppKey(appKey);
            accessTokenCache.setAppSecret(appSecret);
            AccessTokenResponse accessTokenResponse = client.accessToken(accessTokenCache);
            AccessTokenResponseBody body = accessTokenResponse.body;
            String token = body.getData().token;
            return token;
        } catch (
                TeaException e) {
            String code = e.getCode();
            String msg = e.getMessage();
            Map<String, Object> data = e.getData();
            //failed的场景
            StringBuffer sb = new StringBuffer();
            sb.append(" code : ")
                    .append(code)
                    .append(" msg : ")
                    .append(msg)
                    .append(" data : ")
                    .append(data);
            log.error(sb.toString(), e);
        } catch (Exception e) {
            //其他异常处理
             log.error(LocalDateTime.now() + " initCorpToken ", e);
        }
        return null;
    }

}
ClientUtils
@Component
@Slf4j
public class ClientUtils {

    public  Client client;
    @Value("${alibtrip.appKey}")
    private String appKey;
    @Value("${alibtrip.appSecret}")
    private String appSecret;

    private ClientUtils() {
    }

    private void instanceClient() {
        Config config = new Config();
        config.setAccessKeyId(appKey);
        config.setAccessKeySecret(appSecret);
        config.setProtocol("https");
        config.setEndpoint("btripopen.aliyuncs.com");

        try {
            client = new Client(config);
        } catch (Exception e) {
            e.printStackTrace();
            log.error(LocalDateTime.now() + " initCorpToken ", e);
        }
        //设置签名算法
        client._signatureAlgorithm = "ACS3-HMAC-SHA256";

    }

    public Client getClient()
    {
       if (client==null){
           synchronized (Object.class){
               if (client==null){
                   instanceClient();
               }
           }
       }
       return client;
    }

}
CorpTokenUtils
@Slf4j
@Component
public class CorpTokenUtils {

    @Value("${alibtrip.corpTokenType}")
    private Integer corpTokenType;
    @Value("${alibtrip.corpTokenCorpId}")
    private String corpTokenCorpId;

    @Autowired
    private ClientUtils clientUtils;
    @Autowired
    private AccessTokenUtils accessTokenUtils;

    private CorpTokenUtils() {
    }

    private final String key = CacheKeyEnum.CROP_TOKEN_KEY.key;

    public String getToken() {
        Object ifPresent = corpTokenCache.getIfPresent(key);
        if (ifPresent == null) {
            synchronized (CorpTokenUtils.class) {
                if (ifPresent == null) {
                    String corpToken = initCorpToken();
                    corpTokenCache.put(key, corpToken);
                    return corpToken;
                }
            }
        }
        return (String) ifPresent;
    }

    private Cache<Object, Object> corpTokenCache = Caffeine.newBuilder().refreshAfterWrite(
            7000000, TimeUnit.MILLISECONDS
    ).build(new CacheLoader<Object, Object>() {
        @Override
        public @Nullable Object reload(@NonNull Object key, @NonNull Object oldValue) throws Exception {
            String corpToken = initCorpToken();
            if (corpToken == null) {
                return corpTokenCache.get(key, null);
            }
            return corpToken;
        }

        @Override
        public @Nullable Object load(Object key) throws Exception {
            String corpToken = initCorpToken();
            if (corpToken == null) {
                return corpTokenCache.get(key, null);
            }
            return corpToken;
        }
    });


    private String initCorpToken() {
        Client client = clientUtils.getClient();
        try {
            CorpTokenHeaders corpTokenHeaders = new CorpTokenHeaders();
            String accessTokenUtilsToken = accessTokenUtils.getToken();
            corpTokenHeaders.setXAcsBtripAccessToken(accessTokenUtilsToken);
            CorpTokenRequest corpTokenRequest = new CorpTokenRequest();
            corpTokenRequest.setType(corpTokenType);
            corpTokenRequest.setCorpId(corpTokenCorpId);
            CorpTokenResponse corpTokenResponse = client.corpTokenWithOptions(corpTokenRequest, corpTokenHeaders, new RuntimeOptions());
            CorpTokenResponseBody body = corpTokenResponse.body;
            String token = body.getData().token;
            return token;
        } catch (
                TeaException e) {
            String code = e.getCode();
            String msg = e.getMessage();
            Map<String, Object> data = e.getData();
            //failed的场景
            StringBuffer sb = new StringBuffer();
            sb.append(" code : ")
                    .append(code)
                    .append(" msg : ")
                    .append(msg)
                    .append(" data : ")
                    .append(data);
            log.error(sb.toString(), e);
        } catch (Exception e) {
            //其他异常处理
            log.error(LocalDateTime.now() + " initCorpToken ", e);
        }
        return "";
    }
}
DingDingUtils
@Slf4j
@Component("newDingDing")
public class DingDingUtils extends AbstractDingDing {

    @Value("${dingding.url}")
    private String DING_URL ;
    @Value("${dingding.app.agentid}")
    private String AGENT_ID;
    @Value("${dingding.app.key}")
    private String APP_KEY; // 应用的Key
    @Value("${dingding.app.secret}")
    private String APP_SECRET ; // 应用的密码

    com.aliyun.dingtalkcontact_1_0.Client client1 = null;
    com.aliyun.dingtalkoauth2_1_0.Client client2 = null;


    public static com.aliyun.dingtalkcontact_1_0.Client createClient1() throws Exception {
        Config config = new Config();
        config.protocol = "https";
        config.regionId = "oapi.dingtalk.com";
        return new com.aliyun.dingtalkcontact_1_0.Client(config);
    }


    public static com.aliyun.dingtalkoauth2_1_0.Client createClient2() throws Exception {
        Config config = new Config();
        config.protocol = "https";
        config.regionId = "oapi.dingtalk.com";
        return new com.aliyun.dingtalkoauth2_1_0.Client(config);
    }


    @Override
    public  String getAccessToken(String code) {

        if (client2==null){
            try {
                client2 = DingDingUtils.createClient2();
            } catch (Exception e) {
                log.error("getAccessToken {}",e);
            }
        }
        GetUserTokenRequest getUserTokenRequest = new GetUserTokenRequest()
                .setClientId(APP_KEY)
                .setClientSecret(APP_SECRET)
                .setCode(code)
                .setRefreshToken(code)
                .setGrantType("authorization_code");

        try {
            GetUserTokenResponse userToken = client2.getUserToken(getUserTokenRequest);
            return userToken.getBody().getAccessToken();
        } catch (TeaException err) {
            if (!com.aliyun.teautil.Common.empty(err.code) && !com.aliyun.teautil.Common.empty(err.message)) {
                // err 中含有 code 和 message 属性，可帮助开发定位问题
                log.error("getAccessToken {}",err);
            }

        } catch (Exception _err) {
            TeaException err = new TeaException(_err.getMessage(), _err);
            if (!com.aliyun.teautil.Common.empty(err.code) && !com.aliyun.teautil.Common.empty(err.message)) {
                // err 中含有 code 和 message 属性，可帮助开发定位问题
                log.error("getAccessToken {}",err);
            }

        }
        return "";
    }


    @Override
    public String getUserId(String accessToken, String code) {
        if (client1==null){
            try {
                client1 = DingDingUtils.createClient1();
            } catch (Exception e) {
                log.error("getAccessToken {}",e);
            }
        }

        try {
            GetUserHeaders headers = new GetUserHeaders();
            headers.setXAcsDingtalkAccessToken(accessToken);
            GetUserResponse userWithOptions = client1.getUserWithOptions("me", headers, new RuntimeOptions());
            GetUserResponseBody userWithOptionsBody = userWithOptions.getBody();
            String unionId = userWithOptions.body.unionId;
        } catch (TeaException err) {
            if (!Common.empty(err.code) && !Common.empty(err.message)) {
                // err 中含有 code 和 message 属性，可帮助开发定位问题
                log.error("getAccessToken {}",err);
            }

        } catch (Exception _err) {
            TeaException err = new TeaException(_err.getMessage(), _err);
            if (!Common.empty(err.code) && !Common.empty(err.message)) {
                // err 中含有 code 和 message 属性，可帮助开发定位问题
                log.error("getAccessToken {}",err);
            }
        }
        return "";
    }


}
HttpClientUtil
@Component
@Slf4j
public class HttpClientUtil {

	CloseableHttpClient httpclient = null;
	CloseableHttpResponse response = null;

	HttpRequestRetryHandler requestRetryHandler=new HttpRequestRetryHandler() {

		@Override
		public boolean retryRequest(IOException exception, int executionCount, HttpContext context) {
			if (executionCount > 3) //超过重试次数，就放弃
				return false;
			if (exception instanceof NoHttpResponseException) {//没有响应，重试
				return true;
			}else if (exception instanceof ConnectTimeoutException) {//连接超时，重试
				return true;
			} else if (exception instanceof SocketTimeoutException) {//连接或读取超时，重试
				return true;
			}else if (exception instanceof SSLHandshakeException) {//本地证书异常
				return false;
			} else if (exception instanceof InterruptedIOException) {//被中断
				return false;
			} else if (exception instanceof UnknownHostException) {//找不到服务器
				return false;
			}  else if (exception instanceof SSLException) {//SSL异常
				return false;
			} else {
				log.info("出现异常");
			}
			HttpClientContext clientContext = HttpClientContext.adapt(context);
			HttpRequest request = clientContext.getRequest();
			// 如果请求是幂等的，则重试
			if (!(request instanceof HttpEntityEnclosingRequest)) return true;
			return false;
		}
	};

	public String doGet(String url, Map<String, String> map) {
		String returnJson = "";
		try {
			RequestConfig globalConfig = RequestConfig.custom()
					.setSocketTimeout(10000)
					.setConnectTimeout(10000)
					.setCookieSpec(CookieSpecs.IGNORE_COOKIES).build();
			httpclient = HttpClients.custom()
					.setRetryHandler(requestRetryHandler)
					.setDefaultRequestConfig(globalConfig).build();
			HttpGet httpGet = new HttpGet(url);
//			httpGet.setProtocolVersion(HttpVersion.HTTP_1_0);
//			httpGet.addHeader(HTTP.CONN_DIRECTIVE, HTTP.CONN_CLOSE);
			// httpGet.addHeader(HTTP.CONTENT_TYPE,
			// "application/x-www-form-urlencoded;charset=UTF-8");
			for (String key : map.keySet()) {
				httpGet.addHeader(key, map.get(key));
			}

			response = httpclient.execute(httpGet);

			HttpEntity entity = response.getEntity();
			if (entity != null) {
				returnJson = "" + EntityUtils.toString(entity, "UTF-8");
			}
			log.info(returnJson);
		} catch (Exception e) {
			log.error("连接超时",e);
			throw new RuntimeException(e);
		}
		finally {
			closeHttp();
		}
		return returnJson;
	}

	public String doPost(String url, String data,
			Map<String, String> headermap, Map<String, String> bodymap) {
		String returnJson = "";
		try {
			RequestConfig globalConfig = RequestConfig.custom()
					.setSocketTimeout(10000)
					.setConnectTimeout(10000)
					.setCookieSpec(CookieSpecs.IGNORE_COOKIES).build();
			//客户端请求
			httpclient = HttpClients.custom()
					.setRetryHandler(requestRetryHandler)
					.setDefaultRequestConfig(globalConfig).build();

			HttpPost httpPost = new HttpPost(url);
			// 设置header
			if (bodymap != null) {
				for (String key : headermap.keySet()) {
					httpPost.addHeader(key, headermap.get(key));
				}
			}
			// 设置body
			if (bodymap != null) {
				List<NameValuePair> pairs = new ArrayList<NameValuePair>();
				for (Map.Entry<String, String> entry : bodymap.entrySet()) {
					pairs.add(new BasicNameValuePair(entry.getKey(), entry
							.getValue()));
				}
				httpPost.setEntity(new UrlEncodedFormEntity(pairs, "UTF-8"));
			}
			// 参数动态传入

			// StringEntity se = new StringEntity("data=" + json, "UTF-8");
			if (data != null && !data.equals("")) {
				StringEntity se = new StringEntity(data, "UTF-8");
				se.setContentEncoding("UTF-8");
				se.setContentType("application/json");// 发送json需要设置contentType
				httpPost.setEntity(se);
			}

			response = httpclient.execute(httpPost);

			// 解析返结果
			HttpEntity entity = response.getEntity();
			if (entity != null) {
				returnJson = "" + EntityUtils.toString(entity, "UTF-8");
			}
		} catch (Exception e) {
			log.error("连接超时",e);
			throw new RuntimeException(e);
		}
		finally {
			closeHttp();
		}
		return returnJson;
	}

	public void closeHttp() {
		try {
			if (httpclient != null) {
				httpclient.close();
			}
			if (response != null) {
				response.close();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
OldDingDingUtis
@Slf4j
@Component("oldDingDing")
public class OldDingDingUtis extends AbstractDingDing {

    @Value("${dingding.url}")
    private String DING_URL ;
    @Value("${dingding.app.agentid}")
    private String AGENT_ID;
    @Value("${dingding.app.key}")
    private String APP_KEY; // 应用的Key
    @Value("${dingding.app.secret}")
    private String APP_SECRET ; // 应用的密码

    // 获取钉钉token
    public String getAccessToken() {
        String result = null;
        DefaultDingTalkClient client = new DefaultDingTalkClient(DING_URL + "/gettoken");
        OapiGettokenRequest request = new OapiGettokenRequest();
        request.setAppkey(APP_KEY);
        request.setAppsecret(APP_SECRET);
        request.setHttpMethod("GET");
        try {
            OapiGettokenResponse response = client.execute(request);
            result = response.isSuccess() ? response.getAccessToken() : null;
        } catch (ApiException e) {
            log.error("获取钉钉AccessToken错误 {}" , e);
        }
        return result;
    }


    @Override
    public String getAccessToken(String code) {
        return getAccessToken();
    }

    @Override
    public String getUserId(String token, String code)
    {
        OapiV2UserGetResponse rspGetResponse = null;
        try {
            // 通过临时授权码获取授权用户的个人信息
            DefaultDingTalkClient client2 = new DefaultDingTalkClient("https://oapi.dingtalk.com/sns/getuserinfo_bycode");
            OapiSnsGetuserinfoBycodeRequest reqBycodeRequest = new OapiSnsGetuserinfoBycodeRequest();

            reqBycodeRequest.setTmpAuthCode(code);
            OapiSnsGetuserinfoBycodeResponse bycodeResponse = client2.execute(reqBycodeRequest, APP_KEY, APP_SECRET);

            // 根据unionid获取userid
            String unionid = bycodeResponse.getUserInfo().getUnionid();
            DingTalkClient clientDingTalkClient = new DefaultDingTalkClient("https://oapi.dingtalk.com/topapi/user/getbyunionid");
            OapiUserGetbyunionidRequest reqGetbyunionidRequest = new OapiUserGetbyunionidRequest();
            reqGetbyunionidRequest.setUnionid(unionid);
            OapiUserGetbyunionidResponse oapiUserGetbyunionidResponse = clientDingTalkClient.execute(reqGetbyunionidRequest, token);

            // 根据userId获取用户信息
            String userid = oapiUserGetbyunionidResponse.getResult().getUserid();
            DingTalkClient clientDingTalkClient2 = new DefaultDingTalkClient(
                    "https://oapi.dingtalk.com/topapi/v2/user/get");
            OapiV2UserGetRequest reqGetRequest = new OapiV2UserGetRequest();
            reqGetRequest.setUserid(userid);
            reqGetRequest.setLanguage("zh_CN");
            rspGetResponse = clientDingTalkClient2.execute(reqGetRequest, token);
            return rspGetResponse.getResult().getJobNumber();
        } catch (ApiException e) {
            e.printStackTrace();
        }
        return "";
    }
}
SpringBeanUtils
@Component
public class SpringBeanUtils implements ApplicationContextAware {


    private static ApplicationContext app;


    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if (app == null) {
            app = applicationContext;
        }
    }

    // 获得applicationContext
    public static ApplicationContext getApplicationContext() throws Exception {
        return app;
    }

    // 通过class获取Bean
    public static <T> T getBean(Class<T> clazz) throws Exception {
        return getApplicationContext().getBean(clazz);
    }

    // 通过name获取 Bean
    public static Object getBean(String name) throws Exception {
        return getApplicationContext().getBean(name);
    }


}
WeChatUtil
@Slf4j
@Component
public class WeChatUtil {


    @Autowired
    private HttpClientUtil httpClientUtil;

    @Value("${wechat.corpid}")
    private String corpid;

    @Value("${wechat.corpsecret}")
    private String corpsecret;

    @Value("${wechat.getTokenUri}")
    private String wxgetTokenUri;

    @Value("${wechat.getUserIdUri}")
    private String wxgetUserIdUri;

    @Value("${wechat.readUserUri}")
    private String wxreadUserUri;

    private static Long tokenTime = 0L;
    //2小时过期
    private final Integer invalidTime = 2;
    private String accesstToken;

    //获取登陆凭证
    public String getAccessToekn() {
        if (System.currentTimeMillis() - tokenTime > invalidTime * 1000 * 60) {
            tokenTime = System.currentTimeMillis();
            String url = wxgetTokenUri + "?corpid=" + corpid + "&corpsecret=" + corpsecret;
            String doGet = httpClientUtil.doGet(url, new HashMap<>());
            HashMap map = JSON.parseObject(doGet, HashMap.class);
            if ("ok".equals(map.get("errmsg"))) {
                accesstToken = (String) map.get("access_token");
                return accesstToken;
            } else {
                log.error("getAccessToekn 出错 {}",map.get("errmsg"));
                return "";
            }
        } else {
            return accesstToken;
        }
    }

    //获取访问用户ID
    public String getUserId(String accessToken, String code) {
        String url = wxgetUserIdUri + "?access_token=" + accessToken + "&code=" + code;
        String doGet = httpClientUtil.doGet(url, new HashMap<>());
        HashMap map = JSON.parseObject(doGet, HashMap.class);
        if ("ok".equals(map.get("errmsg"))) {
            return (String) map.get("UserId");
        } else {
            throw new RuntimeException(map.get("errcode")+"  "+(String) map.get("errmsg"));
        }
    }

    public String getEmpId(String accessToken,String userId){
        String url = wxreadUserUri + "?access_token=" + accessToken + "&userid=" + userId;
        String doGet = httpClientUtil.doGet(url, new HashMap<>());
        HashMap map = JSON.parseObject(doGet, HashMap.class);
        JSONObject jsonDoget = (JSONObject) JSONObject.parseObject(JSON.parseObject(doGet).getString("extattr")).getJSONArray("attrs").get(0);
        String empId = (String) jsonDoget.get("value");
        if ("ok".equals(map.get("errmsg"))) {
            return empId;
        } else {
            throw new RuntimeException(map.get("errcode")+"  "+(String) map.get("errmsg"));
        }
    }
}

(6) 枚举类

CacheKeyEnum
public enum CacheKeyEnum {

    ACCESS_TOKEN_KEY("accessToken"),
    CROP_TOKEN_KEY("corpToken")
    ;


    public String key;

    CacheKeyEnum(String key) {
        this.key = key;
    }

    public String getkey() {
        return key;
    }

    public void setkey(String key) {
        this.key = key;
    }

    @Override
    public String toString() {
        return super.toString();
    }
}
vue-钉钉H5微应用单点登录，获取用户信息踩坑指南
qq_41139348的博客
10-25 4205
最近接到一个新任务，H5开发俩页面，嵌入钉钉，作为一个H5微应用，需要实现免登录，也就是不要进入微应用得时候再走一个登录页面，首页+详情页，详情页带一个分享给钉钉好友的功能。 首先想到既然俩页面需要需要获取用户信息，并且还有个分享给好友功能，是不是要在路由拦截处添加获取用户信息，就是用了router.beforeEach路由拦截，写着写着发现陷入了死循环，而且发现首页的免登和详情页的获取用户信息调用的钉钉api不是同一个，显然得分开写了，所以放弃了这个bug想法。 根据钉钉api结合自己思考实现方式：
普元 sso 单点登陆集成指南
05-31
普元SSO（Single Sign-On）单点登录集成指南是一份详细指导文档，它主要介绍普元信息技术股份有限公司提供的SSO组件的集成原理、集成方法和配置流程，目的是为了实现用户在多个应用系统间无需重复登录即可切换的体验...
Spring Security基于JWT实现SSO单点登录详解
08-25
主要介绍了Spring Security基于JWT实现SSO单点登录详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
企业微信单点登录集成
码上红尘仙的博客
03-18 425
若依微服务集成企业微信单点登录
vue集成钉钉单点登录
weixin_38565317的博客
10-18 1377
登录钉钉开发平台，（访问地址 https://login.dingtalk.com/），创建应用并获取对应的配置。接口地址：https://oapi.dingtalk.com/topapi/v2/user/getuserinfo。接口地址：https://oapi.dingtalk.com/sso/gettoken。钉钉集成 pom.xml sdk依赖。获取微应用后台免登的。获取应用免登的用户信息。
【钉钉免登录】使用dingtalk-jsapi将H5/小程序集成到钉钉，实现单点登录，H5/小程序免登
weixin_51054408的博客
02-15 6373
【钉钉免登录】使用dingtalk-jsapi将H5/小程序集成到钉钉，实现单点登录，H5/小程序免登
SpringBoot——企业级应用对接钉钉（扫码）单点登录
专注写bug
01-10 1551
企业级应用中，单点登录一般应用的较为广泛。如常见的企微单点快捷登录、QQ登录、微信登录等等。本篇博客主要说明钉钉单点登录的一些操作流程，从创建应用到实际应用全面说明。
钉钉单点登录（Vue3）
最新发布
weixin_70585377的博客
04-25 116
2.创建一个中转页面用于钉钉跳转及获取code（/views/ssoLogin.vue）1.在index.html文件引入钉钉包。3.公共路由及权限白名单进行注册。
基于Java语言的webutil-sso单点登陆客户端设计源码
10-04
在Java Web应用开发中，单点登录的实现通常是通过集成成熟的SSO框架来完成的。这可能包括Apache Shiro、Spring Security等框架，它们提供了认证、授权、会话管理等功能，开发者可以通过配置和扩展来构建满足需求的...
spring security oauth2以及jwt实现sso单点登陆的功能
05-07
SSO（Single Sign-On）单点登录是一种身份验证机制，允许用户在一次登录后访问多个相互关联的应用系统，而无需再次进行身份验证。在本项目中，通过集成Spring Security OAuth2和JWT（JSON Web Token）技术，实现了...
ssm+redis实现sso单点登陆，maven模块化实现
03-10
本项目基于SSM（Spring、SpringMVC、MyBatis）框架与Redis缓存系统，实现了SSO的集成方案，并通过Maven的模块化管理来组织代码，提高了项目的可维护性和可扩展性。 **SSM框架整合** 1. **Spring**：Spring作为核心...
实战项目对接单点登录
01-05
这个单点登录文件是我在实际项目开发中的的代码，通过 拦截器的方式对接单点登录，主要的技术是在项目中web.xml 文件中的拦截器进行配置，和原有的shiro 框架进行整合
应用系统与钉钉集成案例及操作步骤
01-29 4474
应用系统与阿里钉钉集成涉及到多个步骤，包括：在钉钉平台注册账号，注册微应用，获取密钥，同步用户，推送消息、调用钉钉API接口等多个关键步骤，本案例详细具体展示了如何一步一步完成应用系统和钉钉的集成。
企业微信工作台集成CAS实现单点登录
Forget_Re的博客
11-18 4560
企业微信工作台集成CAS实现单点登录
钉钉一键登录第三方网站
csdn565973850的博客
02-03 4766
钉钉一键登录第三方网站，这里主要记录一键登录整个实现步骤。登录页面构造好钉钉一键登录链接后的页面效果。
.NET实现企业微信接入应用实现单点登录（自动登录）
willingtolove的博客
09-25 3358
文章目录#需求场景#参考#具体步骤1、获取access_token2、构造网页授权链接3、获取访问用户身份#.Net具体代码1、Web首页服务端代码2、帮助类代码 #需求场景 一个.net开发的web应用接入到企业微信的应用中，实现微信用户点击应用，打开web，获取到用户信息，并实现自动登录功能。 #参考 企业微信官方API文档：https://work.weixin.qq.com/api/doc/90000/90135/91020 #具体步骤 1、获取access_token 获取access_toke
集成钉钉扫码登录到 Web 应用
weixin_39651041的博客
04-12 812
最近有个需求，需要在自己的系统中集成钉钉扫码登录。
uniapp插件钉钉登录分享
王延朕的博客
07-26 1419
插件地址。
单点登录原理与简单实现
热门推荐
u011277123的博客
11-30 4万+
创未来 2016-11-29 16:09 一、单系统登录机制 1、http无状态协议 web应用采用browser/server架构，http作为通信协议。http是无状态协议，浏览器的每一次请求，服务器会独立处理，不与之前或之后的请求产生关联，这个过程用下图说明，三次请求/响应对之间没有任何联系 但这也同时意味着，任何用户都能通过浏览器访问服务器资源，如果想保护服务器的某些资
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

秋日的晚霞

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值