tj

RuoYi-App/pages/novel/list.vue

   try {
     console.log('准备打开小说:', novel);
     
-    // 确保 novel 对象存在且有有效 ID
-    if (!novel || typeof novel !== 'object') {
-      console.error('novel对象无效:', novel);
-      uni.showToast({
-        title: '小说信息错误',
-        icon: 'none'
-      });
-      return;
-    }
-    
-    // 获取小说ID - 使用若依框架的标准方式
     const novelId = novel.id || novel.novelId || novel.bookId;
     if (!novelId) {
       console.error('无法获取小说ID:', novel);
       return;
     }
     
-    console.log('跳转到阅读页面，小说ID:', novelId, '章节ID:', 1);
-    // 使用若依框架的标准导航方式
-    this.$router.push({
-      path: '/pages/novel/reader',
-      query: { novelId: novelId ,chapterId : 1}
-    });
+    console.log('跳转到阅读页面，小说ID:', novelId);
     
+    // 使用uni-app的标准导航方式
+    uni.navigateTo({
+      url: `/pages/novel/reader?novelId=${novelId}&chapterId=1`,
+      success: (res) => {
+        console.log('导航成功', res);
+      },
+      fail: (err) => {
+        console.error('导航失败', err);
+        // 备用导航方案
+        this.$router.push({
+          path: '/pages/novel/reader',
+          query: { novelId: novelId, chapterId: 1 }
+        });
+      }
+    });
   } catch (error) {
     console.error('openNovel方法执行异常:', error);
     uni.showToast({
   }
 },
 
+
 // 添加安全导航方法
 safeNavigateTo(url) {
   try {

RuoYi-App/pages/novel/reader.vue

 <template>
-  <view class="reader-container">
+  <view class="reader-container" :class="{ 'night-mode': nightMode }">
     <!-- 顶部导航栏 -->
     <view class="reader-header" v-if="showHeader">
       <view class="header-left">
     >
       <view class="chapter-title">{{chapterTitle}}</view>
       <view class="content-text">
-        <text>{{decodedContent}}</text>
+        <text>{{content}}</text>
       </view>
       
       <!-- 加载状态 -->
 
     <!-- 设置面板 -->
     <view class="settings-panel" v-if="showSettings">
-      <!-- 字体大小、背景颜色等设置 -->
+      <view class="font-size-controls">
+        <text class="iconfont icon-font-small" @click="decreaseFontSize"></text>
+        <text>字体大小: {{fontSize}}px</text>
+        <text class="iconfont icon-font-large" @click="increaseFontSize"></text>
+      </view>
+      <view class="background-options">
+        <view 
+          v-for="bg in backgroundOptions" 
+          :key="bg.value"
+          class="bg-option"
+          :class="{ active: backgroundColor === bg.value }"
+          :style="{ backgroundColor: bg.value }"
+          @click="changeBackground(bg.value)"
+        ></view>
+      </view>
     </view>
 
     <!-- 目录面板 -->
     <view class="catalog-panel" v-if="showCatalogPanel">
-      <!-- 章节列表 -->
+      <view class="catalog-header">
+        <text class="catalog-title">目录</text>
+        <text class="iconfont icon-close" @click="showCatalogPanel = false"></text>
+      </view>
+      <scroll-view class="chapter-list" scroll-y>
+        <view 
+          v-for="chapter in chapterList" 
+          :key="chapter.id"
+          class="chapter-item"
+          :class="{ active: chapter.id === chapterId }"
+          @click="selectChapter(chapter.id)"
+        >
+          <text>{{chapter.title}}</text>
+        </view>
+      </scroll-view>
     </view>
   </view>
 </template>
 
+
 <script>
 export default {
   data() {
       chapterId: '',
       novelTitle: '加载中...',
       chapterTitle: '加载中...',
-      content: '', // Base64编码的内容
-      decodedContent: '正在加载内容...', // 解码后的内容
+      content: '正在加载内容...', // 直接存储解码后的内容
       currentChapter: 1,
       totalChapters: 0,
       progress: 0,
       showFooter: false,
       showSettings: false,
       showCatalogPanel: false,
-      showAd: false, // 默认不显示广告
+      showAd: false,
       nightMode: false,
       touchStartX: 0,
       touchStartY: 0,
       lastScrollPosition: 0,
       loading: false,
-      error: null
+      error: null,
+      fontSize: 18,
+      backgroundColor: '#f5f0e1',
+      backgroundOptions: [
+        { value: '#f5f0e1', name: '羊皮纸' },
+        { value: '#e8f5e9', name: '护眼绿' },
+        { value: '#e3f2fd', name: '天空蓝' },
+        { value: '#fce4ec', name: '粉红' },
+        { value: '#1a1a1a', name: '夜间' }
+      ],
+      chapterList: []
     }
   },
+    // 添加所有生命周期钩子进行调试
+  beforeCreate() {
+    console.log('reader beforeCreate');
+  },
+    created() {
+    console.log('reader created');
+  },
+    beforeMount() {
+    console.log('reader beforeMount');
+  },
+    mounted() {
+    console.log('reader mounted');
+  },
+    onReady() {
+    console.log('reader onReady');
+  },
+    onHide() {
+    console.log('reader onHide');
+  },
+  onUnload() {
+    console.log('reader onUnload');
+  },
   onLoad(options) {
     console.log('阅读器页面加载，参数:', options);
     
-    // 确保参数正确获取
+    // 确保参数获取方式正确
     this.novelId = options.novelId || '';
     this.chapterId = options.chapterId || '1';
     
     if (!this.novelId) {
+      console.error('小说ID参数缺失');
       this.error = '小说ID参数缺失';
+      uni.showToast({
+        title: '小说ID参数缺失',
+        icon: 'none'
+      });
       return;
     }
     
+    // 显示加载提示
+    uni.showLoading({
+      title: '加载中...',
+      mask: true
+    });
+    
     this.loadChapterContent();
   },
-  methods: {
-    // 添加onScroll方法
-    onScroll(e) {
-      this.lastScrollPosition = e.detail.scrollTop;
-      // 计算阅读进度
-      this.calculateProgress();
-    },
-    
-    onTouchStart(e) {
-      this.touchStartX = e.touches[0].clientX;
-      this.touchStartY = e.touches[0].clientY;
-    },
-    
-    onTouchEnd(e) {
-      const endX = e.changedTouches[0].clientX;
-      const endY = e.changedTouches[0].clientY;
-      const diffX = endX - this.touchStartX;
-      const diffY = endY - this.touchStartY;
-      
-      // 横向滑动大于纵向滑动，且滑动距离大于50px
-      if (Math.abs(diffX) > Math.abs(diffY) && Math.abs(diffX) > 50) {
-        if (diffX > 0) {
-          this.prevChapter(); // 右滑，上一章
-        } else {
-          this.nextChapter(); // 左滑，下一章
-        }
-      }
-    },
-    
-    // Base64解码
-    decodeBase64(content) {
-      if (typeof content !== 'string') {
-        console.error('Base64解码失败：内容不是字符串');
-        return '内容格式错误';
-      }
-      
-      try {
-        // 处理可能的URL安全Base64编码
-        let base64 = content.replace(/-/g, '+').replace(/_/g, '/');
-        
-        // 添加必要的填充字符
-        const pad = base64.length % 4;
-        if (pad) {
-          if (pad === 1) {
-            throw new Error('InvalidLengthError: Input base64url string is the wrong length to determine padding');
-          }
-          base64 += new Array(5-pad).join('=');
-        }
-        
-        // 解码
-        const decoded = uni.base64ToArrayBuffer(base64);
-        const textDecoder = new TextDecoder('utf-8');
-        return textDecoder.decode(decoded);
-      } catch (error) {
-        console.error('Base64解码失败:', error);
-        return '内容解码失败，请稍后再试。';
+  onShow() {
+    // 确保页面显示时也能处理参数
+    const pages = getCurrentPages();
+    const currentPage = pages[pages.length - 1];
+    if (currentPage && currentPage.options) {
+      const options = currentPage.options;
+      if (options.novelId && !this.novelId) {
+        this.novelId = options.novelId;
+        this.chapterId = options.chapterId || '1';
+        this.loadChapterContent();
       }
-    },
-    
+    }
+  },
+  methods: {
     async loadChapterContent() {
       this.loading = true;
       this.error = null;
       
       try {
         console.log('开始请求章节内容，章节ID:', this.chapterId);
+        
+        // 使用若依框架的API调用方式
         const res = await this.$http.get(`/novel/chapter/${this.chapterId}`);
         console.log('章节内容响应:', res);
         
         if (res.code === 200) {
           this.novelTitle = res.data.novelTitle || '未知小说';
           this.chapterTitle = res.data.chapterTitle || '未知章节';
+          
+          // 后台已经解码Base64，直接使用内容
           this.content = res.data.content || '';
-          this.decodedContent = this.decodeBase64(this.content);
           
           // 设置章节信息
           this.currentChapter = res.data.chapterIndex || 1;
           this.totalChapters = res.data.totalChapters || 0;
+          
+          uni.showToast({
+            title: '加载成功',
+            icon: 'success',
+            duration: 1500
+          });
         } else {
           console.error('API返回错误状态码:', res.code);
-          this.error = '加载失败，请重试';
+          this.error = '加载失败: ' + (res.msg || '未知错误');
+          uni.showToast({
+            title: res.msg || '加载失败',
+            icon: 'none'
+          });
         }
       } catch (error) {
         console.error('加载章节内容失败:', error);
         this.error = '加载失败，请检查网络连接';
+        uni.showToast({
+          title: '加载失败，请检查网络连接',
+          icon: 'none'
+        });
       } finally {
         this.loading = false;
+        uni.hideLoading();
       }
     },
     
     calculateProgress() {
-      // 根据滚动位置计算阅读进度
-      // 这里需要获取内容区域的实际高度，由于uni-app中获取节点高度较为复杂，暂时用模拟数据
-      // 实际项目中应该通过uni.createSelectorQuery()获取
+      // 简化进度计算
       this.progress = Math.min(100, Math.round((this.lastScrollPosition / 1000) * 100));
     },
     
       }
     },
     
+    selectChapter(chapterId) {
+      this.chapterId = chapterId;
+      this.showCatalogPanel = false;
+      this.loadChapterContent();
+    },
+    
     showMenu() {
-      // 显示/隐藏顶部和底部栏
       this.showHeader = !this.showHeader;
       this.showFooter = !this.showFooter;
     },
     },
     
     showFontSettings() {
-      this.showSettings = true;
+      this.showSettings = !this.showSettings;
     },
     
     toggleNightMode() {
       this.nightMode = !this.nightMode;
-      // 切换夜间模式样式
+      this.backgroundColor = this.nightMode ? '#1a1a1a' : '#f5f0e1';
+    },
+    
+    increaseFontSize() {
+      this.fontSize = Math.min(24, this.fontSize + 2);
+    },
+    
+    decreaseFontSize() {
+      this.fontSize = Math.max(14, this.fontSize - 2);
+    },
+    
+    changeBackground(color) {
+      this.backgroundColor = color;
+      this.nightMode = color === '#1a1a1a';
     },
     
     setAdStrategy() {
-      // 设置广告显示策略，如每阅读三章显示一次广告
       const readChapters = uni.getStorageSync('readChapters') || 0;
       this.showAd = readChapters > 0 && readChapters % 3 === 0;
     },
 }
 </script>
 
+
 <style>
 .reader-container {
   position: relative;
   height: 100vh;
   display: flex;
   flex-direction: column;
-  background-color: #f5f0e1; /* 羊皮纸色背景 */
+  background-color: v-bind(backgroundColor);
+  transition: background-color 0.3s ease;
 }
 
 .reader-header {
   align-items: center;
   background: rgba(0, 0, 0, 0.8);
   color: white;
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  z-index: 1000;
 }
 
 .reader-content {
   padding: 20px;
   box-sizing: border-box;
   line-height: 1.8;
-  font-size: 18px;
+  font-size: v-bind(fontSize + 'px');
   color: #333;
+  margin-top: 44px;
+  margin-bottom: 50px;
 }
 
 .chapter-title {
   align-items: center;
   background: rgba(0, 0, 0, 0.8);
   color: white;
+  position: fixed;
+  bottom: 0;
+  left: 0;
+  right: 0;
+  z-index: 1000;
 }
 
 .reader-ad {
 
 .error-container button {
   margin-top: 20px;
+  background-color: var(--primary-color);
+  color: white;
+  border: none;
+  padding: 10px 20px;
+  border-radius: 5px;
+}
+
+.settings-panel {
+  position: fixed;
+  bottom: 50px;
+  left: 0;
+  right: 0;
+  background: rgba(255, 255, 255, 0.95);
+  padding: 20px;
+  z-index: 999;
+  box-shadow: 0 -2px 10px rgba(0, 0, 0, 0.1);
+}
+
+.font-size-controls {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 20px;
+}
+
+.background-options {
+  display: flex;
+  justify-content: space-around;
+}
+
+.bg-option {
+  width: 40px;
+  height: 40px;
+  border-radius: 50%;
+  border: 2px solid transparent;
+  cursor: pointer;
+}
+
+.bg-option.active {
+  border-color: var(--primary-color);
+}
+
+.catalog-panel {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: white;
+  z-index: 1001;
+}
+
+.catalog-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 15px;
+  border-bottom: 1px solid #eee;
+}
+
+.chapter-list {
+  height: calc(100vh - 60px);
+}
+
+.chapter-item {
+  padding: 15px;
+  border-bottom: 1px solid #eee;
+}
+
+.chapter-item.active {
+  color: var(--primary-color);
+  font-weight: bold;
 }
 
 /* 夜间模式样式 */
-.night-mode {
-  background-color: #1a1a1a;
+.night-mode .reader-content {
   color: #888;
 }
 
-.night-mode .reader-content {
-  background-color: #1a1a1a;
+.night-mode .content-text {
   color: #888;
 }
 </style>

RuoYi-App/router/index.js

 ]
 
 const router = new Router({
-  mode: 'history',
+  mode: 'hash',
   routes
 })
 

RuoYi-Vue/ruoyi-system/src/main/java/com/ruoyi/novel/controller/NovelController.java

 import com.ruoyi.common.core.page.TableDataInfo;
 import com.ruoyi.common.core.page.TableSupport;
 import com.ruoyi.novel.domain.AuthorApplicationDTO;
+import com.ruoyi.novel.domain.Chapter;
 import com.ruoyi.novel.domain.Novel;
 import com.ruoyi.novel.domain.NovelCategory;
 import com.ruoyi.novel.mapper.NovelMapper;
 import org.springframework.cache.annotation.Cacheable;
 import org.springframework.http.ResponseEntity;
 import org.springframework.scheduling.annotation.Async;
+import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.web.bind.annotation.*;
 
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 
     @GetMapping("/hot")
     public TableDataInfo getHotNovels() {
-        //startPage();
+
         List<Novel> hotNovels = novelService.getHotNovels();
-        //return novelService.getHotNovels();
-        // 返回统一格式 { code, msg, data }
+
         return getDataTable(hotNovels);
-        //return (List<Novel>) AjaxResult.success(hotNovels);
+
     }
 
     // 获取分类列表
     public AjaxResult getCategories() {
         return AjaxResult.success(novelService.getAllCategories());
     }
-//    @GetMapping("/novel/categories")
-//    public ResponseEntity<?> getCategories() {
-//        return ResponseEntity.ok(novelService.getAllCategories());
-//    }
-    // 获取热门小说
-// 获取热门小说
-//    @GetMapping("/novel/hot")
-//    public ResponseEntity<?> getHotNovels() {
-//        return ResponseEntity.ok(novelService.getHotNovels());
-//    }
-    // 按分类获取小说
-// 按分类获取小说
-//@GetMapping("/list")
-//public TableDataInfo getNovelsByCategory(@RequestParam(required = false) Long categoryId) {
-//    return (TableDataInfo) novelService.getNovelsByCategory(categoryId);
-//}
+
+
     // 获取小说列表
     @GetMapping("/list")
     public TableDataInfo list(Novel novel) {
     }
 
 
-// 获取小说章节列表
-@GetMapping("/{novelId}/chapters")
-public AjaxResult getChapters(@PathVariable Long novelId) {
-    return AjaxResult.success(novelService.getChaptersByNovelId(novelId));
-}
+    // 获取小说章节列表
+    @GetMapping("/{novelId}/chapters")
+    public AjaxResult getChapters(@PathVariable Long novelId) {
+        return AjaxResult.success(novelService.getChaptersByNovelId(novelId));
+    }
+
 
-//    @GetMapping("/novel/{novelId}/chapters")
-//    public ResponseEntity<?> getChapters(@PathVariable Long novelId) {
-//        return ResponseEntity.ok(novelService.getChaptersByNovelId(novelId));
-//    }
     // 获取章节内容
-// 获取章节内容
-@GetMapping("/chapter/{chapterId}")
-public AjaxResult getChapterContent(@PathVariable Long chapterId) {
-    return AjaxResult.success(novelService.getChapterContent(chapterId));
-}
-//    @GetMapping("/novel/chapter/{chapterId}")
-//    public ResponseEntity<?> getChapterContent(@PathVariable Long chapterId) {
-//        return ResponseEntity.ok(novelService.getChapterContent(chapterId));
-//    }
-    // 提交作家申请
-//    @PostMapping("/author/apply")
-//    public ResponseEntity<?> applyAuthor(@RequestBody AuthorApplicationDTO dto,
-//                                         @RequestHeader("Authorization") String token) {
-//        Long userId = authService.getUserIdFromToken(token);
-//        novelService.submitAuthorApplication(dto, userId);
-//        return ResponseEntity.ok("申请已提交");
-//    }
+    @PreAuthorize("@ss.hasPermi('novel:chapter:query')")
+    @GetMapping("/chapter/{chapterId}")
+    public AjaxResult getChapterContent(@PathVariable("chapterId") Long chapterId) {
+        //return AjaxResult.success(novelService.getChapterContent(chapterId));
+
+        Chapter chapter = novelService.getChapterContent(chapterId);
+        if (chapter == null) {
+            return AjaxResult.error("章节不存在");
+        }
+
+        // 构建响应数据
+        Map<String, Object> data = new HashMap<>();
+        Novel novel = novelService.selectNovelById(chapter.getNovelId());
+
+        data.put("novelTitle", novel.getTitle() != null ? novel.getTitle() : "");
+        data.put("chapterTitle", chapter.getTitle());
+        data.put("content", chapter.getContent());
+        data.put("chapterIndex", chapter.getChapterOrder());
+        data.put("totalChapters", novelService.getChapterCount(chapter.getNovelId()));
+
+        return AjaxResult.success(data);
+    }
 
 
     // 提交作家申请
         novelService.submitAuthorApplication(dto, userId);
         return ResponseEntity.ok().build();
     }
-//    @GetMapping("/list")
-//    public TableDataInfo list(Novel novel) {
-//        startPage();
-//        List<Novel> list = novelService.selectNovelList(novel);
-//        return getDataTable(list);
-//    }
+
     @PostMapping("/add")
     public AjaxResult add(@RequestBody Novel novel) {
         return toAjax(novelService.insertNovel(novel));
     }
     @Async
     public CompletableFuture<List<Novel>> searchNovelsAsync(String keyword, Long categoryId) {
-        return CompletableFuture.completedFuture((List<Novel>) searchNovels(keyword, categoryId));
+        return CompletableFuture.completedFuture(searchService.searchNovels(keyword, categoryId));
     }
     @GetMapping("/suggest")
     public List<String> suggestKeywords(@RequestParam String prefix) {
         //searchService.deleteNovelIndex(id); // 删除索引
         return AjaxResult.success();
     }
-}
+}

RuoYi-Vue/ruoyi-system/src/main/java/com/ruoyi/novel/domain/Chapter.java

 package com.ruoyi.novel.domain;
 
 
+import com.ruoyi.novel.service.NovelService;
+import com.ruoyi.system.domain.SysOperLog;
 import lombok.Data;
+import org.springframework.beans.factory.annotation.Autowired;
 
 import javax.persistence.*;
 import java.util.Date;
 @Entity
 @Table(name = "chapter")
 public class Chapter {
+
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
     @Column(name = "create_time")
     private Date createTime;
 
-
-
     // Getters and setters
 }

RuoYi-Vue/ruoyi-system/src/main/java/com/ruoyi/novel/mapper/ChapterMapper.java

     int insertChapter(Chapter chapter);
     List<Chapter> selectChapterList(Chapter chapter);
     Integer selectMaxChapterOrder(Long novelId);
+    int selectChapterCountByNovelId(Long novelId);
 }

RuoYi-Vue/ruoyi-system/src/main/java/com/ruoyi/novel/service/NovelService.java

         assert novelRepository != null : "JPA Repository未注入";
         //assert novelSearchRepository != null : "ES Repository未注入";
     }
+    int getChapterCount(Long novelId);
 }

RuoYi-Vue/ruoyi-system/src/main/java/com/ruoyi/novel/service/impl/NovelServiceImpl.java

 
 import com.ruoyi.novel.repository.jpa.NovelRepository;
 import com.ruoyi.novel.service.*;
+import com.ruoyi.novel.utils.Base64Utils;
 import com.ruoyi.system.mapper.SysUserMapper;
 import jdk.jfr.Category;
 import org.slf4j.Logger;
 
     @Override
     public Chapter getChapterContent(Long chapterId) {
-        return chapterMapper.selectChapterById(chapterId);
+        Chapter chapter = chapterMapper.selectChapterById(chapterId);
+        if (chapter != null && chapter.getContent() != null) {
+            // 解码Base64内容
+            String decodedContent = Base64Utils.decode(chapter.getContent());
+            chapter.setContent(decodedContent);
+        }
+        return chapter;
+        //return chapterMapper.selectChapterById(chapterId);
     }
 
     @Override
 //
 //    }
 
-
+    @Override
+    public int getChapterCount(Long novelId) {
+        return chapterMapper.selectChapterCountByNovelId(novelId);
+    }
 
     // 其他CRUD方法...
 }

RuoYi-Vue/ruoyi-system/src/main/java/com/ruoyi/novel/utils/Base64Utils.java

+package com.ruoyi.novel.utils;
+
+
+import java.util.Base64;
+
+/**
+ * Base64工具类
+ */
+public class Base64Utils {
+
+    /**
+     * 解码Base64字符串（兼容URL安全格式）
+     * @param base64Str Base64编码的字符串
+     * @return 解码后的字符串
+     */
+    public static String decode(String base64Str) {
+        if (base64Str == null || base64Str.isEmpty()) {
+            return "";
+        }
+
+        try {
+            // 处理URL安全的Base64编码（将'-'替换为'+'，将'_'替换为'/')
+            String base64 = base64Str.replace('-', '+').replace('_', '/');
+
+            // 添加必要的填充字符
+            int pad = base64.length() % 4;
+            if (pad > 0) {
+                base64 += "====".substring(pad);
+            }
+
+            // 解码
+            byte[] decodedBytes = Base64.getDecoder().decode(base64);
+            return new String(decodedBytes, "UTF-8");
+        } catch (Exception e) {
+            // 解码失败，返回原始字符串或空字符串
+            return "内容解码失败: " + e.getMessage();
+        }
+    }
+
+    /**
+     * 编码字符串为Base64
+     * @param str 要编码的字符串
+     * @return Base64编码的字符串
+     */
+    public static String encode(String str) {
+        if (str == null || str.isEmpty()) {
+            return "";
+        }
+
+        try {
+            return Base64.getEncoder().encodeToString(str.getBytes("UTF-8"));
+        } catch (Exception e) {
+            return "";
+        }
+    }
+}

RuoYi-Vue/ruoyi-system/src/main/resources/mapper/novel/ChapterMapper.xml

         FROM novel_category
         WHERE id = #{categoryId}
     </select>
+    <select id="selectChapterCountByNovelId" parameterType="Long" resultType="int">
+        SELECT COUNT(*) FROM novel_chapter WHERE novel_id = #{novelId}
+    </select>
 </mapper>