基于javaweb+mysql的ssm+maven在线小说阅读系统(读者+作者+管理员)(java+ssm+jsp+mysql+maven)

最新推荐文章于 2024-09-15 19:46:31 发布
最新推荐文章于 2024-09-15 19:46:31 发布
阅读量157 收藏 3
点赞数
文章标签： java mysql maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71481852/article/details/131859494
版权

基于javaweb+mysql的ssm+maven在线小说阅读系统(读者+作者+管理员)(java+ssm+jsp+mysql+maven)

运行环境

Java≥8、MySQL≥5.7、Tomcat≥8

开发工具

eclipse/idea/myeclipse/sts等均可配置运行

适用

课程设计，大作业，毕业设计，项目练习，学习演示等

功能说明

基于javaweb+mysql的SSM+Maven在线小说阅读系统(读者+作者+管理员)(java+ssm+jsp+mysql+maven)

一、项目简述

功能包括： 1:用户及主要操作功能 游客可以浏览网站的主页，登陆注册，小说湿度，下单购 买，订单查询，个人信息查询，留言评论。 2:作者模块 作者登录注册，小说发表，小说维护等等。 3:作者模块 管理员登录，读者管理，小说管理，评论管理，充值订单 管理，订阅订单管理，折扣活动管理等等

二、项目运行

环境配置： Jdk1.8 + Tomcat8.5 + mysql + Eclispe (IntelliJ IDEA,Eclispe,MyEclispe,Sts 都支持)

项目技术： JSP +Spring + SpringMVC + MyBatis + html+ css + JavaScript + JQuery + Ajax + layui+ maven等等。

//        }
//
//        return resultData;
//    }
//
    //读者列表
    @RequestMapping("/reader/list")
    public String list(Model model,
                       @RequestParam(defaultValue = "1") Integer page,
                       @RequestParam(defaultValue = "5") Integer pageSize){

        PageInfo<Reader> pageInfo = readerService.list(page,pageSize);

        model.addAttribute("list",pageInfo.getList());
        model.addAttribute("pageInfo",pageInfo);

        return "reader/reader-list";
    }

    //搜索读者显示列表
    @RequestMapping("/reader/search")
    public String searchList(Model model,
                       @RequestParam(defaultValue = "1") Integer page,
                       @RequestParam(defaultValue = "5") Integer pageSize,
                             String keyword){

        PageInfo<Reader> pageInfo = readerService.searchList(page, pageSize, keyword);
        model.addAttribute("list",pageInfo.getList());
        model.addAttribute("pageInfo",pageInfo);

        return "reader/reader-list";
    }

    //读者删除列表
    @RequestMapping("/reader/deleteList")
    public String deleteList(Model model,
                       @RequestParam(defaultValue = "1") Integer page,
                       @RequestParam(defaultValue = "5") Integer pageSize){


    //    更新状态
    @Override
    public ResultData updateStatus(Integer bookId, Integer condition) {
        if (bookId == null || bookId <= 0) {
            return new ResultData(6001, "更新数据ID异常");
        }
        if (condition != 1 && condition != 2 && condition != 3) {
            return new ResultData(6002, "状态数据不正确");
        }
        if (bookMapper.updateStatus(bookId, condition)) {
            return new ResultData(200, "处理状态数据成功");
        }
        return new ResultData(6003, "处理状态数据失败");
    }

    @Override
    public Book findById(Integer bookId) {
        return bookMapper.findById(bookId);
    }

    //    更新基本信息
    @Override
    public ResultData edit(Book book) {
        if (book == null) {
            return new ResultData(7001, "更新数据异常");
        }
        if (bookMapper.update(book)) {
            return new ResultData(200, "更新数据成功");
        }
        return new ResultData(7002, "更新失败");
    }

    //批量更改状态
    @Override
    public ResultData batchDelete(String[] ids) {
        if (ids.length == 0) {
            return new ResultData(8001, "批量删除数据异常");
        }
        if (bookMapper.batchUpdateStatus(ids)) {
            return new ResultData(200, "批量删除数据成功");
        }
        return new ResultData(8002, "批量删除数据失败");


        List<Chapter> list = chapterMapper.findList(params);
        return new PageInfo<>(list);
    }

    @Override
    public Chapter findById(Integer chapterId) {
        return chapterMapper.findById(chapterId);
    }

//    更新
    @Override
    public ResultData edit(Chapter chapter) {
        if (chapter == null){
            return new ResultData(7001,"更新数据异常");
        }

        System.out.println("asfaffffa"+chapter.toString());
        if (chapterMapper.update(chapter)) {
            return new ResultData(200,"更新数据成功");
        }
        return new ResultData(7002,"更新失败");
    }

    @Override
    public PageInfo<Chapter> searchList(Integer page, Integer pageSize, String keyword) {
        PageHelper.startPage(page,pageSize);
        List<Chapter> list=chapterMapper.findByContent("%"+keyword+"%");
        return new PageInfo<>(list);
    }
    @Override
    public ResultData batchDelete(String[] ids) {
        if (ids.length == 0){
            return  new ResultData(8001,"批量删除数据异常");
        }
        if (chapterMapper.batchUpdateStatus(ids)) {
            return  new ResultData(200,"批量删除数据成功");
        }
        return  new ResultData(8002,"批量删除数据失败");
    }

    /**
     * 通过bookId查询
     * @param bookId
     * @return
     */
    @Override
    public List<Chapter> findByBookId(Integer bookId) {
        List<Chapter> chapterList = chapterMapper.findByBookId(bookId);
        return chapterList;
    }

    @Override


@Controller
public class AuthorController {
    @Autowired
    private AuthorService authorService;

    @RequestMapping("/zuozhe")
    public String duzhe() {
        return "loginauthor";
    }

    @RequestMapping("/zuoping")
    public String zuoping() {
        return "index11";
    }

    /**
     * 登陆操作
     *
     * @return
     */
    @RequestMapping("/loginauthor")
    @ResponseBody
    public ResultData login2(Author author, HttpServletRequest request) {
        ResultData resultData = authorService.login2(author);

        try {

 */
@Controller
public class LoginController {

    @Autowired
    private AdminService adminService;

    @Autowired
    private BookService bookService;

    @Autowired
    private MessageService messageService;

    /**
     * 登陆页面
     * @return
     */
    @RequestMapping("/loginPage")
    public String loginPage(){
        return "login";
    }

    @RequestMapping(value = "/novelPage",method = RequestMethod.GET)
    public String novelPage(Integer bookId, Model model){
        Book book = bookService.findById(bookId);
        List<Message> messageList = messageService.findByBookId(bookId);

        model.addAttribute("book",book);
        model.addAttribute("messageList",messageList);
        return "novel";
    }

    @RequestMapping(value = "/shiduPage",method = RequestMethod.GET)
    public String shiduPage(Integer bookId,Integer page,Model model){
        Book book = bookService.findById(bookId);
        Chapter chapter = book.getChapterList().get(page-1);
        int totalPage= book.getChapterList().size();
        List<Chapter> chapterList = new ArrayList<>();
        chapterList.add(chapter);
        book.setChapterList(chapterList);
        model.addAttribute("book",book);
        model.addAttribute("page",page);
        model.addAttribute("totalPage",totalPage);
        return "shidu";
    }


     * @return
     */
    @RequestMapping("/admin/editPage")
    public String editPage(Model model,Integer id){
        // 从数据库查询到的数据
        Admin dbAdmin = adminService.findById(id);

        model.addAttribute("admin",dbAdmin);
        return "admin/admin-edit";
    }

    /**
     * 更新员工基本信息的方法
     * @param admin
     * @return
     */
    @RequestMapping("/admin/edit")
    @ResponseBody
    public ResultData edit(Admin admin){
        return adminService.edit(admin);
    }

    /**
     * 批量删除
     * @return
     */
    @RequestMapping("/admin/deleteAll")
    @ResponseBody
    public ResultData deleteAll(@RequestParam(name = "ids") String ids){
        // 将ids转换成数组
        String[] idArr = ids.split(",");

        return adminService.batchDelete(idArr);
    }

    @RequestMapping("/admin/upload")
    @ResponseBody
    public ResultData upload(MultipartFile file){

        return adminService.upload(file);
    }

    /**
     * excel数据的导出
     */
    @RequestMapping("/admin/export")
    public void export(HttpServletResponse response) throws IOException {

        // 查询到所有的数据

    }

//    编辑页面
    @RequestMapping("/book/editPage")
    public String editPage(Model model, Integer bookId){
        Book dbBook = bookService.findById(bookId);
        model.addAttribute("book",dbBook);

        return "book/book-edit";
    }
//更新基本信息
    @RequestMapping("/book/edit")
    @ResponseBody
    public ResultData edit(Book book, HttpServletRequest request) {
        Integer currentLoginAuthorId = (Integer) request.getSession().getAttribute("currentLoginAuthorId");
        book.setAuthorId(currentLoginAuthorId);
        book.setAuthor(authorService.findById(currentLoginAuthorId).getAuthorName());

        return  bookService.edit(book);
    }

//    批量删除
    @RequestMapping("/book/deleteAll")
    @ResponseBody
    public ResultData deleteAll(@RequestParam(name="ids") String ids){
        //将ids转为数组
        String[] idArr = ids.split(",");
        //将字符串数组转为int数组
        return bookService.batchDelete(idArr);

    }

    //    search
    @RequestMapping("/book/search")
    public String searchList(Model model,
                             @RequestParam(defaultValue = "1") Integer page,
                             @RequestParam(defaultValue = "3") Integer pageSize,
                             String keyword) {
        PageInfo<Book> pageInfo=bookService.searchList(page,pageSize,keyword);

        model.addAttribute("list",pageInfo.getList());
        model.addAttribute("pageInfo",pageInfo);
        return  "book/book-list";
    }

    @RequestMapping("/book/search1")
    public String searchList1(Model model,
                             @RequestParam(defaultValue = "1") Integer page,

        message.setReaderId(reader.getReaderId());*/
        message.setReaderId(2);
        ResultData resultData = messageService.add(message);

        Book book = bookService.findById(message.getBookId());
        List<Message> messageList = messageService.findByBookId(message.getBookId());

        model.addAttribute("book",book);
        model.addAttribute("messageList",messageList);
        return "novel";
    }

//    留言编辑页面
    @RequestMapping("/message/editPage")
    public String editPage(Model model,Integer id){
//        从数据库查询到的数据
        Message dbMessage = messageService.findById(id);

        model.addAttribute("message",dbMessage);
        return "message/message-edit";
    }

//    更新留言信息的方法
    @RequestMapping("/message/edit")
    @ResponseBody
    public ResultData edit(Message message){

        return messageService.edit(message);

    }

//    批量删除
    @RequestMapping("/message/deleteAll")
    @ResponseBody
    public ResultData deleteAll(@RequestParam(name = "ids") String ids){
//        将ids转换成数组
        String[] idArr=ids.split(",");
        return messageService.mesDelete(idArr);
    }
}
package com.xh.controller;


    @RequestMapping("/duzhe")
    public String duzhe(){
        return "loginreader";
    }

    @RequestMapping("/book/getByType?bookType=1")
    public String xiangqing(){
        return "front/personal";
    }

    /**
     * 登陆操作
     * @return
     */
    @RequestMapping("/loginreader")
    @ResponseBody

        public ResultData login1(Reader reader,HttpServletRequest request){
        request.getSession().setAttribute("currentLoginAuthorId", null);
            // 登陆操作
            ResultData resultData = readerService.login1(reader);
            // 判断登陆成功,将用户数据保存到 session中
            // 如何获取session对象?
            if(resultData.getCode() == 200){
                HttpSession session = request.getSession();
                session.setAttribute("reader",resultData.getData());
            }

            return resultData;
        }

   @RequestMapping("/loginOut")
   @ResponseBody

       public String loginOut(HttpServletRequest request){
	   // 只需要去将保存到session的数据干掉即可


@Controller
public class BookOrderController {
    @Autowired
    private BookOrderService bookOrderService;
    @Autowired
    private BookService bookService;

    @RequestMapping("/bookorder/bookorderlist")
    public String bookorderlist(Model model,
                                @RequestParam(defaultValue = "1") Integer page,
                                @RequestParam(defaultValue = "3") Integer pageSize) {
        PageInfo<BookOrder> pageInfo = bookOrderService.list(page, pageSize);

//将数据转发到页面
        model.addAttribute("list", pageInfo.getList());
        model.addAttribute("pageInfo", pageInfo);
        return "bookorder/bookorder-list";
    }

    @RequestMapping("/bookorder/orderSearch")
    public String searchList(Model model,
                                @RequestParam(defaultValue = "1") Integer page,
                                @RequestParam(defaultValue = "3") Integer pageSize,
                             String keyword) {
        PageInfo<BookOrder> pageInfo = bookOrderService.searchList(page,pageSize,keyword);

//将数据转发到页面
        model.addAttribute("list", pageInfo.getList());
        model.addAttribute("pageInfo", pageInfo);
        return "bookorder/bookorder-list";
    }


    @RequestMapping("/bookorder/bookorderadd")
    public String bookorderadd() {
        return "bookorder/bookorder-add";

    }

    @RequestMapping(value = "/bookorder/add",method = RequestMethod.POST)
    @ResponseBody
    public ResultData add(BookOrder bookOrder, HttpSession session) {
        Reader reader = (Reader)session.getAttribute("reader");
        if(reader==null){
            return  new ResultData(2001,"用户未登陆",null);
        }
        int readerId = reader.getReaderId();
        bookOrder.setUserId(1);
        bookOrder.setDiscountId(1);
        bookOrder.setOrderDate(new Timestamp(System.currentTimeMillis()));
        bookOrder.setOrderStatus(1);
        bookOrder.setPayStatus(1);
        ResultData resultData = bookOrderService.add(bookOrder);

        return resultData;
    }

    @RequestMapping("/bookorder/editStatus")
    @ResponseBody
    public ResultData editStatus(Integer id, Integer status) {
        return bookOrderService.updateStatus(id,status);

    }
    @RequestMapping("/bookorder/deleteAll")
    @ResponseBody
    public ResultData deleteAll(@RequestParam(name = "ids") String ids){
        // 将ids转换成数组
        String[] idArr = ids.split(",");

        return bookOrderService.batchDelete(idArr);
    }

    @RequestMapping("/bookorder/delete")
    @ResponseBody
    public  ResultData delete(Integer orderid,Integer orderStatus){

public class BookServiceImpl implements BookService {
    @Autowired
    private BookMapper bookMapper;

    //    添加
    @Override
    public ResultData add(Book book) {
        if (book == null) {
            return new ResultData(5001, "添加异常");
        }
        book.setCondition(1);
        book.setReleaseTime(new Timestamp(System.currentTimeMillis()));

        try {
            if (bookMapper.save(book)) {
                return new ResultData(200, "添加小说成功");
            }
        } catch (Exception e) {
            return new ResultData(5003, "添加小说已经存在");
        }

        return new ResultData(5002, "添加小说失败");
    }

    //列表
    @Override
    public PageInfo<Book> list(Integer page, Integer pageSize) {
        PageHelper.startPage(page, pageSize);

        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        Object authorId=request.getSession().getAttribute("currentLoginAuthorId");
            Map<String,Object> params = new HashMap<>();
        if ( authorId!= null) {
            params.put("currentLoginAuthorId",authorId);
        }

        System.out.println("params1:"+params);

        List<Book> list = bookMapper.findList(params);
        return new PageInfo<>(list);
    }

    //    更新状态
    @Override
    public ResultData updateStatus(Integer bookId, Integer condition) {
        if (bookId == null || bookId <= 0) {
            return new ResultData(6001, "更新数据ID异常");

                       @RequestParam(defaultValue = "3") Integer pageSize){
        PageInfo<Chapter> pageInfo=chapterService.list(page,pageSize);
        model.addAttribute("list",pageInfo.getList());
        model.addAttribute("pageInfo",pageInfo);
        return "chapter/chapter-list";
    }

//添加
    @RequestMapping("/chapter/addPage")
    public String addPage(){
        return "chapter/chapter-add";
    }

    //    添加
    @RequestMapping("/chapter/add")
    @ResponseBody
    public ResultData add(Chapter chapter){
        return chapterService.add(chapter);
    }

//    编辑
    @RequestMapping("/chapter/editPage")
    public String editPage(Model model, Integer chapterId){
        Chapter dbChapter = chapterService.findById(chapterId);
        model.addAttribute("chapter",dbChapter);

        return "chapter/chapter-edit";
    }

    //更新基本信息
    @RequestMapping("/chapter/edit")
    @ResponseBody
    public ResultData edit(Chapter chapter){
        System.out.println("qqqqqqqqqqqq"+chapter.toString());
        return  chapterService.edit(chapter);
    }

    //    search
    @RequestMapping("/chapter/search")
    public String searchList(Model model,


        model.addAttribute("list", pageInfo.getList());
        model.addAttribute("pageInfo", pageInfo);

        return "author/author-list";
    }

    //搜索作者显示列表
    @RequestMapping("/author/search")
    public String searchList(Model model,
                             @RequestParam(defaultValue = "1") Integer page,
                             @RequestParam(defaultValue = "5") Integer pageSize,
                             String keyword) {

        PageInfo<Author> pageInfo = authorService.searchList(page, pageSize, keyword);
        model.addAttribute("list", pageInfo.getList());
        model.addAttribute("pageInfo", pageInfo);

        return "author/author-list";
    }

    //作者删除列表
    @RequestMapping("/author/deleteList")
    public String deleteList(Model model,
                             @RequestParam(defaultValue = "1") Integer page,
                             @RequestParam(defaultValue = "5") Integer pageSize) {

        PageInfo<Author> pageInfo = authorService.DeleteList(page, pageSize);
        model.addAttribute("list", pageInfo.getList());
        model.addAttribute("pageInfo", pageInfo);
        return "author/author-del";
    }

    //添加作者
    @RequestMapping("/author/addPage")
    public String addPage() {
        return "author/author-add";
    }



@Service
@Transactional(rollbackFor = Exception.class)
public class ChapterServiceImpl implements ChapterService {
    @Autowired
    private ChapterMapper chapterMapper;

    //    添加
    @Override
    public ResultData add(Chapter chapter) {
        if (chapter == null) {
            return new ResultData(5001, "添加异常");
        }
        chapter.setUpdateTime(new Timestamp(System.currentTimeMillis()));
        try {
            if (chapterMapper.save(chapter)) {
                return new ResultData(200, "添加成功");
            }
        } catch (Exception e) {
            return new ResultData(5003, "添加章节已经存在");
        }
        return new ResultData(5002, "添加失败");
    }

    //列表
    @Override


       // 重定向和转发的区别?
       // 重定向: 1. 客户端行为 2. 两次请求 3. 不能携带前一次请求的数据
       // 转发: 1. 服务器端行为 2. 一次请求 3. 能够携带前一次请求的数据
       return "redirect:/loginPage";
       }

//    @RequestMapping("/login")
//    @ResponseBody// 该方法返回的是json字符串
//    public ResultData login(Admin admin,HttpServletRequest request){
//        // 登陆操作
//        ResultData resultData = adminService.login(admin);
//        // 判断登陆成功,将用户数据保存到 session中
//        // 如何获取session对象?
//        if(resultData.getCode() == 200){
//            HttpSession session = request.getSession();
//            session.setAttribute("admin",resultData.getData());
//        }
//
//        return resultData;
//    }
//
    //读者列表
    @RequestMapping("/reader/list")
    public String list(Model model,
                       @RequestParam(defaultValue = "1") Integer page,
                       @RequestParam(defaultValue = "5") Integer pageSize){

        PageInfo<Reader> pageInfo = readerService.list(page,pageSize);

        model.addAttribute("list",pageInfo.getList());
        model.addAttribute("pageInfo",pageInfo);

        return "reader/reader-list";
    }

    //搜索读者显示列表
    @RequestMapping("/reader/search")
    public String searchList(Model model,
                       @RequestParam(defaultValue = "1") Integer page,
                       @RequestParam(defaultValue = "5") Integer pageSize,
                             String keyword){

        PageInfo<Reader> pageInfo = readerService.searchList(page, pageSize, keyword);


@Controller
public class BookOrderController {
    @Autowired
    private BookOrderService bookOrderService;
    @Autowired
    private BookService bookService;

    @RequestMapping("/bookorder/bookorderlist")
    public String bookorderlist(Model model,
                                @RequestParam(defaultValue = "1") Integer page,
                                @RequestParam(defaultValue = "3") Integer pageSize) {
        PageInfo<BookOrder> pageInfo = bookOrderService.list(page, pageSize);

//将数据转发到页面
        model.addAttribute("list", pageInfo.getList());
        model.addAttribute("pageInfo", pageInfo);
        return "bookorder/bookorder-list";
    }

    @RequestMapping("/bookorder/orderSearch")
    public String searchList(Model model,
                                @RequestParam(defaultValue = "1") Integer page,
                                @RequestParam(defaultValue = "3") Integer pageSize,
                             String keyword) {
        PageInfo<BookOrder> pageInfo = bookOrderService.searchList(page,pageSize,keyword);

//将数据转发到页面
        model.addAttribute("list", pageInfo.getList());
        model.addAttribute("pageInfo", pageInfo);
        return "bookorder/bookorder-list";
    }


        return "author/author-list";
    }

    //作者删除列表
    @RequestMapping("/author/deleteList")
    public String deleteList(Model model,
                             @RequestParam(defaultValue = "1") Integer page,
                             @RequestParam(defaultValue = "5") Integer pageSize) {

        PageInfo<Author> pageInfo = authorService.DeleteList(page, pageSize);
        model.addAttribute("list", pageInfo.getList());
        model.addAttribute("pageInfo", pageInfo);
        return "author/author-del";
    }

    //添加作者
    @RequestMapping("/author/addPage")
    public String addPage() {
        return "author/author-add";
    }

    //    添加作者的方法
    @RequestMapping("/author/add")
    @ResponseBody
    public ResultData add(Author author) {
        return authorService.add(author);
    }

    /**
     * 编辑作者状态信息
     *
     * @param authorId      : 当前作者Id
     * @param authorStatus: 作者当前状态
     * @return
     */
    @RequestMapping("/author/editStatus")
    @ResponseBody
    public ResultData editStatus(Integer authorId, Integer authorStatus) {
        return authorService.updateStatus(authorId, authorStatus);
    }

    /**
     * 编辑作者
     *

}
package com.xh.controller;

@Controller
public class  RechargeOrderController{
    @Autowired
    private RechargeOrderService rechargeOrderService;

    @RequestMapping("/rechargeorder/rechargeorderlist")
    public String rechargeorderlist(Model model,
                                @RequestParam(defaultValue = "1") Integer page,
                                @RequestParam(defaultValue = "3") Integer pageSize) {
        PageInfo<RechargeOrder> pageInfo = rechargeOrderService.list(page, pageSize);
        //将数据转发到页面
        model.addAttribute("list", pageInfo.getList());
        model.addAttribute("pageInfo", pageInfo);
        return "rechargeorder/rechargeorder-list";
    }

    @RequestMapping("/rechargeorder/search")
    public String rechargeSearchList(Model model,
                                    @RequestParam(defaultValue = "1") Integer page,
                                    @RequestParam(defaultValue = "3") Integer pageSize,
                                     String keyword) {
        PageInfo<RechargeOrder> pageInfo = rechargeOrderService.searchList(page, pageSize,keyword);
        //将数据转发到页面
        model.addAttribute("list", pageInfo.getList());
        model.addAttribute("pageInfo", pageInfo);
        return "rechargeorder/rechargeorder-list";
    }

    @RequestMapping("/rechargeorder/rechargeorderadd")
    public String rechargeorderadd() {
        return "rechargeorder/rechargeorder-add";
    }



@Service
@Transactional(rollbackFor = Exception.class)
public class BookServiceImpl implements BookService {
    @Autowired
    private BookMapper bookMapper;

    //    添加
    @Override
    public ResultData add(Book book) {
        if (book == null) {
            return new ResultData(5001, "添加异常");
        }
        book.setCondition(1);
        book.setReleaseTime(new Timestamp(System.currentTimeMillis()));

        try {
            if (bookMapper.save(book)) {
                return new ResultData(200, "添加小说成功");
            }
        } catch (Exception e) {
            return new ResultData(5003, "添加小说已经存在");
        }

     * @return
     */
    @RequestMapping("/reader/editStatus")
    @ResponseBody
    public ResultData editStatus(Integer readerId, Integer readerStatus){
        return readerService.updateStatus(readerId, readerStatus);
    }

    /**
     * 编辑读者
     * @param
     * @param
     * @return
     */
    @RequestMapping("/reader/editPage")
    public String editPage(Model model, Integer readerId){
        Reader dbreadder = readerService.findById(readerId);
        model.addAttribute("reader",dbreadder);
        return "reader/reader-edit";
    }

    /**
     * 更新读者基本信息的方法
     * @param reader
     * @return
     */
    @RequestMapping("/reader/edit")
    @ResponseBody
    public ResultData edit(Reader reader){
        return readerService.edit(reader);
    }

    /**
     * 批量删除
     * @param ids
     * @return
     */
    @RequestMapping("/reader/deleteAll")
    @ResponseBody
    public ResultData deleteAll(@RequestParam(name = "ids") String ids){
//        将ids转换成数组
        String[] idArr=ids.split(",");
        return readerService.batchDelete(idArr);
    };

    /**


//将数据转发到页面
        model.addAttribute("list",pageInfo.getList());
        model.addAttribute("pageInfo",pageInfo);

        return "message/message-list";
    }
    @RequestMapping("/message/addMessage")
    public  String addMessage(){
        return  "message/message-add";
    }

//    搜索留言显示列表
    @RequestMapping("/message/search")
    public String searchList(Model model,@RequestParam(defaultValue = "1") Integer page,
                             @RequestParam(defaultValue = "5") Integer pageSize,
                             String keyword){
        PageInfo<Message> pageInfo=messageService.searchList(page,pageSize,keyword);
        model.addAttribute("list",pageInfo.getList());
        model.addAttribute("pageInfo",pageInfo);

        return "message/message-list";
    }
//    添加留言
    @RequestMapping(value = "/message/add",method = RequestMethod.POST)
    public String  add(Message message, HttpSession session,Model model){
        /*Reader reader  = (Reader)session.getAttribute("reader");
        message.setReaderId(reader.getReaderId());*/
        message.setReaderId(2);
        ResultData resultData = messageService.add(message);

        Book book = bookService.findById(message.getBookId());
        List<Message> messageList = messageService.findByBookId(message.getBookId());

        model.addAttribute("book",book);
        model.addAttribute("messageList",messageList);
        return "novel";
    }

//    留言编辑页面
    @RequestMapping("/message/editPage")
    public String editPage(Model model,Integer id){
//        从数据库查询到的数据
        Message dbMessage = messageService.findById(id);

        model.addAttribute("message",dbMessage);
        return "message/message-edit";
    }

//    更新留言信息的方法

    public  ResultData delete(Integer orderid,Integer orderStatus){
        return  bookOrderService.delete(orderid,orderStatus);
    }

    @RequestMapping("/bookOrder/toOrder")
    public  String delete(Integer bookId,Model model){
        Book book = bookService.findById(bookId);
        model.addAttribute("book",book);
        return  "front/order";
    }

    @RequestMapping("/bookOrder/toOrderCenter")
    public  String toOrderCenter(HttpSession session,Model model){
         /*Reader reader = (Reader)session.getAttribute("reader");
        if(reader==null){
            return  new ResultData(2001,"用户未登陆",null);
        }
        int readerId = reader.getReaderId();*/
         int readerId = 1;

        List<BookOrder> bookOrderList = bookOrderService.getAll(readerId);
        model.addAttribute("bookOrderList",bookOrderList);
        return  "front/orderCenter";
    }

}
package com.xh.controller;



    @RequestMapping("/admin/search")
    public String searchList(Model model,
                             @RequestParam(defaultValue = "1") Integer page,
                             @RequestParam(defaultValue = "5") Integer pageSize,
                             String keyword){

        PageInfo<Admin> pageInfo = adminService.searchList(page, pageSize, keyword);
        model.addAttribute("list",pageInfo.getList());
        model.addAttribute("pageInfo",pageInfo);

        return "admin/admin-list";
    }

    /**
     * 员工编辑页面
     * @return
     */
    @RequestMapping("/admin/editPage")
    public String editPage(Model model,Integer id){
        // 从数据库查询到的数据
        Admin dbAdmin = adminService.findById(id);

        model.addAttribute("admin",dbAdmin);
        return "admin/admin-edit";
    }

    /**
     * 更新员工基本信息的方法
     * @param admin
     * @return
     */
    @RequestMapping("/admin/edit")
    @ResponseBody
    public ResultData edit(Admin admin){
        return adminService.edit(admin);
    }



//将数据转发到页面
        model.addAttribute("list", pageInfo.getList());
        model.addAttribute("pageInfo", pageInfo);
        return "bookorder/bookorder-list";
    }

    @RequestMapping("/bookorder/orderSearch")
    public String searchList(Model model,
                                @RequestParam(defaultValue = "1") Integer page,
                                @RequestParam(defaultValue = "3") Integer pageSize,
                             String keyword) {
        PageInfo<BookOrder> pageInfo = bookOrderService.searchList(page,pageSize,keyword);

//将数据转发到页面
        model.addAttribute("list", pageInfo.getList());
        model.addAttribute("pageInfo", pageInfo);
        return "bookorder/bookorder-list";
    }

    @RequestMapping("/bookorder/bookorderadd")
    public String bookorderadd() {
        return "bookorder/bookorder-add";

    }

    @RequestMapping(value = "/bookorder/add",method = RequestMethod.POST)
    @ResponseBody
    public ResultData add(BookOrder bookOrder, HttpSession session) {
        Reader reader = (Reader)session.getAttribute("reader");
        if(reader==null){
            return  new ResultData(2001,"用户未登陆",null);
        }
        int readerId = reader.getReaderId();
        bookOrder.setUserId(1);
        bookOrder.setDiscountId(1);
        bookOrder.setOrderDate(new Timestamp(System.currentTimeMillis()));
        bookOrder.setOrderStatus(1);
        bookOrder.setPayStatus(1);
        ResultData resultData = bookOrderService.add(bookOrder);

        return resultData;
    }

    @RequestMapping("/bookorder/editStatus")

    //    search
    @RequestMapping("/book/search")
    public String searchList(Model model,
                             @RequestParam(defaultValue = "1") Integer page,
                             @RequestParam(defaultValue = "3") Integer pageSize,
                             String keyword) {
        PageInfo<Book> pageInfo=bookService.searchList(page,pageSize,keyword);

        model.addAttribute("list",pageInfo.getList());
        model.addAttribute("pageInfo",pageInfo);
        return  "book/book-list";
    }

    @RequestMapping("/book/search1")
    public String searchList1(Model model,
                             @RequestParam(defaultValue = "1") Integer page,
                             @RequestParam(defaultValue = "3") Integer pageSize,
                             String keyword1) {
        PageInfo<Book> pageInfo=bookService.searchList1(page,pageSize,keyword1);

        model.addAttribute("list",pageInfo.getList());
        model.addAttribute("pageInfo",pageInfo);
        return  "book/book-list";
    }

    @RequestMapping(value = "/book/getByType",method = RequestMethod.GET)
    public String getByType(Integer bookType, Model model, HttpSession session){
        List<Book> bookList = bookService.findByType(bookType);
        List<Book> randList = bookService.findRandList();
        //将字符串数组转为int数组
        session.setAttribute("bookList",bookList);
        session.setAttribute("randList",randList);
        return "/front/personal";
    }

    @RequestMapping(value = "/book/getByName",method = RequestMethod.POST)
    public String getByName(String likeName, Model model, HttpSession session) throws UnsupportedEncodingException {
       // String likeName1 = new String(likeName.getBytes("ISO-8859-1"),"utf-8");
        List<Book> bookList = bookService.findByLikeName(likeName);
        List<Book> randList = bookService.findRandList();
        //将字符串数组转为int数组
        session.setAttribute("bookList",bookList);
        session.setAttribute("randList",randList);
        return "/front/personal";

        if (condition != 1 && condition != 2 && condition != 3) {
            return new ResultData(6002, "状态数据不正确");
        }
        if (bookMapper.updateStatus(bookId, condition)) {
            return new ResultData(200, "处理状态数据成功");
        }
        return new ResultData(6003, "处理状态数据失败");
    }

    @Override
    public Book findById(Integer bookId) {
        return bookMapper.findById(bookId);
    }

    //    更新基本信息
    @Override
    public ResultData edit(Book book) {
        if (book == null) {
            return new ResultData(7001, "更新数据异常");
        }
        if (bookMapper.update(book)) {
            return new ResultData(200, "更新数据成功");
        }
        return new ResultData(7002, "更新失败");
    }

    //批量更改状态
    @Override
    public ResultData batchDelete(String[] ids) {
        if (ids.length == 0) {
            return new ResultData(8001, "批量删除数据异常");
        }
        if (bookMapper.batchUpdateStatus(ids)) {
            return new ResultData(200, "批量删除数据成功");
        }
        return new ResultData(8002, "批量删除数据失败");
    }

    //search
    @Override
    public PageInfo<Book> searchList(Integer page, Integer pageSize, String keyword) {
        PageHelper.startPage(page, pageSize);
        List<Book> list = bookMapper.findByName("%" + keyword + "%");
        return new PageInfo<>(list);
    }

    @Override
    public PageInfo<Book> searchList1(Integer page, Integer pageSize, String keyword1) {
        PageHelper.startPage(page, pageSize);
        List<Book> list = bookMapper.findByAuthor("%" + keyword1 + "%");
        return new PageInfo<>(list);
    }

请添加图片描述

请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述

m0_71481852
关注
基于javaweb的在线小说阅读系统(读者+作者+管理员)(java+ssm+jsp+mysql)
m0_68551656的博客
10-23 920
基于javaweb的在线小说阅读系统(读者+作者+管理员)(java+ssm+jsp+mysql) 运行环境 Java≥8、MySQL≥5.7、Tomcat≥8 开发工具 eclipse/idea/myeclipse/sts等均可配置运行 适用 课程设计，大作业，毕业设计，项目练习，学习演示等 功能说明 ![20220519002739](https://pic1.imgdb.cn/files/52560/project20/20220519002739.jpg)
基于SSM基于在线阅读系统mysql数据源
QQ21503882的博客
10-12 893
基于SSM基于在线阅读系统mysql数据源mysql数据源1.包含源程序，数据库脚本。代码和数据库脚本都有详细注释。 2.课题设计仅供参考学习使用，可以在此基础上进行扩展完善 开发环境： Eclipse ,MYSQL,JDK1.8,Tomcat 7 代码已经上传github，下载地址https://github.com/21503882/reading 涉及技术点： MVC模式、SpringM...
基于javaweb+mysql的ssm小说在线阅读系统(前台阅读+后台管理)(java+ssm+jsp+mysql)
毕业javaweb，一直在线，欢迎私信
11-16 132
项目技术： JSP +Spring + SpringMVC + MyBatis + html+ css + JavaScript + JQuery + Ajax等等。基于javaweb+mysql的ssm小说在线阅读系统(前台阅读+后台管理)(java+ssm+jsp+mysql)基于javaweb+mysql的SSM小说在线阅读系统(前台阅读+后台管理)(java+ssm+jsp+mysql)
Java项目:小说在线阅读系统(前台阅读+后台管理)(java+SSM+jsp+mysql+maven)
常年被追砍的博客
07-12 813
一、项目简述 功能包括(管理员和游客角色)： 1:用户及主要操作功能 游客可以浏览网站的主页，但是需要注册为会员后部分小 说才能对网络小说进免费行阅读或阅读。用户可以收藏书 架，留言评论，上次阅读，阅读历史，章节选择等等功 能。 2:管理模块 网络小说管理模块包括不同网络小说类别的添加，删除以 及网络小说的上传，删除管理。可以包括武侠小书，都市 言情，穿越小书等各个类等等功能。 二、项目运行 环境配置： Jdk1.8 + Tomcat8.5 + mysql + Eclispe (Intel..
基于JAVAWEB的小说阅读网站管理系统
qq_43485489的博客
05-27 2020
该系统采用了JAVAWeb开发技术，以Eclipse为开发工具，MySQL用于存储该系统的所有数据信息。通过Tomcat将其部署到本地服务器。 系统分为3类角色，分别是管理员、用户、编辑者。不同的角色登录之后，具有不同的操作权限。管理员的权限最高。可以添加编辑者和用户的账户，并对他们的信息进行修改。 （1）管理员有权限管理所有信息，并对编辑者发布的小说内容进行审核，审核通过之后，才能供人们阅读。管理员也可以录入、修改、删除小说的内容。此外，管理员还可以新增小说的种类，例如言情小说、科幻小说等。可以查看到
Jsp web小说在线阅读网站的设计与实现(附源码 调试 文档)
shenchengyv的博客
11-02 1056
本文设计并实现了一个基于JSP和MySQL的小说在线阅读网站管理系统。系统包括两种用户角色：系统管理员和前台会员。系统管理员具有会员管理、通知公告管理、小说类别管理、小说管理和留言管理的功能；前台会员具有小说阅读、小说搜索、公告查看和个人中心管理的功能。本文详细介绍了系统的设计思路、实现方法和具体功能，并通过实际应用案例证明了系统的可行性和实用性。本系统的设计和实现对于提高小说在线阅读网站的管理效率和用户体验具有重要的意义，可以为小说在线阅读网站提供有力的支持和帮助。
springboot+java+Mysql小说在线阅读系统-计算机毕业设计源码82630
2301_79169090的博客
07-31 1542
本文以java为开发技术，实现了一个小说在线阅读系统。小说在线阅读系统的主要使用者分为管理员、读者用户、作者用户；实现功能：首页、网站管理（轮播图、网站公告）人员管理（管理员、读者用户、作者用户）购物管理（小说商城、分类列表、订单列表）模块管理（小说类型、本周强推、点击榜单、更新榜单、创作作品、系统收入汇总、读者建议、作者建议、提现信息、稿费明细、稿费信息）个人管理等功能。通过这些功能模块的设计，基本上实现了整个小说信息管理的过程。
基于javaweb+mysql的ssm图书管理系统(java+ssm+jsp+jquery+mysql)
m0_71414463的博客
07-26 425
2.后台功能 后台系统登陆、用户信息管理、新闻公告信息管理、图书类型管理、图书信息管理、图书预约管理、延期申请管理、图书评价管理、意见反馈管理、统计信息等功能。使用IDEA/Eclipse/MyEclipse导入项目，修改配置，运行项目；
Java项目:轻语音乐网平台(java+Springboot+ssm+mysql+maven+jsp)
02-11
环境配置： Jdk1.8 + Tomcat8.5 + mysql + Eclispe (IntelliJ IDEA,Eclispe,MyEclispe,Sts 都支持) 项目技术： JSP +SpringBoot + MyBatis + html+ css + JavaScript + JQuery + Ajax + Bootstrap+ maven 等等。
Java项目:在线考试平台(java+Springboot+ssm+mysql+maven)
12-02
功能列表 考试前台 /系统登录：学生、教师、管理员登录 /门户首页：无需认证访问 /在线考试：需认证即可查看当前考除目 /题库中心：需认证查看题库 /成绩查询：需认证查询成绩 /留言板：需认证留言 管理后台 /考:...
Java项目:超市进销存系统设计和实现(java+Springboot+ssm+mysql+jsp+maven)
11-29
本系统主要实现的功能有： 用户管理，商品管理，销售管理，进货退货管理，仓库管 理等等功能。 二、项目运行 环境配置： Jdk1.8 + Tomcat8.5 + mysql + Eclispe (IntelliJ IDEA,Eclispe,MyEclispe,Sts 都支持) ...
Java项目:个人博客系统设计和实现(java+Springboot+ssm+mysql+jsp+maven)
11-29
环境配置： Jdk1.8 + Tomcat8.5 + mysql + Eclispe (IntelliJ IDEA,Eclispe,MyEclispe,Sts 都支持) 项目技术： JSP +Springboot+ SpringMVC + MyBatis + ThymeLeaf + HTML+ JavaScript + JQuery + Ajax + maven等等
Java企业面试题3
最新发布
m0_74972727的博客
09-15 311
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 566
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1090
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 112
");
C#基础（11）函数重载
a6s686的博客
09-12 859
我们通过这些例子的学习，想毕你一定已经掌握了函数重载的相关内容，我相信你只要稍加练习，便能达到很熟练的程度。不过不管知识点难或者简单，还是那句话，学习路上，戒骄戒躁，脚踏实地。请期待我的下一篇博客！
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 885
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
Java SSM+Vue后勤管理系统实现与功能详解
"Java+SSM+Vue的公寓宿舍后勤管理系统是一个基于B/S架构和Web技术的JavaWeb项目，利用Spring、SpringMVC和MyBatis（SSM）框架进行开发，结合Vue.js前端框架，提供了全面的后勤管理功能。项目包含源代码、数据库、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值