微信授权登录，系统权限放开

guoshilong

2023-05-04 cfd896cef1c970935e3acf595c3c0f5664219df6

微信授权登录，系统权限放开

 skjcmanager/skjcmanager-auth/src/main/java/cn/gistack/auth/endpoint/BladeTokenEndPoint.java

@@ -16,6 +16,13 @@
 */
package cn.gistack.auth.endpoint;


import cn.gistack.common.utils.HttpClientUtils;
import cn.gistack.system.user.entity.User;
import cn.gistack.system.user.feign.IUserClient;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONAware;
import com.alibaba.fastjson.JSONObject;
import com.wf.captcha.SpecCaptcha;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
@@ -32,19 +39,31 @@
import org.springblade.core.tool.support.Kv;
import org.springblade.core.tool.utils.StringUtil;
import org.springblade.core.tool.utils.WebUtil;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.oauth2.common.OAuth2AccessToken;
import org.springframework.security.oauth2.common.OAuth2RefreshToken;
import org.springframework.security.oauth2.provider.AuthorizationRequest;
import org.springframework.security.oauth2.provider.ClientDetailsService;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpSession;
import java.time.Duration;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

import static org.springblade.core.cache.constant.CacheConstant.*;

@@ -63,6 +82,13 @@
    private final JwtProperties jwtProperties;
    private final ClientDetailsService clientDetailsService;
    private final TokenStore tokenStore;
    private final IUserClient userClient;
    private final UserDetailsService userDetailsService;
    //获取wxAccessToken
    private final String WX_GET_ACCESS_TOKEN = "https://api.weixin.qq.com/cgi-bin/token";
    private final String WX_GET_PHONE_NUMBER = "https://api.weixin.qq.com/wxa/business/getuserphonenumber";
    private final String WX_APP_ID = "wx521ae71bcde281bc";
    private final String WX_SECRET = "c1c93b0c4545f8cdf42752121ea8458c";

    /**
     * 登录页面
@@ -73,6 +99,42 @@
        return model;
    }

    @GetMapping("/oauth/wxLogin")
    public R wxLogin(String code){
        String wxAccessToken = getWxAccessToken();
        //参数
        String url = WX_GET_PHONE_NUMBER+"?access_token="+wxAccessToken;
        //向微信接口发起请求获取手机号

        RestTemplate template = new RestTemplate();
        Map<String, Object> params = new LinkedHashMap<>();
        params.put("code", code);
        String result = template.postForObject(url, params, String.class);
        JSONObject resultObj = (JSONObject)JSONObject.parse(result);
        JSONObject phoneInfo = (JSONObject)resultObj.get("phone_info");
        String phoneNumber = phoneInfo.get("phoneNumber").toString();
        R<User> userR = userClient.userByAccount("000000", phoneNumber);
        if (userR.getData() != null){
            UserDetails userDetails = userDetailsService.loadUserByUsername(userR.getData().getAccount());
            return R.data(userDetails);
        }else {
            return R.fail("不存在该用户");
        }
    }

    public String getWxAccessToken(){
        //参数
        Map<String, String> params = new HashMap<>();
        params.put("grant_type","client_credential");
        params.put("appid",WX_APP_ID);
        params.put("secret",WX_SECRET);
        String result = HttpClientUtils.doGet(WX_GET_ACCESS_TOKEN, params);
        JSONObject jsonObject = JSON.parseObject(result);
        String accessToken = jsonObject.getString("access_token");
        return accessToken;
    }


    /**
     * 授权页面
     */

 skjcmanager/skjcmanager-common/pom.xml

@@ -28,6 +28,10 @@
            <artifactId>blade-core-auto</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
        </dependency>
    </dependencies>

    <build>

 skjcmanager/skjcmanager-common/src/main/java/cn/gistack/common/launch/LauncherServiceImpl.java

@@ -39,13 +39,12 @@
        PropsUtil.setProperty(props, "spring.cloud.nacos.discovery.server-addr", LauncherConstant.nacosAddr(profile));
        PropsUtil.setProperty(props, "spring.cloud.nacos.config.server-addr", LauncherConstant.nacosAddr(profile));

        //自定义命名空间
//        PropsUtil.setProperty(props, "spring.cloud.nacos.config.namespace", "xiebin");
//        PropsUtil.setProperty(props, "spring.cloud.nacos.discovery.namespace", "xiebin");
        //自定义注册
        PropsUtil.setProperty(props, "spring.cloud.nacos.config.namespace", "guoshilong");
        PropsUtil.setProperty(props, "spring.cloud.nacos.discovery.namespace", "guoshilong");

        PropsUtil.setProperty(props, "spring.cloud.sentinel.transport.dashboard", LauncherConstant.sentinelAddr(profile));
        PropsUtil.setProperty(props, "spring.zipkin.base-url", LauncherConstant.zipkinAddr(profile));
        //开启多数据源
        PropsUtil.setProperty(props, "spring.datasource.dynamic.enabled", "false");

        // 开启elk日志

 skjcmanager/skjcmanager-common/src/main/java/cn/gistack/common/utils/HttpClientUtils.java

New file
@@ -0,0 +1,470 @@
package cn.gistack.common.utils;

import com.alibaba.fastjson.JSON;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.client.LaxRedirectStrategy;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.SSLContext;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.*;


public class HttpClientUtils {
    /**
     * 执行有参GET请求
     *
     * @param url
     * @param params
     * @return
     */
    public static String doGet(String url, Map<String, String> params) {

        //获取httpclient客户端
        CloseableHttpClient httpclient = HttpClients.createDefault();

        String resultString = "";

        CloseableHttpResponse response = null;

        try {
            URIBuilder builder = new URIBuilder(url);

            if (null != params) {
                for (String key : params.keySet()) {
                    builder.setParameter(key, params.get(key));
                }
            }

            HttpGet get = new HttpGet(builder.build());

            response = httpclient.execute(get);


            if (200 == response.getStatusLine().getStatusCode()) {
                HttpEntity entity = response.getEntity();
                resultString = EntityUtils.toString(entity, "utf-8");
            }

        } catch (Exception e) {

            e.printStackTrace();
        } finally {
            if (null != response) {
                try {
                    response.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != httpclient) {
                try {
                    httpclient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        return resultString;
    }

    /**
     * 执行有参GET请求,带请求头
     *
     * @param url 请求url
     * @param params 参数
     * @param key 请求头Key
     * @param secretKey 秘钥
     * @return
     */
    public static String doGetHeader(String url, String key, String secretKey, Map<String, String> params) {

        //获取httpclient客户端
        CloseableHttpClient httpclient = HttpClients.createDefault();

        String resultString = "";

        CloseableHttpResponse response = null;

        try {
            URIBuilder builder = new URIBuilder(url);

            if (null != params) {
                for (String keys : params.keySet()) {
                    builder.addParameter(keys,params.get(keys));
                    //builder.setParameter(keys, params.get(keys));
                }
            }

            HttpGet httpGet = new HttpGet(builder.build());

            //设置请求头
            httpGet.addHeader(key,secretKey);
            // 传输的类型
            httpGet.addHeader("Content-Type", "application/x-www-form-urlencoded");
            //执行Http请求调用
            response = httpclient.execute(httpGet);
            //判断是否请求成功返回
            if (200 == response.getStatusLine().getStatusCode()) {
                HttpEntity entity = response.getEntity();
                resultString = EntityUtils.toString(entity, "utf-8");
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (null != response) {
                try {
                    response.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != httpclient) {
                try {
                    httpclient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        return resultString;
    }

    /**
     * 执行无参GET请求
     *
     * @param url
     * @return
     */
    public static String doGet(String url) {
        return doGet(url, null);
    }

    /**
     * 执行有参POST请求
     *
     * @param url
     * @param params
     * @return
     */
    public static String doPost(String url, Map<String, String> params) {
        /**
         * 在4.0及以上httpclient版本中，post需要指定重定向的策略，如果不指定则按默认的重定向策略。
         *
         * 获取httpclient客户端
         */
        CloseableHttpClient httpclient = HttpClientBuilder.create().setRedirectStrategy(new LaxRedirectStrategy()).build();

        String resultString = "";

        CloseableHttpResponse response = null;

        try {


            HttpPost post = new HttpPost(url);
            post.setHeader("Accept", "application/json");
            post.setHeader("Accept-Encoding", "gzip");
//        post.setHeader("Cache-Control", "no-cache");
//        post.setHeader("Connection", "keep-alive");
            post.setHeader("Content-Type", "application/json;charset=UTF-8");

            List<NameValuePair> paramaters = new ArrayList<>();

            if (null != params) {
                for (String key : params.keySet()) {
                    paramaters.add(new BasicNameValuePair(key, params.get(key)));
                }
                // 构造一个form表单式的实体
                UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(paramaters);
                // 将请求实体设置到httpPost对象中
                post.setEntity(formEntity);
            }


            /**
             * HTTP/1.1 403 Forbidden
             *   原因：
             *      有些网站，设置了反爬虫机制
             *   解决的办法：
             *      设置请求头，伪装浏览器
             */
            post.addHeader("user-agent", "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36");

            response = httpclient.execute(post);

            if (200 == response.getStatusLine().getStatusCode()) {
                HttpEntity entity = response.getEntity();
                resultString = EntityUtils.toString(entity, "utf-8");
            }

        } catch (Exception e) {

            e.printStackTrace();
        } finally {
            if (null != response) {
                try {
                    response.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (null != httpclient) {
                try {
                    httpclient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return resultString;
    }

    public static String doPost(String url) {
        return doPost(url, null);
    }


//    public static void main(String[] args) {
//
//        Map<String, String> params = new HashMap<>();
//        params.put("scope", "project");
//        params.put("q", "数据库");
//
//        /**
//         * 有一部分网站，禁止爬虫技术访问网站。
//         *
//         * 解决方案：
//         *    伪装浏览器
//         *    post.addHeader("user-agent", "Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36");
//         */
//        System.out.println(doPost("http://www.oschina.net/search", params));
//    }

    /**
     * post 请求 header 带 秘钥
     * @param url
     * @param appId
     * @param timestamp
     * @param transId
     * @param token
     * @param map
     * @return
     */
    public static String httpPost(String url,
                                  String appId,
                                  String timestamp,
                                  String transId,
                                  String token,
                                  Map<String, Object> map) {
        // 返回body
        String res = null;
        // 获取连接客户端工具
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse httpResponse = null;
        // 2、创建一个HttpPost请求
        HttpPost post = new HttpPost(url);
        // 5、设置header信息
        /**header中通用属性*/
        post.setHeader("Accept", "application/json");
        post.setHeader("Accept-Encoding", "gzip");
        post.setHeader("Content-Type", "application/json;charset=UTF-8");
        HashMap<Object, Object> hashMap = new HashMap<>(4);
        hashMap.put("appId",appId);
        hashMap.put("timestamp",timestamp);
        hashMap.put("transId",transId);
        hashMap.put("token",token);
        String head = hashMap.toString();
        post.setHeader("head", JSON.toJSONString(head));
        String body = JSON.toJSONString(map);

        // 设置参数
        if (map != null) {
            try {
                StringEntity entity1 = new StringEntity(body, "UTF-8");
                entity1.setContentEncoding("UTF-8");
                entity1.setContentType("json/form-data");
                post.setEntity(entity1);

                // 7、执行post请求操作，并拿到结果
                httpResponse = httpClient.execute(post);
                // 获取结果实体
                HttpEntity entity = httpResponse.getEntity();
                if (entity != null) {
                    // 按指定编码转换结果实体为String类型
                    res = EntityUtils.toString(entity, "UTF-8");
                }
                try {
                    httpResponse.close();
                    httpClient.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return res;
    }

    public static SSLContext createIgnoreVerifySSL() throws KeyManagementException, NoSuchAlgorithmException, KeyStoreException {

        SSLContext sc = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {

            public boolean isTrusted(X509Certificate[] arg0, String arg1) throws CertificateException {
                return true;
            }

        }).build();

        return sc;
    }

    //适用于post请求并传送form-data数据（同样适用于post的Raw类型的application-json格式）
    public static String postParams(String url, String appKey, String appKeyValue, Map<String, String> map) {
        SSLContext sslcontext = null;
        try {
            sslcontext = createIgnoreVerifySSL();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyStoreException e) {
            e.printStackTrace();
        }
        // 设置协议http和https对应的处理socket链接工厂的对象
        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", PlainConnectionSocketFactory.INSTANCE)
                .register("https", new SSLConnectionSocketFactory(sslcontext))
                .build();
        PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);

        //创建自定义的httpclient对象
        CloseableHttpClient client = HttpClients.custom().setConnectionManager(connManager).build();
        HttpPost post = new HttpPost(url);
//        post.setHeader(appKey, appKeyValue);
        CloseableHttpResponse res = null;
        try {
            List<NameValuePair> nvps = new ArrayList<NameValuePair>();
            Set<String> keySet = map.keySet();
            for (String key : keySet) {
                nvps.add(new BasicNameValuePair(key, map.get(key)));
            }
            post.setEntity(new UrlEncodedFormEntity(nvps, "utf-8"));
            res = client.execute(post);
            HttpEntity entity = res.getEntity();
            return EntityUtils.toString(entity, "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                res.close();
                client.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return "";
    }

    /**
     * 向指定 URL 发送POST方法的请求
     *
     * @param url    发送请求的 URL
     * @param params 请求的参数集合
     * @return 远程资源的响应结果
     */
    @SuppressWarnings("unused")
    public static String sendPost(String url, Map<String, String> params) {
        OutputStreamWriter out = null;
        BufferedReader in = null;
        StringBuilder result = new StringBuilder();
        try {
            URL realUrl = new URL(url);
            HttpURLConnection conn = (HttpURLConnection) realUrl.openConnection();
            // 发送POST请求必须设置如下两行
            conn.setDoOutput(true);
            conn.setDoInput(true);
            // POST方法
            conn.setRequestMethod("POST");
            // 设置通用的请求属性
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            conn.connect();
            // 获取URLConnection对象对应的输出流
            out = new OutputStreamWriter(conn.getOutputStream(), "UTF-8");
            // 发送请求参数
            if (params != null) {
                StringBuilder param = new StringBuilder();
                for (Map.Entry<String, String> entry : params.entrySet()) {
                    if (param.length() > 0) {
                        param.append("&");
                    }
                    param.append(entry.getKey());
                    param.append("=");
                    param.append(entry.getValue());
                }
                out.write(param.toString());
            }
            // flush输出流的缓冲
            out.flush();
            // 定义BufferedReader输入流来读取URL的响应
            in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));
            String line;
            while ((line = in.readLine()) != null) {
                result.append(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 使用finally块来关闭输出流、输入流
        finally {
            try {
                if (out != null) {
                    out.close();
                }
                if (in != null) {
                    in.close();
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
        return result.toString();
    }

}

 skjcmanager/skjcmanager-gateway/src/main/java/cn/gistack/gateway/provider/AuthProvider.java

@@ -58,6 +58,8 @@
        DEFAULT_SKIP_URL.add("/sjztmd/**/**");
        DEFAULT_SKIP_URL.add("/simulate/**");
        DEFAULT_SKIP_URL.add("/app/manage/getLastInfo");
        DEFAULT_SKIP_URL.add("/oauth/wxLogin");
        DEFAULT_SKIP_URL.add("/sms/sms/sendCode");
    }

    /**

 skjcmanager/skjcmanager-service/skjcmanager-system/src/main/java/cn/gistack/system/controller/AuthClientController.java

@@ -48,7 +48,7 @@
@RequestMapping("/client")
@ApiIgnore
@Api(value = "应用管理", tags = "接口")
@PreAuth(RoleConstant.HAS_ROLE_ADMINISTRATOR)
//@PreAuth(RoleConstant.HAS_ROLE_ADMINISTRATOR)
public class AuthClientController extends BladeController {

    private final IAuthClientService clientService;

 skjcmanager/skjcmanager-service/skjcmanager-system/src/main/java/cn/gistack/system/controller/DeptController.java

@@ -63,7 +63,7 @@
@AllArgsConstructor
@RequestMapping("/dept")
@Api(value = "部门", tags = "部门")
@PreAuth(RoleConstant.HAS_ROLE_ADMIN)
//@PreAuth(RoleConstant.HAS_ROLE_ADMIN)
public class DeptController extends BladeController {

    private final IDeptService deptService;

 skjcmanager/skjcmanager-service/skjcmanager-system/src/main/java/cn/gistack/system/controller/TopMenuController.java

@@ -51,7 +51,7 @@
@AllArgsConstructor
@RequestMapping("/topmenu")
@Api(value = "顶部菜单表", tags = "顶部菜单")
@PreAuth(RoleConstant.HAS_ROLE_ADMIN)
//@PreAuth(RoleConstant.HAS_ROLE_ADMIN)
public class TopMenuController extends BladeController {

    private final ITopMenuService topMenuService;