一：我對代碼注釋的觀點

博主個人寫代碼是肯定會寫注釋的，哪怕是簡單的功能，文檔注釋、多行注釋、單行注釋怎么順手怎么用，讓一個小白也能看懂自己的代碼。

二：我認為程序員不寫注釋的原因

博主認為程序員不寫注釋的原因無外乎以下幾點：

1、太懶了，就是單純不想寫

2、平時沒有養(yǎng)成寫代碼注釋的習慣

3、作為一個程序員，卻沒有程序員的基本素養(yǎng)（為什么和第1點分開寫呢，懂的都懂）

三：如何才能寫出漂亮的注釋

1、在類和方法上，使用文檔注釋

2、在方法內部，可以使用多行注釋+單行注釋的組合讓注釋有條有理

3、漂亮的注釋要配合適當的代碼縮進才能達到更好的效果，如果所有代碼之前都沒有空格和換行，那么你的代碼整體會非常亂，哪怕寫了注釋也一樣。注釋和代碼會混合在一起，可讀性非常差。

4、和代碼編寫不同的是，代碼注釋本身并沒有統一的規(guī)范，所以，其實完全可以根據自己的喜好來寫，甚至可以在service層的impl實現類的方法上面加上整個業(yè)務的核心步驟并編號，然后在代碼中也復寫一次，類似于書的目錄。

說了那么多，不如show me your code!

下面貼出的兩個類，基本上就是我的代碼注釋風格了文章來源地址http://www.zghlxwxcb.cn/news/detail-726596.html

package cn.edu.sgu.www.mhxysy.service.chongwu.impl;

import cn.edu.sgu.www.mhxysy.base.Pager;
import cn.edu.sgu.www.mhxysy.consts.IdentifierPrefixConst;
import cn.edu.sgu.www.mhxysy.dto.chongwu.ChongwuDTO;
import cn.edu.sgu.www.mhxysy.dto.chongwu.ChongwuTongyuDTO;
import cn.edu.sgu.www.mhxysy.entity.chongwu.Chongwu;
import cn.edu.sgu.www.mhxysy.entity.chongwu.ChongwuAttribute;
import cn.edu.sgu.www.mhxysy.entity.chongwu.ChongwuJiadian;
import cn.edu.sgu.www.mhxysy.entity.chongwu.ChongwuZizhi;
import cn.edu.sgu.www.mhxysy.enums.JiadianSchemas;
import cn.edu.sgu.www.mhxysy.enums.TongyuState;
import cn.edu.sgu.www.mhxysy.exception.GlobalException;
import cn.edu.sgu.www.mhxysy.mapper.chongwu.*;
import cn.edu.sgu.www.mhxysy.pager.chongwu.ChongwuPager;
import cn.edu.sgu.www.mhxysy.restful.JsonPage;
import cn.edu.sgu.www.mhxysy.restful.JsonResult;
import cn.edu.sgu.www.mhxysy.restful.ResponseCode;
import cn.edu.sgu.www.mhxysy.service.chongwu.ChongwuService;
import cn.edu.sgu.www.mhxysy.util.StringUtils;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author heyunlin
 * @version 1.0
 */
@Service
public class ChongwuServiceImpl implements ChongwuService {

	private final ChongwuAttributeMapper chongwuAttributeMapper;
	private final ChongwuJiadianMapper chongwuJiadianMapper;
	private final ChongwuSkillMapper chongwuSkillMapper;
	private final ChongwuZizhiMapper chongwuZizhiMapper;
	private final ChongwuMapper chongwuMapper;

	@Autowired
	public ChongwuServiceImpl(
			ChongwuAttributeMapper chongwuAttributeMapper,
			ChongwuJiadianMapper chongwuJiadianMapper,
			ChongwuSkillMapper chongwuSkillMapper,
			ChongwuZizhiMapper chongwuZizhiMapper,
			ChongwuMapper chongwuMapper) {
		this.chongwuAttributeMapper = chongwuAttributeMapper;
		this.chongwuJiadianMapper = chongwuJiadianMapper;
		this.chongwuSkillMapper = chongwuSkillMapper;
		this.chongwuZizhiMapper = chongwuZizhiMapper;
		this.chongwuMapper = chongwuMapper;
	}

	@Override
	public void insert(ChongwuDTO chongwuDTO) {
		// 1、添加寵物屬性
		int dkfy = (chongwuDTO.getGrade() - 10) * 20; // 抵抗封印
		ChongwuAttribute attribute = new ChongwuAttribute();

		attribute.setId(IdentifierPrefixConst.PREFIX_CHONGWU_SHUXING + StringUtils.uuid());
		attribute.setDkfy((dkfy > 0)? dkfy: 1);
		
		chongwuAttributeMapper.insert(attribute);
		
		// 2、添加寵物資質、成長信息
		ChongwuZizhi zizhi = new ChongwuZizhi();
		
		zizhi.setId(IdentifierPrefixConst.PREFIX_CHONGWU_ZIZHI + StringUtils.uuid());
		
		chongwuZizhiMapper.insert(zizhi);
		
		// 3、添加寵物
		Chongwu chongwu = new Chongwu();

		chongwu.setZizhiId(null);
		chongwu.setZizhiId(zizhi.getId());
		chongwu.setAttributeId(attribute.getId());
		chongwu.setTyStatus(TongyuState.WTY.getValue());
		chongwu.setId(IdentifierPrefixConst.PREFIX_CHONGWU + StringUtils.uuid());
		// copy value from ChongwuDTO
		chongwu.setName(chongwuDTO.getName());
		chongwu.setType(chongwuDTO.getType());
		chongwu.setScore(chongwuDTO.getScore());
		chongwu.setGrade(chongwuDTO.getGrade());
		chongwu.setRoleId(chongwuDTO.getRoleId());
		chongwu.setLifespan(chongwuDTO.getLifespan());
		chongwu.setCategoryId(chongwuDTO.getCategoryId());

		chongwuMapper.insert(chongwu);
		
		// 4、添加寵物加點
		ChongwuJiadian chongwuJiadian = new ChongwuJiadian();
		
		chongwuJiadian.setId(IdentifierPrefixConst.PREFIX_CHONGWU_JIADIAN + StringUtils.uuid());
		chongwuJiadian.setJiadianSchema(JiadianSchemas.JDFAY.getValue());
		chongwuJiadian.setAttributeId(attribute.getId());
		chongwuJiadian.setChongwuId(chongwu.getId());
		chongwuJiadian.setUnlockState(1);
		chongwuJiadian.setOpenState(1);

		chongwuJiadianMapper.insert(chongwuJiadian);
	}

	@Override
	public void deleteById(String id) {
		// 通過寵物id查詢寵物技能
		Chongwu chongwu = chongwuMapper.selectById(id);

		// 判斷寵物是否存在，若不存在，拋出異常
		if (chongwu == null) {
			throw new GlobalException(ResponseCode.NOT_FOUND, "刪除失敗，寵物不存在~");
		}

		// 1、通過id刪除寵物屬性
		chongwuAttributeMapper.deleteById(chongwu.getAttributeId());

		// 2、通過id刪除寵物資質
		chongwuZizhiMapper.deleteById(chongwu.getZizhiId());

		// 3、通過寵物id刪除寵物技能
		chongwuSkillMapper.deleteByChongwuId(id);

		// 4、通過id刪除寵物
		chongwuMapper.deleteById(id);
	}

	@Override
	public void updateById(Chongwu chongwu) {
		chongwuMapper.updateById(chongwu);
	}

	@Override
	public List<Chongwu> selectAll() {
		return chongwuMapper.selectList(null);
	}

	@Override
	public Chongwu selectById(String id) {
		return chongwuMapper.selectById(id);
	}

	@Override
	public List<Chongwu> select(Chongwu chongwu) {
		QueryWrapper<Chongwu> wrapper = new QueryWrapper<Chongwu>();

		wrapper.eq(
				chongwu.getCategoryId() != null,
				"category_id", chongwu.getCategoryId()
		);
		wrapper.eq(
				StringUtils.isNotEmpty(chongwu.getRoleId()),
				"role_id", chongwu.getRoleId()
		);
		wrapper.eq(
				StringUtils.isNotEmpty(chongwu.getZuoqiId()),
				"zuoqi_id", chongwu.getZuoqiId()
		);

		return chongwuMapper.selectList(wrapper);
	}

	@Override
	public List<Chongwu> selectByRoleId(String roleId) {
		QueryWrapper<Chongwu> wrapper = new QueryWrapper<>();

		wrapper.eq("role_id", roleId);

		return chongwuMapper.selectList(wrapper);
	}

	@Override
	public List<String> selectImagesByZuoqiId(String zuoqiId) {
		return chongwuMapper.selectImagesByZuoqiId(zuoqiId);
	}

	@Override
	public JsonResult<JsonPage<Chongwu>> selectByPage(ChongwuPager pager) {
		String skillIds = pager.getSkillIds();

		if (StringUtils.isNotEmpty(skillIds)) {
			String[] array = skillIds.split("-");
			// 得到order by語句
			String statement = Pager.getStatement(pager);

			List<Chongwu> list = chongwuMapper.selectBySkills(pager, array, array.length, statement);
			long total = chongwuMapper.selectCountBySkills(pager, array, array.length);

			return JsonResult.restPage(total, list);
		} else {
			Page<Chongwu> page = new Page<>(pager.getPage(), pager.getRows());
			QueryWrapper<Chongwu> wrapper = new QueryWrapper<>();

			wrapper.eq(
					pager.getCategoryId() != null,
					"category_id", pager.getCategoryId()
			);
			wrapper.eq(
					StringUtils.isNotEmpty(pager.getRoleId()),
					"role_id", pager.getRoleId()
			);
			wrapper.eq(
					StringUtils.isNotEmpty(pager.getZuoqiId()),
					"zuoqi_id", pager.getZuoqiId()
			);
//			wrapper.orderByAsc("role_id");

			// 得到order by語句
			String statement = Pager.getOrderByStatement(pager);
			wrapper.last(statement);

			Page<Chongwu> result = chongwuMapper.selectPage(page, wrapper);
			return JsonResult.restPage(result);
		}
	}

	@Override
	public void tongyu(Chongwu chongwu) {
		chongwu.setTyStatus(1 - chongwu.getTyStatus());

		// 【統御】操作
		if (chongwu.getTyStatus() == 1) {
			QueryWrapper<Chongwu> wrapper = new QueryWrapper<Chongwu>();

			wrapper.eq(
					StringUtils.isNotEmpty(chongwu.getRoleId()),
					"role_id", chongwu.getRoleId()
			);
			wrapper.eq(
					StringUtils.isNotEmpty(chongwu.getZuoqiId()),
					"zuoqi_id", chongwu.getZuoqiId()
			);
			wrapper.eq("ty_status", TongyuState.YTY.getValue());

			// 獲取坐騎統御的寵物總數
			long count =  chongwuMapper.selectCount(wrapper);

			// 已經統御兩只寵物，終止操作，拋出異常
			if (count >= 2) {
				throw new GlobalException(ResponseCode.BAD_REQUEST, "最多可以統御兩只寵物！");
			}

			chongwuMapper.updateById(chongwu);
		} else { // [取消統御]操作
			// 修改寵物的坐騎id為null，并設置統御狀態(tài)為：0-未統御
			UpdateWrapper<Chongwu> wrapper = new UpdateWrapper<>();

			wrapper.eq("id", chongwu.getId());
			wrapper.set("zuoqi_id", null);
			wrapper.set("ty_status", TongyuState.WTY.getValue());

			chongwuMapper.update(wrapper.getEntity(), wrapper);
		}
	}

	@Override
	public void change(ChongwuTongyuDTO tongyuDTO) {
		// 判斷寵物的統御狀態(tài)，若為未統御，拋出異常
		if (TongyuState.WTY.getValue().equals(tongyuDTO.getTyStatus())) {
			throw new GlobalException(ResponseCode.BAD_REQUEST, "寵物狀態(tài)為未統御，更換統御失??！");
		}

		// 修改寵物的統御坐騎id
		Chongwu chongwu = new Chongwu();

		chongwu.setId(tongyuDTO.getId());
		chongwu.setZuoqiId(tongyuDTO.getZuoqiId());

		chongwuMapper.updateById(chongwu);
	}

}

package cn.edu.sgu.www.mhxysy.service.chongwu.impl;

import cn.edu.sgu.www.mhxysy.base.Pager;
import cn.edu.sgu.www.mhxysy.consts.IdentifierPrefixConst;
import cn.edu.sgu.www.mhxysy.dto.chongwu.ChongwuSkillDTO;
import cn.edu.sgu.www.mhxysy.entity.chongwu.Chongwu;
import cn.edu.sgu.www.mhxysy.entity.chongwu.ChongwuSkill;
import cn.edu.sgu.www.mhxysy.entity.chongwu.ChongwuSkillCategory;
import cn.edu.sgu.www.mhxysy.enums.AuthStatus;
import cn.edu.sgu.www.mhxysy.exception.GlobalException;
import cn.edu.sgu.www.mhxysy.mapper.chongwu.ChongwuMapper;
import cn.edu.sgu.www.mhxysy.mapper.chongwu.ChongwuSkillCategoryMapper;
import cn.edu.sgu.www.mhxysy.mapper.chongwu.ChongwuSkillMapper;
import cn.edu.sgu.www.mhxysy.pager.chongwu.ChongwuSkillPager;
import cn.edu.sgu.www.mhxysy.restful.ResponseCode;
import cn.edu.sgu.www.mhxysy.service.chongwu.ChongwuSkillService;
import cn.edu.sgu.www.mhxysy.util.NumberUtils;
import cn.edu.sgu.www.mhxysy.util.StringUtils;
import cn.edu.sgu.www.mhxysy.vo.chongwu.ChongwuSkillVO;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author heyunlin
 * @version 1.0
 */
@Service
public class ChongwuSkillServiceImpl implements ChongwuSkillService {

	private final ChongwuMapper chongwuMapper;
	private final ChongwuSkillMapper chongwuSkillMapper;
	private final ChongwuSkillCategoryMapper chongwuSkillCategoryMapper;

	@Autowired
	public ChongwuSkillServiceImpl(
			ChongwuMapper chongwuMapper,
			ChongwuSkillMapper chongwuSkillMapper,
			ChongwuSkillCategoryMapper chongwuSkillCategoryMapper) {
		this.chongwuMapper = chongwuMapper;
		this.chongwuSkillMapper = chongwuSkillMapper;
		this.chongwuSkillCategoryMapper = chongwuSkillCategoryMapper;
	}

	@Override
	public void insert(ChongwuSkillDTO chongwuSkillDTO) {
		// 得到寵物ID和技能ID
		String chongwuId = chongwuSkillDTO.getChongwuId();
		Integer skillId = chongwuSkillDTO.getSkillId();

		// 驗證寵物技能是否重復
		int location = validate(chongwuId, skillId);

		if (location > 0) {
			// 添加寵物技能
			ChongwuSkill chongwuSkill = new ChongwuSkill();

			chongwuSkill.setSkillId(skillId);
			chongwuSkill.setLocation(location);
			chongwuSkill.setChongwuId(chongwuId);
			chongwuSkill.setAuthStatus(AuthStatus.WRZ.getValue());
			chongwuSkill.setId(IdentifierPrefixConst.PREFIX_CWJN + StringUtils.uuid());

			chongwuSkillMapper.insert(chongwuSkill);
		}
	}

	@Override
	public void updateById(ChongwuSkill chongwuskill) {
		chongwuSkillMapper.updateById(chongwuskill);
	}

	@Override
	public Page<ChongwuSkill> selectByPage(ChongwuSkillPager pager) {
		QueryWrapper<ChongwuSkill> wrapper = new QueryWrapper<>();
		Page<ChongwuSkill> page = Pager.ofPage(pager);

		wrapper.eq(
				StringUtils.isNotEmpty(pager.getChongwuId()),
				"chongwu_id", pager.getChongwuId()
		);
		wrapper.eq(
				pager.getSkillId() != null,
				"skill_id", pager.getSkillId()
		);

		return chongwuSkillMapper.selectPage(page, wrapper);
	}

	@Override
	public List<ChongwuSkillVO> getLearnedSkills(String chongwuId) {
		return chongwuSkillMapper.getLearnedSkills(chongwuId);
	}

	@Override
	public ChongwuSkill getAuthedSkill(String chongwuId) {
		QueryWrapper<ChongwuSkill> wrapper = new QueryWrapper<>();

		wrapper.eq("chongwu_id", chongwuId);
		wrapper.eq("auth_status", AuthStatus.YRZ.getValue());

		return chongwuSkillMapper.selectOne(wrapper);
	}

	@Override
	public List<ChongwuSkill> getCanAuthedSkills(String chongwuId) {
		return chongwuSkillMapper.getCanAuthedSkills(chongwuId);
	}

	/**
	 * 學習技能
	 * @param chongwuSkillDTO 寵物技能信息
	 * @return String 學習的新技能名稱
	 */
	@Override
	public String study(ChongwuSkillDTO chongwuSkillDTO) {
		Integer skillId = chongwuSkillDTO.getSkillId();
		String chongwuId = chongwuSkillDTO.getChongwuId();

		/*
		 * 1、判斷是否寵物已學習的技能
		 */
		int location = validate(chongwuId, skillId);

		/*
		 * 2、進入寵物學習技能流程
		 */
		// 查詢寵物技能
		List<ChongwuSkill> chongwuSkills = selectByChongwuId(chongwuId);
		// 刪除已認證的技能（1號位 && 認證狀態(tài)為：1-已認證）
		chongwuSkills.removeIf(chongwuSkill -> chongwuSkill.getAuthStatus() == 1 && chongwuSkill.getLocation() == 1);

		// 學習之前的技能名稱
		String name = null;

		/*
			新增技能
			1、寵物尚未學習技能
			2、寵物已學習技能數 < 3
			3、只有一個已認證的技能（理論上不存在這種可能，因為認證會生成一個新技能）
		*/
		if (chongwuSkills.isEmpty() || location <= 3) {
			ChongwuSkill chongwuSkill = new ChongwuSkill();

			chongwuSkill.setSkillId(skillId);
			chongwuSkill.setLocation(location);
			chongwuSkill.setChongwuId(chongwuId);
			chongwuSkill.setAuthStatus(AuthStatus.WRZ.getValue());
			chongwuSkill.setId(IdentifierPrefixConst.PREFIX_CWJN + StringUtils.uuid());

			chongwuSkillMapper.insert(chongwuSkill);
		} else {
			/*
				替換技能：隨機替換寵物學習的一個技能
			*/
			// 生成隨機下標
			int index = NumberUtils.random(0, chongwuSkills.size() - 1);
			// 得到指定下標的元素
			ChongwuSkill chongwuSkill = chongwuSkills.get(index);
			// 查詢學習之前當前位置的的技能名稱
			name = chongwuSkillCategoryMapper.selectById(chongwuSkill.getSkillId()).getName();

			// 修改寵物技能信息
			chongwuSkill.setSkillId(skillId);
			chongwuSkillMapper.updateById(chongwuSkill);
		}

		// 返回學習之前的技能名稱
		return name;
	}

	/**
	 * 法術認證
	 * 1、判斷技能是否存在：不存在則認證失敗，拋出異常
	 * 2、判斷技能是否可認證：不可認證則認證失敗，拋出異常
	 * 3、判斷技能的認證狀態(tài)：已認證則認證失敗，拋出異常
	 * 4、判斷寵物是否已有認證的技能，每只寵物只能認證一個技能：若有，則認證失敗，拋出異常
	 * 5、判斷認證后寵物學習的技能數量是否大于13：大于13則認證失敗，拋出異常
	 * 6、在其前面的技能整體后移1位
	 * 7、修改認證的技能位置及認證狀態(tài)為1
	 * 8、為寵物隨機添加一個未學習的低級技能
	 */
	@Override
	public void authenticate(ChongwuSkill chongwuSkill) {
		/*
		 * 1、判斷技能是否存在：不存在則認證失敗，拋出異常
		 */
		Integer location = chongwuSkill.getLocation();
		String chongwuId = chongwuSkill.getChongwuId();

		// 獲取寵物指定位置的技能信息
		QueryWrapper<ChongwuSkill> wrapper = new QueryWrapper<>();
		wrapper.eq("chongwu_id", chongwuId);
		wrapper.eq("location", location);
		List<ChongwuSkill> list = chongwuSkillMapper.selectList(wrapper);

		// 查詢結果大于1，數據異常
		int count = list.size();
		ChongwuSkill dbResult;

		if (count == 0){
			throw new GlobalException(ResponseCode.NOT_FOUND, "技能不存在，認證失敗");
		} else if (count > 1) {
			String msg = "數據錯誤，查詢到寵物" + chongwuId + "在" + location + "號位的技能超過1個，請聯系管理員處理";

			throw new GlobalException(ResponseCode.BAD_REQUEST, msg);
		} else {
			dbResult = list.get(0);
		}
		/*
		 * 2、判斷技能是否可認證，不可認證則認證失敗，拋出異常
		 */
		ChongwuSkillCategory category = chongwuSkillCategoryMapper.selectById(dbResult.getSkillId());
		String name = category.getName();

		// 技能無法認證
		if (category.getCanAuthed() == 0) {
			throw new GlobalException(ResponseCode.FORBIDDEN,
					"技能<span class='blue'>" + name + "</span>無法認證，選擇其他技能試試吧o_o");
		}

		/*
		 * 3、判斷技能的認證狀態(tài)，已認證則認證失敗，拋出異常
		 */
		// 技能已認證
		if (AuthStatus.YRZ.getValue().equals(dbResult.getAuthStatus())) {
			throw new GlobalException(ResponseCode.FORBIDDEN,
					"技能<span style='color:blue;'>" + name + "</span>已經認證，少俠不要戲弄我了");
		}

		/*
		 * 4、判斷寵物是否已有認證的技能，每只寵物只能認證一個技能：若有，則認證失敗，拋出異常
		 */
		// 查詢寵物已認證的技能
		wrapper = new QueryWrapper<>();

		wrapper.eq("chongwu_id", chongwuId);
		wrapper.eq("auth_status", AuthStatus.YRZ.getValue());

		long size = chongwuSkillMapper.selectCount(wrapper);

		if (size > 0) {
			throw new GlobalException(ResponseCode.CONFLICT, "已經有一個已認證的技能了");
		}

		/*
		 * 5、判斷認證后寵物學習的技能數量是否大于13：大于13則認證失敗，拋出異常
		 */
		// 查詢寵物學習的技能總數
		int total = chongwuSkillMapper.selectCountByChongwuId(chongwuId);

		// 判斷count + 1 > 13
		if (total > 12) {
			throw new GlobalException(ResponseCode.BAD_REQUEST, "寵物技能數量已達上限");
		}

		/*
		 * 6、在其前面的技能整體后移1位
		 */
		// 如果位置大于1，則其前面還有技能，修改其前面的技能位置+1
		if (location > 1) {
			chongwuSkillMapper.increaseLocations(chongwuId, location);
		}

		/*
		 * 7、修改認證的技能位置及認證狀態(tài)為1
		 */
		UpdateWrapper<ChongwuSkill> updateWrapper = new UpdateWrapper<>();

		updateWrapper.eq("id", dbResult.getId());
		updateWrapper.set("location", 1);
		updateWrapper.set("auth_status", AuthStatus.YRZ.getValue());

		chongwuSkillMapper.update(updateWrapper.getEntity(), updateWrapper);

		/*
		 * 8、為寵物隨機添加一個寵物未學習的低級技能
		 */
		// 查詢寵物已學習的技能的ID
		List<Integer> skillIds = chongwuSkillMapper.selectLearnedSkillIds(chongwuId);

		// 查詢寵物未學習的低級技能
		QueryWrapper<ChongwuSkillCategory> queryWrapper = new QueryWrapper<>();

		queryWrapper.notIn("id", skillIds);
		queryWrapper.eq("type", 0);
		queryWrapper.eq("can_authed", 0);

		List<ChongwuSkillCategory> categories = chongwuSkillCategoryMapper.selectList(queryWrapper);

		// 得到隨機下標
		int index = NumberUtils.random(0, categories.size() - 1);

		// 添加一個新的寵物技能
		ChongwuSkill skill = new ChongwuSkill();

		skill.setLocation(total + 1);
		skill.setChongwuId(chongwuId);
		skill.setAuthStatus(AuthStatus.WRZ.getValue());
		skill.setSkillId(categories.get(index).getId());
		skill.setId(IdentifierPrefixConst.PREFIX_CWJN + StringUtils.uuid());

		chongwuSkillMapper.insert(skill);
	}

	/**
	 * 取消法術認證
	 * 1、查詢寵物已認證的技能：若查詢結果為空，則拋出異常
	 * 2、刪除已認證的技能
	 * 3、其他技能的位置向前推進1格
	 * @param chongwuId 寵物id
	 * @return String
	 */
	@Override
	public String cancelAuth(String chongwuId) {
		/*
		 * 1、查詢寵物已認證的技能：若查詢結果為空，則拋出異常
		 */
		ChongwuSkill chongwuSkill = beforAuth(chongwuId);

		/*
		 * 2、刪除已認證的技能
		 */
		chongwuSkillMapper.deleteById(chongwuSkill.getId());

		/*
		 * 3、其他技能的位置向前推進1格
		 */
		chongwuSkillMapper.decreaseLocations(chongwuId);


		// 返回寵物名稱和等級拼接的字符串
		Chongwu chongwu = chongwuMapper.selectById(chongwuId);

		return chongwu.getName() + "(" + chongwu.getGrade() + "級)";
	}

	/**
	 * 認證替換
	 * 1、查詢寵物已認證的技能：若查詢結果為空，拋出異常
	 * 2、修改已認證技能的寵物技能類型id
	 * @param chongwuSkillDTO 認證信息
	 */
	@Override
	public void replaceAuth(ChongwuSkillDTO chongwuSkillDTO) {
		/*
		 * 1、查詢寵物已認證的技能：若查詢結果為空，則拋出異常
		 */
		ChongwuSkill chongwuSkill = beforAuth(chongwuSkillDTO.getChongwuId());

		/*
		 * 2、修改已認證技能的寵物技能類型id
		 */
		UpdateWrapper<ChongwuSkill> updateWrapper = new UpdateWrapper<>();
		updateWrapper.set("skill_id", chongwuSkillDTO.getSkillId());
		updateWrapper.eq("id", chongwuSkill.getId());

		chongwuSkillMapper.update(updateWrapper.getEntity(), updateWrapper);
	}

	@Override
	public boolean hasAuthedSkills(String chongwuId) {
		QueryWrapper<ChongwuSkill> wrapper = new QueryWrapper<>();

		wrapper.eq("chongwu_id", chongwuId);
		wrapper.eq("auth_status", AuthStatus.YRZ.getValue());

		return chongwuSkillMapper.exists(wrapper);
	}

	/**
	 * 驗證寵物技能上限及是否重復
	 * @param chongwuId 寵物ID
	 * @param skillId 技能ID
	 * @return int 寵物技能的下一個位置
	 */
	private int validate(String chongwuId, Integer skillId) {
		// 通過寵物ID查詢寵物技能
		List<ChongwuSkill> chongwuSkills = selectByChongwuId(chongwuId);

		// 寵物技能不為空
		if (!chongwuSkills.isEmpty()) {
			// 檢查寵物已學習的技能數量
			if (chongwuSkills.size() > 12) {
				throw new GlobalException(ResponseCode.BAD_REQUEST, "該寵物的技能數量已經上限！");
			}

			// 判斷技能是否重復，當前的技能ID是否在技能列表
			for (ChongwuSkill chongwuSkill : chongwuSkills) {
				if (skillId.equals(chongwuSkill.getSkillId())) {
					throw new GlobalException(ResponseCode.BAD_REQUEST, "已經學習了相同的技能，別浪費了~");
				}
			}
		}

		return chongwuSkills.size() + 1;
	}

	/**
	 * 通過寵物id查詢寵物技能
	 * @param chongwuId 寵物id
	 * @return List<ChongwuSkill>
	 */
	private List<ChongwuSkill> selectByChongwuId(String chongwuId) {
		QueryWrapper<ChongwuSkill> wrapper = new QueryWrapper<>();

		wrapper.eq("chongwu_id", chongwuId);

		return chongwuSkillMapper.selectList(wrapper);
	}

	/**
	 * 認證/取消認證前的檢查
	 * @param chongwuId 寵物id
	 */
	private ChongwuSkill beforAuth(String chongwuId) {
		// 查詢寵物已認證的技能
		QueryWrapper<ChongwuSkill> wrapper = new QueryWrapper<>();
		wrapper.eq("chongwu_id", chongwuId);
		wrapper.eq("auth_status", AuthStatus.YRZ.getValue());
		List<ChongwuSkill> chongwuSkills = chongwuSkillMapper.selectList(wrapper);

		// 查詢結果數
		int count = chongwuSkills.size();

		if (count == 0) { // 查詢結果為空
			throw new GlobalException(ResponseCode.NOT_FOUND, "當前寵物沒有已認證的技能");
		} else if (count > 1) { // 查詢結果數大于1
			throw new GlobalException(ResponseCode.CONFLICT, "數據異常，寵物已認證的技能數大于1");
		} else {
			return chongwuSkills.get(0);
		}
	}

}

到了這里，關于關于程序員不寫代碼注釋這一件事的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網！