添加登录

src/main/java/com/bme/access/upload/common/ApplicationContextHelper.java

+package com.bme.access.upload.common;
+
+import org.springframework.beans.BeansException;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.stereotype.Component;
+
+@Component
+public class ApplicationContextHelper implements ApplicationContextAware {
+    private static ApplicationContext applicationContext;
+
+    @Override
+    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+        ApplicationContextHelper.applicationContext = applicationContext;
+        if(ApplicationContextHelper.applicationContext == null) {
+            ApplicationContextHelper.applicationContext = applicationContext;
+        }
+    }
+
+    public static ApplicationContext getApplicationContext() {
+        return applicationContext;
+    }
+
+    public static <T> T getBean(Class<T> clasz) {
+        return applicationContext != null ? applicationContext.getBean(clasz) : null;
+    }
+
+    public static Object getBean(String name){
+        return getApplicationContext().getBean(name);
+    }
+}
\ No newline at end of file

src/main/java/com/bme/access/upload/common/CommonResult.java

+package com.bme.access.upload.common;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class CommonResult {
+
+	public CommonResult() {
+	}
+
+	public CommonResult(boolean success, String msg, Object data) {
+		super();
+		this.success = success;
+		this.msg = msg;
+		this.data = data;
+	}
+
+	public static CommonResult success() {
+		return CommonResult.success(null, null);
+	}
+
+	public static CommonResult success(String msg) {
+		return CommonResult.success(msg, null);
+	}
+
+	public static CommonResult success(String msg, Object data) {
+		CommonResult result = new CommonResult(true, msg, data);
+		result.setType(0);
+		return result;
+	}
+
+	public static CommonResult fail() {
+		return CommonResult.fail(null, null);
+	}
+
+	public static CommonResult fail(String msg) {
+		return CommonResult.fail(msg, null);
+	}
+
+	public static CommonResult fail(String msg, Object data) {
+		CommonResult result = new CommonResult(false, msg, data);
+		result.setType(0);
+		return result;
+	}
+
+	@SuppressWarnings("unchecked")
+	public CommonResult data(Object... objects) {
+		if (objects != null) {
+			if (objects.length == 1) {
+				this.data = objects[0];
+			} else {
+				Map<String, Object> dataMap = new HashMap<String, Object>();
+				if (data instanceof Map) {
+					dataMap = (Map<String, Object>) this.data;
+				}
+				for (int i = 0; i < objects.length / 2; i++) {
+					int index = i * 2;
+					dataMap.put(String.valueOf(objects[index]), objects[index + 1]);
+				}
+				this.data = dataMap;
+			}
+		}
+		return this;
+	}
+
+	private boolean success;
+	private Integer type;
+	private String msg;
+	private Object data;
+
+	public boolean isSuccess() {
+		return success;
+	}
+
+	public void setSuccess(boolean success) {
+		this.success = success;
+	}
+
+	public Integer getType() {
+		return type;
+	}
+
+	public void setType(Integer type) {
+		this.type = type;
+	}
+
+	public String getMsg() {
+		return msg;
+	}
+
+	public void setMsg(String msg) {
+		this.msg = msg;
+	}
+
+	public Object getData() {
+		return data;
+	}
+
+	public void setData(Object data) {
+		this.data = data;
+	}
+
+	public static CommonResult result(boolean checkResult) {
+		CommonResult result = new CommonResult();
+		result.setSuccess(checkResult);
+		return result;
+	}
+
+}
\ No newline at end of file

src/main/java/com/bme/access/upload/common/HttpUtils.java

+package com.bme.access.upload.common;
+
+import com.alibaba.fastjson.JSON;
+import com.bme.access.upload.config.LoginConfig;
+import org.apache.commons.lang.StringUtils;
+import org.apache.http.HttpResponse;
+import org.apache.http.NameValuePair;
+import org.apache.http.client.HttpClient;
+import org.apache.http.client.entity.UrlEncodedFormEntity;
+import org.apache.http.client.methods.HttpDelete;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.client.methods.HttpPut;
+import org.apache.http.conn.ClientConnectionManager;
+import org.apache.http.conn.scheme.Scheme;
+import org.apache.http.conn.scheme.SchemeRegistry;
+import org.apache.http.conn.ssl.SSLSocketFactory;
+import org.apache.http.entity.ByteArrayEntity;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.impl.client.DefaultHttpClient;
+import org.apache.http.message.BasicNameValuePair;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.X509TrustManager;
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class HttpUtils {
+
+    /**
+     * get
+     *
+     * @param host
+     * @param path
+     * @param method
+     * @param headers
+     * @param querys
+     * @return
+     * @throws Exception
+     */
+    public static HttpResponse doGet(String host, String path, String method,
+                                     Map<String, String> headers,
+                                     Map<String, String> querys)
+            throws Exception {
+        HttpClient httpClient = wrapClient(host);
+
+        HttpGet request = new HttpGet(buildUrl(host, path, querys));
+        for (Map.Entry<String, String> e : headers.entrySet()) {
+            request.addHeader(e.getKey(), e.getValue());
+        }
+
+        return httpClient.execute(request);
+    }
+
+    /**
+     * post form
+     *
+     * @param host
+     * @param path
+     * @param method
+     * @param headers
+     * @param querys
+     * @param bodys
+     * @return
+     * @throws Exception
+     */
+    public static HttpResponse doPost(String host, String path, String method,
+                                      Map<String, String> headers,
+                                      Map<String, String> querys,
+                                      Map<String, String> bodys)
+            throws Exception {
+        HttpClient httpClient = wrapClient(host);
+
+        HttpPost request = new HttpPost(buildUrl(host, path, querys));
+        for (Map.Entry<String, String> e : headers.entrySet()) {
+            request.addHeader(e.getKey(), e.getValue());
+        }
+
+        if (bodys != null) {
+            List<NameValuePair> nameValuePairList = new ArrayList<NameValuePair>();
+
+            for (String key : bodys.keySet()) {
+                nameValuePairList.add(new BasicNameValuePair(key, bodys.get(key)));
+            }
+            UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nameValuePairList, "utf-8");
+            formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8");
+            request.setEntity(formEntity);
+        }
+
+        return httpClient.execute(request);
+    }
+
+    /**
+     * Post String
+     *
+     * @param host
+     * @param path
+     * @param method
+     * @param headers
+     * @param querys
+     * @param body
+     * @return
+     * @throws Exception
+     */
+    public static HttpResponse doPost(String host, String path, Map<String, String> headers, Map<String, String> querys, Map<String, String> bodys) throws Exception {
+        HttpClient httpClient = wrapClient(host);
+
+        HttpPost request = new HttpPost(buildUrl(host, path, querys));
+        for (Map.Entry<String, String> e : headers.entrySet()) {
+            request.addHeader(e.getKey(), e.getValue());
+        }
+
+        if (bodys != null) {
+            List<NameValuePair> nameValuePairList = new ArrayList<>();
+
+            for (String key : bodys.keySet()) {
+                nameValuePairList.add(new BasicNameValuePair(key, bodys.get(key)));
+            }
+            UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nameValuePairList, "utf-8");
+            formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8");
+            request.setEntity(formEntity);
+        }
+        return httpClient.execute(request);
+    }
+
+    /**
+     * Post stream
+     *
+     * @param host
+     * @param path
+     * @param method
+     * @param headers
+     * @param querys
+     * @param body
+     * @return
+     * @throws Exception
+     */
+    public static HttpResponse doPost(String host, String path, String method,
+                                      Map<String, String> headers,
+                                      Map<String, String> querys,
+                                      byte[] body)
+            throws Exception {
+        HttpClient httpClient = wrapClient(host);
+
+        HttpPost request = new HttpPost(buildUrl(host, path, querys));
+        for (Map.Entry<String, String> e : headers.entrySet()) {
+            request.addHeader(e.getKey(), e.getValue());
+        }
+
+        if (body != null) {
+            request.setEntity(new ByteArrayEntity(body));
+        }
+
+        return httpClient.execute(request);
+    }
+
+    /**
+     * Put String
+     * @param host
+     * @param path
+     * @param method
+     * @param headers
+     * @param querys
+     * @param body
+     * @return
+     * @throws Exception
+     */
+    public static HttpResponse doPut(String host, String path, String method,
+                                     Map<String, String> headers,
+                                     Map<String, String> querys,
+                                     String body)
+            throws Exception {
+        HttpClient httpClient = wrapClient(host);
+
+        HttpPut request = new HttpPut(buildUrl(host, path, querys));
+        for (Map.Entry<String, String> e : headers.entrySet()) {
+            request.addHeader(e.getKey(), e.getValue());
+        }
+
+        if (StringUtils.isNotBlank(body)) {
+            request.setEntity(new StringEntity(body, "utf-8"));
+        }
+
+        return httpClient.execute(request);
+    }
+
+    /**
+     * Put stream
+     * @param host
+     * @param path
+     * @param method
+     * @param headers
+     * @param querys
+     * @param body
+     * @return
+     * @throws Exception
+     */
+    public static HttpResponse doPut(String host, String path, String method,
+                                     Map<String, String> headers,
+                                     Map<String, String> querys,
+                                     byte[] body)
+            throws Exception {
+        HttpClient httpClient = wrapClient(host);
+
+        HttpPut request = new HttpPut(buildUrl(host, path, querys));
+        for (Map.Entry<String, String> e : headers.entrySet()) {
+            request.addHeader(e.getKey(), e.getValue());
+        }
+
+        if (body != null) {
+            request.setEntity(new ByteArrayEntity(body));
+        }
+
+        return httpClient.execute(request);
+    }
+
+    /**
+     * Delete
+     *
+     * @param host
+     * @param path
+     * @param method
+     * @param headers
+     * @param querys
+     * @return
+     * @throws Exception
+     */
+    public static HttpResponse doDelete(String host, String path, String method,
+                                        Map<String, String> headers,
+                                        Map<String, String> querys)
+            throws Exception {
+        HttpClient httpClient = wrapClient(host);
+
+        HttpDelete request = new HttpDelete(buildUrl(host, path, querys));
+        for (Map.Entry<String, String> e : headers.entrySet()) {
+            request.addHeader(e.getKey(), e.getValue());
+        }
+
+        return httpClient.execute(request);
+    }
+
+    private static String buildUrl(String host, String path, Map<String, String> querys) throws UnsupportedEncodingException {
+        StringBuilder sbUrl = new StringBuilder();
+        sbUrl.append(host);
+        if (!StringUtils.isBlank(path)) {
+            sbUrl.append(path);
+        }
+        if (null != querys) {
+            StringBuilder sbQuery = new StringBuilder();
+            for (Map.Entry<String, String> query : querys.entrySet()) {
+                if (0 < sbQuery.length()) {
+                    sbQuery.append("&");
+                }
+                if (StringUtils.isBlank(query.getKey()) && !StringUtils.isBlank(query.getValue())) {
+                    sbQuery.append(query.getValue());
+                }
+                if (!StringUtils.isBlank(query.getKey())) {
+                    sbQuery.append(query.getKey());
+                    if (!StringUtils.isBlank(query.getValue())) {
+                        sbQuery.append("=");
+                        sbQuery.append(URLEncoder.encode(query.getValue(), "utf-8"));
+                    }
+                }
+            }
+            if (0 < sbQuery.length()) {
+                sbUrl.append("?").append(sbQuery);
+            }
+        }
+
+        return sbUrl.toString();
+    }
+
+    private static HttpClient wrapClient(String host) {
+        HttpClient httpClient = new DefaultHttpClient();
+        if (host.startsWith("https://")) {
+            sslClient(httpClient);
+        }
+
+        return httpClient;
+    }
+
+    private static void sslClient(HttpClient httpClient) {
+        try {
+            SSLContext ctx = SSLContext.getInstance("TLS");
+            X509TrustManager tm = new X509TrustManager() {
+                public X509Certificate[] getAcceptedIssuers() {
+                    return null;
+                }
+                public void checkClientTrusted(X509Certificate[] xcs, String str) {
+
+                }
+                public void checkServerTrusted(X509Certificate[] xcs, String str) {
+
+                }
+            };
+            ctx.init(null, new TrustManager[] { tm }, null);
+            SSLSocketFactory ssf = new SSLSocketFactory(ctx);
+            ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
+            ClientConnectionManager ccm = httpClient.getConnectionManager();
+            SchemeRegistry registry = ccm.getSchemeRegistry();
+            registry.register(new Scheme("https", 443, ssf));
+        } catch (KeyManagementException ex) {
+            throw new RuntimeException(ex);
+        } catch (NoSuchAlgorithmException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+
+
+    /**
+     * Post String
+     *
+     * @param host
+     * @param path
+     * @param headers
+     * @param querys
+     * @return
+     * @throws Exception
+     */
+    public static HttpResponse sendRequest(String host, String path, Map<String, String> headers, Map<String, String> querys, Map<String, Object> bodys) throws Exception {
+        HttpClient httpClient = wrapClient(host);
+
+        HttpPost request = new HttpPost(buildUrl(host, path, querys));
+        for (Map.Entry<String, String> e : headers.entrySet()) {
+            request.addHeader(e.getKey(), e.getValue());
+        }
+
+        if (bodys != null) {
+            StringEntity entity = new StringEntity(JSON.toJSONString(bodys), "UTF-8");
+            request.setEntity(entity);
+        }
+        return httpClient.execute(request);
+    }
+
+    public static HttpResponse send(String host, String path, Map<String, String> querys, Map<String, Object> bodys) throws Exception {
+        HttpClient httpClient = wrapClient(host);
+        HttpPost request = new HttpPost(buildUrl(host, path, querys));
+        Map<String, String> headers = new HashMap<>();
+        headers.put("X-Access-Token", LoginConfig.token);
+        headers.put("Content-Type", "application/json");
+        for (Map.Entry<String, String> e : headers.entrySet()) {
+            request.addHeader(e.getKey(), e.getValue());
+        }
+        if (bodys != null) {
+            StringEntity entity = new StringEntity(JSON.toJSONString(bodys), "UTF-8");
+            request.setEntity(entity);
+        }
+        return httpClient.execute(request);
+    }
+
+
+
+}
\ No newline at end of file

src/main/java/com/bme/access/upload/config/LoginConfig.java

+package com.bme.access.upload.config;
+
+import com.alibaba.fastjson.JSONObject;
+import com.bme.access.upload.common.*;
+import org.apache.http.HttpResponse;
+import org.apache.http.util.EntityUtils;
+import org.springframework.context.annotation.Configuration;
+
+import javax.annotation.PostConstruct;
+import java.util.HashMap;
+import java.util.Map;
+
+@Configuration
+public class LoginConfig {
+
+    //账号
+    public final static String USERNAME = "13905902008";
+    //密码
+    public final static String PASSWORD = "uR4}eP4!";
+
+    public final static String AUTH = "111";
+
+    public final static String LOGIN_URL = "https://dctapi.soszyzg.com/dct/login";
+
+    public static String token = "";
+
+    @PostConstruct
+    public void getLogin() throws Exception {
+        Map<String, Object> body = new HashMap<>();
+        body.put("username", USERNAME);
+        body.put("password", PASSWORD);
+        Map<String, String> headers = new HashMap<>();
+        headers.put("Content-Type", "application/json");
+        headers.put("X-Access-Token", AUTH);
+        HttpResponse response = HttpUtils.sendRequest(LOGIN_URL, null, headers, null, body);
+        String str = EntityUtils.toString(response.getEntity());
+        JSONObject jsonObject = JSONObject.parseObject(str);
+        Integer code = jsonObject.getInteger("code");
+        if (code.equals(200)){
+            String result = jsonObject.getString("result");
+            JSONObject resultObject = JSONObject.parseObject(result);
+            token = resultObject.getString("token");
+        }
+    }
+
+}

src/main/java/com/bme/access/upload/module/service/LoginService.java

+package com.bme.access.upload.module.service;
+
+import org.springframework.stereotype.Service;
+
+@Service
+public class LoginService {
+
+}

src/main/java/com/bme/access/upload/module/web/AuthController.java

+package com.bme.access.upload.module.web;
+
+
+import com.bme.access.upload.common.CommonResult;
+import com.bme.access.upload.common.HttpUtils;
+import com.bme.access.upload.config.LoginConfig;
+import com.bme.access.upload.module.service.LoginService;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.http.HttpResponse;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@RestController
+@Slf4j
+@RequestMapping("/auth")
+public class AuthController {
+
+    @Autowired
+    private LoginService loginService;
+    @Autowired
+    private LoginConfig loginConfig;
+
+
+    @GetMapping("")
+    public CommonResult getAuthToken() throws Exception {
+        loginConfig.getLogin();
+        return CommonResult.success("成功");
+    }
+}

src/main/java/com/bme/access/upload/module/web/LoginController.java

-package com.bme.access.upload.module.web;
-
-public class LoginController {
-}