@Data
public class ResultAjax {
private int code; //状态码
private String msg; //状态码的描述信息
private Object data;
public static ResultAjax success(Object data){
ResultAjax result = new ResultAjax();
result.setCode(200);
result.setMsg("");
result.setData(data);
return result;
}
public static ResultAjax success(int code,String msg,Object data){
ResultAjax result = new ResultAjax();
result.setCode(code);
result.setMsg(msg);
result.setData(data);
return result;
}
public static ResultAjax fail(int code,String msg){
ResultAjax result = new ResultAjax();
result.setCode(code);
result.setMsg(msg);
result.setData(null);
return result;
}
public static ResultAjax fail(int code,String msg,Object data){
ResultAjax result = new ResultAjax();
result.setCode(code);
result.setMsg(msg);
result.setData(data);
return result;
}
}
保底统一返回处理
在common中创建类
@ControllerAdvice
public class ResponseAdvice implements ResponseBodyAdvice {
@Autowired
private ObjectMapper objectMapper;
@Override
public boolean supports(MethodParameter returnType, Class converterType) {
return true;
}
@Override
public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
if (body instanceof ResultAjax){
return body;
}
if (body instanceof String){
ResultAjax resultAjax = ResultAjax.success(body);
try {
return objectMapper.writeValueAsString(resultAjax);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
}
return ResultAjax.success(body);
}
}
统一异常处理
/*
* 统一异常处理
* */
@RestControllerAdvice
public class ExceptionAdvice {
@ExceptionHandler(Exception.class)
public ResultAjax doException(Exception e){
return ResultAjax.fail(-1,e.getMessage());
}
}
3、处理请求
编写Mapper层，将拿到的数据进行插入
@Mapper
public interface UserMapper {
@Insert("insert into userinfo(username,password) values (#{username},#{password})")
int reg(Userinfo userinfo);
}
然后在Service层中使用@Autowired将userMapper注入
@Service
public class UserService {
@Autowired
private UserMapper userMapper;
public int reg(Userinfo userinfo){
return userMapper.reg(userinfo);
}
}
在UserController中使用Userinfo对象接收请求信息
（1）校验参数
（2）请求 service 进行添加操作
（3）将执行的结果返回给前端
@RestController
@RequestMapping("/user")
public class UserController {
@Autowired
UserService userService;
@RequestMapping("/reg")
public ResultAjax reg(Userinfo userinfo){
if (userinfo == null || !StringUtils.hasLength(userinfo.getUsername())
|| !StringUtils.hasLength(userinfo.getPassword())){
return ResultAjax.fail(-1,"非法参数");
}
int result = userService.reg(userinfo);
return ResultAjax.success(result);
}
检验该功能是否实现
查看数据库是否插入张三的信息：
二、编写登录功能
1、使用ajax构造请求
在前端页面的
添加jquery
添加事件：点击提交按钮，触发mysub()
（1）校验参数
（2）将数据提交给后端
（3）将结果展示给前端
2、处理请求
创建实体类
首先，再创建一个扩展Userinfo的实体类，UserinfoVO
/*
* userinfo扩展类
* */
@Data
public class UserinfoVO extends Userinfo {
private String checkCode;
}
添加接口方法
在UserMapper中添加以下方法：
@Select("select * from userinfo where username = #{username} order by id desc")
Userinfo getUserByName(@Param("username")String username);
service层
public Userinfo getUserByName(String username){
return userMapper.getUserByName(username);
}
controller：处理请求并返回
首先创建一个公共类（common包中）：AppVariable
设置一个用户的session key
/*
* 全局变量
* */
public class AppVariable {
public static final String SESSION_USERINFO_KEY = "SESSION_USERINFO";
}
/*
* session工具类
* */
public class SessionUtils {
// 得到登录用户
public static Userinfo getUser(HttpServletRequest request){
// false代表有session就创建session，没有就创建
HttpSession session = request.getSession(false);
if (session != null && session.getAttribute(AppVariable.SESSION_USERINFO_KEY) != null){
// 登录状态
return (Userinfo) session.getAttribute(AppVariable.SESSION_USERINFO_KEY);
}
return null;
}
}
2、处理请求
添加接口方法（mapper）
@Mapper
public interface ArticleMapper {
@Select("select * from articleinfo where uid=#{uid}")
List getListByUid(@Param("uid")int uid);
}
service层
对象注入
@Service
public class ArticleService {
@Autowired
private ArticleMapper articleMapper;
public List getListByUid(int uid){
return articleMapper.getListByUid(uid);
}
}
controller处理请求并返回响应
使用并行的方式处理文章正文（_DESC_LENGTH是简介）
@RestController
@RequestMapping("art")
public class ArticleController {
@Autowired
public ArticleService articleService;
private static final int _DESC_LENGTH = 120;
@RequestMapping("/mylist")
public ResultAjax myList(HttpServletRequest request){
// 得到登录用户
Userinfo userinfo = SessionUtils.getUser(request);
if (userinfo == null){
return ResultAjax.fail(-1,"请先登录");
}
// 根据用户id查询用户发表的文章
List list = articleService.getListByUid(userinfo.getId());
// 处理list -> 将文章正文变成简介
if (list != null && list.size() > 0){
// 并行处理list集合
list.stream().parallel().forEach((art)->{
if (art.getContent().length() > _DESC_LENGTH){
art.setContent(art.getContent().substring(0,_DESC_LENGTH));
}
});
}
// 返回前端
return ResultAjax.success(list);
}
}
3、使用ajax构造请求
在前端页面的
添加jquery
添加一个id，包含了文章列表的div
三、编写注销功能
1、使用ajax获取请求
由于注销功能，在很多页面都需要用到，所以这里就给一个公共的js
function logout(){
if (confirm("是否确定注销？")){
// 1、在后端删除session信息
jQuery.ajax({
url:"/user/logout",
type:"POST",
data:{},
success:function (res){}
});
// 2、跳转到登录页
location.href = "login.html"
}
}
@Delete("delete from articleinfo where id=#{aid} and uid=#{uid}")
int del(@Param("aid")Integer aid,int uid);
service层
public int del(Integer aid,int uid){
return articleMapper.del(aid,uid);
}
controller层：处理请求
主要有以下几步：
1、参数校验
2、得到当前登录的用户
3、判断文章的归属人并且进行删除操作
4、将结果返回给前端
// 删除文章
@RequestMapping("/del")
public ResultAjax del(Integer aid,HttpServletRequest request){
if (aid==null || aid<=0){
return ResultAjax.fail(-1,"参数错误！");
}
Userinfo userinfo = SessionUtils.getUser(request);
if (userinfo == null){
return ResultAjax.fail(-1,"请先登录！");
}
int result = articleService.del(aid,userinfo.getId());
return ResultAjax.success(result);
}
五、编写文章添加功能
1、使用ajax构造请求
（1）非空校验
（2）将用户提交的数据传递给后端
（3）将后端返回的结果展示给用户
进入到blog_add.html中，添加如下代码
function mysub(){
var title = jQuery("#title");
if (title.val.trim()==""){
alert("请先输入标题！");
title.focus();
return false;
}
if (editor.getValue()==""){
alert("请先输入正文！");
return false;
}
jQuery.ajax({
url:"/art/add",
type:"POST",
data:{
"title":title.val(),
"content":editor.getValue()
},
success:function (res){
// 文章添加成功
if (res.code==200 && res.data==1){
if (confirm("恭喜：添加成功！是否继续添加文章？")){
location.href=location.href;
}else{
location.href="myblog_list.html"
}
}else {
//文章添加失败
alert("抱歉：操作失败！"+res.msg);
}
}
});
}
2、处理请求
mapper层：添加接口方法
@Insert("insert into articleinfo(title,content,uid) values(#{title},#{content},#{uid})")
int add(Articleinfo articleinfo);
service层：返回受影响行数
public int add(Articleinfo articleinfo){
return articleMapper.add(articleinfo);
}
controller：处理添加文章的请求
主要分为以下几步：
（1）校验参数
（2）组装数据
（3）将数据入库
（4）将结果返回给前端
@RequestMapping("/add")
public ResultAjax add(Articleinfo articleinfo,HttpServletRequest request){
if (articleinfo==null || !StringUtils.hasLength(articleinfo.getTitle())
|| !StringUtils.hasLength(articleinfo.getContent())){
return ResultAjax.fail(-1,"非法参数！");
}
Userinfo userinfo = SessionUtils.getUser(request);
if (userinfo == null){
return ResultAjax.fail(-2,"请先登录");
}
articleinfo.setUid(userinfo.getId());
int result = articleService.add(articleinfo);
return ResultAjax.success(result);
}
六、修改功能：查询到修改的文章
1、通过ajax构造请求
（1）获取url中的参数：
（例如）localhost:8080/blog_edit.html?aid=2&uid=1
a、通过location.search获取“？”后面的参数
b、去除“？”
c、根据“&”将参数分割成多个数组
d、循环对比key，并返回查询value
创建一个公共的js：
// 根据key获取到对应的url中对应的value
function getParamValue(key){
var params = location.search;
if (params.indexOf("?")>=0){
params=params.substring(1);
var paramArray=params.split("&");
if (paramArray.length>=1){
for (var i = 0; i < paramArray.length; i++) {
var item=paramArray[i].split("=");
if (item[0]==key[1]){
return item;
}
}
}
}
return null;
}
（2）校验 aid
（3）查询文章详情
（4）将文章的详情信息展示到页面
首先在head中添加得到参数的方法
在blog_edit.html中的中添加代码
var aid=getParamValue("aid");
function init(){
if (aid==null || aid<=0){
alert("非法参数")
return false;
}
jQuert.ajax({
url:"/art/getdetail",
type:"GET",
data:{
"aid":aid
},
success:function(res){
if (res.code==200 && res.data!=null && res.data.id>0){
jQuery("#title").val(res.data.title);
initEdit(res.data.content);
}else {
alert("抱歉，查询失败！"+res.msg);
}
}
});
}
init();
2、处理请求
Mapper层：添加接口
进入到ArticleMapper中
@Select("select * from aeticleinfo where id=#{aid} and uid=#{uid}")
Articleinfo getArticleByIdAndUid(@Param("aid")int aid,
@Param("uid")int uid);
service层
public Articleinfo getArticleByIdAndUid(int aid,int uid){
return ArticleMapper.getArticleByIdAndUid(aid,uid);
}
var aid = getParamValue("aid");
//初始化页面
function init(){
var aid = getParamValue("aid");
if (aid==null || aid<=0){
alert("参数有误！");
return false;
}
jQuery.ajax({
url:"/art/detail",
type:"GET",
data:{
"aid":aid
},
success: function (res){
if (res.code==200 && res.data!=null){
var user = res.data.user;
var art = res.data.art;
if (user!=null){
if(user.photo!=""){
jQuery("#photo").art("src,user.photo");
}
jQuery("#username").html(user.username);
jQuery("#artcount").html(user.artCount);
}else{
alert("抱歉：查询失败!"+reg.msg);
}
if(art!=null){
jQuery("#title").html(art.title);
jQuery("#createtime").html(art.createtime);
jQuery("#rcount").html(art.rcount);
initEdit(art.content);
}else{
alert("抱歉：查询失败！"+reg.msg)
}
}else{
alert("抱歉，查询失败！"+res.msg);
}
}
});
}
2、处理请求
首先在userinfoVO中添加一个变量：
private int artCount; //用户发布的文章总数
mapper层
首先在Articleinfo中添加一条sql：根据id查询文章
@Select("select * from articleinfo where id=#{aid}")
Articleinfo getDetaiById(@Param("aid") int aid);
@Select("select count(*) from articleinfo where uid=#{uid}")
int getArticleByUid(@Param("uid")int uid);
然后再Userinfo中添加一条sql：根据id查询用户
@Select("select * from us erinfo where id=#{uid}")
UserinfoVO getUserById(@Param("uid") int uid);
service层
ArticleService中
public Articleinfo getDetail(int aid){
return articleMapper.getDetaiById(aid);
}
public int getArtCountByUid(int uid){
return articleMapper.getArticleByUid(uid);
}
UserService中
public UserinfoVO getUserById(int uid){
return userMapper.getUserById(uid);
}
@Update("update articleinfo set rcount=rcount+1 where id=#{aid}")
int incrementRCount(@Param("aid") int aid);
service层
public int incrementRCount(int aid){
return articleMapper.incrementRCount(aid);
}
controller层
（1）校验参数
（2）更改数据库
（3）返回结果
@RequestMapping("/increment_rcount")
public ResultAjax incrementRCount(Integer aid){
if (aid==null || aid<=0){
return ResultAjax.fail(-1,"参数有误！");
}
int result = articleService.incrementRCount(aid);
return ResultAjax.success(result);
}
';
}
jQuery("#artListDiv").html(createHtml);
}else{
alert("抱歉：查询失败！"+res.msg);
}
}
});
}
init();
//点击首页
function doFirst(){
if (pindex<=1){
alert("已经在首页了，无需跳转");
return false;
}
location.href = "blog_list.html";
}
//跳转到末页
function doLast(){
if (pindex>=totalpage){
alert("已经在末页了，无需跳转！");
return false;
}
location.href="blog_list.html?pindex="+totalpage;
}
//点击上一页
function doBefore(){
if (pindex<=1){
alert("已经在首页了，无需跳转");
return false;
}
location.href="blog_list.html?pindex="+(parseInt(pindex)-1);
}
//点击下一页
function doNext(){
if (pindex>=totalpage){
alert("已经在末页了，无需跳转！");
return false;
}
location.href="blog_list.html?pindex="+(parseInt(pindex)+1);
}
2、后端处理
推导到分页公式：每页显示两条数据
每次只有偏移量offset变了
# 第一页
mysql> select * from articleinfo order by id limit 2 offset 0;
# 第三页
mysql> select * from articleinfo order by id limit 2 offset 2;
# 第四页
mysql> select * from articleinfo order by id limit 2 offset 2;
.....
假设每条显示条数为pageSize，页码为pageIndex
故而推到出的公式为：offset = pageSize*(pageIndex-1）
mapper层
@Select("select * from articleinfo order by id desc limit #{psize} offset #{offset} ")
public List getListByPage(@Param("psize") int psize,@Param("offset")int offset);
@Select("select count(*) from articleinfo")
int getCount();
service层
public List getListByPage(int psize,int offset){
return articleMapper.getListByPage(psize, offset);
}
controller层
（1）加工矫正
（2）并发进行文章列表和总页数的查询
（3）组装数据
（4）将结果返回给前端
@RequestMapping("/getlistbypage")
public ResultAjax getListByPage(Integer pindex,Integer psize) throws ExecutionException, InterruptedException {
if (pindex == null || pindex < 1){
pindex = 1;
}
if (psize==null || psize<1){
psize = 2;
}
//查询分页列表数据：
Integer finalPsize = psize;
Integer finalPindex = pindex;
FutureTask> listTask = new FutureTask<>(()->{
int finalOffset = finalPsize *(finalPindex -1);
return articleService.getListByPage(finalPsize,finalOffset);
}) ;
//查询总页数
FutureTask sizeTask = new FutureTask<>(()->{
int totalCount = articleService.getCount();
double sizeTemp = (totalCount * 1.0) / (finalPsize * 1.0);
return (int) Math.ceil(sizeTemp);
});
taskExecutor.submit(listTask);
taskExecutor.submit(sizeTask);
List list = listTask.get();
int size = sizeTask.get();
HashMap map = new HashMap<>();
map.put("list",list);
map.put("size",size);
return ResultAjax.success(map);
}
十一、密码加盐
先修改数据库中的字段：
mysql> alter table userinfo modify password varchar(65) not null;
1、定义加密规则
加密流程：
使用加盐算法，也就是使用一个不重复随机的盐值+密码，得到一个无规律的密码 （1）生成一个盐值
（2）（根据盐值 + 固定密码）进行加密 -> md5（盐值 + 密码）= 最终密码
（3）将[盐值]+ [分隔符$] + 最终密码保存到数据库中
验证密码流程：
（1）得到盐值
（2）md5（盐值+待验证密码）-> 最终待验证的密码
（3）对比最终待验证的密码和数据中的最终密码是否相同-> 相同密码正确
创建一个加密解密的类：
public class PasswordUtils {
//加盐加密
public static String encrypt(String password){
String salt = UUID.randomUUID().toString().replace("-","");
String finalPassword = DigestUtils.md5DigestAsHex((salt+password).getBytes(StandardCharsets.UTF_8));
return salt+"$"+finalPassword;
}
//待验证密码
public static boolean decrypt(String password,String dbPassword){
if (!StringUtils.hasLength(password) || !StringUtils.hasLength(dbPassword) ||
dbPassword.length() != 65){
return false;
}
String[] dbPasswordArray = dbPassword.split("$");
if (dbPasswordArray.length!=2){
return false;
}
String salt = dbPasswordArray[0];
String dbFinalPassword = dbPasswordArray[1];
String finalPassword = DigestUtils.md5DigestAsHex((salt+password).getBytes(StandardCharsets.UTF_8));
if (finalPassword.equals(dbFinalPassword)){
return true;
}
return false;
}
}
public class OcuppyMoreThanHalf {
/**
* Q74 数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字
* two solutions:
* 1.O(n)
* see <beauty of coding>--每次删除两个不同的数字，不改变数组的特性
* 2.O(nlogn)
* 排序。中间
cygwin很多命令显示command not found的解决办法
修改cygwin.BAT文件如下
@echo off
D:
set CYGWIN=tty notitle glob
set PATH=%PATH%;d:\cygwin\bin;d:\cygwin\sbin;d:\cygwin\usr\bin;d:\cygwin\usr\sbin;d:\cygwin\us
