DemoController.java

/*Copyright ©2016 TommyLemon(https://github.com/TommyLemon/APIJSON)

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.*/

packageapijson.boot;

importapijson.fastjson2.APIJSONController;
importapijson.fastjson2.APIJSONParser;
importapijson.fastjson2.JSONRequest;
importapijson.orm.exception.*;
importcom.alibaba.fastjson2.JSONArray;
importcom.alibaba.fastjson2.JSONObject;
importcom.fasterxml.jackson.databind.util.LRUMap;

importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.http.*;
importorg.springframework.http.client.HttpComponentsClientHttpRequestFactory;
importorg.springframework.stereotype.Service;
importorg.springframework.web.bind.annotation.*;
importorg.springframework.web.client.RestClientResponseException;
importorg.springframework.web.client.RestTemplate;

importjava.lang.reflect.Array;
importjava.net.URLDecoder;
importjava.net.URLEncoder;
importjava.rmi.ServerException;
importjava.sql.PreparedStatement;
importjava.sql.ResultSet;
importjava.sql.ResultSetMetaData;
importjava.sql.Statement;
importjava.util.*;
importjava.util.Map.Entry;
importjava.util.concurrent.TimeoutException;

importjakarta.servlet.http.HttpServletRequest;
importjakarta.servlet.http.HttpServletResponse;
importjakarta.servlet.http.HttpSession;

importapijson.fastjson2.JSON;
importapijson.fastjson2.JSONResponse;
importapijson.Log;
importapijson.RequestMethod;
importapijson.StringUtil;
importapijson.demo.DemoFunctionParser;
importapijson.demo.DemoParser;
importapijson.demo.DemoSQLConfig;
importapijson.demo.DemoSQLExecutor;
importapijson.demo.DemoVerifier;
importapijson.demo.model.Privacy;
importapijson.demo.model.User;
importapijson.demo.model.Verify;
importapijson.framework.BaseModel;
importunitauto.MethodUtil;

importstaticapijson.JSON.getString;
importstaticapijson.RequestMethod.DELETE;
importstaticapijson.RequestMethod.GET;
importstaticapijson.RequestMethod.GETS;
importstaticapijson.RequestMethod.HEAD;
importstaticapijson.RequestMethod.HEADS;
importstaticapijson.RequestMethod.POST;
importstaticapijson.RequestMethod.PUT;
importstaticapijson.framework.APIJSONConstant.ACCESS_;
importstaticapijson.framework.APIJSONConstant.COUNT;
importstaticapijson.framework.APIJSONConstant.FORMAT;
importstaticapijson.framework.APIJSONConstant.FUNCTION_;
importstaticapijson.framework.APIJSONConstant.ID;
importstaticapijson.framework.APIJSONConstant.REQUEST_;
importstaticapijson.framework.APIJSONConstant.USER_ID;
importstaticapijson.framework.APIJSONConstant.VERSION;
importstaticorg.springframework.http.HttpHeaders.COOKIE;
importstaticorg.springframework.http.HttpHeaders.SET_COOKIE;


/**请求路由入口控制器，包括通用增删改查接口等，转交给 APIJSON 的 Parser<T, M, L> 来处理
 * 具体见 SpringBoot 文档
 * https://www.springcloud.cc/spring-boot.html#boot-features-spring-mvc
 * 以及 APIJSON 通用文档 3.设计规范 3.1 操作方法
 * https://github.com/Tencent/APIJSON/blob/master/Document.md#3.1
 * <br > 建议全通过HTTP POST来请求:
 * <br > 1.减少代码 - 客户端无需写HTTP GET,PUT等各种方式的请求代码
 * <br > 2.提高性能 - 无需URL encode和decode
 * <br > 3.调试方便 - 建议使用 APIAuto(http://apijson.cn/api) 或 Postman
 * @author Lemon
 */
@Service
@RestController
@RequestMapping("")
publicclassDemoControllerextendsAPIJSONController<Long> {
privatestaticfinalStringTAG = "DemoController";

publicStringgetRequestBaseURL() {
HttpServletRequesthttpReq = httpServletRequest;
Stringhost = httpReq.getHeader("origin");

if (StringUtil.isEmpty(host)) {
host = httpReq.getHeader("host");
Stringprefix = httpReq.getProtocol().trim().toLowerCase().contains("https") ? "https://" : "http://";
if (StringUtil.isEmpty(host)) {
returnprefix + httpReq.getServerName() + ":" + httpReq.getServerPort();
 }

returnprefix + host;
 }

returnhost;
 }

publicStringgetRequestPath() {
Stringpath = httpServletRequest.getServletPath();
intindex = path.lastIndexOf("/");
path = index < 0 ? path : path.substring(0, index);
returnpath;
 }

// 可以更方便地通过日志排查错误
@Override
publicStringgetRequestURL() {
returngetRequestBaseURL() + getRequestPath();
 }

@Override
publicAPIJSONParser<Long> newParser(HttpSessionsession, RequestMethodmethod) {
returnsuper.newParser(session, method); // .setNeedVerify(false);
 }


/**增删改查统一的类 RESTful API 入口，牺牲一点路由解析性能来提升一些开发效率
 * @param method
 * @param tag
 * @param params
 * @param request
 * @param session
 * @return
 */
@PostMapping("router/{method}/{tag}")
@Override
publicStringrouter(@PathVariable("method") Stringmethod, @PathVariable("tag") Stringtag
 , @RequestParamMap<String, String> params, @RequestBodyStringrequest, HttpSessionsession) {
returnsuper.router(method, tag, params, request, session);
 }

// 通用接口，非事务型操作 和 简单事务型操作 都可通过这些接口自动化实现 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

/**全能增删改查接口，可同时进行 增、删、改、查 多种操作，
 * 通过 @method: "POST", @gets: { "Privacy":"Privacy-CIRCLE", "User": { "@role":"LOGIN", "tag":"User" } } 等关键词指定
 * @param request
 * @param session
 * @return
 */
@PostMapping(value = "crud") // 直接 {method} 或 apijson/{method} 会和内置网页的路由有冲突
// @Override
publicStringcrudAll(@RequestBodyStringrequest, HttpSessionsession) {
returnsuper.crudAll(request, session);
 }
/**增删改查统一入口，这个一个方法可替代以下 7 个方法，牺牲一点路由解析性能来提升一些开发效率
 * @param method
 * @param request
 * @param session
 * @return
 */
@PostMapping(value = "crud/{method}") // 直接 {method} 或 apijson/{method} 会和内置网页的路由有冲突
@Override
publicStringcrud(@PathVariable("method") Stringmethod, @RequestBodyStringrequest, HttpSessionsession) {
returnsuper.crud(method, request, session);
 }

/**获取
 * @param request 只用String，避免encode后未decode
 * @param session
 * @return
 * @see {@link RequestMethod#GET}
 */
@PostMapping(value = "get")
@Override
publicStringget(@RequestBodyStringrequest, HttpSessionsession) {
returnsuper.get(request, session);
 }

/**计数
 * @param request 只用String，避免encode后未decode
 * @param session
 * @return
 * @see {@link RequestMethod#HEAD}
 */
@PostMapping("head")
@Override
publicStringhead(@RequestBodyStringrequest, HttpSessionsession) {
returnsuper.head(request, session);
 }

/**限制性GET，request和response都非明文，浏览器看不到，用于对安全性要求高的GET请求
 * @param request 只用String，避免encode后未decode
 * @param session
 * @return
 * @see {@link RequestMethod#GETS}
 */
@PostMapping("gets")
@Override
publicStringgets(@RequestBodyStringrequest, HttpSessionsession) {
returnsuper.gets(request, session);
 }

/**限制性HEAD，request和response都非明文，浏览器看不到，用于对安全性要求高的HEAD请求
 * @param request 只用String，避免encode后未decode
 * @param session
 * @return
 * @see {@link RequestMethod#HEADS}
 */
@PostMapping("heads")
@Override
publicStringheads(@RequestBodyStringrequest, HttpSessionsession) {
returnsuper.heads(request, session);
 }

/**新增
 * @param request 只用String，避免encode后未decode
 * @param session
 * @return
 * @see {@link RequestMethod#POST}
 */
@PostMapping("post")
@Override
publicStringpost(@RequestBodyStringrequest, HttpSessionsession) {
returnsuper.post(request, session);
 }

/**修改
 * @param request 只用String，避免encode后未decode
 * @param session
 * @return
 * @see {@link RequestMethod#PUT}
 */
@PostMapping("put")
@Override
publicStringput(@RequestBodyStringrequest, HttpSessionsession) {
returnsuper.put(request, session);
 }

/**删除
 * @param request 只用String，避免encode后未decode
 * @param session
 * @return
 * @see {@link RequestMethod#DELETE}
 */
@PostMapping("delete")
@Override
publicStringdelete(@RequestBodyStringrequest, HttpSessionsession) {
returnsuper.delete(request, session);
 }

// 通用接口，非事务型操作 和 简单事务型操作 都可通过这些接口自动化实现 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

// 以上接口对应的简版接口，格式为 {method}/{tag}?format=true&@explain=true.. <<<<<<<<<<<<<<<<<<<<<<<<<

/**增删改查统一接口，这个一个接口可替代 7 个万能通用接口，牺牲一些路由解析性能来提升一点开发效率
 * @param method
 * @param tag
 * @param params
 * @param request
 * @param session
 * @return
 */
@PostMapping("crud/{method}/{tag}") // 直接 {method}/{tag} 或 apijson/{method}/{tag} 会和内置网页的路由有冲突
@Override
publicStringcrudByTag(@PathVariable("method") Stringmethod, @PathVariable("tag") Stringtag
 , @RequestParamMap<String, String> params, @RequestBodyStringrequest, HttpSessionsession) {
returnsuper.crudByTag(method, tag, params, request, session);
 }

/**获取
 * @param request 只用String，避免encode后未decode
 * @param session
 * @return
 * @see {@link RequestMethod#GET}
 */
@PostMapping("get/{tag}") // 虽然看起来 APIAuto 更好识别是否为 APIJSON 万能接口，但 tag 导致空格截断前 Host 不固定不方便批量测试 {tag}/get")
@Override
publicStringgetByTag(@PathVariable("tag") Stringtag, @RequestParamMap<String, String> params, @RequestBodyStringrequest, HttpSessionsession) {
returnsuper.getByTag(tag, params, request, session);
 }

/**计数
 * @param request 只用String，避免encode后未decode
 * @param session
 * @return
 * @see {@link RequestMethod#HEAD}
 */
@PostMapping("head/{tag}")
@Override
publicStringheadByTag(@PathVariable("tag") Stringtag, @RequestParamMap<String, String> params, @RequestBodyStringrequest, HttpSessionsession) {
returnsuper.headByTag(tag, params, request, session);
 }

/**限制性GET，request和response都非明文，浏览器看不到，用于对安全性要求高的GET请求
 * @param request 只用String，避免encode后未decode
 * @param session
 * @return
 * @see {@link RequestMethod#GETS}
 */
@PostMapping("gets/{tag}")
@Override
publicStringgetsByTag(@PathVariable("tag") Stringtag, @RequestParamMap<String, String> params, @RequestBodyStringrequest, HttpSessionsession) {
returnsuper.getsByTag(tag, params, request, session);
 }

/**限制性HEAD，request和response都非明文，浏览器看不到，用于对安全性要求高的HEAD请求
 * @param request 只用String，避免encode后未decode
 * @param session
 * @return
 * @see {@link RequestMethod#HEADS}
 */
@PostMapping("heads/{tag}")
@Override
publicStringheadsByTag(@PathVariable("tag") Stringtag, @RequestParamMap<String, String> params, @RequestBodyStringrequest, HttpSessionsession) {
returnsuper.headsByTag(tag, params, request, session);
 }

/**新增
 * @param request 只用String，避免encode后未decode
 * @param session
 * @return
 * @see {@link RequestMethod#POST}
 */
@PostMapping("post/{tag}")
@Override
publicStringpostByTag(@PathVariable("tag") Stringtag, @RequestParamMap<String, String> params, @RequestBodyStringrequest, HttpSessionsession) {
returnsuper.postByTag(tag, params, request, session);
 }

/**修改
 * @param request 只用String，避免encode后未decode
 * @param session
 * @return
 * @see {@link RequestMethod#PUT}
 */
@PostMapping("put/{tag}")
@Override
publicStringputByTag(@PathVariable("tag") Stringtag, @RequestParamMap<String, String> params, @RequestBodyStringrequest, HttpSessionsession) {
returnsuper.putByTag(tag, params, request, session);
 }

/**删除
 * @param request 只用String，避免encode后未decode
 * @param session
 * @return
 * @see {@link RequestMethod#DELETE}
 */
@PostMapping("delete/{tag}")
@Override
publicStringdeleteByTag(@PathVariable("tag") Stringtag, @RequestParamMap<String, String> params, @RequestBodyStringrequest, HttpSessionsession) {
returnsuper.deleteByTag(tag, params, request, session);
 }

// 以上接口对应的简版接口，格式为 {method}/{tag}?format=true&@explain=true.. >>>>>>>>>>>>>>>>>>>>>>>>>




/**获取
 * 只为兼容HTTP GET请求，推荐用HTTP POST，可删除
 * @param request 只用String，避免encode后未decode
 * @param session
 * @return
 * @see {@link RequestMethod#GET}
 */
@GetMapping("get/{request}")
publicStringopenGet(@PathVariable("request") Stringrequest, HttpSessionsession) {
try {
request = URLDecoder.decode(request, StringUtil.UTF_8);
 } catch (Exceptione) {
// Parser<T, M, L> 会报错
 }

if (! Log.DEBUG) { // 一般情况这样简单使用
returnget(request, session);
 }

// 以下代码是为了方便调试，引导手动/自动跳转 http://apijson.cn/api 来测试接口
StringnewUrl = null;
try {
Stringurl = getRequestURL();

Stringquery = StringUtil.trim(httpServletRequest.getQueryString());
if (StringUtil.isNotEmpty(query)) {
try {
query = "?" + URLEncoder.encode(query, StringUtil.UTF_8);
 } catch (Throwablee) {
e.printStackTrace();
query = "&" + query;
 }
 }

if (StringUtil.isNotEmpty(url)) {
try {
url = URLEncoder.encode(url, StringUtil.UTF_8);
 } catch (Throwablee) {
e.printStackTrace();
 }
 }

Stringreq = request;
if (StringUtil.isNotEmpty(req)) {
try {
req = URLEncoder.encode(req, StringUtil.UTF_8);
 } catch (Throwablee) {
e.printStackTrace();
 }
 }

StringbaseUrl = getRequestBaseURL();
newUrl = baseUrl + "/api/index.html?send=false&redirect=false&type=JSON&decode=true&url="
 + url + query + "&json=" + req;

// httpServletResponse.setHeader("Referer", newUrl);
// httpServletResponse.setHeader("Redirect-Ref", newUrl);
// httpServletResponse.sendRedirect(newUrl);
 } catch (Throwablee) {
e.printStackTrace();
 }

JSONObjectrsp = newParser(session, GET).parseResponse(request);
rsp.put("@link", newUrl);
Stringstr = JSON.format(rsp); // rsp.toJSONString();
if (StringUtil.isEmpty(newUrl) || Math.random() < 0.5) {
returnstr;
 }

Stringhtml = "<!DOCTYPE html>\n" +
"<html>\n" +
"<head>\n" +
" <title>APIAuto-机器学习零代码测试、生成代码与静态检查、生成文档与光标悬浮注释</title>\n" +
" <meta charset=\"utf-8\" />\n" +
"</head>\n" +
"\n" +
"<body>\n" +
" <span style=\"white-space: pre\">" + str + "</span>\n" +
" <script language=\"javascript\">setTimeout(function() {\n" +
" window.open('" + newUrl.replaceAll("'", "\\\\'") + "') \n" +
" }, 5000)</script>\n" +
"</body>";

returnhtml;
 }

/**计数
 * 只为兼容HTTP GET请求，推荐用HTTP POST，可删除
 * @param request 只用String，避免encode后未decode
 * @param session
 * @return
 * @see {@link RequestMethod#HEAD}
 */
@GetMapping("head/{request}")
publicStringopenHead(@PathVariable("request") Stringrequest, HttpSessionsession) {
try {
request = URLDecoder.decode(request, StringUtil.UTF_8);
 } catch (Exceptione) {
// Parser会报错
 }
returnhead(request, session);
 }


//通用接口，非事务型操作 和 简单事务型操作 都可通过这些接口自动化实现>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>










publicstaticfinalStringUSER_;
publicstaticfinalStringPRIVACY_;
publicstaticfinalStringVERIFY_; //加下划线后缀是为了避免 Verify 和 verify 都叫VERIFY，分不清
static {
USER_ = User.class.getSimpleName();
PRIVACY_ = Privacy.class.getSimpleName();
VERIFY_ = Verify.class.getSimpleName();
 }



publicstaticfinalStringCURRENT_USER_ID = "currentUserId";
publicstaticfinalStringNAME = "name";
publicstaticfinalStringPHONE = "phone";
publicstaticfinalStringPASSWORD = "password";
publicstaticfinalString_PASSWORD = "_password";
publicstaticfinalString_PAY_PASSWORD = "_payPassword";
publicstaticfinalStringOLD_PASSWORD = "oldPassword";
publicstaticfinalStringVERIFY = "verify";

publicstaticfinalStringTYPE = "type";
publicstaticfinalStringVALUE = "value";



/**重新加载配置
 * @param request
 * @return
 * @see
 * <pre>
 {
 "type": "ALL", //重载对象，ALL, FUNCTION, REQUEST, ACCESS，非必须
 "phone": "13000082001",
 "verify": "1234567", //验证码，对应类型为 Verify.TYPE_RELOAD
 "value": { // 自定义增量更新条件
 "id": 1 // 过滤条件，符合 APIJSON 查询功能符即可
 }
 }
 * </pre>
 */
@PostMapping("reload")
@Override
publicJSONObjectreload(@RequestBodyStringrequest) {
JSONObjectrequestObject = null;
Stringtype;
JSONObjectvalue;
Stringphone;
Stringverify;
try {
requestObject = DemoParser.parseRequest(request);
type = requestObject.getString(TYPE);
value = requestObject.getJSONObject(VALUE);
phone = requestObject.getString(PHONE);
verify = requestObject.getString(VERIFY);
 } catch (Exceptione) {
returnextendErrorResult(requestObject, e);
 }

JSONResponseresponse = newJSONResponse(headVerify(Verify.TYPE_RELOAD, phone, verify));
response = response.getJSONResponse(VERIFY_);
if (JSONResponse.isExist(response) == false) {
returnextendErrorResult(requestObject, newConditionErrorException("手机号或验证码错误"));
 }

JSONObjectresult = newSuccessResult();

booleanreloadAll = StringUtil.isEmpty(type, true) || "ALL".equals(type);

if (reloadAll || "ACCESS".equals(type)) {
try {
result.put(ACCESS_, DemoVerifier.initAccess(false, null, value));
 } catch (ServerExceptione) {
e.printStackTrace();
result.put(ACCESS_, newErrorResult(e));
 }
 }

if (reloadAll || "FUNCTION".equals(type)) {
try {
result.put(FUNCTION_, DemoFunctionParser.init(false, null, value));
 } catch (ServerExceptione) {
e.printStackTrace();
result.put(FUNCTION_, newErrorResult(e));
 }
 }

if (reloadAll || "REQUEST".equals(type)) {
try {
result.put(REQUEST_, DemoVerifier.initRequest(false, null, value));
 } catch (ServerExceptione) {
e.printStackTrace();
result.put(REQUEST_, newErrorResult(e));
 }
 }

returnresult;
 }

/**生成验证码,修改为post请求
 * @param request
 * @see
 * <pre>
 {
 "type": 0, //类型，0,1,2,3,4，非必须
 "phone": "13000082001"
 }
 * </pre>
 */
@PostMapping("post/verify")
publicJSONObjectpostVerify(@RequestBodyStringrequest) {
JSONObjectrequestObject = null;
inttype;
Stringphone;
try {
requestObject = DemoParser.parseRequest(request);
type = requestObject.getIntValue(TYPE);
phone = requestObject.getString(PHONE);
 } catch (Exceptione) {
returnextendErrorResult(requestObject, e);
 }

newDemoParser(DELETE, false).parse(newVerifyRequest(type, phone));

JSONObjectresponse = newDemoParser(POST, false).parseResponse(
newVerifyRequest(type, phone, "" + (newRandom().nextInt(9999) + 1000))
 );


if (JSONResponse.isSuccess(response) == false) {
newDemoParser(DELETE, false).parseResponse(newVerifyRequest(type, phone));
returnresponse;
 }

//TODO 这里直接返回验证码，方便测试。实际上应该只返回成功信息，验证码通过短信发送
JSONObjectobject = newJSONObject();
object.put(TYPE, type);
object.put(PHONE, phone);
returngetVerify(JSON.toJSONString(object));
 }

/**获取验证码
 * @param request
 * @see
 * <pre>
 {
 "type": 0, //类型，0,1,2,3,4，非必须
 "phone": "13000082001"
 }
 * </pre>
 */
@PostMapping("gets/verify")
publicJSONObjectgetVerify(@RequestBodyStringrequest) {
JSONObjectrequestObject = null;
inttype;
Stringphone;
try {
requestObject = DemoParser.parseRequest(request);
type = requestObject.getIntValue(TYPE);
phone = requestObject.getString(PHONE);
 } catch (Exceptione) {
returnextendErrorResult(requestObject, e);
 }
returnnewDemoParser(GETS, false).parseResponse(newVerifyRequest(type, phone));
 }

/**校验验证码
 * @param request
 * @see
 * <pre>
 {
 "type": 0, //类型，0,1,2,3,4，非必须
 "phone": "13000082001",
 "verify": "123456"
 }
 * </pre>
 */
@PostMapping("heads/verify")
publicJSONObjectheadVerify(@RequestBodyStringrequest) {
JSONObjectrequestObject = null;
inttype;
Stringphone;
Stringverify;
try {
requestObject = DemoParser.parseRequest(request);
type = requestObject.getIntValue(TYPE);
phone = requestObject.getString(PHONE);
verify = requestObject.getString(VERIFY);
 } catch (Exceptione) {
returnextendErrorResult(requestObject, e);
 }
returnheadVerify(type, phone, verify);
 }

/**校验验证码
 * @author Lemon
 * @param type
 * @param phone
 * @param code
 * @return
 */
publicJSONObjectheadVerify(inttype, Stringphone, Stringcode) {
JSONResponseresponse = newJSONResponse(
newDemoParser(GETS, false).parseResponse(
newVerifyRequest(type, phone, code)
 )
 );
Verifyverify = response.getObject(Verify.class);
if (verify == null) {
returnnewErrorResult(StringUtil.isEmpty(code, true)
 ? newNotExistException("验证码不存在！") : newConditionErrorException("手机号或验证码错误！"));
 }

//验证码过期
longtime = BaseModel.getTimeMillis(verify.getDate());
longnow = System.currentTimeMillis();
if (now > 60*1000 + time) {
newDemoParser(DELETE, false).parseResponse(
newVerifyRequest(type, phone)
 );
returnnewErrorResult(newTimeoutException("验证码已过期！"));
 }

returnnewDemoParser(HEADS, false).parseResponse(
newVerifyRequest(type, phone, code)
 );
 }



/**新建一个验证码请求
 * @param phone
 * @param phone
 * @return
 */
publicstaticJSONObjectnewVerifyRequest(inttype, Stringphone) {
returnnewVerifyRequest(type, phone, null);
 }
/**新建一个验证码请求
 * @param type
 * @param phone
 * @param verify
 * @return
 */
publicstaticJSONObjectnewVerifyRequest(inttype, Stringphone, Stringverify) {
returnnewJSONRequest(
newVerify(type, phone).setVerify(verify)
 ).setTag(VERIFY_).setFormat(true);
 }


publicstaticfinalStringLOGIN = "login";
publicstaticfinalStringAS_DB_ACCOUNT = "asDBAccount";
publicstaticfinalStringREMEMBER = "remember";
publicstaticfinalStringDEFAULTS = "defaults";

publicstaticfinalintLOGIN_TYPE_PASSWORD = 0;//密码登录
publicstaticfinalintLOGIN_TYPE_VERIFY = 1;//验证码登录
/**用户登录
 * @param request 只用String，避免encode后未decode
 * @return
 * @see
 * <pre>
 {
 "type": 0, //登录方式，非必须 0-密码 1-验证码
 "phone": "13000082001",
 "password": "1234567",
 "version": 1 //全局版本号，非必须
 }
 * </pre>
 */
@PostMapping(LOGIN) //TODO 改 SQLConfig<T, M, L> 里的 dbAccount, dbPassword，直接用数据库鉴权
publicJSONObjectlogin(@RequestBodyStringrequest, HttpSessionsession) {
JSONObjectrequestObject = null;
booleanisPassword;
Stringphone;
Stringpassword;
intversion;
Booleanformat;
booleanremember;
BooleanasDBAccount;
JSONObjectdefaults;
try {
requestObject = DemoParser.parseRequest(request);

isPassword = requestObject.getIntValue(TYPE) == LOGIN_TYPE_PASSWORD;//登录方式
phone = requestObject.getString(PHONE);//手机
password = requestObject.getString(PASSWORD);//密码

if (StringUtil.isPhone(phone) == false) {
thrownewIllegalArgumentException("手机号不合法！");
 }

if (isPassword) {
if (StringUtil.isPassword(password) == false) {
thrownewIllegalArgumentException("密码不合法！");
 }
 } else {
if (StringUtil.isVerify(password) == false) {
thrownewIllegalArgumentException("验证码不合法！");
 }
 }

version = requestObject.getIntValue(VERSION);
format = requestObject.getBoolean(FORMAT);
remember = requestObject.getBooleanValue(REMEMBER);
asDBAccount = requestObject.getBoolean(AS_DB_ACCOUNT);
defaults = requestObject.getJSONObject(DEFAULTS); //默认加到每个请求最外层的字段
requestObject.remove(VERSION);
requestObject.remove(FORMAT);
requestObject.remove(REMEMBER);
requestObject.remove(DEFAULTS);
 } catch (Exceptione) {
returnextendErrorResult(requestObject, e);
 }


//手机号是否已注册
JSONObjectphoneResponse = newDemoParser(HEADS, false).parseResponse(
newJSONRequest(newPrivacy().setPhone(phone))
 );
if (JSONResponse.isSuccess(phoneResponse) == false) {
returnnewResult(phoneResponse.getIntValue(JSONResponse.KEY_CODE), getString(phoneResponse, JSONResponse.KEY_MSG));
 }
JSONResponseresponse = newJSONResponse(phoneResponse).getJSONResponse(PRIVACY_);
if(JSONResponse.isExist(response) == false) {
returnnewErrorResult(newNotExistException("手机号未注册"));
 }

//根据phone获取User
JSONObjectprivacyResponse = newDemoParser(GETS, false).parseResponse(
newJSONRequest(
newPrivacy().setPhone(phone)
 ).setFormat(true)
 );
response = newJSONResponse(privacyResponse);

Privacyprivacy = response == null ? null : response.getObject(Privacy.class);
longuserId = privacy == null ? 0 : BaseModel.value(privacy.getId());
if (userId <= 0) {
returnprivacyResponse;
 }

//校验凭证
if (isPassword) { //password 密码登录
response = newJSONResponse(
newDemoParser(HEADS, false).parseResponse(
newJSONRequest(newPrivacy(userId).setPassword(password))
 )
 );
 } else {//verify手机验证码登录
response = newJSONResponse(headVerify(Verify.TYPE_LOGIN, phone, password));
 }
if (JSONResponse.isSuccess(response) == false) {
returnresponse.toObject(JSONObject.class);
 }
response = response.getJSONResponse(isPassword ? PRIVACY_ : VERIFY_);
if (JSONResponse.isExist(response) == false) {
returnnewErrorResult(newConditionErrorException("账号或密码错误"));
 }

response = newJSONResponse(
newDemoParser(GETS, false).parseResponse(
newJSONRequest( // 兼容 MySQL 5.6 及以下等不支持 json 类型的数据库
USER_, // User 里在 setContactIdList(List<Long>) 后加 setContactIdList(String) 没用
JSONRequest.setJson(JSON.parseObject(newUser(userId)),"contactIdList,pictureList")
 )
 .setFormat(true)
 )
 );
Useruser = response.getObject(User.class);
if (user == null || BaseModel.value(user.getId()) != userId) {
returnnewErrorResult(newNullPointerException("服务器内部错误"));
 }

//登录状态保存至session
super.login(session, user, version, format, defaults);
session.setAttribute(USER_ID, userId); //用户id
session.setAttribute(TYPE, isPassword ? LOGIN_TYPE_PASSWORD : LOGIN_TYPE_VERIFY); //登录方式
session.setAttribute(USER_, user); //用户
session.setAttribute(PRIVACY_, privacy); //用户隐私信息
session.setAttribute(REMEMBER, remember); //是否记住登录
session.setAttribute(AS_DB_ACCOUNT, asDBAccount); //是否作为数据库账号密码
session.setMaxInactiveInterval(60*60*24*(remember ? 7 : 1)); //设置session过期时间

response.put(REMEMBER, remember);
response.put(DEFAULTS, defaults);
returnresponse;
 }

/**退出登录，清空session
 * @param session
 * @return
 */
@PostMapping("logout")
@Override
publicJSONObjectlogout(HttpSessionsession) {
if (session != null) {
SESSION_MAP.remove(session.getId());
 }

LonguserId;
try {
userId = DemoVerifier.getVisitorId(session);//必须在session.invalidate();前！
Log.d(TAG, "logout userId = " + userId + "; session.getId() = " + (session == null ? null : session.getId()));
super.logout(session);
 } catch (Exceptione) {
returnnewErrorResult(e);
 }

JSONObjectresult = newSuccessResult();
JSONObjectuser = newSuccessResult();
user.put(ID, userId);
user.put(COUNT, 1);
result.put(StringUtil.firstCase(USER_), user);

returnresult;
 }


privatestaticfinalStringREGISTER = "register";
/**注册
 * @param request 只用String，避免encode后未decode
 * @return
 * @see
 * <pre>
 {
 "Privacy": {
 "phone": "13000082222",
 "_password": "123456"
 },
 "User": {
 "name": "APIJSONUser"
 },
 "verify": "1234"
 }
 * </pre>
 */
@PostMapping(REGISTER)
publicJSONObjectregister(@RequestBodyStringrequest) {
JSONObjectrequestObject = null;

JSONObjectprivacyObj;

Stringphone;
Stringverify;
Stringpassword;
try {
requestObject = DemoParser.parseRequest(request);
privacyObj = requestObject.getJSONObject(PRIVACY_);

phone = StringUtil.get(privacyObj.getString(PHONE));
verify = requestObject.getString(VERIFY);
password = privacyObj.getString(_PASSWORD);

if (StringUtil.isPhone(phone) == false) {
returnnewIllegalArgumentResult(requestObject, PRIVACY_ + "/" + PHONE);
 }
if (StringUtil.isPassword(password) == false) {
returnnewIllegalArgumentResult(requestObject, PRIVACY_ + "/" + _PASSWORD);
 }
if (StringUtil.isVerify(verify) == false) {
returnnewIllegalArgumentResult(requestObject, VERIFY);
 }
 } catch (Exceptione) {
returnextendErrorResult(requestObject, e);
 }


JSONResponseresponse = newJSONResponse(headVerify(Verify.TYPE_REGISTER, phone, verify));
if (JSONResponse.isSuccess(response) == false) {
returnresponse;
 }
//手机号或验证码错误
if (JSONResponse.isExist(response.getJSONResponse(VERIFY_)) == false) {
returnextendErrorResult(response, newConditionErrorException("手机号或验证码错误！"));
 }

//生成User和Privacy
if (StringUtil.isEmpty(requestObject.getString(JSONRequest.KEY_TAG), true)) {
requestObject.put(JSONRequest.KEY_TAG, REGISTER);
 }
requestObject.put(JSONRequest.KEY_FORMAT, true);
response = newJSONResponse(
newDemoParser(POST).setNeedVerifyLogin(false).parseResponse(requestObject)
 );

//验证User和Privacy
Useruser = response.getObject(User.class);
longuserId = user == null ? 0 : BaseModel.value(user.getId());
Privacyprivacy = response.getObject(Privacy.class);
longuserId2 = privacy == null ? 0 : BaseModel.value(privacy.getId());
Exceptione = null;
if (userId <= 0 || userId != userId2) { //id不同
e = newException("服务器内部错误！写入User或Privacy失败！");
 }

if (e != null) { //出现错误，回退
newDemoParser(DELETE, false).parseResponse(
newJSONRequest(newUser(userId))
 );
newDemoParser(DELETE, false).parseResponse(
newJSONRequest(newPrivacy(userId2))
 );
 }

returnresponse;
 }


/**
 * @param requestObject
 * @param key
 * @return
 */
publicstaticJSONObjectnewIllegalArgumentResult(JSONObjectrequestObject, Stringkey) {
returnnewIllegalArgumentResult(requestObject, key, null);