lxy5

back/src/main/java/com/service/impl/KefangyudingServiceImpl.java

@@ -1,63 +1,105 @@
+// 声明该类所属的包，通常用于组织和管理服务实现类相关代码
 package com.service.impl;
 
+// 导入Spring框架的Service注解，用于将当前类标记为一个服务组件，使其能被Spring容器管理和识别
 import org.springframework.stereotype.Service;
+// 导入Java标准库中的Map接口，用于处理键值对形式的数据，常用于方法参数传递等场景
 import java.util.Map;
+// 导入Java标准库中的List接口，用于处理一组有序的对象集合，常用于方法的返回值或参数中
 import java.util.List;
 
+// 导入MyBatis-Plus框架的Wrapper接口，它是构建查询条件的基础接口
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus框架的EntityWrapper类，用于创建基于实体类的查询条件包装器
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus框架的Page类，用于处理分页查询相关的数据和操作
 import com.baomidou.mybatisplus.plugins.Page;
+// 导入MyBatis-Plus框架的ServiceImpl类，提供了基础的服务层实现方法和功能
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+// 导入自定义的PageUtils工具类，用于将MyBatis-Plus的Page对象转换为自定义的分页工具对象
 import com.utils.PageUtils;
+// 导入自定义的Query工具类，用于构建查询参数和获取分页的Page对象
 import com.utils.Query;
 
-
+// 导入自定义的数据访问对象接口，用于对客房预订数据进行数据库操作
 import com.dao.KefangyudingDao;
+// 导入自定义的客房预订实体类，用于表示数据库中客房预订表的记录
 import com.entity.KefangyudingEntity;
+// 导入自定义的客房预订服务接口，当前类实现该接口以提供具体的客房预订业务逻辑
 import com.service.KefangyudingService;
+// 导入自定义的客房预订值对象类，用于在业务逻辑中传输和处理特定格式的客房预订数据
 import com.entity.vo.KefangyudingVO;
+// 导入自定义的客房预订视图类，用于以特定的视图形式展示客房预订相关的数据
 import com.entity.view.KefangyudingView;
 
+// 使用Service注解将该类注册为Spring的服务组件，服务名称为"kefangyudingService"
 @Service("kefangyudingService")
+// 继承ServiceImpl类，并指定数据访问对象为KefangyudingDao和实体类为KefangyudingEntity，实现KefangyudingService接口
 public class KefangyudingServiceImpl extends ServiceImpl<KefangyudingDao, KefangyudingEntity> implements KefangyudingService {
-	
-	
-    @Override
-    public PageUtils queryPage(Map<String, Object> params) {
-        Page<KefangyudingEntity> page = this.selectPage(
-                new Query<KefangyudingEntity>(params).getPage(),
-                new EntityWrapper<KefangyudingEntity>()
-        );
-        return new PageUtils(page);
-    }
-    
-    @Override
+
+	// 重写queryPage方法，根据传入的参数进行分页查询客房预订实体数据
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @return PageUtils对象，包含了分页查询结果的相关信息，如总记录数、当前页码等
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象
+		Page<KefangyudingEntity> page = this.selectPage(
+				new Query<KefangyudingEntity>(params).getPage(),
+				// 创建一个空的实体查询条件包装器，即查询所有符合条件的记录（这里未添加具体条件）
+				new EntityWrapper<KefangyudingEntity>()
+		);
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
+		return new PageUtils(page);
+	}
+
+	// 重写queryPage方法，根据传入的参数和查询条件进行分页查询客房预订视图数据
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @param wrapper 用于构建查询条件的包装器，类型为KefangyudingEntity的包装器
+	// @return PageUtils对象，包含了分页查询结果的相关信息
+	@Override
 	public PageUtils queryPage(Map<String, Object> params, Wrapper<KefangyudingEntity> wrapper) {
-		  Page<KefangyudingView> page =new Query<KefangyudingView>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
-	    	PageUtils pageUtil = new PageUtils(page);
-	    	return pageUtil;
- 	}
-    
-    @Override
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象，指定类型为KefangyudingView
+		Page<KefangyudingView> page = new Query<KefangyudingView>(params).getPage();
+		// 设置分页对象的记录，通过调用数据访问对象的selectListView方法，传入分页对象和查询条件包装器获取结果
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	// 重写selectListVO方法，根据传入的查询条件查询客房预订值对象列表
+	// @param wrapper 用于构建查询条件的包装器，类型为KefangyudingEntity的包装器
+	// @return 包含客房预订值对象的List集合
+	@Override
 	public List<KefangyudingVO> selectListVO(Wrapper<KefangyudingEntity> wrapper) {
- 		return baseMapper.selectListVO(wrapper);
+		// 调用数据访问对象的selectListVO方法，传入查询条件包装器，获取客房预订值对象列表
+		return baseMapper.selectListVO(wrapper);
 	}
-	
+
+	// 重写selectVO方法，根据传入的查询条件查询单个客房预订值对象
+	// @param wrapper 用于构建查询条件的包装器，类型为KefangyudingEntity的包装器
+	// @return 单个客房预订值对象
 	@Override
 	public KefangyudingVO selectVO(Wrapper<KefangyudingEntity> wrapper) {
- 		return baseMapper.selectVO(wrapper);
+		// 调用数据访问对象的selectVO方法，传入查询条件包装器，获取单个客房预订值对象
+		return baseMapper.selectVO(wrapper);
 	}
-	
+
+	// 重写selectListView方法，根据传入的查询条件查询客房预订视图列表
+	// @param wrapper 用于构建查询条件的包装器，类型为KefangyudingEntity的包装器
+	// @return 包含客房预订视图的List集合
 	@Override
 	public List<KefangyudingView> selectListView(Wrapper<KefangyudingEntity> wrapper) {
+		// 调用数据访问对象的selectListView方法，传入查询条件包装器，获取客房预订视图列表
 		return baseMapper.selectListView(wrapper);
 	}
 
+	// 重写selectView方法，根据传入的查询条件查询单个客房预订视图
+	// @param wrapper 用于构建查询条件的包装器，类型为KefangyudingEntity的包装器
+	// @return 单个客房预订视图
 	@Override
 	public KefangyudingView selectView(Wrapper<KefangyudingEntity> wrapper) {
+		// 调用数据访问对象的selectView方法，传入查询条件包装器，获取单个客房预订视图
 		return baseMapper.selectView(wrapper);
 	}
-
-
-}
+}

back/src/main/java/com/service/impl/NewsServiceImpl.java

@@ -1,63 +1,105 @@
+// 声明该类所在的包为com.service.impl，通常用于组织服务实现类
 package com.service.impl;
 
+// 导入Spring框架中用于声明服务层组件的注解，将当前类标记为一个服务组件
 import org.springframework.stereotype.Service;
+// 导入Java标准库中的Map接口，用于处理键值对数据，常用于方法参数传递
 import java.util.Map;
+// 导入Java标准库中的List接口，用于处理一组有序的数据，常用于方法返回值
 import java.util.List;
 
+// 导入MyBatis-Plus框架中用于构建查询条件的包装器接口
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus框架中用于构建实体包装器的类，可用于构建实体相关的查询条件
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus框架中用于分页的Page类，用于处理分页查询操作
 import com.baomidou.mybatisplus.plugins.Page;
+// 导入MyBatis-Plus框架中提供基础服务层实现的ServiceImpl类
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+// 导入自定义的工具类，用于处理分页结果，将MyBatis-Plus的Page对象转换为自定义的分页工具对象
 import com.utils.PageUtils;
+// 导入自定义的工具类，用于构建查询相关的操作，如分页参数的处理等
 import com.utils.Query;
 
-
+// 导入自定义的数据访问对象接口，用于对新闻数据进行数据库操作
 import com.dao.NewsDao;
+// 导入自定义的新闻实体类，用于表示数据库中新闻表的记录
 import com.entity.NewsEntity;
+// 导入自定义的新闻服务接口，当前类实现该接口以提供具体的新闻业务逻辑
 import com.service.NewsService;
+// 导入自定义的新闻值对象类，用于在特定业务场景下传输和处理新闻相关的数据
 import com.entity.vo.NewsVO;
+// 导入自定义的新闻视图类，用于以特定的格式展示新闻相关的数据
 import com.entity.view.NewsView;
 
+// 使用Service注解将该类注册为Spring的服务组件，名称为"newsService"
 @Service("newsService")
+// 当前类继承自ServiceImpl，并实现了NewsService接口，指定了数据访问对象为NewsDao和实体类为NewsEntity
 public class NewsServiceImpl extends ServiceImpl<NewsDao, NewsEntity> implements NewsService {
-	
-	
-    @Override
-    public PageUtils queryPage(Map<String, Object> params) {
-        Page<NewsEntity> page = this.selectPage(
-                new Query<NewsEntity>(params).getPage(),
-                new EntityWrapper<NewsEntity>()
-        );
-        return new PageUtils(page);
-    }
-    
-    @Override
+
+	// 根据传入的参数进行分页查询新闻实体数据的方法
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @return PageUtils对象，包含了分页查询结果的相关信息，如总记录数、当前页码等
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 创建分页对象，使用Query工具类从参数中提取分页信息
+		Page<NewsEntity> page = this.selectPage(
+				new Query<NewsEntity>(params).getPage(),
+				// 创建一个空的实体包装器，用于查询所有符合条件的新闻实体（未添加具体条件）
+				new EntityWrapper<NewsEntity>()
+		);
+		// 将查询得到的Page对象转换为自定义的PageUtils对象并返回
+		return new PageUtils(page);
+	}
+
+	// 根据传入的参数和包装器进行分页查询新闻视图数据的方法
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @param wrapper 用于构建查询条件的包装器，类型为NewsEntity的包装器
+	// @return PageUtils对象，包含了分页查询结果的相关信息
+	@Override
 	public PageUtils queryPage(Map<String, Object> params, Wrapper<NewsEntity> wrapper) {
-		  Page<NewsView> page =new Query<NewsView>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
-	    	PageUtils pageUtil = new PageUtils(page);
-	    	return pageUtil;
- 	}
-    
-    @Override
+		// 创建分页对象，使用Query工具类从参数中提取分页信息，指定类型为NewsView
+		Page<NewsView> page = new Query<NewsView>(params).getPage();
+		// 设置分页对象的记录，通过调用数据访问对象的selectListView方法查询
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 创建PageUtils对象并返回
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	// 根据传入的包装器查询新闻值对象列表的方法
+	// @param wrapper 用于构建查询条件的包装器，类型为NewsEntity的包装器
+	// @return 新闻值对象列表
+	@Override
 	public List<NewsVO> selectListVO(Wrapper<NewsEntity> wrapper) {
- 		return baseMapper.selectListVO(wrapper);
+		// 调用数据访问对象的selectListVO方法查询
+		return baseMapper.selectListVO(wrapper);
 	}
-	
+
+	// 根据传入的包装器查询单个新闻值对象的方法
+	// @param wrapper 用于构建查询条件的包装器，类型为NewsEntity的包装器
+	// @return 单个新闻值对象
 	@Override
 	public NewsVO selectVO(Wrapper<NewsEntity> wrapper) {
- 		return baseMapper.selectVO(wrapper);
+		// 调用数据访问对象的selectVO方法查询
+		return baseMapper.selectVO(wrapper);
 	}
-	
+
+	// 根据传入的包装器查询新闻视图列表的方法
+	// @param wrapper 用于构建查询条件的包装器，类型为NewsEntity的包装器
+	// @return 新闻视图列表
 	@Override
 	public List<NewsView> selectListView(Wrapper<NewsEntity> wrapper) {
+		// 调用数据访问对象的selectListView方法查询
 		return baseMapper.selectListView(wrapper);
 	}
 
+	// 根据传入的包装器查询单个新闻视图的方法
+	// @param wrapper 用于构建查询条件的包装器，类型为NewsEntity的包装器
+	// @return 单个新闻视图
 	@Override
 	public NewsView selectView(Wrapper<NewsEntity> wrapper) {
+		// 调用数据访问对象的selectView方法查询
 		return baseMapper.selectView(wrapper);
 	}
-
-
-}
+}

back/src/main/java/com/service/impl/RuzhuanpaiServiceImpl.java

@@ -1,63 +1,105 @@
+// 声明该类所属的包，用于组织和管理服务实现类，这里是 com.service.impl 包
 package com.service.impl;
 
+// 导入 Spring 框架的 Service 注解，用于将当前类标记为一个服务组件，使其能被 Spring 容器管理
 import org.springframework.stereotype.Service;
+// 导入 Java 标准库中的 Map 接口，用于处理键值对数据，常用于方法参数传递等场景
 import java.util.Map;
+// 导入 Java 标准库中的 List 接口，用于处理一组有序的对象集合，常用于方法的返回值或参数中
 import java.util.List;
 
+// 导入 MyBatis-Plus 框架的 Wrapper 接口，用于构建查询条件的包装器
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入 MyBatis-Plus 框架的 EntityWrapper 类，用于创建基于实体类的查询条件包装器
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入 MyBatis-Plus 框架的 Page 类，用于处理分页查询，存储分页相关的数据
 import com.baomidou.mybatisplus.plugins.Page;
+// 导入 MyBatis-Plus 框架的 ServiceImpl 类，提供了基础的服务层实现方法和通用功能
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+// 导入自定义的 PageUtils 工具类，用于处理分页结果，将 MyBatis-Plus 的 Page 对象转换为自定义的分页工具对象
 import com.utils.PageUtils;
+// 导入自定义的 Query 工具类，用于从参数 Map 中构建分页查询所需的参数和 Page 对象
 import com.utils.Query;
 
-
+// 导入自定义的数据访问对象接口，用于对如转派（根据类名推测）相关数据进行数据库操作
 import com.dao.RuzhuanpaiDao;
+// 导入自定义的如转派实体类，用于表示数据库中如转派表的记录
 import com.entity.RuzhuanpaiEntity;
+// 导入自定义的如转派服务接口，当前类实现该接口以提供具体的如转派业务逻辑
 import com.service.RuzhuanpaiService;
+// 导入自定义的如转派值对象类，用于在特定业务场景下传输和处理如转派相关的数据
 import com.entity.vo.RuzhuanpaiVO;
+// 导入自定义的如转派视图类，用于以特定的视图形式展示如转派相关的数据
 import com.entity.view.RuzhuanpaiView;
 
+// 使用 Service 注解将该类注册为 Spring 的服务组件，服务名称为 "ruzhuanpaiService"
 @Service("ruzhuanpaiService")
+// 继承 ServiceImpl 类，并指定数据访问对象为 RuzhuanpaiDao 和实体类为 RuzhuanpaiEntity，实现 RuzhuanpaiService 接口
 public class RuzhuanpaiServiceImpl extends ServiceImpl<RuzhuanpaiDao, RuzhuanpaiEntity> implements RuzhuanpaiService {
-	
-	
-    @Override
-    public PageUtils queryPage(Map<String, Object> params) {
-        Page<RuzhuanpaiEntity> page = this.selectPage(
-                new Query<RuzhuanpaiEntity>(params).getPage(),
-                new EntityWrapper<RuzhuanpaiEntity>()
-        );
-        return new PageUtils(page);
-    }
-    
-    @Override
+
+	// 重写 queryPage 方法，根据传入的参数进行分页查询如转派实体数据
+	// @param params 包含查询条件、分页参数等信息的 Map 集合
+	// @return PageUtils 对象，包含了分页查询结果的相关信息，如总记录数、当前页码等
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 创建分页对象，使用 Query 工具类从参数中构建分页参数并获取 Page 对象
+		Page<RuzhuanpaiEntity> page = this.selectPage(
+				new Query<RuzhuanpaiEntity>(params).getPage(),
+				// 创建一个空的实体查询条件包装器，即查询所有符合条件的记录（这里未添加具体条件）
+				new EntityWrapper<RuzhuanpaiEntity>()
+		);
+		// 使用 PageUtils 工具类将 MyBatis-Plus 的 Page 对象转换为自定义的分页工具对象并返回
+		return new PageUtils(page);
+	}
+
+	// 重写 queryPage 方法，根据传入的参数和查询条件进行分页查询如转派视图数据
+	// @param params 包含查询条件、分页参数等信息的 Map 集合
+	// @param wrapper 用于构建查询条件的包装器，类型为 RuzhuanpaiEntity 的包装器
+	// @return PageUtils 对象，包含了分页查询结果的相关信息
+	@Override
 	public PageUtils queryPage(Map<String, Object> params, Wrapper<RuzhuanpaiEntity> wrapper) {
-		  Page<RuzhuanpaiView> page =new Query<RuzhuanpaiView>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
-	    	PageUtils pageUtil = new PageUtils(page);
-	    	return pageUtil;
- 	}
-    
-    @Override
+		// 创建分页对象，使用 Query 工具类从参数中构建分页参数并获取 Page 对象，指定类型为 RuzhuanpaiView
+		Page<RuzhuanpaiView> page = new Query<RuzhuanpaiView>(params).getPage();
+		// 设置分页对象的记录，通过调用数据访问对象的 selectListView 方法，传入分页对象和查询条件包装器获取结果
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 使用 PageUtils 工具类将 MyBatis-Plus 的 Page 对象转换为自定义的分页工具对象并返回
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	// 重写 selectListVO 方法，根据传入的查询条件查询如转派值对象列表
+	// @param wrapper 用于构建查询条件的包装器，类型为 RuzhuanpaiEntity 的包装器
+	// @return 包含如转派值对象的 List 集合
+	@Override
 	public List<RuzhuanpaiVO> selectListVO(Wrapper<RuzhuanpaiEntity> wrapper) {
- 		return baseMapper.selectListVO(wrapper);
+		// 调用数据访问对象的 selectListVO 方法，传入查询条件包装器，获取如转派值对象列表
+		return baseMapper.selectListVO(wrapper);
 	}
-	
+
+	// 重写 selectVO 方法，根据传入的查询条件查询单个如转派值对象
+	// @param wrapper 用于构建查询条件的包装器，类型为 RuzhuanpaiEntity 的包装器
+	// @return 单个如转派值对象
 	@Override
 	public RuzhuanpaiVO selectVO(Wrapper<RuzhuanpaiEntity> wrapper) {
- 		return baseMapper.selectVO(wrapper);
+		// 调用数据访问对象的 selectVO 方法，传入查询条件包装器，获取单个如转派值对象
+		return baseMapper.selectVO(wrapper);
 	}
-	
+
+	// 重写 selectListView 方法，根据传入的查询条件查询如转派视图列表
+	// @param wrapper 用于构建查询条件的包装器，类型为 RuzhuanpaiEntity 的包装器
+	// @return 包含如转派视图的 List 集合
 	@Override
 	public List<RuzhuanpaiView> selectListView(Wrapper<RuzhuanpaiEntity> wrapper) {
+		// 调用数据访问对象的 selectListView 方法，传入查询条件包装器，获取如转派视图列表
 		return baseMapper.selectListView(wrapper);
 	}
 
+	// 重写 selectView 方法，根据传入的查询条件查询单个如转派视图
+	// @param wrapper 用于构建查询条件的包装器，类型为 RuzhuanpaiEntity 的包装器
+	// @return 单个如转派视图
 	@Override
 	public RuzhuanpaiView selectView(Wrapper<RuzhuanpaiEntity> wrapper) {
+		// 调用数据访问对象的 selectView 方法，传入查询条件包装器，获取单个如转派视图
 		return baseMapper.selectView(wrapper);
 	}
-
-
-}
+}

back/src/main/java/com/service/impl/StoreupServiceImpl.java

@@ -1,63 +1,105 @@
+// 声明该类所属的包，用于组织和管理服务实现类相关代码
 package com.service.impl;
 
+// 导入Spring框架的Service注解，将当前类标记为服务层组件，使其可被Spring容器管理
 import org.springframework.stereotype.Service;
+// 导入Java标准库中的Map接口，用于处理键值对数据，常用于方法参数传递等场景
 import java.util.Map;
+// 导入Java标准库中的List接口，用于处理一组有序的数据集合，常用于方法的返回值或参数中
 import java.util.List;
 
+// 导入MyBatis-Plus框架的Wrapper接口，是构建查询条件包装器的基础接口
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus框架的EntityWrapper类，用于创建基于实体类的查询条件包装器
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus框架的Page类，用于处理分页查询，存储分页相关的数据
 import com.baomidou.mybatisplus.plugins.Page;
+// 导入MyBatis-Plus框架的ServiceImpl类，提供基础的服务层实现方法和功能
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+// 导入自定义的PageUtils工具类，用于将MyBatis-Plus的Page对象转换为自定义的分页工具对象
 import com.utils.PageUtils;
+// 导入自定义的Query工具类，用于从参数Map中构建分页查询所需的参数和Page对象
 import com.utils.Query;
 
-
+// 导入自定义的数据访问对象接口，用于对收藏（根据类名推测）相关数据进行数据库操作
 import com.dao.StoreupDao;
+// 导入自定义的收藏实体类，用于表示数据库中收藏表的记录
 import com.entity.StoreupEntity;
+// 导入自定义的收藏服务接口，当前类实现该接口以提供具体的收藏业务逻辑
 import com.service.StoreupService;
+// 导入自定义的收藏值对象类，用于在特定业务场景下传输和处理收藏相关的数据
 import com.entity.vo.StoreupVO;
+// 导入自定义的收藏视图类，用于以特定的视图形式展示收藏相关的数据
 import com.entity.view.StoreupView;
 
+// 使用Service注解将该类注册为Spring的服务组件，服务名称为"storeupService"
 @Service("storeupService")
+// 继承ServiceImpl类，并指定数据访问对象为StoreupDao和实体类为StoreupEntity，实现StoreupService接口
 public class StoreupServiceImpl extends ServiceImpl<StoreupDao, StoreupEntity> implements StoreupService {
-	
-	
-    @Override
-    public PageUtils queryPage(Map<String, Object> params) {
-        Page<StoreupEntity> page = this.selectPage(
-                new Query<StoreupEntity>(params).getPage(),
-                new EntityWrapper<StoreupEntity>()
-        );
-        return new PageUtils(page);
-    }
-    
-    @Override
+
+	// 重写queryPage方法，根据传入的参数进行分页查询收藏实体数据
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @return PageUtils对象，包含了分页查询结果的相关信息，如总记录数、当前页码等
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象
+		Page<StoreupEntity> page = this.selectPage(
+				new Query<StoreupEntity>(params).getPage(),
+				// 创建一个空的实体查询条件包装器，即查询所有符合条件的记录（这里未添加具体条件）
+				new EntityWrapper<StoreupEntity>()
+		);
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
+		return new PageUtils(page);
+	}
+
+	// 重写queryPage方法，根据传入的参数和查询条件进行分页查询收藏视图数据
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @param wrapper 用于构建查询条件的包装器，类型为StoreupEntity的包装器
+	// @return PageUtils对象，包含了分页查询结果的相关信息
+	@Override
 	public PageUtils queryPage(Map<String, Object> params, Wrapper<StoreupEntity> wrapper) {
-		  Page<StoreupView> page =new Query<StoreupView>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
-	    	PageUtils pageUtil = new PageUtils(page);
-	    	return pageUtil;
- 	}
-    
-    @Override
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象，指定类型为StoreupView
+		Page<StoreupView> page = new Query<StoreupView>(params).getPage();
+		// 设置分页对象的记录，通过调用数据访问对象的selectListView方法，传入分页对象和查询条件包装器获取结果
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	// 重写selectListVO方法，根据传入的查询条件查询收藏值对象列表
+	// @param wrapper 用于构建查询条件的包装器，类型为StoreupEntity的包装器
+	// @return 包含收藏值对象的List集合
+	@Override
 	public List<StoreupVO> selectListVO(Wrapper<StoreupEntity> wrapper) {
- 		return baseMapper.selectListVO(wrapper);
+		// 调用数据访问对象的selectListVO方法，传入查询条件包装器，获取收藏值对象列表
+		return baseMapper.selectListVO(wrapper);
 	}
-	
+
+	// 重写selectVO方法，根据传入的查询条件查询单个收藏值对象
+	// @param wrapper 用于构建查询条件的包装器，类型为StoreupEntity的包装器
+	// @return 单个收藏值对象
 	@Override
 	public StoreupVO selectVO(Wrapper<StoreupEntity> wrapper) {
- 		return baseMapper.selectVO(wrapper);
+		// 调用数据访问对象的selectVO方法，传入查询条件包装器，获取单个收藏值对象
+		return baseMapper.selectVO(wrapper);
 	}
-	
+
+	// 重写selectListView方法，根据传入的查询条件查询收藏视图列表
+	// @param wrapper 用于构建查询条件的包装器，类型为StoreupEntity的包装器
+	// @return 包含收藏视图的List集合
 	@Override
 	public List<StoreupView> selectListView(Wrapper<StoreupEntity> wrapper) {
+		// 调用数据访问对象的selectListView方法，传入查询条件包装器，获取收藏视图列表
 		return baseMapper.selectListView(wrapper);
 	}
 
+	// 重写selectView方法，根据传入的查询条件查询单个收藏视图
+	// @param wrapper 用于构建查询条件的包装器，类型为StoreupEntity的包装器
+	// @return 单个收藏视图
 	@Override
 	public StoreupView selectView(Wrapper<StoreupEntity> wrapper) {
+		// 调用数据访问对象的selectView方法，传入查询条件包装器，获取单个收藏视图
 		return baseMapper.selectView(wrapper);
 	}
-
-
-}
+}

back/src/main/java/com/service/impl/TokenServiceImpl.java

@@ -1,7 +1,5 @@
-
 package com.service.impl;
 
-
 import java.util.Calendar;
 import java.util.Date;
 import java.util.List;
@@ -15,65 +13,101 @@ import com.baomidou.mybatisplus.plugins.Page;
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
 import com.dao.TokenDao;
 import com.entity.TokenEntity;
-import com.entity.TokenEntity;
 import com.service.TokenService;
 import com.utils.CommonUtil;
 import com.utils.PageUtils;
 import com.utils.Query;
 
-
 /**
- * token
+ * 处理token相关业务逻辑的服务实现类
  */
 @Service("tokenService")
+// 继承ServiceImpl类，指定数据访问对象为TokenDao和实体类为TokenEntity，实现TokenService接口
 public class TokenServiceImpl extends ServiceImpl<TokenDao, TokenEntity> implements TokenService {
 
+	// 根据传入的参数进行分页查询Token实体数据的方法
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @return PageUtils对象，包含了分页查询结果的相关信息，如总记录数、当前页码等
 	@Override
 	public PageUtils queryPage(Map<String, Object> params) {
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象
 		Page<TokenEntity> page = this.selectPage(
-                new Query<TokenEntity>(params).getPage(),
-                new EntityWrapper<TokenEntity>()
-        );
-        return new PageUtils(page);
+				new Query<TokenEntity>(params).getPage(),
+				// 创建一个空的实体查询条件包装器，即查询所有符合条件的记录（这里未添加具体条件）
+				new EntityWrapper<TokenEntity>()
+		);
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
+		return new PageUtils(page);
 	}
 
+	// 根据传入的查询条件包装器查询Token实体视图列表的方法
+	// @param wrapper 用于构建查询条件的包装器，类型为TokenEntity的包装器
+	// @return 包含Token实体视图的List集合
 	@Override
 	public List<TokenEntity> selectListView(Wrapper<TokenEntity> wrapper) {
+		// 调用数据访问对象的selectListView方法，传入查询条件包装器，获取Token实体视图列表
 		return baseMapper.selectListView(wrapper);
 	}
 
+	// 根据传入的参数和查询条件进行分页查询Token实体数据的方法
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @param wrapper 用于构建查询条件的包装器，类型为TokenEntity的包装器
+	// @return PageUtils对象，包含了分页查询结果的相关信息
 	@Override
 	public PageUtils queryPage(Map<String, Object> params,
-			Wrapper<TokenEntity> wrapper) {
-		 Page<TokenEntity> page =new Query<TokenEntity>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
-	    	PageUtils pageUtil = new PageUtils(page);
-	    	return pageUtil;
+							   Wrapper<TokenEntity> wrapper) {
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象
+		Page<TokenEntity> page = new Query<TokenEntity>(params).getPage();
+		// 设置分页对象的记录，通过调用数据访问对象的selectListView方法，传入分页对象和查询条件包装器获取结果
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
 	}
 
+	// 生成Token的方法，根据用户ID、用户名、表名和角色生成并处理Token相关信息
+	// @param userid 用户ID
+	// @param username 用户名
+	// @param tableName 表名
+	// @param role 角色
+	// @return 生成的Token字符串
 	@Override
-	public String generateToken(Long userid,String username, String tableName, String role) {
+	public String generateToken(Long userid, String username, String tableName, String role) {
+		// 根据用户ID和角色查询Token实体，判断是否已存在对应的Token记录
 		TokenEntity tokenEntity = this.selectOne(new EntityWrapper<TokenEntity>().eq("userid", userid).eq("role", role));
+		// 生成32位的随机字符串作为Token
 		String token = CommonUtil.getRandomString(32);
-		Calendar cal = Calendar.getInstance();   
-    	cal.setTime(new Date());   
-    	cal.add(Calendar.HOUR_OF_DAY, 1);
-		if(tokenEntity!=null) {
+		// 获取当前时间的日历对象
+		Calendar cal = Calendar.getInstance();
+		// 设置日历的时间为当前时间
+		cal.setTime(new Date());
+		// 将时间增加1小时，设置Token的过期时间
+		cal.add(Calendar.HOUR_OF_DAY, 1);
+		// 如果Token实体已存在，则更新其Token和过期时间
+		if (tokenEntity != null) {
 			tokenEntity.setToken(token);
 			tokenEntity.setExpiratedtime(cal.getTime());
 			this.updateById(tokenEntity);
 		} else {
-			this.insert(new TokenEntity(userid,username, tableName, role, token, cal.getTime()));
+			// 如果Token实体不存在，则插入一条新的Token记录
+			this.insert(new TokenEntity(userid, username, tableName, role, token, cal.getTime()));
 		}
+		// 返回生成的Token
 		return token;
 	}
 
+	// 根据Token获取Token实体的方法，并检查Token是否过期
+	// @param token Token字符串
+	// @return TokenEntity对象，如果Token无效或已过期则返回null
 	@Override
 	public TokenEntity getTokenEntity(String token) {
+		// 根据Token查询Token实体
 		TokenEntity tokenEntity = this.selectOne(new EntityWrapper<TokenEntity>().eq("token", token));
-		if(tokenEntity == null || tokenEntity.getExpiratedtime().getTime()<new Date().getTime()) {
+		// 如果Token实体不存在或者Token已过期（过期时间早于当前时间），则返回null
+		if (tokenEntity == null || tokenEntity.getExpiratedtime().getTime() < new Date().getTime()) {
 			return null;
 		}
+		// 返回有效的Token实体
 		return tokenEntity;
 	}
-}
+}

back/src/main/java/com/service/impl/UserServiceImpl.java

@@ -1,49 +1,83 @@
-
+// 声明该类所在的包，通常用于组织服务实现类
 package com.service.impl;
 
-
+// 导入用于存储和操作列表的List接口
 import java.util.List;
+// 导入用于存储键值对的Map接口
 import java.util.Map;
 
+// 导入Spring的Service注解，用于将该类标记为服务层组件
 import org.springframework.stereotype.Service;
 
+// 导入MyBatis-Plus的EntityWrapper类，用于构建实体查询条件
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus的Wrapper接口，是构建查询条件的基础接口
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus的Page类，用于处理分页查询
 import com.baomidou.mybatisplus.plugins.Page;
+// 导入MyBatis-Plus的ServiceImpl类，提供基础的服务层实现功能
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+// 导入用户数据访问对象接口，用于与数据库交互
 import com.dao.UserDao;
+// 导入用户实体类，用于表示数据库中的用户记录
 import com.entity.UserEntity;
+// 导入用户服务接口，该类将实现此接口的方法
 import com.service.UserService;
+// 导入自定义的分页工具类，用于封装分页查询结果
 import com.utils.PageUtils;
+// 导入自定义的查询工具类，用于从参数中构建查询条件和分页信息
 import com.utils.Query;
 
-
 /**
- * 系统用户
+ * 系统用户服务实现类，处理系统用户相关的业务逻辑
  */
 @Service("userService")
+// 继承ServiceImpl类并实现UserService接口
 public class UserServiceImpl extends ServiceImpl<UserDao, UserEntity> implements UserService {
 
+	/**
+	 * 根据传入的参数进行分页查询用户实体数据
+	 * @param params 包含查询条件、分页参数等信息的Map集合
+	 * @return PageUtils对象，包含分页查询结果的相关信息
+	 */
 	@Override
 	public PageUtils queryPage(Map<String, Object> params) {
+		// 使用Query工具类从参数中构建分页信息，获取Page对象
 		Page<UserEntity> page = this.selectPage(
-                new Query<UserEntity>(params).getPage(),
-                new EntityWrapper<UserEntity>()
-        );
-        return new PageUtils(page);
+				new Query<UserEntity>(params).getPage(),
+				// 创建一个空的实体查询条件包装器，查询所有用户记录
+				new EntityWrapper<UserEntity>()
+		);
+		// 使用PageUtils工具类封装分页查询结果
+		return new PageUtils(page);
 	}
 
+	/**
+	 * 根据传入的查询条件包装器查询用户实体列表
+	 * @param wrapper 用于构建查询条件的包装器
+	 * @return 包含用户实体的列表
+	 */
 	@Override
 	public List<UserEntity> selectListView(Wrapper<UserEntity> wrapper) {
+		// 调用数据访问对象的selectListView方法，根据查询条件包装器查询用户实体列表
 		return baseMapper.selectListView(wrapper);
 	}
 
+	/**
+	 * 根据传入的参数和查询条件进行分页查询用户实体数据
+	 * @param params 包含查询条件、分页参数等信息的Map集合
+	 * @param wrapper 用于构建查询条件的包装器
+	 * @return PageUtils对象，包含分页查询结果的相关信息
+	 */
 	@Override
 	public PageUtils queryPage(Map<String, Object> params,
-			Wrapper<UserEntity> wrapper) {
-		 Page<UserEntity> page =new Query<UserEntity>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
-	    	PageUtils pageUtil = new PageUtils(page);
-	    	return pageUtil;
+							   Wrapper<UserEntity> wrapper) {
+		// 使用Query工具类从参数中构建分页信息，获取Page对象
+		Page<UserEntity> page = new Query<UserEntity>(params).getPage();
+		// 调用数据访问对象的selectListView方法，根据分页信息和查询条件包装器查询用户实体列表，并设置到Page对象中
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 使用PageUtils工具类封装分页查询结果
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
 	}
-}
+}

back/src/main/java/com/service/impl/YonghuServiceImpl.java

@@ -16,7 +16,7 @@ import com.entity.YonghuEntity;
 import com.service.YonghuService;
 import com.entity.vo.YonghuVO;
 import com.entity.view.YonghuView;
-
+//test
 // 将该类标记为一个服务组件，名为"yonghuService"，用于处理与用户相关的业务逻辑
 @Service("yonghuService")
 // YonghuServiceImpl类继承自ServiceImpl<YonghuDao, YonghuEntity>，并实现了YonghuService接口

back/src/main/java/com/service/impl/YuangongServiceImpl.java

@@ -1,63 +1,105 @@
+// 声明该类所在的包，通常用于组织服务实现类
 package com.service.impl;
 
+// 导入Spring框架的Service注解，用于将当前类标记为一个服务组件
 import org.springframework.stereotype.Service;
+// 导入Java标准库中的Map接口，用于处理键值对数据，常用于方法参数传递等场景
 import java.util.Map;
+// 导入Java标准库中的List接口，用于处理一组有序的数据集合，常用于方法的返回值或参数中
 import java.util.List;
 
+// 导入MyBatis-Plus框架的Wrapper接口，用于构建查询条件的包装器
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus框架的EntityWrapper类，用于创建基于实体类的查询条件包装器
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus框架的Page类，用于处理分页查询，存储分页相关的数据
 import com.baomidou.mybatisplus.plugins.Page;
+// 导入MyBatis-Plus框架的ServiceImpl类，提供了基础的服务层实现方法和通用功能
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+// 导入自定义的PageUtils工具类，用于处理分页结果，将MyBatis-Plus的Page对象转换为自定义的分页工具对象
 import com.utils.PageUtils;
+// 导入自定义的Query工具类，用于从参数Map中构建分页查询所需的参数和Page对象
 import com.utils.Query;
 
-
+// 导入自定义的数据访问对象接口，用于对员工相关数据进行数据库操作
 import com.dao.YuangongDao;
+// 导入自定义的员工实体类，用于表示数据库中员工表的记录
 import com.entity.YuangongEntity;
+// 导入自定义的员工服务接口，当前类实现该接口以提供具体的员工业务逻辑
 import com.service.YuangongService;
+// 导入自定义的员工值对象类，用于在特定业务场景下传输和处理员工相关的数据
 import com.entity.vo.YuangongVO;
+// 导入自定义的员工视图类，用于以特定的视图形式展示员工相关的数据
 import com.entity.view.YuangongView;
 
+// 使用Service注解将该类注册为Spring的服务组件，服务名称为"yuangongService"
 @Service("yuangongService")
+// 继承ServiceImpl类，并指定数据访问对象为YuangongDao和实体类为YuangongEntity，实现YuangongService接口
 public class YuangongServiceImpl extends ServiceImpl<YuangongDao, YuangongEntity> implements YuangongService {
-	
-	
-    @Override
-    public PageUtils queryPage(Map<String, Object> params) {
-        Page<YuangongEntity> page = this.selectPage(
-                new Query<YuangongEntity>(params).getPage(),
-                new EntityWrapper<YuangongEntity>()
-        );
-        return new PageUtils(page);
-    }
-    
-    @Override
+
+	// 重写queryPage方法，根据传入的参数进行分页查询员工实体数据
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @return PageUtils对象，包含了分页查询结果的相关信息，如总记录数、当前页码等
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象
+		Page<YuangongEntity> page = this.selectPage(
+				new Query<YuangongEntity>(params).getPage(),
+				// 创建一个空的实体查询条件包装器，即查询所有符合条件的记录（这里未添加具体条件）
+				new EntityWrapper<YuangongEntity>()
+		);
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
+		return new PageUtils(page);
+	}
+
+	// 重写queryPage方法，根据传入的参数和查询条件进行分页查询员工视图数据
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @param wrapper 用于构建查询条件的包装器，类型为YuangongEntity的包装器
+	// @return PageUtils对象，包含了分页查询结果的相关信息
+	@Override
 	public PageUtils queryPage(Map<String, Object> params, Wrapper<YuangongEntity> wrapper) {
-		  Page<YuangongView> page =new Query<YuangongView>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
-	    	PageUtils pageUtil = new PageUtils(page);
-	    	return pageUtil;
- 	}
-    
-    @Override
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象，指定类型为YuangongView
+		Page<YuangongView> page = new Query<YuangongView>(params).getPage();
+		// 设置分页对象的记录，通过调用数据访问对象的selectListView方法，传入分页对象和查询条件包装器获取结果
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	// 重写selectListVO方法，根据传入的查询条件查询员工值对象列表
+	// @param wrapper 用于构建查询条件的包装器，类型为YuangongEntity的包装器
+	// @return 包含员工值对象的List集合
+	@Override
 	public List<YuangongVO> selectListVO(Wrapper<YuangongEntity> wrapper) {
- 		return baseMapper.selectListVO(wrapper);
+		// 调用数据访问对象的selectListVO方法，传入查询条件包装器，获取员工值对象列表
+		return baseMapper.selectListVO(wrapper);
 	}
-	
+
+	// 重写selectVO方法，根据传入的查询条件查询单个员工值对象
+	// @param wrapper 用于构建查询条件的包装器，类型为YuangongEntity的包装器
+	// @return 单个员工值对象
 	@Override
 	public YuangongVO selectVO(Wrapper<YuangongEntity> wrapper) {
- 		return baseMapper.selectVO(wrapper);
+		// 调用数据访问对象的selectVO方法，传入查询条件包装器，获取单个员工值对象
+		return baseMapper.selectVO(wrapper);
 	}
-	
+
+	// 重写selectListView方法，根据传入的查询条件查询员工视图列表
+	// @param wrapper 用于构建查询条件的包装器，类型为YuangongEntity的包装器
+	// @return 包含员工视图的List集合
 	@Override
 	public List<YuangongView> selectListView(Wrapper<YuangongEntity> wrapper) {
+		// 调用数据访问对象的selectListView方法，传入查询条件包装器，获取员工视图列表
 		return baseMapper.selectListView(wrapper);
 	}
 
+	// 重写selectView方法，根据传入的查询条件查询单个员工视图
+	// @param wrapper 用于构建查询条件的包装器，类型为YuangongEntity的包装器
+	// @return 单个员工视图
 	@Override
 	public YuangongView selectView(Wrapper<YuangongEntity> wrapper) {
+		// 调用数据访问对象的selectView方法，传入查询条件包装器，获取单个员工视图
 		return baseMapper.selectView(wrapper);
 	}
-
-
-}
+}