基于javaweb+mysql的springboot人才求职招聘管理系统(java+springboot+freemarker+jpa+mysql)

最新推荐文章于 2025-05-31 16:51:52 发布
最新推荐文章于 2025-05-31 16:51:52 发布
阅读量120 收藏
点赞数
文章标签： mysql 汽车 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_71481126/article/details/132260200
版权

基于javaweb+mysql的springboot人才求职招聘管理系统(java+springboot+freemarker+jpa+mysql)

运行环境

Java≥8、MySQL≥5.7

开发工具

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

适用

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

功能说明

基于javaweb+mysql的SpringBoot人才求职招聘管理系统(java+springboot+freemarker+jpa+mysql)

项目介绍

基于SpringBoot框架开发的求职招聘管理系统。 本项目分三种角色：管理员、招聘人员、求职者。 用户可以以两种身份注册登录，一种是求职者，另一种是招聘者。 求职者可以浏览查询公司信息、职位信息，并且可以填写自己的简历，然后给自己心仪的职位投递简历。招聘者可以填写自己公司的信息，然后进行认证申请， 申请通过后，就可以进行发布职位，接收求职者投递来简历，并且进行审核和通知。 除此之外，该项目还附带后台管理功能，管理员可以登录后台管系统，进行职位类别添加、管理用户信息、通过审核来更改公司、职位的状态等。 项目功能：注册（引入邮箱验证码功能）、登录、修改密码、按条件查询、填写我的简历、填写公司信息、投递简历、发布职位、接收简历等等功能。

环境需要

1.运行环境：最好是java jdk 1.8，我们在这个平台上运行的。其他版本理论上也可以。 2.IDE环境：IDEA，Eclipse,Myeclipse都可以。推荐IDEA; 3.硬件环境：windows 7/8/10 1G内存以上；或者 Mac OS； 4.数据库：MySql 5.7版本； 5.是否Maven项目：是；

技术栈

SpringBoot + FreeMarker + JPA

使用说明

  1. 使用Navicat或者其它工具，在mysql中创建对应名称的数据库，并导入项目的sql文件； 2. 使用IDEA/Eclipse/MyEclipse导入项目，导入成功后请执行maven clean;maven install命令，然后运行； 3. 将项目中application-dev.properties配置文件中的数据库配置改为自己的配置; 4. 运行项目，项目运行成功后，在浏览器中输入网址： http://localhost:8082/home/index/index 访问的是网站首页面 http://localhost:8082/admin/system/login 访问的是后台管理页面
	 * 保存公司产品
	 * @param company
	 * @param request
	 * @return
	 */
	@RequestMapping(value="/save_company_product",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> saveCompanyProduct(Company company,HttpServletRequest request)
	{
		if(company == null){
			return Result.error(CodeMsg.DATA_ERROR);
		}
		//检测公司产品标题长度
		if(company.getProductTitle().length() > 11) {
			return Result.error(CodeMsg.COMPANY_PRODUCT_NAME_WORD_OVER);
		}
		User session_user = (User) request.getSession().getAttribute(SessionConstant.SESSION_USER_LOGIN_KEY);
		Company findCompany = companyService.findByUserId(session_user.getId());
		if(findCompany == null) {
			//先让用户填写名称和价值观基本信息
			return Result.error(CodeMsg.COMPANY_NAME_AND_VALUE_PRIORITY);
		}else {
			//进行修改操作
			if("".equals(company.getProductTitle())) {
				company.setProductTitle(null);
			}
			if("".equals(company.getProductContent())) {
				company.setProductContent(null);
			}
			company.setState("待审核");
			BeanUtils.copyProperties(company, findCompany, "id","createTime","updateTime","tags","user","name","value","photo","introduction","locale","territory","scale","url","finance","founderName","founderPosition","founderPhoto");
			if(companyService.save(findCompany) == null){
				return Result.error(CodeMsg.COMPANY_PRODUCT_SAVE_ERROR);
			}
		}
		return Result.success(true);
	}
	
	/**
	 * 保存公司介绍
	 * @param company
	 * @param request
	 * @return
	 */
	@RequestMapping(value="/save_company_introduction",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> saveCompanyIntroduction(Company company,HttpServletRequest request)
	{
		if(company == null){
			return Result.error(CodeMsg.DATA_ERROR);
		}
		User session_user = (User) request.getSession().getAttribute(SessionConstant.SESSION_USER_LOGIN_KEY);

            return Result.success(true);
        }

        return Result.success(true);
    }
}

/**
 * 职位类别控制类
 *
 */
@RequestMapping("/admin/position_category")
@Controller
public class PositionCategoryController {

	@Autowired 
	private PositionCategoryService positionCategoryService;

			Position findById = positionService.findById(id);
			Resume resume = new Resume();
			resume.setPosition(findById);
			Resume findByPositionIdAndUserId = resumeService.findByPositionIdAndUserId(user.getId(), findById.getId());
			if(findByPositionIdAndUserId != null) {
				return Result.error(CodeMsg.RESUME_ALREADY_SUBMIT);
			}else {
				resume.setUser(user);
				resume.setCompany(findById.getCompany());
				resume.setState("wait");
				resumeService.save(resume);
				findById.setNumber(findById.getNumber()+1);
				positionService.save(findById);
			}
		}else {
			return Result.error(CodeMsg.RESUME_WRITE_NOT_COMPLETE);
		}
		return Result.success(true);
	}
	
	/**
	 * 保存期望工作信息
	 * @param expectWork
	 * @param request
	 * @return
	 */
	@RequestMapping(value="/save_expect_work",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> saveExpectWorkForm(ExpectWork expectWork,HttpServletRequest request)
	{
		if(expectWork == null){
			return Result.error(CodeMsg.DATA_ERROR);
		}
		User session_user = (User) request.getSession().getAttribute("user");
		expectWork.setUser(session_user);
		//检查有没有添加过期望工作
		ExpectWork findExpectWork = expectWorkService.findExpectWorkByUserId(session_user.getId());
		if(findExpectWork != null){
			//进行修改操作
			BeanUtils.copyProperties(expectWork, findExpectWork, "id","createTime","updateTime");


	@Autowired
	private CompanyService companyService;
	
	@Autowired
	private PositionService positionService;
	
	/**
	 * 公司详情页面
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/detail",method=RequestMethod.GET)
	public String companyDetail(Model model,@RequestParam(name="id",required=true)Long id){
		Company findCompany = companyService.find(id);
		model.addAttribute("Company", findCompany);
		return "home/company/detail";
	}
	
	
	
	/**
	 * 我的公司页面
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/my_company",method=RequestMethod.GET)
	public String myCompany(Model model,HttpServletRequest request){
		User session_user = (User) request.getSession().getAttribute(SessionConstant.SESSION_USER_LOGIN_KEY);
		Company company = companyService.findByUserId(session_user.getId());
		model.addAttribute("Company", company);
		if(company != null && company.getTags() != null){
			model.addAttribute("Tags", company.getTags().split(","));
		}
		if(company != null && company.getId() != null) {
			model.addAttribute("PositionList", positionService.findPositionByCompanyIdAndState(company.getId(), "effective"));
		}
		
		return "home/company/my_company";
	}
	
	
	/**
	 * 申请公司认证
	 * @param id
	 * @return
	 */
	@RequestMapping(value="/apply_confirm",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> applyConfirm(@RequestParam(name="id",required=true)Long id)

	
	/**
	 * 后台公司管理信息页面
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/list",method=RequestMethod.GET)
	public String list(Model model){
		return "admin/company/list";
	}
	

	/**
	 * 获取后台公司信息列表
	 * @param request
	 * @param page
	 * @return
	 */
	@RequestMapping(value="/list",method=RequestMethod.POST)
	@ResponseBody
	public  Map<String, Object> list(@RequestParam(name="state",required=false,defaultValue="") String state,Page page){
		Map<String, Object> ret = new HashMap<String, Object>();
		if(!StringUtil.isEmpty(state)) {
			//如果state不为空
			List<Company> findCompanyList = companyService.findCompanyList(state, page.getOffset(), page.getRows());
			ret.put("rows", findCompanyList);
			ret.put("total", companyService.getCompanyTotal(state));
		}else {
			//如果state为空
			List<Company> findAllCompanyList = companyService.findAllCompanyList(page.getOffset(), page.getRows());
			ret.put("rows", findAllCompanyList);
			ret.put("total", companyService.total());
		}
		
		return ret; 
	}
	
	/**
	 * 改变公司状态
	 * @param request
	 * @param page
	 * @return
	 */
	@RequestMapping(value="/change_state",method=RequestMethod.POST)
	@ResponseBody
	public  Result<Boolean> changeState(Company company){
		if(company == null) {

	@ResponseBody
	public Result<Boolean> saveWorkExperienceForm(WorkExperience workExperience,HttpServletRequest request)
	{
		if(workExperience == null){
			return Result.error(CodeMsg.DATA_ERROR);
		}
		//检查公司名称是否为空
		if(StringUtil.isEmpty(workExperience.getName())){
			return Result.error(CodeMsg.RESUME_WORK_EXPERIENCE_COMPANY_NAME_EMPTY);
		}
		//检查职位名称是否为空
		if(StringUtil.isEmpty(workExperience.getPosition())) {
			return Result.error(CodeMsg.RESUME_WORK_EXPERIENCE_POSITION_NAME_EMPTY);
		}
		//检查开始时间是否为空
		if(workExperience.getStartYear() == null || workExperience.getStartMonth() == null || "开始年份".equals(workExperience.getStartYear()) || "开始月份".equals(workExperience.getStartMonth())) {
			return Result.error(CodeMsg.RESUME_WORK_EXPERIENCE_START_TIME_EMPTY);
		}
		//检查结束时间是否为空
		if(workExperience.getEndYear() == null || workExperience.getEndMonth() == null || "结束年份".equals(workExperience.getEndYear()) || "结束月份".equals(workExperience.getEndMonth())) {
			return Result.error(CodeMsg.RESUME_WORK_EXPERIENCE_END_TIME_EMPTY);
		}
		//检查结束时间是否大于开始时间
		if(Integer.valueOf(workExperience.getStartYear()) > Integer.valueOf(workExperience.getEndYear()) || (workExperience.getStartYear().equals(workExperience.getEndYear()) && Integer.valueOf(workExperience.getStartMonth()) > Integer.valueOf(workExperience.getEndMonth()))) {
			return Result.error(CodeMsg.RESUME_WORK_EXPERIENCE_TIME_NOT_CORRECT);
		}
		User session_user = (User) request.getSession().getAttribute("user");
		workExperience.setUser(session_user);
		//检查有没有添加过工作经历
		WorkExperience findWorkExperience = workExperienceService.findWorkExperienceByUserId(session_user.getId());
		if(findWorkExperience != null){
			//进行修改操作
			BeanUtils.copyProperties(workExperience, findWorkExperience, "id","createTime","updateTime");
			if(workExperienceService.save(findWorkExperience) == null){
				return Result.error(CodeMsg.RESUME_WORK_EXPERIENCE_ERROR);
			}
		}else {
			//进行添加操作
			if(workExperienceService.save(workExperience) == null){
				return Result.error(CodeMsg.RESUME_WORK_EXPERIENCE_ERROR);
			}
		}
		//更新最后一次修改时间
		session_user.setUpdateTime(new Date());
		if(userService.save(session_user) == null){
			return Result.error(CodeMsg.USER_UPDATE_TIME_ERROR);
		}
		//把用户权限更新
		User new_session_user = userService.find(session_user.getId());
		request.getSession().setAttribute(SessionConstant.SESSION_USER_LOGIN_KEY, new_session_user);
		

			if(findByPositionIdAndUserId != null) {
				return Result.error(CodeMsg.RESUME_ALREADY_SUBMIT);
			}else {
				resume.setUser(user);
				resume.setCompany(findById.getCompany());
				resume.setState("wait");
				resumeService.save(resume);
				findById.setNumber(findById.getNumber()+1);
				positionService.save(findById);
			}
		}else {
			return Result.error(CodeMsg.RESUME_WRITE_NOT_COMPLETE);
		}
		return Result.success(true);
	}
	
	/**
	 * 保存期望工作信息
	 * @param expectWork
	 * @param request
	 * @return
	 */
	@RequestMapping(value="/save_expect_work",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> saveExpectWorkForm(ExpectWork expectWork,HttpServletRequest request)
	{
		if(expectWork == null){
			return Result.error(CodeMsg.DATA_ERROR);
		}
		User session_user = (User) request.getSession().getAttribute("user");
		expectWork.setUser(session_user);
		//检查有没有添加过期望工作
		ExpectWork findExpectWork = expectWorkService.findExpectWorkByUserId(session_user.getId());
		if(findExpectWork != null){
			//进行修改操作
			BeanUtils.copyProperties(expectWork, findExpectWork, "id","createTime","updateTime");
			if(expectWorkService.save(findExpectWork) == null){
				return Result.error(CodeMsg.RESUME_EXPECT_WORK_ERROR);
			}
		}else {
			//进行添加操作
			if(expectWorkService.save(expectWork) == null){
				return Result.error(CodeMsg.RESUME_EXPECT_WORK_ERROR);
			}
		}
		//更新最后一次修改时间
		session_user.setUpdateTime(new Date());
		if(userService.save(session_user) == null){
			return Result.error(CodeMsg.USER_UPDATE_TIME_ERROR);
		}
		//把用户权限更新
		User new_session_user = userService.find(session_user.getId());
		request.getSession().setAttribute(SessionConstant.SESSION_USER_LOGIN_KEY, new_session_user);
		return Result.success(true);

            //连接邮件服务器
            transport.connect("smtp.163.com", 25, username, password);
            //设置收件人地址,并发送消息
            transport.sendMessage(message, new Address[]{new InternetAddress(receiver)});
            transport.close();
        } catch (MessagingException e) {
            //e.printStackTrace();
            for (int i = 0; i < 100; i++) {
//假装邮件发送成功
                System.out.println("邮箱验证码为：" + generatorVCode);
            }

            // return Result.error(CodeMsg.USER_EMAIL_SEND_ERROR);
            return Result.success(true);
        }

        return Result.success(true);
    }
}


/**
 * 后端用户管理控制器
 *
 */
@RequestMapping("/admin/user")
@Controller
public class UserController {

	@Autowired
	private UserService userService;
	
	@Autowired
	private ResumeService resumeService;
	
	@Autowired
	private WorkExperienceService workExperienceService;
	
	@Autowired
	private WorkShowService workShowService;
	
	@Autowired 
	private ProjectExperienceService projectExperienceService;
	
	@Autowired
	private ExpectWorkService expectWorkService;
	
	@Autowired
	private EducationBackgroundService educationBackgroundService;
	
	@Autowired 
	private CompanyService companyService;
	
	@Autowired
	private PositionService PositionService;
	
	/**
	 * 后台用户管理信息页面
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/user_info",method=RequestMethod.GET)
	public String myInfo(Model model){
		return "admin/admin/user_info";
	}
	


 */
@RequestMapping("/admin/admin")
@Controller
public class AdminController {

	@Autowired 
	private AdminService adminService; 
	
	@Autowired
	private OperaterLogService  operaterLogService; 
	
	
	
	/**
	 * 后台管理员管理
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/my_info",method=RequestMethod.GET)
	public String myInfo(Model model){
		return "admin/admin/my_info";
	}
	
	/**
	 * 后台管理员信息列表
	 * @param request
	 * @param page
	 * @return
	 */
	@RequestMapping(value="/my_info_list",method=RequestMethod.POST)
	@ResponseBody
	public  Map<String, Object>  myInfoList(HttpServletRequest request,Page page){
		Map<String, Object> ret = new HashMap<String, Object>();
		Admin admin = (Admin) request.getSession().getAttribute(SessionConstant.SESSION_ADMIN_LOGIN_KEY);
		List<Admin> findList = adminService.findAdminList(admin.getId(),page.getOffset(), page.getRows());
		ret.put("rows", findList);
		ret.put("total", 1);
		return ret; 
	}
	
	/**
	 * 管理员信息修改处理
	 * @param admin
	 * @return
	 */
	@RequestMapping(value="/edit",method=RequestMethod.POST)

	/**
	 * 保存期望工作信息
	 * @param expectWork
	 * @param request
	 * @return
	 */
	@RequestMapping(value="/save_expect_work",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> saveExpectWorkForm(ExpectWork expectWork,HttpServletRequest request)
	{
		if(expectWork == null){
			return Result.error(CodeMsg.DATA_ERROR);
		}
		User session_user = (User) request.getSession().getAttribute("user");
		expectWork.setUser(session_user);
		//检查有没有添加过期望工作
		ExpectWork findExpectWork = expectWorkService.findExpectWorkByUserId(session_user.getId());
		if(findExpectWork != null){
			//进行修改操作
			BeanUtils.copyProperties(expectWork, findExpectWork, "id","createTime","updateTime");
			if(expectWorkService.save(findExpectWork) == null){
				return Result.error(CodeMsg.RESUME_EXPECT_WORK_ERROR);
			}
		}else {
			//进行添加操作
			if(expectWorkService.save(expectWork) == null){
				return Result.error(CodeMsg.RESUME_EXPECT_WORK_ERROR);
			}
		}
		//更新最后一次修改时间
		session_user.setUpdateTime(new Date());
		if(userService.save(session_user) == null){
			return Result.error(CodeMsg.USER_UPDATE_TIME_ERROR);
		}
		//把用户权限更新
		User new_session_user = userService.find(session_user.getId());
		request.getSession().setAttribute(SessionConstant.SESSION_USER_LOGIN_KEY, new_session_user);
		return Result.success(true);
	}
	
	/**
	 * 保存工作经历信息
	 * @param workExperience
	 * @param request
	 * @return
	 */

            e.printStackTrace();
        }
    }

    @RequestMapping(value = "/generate_emailCpacha", method = RequestMethod.POST)
    @ResponseBody
    public Result<Boolean> generateEmailCpacha(HttpServletRequest request, String receiver, String type) {
        String generatorVCode = null;
        //判断接收人邮箱地址是否为空
        if (receiver == null || "".equals(receiver)) {
            return Result.error(CodeMsg.USER_EMAIL_EMPTY);
        }
        //判断邮件类别是否为空
        if (type == null || "".equals(type)) {
            return Result.error(CodeMsg.USER_EMAIL_TYPE_EMPTY);
        }
        //定义Properties对象,设置环境信息
        Properties props = System.getProperties();
        //设置邮件服务器的地址
        props.setProperty("mail.smtp.host", "smtp.163.com"); // 指定的smtp服务器
        props.setProperty("mail.smtp.auth", "true");
        props.setProperty("mail.transport.protocol", "smtp");//设置发送邮件使用的协议
        //创建Session对象,session对象表示整个邮件的环境信息
        Session session = Session.getInstance(props);
        //设置输出调试信息
        session.setDebug(true);
        try {
            //Message的实例对象表示一封电子邮件
            MimeMessage message = new MimeMessage(session);
            //设置发件人的地址
            message.setFrom(new InternetAddress(senderAddress));

            //如果邮件类别是用户注册验证
            if ("user_register".equals(type)) {
                //设置主题
                message.setSubject("用户注册邮箱验证");

                //获取邮箱验证码
                CpachaUtil cpachaUtil = new CpachaUtil(4);
                generatorVCode = cpachaUtil.generatorVCode(); //验证码的值
                request.getSession().setAttribute(type, generatorVCode);

	 * @return
	 */
	@RequestMapping(value="/save_project_experience",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> saveProjectExperienceForm(ProjectExperience projectExperience,HttpServletRequest request)
	{
		if(projectExperience == null){
			return Result.error(CodeMsg.DATA_ERROR);
		}
		//检查项目名称是否为空
		if(StringUtil.isEmpty(projectExperience.getName())){
			return Result.error(CodeMsg.RESUME_PROJECT_EXPERIENCE_PROJECT_NAME_EMPTY);
		}
		//检查职位名称是否为空
		if(StringUtil.isEmpty(projectExperience.getPosition())) {
			return Result.error(CodeMsg.RESUME_PROJECT_EXPERIENCE_POSITION_NAME_EMPTY);
		}
		//检查开始时间是否为空
		if(projectExperience.getStartYear() == null || projectExperience.getStartMonth() == null || "开始年份".equals(projectExperience.getStartYear()) || "开始月份".equals(projectExperience.getStartMonth())) {
			return Result.error(CodeMsg.RESUME_PROJECT_EXPERIENCE_START_TIME_EMPTY);
		}
		//检查结束时间是否为空
		if(projectExperience.getEndYear() == null || projectExperience.getEndMonth() == null || "结束年份".equals(projectExperience.getEndYear()) || "结束月份".equals(projectExperience.getEndMonth())) {
			return Result.error(CodeMsg.RESUME_PROJECT_EXPERIENCE_END_TIME_EMPTY);
		}
		//检查结束时间是否大于开始时间
		if(Integer.valueOf(projectExperience.getStartYear()) > Integer.valueOf(projectExperience.getEndYear()) || (projectExperience.getStartYear().equals(projectExperience.getEndYear()) && Integer.valueOf(projectExperience.getStartMonth()) > Integer.valueOf(projectExperience.getEndMonth()))) {
			return Result.error(CodeMsg.RESUME_PROJECT_EXPERIENCE_TIME_NOT_CORRECT);
		}
		User session_user = (User) request.getSession().getAttribute("user");
		projectExperience.setUser(session_user);
		//检查有没有添加过项目经验
		ProjectExperience findProjectExperience = projectExperienceService.findProjectExperienceByUserId(session_user.getId());
		if(findProjectExperience != null){
			//进行修改操作
			BeanUtils.copyProperties(projectExperience, findProjectExperience, "id","createTime","updateTime");
			if(projectExperienceService.save(findProjectExperience) == null){
				return Result.error(CodeMsg.RESUME_PROJECT_EXPERIENCE_ERROR);
			}
		}else {
			//进行添加操作

	public Result<Boolean> savePosition(Position position,HttpServletRequest request)
	{
		if(position == null){
			return Result.error(CodeMsg.DATA_ERROR);
		}
		//统一表单验证
		CodeMsg validate = ValidateEntityUtil.validate(position);
		if(validate.getCode() != CodeMsg.SUCCESS.getCode()){
			return Result.error(validate);
		}
		if(position.getMinMoney() > position.getMaxMoney()) {
			return Result.error(CodeMsg.POSITION_MONEY_NOT_CORRECT);
		}
		User session_user = (User) request.getSession().getAttribute(SessionConstant.SESSION_USER_LOGIN_KEY);
		Company findCompanyByUserId = companyService.findByUserId(session_user.getId());
		position.setCompany(findCompanyByUserId);
		
		CodeMsg url_way_one = new CodeMsg(1,"");  //前往待处理职位页面
		CodeMsg url_way_two = new CodeMsg(2,"");  //前往已下线职位页面
		//接下来进行添加或者更新数据库的操作
		if(position.getId() != null) {
			//编辑
			Position findById = positionService.findById(position.getId());
			if("effective".equals(findById.getState()) || "wait".equals(findById.getState())) {
				position.setState("wait");
			}else if("out".equals(findById.getState())) {
				position.setState("out");
			}
			BeanUtils.copyProperties(position, findById, "id","createTime","updateTime","number");
			if(positionService.save(findById) == null) {
				return Result.error(CodeMsg.POSITION_SAVE_ERROR);
			}
			if("effective".equals(findById.getState()) || "wait".equals(findById.getState())) {
				return Result.error(url_way_one);  //前往待处理职位页面
			}else{
				return Result.error(url_way_two);  //前往已下线职位页面
			}
		}else {
			//添加
			position.setState("wait");
			if(positionService.save(position) == null) {
				return Result.error(CodeMsg.POSITION_SAVE_ERROR);
			}
			return Result.error(url_way_one);  //前往待处理职位页面
		}
	
	}
	
	/**
	 * 删除职位信息
	 * @param id
	 * @param request
	 * @return

			return Result.error(CodeMsg.USER_SAVE_ERROR);
		}
		//更新权限
		request.getSession().setAttribute(SessionConstant.SESSION_USER_LOGIN_KEY, userService.find(session_user.getId()));
		return Result.success(true);
	}
	
	/**
	 * 保存自我描述信息
	 * @param content
	 * @param request
	 * @return
	 */
	@RequestMapping(value="/save_self_description",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> saveSelfDescription(String content,HttpServletRequest request)
	{
		User session_user = (User) request.getSession().getAttribute("user");
		session_user.setContent(content);
		session_user.setUpdateTime(new Date());
		if(userService.save(session_user) == null){
			return Result.error(CodeMsg.USER_SAVE_SELF_DESCRIPTION_ERROR);
		}
		//更新权限
		request.getSession().setAttribute(SessionConstant.SESSION_USER_LOGIN_KEY, userService.find(session_user.getId()));
		return Result.success(true);
	}
	
	
	//检查有没有重复的username
	public boolean checkUsername(User user,Long id)
	{
		User findByUsername = userService.findByUsername(user.getUsername());
		if(findByUsername == null)
			return false;  //没有重复
		if(findByUsername.getId().longValue() == id.longValue())
			return false;  //没有重复
		return true;  //有重复
	}
}


/**
 * 后台管理员登录拦截器
 *
 */
@Component
public class AdminLoginInterceptor implements HandlerInterceptor{

	private Logger log = LoggerFactory.getLogger(AdminLoginInterceptor.class);
	
	@Override
	public boolean  preHandle(HttpServletRequest request, HttpServletResponse response, Object handler){
		String requestURI = request.getRequestURI();  //取得被拦截的链接，比如：requestURI=/admin/system/index
		HttpSession session = request.getSession();
		Object attribute = session.getAttribute(SessionConstant.SESSION_ADMIN_LOGIN_KEY);
		if(attribute == null && requestURI.contains("/admin/")){
			log.info("用户还未登录或者session失效,重定向到登录页面,当前URL=" + requestURI);
			//首先判断是否是ajax请求
			if(StringUtil.isAjax(request)){
				//表示是ajax请求
				try {
					response.setCharacterEncoding("UTF-8");
					//JSON.parseObject，是将Json字符串转化为相应的对象；JSON.toJSONString则是将对象转化为Json字符串。
					response.getWriter().write(JSON.toJSONString(CodeMsg.SESSION_EXPIRED));
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				return false;
			}
			//说明是普通的请求，可直接重定向到登录页面


/**
 * 公用的上传类
 *
 */
@RequestMapping("/upload")
@Controller
public class UploadController {

	@Value("${yjq.upload.photo.sufix}")
	private String uploadPhotoSufix;
	
	@Value("${yjq.upload.photo.maxsize}")
	private long uploadPhotoMaxSize;   //大小1024KB
	
	private String uploadPhotoPath=System.getProperty("user.dir") + "/src/main/resources/upload/";
	
	private Logger log = LoggerFactory.getLogger(UploadController.class);
	
	/**
	 * 图片统一上传类
	 * @param photo
	 * @return
	 */
	@RequestMapping(value="/upload_photo",method=RequestMethod.POST)
	@ResponseBody
	public Result<String> uploadPhoto(@RequestParam(name="photo",required=true)MultipartFile photo){
		//判断文件类型是否是图片
		String originalFilename = photo.getOriginalFilename();
		//获取文件后缀
		String suffix = originalFilename.substring(originalFilename.lastIndexOf("."),originalFilename.length());
		if(!uploadPhotoSufix.contains(suffix.toLowerCase())){
			return Result.error(CodeMsg.UPLOAD_PHOTO_SUFFIX_ERROR);
		}
		//photo.getSize()单位是B

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

m0_71481126
关注
大语言模型LLM的发展历程与应用前景
AI天才研究院
03-16 766
本研究的目的在于全面梳理大语言模型（LLM）的发展历程，深入剖析其核心技术原理，并对其未来的应用前景进行展望。通过对大语言模型从诞生到发展至今的关键节点、技术突破进行详细分析，让读者清晰了解其发展脉络。同时，探讨大语言模型在不同领域的应用现状和潜在应用场景，为科研人员、开发者以及企业决策者提供有价值的参考。研究范围涵盖大语言模型的技术发展、算法原理、应用领域等多个方面，从基础理论到实际应用进行全方位的探讨。本文共分为十个部分。第一部分是背景介绍，包括研究的目的和范围、预期读者、文档结构概述以及术语表。
大语言模型(LLM)入门学习路线图
weixin_36751401的博客
02-28 2万+
Github项目上有一个，它涵盖了大语言模型基础学习，LLM前沿算法和架构学习，以及如何将大语言模型进行工程化，是一个很好的帮助初学者入门大语言模型的路线图。
【大语言模型LLM】-大语言模型如何编写Prompt?
我的数据分析师之路
04-18 4610
在实际的工作流中，我们往往要处理大量的评论文本，下面的示例将多条用户评价集合在一个列表中，并利用 for 循环和文本概括（Summarize）提示词，将评价概括至小于 20 个词以下，并按顺序打印。虽然我们通过添加关键角度侧重的 Prompt ，确实让文本摘要更侧重于某一特定方面，然而，我们可以发现，在结果中也会保留一些其他信息，比如偏重价格与质量角度的概括中仍保留了“快递提前到货”的信息。在这个例子中，学生的答案是错误的，但如果我们没有先让模型自己计算，那么可能会被误导以为学生是正确的。
【大模型入门】LLM-AI大模型介绍
2301_81940605的博客
07-16 980
大语言模型 (Large Language Model) 是一种人工智能模型, 它们通常包含数千亿甚至更多的参数，并在大规模数据集上进行训练。大语言模型可以处理多种自然语言任务，如文本分类、问答、翻译、对话等等。
大语言模型(LLM)入门 - (2) 模型构建
三月桃城的博客
05-31 441
TiaoYu-1是一个面向初学者的开源大语言模型(LLM)自学项目，其核心特点是代码完全包含中文注释，便于理解。项目全面覆盖LLM训练全流程，包括预训练、监督微调(SFT)、人类反馈强化学习(ELHF)、LoRA微调、推理训练和知识蒸馏等环节，并配有详细的原理文档。该项目采用模块化学习路径，推荐从基础概念文档入手，逐步深入到模型构建、参数设置、关键组件实现等代码层面，最后完成全流程训练实践。项目还包含多个可选进阶内容，如模型评价指标、梯度问题处理等专题文档，适合不同学习阶段的开发者系统掌握LLM技术。Git
大语言模型(LLM)入门 - (8) 线性层
三月桃城的博客
05-31 788
TiaoYu-1是一个面向初学者的开源大语言模型项目，特点是每行代码都有中文注释，便于理解。项目覆盖了完整的LLM开发流程，包括预训练、监督微调、强化学习、LoRA微调等核心环节，并配套详细原理文档。其结构化学习路径从基础概念到具体实现层层递进，包含模型结构、注意力机制、训练优化等关键环节的文档和代码解析。项目还提供多项可选内容，如评价指标、算法解析等扩展知识，非常适合LLM初学者系统性地学习。
大语言模型(LLM)入门 - (4) 嵌入层
三月桃城的博客
05-31 412
《TiaoYu-1：中文注释完整的大语言模型学习项目》 TiaoYu-1是一个面向初学者的开源大语言模型学习项目，特色在于每行代码都配有中文注释，极大降低了学习门槛。该项目覆盖了完整的LLM训练全流程，包括预训练、监督微调、强化学习、LoRA微调等核心环节，并配有详细的原理文档。项目采用模块化学习路径，从基础概念到模型构建，再到各组件实现（如位置编码、注意力机制等），最后到完整训练流程，循序渐进。特别适合希望系统学习LLM技术细节的开发者，文档与代码结合的教学方式让理论学习与工程实践同步进行。
大语言模型(LLM)入门 - (6) 位置编码
三月桃城的博客
05-31 591
TiaoYu-1是一个开源的大语言模型学习项目，专为初学者设计。项目特点包括：1)所有代码都配有中文注释，便于理解；2)完整覆盖从预训练到推理模型的全流程；3)提供配套原理文档。学习路径分为四个阶段：概念理解、模型构建、代码实现和可选扩展知识。项目包含预训练、微调、强化学习等核心模块，以及FlashAttention、MOE等前沿技术实现。适合想要系统学习LLM原理和实践的开发者。
大语言模型(LLM)入门 - (12) 交叉熵损失
三月桃城的博客
05-31 552
TiaoYu-1是一个面向初学者的开源大语言模型学习项目，提供完整的中文注释代码和配套原理文档。该项目涵盖了从预训练到推理的完整流程，包括SFT微调、RLHF强化学习、LoRA微调等关键技术模块。项目采用模块化学习路径，推荐从基础概念文档入手，逐步深入模型架构、注意力机制等核心组件（如FlashAttention、MOE网络），最后实践训练流程。特别适合希望通过代码实践结合理论学习来掌握LLM技术的开发者，所有代码均配有中文注释以降低学习门槛。
大语言模型(LLM)入门 - (5) 正则化
三月桃城的博客
05-31 545
TiaoYu-1是一个面向初学者的中文大语言模型(LLM)学习项目。该项目特点包括：1)所有代码配有中文注释，易于理解；2)完整覆盖LLM训练全流程，包括预训练、SFT微调、RLHF强化学习、LoRA微调等；3)提供配套原理文档。学习路径设计合理，从概念到代码逐步深入，包含模型架构、注意力机制、优化方法等核心内容。项目还提供可选扩展知识，如评价指标、梯度问题处理等，适合LLM入门者系统学习。
大模型微调入门 LLM-quickstart-main
01-01
大模型微调入门的知识点涵盖广泛，其中涉及到机器学习、深度学习以及自然语言处理等多个领域。首先，我们需要对“大模型”这一概念有所了解。在当前人工智能领域中，大模型通常指的是拥有数十亿甚至更多参数的深度...
开源模型应用落地-解锁大语言模型的无限潜能
热门推荐
没有卑微的工作，只有卑微的心态，与其抱怨，不如埋头实干
01-11 2万+
1、您是否也在迫不及待地期待在AI时代中展示自己的能力？ 2、您是否一直在研究如何使用开源模型？ 3、您是否一直在寻找将AI与业务结合的方向？ 4、您是否一直在寻找模型推理加速的方法？ 5、您是否一直在努力整合来自互联网上零散的资料？
万字精研：大型语言模型微调Fine-Tuning技术——14种主流方法的原理、适用场景及实践指南
2401_85377976的博客
09-05 1310
BitFit对微调机制的一种积极探索，也很简单，通过仅调整 bias 效果就能有不错的效果，但没有具体阐述原理，就是通过猜测加实验得到的结果。同时，作者提出一个观点：微调的过程不是让模型适应另外的数据分布，而是让模型更好的应用出本身的表征能力。特点：训练参数量极小（约 0.1%）。在大部分任务上效果会差于 LoRA、Adapter 等方法。在每一个 Transformer 层都带上一些 virtual token 作为前缀，以适应不同的任务。
深度学习-45-大型语言模型LLM之本地化部署运行自己的大模型
qq_20466211的博客
04-23 1809
两个可以运行在本地的大模型工具：ollama和llama.cpp，尤其是ollama，本地跑一个大模型特别简单。无论是Ollama还是llama.cpp都是运行的量化后的模型（GGUF格式的），所以对电脑配置的要求大幅降低。
Github 2025-05-30Java开源项目日报Top10
老孙正经胡说
05-30 1123
根据Github Trendings的统计，今日(2025-05-30统计)共有10个项目上榜。
OpenCV CUDA模块直方图计算------在 GPU 上计算输入图像的直方图（histogram）函数histEven()
jndingxin的专栏
05-29 912
该函数用于在 GPU 上计算输入图像的直方图（histogram）。它将像素值区间均匀划分为若干个 bin（桶），并统计每个 bin 中像素的数量。
Sentiment analysis integrating LangGraph and large-scale conceptual models
最新发布
frostmelody 全网同名，大家多多关注呀~ 持续分享优质内容！
05-31 765
基础单元：句子/评论/文档（如图中4条手机评论）。扩展单元：实体（如“相机”、“电池”）。关系类型构建规则示例实体共现两节点提及相同实体评论A和B都讨论“电池”语义相似概念向量余弦相似度 > 阈值两条夸“拍照效果”的评论句法依赖基于依存解析的语法关系评论中“电池”修饰“续航”工具NetworkX或PyG（Python库）。
一、OpenCV的基本操作
qq_48904748的博客
05-23 1202
OpenCV是一个功能强大的计算机视觉库，包含多个模块，如图像处理、视频分析、机器学习等。基础操作包括图像的IO操作、绘制几何图形、获取和修改像素点、获取图像属性、图像通道的拆分与合并以及色彩空间的转换。此外，OpenCV还支持图像的算术操作，如图像的加法和混合，这些操作可以用于图像增强和合成。通过这些功能，OpenCV能够处理各种图像处理任务，为计算机视觉应用提供强大的支持。
智能体商业化落地实战指南：破解技术变现“最后一公里“难题
2401_88740939的博客
05-28 1175
AI智能体开发遇变现难题，井云平台推出解决方案。当前智能体开发者面临三大困境：用户管理低效、支付链路缺失、流量转化乏力。井云平台通过三大引擎帮助实现商业化闭环：1）灵活计费模式和支付系统；2）独立官网生成与会员运营工具；3）企业级定制服务。典型应用场景包括法律咨询、文案生成、虚拟偶像等，支持从开发到变现的零代码快速部署，解决AI技术落地最后一公里问题，让智能体真正实现商业价值。
mcp API
03-28
### MCP API 的文档与使用教程 MCP 是一种用于增强大型语言模型 (LLM) 功能的技术框架，它通过提示（Prompts）、资源（Resources）以及工具（Tools）这三种核心原语来扩展 LLM 能力[^2]。Apifox 平台也认识到 MCP 技术在 API 开发领域的重要作用，并将其应用于实际场景中[^1]。 为了实现将 `/Users/syw/project/wechatAr` 文件夹下的所有文件上传至远程服务器 `47.93.xx.xx` 用户名 `root` 下的 `/opt/ll` 目录的操作，可以基于 MCP 工具功能构建一个自定义的服务逻辑。以下是具体实现方法： #### 实现方案 利用 SCP 命令完成文件传输任务，并结合 MCP 的 Tool 功能封装此操作以便于后续调用。当关键词为“上传微信目录”时，触发该工具执行相应动作。 ```python import subprocess def upload_wechat_directory(): source_dir = "/Users/syw/project/wechatAr/*" target_server = "root@47.93.xx.xx:/opt/ll/" try: result = subprocess.run(["scp", "-r", source_dir, target_server], check=True) return {"status": "success", "message": f"All files from {source_dir} have been uploaded to {target_server}"} except Exception as e: return {"status": "error", "message": str(e)} # 将上述函数注册为 MCP 中的一个 tool tools = { "upload_wechat_directory_tool": upload_wechat_directory, } # 定义 prompt 和 resource 配置部分省略... ``` 以上代码片段展示了如何创建一个名为 `upload_wechat_directory_tool` 的工具并将其集成到 MCP 系统里去[^3]。每当接收到匹配条件的消息比如含有特定关键字的时候就会激活对应的行为即启动SCP进程从而达成目标需求。 #### 进一步学习资料推荐 对于希望深入研究或者实践更多关于 MCP 应用案例的人士来说，《MCP 教程进阶篇》提供了丰富的实例分析和技术细节值得参考阅读；另外《MCP 极简入门：超快速上手运行简单的 MCP 服务和 MCP 客户端》同样是非常好的起点材料之一可以帮助初学者迅速掌握基础概念及其运作机制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值