基于springboot layui新闻发布网站前后端源码

开发工具：idea或eclipse
数据库：mysql 数据库连接工具：navcat 

package cn.tzp.news.controller;

import cn.tzp.news.domain.Article;
import cn.tzp.news.domain.Comment;
import cn.tzp.news.domain.Favorite;
import cn.tzp.news.domain.User;
import cn.tzp.news.service.ArticleService;
import cn.tzp.news.service.CommentService;
import cn.tzp.news.service.FavoriteService;
import cn.tzp.news.service.UserService;
import cn.tzp.news.utils.CheckCodeUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.*;
import java.util.List;

/**
 * @program: news_demo
 * @description: 用户管理
 * @author: tzp
 * @create: 2023-02-13 13:10
 **/
@Controller
@Slf4j
@RequestMapping("/user")
public class UserController {

    @Autowired
    UserService userService;

    @Autowired
    ArticleService articleService;

    @Autowired
    FavoriteService favoriteService;

    @Autowired
    CommentService commentService;

    //    注册页面
    @RequestMapping("/register")
    public String register(Model model) {
        return "register";
    }

    //提供注册页面验证码
    @RequestMapping("/register/checkCode")
    @ResponseBody
    public void getCheck(HttpServletResponse response, HttpServletRequest request) {
        //调用验证码工具类提供验证码
        CheckCodeUtil.getCheckCode(request,response);
    }

//    注册页面提交表单返回结果
    @PostMapping("/register/result")
    @ResponseBody
    public Map sendRegisterResult(@RequestBody Map<String,String> map1
                ,HttpSession session){

        Map map = userService.registerResult(map1, session);
//        log.info("用户属性{}",map1);
//        log.info("map{}",map);
        return map;
    }

    //前端登录页面
    @RequestMapping("/login")
    public String userLogin(Model model){
        return "login";
    }

    //前端登录页面结果返回
    @PostMapping("/login/result")
    @ResponseBody
    public Map sendLoginResult(@RequestBody Map<String,String> map1
            ,HttpSession session){

        Map map = userService.loginResult(map1, session);
        log.info("用户属性{}",map1);
        log.info("map{}",map);
//        log.info("前端验证码{}",checkcode);
        return map;
    }

    //前端用户账号退出
    @RequestMapping("/quit")
    public String userQuit(HttpSession session)
    {
        //销毁保存的session
        session.invalidate();
        return "redirect:/index";
    }

    //前端用户点击邮箱内链接激活结果
    @RequestMapping("/active")
    @ResponseBody
    public String userActive(@RequestParam("code")String code,HttpSession session)
    {
        String msg = userService.activeResult(code,session);
        return msg;
    }

    //用户手动点击激活
    @RequestMapping("per_active")
    @ResponseBody
    public  Map personActive(HttpSession session){
        User user = (User) session.getAttribute("user");
        user=userService.activeEmail(user);
        //将激活码写进去数据库
        userService.updateById(user);
        HashMap<String, Object> map = new HashMap<>();
        map.put("flag",200);
        return map;
    }


    //    个人主页，暂时无用
    @RequestMapping("/home")
    public String home(Model model) {

        return "home";
    }

    //我的消息,暂时无用
    @RequestMapping("/message")
    public String message(Model model) {

        return "message";
    }

    //个人设置页面
    @RequestMapping("/set")
    public String set(Model model,HttpSession session) {
        User user =(User) session.getAttribute("user");
        model.addAttribute("user",user);
        return "set";
    }



    //用户中心，返回用户发帖和帖子收藏以及评论
    @RequestMapping("/user_center")
    public String user_center(Model model,HttpSession session) {
        //返回用户发表的新闻
        User user =(User) session.getAttribute("user");
        QueryWrapper<Article> wrapper = new QueryWrapper<>();
        wrapper.eq("author_id",user.getUid()).orderByDesc("create_time");
        List<Article> list = articleService.list(wrapper);
        model.addAttribute("lists",list);

        //返回用户的收藏
        List<Article> favArts = userService.getFavArt(user.getUid());
        model.addAttribute("favArts",favArts);
        //需要返回添加时间
        QueryWrapper<Favorite> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("uid",user.getUid()).orderByDesc("add_time");
        List<Favorite> favorites = favoriteService.list(queryWrapper);
        model.addAttribute("favorites",favorites);
        //返回用户评论
        QueryWrapper<Comment> comWrapper = new QueryWrapper<>();
        comWrapper.eq("uid",user.getUid()).orderByDesc("com_time");
        List<Comment> commentList = commentService.list(comWrapper);
        model.addAttribute("commentList",commentList);
        return "user_center";
    }

    //进行用户个人新闻的删除
    @RequestMapping("/delArt")
    @ResponseBody
    public Map delArt(Integer aid,HttpSession session){
        log.info("{}", aid);
        boolean b = articleService.removeById(aid);
        HashMap<String, Object> map = new HashMap<>();
        if (b){
            map.put("flag",200);
            map.put("msg","删除成功");
        }else {
            map.put("flag",400);
            map.put("msg","删除失败，请稍后尝试");
        }
        return map;
    }

    //进行用户收藏夹的删除
    @RequestMapping("/delFav")
    @ResponseBody
    public Map delFavorite(Integer aid,HttpSession session){
        User user =(User) session.getAttribute("user");
        QueryWrapper<Favorite> wrapper = new QueryWrapper<>();
        wrapper.eq("aid",aid).eq("uid",user.getUid());
        boolean b = favoriteService.remove(wrapper);
        HashMap<String, Object> map = new HashMap<>();
        if (b){
            map.put("flag",200);
            map.put("msg","删除成功");
        }else {
            map.put("flag",400);
            map.put("msg","删除失败，请稍后尝试");
        }
        return map;
    }


    //进行用户评论的删除
    @RequestMapping("/delCom")
    @ResponseBody
    public Map delComment(Integer comid,HttpSession session){
        User user =(User) session.getAttribute("user");
        QueryWrapper<Comment> wrapper = new QueryWrapper<>();
        wrapper.eq("comid",comid);
        boolean b = commentService.remove(wrapper);
        HashMap<String, Object> map = new HashMap<>();
        if (b){
            map.put("flag",200);
            map.put("msg","删除成功");
        }else {
            map.put("flag",400);
            map.put("msg","删除失败，请稍后尝试");
        }
        return map;
    }

    //上传图片等资源文件
    @ResponseBody
    @RequestMapping(value = "/uploadHeadImg")
    public Map uploadFile(HttpServletRequest request, @RequestParam("file") MultipartFile file,HttpSession session) throws IOException {
        Map<String, Object> map = new HashMap<>();
        Map<String, Object> map2 = new HashMap<>();
        if (file != null) {
//            String webapp = request.getSession().getServletContext().getRealPath("/");
            //存放到项目静态资源下
            String webapp = "src/main/resources/";
            try {
                //图片名字
                String substring = file.getOriginalFilename();
//                System.out.println(substring);
                //使用uuid替代原来名字
                String uuid = UUID.randomUUID().toString().replaceAll("-", "").toUpperCase();
                // 图片的路径+文件名称
//                String fileName = "/static/upload/" + substring;
                //使用uuid上传将上传的图片重命名，但是遇到改名之后上传较慢，需要等待传输才能回显
                String uuidName = uuid + "." + substring.substring(substring.lastIndexOf(".") + 1);
//                System.out.println(uuidName);
                String fileName = "/static/upload_headImg/" + uuidName;
//                System.out.println(fileName);
                // 图片的在服务器上面的物理路径
                File destFile = new File(webapp, fileName);
//                log.info("真实路径{}",destFile);
                // 生成upload目录
                File parentFile = destFile.getParentFile();
                if (!parentFile.exists()) {
                    parentFile.mkdirs();// 自动生成upload目录
                }
                // 把上传的临时图片，复制到当前项目的webapp路径
                FileCopyUtils.copy(file.getInputStream(), new FileOutputStream(destFile));
                map = new HashMap<>();
                map2 = new HashMap<>();
                map.put("code", 0);//0表示成功，1失败
                map.put("msg", "上传成功");//提示消息
                map.put("data", map2);
//                map2.put("src", fileName);//图片url
//                map2.put("src", "/upload/" + substring);//图片url
                map2.put("src", "/upload_headImg/"+uuidName);//图片url
//                map2.put("title", substring);//图片名称，这个会显示在输入框里
                map2.put("title", uuidName);//图片名称，这个会显示在输入框里
                log.info("图片地址为{}",uuidName);
                //将用户头像保存到数据库
                User user = (User) session.getAttribute("user");
                user.setHeadImage("/upload_headImg/"+uuidName);
                userService.updateById(user);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return map;
    }


    //修改用户基本信息
    @PostMapping("/alterInfo")
    @ResponseBody
    public Map alterUserInfo(@RequestBody User user,HttpSession session){
//        log.info("用户信息{}",user);
        Map<String, Object> map = new HashMap<>();
        //从session取出已有数据然后替换，保存到数据库
        User sessionUser = (User) session.getAttribute("user");
        sessionUser.setTelephone(user.getTelephone());
        sessionUser.setEmail(user.getEmail());
        sessionUser.setSex(user.getSex());
        sessionUser.setNewsName(user.getNewsName());
        //更新用户信息
        boolean flag = userService.updateById(sessionUser);
        if (flag){
            //修改session
            session.setAttribute("user",sessionUser);
            map.put("flag",200);
        }

        return map;
    }

    //修改用户密码
    @PostMapping("/alterPassword")
    @ResponseBody
    public Map alterPassword(@RequestBody Map<String,String> map1
            ,HttpSession session){
//        log.info("修改密码{}",map1);
        Map map = userService.alterPass(map1, session);
        return map;
    }


}

 

 

package cn.tzp.news.controller;

import cn.tzp.news.domain.Article;
import cn.tzp.news.domain.Category;
import cn.tzp.news.domain.Comment;
import cn.tzp.news.domain.User;
import cn.tzp.news.service.ArticleService;
import cn.tzp.news.service.CateService;
import cn.tzp.news.service.CommentService;
import cn.tzp.news.service.UserService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.*;

/**
 * @program: demo
 * @description: 文章管理
 * @author: tzp
 * @create: 2023-02-13 09:38
 **/
@Controller
@Slf4j
public class ArticleController {
    @Autowired
    ArticleService articleService;

    @Autowired
    CateService cateService;

    @Autowired
    UserService userService;

    @Autowired
    CommentService commentService;

    @RequestMapping("article_pub")
    public String article_Pub(@RequestParam(value = "id",required = false)Integer id,Model model) {
        Article byId = articleService.getById(id);
        model.addAttribute("byId",byId);

        List<Category> categories = cateService.list();
        model.addAttribute("categories",categories);
        return "article_pub";
    }

    //上传图片等资源文件
    @ResponseBody
    @RequestMapping(value = "/upload/uploadFile")
    public Map uploadFile(HttpServletRequest request, @RequestParam("file") MultipartFile file) throws IOException {
        Map<String, Object> map = new HashMap<>();
        Map<String, Object> map2 = new HashMap<>();
        if (file != null) {
//            String webapp = request.getSession().getServletContext().getRealPath("/");
            //存放到项目静态资源下
            String webapp = "src/main/resources/";
            try {
                //图片名字
                String substring = file.getOriginalFilename();
//                System.out.println(substring);
                //使用uuid替代原来名字
                String uuid = UUID.randomUUID().toString().replaceAll("-", "").toUpperCase();
                // 图片的路径+文件名称
//                String fileName = "/static/upload/" + substring;
                //使用uuid上传将上传的图片重命名，但是遇到改名之后上传较慢，需要等待传输才能回显
                String uuidName = uuid + "." + substring.substring(substring.lastIndexOf(".") + 1);
//                System.out.println(uuidName);
                String fileName = "/static/upload/" + uuidName;
//                System.out.println(fileName);
                // 图片的在服务器上面的物理路径
                File destFile = new File(webapp, fileName);
//                log.info("真实路径{}",destFile);
                // 生成upload目录
                File parentFile = destFile.getParentFile();
                if (!parentFile.exists()) {
                    parentFile.mkdirs();// 自动生成upload目录
                }
                // 把上传的临时图片，复制到当前项目的webapp路径
                FileCopyUtils.copy(file.getInputStream(), new FileOutputStream(destFile));
                map = new HashMap<>();
                map2 = new HashMap<>();
                map.put("code", 0);//0表示成功，1失败
                map.put("msg", "上传成功");//提示消息
                map.put("data", map2);
//                map2.put("src", fileName);//图片url
//                map2.put("src", "/upload/" + substring);//图片url
                map2.put("src", "/upload/"+uuidName);//图片url
//                map2.put("title", substring);//图片名称，这个会显示在输入框里
                map2.put("title", uuidName);//图片名称，这个会显示在输入框里
                log.info("图片地址为{}",uuidName);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return map;
    }

    //文章保存
    @PostMapping("/articleSave")
    @ResponseBody
    public Map articleSave(@RequestBody Article article, HttpSession session) {

        Map map1 = articleService.savaArticle(article, session);

        return map1;
    }


    //通过列表点击文章跳转
    @GetMapping("/article/details/{id}")
    public String findArticalDetail(@PathVariable("id")Integer id,Model model){
//        Article articleById = articleService.getById(id);
//        //点击数+1
//        articleById.setCheckNum(articleById.getCheckNum()+1);
//        articleService.updateById(articleById);
        //获取点击新闻的内容
        Article articleById = articleService.findMessageId(id);
        //获取该新闻下评论
        QueryWrapper<Comment> wrapper = new QueryWrapper<>();
        List<Comment> commentList = commentService.list(wrapper.eq("aid", id).orderByAsc("com_time"));
        //获取相关评论的用户信息
        List<User> comUser = commentService.getComUser(id);

        model.addAttribute("articleById",articleById);
        model.addAttribute("commentList",commentList);
        model.addAttribute("comUser",comUser);
        return "article_details";
    }


    //访问指定新闻分类
    @GetMapping("/cate/CateArticle/{cid}")
     public String CateArticle(@PathVariable("cid")Integer cid, Model model){

        Category cateById = cateService.getById(cid);
        model.addAttribute("cateById",cateById);

        return "article";
    }

    //新闻分类查询结果返回分页结果
    @RequestMapping("/cate/queryCaetAll")
    @ResponseBody
    public Map queryCateAll(Integer pageNum,Integer pageSize,Integer cateId,HttpSession session) {

        //使用MP自带的分页插件分页查询数据
        Page<Article> catePage = new Page<>(pageNum, pageSize);
        //分页查询结果
        QueryWrapper<Article> cateQuery = new QueryWrapper<>();
        //查询条件,用户有登录显示为用户等级的查询，没有登录查询的是最低的等级
        User user = (User) session.getAttribute("user");
        if (user!=null){
            cateQuery.eq("cid",cateId).eq("lid",user.getLid())
                    .eq("status",1).orderByDesc("create_time");
        }else {
            cateQuery.eq("cid",cateId).eq("lid",1)
                    .eq("status",1).orderByDesc("create_time");
        }

        Page<Article> catepages = articleService.page(catePage, cateQuery);
        List<Article> cateArtList = catepages.getRecords();

        long total = catepages.getTotal();
        Map<String, Object> map = new HashMap<>();
        map.put("data",cateArtList);
        map.put("count",total);
        map.put("status",200);
//        map.put("cate",cate);
        return map;
    }


//    进行新闻收藏
    @PostMapping("/article/fav")
    @ResponseBody
    public Map artFavorite(Integer id,HttpSession session){
        Map map = articleService.artFavorite(id, session);
        return map;
    }

    //新闻搜索
    @PostMapping("/article/search")
    public String search(String keyword,Model model,HttpSession session){
        //返回搜素的内容
        model.addAttribute("keyword",keyword);
        //返回搜素结果
        List<Article> articles = articleService.searchArt(session, keyword);
        model.addAttribute("articles",articles);
        return "search";
    }

    //展示其他等级新闻
    @RequestMapping("/article/other/{lid}")
    public  String otherArticle(@PathVariable("lid")Integer lid,Model model,
                                @RequestParam(value = "level",required = false)Integer level,
                                @RequestParam(value = "cid",required = false)Integer cid,
                                @RequestParam(value = "keyword",required = false)String keyword){
//                                @RequestParam(value = "pageNum")Integer pageNum,
//                                @RequestParam(value = "pageSize")Integer pageSize){
        model.addAttribute("level",lid);
        model.addAttribute("cid",cid);
        model.addAttribute("keyword",keyword);
//        model.addAttribute("level",lid);
//        model.addAttribute("level",lid);

//        log.info("{}",level);
//        log.info("{}",cid);
//        log.info("{}",keyword);
        return "other_level";
    }


    //返回其他等级查询结果，可分页
    @RequestMapping("/article/other/levelResult")
    @ResponseBody
    public Map queryOtherLevResult(Integer pageNum,Integer pageSize,Integer cid,Integer level,
                                   String keyword) {
        Map<String, Object> map = new HashMap<>();
        try {
            IPage<Article> page = articleService.findOtherLevPage(pageNum, pageSize,cid,level,keyword);
            List<Article> addCateList = page.getRecords();
            long total = page.getTotal();
            map.put("data",addCateList);
            map.put("count",total);
            map.put("status",200);
        } catch (Exception e) {
            log.error(e.getMessage());
        }

        return map;

//        System.out.println(pageNum+":"+pageSize+":"+cid+":"+level+":"+keyword);
//        //使用MP自带的分页插件分页查询数据
//        Page<Article> levelPage = new Page<>(pageNum, pageSize);
//        //分页查询结果
        QueryWrapper<Article> cateQuery = new QueryWrapper<>();
//        QueryWrapper<Article> wrapper = new QueryWrapper<>();
//        //查询条件
//        wrapper.eq("lid",level);
//        //条件筛选
//        if (StringUtils.isNotBlank(keyword)){
//            wrapper.like("title",keyword).or().like("content",keyword);
//        }
//        if (cid!=null){
//            wrapper.eq("cid",cid);
//        }
//
//        Page<Article> levpages = articleService.page(levelPage, wrapper);
//        List<Article> levArtList = levpages.getRecords();
//
//        long total = levpages.getTotal();
//        Map<String, Object> map = new HashMap<>();
//        map.put("data",levArtList);
//        map.put("count",total);
//        map.put("status",200);
//        map.put("cate",cate);
//        return map;
    }


}