电商项目总结(二)
用户模块
总共会有11个接口:
登录
封装统一返回对象:这里的isSuccess()方法是不需要返回给前端的,这个时候,我们就可以给它加上一个注解@JsonIgnore
//使之不在json序列化的结果当中
@JsonIgnore
public boolean isSuccess() {
return this.status == ResponseCode.SUCCESS.getCode();
}
还有一个需要注意的地方就是,如果我们有的时候,比如说数据data,或者是提示信息msg,当这些没有的时候,返回的json里面就是会出现{null:null,}的key,value出现,这个时候,如果我们不想这个空的key,value出现,我们就可以在类上面加上这样的一个注解:
//保证序列化json的时候,如果是NULL值的对象,key值是会消失
@JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL)
package com.mmall.common;
import org.codehaus.jackson.annotate.JsonIgnore;
import org.codehaus.jackson.map.annotate.JsonSerialize;
import java.io.Serializable;
//保证序列化json的时候,如果是NULL值的对象,key值是会消失
@JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL)
public class ServerResponse<T> implements Serializable {
/** 返回的状态 */
private int status;
/** 返回的信息 */
private String msg;
/** 返回的数据对象 */
private T data;
private ServerResponse(int status) {
this.status = status;
}
private ServerResponse(int status, T data) {
this.status = status;
this.data = data;
}
private ServerResponse(int status, String msg, T data) {
this.status = status;
this.msg = msg;
this.data = data;
}
private ServerResponse(int status, String msg) {
this.status = status;
this.msg = msg;
}
//使之不在json序列化的结果当中
@JsonIgnore
public boolean isSuccess() {
return this.status == ResponseCode.SUCCESS.getCode();
}
public int getStatus() {
return status;
}
public String getMsg() {
return msg;
}
public T getData() {
return data;
}
/**这个时候,如果我们还要开放的话,就要用静态的方法来进行一个开放了*/
/**这个方法就是会返回一个status的*/
public static <T> ServerResponse<T> createBySuccess() {
return new ServerResponse<T>(ResponseCode.SUCCESS.getCode());
}
/**这个方法就是会返回一个status,并且返回了一个提示的信息*/
public static <T> ServerResponse<T> createBySuccessMessage(String msg) {
return new ServerResponse<T>(ResponseCode.SUCCESS.getCode(),msg);
}
/**返回一个单纯成功响应后的数据*/
public static <T> ServerResponse<T> createBySuccess(T data) {
return new ServerResponse<T>(ResponseCode.SUCCESS.getCode(),data);
}
/**返回一个单纯成功响应后的数据*/
public static <T> ServerResponse<T> createBySuccess(String msg,T data) {
return new ServerResponse<T>(ResponseCode.SUCCESS.getCode(), msg, data);
}
/**单纯的错误的状态码和错误信息的*/
public static <T> ServerResponse<T> createByError() {
return new ServerResponse<T>(ResponseCode.ERROR.getCode(),ResponseCode.ERROR.getDesc());
}
/**单纯的错误的状态码和自己填写的错误信息的*/
public static <T> ServerResponse<T> createByErrorMessage(String errorMessage) {
return new ServerResponse<T>(ResponseCode.ERROR.getCode(),errorMessage);
}
/**这里还要写上一个把状态码作为一个变量来写的*/
public static <T> ServerResponse<T> createByErrorCodeMessage(int errorCode,String errorMessage) {
return new ServerResponse<T>(errorCode,errorMessage);
}
}
返回状态码的枚举:
public enum ResponseCode {
SUCCESS(0, "SUCCESS"),
ERROR(1, "ERROR"),
NEED_LOGIN(10, "NEED_LOGIN"),
ILLEGAL_ARGUMENT(2, "ILLEGAL_ARGUMENT");
private final int code;
private final String desc;
ResponseCode(int code, String desc) {
this.code = code;
this.desc = desc;
}
public int getCode() {
return code;
}
public String getDesc() {
return desc;
}
}
这个就是service实现类的写法:当我们需要把返回的user的密码置为空的话,我们就是可以用**user.setPassword(org.apache.commons.lang3.StringUtils.EMPTY);**来把密码置为空;
@Override
public ServerResponse<User> login(String username, String password) {
int resultCount = userMapper.checkUsername(username);
if (resultCount == 0) {
return ServerResponse.createByErrorMessage("用户名不存在");
}
String md5Password = MD5Util.MD5EncodeUtf8(password);
User user = userMapper.selectLogin(username, md5Password);
if (user == null) {
return ServerResponse.createByErrorMessage("密码错误");
}
//返回给前端的密码置为空
user.setPassword(org.apache.commons.lang3.StringUtils.EMPTY);
return ServerResponse.createBySuccess("登录成功", user);
}
- 当传入多个参数的时候,我们就可以用这个:
parameterType=“map”
- 我们可以用这个在映射文件里面写的这个:
<resultMap id="BaseResultMap" type="com.mmall.pojo.User" >
<constructor >
<idArg column="id" jdbcType="INTEGER" javaType="java.lang.Integer" />
<arg column="username" jdbcType="VARCHAR" javaType="java.lang.String" />
<arg column="password" jdbcType="VARCHAR" javaType="java.lang.String" />
<arg column="email" jdbcType="VARCHAR" javaType="java.lang.String" />
<arg column="phone" jdbcType="VARCHAR" javaType="java.lang.String" />
<arg column="question" jdbcType="VARCHAR" javaType="java.lang.String" />
<arg column="answer" jdbcType="VARCHAR" javaType="java.lang.String" />
<arg column="role" jdbcType="INTEGER" javaType="java.lang.Integer" />
<arg column="create_time" jdbcType="TIMESTAMP" javaType="java.util.Date" />
<arg column="update_time" jdbcType="TIMESTAMP" javaType="java.util.Date" />
</constructor>
</resultMap>
这个时候,我们就是可以用这个来引用:
resultMap=“BaseResultMap”
- 我们传进去的参数用#号是可以防止sql注入的:
<select id="checkEmail" resultType="int" parameterType="string">
select count(1) from mmall_user
where email=#{email}
</select>
在controller进行调用,如果登录成功了,我们就往session里面放user的信息,我们可以定义一个常量类,
public class Const {
/** 当前的用户 */
public static final String CURRENT_USER = "currentUser";
}
Controller:
@RequestMapping(value = "login.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<User> login(String username, String password, HttpSession session) {
ServerResponse<User> response = iUserService.login(username, password);
if (response.isSuccess()) {
session.setAttribute(Const.CURRENT_USER, response.getData());
}
return response;
}
退出登录
使session失效:
@RequestMapping(value = "logout.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<String> logOut(HttpSession session) {
session.removeAttribute(Const.CURRENT_USER);
return ServerResponse.createBySuccess();
}
注册
说明:先通过checkValid方法对用户名和email进行校验,
@Override
public ServerResponse<String> checkValid(String str, String type) {
if (StringUtils.isNotBlank(type)) {
/** 开始校验 */
if (Const.USERNAME.equals(type)) {
int resultCount = userMapper.checkUsername(str);
if (resultCount > 0) {
return ServerResponse.createByErrorMessage("用户名已存在");
}
}
if (Const.EMAIL.equals(type)) {
int resultCount = userMapper.checkEmail(str);
if (resultCount > 0) {
return ServerResponse.createByErrorMessage("email已存在");
}
}
} else {
ServerResponse.createByErrorMessage("参数错误");
}
return ServerResponse.createBySuccessMessage("校验成功");
}
注册的逻辑:先进行用户名和email进行校验,看是否已经存在相同的用户名和email;
并且给它一个默认的角色是普通用户:
@Override
public ServerResponse<String> register(User user) {
ServerResponse validResponse = this.checkValid(user.getUsername(), Const.USERNAME);
if (!validResponse.isSuccess()) {
return validResponse;
}
validResponse = this.checkValid(user.getEmail(), Const.EMAIL);
if (!validResponse.isSuccess()) {
return validResponse;
}
/** 给它一个默认的普通用户,而不是管理员 */
user.setRole(Const.Role.ROLE_CUSTOMER);
/** MD5加密 */
user.setPassword(MD5Util.MD5EncodeUtf8(user.getPassword()));
int resultCount = userMapper.insert(user);
if (resultCount == 0) {
return ServerResponse.createByErrorMessage("注册失败");
}
return ServerResponse.createBySuccessMessage("注册成功");
}
我们在常量类里面定义了一个接口,可以起到一个分组的作用,接着,我们就可以这样来访问了:Const.Role.ROLE_CUSTOMER
@Controller
@RequestMapping("/user/")
public class UserController {
@Autowired
private IUserService iUserService;
/**
* 用户登录
*
* @param username
* @param password
* @param session
* @return
*/
@RequestMapping(value = "login.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<User> login(String username, String password, HttpSession session) {
ServerResponse<User> response = iUserService.login(username, password);
if (response.isSuccess()) {
session.setAttribute(Const.CURRENT_USER, response.getData());
}
return response;
}
/**
* 登出的功能
*
* @param session
* @return
*/
@RequestMapping(value = "logout.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<String> logOut(HttpSession session) {
session.removeAttribute(Const.CURRENT_USER);
return ServerResponse.createBySuccess();
}
/**
* 注册
* @param user
* @return
*/
@RequestMapping(value = "register.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<String> register(User user) {
return iUserService.register(user);
}
/**
* 参数的校验
* @param str
* @param type
* @return
*/
@RequestMapping(value = "check_valid.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<String> checkValid(String str, String type) {
return iUserService.checkValid(str, type);
}
/**
* 查询用户信息
* @param session
* @return
*/
@RequestMapping(value = "get_user_info.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<User> getUserInfo( HttpSession session ){
User user = (User) session.getAttribute(Const.CURRENT_USER);
if (user != null) {
return ServerResponse.createBySuccess(user);
}
return ServerResponse.createByErrorMessage("用户未登录,无法获取当前用户的信息");
}
/**
* 查询当前用户的找回密码的提示问题
* @param username
* @return
*/
@RequestMapping(value = "forget_get_question.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<String> forgetGetQuestion(String username) {
return iUserService.selectQuestion(username);
}
/**
* 校验提示问题的答案是否正确
* @param username
* @param question
* @param answer
* @return
*/
@RequestMapping(value = "forget_check_answer.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<String> forgetCheckAnswer(String username, String question,String answer) {
return iUserService.forgetCheckAnswer(username, question, answer);
}
/**
* 忘记密码的重置密码
* @param username
* @param passwordNew
* @param forgetToken
* @return
*/
@RequestMapping(value = "forget_reset_password.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<String> forgetResetPassword(String username,String passwordNew,String forgetToken) {
return iUserService.forgetResetPassword(username, passwordNew, forgetToken);
}
/**
* 登录状态下的重置密码
* @param session
* @param passwordOld
* @param passwordNew
* @return
*/
@RequestMapping(value = "reset_password.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<String> restPassword(HttpSession session, String passwordOld, String passwordNew) {
User user = (User) session.getAttribute(Const.CURRENT_USER);
if (user == null) {
return ServerResponse.createByErrorMessage("用户未登录");
}
return iUserService.restPassword(passwordOld, passwordNew, user);
}
/**
* 更新用户的信息
* @param session
* @param user
* @return
*/
@RequestMapping(value = "update_information.do",method = RequestMethod.POST)
@ResponseBody
public ServerResponse<User> update_information(HttpSession session,User user){
User currentUser = (User)session.getAttribute(Const.CURRENT_USER);
if(currentUser == null){
return ServerResponse.createByErrorMessage("用户未登录");
}
user.setId(currentUser.getId());
user.setUsername(currentUser.getUsername());
ServerResponse<User> response = iUserService.updateInformation(user);
if(response.isSuccess()){
response.getData().setUsername(currentUser.getUsername());
session.setAttribute(Const.CURRENT_USER,response.getData());
}
return response;
}
/**
* 获取用户的详细信息
* @param session
* @return
*/
@RequestMapping(value = "get_information.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<User> get_information(HttpSession session){
/** 判断是否登录,只有在登录的状态下才能获取到用户的信息 */
User currentUser = (User) session.getAttribute(Const.CURRENT_USER);
if (currentUser == null) {
return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "用户未登录,无法获取当前用户信息,status=10,强制登录");
}
return iUserService.getInformation(currentUser.getId());
}
}
MD5加密:
public class MD5Util {
private static String byteArrayToHexString(byte b[]) {
StringBuffer resultSb = new StringBuffer();
for (int i = 0; i < b.length; i++) {
resultSb.append(byteToHexString(b[i]));
}
return resultSb.toString();
}
private static String byteToHexString(byte b) {
int n = b;
if (n < 0) {
n += 256;
}
int d1 = n / 16;
int d2 = n % 16;
return hexDigits[d1] + hexDigits[d2];
}
/**
* 返回大写MD5
*
* @param origin
* @param charsetname
* @return
*/
private static String MD5Encode(String origin, String charsetname) {
String resultString = null;
try {
resultString = new String(origin);
MessageDigest md = MessageDigest.getInstance("MD5");
if (charsetname == null || "".equals(charsetname)) {
resultString = byteArrayToHexString(md.digest(resultString.getBytes()));
} else {
resultString = byteArrayToHexString(md.digest(resultString.getBytes(charsetname)));
}
} catch (Exception exception) {
}
return resultString.toUpperCase();
}
public static String MD5EncodeUtf8(String origin) {
origin = origin + PropertiesUtil.getProperty("password.salt", "");
return MD5Encode(origin, "utf-8");
}
private static final String hexDigits[] = {"0", "1", "2", "3", "4", "5",
"6", "7", "8", "9", "a", "b", "c", "d", "e", "f"};
}
用户名的验证
@RequestMapping(value = "check_valid.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<String> checkValid(String str, String type) {
return iUserService.checkValid(str, type);
}
service的实现逻辑:
@Override
public ServerResponse<String> checkValid(String str, String type) {
if (StringUtils.isNotBlank(type)) {
/** 开始校验 */
if (Const.USERNAME.equals(type)) {
int resultCount = userMapper.checkUsername(str);
if (resultCount > 0) {
return ServerResponse.createByErrorMessage("用户名已存在");
}
}
if (Const.EMAIL.equals(type)) {
int resultCount = userMapper.checkEmail(str);
if (resultCount > 0) {
return ServerResponse.createByErrorMessage("email已存在");
}
}
} else {
ServerResponse.createByErrorMessage("参数错误");
}
return ServerResponse.createBySuccessMessage("校验成功");
}
StringUtils.isNotBlank()和StringUtils.isNotEmpty()的区别:
获取用户信息
从session里面获取:
@RequestMapping(value = "get_user_info.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<User> getUserInfo( HttpSession session ){
User user = (User) session.getAttribute(Const.CURRENT_USER);
if (user != null) {
return ServerResponse.createBySuccess(user);
}
return ServerResponse.createByErrorMessage("用户未登录,无法获取当前用户的信息");
}
忘记密码的提交问题的查询
找到忘记密码的提示问题:
/**
* 查询当前用户的找回密码的提示问题
* @param username
* @return
*/
@RequestMapping(value = "forget_get_question.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<String> forgetGetQuestion(String username) {
return iUserService.selectQuestion(username);
}
业务逻辑:
@Override
public ServerResponse<String> selectQuestion(String username) {
ServerResponse validResponse = this.checkValid(username, Const.USERNAME);
if (validResponse.isSuccess()) {
//用户不存在
return ServerResponse.createByErrorMessage("用户不存在");
}
String question = userMapper.selectQuestionByUsername(username);
if (StringUtils.isNotBlank(question)) {
return ServerResponse.createBySuccess(question);
}
return ServerResponse.createByErrorMessage("找回密码的问题是空的");
}
校验问题的答案是不是正确的
/**
* 校验提示问题的答案是否正确
* @param username
* @param question
* @param answer
* @return
*/
@RequestMapping(value = "forget_check_answer.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<String> forgetCheckAnswer(String username, String question,String answer) {
return iUserService.forgetCheckAnswer(username, question, answer);
}
@Override
public ServerResponse<String> forgetCheckAnswer(String username, String question, String answer) {
int resultCount = userMapper.checkAnswer(username, question, answer);
if (resultCount > 0) {
//问题及问题的答案是这个用户的,并且是正确的
String forgetToken = UUID.randomUUID().toString();
TokenCache.setKey(TokenCache.TOKEN_PREFIX+username, forgetToken);
return ServerResponse.createBySuccess(forgetToken);
}
return ServerResponse.createByErrorMessage("问题的答案错误");
}
这里用到了guava缓存:
public class TokenCache {
/** logger */
private static final Logger logger = LoggerFactory.getLogger(TokenCache.class);
public static final String TOKEN_PREFIX = "token_";
/**
* LRU算法
*/
private static LoadingCache<String, String> localCache = CacheBuilder
.newBuilder()
.initialCapacity(1000)
.maximumSize(10000)
.expireAfterAccess(12, TimeUnit.HOURS).build(new CacheLoader<String, String>() {
/** 默认的数据加载实现,当调用get取值的时候,key没有对应的值,就调用该方法进行加载 */
@Override
public String load(String key) throws Exception {
return "null";
}
});
public static void setKey(String key,String value) {
localCache.put(key, value);
}
public static String getKey(String key) {
String value = null;
try {
value = localCache.get(key);
if ("null".equals(value)) {
return null;
}
return value;
} catch (ExecutionException e) {
logger.error("localCache get error", e);
}
return null;
}
}
重置密码
忘记密码的重置密码
/**
* 忘记密码的重置密码
* @param username
* @param passwordNew
* @param forgetToken
* @return
*/
@RequestMapping(value = "forget_reset_password.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<String> forgetResetPassword(String username,String passwordNew,String forgetToken) {
return iUserService.forgetResetPassword(username, passwordNew, forgetToken);
}
业务逻辑:
@Override
public ServerResponse<String> forgetResetPassword(String username, String password, String forgetToken) {
if (StringUtils.isBlank(forgetToken)) {
ServerResponse.createByErrorMessage("参数错误,token需要传递");
}
ServerResponse validResponse = this.checkValid(username, Const.USERNAME);
if (validResponse.isSuccess()) {
//用户不存在
return ServerResponse.createByErrorMessage("用户不存在");
}
String token = TokenCache.getKey(TokenCache.TOKEN_PREFIX + username);
if (StringUtils.isBlank(token)) {
return ServerResponse.createByErrorMessage("token无效或者过期");
}
if (StringUtils.equals(forgetToken, token)) {
String md5Password = MD5Util.MD5EncodeUtf8(password);
int rowCount = userMapper.updatePasswordByUsername(username, md5Password);
if (rowCount > 0) {
return ServerResponse.createBySuccessMessage("修改密码成功");
}
} else {
return ServerResponse.createByErrorMessage("token错误,请重新获取重置密码的token");
}
return ServerResponse.createByErrorMessage("修改密码失败");
}
- 我们可以使用StringUtils.equals(forgetToken, token)这个方法来对比两个字符串是否相同;这种写法就不用特意去把常量写在前面去防止空指针异常了;
登录状态的重置密码
/**
* 登录状态下的重置密码
* @param session
* @param passwordOld
* @param passwordNew
* @return
*/
@RequestMapping(value = "reset_password.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<String> restPassword(HttpSession session, String passwordOld, String passwordNew) {
User user = (User) session.getAttribute(Const.CURRENT_USER);
if (user == null) {
return ServerResponse.createByErrorMessage("用户未登录");
}
return iUserService.restPassword(passwordOld, passwordNew, user);
}
业务逻辑:
@Override
public ServerResponse<String> restPassword(String passwordOld, String passwordNew, User user) {
//防止横向越权,要校验一下这个用户的旧密码,一定要指定是这个用户,
//因为我们会查询一个count(1),如果不指定id,那么结果就是true,count>0
int resultCount = userMapper.checkPassword(MD5Util.MD5EncodeUtf8(passwordOld), user.getId());
if (resultCount == 0) {
return ServerResponse.createByErrorMessage("旧密码错误");
}
user.setPassword(MD5Util.MD5EncodeUtf8(passwordNew));
int updateCount = userMapper.updateByPrimaryKeySelective(user);
if (updateCount > 0) {
return ServerResponse.createBySuccessMessage("密码更新成功");
}
return ServerResponse.createByErrorMessage("密码更新失败");
}
更新用户信息
/**
* 更新用户的信息
* @param session
* @param user
* @return
*/
@RequestMapping(value = "update_information.do",method = RequestMethod.POST)
@ResponseBody
public ServerResponse<User> update_information(HttpSession session,User user){
User currentUser = (User)session.getAttribute(Const.CURRENT_USER);
if(currentUser == null){
return ServerResponse.createByErrorMessage("用户未登录");
}
user.setId(currentUser.getId());
user.setUsername(currentUser.getUsername());
ServerResponse<User> response = iUserService.updateInformation(user);
if(response.isSuccess()){
response.getData().setUsername(currentUser.getUsername());
session.setAttribute(Const.CURRENT_USER,response.getData());
}
return response;
}
业务逻辑:
@Override
public ServerResponse<User> updateInformation(User user) {
//username是不能给更新的
//email也要进行一个校验,校验新的email是不是已经存在,并且存在的email如果是相同的话,那么不能是我们当前的这个用户的
int resultCount = userMapper.checkEmailByUserId(user.getEmail(), user.getId());
if (resultCount > 0) {
return ServerResponse.createByErrorMessage("email已存在,请更换eamil再尝试更新");
}
User updateUser = new User();
updateUser.setId(user.getId());
updateUser.setEmail(user.getEmail());
updateUser.setPhone(user.getPhone());
updateUser.setQuestion(user.getQuestion());
updateUser.setAnswer(user.getAnswer());
int updateCount = userMapper.updateByPrimaryKeySelective(updateUser);
if (updateCount > 0) {
return ServerResponse.createBySuccess("更新各人信息成功",updateUser);
}
return ServerResponse.createByErrorMessage("更新各人信息失败");
}
我们要查看修改之后的邮箱是否已经被其他人给占用了:
获取用户的详细信息
只有在登录的状态下才能获取用户的详细信息:
/**
* 获取用户的详细信息
* @param session
* @return
*/
@RequestMapping(value = "get_information.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<User> get_information(HttpSession session){
/** 判断是否登录,只有在登录的状态下才能获取到用户的信息 */
User currentUser = (User) session.getAttribute(Const.CURRENT_USER);
if (currentUser == null) {
return ServerResponse.createByErrorCodeMessage(ResponseCode.NEED_LOGIN.getCode(), "用户未登录,无法获取当前用户信息,status=10,强制登录");
}
return iUserService.getInformation(currentUser.getId());
}
业务逻辑:
@Override
public ServerResponse<User> getInformation(Integer userId) {
User user = userMapper.selectByPrimaryKey(userId);
if (user == null) {
return ServerResponse.createByErrorMessage("找不到当前的用户");
}
//如果找到了,我们需要把这个密码置空再返回给前端
user.setPassword(StringUtils.EMPTY);
return ServerResponse.createBySuccess(user);
}
后台管理员登录
@RequestMapping(value = "login.do", method = RequestMethod.POST)
@ResponseBody
public ServerResponse<User> login(String username, String password, HttpSession session) {
ServerResponse<User> response = iuserService.login(username, password);
if (response.isSuccess()) {
User user = response.getData();
if (user.getRole() == Const.Role.ROLE_ADMIN) {
//说明登录的是管理员
session.setAttribute(Const.CURRENT_USER, user);
return response;
} else {
ServerResponse.createByErrorMessage("不是管理员,无法登录");
}
}
return response;
}
小技巧:在idea里面用Alt+F7查看这个方法在哪里被引用了;