Eros1onz

SpringCloud整合SpringBoot-综合案例

1. 使用技术

1.1 后端

SpringCloud+SpringBoot+maven2+web+MySQL+xml+pagehelper+lombok+jwt+ras+BaseResult
Eureka 注册中心 + Eureka 客户端+Zuul网关 + 过滤器

1.2 前端

vue渐进式JavaScript框架

2. 需完成功能

2.1 功能1：用户登录

前端代码

api.js

/** ajax axios */
import axios from 'axios'
import {
      Message } from 'element-ui'

/** axios 基本项设置 */
axios.defaults.baseURL = 'http://localhost:10010/api'
axios.defaults.timeout = 3000

// 全局ajax错误处理
// axios.interceptors.response.use(response => {
     
//   return response
// }, error => {
     
//   Message.error(error.message)
//   return Promise.reject(error)
// })

/** 发送请求 */
export function login (user) {
     
  return axios.post('/userservice/user/login', user)
}
export function FindClassesForPageNum (ClassesPi) {
     
  return axios.get('/studentservice/classes/FindClassesForPageNum',{
     
    params:ClassesPi
  } )
}
export function Findteacher1list (t1) {
     
  return axios.get('/studentservice/classes/Findteacher1list/' +t1)
}
export function Findteacher2list (t2) {
     
  return axios.get('/studentservice/classes/Findteacher2list/' +t2)
}
export function Findteacher3list (t3) {
     
  return axios.get('/studentservice/classes/Findteacher3list/' + t3)
}
export function addClasses (classes) {
     
  return axios.post('/studentservice/classes/addClasses', classes)
}
export function DeleteClassesByCid (ids) {
     
  return axios.delete('/studentservice/classes/DeleteClassesByCid/' + ids)
}
export function FindByClassesByCid (cid) {
     
  return axios.get('/studentservice/classes/FindByClassesByCid/' + cid)
}
export function UpdateClasses (classes) {
     
  return axios.put('/studentservice/classes/UpdateClasses', classes)
}
export function FindStudentListForPageNum (studentPi) {
     
  return axios.get('/studentservice/student/FindStudentListForPageNum', {
     
    params:studentPi
  })
}
export function Findclasses () {
     
  return axios.get('/studentservice/student/Findclasses')
}
export function addStudent (student) {
     
  return axios.post('/studentservice/student/addStudent', student)
}
export function deleteStudentBysid (ids) {
     
  return axios.delete('/studentservice/student/deleteStudentBysid/'+ids)
}
export function FindStudent (sid) {
     
  return axios.get('/studentservice/student/FindStudent/'+sid)
}

后端代码

pom依赖

    
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            org.springframework.cloud
            spring-cloud-starter-netflix-eureka-client
        
        
        
            tk.mybatis
            mapper-spring-boot-starter
            2.0.4
        
        
        
            mysql
            mysql-connector-java
        
        
            com.czxy.cloud
            Exam_common
            1.0-SNAPSHOT

application.yml文件

server:
  port: 9090
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/cloud_db?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
    username: root
    password: 947411
  application:
    name: userservice
eureka:
  client:
    service-url:
      defaultZone: http://localhost:10086/eureka/

UserApplication启动类

package com.czxy;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import tk.mybatis.spring.annotation.MapperScan;

@SpringBootApplication
@EnableEurekaClient
@MapperScan(basePackages = "com.czxy.mapper")
public class UserApplicatioon {
     
    public static void main(String[] args) {
     
        SpringApplication.run(UserApplicatioon.class,args);
    }
}

domain对象类

package com.czxy.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.Id;
import javax.persistence.Table;

@Table(name = "tb_user")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
     
    @Id
    private Integer id;
    private String user_name;
    private String password;
}

mapper 通用mapper类

package com.czxy.mapper;

import com.czxy.domain.User;
import tk.mybatis.mapper.common.Mapper;

public interface UserMapper extends Mapper<User> {
     
}

service

package com.czxy.service;

import com.czxy.domain.User;

public interface UserService {
     
    /**
     * 登录用户
     * @param user
     * @return
     */
    User login(User user);
}

package com.czxy.service.impl;

import com.czxy.domain.User;
import com.czxy.mapper.UserMapper;
import com.czxy.service.UserService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import tk.mybatis.mapper.entity.Example;

import javax.annotation.Resource;

@Service
@Transactional
public class UserServiceImpl implements UserService {
     
    @Resource
    private UserMapper userMapper;
    /**
     * 登录用户
     * @param user
     * @return
     */
    @Override
    public User login(User user) {
     
        Example example = new Example(User.class);
        Example.Criteria c = example.createCriteria();
        c.andEqualTo("user_name",user.getUser_name());
        c.andEqualTo("password",user.getPassword());
        User bean = userMapper.selectOneByExample(example);
        if (bean==null){
     
            return null;
        }
        return bean;
    }
}

controller 控制类

package com.czxy.controller;

import com.czxy.domain.User;
import com.czxy.service.UserService;
import com.czxy.vo.BaseResult;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
@RequestMapping("/user")
public class UserController {
     
    // private static final  String priKeyPath = "D:\\ras\\ras.pri";
    @Resource
    private UserService userService;

    /**
     * 登录用户
     * @param user
     * @return
     */
    @PostMapping("/login")
    public BaseResult login(@RequestBody User user){
     
            //如果登录成功,将数据存入私钥中
            User loginUser = userService.login(user);
            if (loginUser!=null){
     
                // String token = JwtUtils.generateToken(loginUser, 60 * 5, RasUtils.getPrivateKey(priKeyPath));
                return BaseResult.ok("登录成功",loginUser);
            }else{
     
                return BaseResult.error("用户名或密码错误");
            }
        }
}

2.2 功能2：布局

2.3 功能3：添加班级

前端代码

后端代码

domain 对象类

package com.czxy.domain;

import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;
@Table(name = "tb_class")
public class Classes implements Serializable {
     
    @Id
    private Integer cid;
    private String cname;
    private Integer teacher1_id;
    private Teacher teacher1;
    private Integer teacher2_id;
    private Teacher teacher2;
    private Integer teacher3_id;
    private Teacher teacher3;


    @Override
    public String toString() {
     
        return "Classes{" +
                "cid=" + cid +
                ", cname='" + cname + '\'' +
                ", teacher1_id=" + teacher1_id +
                ", teacher1=" + teacher1 +
                ", teacher2_id=" + teacher2_id +
                ", teacher2=" + teacher2 +
                ", teacher3_id=" + teacher3_id +
                ", teacher3=" + teacher3 +
                '}';
    }

    public Classes() {
     
    }

    public Integer getCid() {
     

        return cid;
    }

    public void setCid(Integer cid) {
     
        this.cid = cid;
    }

    public String getCname() {
     
        return cname;
    }

    public void setCname(String cname) {
     
        this.cname = cname;
    }

    public Integer getTeacher1_id() {
     
        return teacher1_id;
    }

    public void setTeacher1_id(Integer teacher1_id) {
     
        this.teacher1_id = teacher1_id;
    }

    public Teacher getTeacher1() {
     
        return teacher1;
    }

    public void setTeacher1(Teacher teacher1) {
     
        this.teacher1 = teacher1;
    }

    public Integer getTeacher2_id() {
     
        return teacher2_id;
    }

    public void setTeacher2_id(Integer teacher2_id) {
     
        this.teacher2_id = teacher2_id;
    }

    public Teacher getTeacher2() {
     
        return teacher2;
    }

    public void setTeacher2(Teacher teacher2) {
     
        this.teacher2 = teacher2;
    }

    public Integer getTeacher3_id() {
     
        return teacher3_id;
    }

    public void setTeacher3_id(Integer teacher3_id) {
     
        this.teacher3_id = teacher3_id;
    }

    public Teacher getTeacher3() {
     
        return teacher3;
    }

    public void setTeacher3(Teacher teacher3) {
     
        this.teacher3 = teacher3;
    }
}

package com.czxy.domain;

import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;
@Table(name = "tb_teacher")

public class Teacher implements Serializable{
     
    @Id
    private Integer tid;
    private String tname;
    private Integer type;

    @Override
    public String toString() {
     
        return "Teacher{" +
                "tid=" + tid +
                ", tname='" + tname + '\'' +
                ", type=" + type +
                '}';
    }

    public Integer getTid() {
     
        return tid;
    }

    public void setTid(Integer tid) {
     
        this.tid = tid;
    }

    public String getTname() {
     
        return tname;
    }

    public void setTname(String tname) {
     
        this.tname = tname;
    }

    public Integer getType() {
     
        return type;
    }

    public void setType(Integer type) {
     
        this.type = type;
    }

    public Teacher(Integer tid, String tname, Integer type) {
     

        this.tid = tid;
        this.tname = tname;
        this.type = type;
    }

    public Teacher() {
     

    }
}

mapper 配置类

package com.czxy.mapper;

import com.czxy.domain.Classes;
import com.czxy.domain.ClassesPi;
import org.apache.ibatis.annotations.*;
import tk.mybatis.mapper.common.Mapper;

import java.util.List;

public interface ClassesMapper extends Mapper<Classes> {
     }

package com.czxy.mapper;

import com.czxy.domain.Teacher;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import tk.mybatis.mapper.common.Mapper;

import java.util.List;

public interface TeacherMapper extends Mapper<Teacher> {
     }

service和serviceImpl

package com.czxy.service;
import com.czxy.domain.Classes;

public interface ClassesService {
     
  /**
    * 添加班级
    * @param classes
    * @return
    */
   void addClasses(Classes classes);}

package com.czxy.service.impl;
import com.czxy.domain.Classes;
import com.czxy.mapper.ClassesMapper;
import com.czxy.mapper.StudentMapper;
import com.czxy.mapper.TeacherMapper;
import com.czxy.service.ClassesService;
import javax.annotation.Resource;
@Service
@Transactional
public class ClassesServiceImpl implements ClassesService {
     
    @Resource
    private ClassesMapper classesMapper;
    @Resource
    private TeacherMapper teacherMapper;
    @Resource
    private StudentMapper studentMapper;

    /**
     * 添加班级
     * @param classes
     * @return
     */
    @PostMapping("/addClasses")
    public BaseResult addClasses(@RequestBody Classes classes){
     
        classesService.addClasses(classes);
        return BaseResult.ok("添加成功");
    }
}

controller 控制器

package com.czxy.controller;
import com.czxy.domain.Classes;
import javax.annotation.Resource;
@RestController
@RequestMapping("/classes")
public class ClassesController {
     
    @Resource
    private ClassesService classesService;
    /**
     * 添加班级
     * @param classes
     * @return
     */
    @PostMapping("/addClasses")
    public BaseResult addClasses(@RequestBody Classes classes){
     
        classesService.addClasses(classes);
        return BaseResult.ok("添加成功");
    }

2.4 功能4：班级列表（基本列表 + 分页 + 条件）

前端代码

后端代码

controller 控制器

package com.czxy.controller;

import com.czxy.domain.Classes;
import com.czxy.domain.ClassesPi;
import com.czxy.service.ClassesService;
import com.czxy.vo.BaseResult;
import com.github.pagehelper.PageInfo;


import javax.annotation.Resource;
import java.util.List;

@RestController
@RequestMapping("/classes")
public class ClassesController {
     
    @Resource
    private ClassesService classesService;

    /**
     * 添加班级
     * @param classes
     * @return
     */
    @PostMapping("/addClasses")
    public BaseResult addClasses(@RequestBody Classes classes){
     
        classesService.addClasses(classes);
        return BaseResult.ok("添加成功");
    }
    
    /**
     * 查询班级列表(分页+条件)
     * @param
     * @return
     */
    @GetMapping("/FindClassesForPageNum")
    public BaseResult FindClassesForPageNum( ClassesPi classesPi){
     
     PageInfo<Classes> pi =  classesService.FindClassesForPageNum(classesPi);
        for (Classes classes : pi.getList()) {
     
            System.out.println(classes.toString());
        }
     return BaseResult.ok("查询成功",pi);
    }
}

service 和 serviceImpl

package com.czxy.service;

        import com.czxy.domain.Classes;
        import com.czxy.domain.ClassesPi;
        import com.github.pagehelper.PageInfo;
        import java.util.List;

public interface ClassesService {
     
    /**
     * 添加班级
     * @param classes
     * @return
     */
    void addClasses(Classes classes);
        /**
     * 查询班级列表(分页+条件)
     * @param
     * @param classesPi
     * @return
     */
    PageInfo<Classes> FindClassesForPageNum(ClassesPi classesPi);
}

mapper 配置类

package com.czxy.mapper;

import com.czxy.domain.Classes;
import com.czxy.domain.ClassesPi;
import org.apache.ibatis.annotations.*;
import tk.mybatis.mapper.common.Mapper;

import java.util.List;

public interface ClassesMapper extends Mapper<Classes> {
     
    /**
     * 查询班级列表(分页+条件)
     * @param
     * @param classesPi
     * @return
     */
    @Select(" ")
    @Results(id = "c1",value = {
     
            @Result(property = "cid",column = "cid"),
            @Result(property = "cname",column = "cname"),
            @Result(property = "teacher1_id",column = "teacher1_id"),
            @Result(property = "teacher2_id",column = "teacher2_id"),
            @Result(property = "teacher3_id",column = "teacher3_id"),
            @Result(property = "teacher1",column = "teacher1_id",one = @One(select = "com.czxy.mapper.TeacherMapper.selectByID")),
            @Result(property = "teacher2",column = "teacher2_id",one = @One(select = "com.czxy.mapper.TeacherMapper.selectByID")),
            @Result(property = "teacher3",column = "teacher3_id",one = @One(select = "com.czxy.mapper.TeacherMapper.selectByID"))
    })
    List<Classes> FindClassesForPageNum(@Param("classesPi") ClassesPi classesPi);

}

2.5 功能5：批量删除班级

前段代码

后端代码

controller

package com.czxy.controller;

import com.czxy.domain.Classes;
import com.czxy.domain.ClassesPi;
import com.czxy.service.ClassesService;
import com.czxy.vo.BaseResult;
import com.github.pagehelper.PageInfo;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.List;

@RestController
@RequestMapping("/classes")
public class ClassesController {
     
    @Resource
    private ClassesService classesService;

    /**
     * 查询班级列表(分页+条件)
     * @param
     * @return
     */
    @GetMapping("/FindClassesForPageNum")
    public BaseResult FindClassesForPageNum( ClassesPi classesPi){
     
     PageInfo<Classes> pi =  classesService.FindClassesForPageNum(classesPi);
        for (Classes classes : pi.getList()) {
     
            System.out.println(classes.toString());
        }
     return BaseResult.ok("查询成功",pi);
    }
    /**
     * 添加班级
     * @param classes
     * @return
     */
    @PostMapping("/addClasses")
    public BaseResult addClasses(@RequestBody Classes classes){
     
        classesService.addClasses(classes);
        return BaseResult.ok("添加成功");
    }

    /**
     * 批量删除数据
     * @param ids
     * @return
     */
    @DeleteMapping("/DeleteClassesByCid/{ids}")
    public BaseResult DeleteClassesByCid(@PathVariable("ids")String ids){
     
        classesService.DeleteClassesByCid(ids);
        return BaseResult.ok("删除成功");
    }


}

service

package com.czxy.service;

        import com.czxy.domain.Classes;
        import com.czxy.domain.ClassesPi;
        import com.github.pagehelper.PageInfo;

        import java.util.List;

public interface ClassesService {
     
    /**
     * 查询班级列表(分页+条件)
     * @param
     * @param classesPi
     * @return
     */
    PageInfo<Classes> FindClassesForPageNum(ClassesPi classesPi);
    /**
     * 添加班级
     * @param classes
     * @return
     */
    void addClasses(Classes classes);
    /**
     * 批量删除数据
     * @param ids
     * @return
     */
    void DeleteClassesByCid(String ids);
 
}

serviceImpl

package com.czxy.service.impl;

import com.czxy.domain.Classes;
import com.czxy.domain.ClassesPi;
import com.czxy.mapper.ClassesMapper;
import com.czxy.mapper.StudentMapper;
import com.czxy.mapper.TeacherMapper;
import com.czxy.service.ClassesService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;
@Service
@Transactional
public class ClassesServiceImpl implements ClassesService {
     
    @Resource
    private ClassesMapper classesMapper;
    @Resource
    private TeacherMapper teacherMapper;
    @Resource
    private StudentMapper studentMapper;
    /**
     * 查询班级列表(分页+条件)
     * @param
     * @param classesPi
     * @return
     */
    @Override
    public PageInfo<Classes> FindClassesForPageNum(ClassesPi classesPi) {
     
        PageHelper.startPage(classesPi.getPageNum(),classesPi.getPageSize());
        if (classesPi.getCname()!=null && !"" .equals(classesPi.getCname())){
     
            classesPi.setCname("%"+classesPi.getCname()+"%");
        }
        List<Classes> clist =  classesMapper.FindClassesForPageNum(classesPi);

        PageInfo<Classes> classesPageInfo = new PageInfo<>(clist);
        return classesPageInfo;
    }
    /**
     * 添加班级
     * @param classes
     * @return
     */
    @Override
    public void addClasses(Classes classes) {
     
        classesMapper.insertSelective(classes);
    }
    /**
     * 批量删除数据
     * @param ids
     * @return
     */
    @Override
    public void DeleteClassesByCid(String ids) {
     
        String[] split = ids.split(",");
        for (String s : split) {
     
            classesMapper.deleteByPrimaryKey(Integer.parseInt(s));
        }
    }
}

2.6 功能6：修改班级

前段代码

后端代码

controller

package com.czxy.controller;

import com.czxy.domain.Classes;
import com.czxy.domain.ClassesPi;
import com.czxy.domain.Teacher;
import com.czxy.service.ClassesService;
import com.czxy.vo.BaseResult;
import com.github.pagehelper.PageInfo;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.List;

@RestController
@RequestMapping("/classes")
public class ClassesController {
     
    @Resource
    private ClassesService classesService;

    /**
     * 查询班级列表(分页+条件)
     * @param
     * @return
     */
    @GetMapping("/FindClassesForPageNum")
    public BaseResult FindClassesForPageNum( ClassesPi classesPi){
     
     PageInfo<Classes> pi =  classesService.FindClassesForPageNum(classesPi);
        for (Classes classes : pi.getList()) {
     
            System.out.println(classes.toString());
        }
     return BaseResult.ok("查询成功",pi);
    }

    /**
     * 查询授课老师信息
     * @param tid
     * @return
     */
    @GetMapping("/Findteacher1list/{t1}")
    public BaseResult Findteacher1list(@PathVariable("t1")Integer tid){
     
       List<Teacher> tlist =  classesService.Findteacher1list(tid);
        System.out.println(tlist);
       return BaseResult.ok("查询成功",tlist);
    }
    /**
     * 查询助理老师信息
     * @param tid
     * @return
     */
    @GetMapping("/Findteacher2list/{t2}")
    public BaseResult Findteacher2list(@PathVariable("t2")Integer tid){
     
        List<Teacher> tlist =  classesService.Findteacher2list(tid);
        System.out.println(tlist);
        return BaseResult.ok("查询成功",tlist);
    }
    /**
     * 查询辅导员老师老师信息
     * @param tid
     * @return
     */
    @GetMapping("/Findteacher3list/{t3}")
    public BaseResult Findteacher3list(@PathVariable("t3")Integer tid){
     
        List<Teacher> tlist =  classesService.Findteacher3list(tid);
        System.out.println(tlist);
        return BaseResult.ok("查询成功",tlist);
    }

    /**
     * 添加班级
     * @param classes
     * @return
     */
    @PostMapping("/addClasses")
    public BaseResult addClasses(@RequestBody Classes classes){
     
        classesService.addClasses(classes);
        return BaseResult.ok("添加成功");
    }

    /**
     * 批量删除数据
     * @param ids
     * @return
     */
    @DeleteMapping("/DeleteClassesByCid/{ids}")
    public BaseResult DeleteClassesByCid(@PathVariable("ids")String ids){
     
        classesService.DeleteClassesByCid(ids);
        return BaseResult.ok("删除成功");
    }

    /**
     * 修改第一步:回显数据
     * @param cid
     * @return
     */
    @GetMapping("/FindByClassesByCid/{cid}")
    public BaseResult FindByClassesByCid(@PathVariable("cid") Integer cid){
     
        Classes classes = classesService.FindByClassesByCid(cid);
        return BaseResult.ok("查询成功",classes);
    }


}

service

package com.czxy.service;

        import com.czxy.domain.Classes;
        import com.czxy.domain.ClassesPi;
        import com.czxy.domain.Teacher;
        import com.github.pagehelper.PageInfo;

        import java.util.List;

public interface ClassesService {
     
    /**
     * 查询班级列表(分页+条件)
     * @param
     * @param classesPi
     * @return
     */
    PageInfo<Classes> FindClassesForPageNum(ClassesPi classesPi);
    /**
     * 查询授课老师信息
     * @param tid
     * @return
     */
    List<Teacher> Findteacher1list(Integer tid);
    /**
     * 查询助理老师信息
     * @param tid
     * @return
     */
    List<Teacher> Findteacher2list(Integer tid);
    /**
     * 查询辅导员老师老师信息
     * @param tid
     * @return
     */
    List<Teacher> Findteacher3list(Integer tid);
    /**
     * 添加班级
     * @param classes
     * @return
     */
    void addClasses(Classes classes);
    /**
     * 批量删除数据
     * @param ids
     * @return
     */
    void DeleteClassesByCid(String ids);
    /**
     * 修改第一步:回显数据
     * @param cid
     * @return
     */
    Classes FindByClassesByCid(Integer cid);
}

serviceIpml

package com.czxy.service.impl;

import com.czxy.domain.Classes;
import com.czxy.domain.ClassesPi;
import com.czxy.domain.Teacher;
import com.czxy.mapper.ClassesMapper;
import com.czxy.mapper.StudentMapper;
import com.czxy.mapper.TeacherMapper;
import com.czxy.service.ClassesService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;
@Service
@Transactional
public class ClassesServiceImpl implements ClassesService {
     
    @Resource
    private ClassesMapper classesMapper;
    @Resource
    private TeacherMapper teacherMapper;
    @Resource
    private StudentMapper studentMapper;
    /**
     * 查询班级列表(分页+条件)
     * @param
     * @param classesPi
     * @return
     */
    @Override
    public PageInfo<Classes> FindClassesForPageNum(ClassesPi classesPi) {
     
        PageHelper.startPage(classesPi.getPageNum(),classesPi.getPageSize());
        if (classesPi.getCname()!=null && !"" .equals(classesPi.getCname())){
     
            classesPi.setCname("%"+classesPi.getCname()+"%");
        }
        List<Classes> clist =  classesMapper.FindClassesForPageNum(classesPi);

        PageInfo<Classes> classesPageInfo = new PageInfo<>(clist);
        return classesPageInfo;
    }
    /**
     * 查询授课老师信息
     * @param tid
     * @return
     */
    @Override
    public List<Teacher> Findteacher1list(Integer tid) {
     
        List<Teacher> tlist =  teacherMapper.Findteacher1list(tid);
        return tlist;
    }
    /**
     * 查询助理老师信息
     * @param tid
     * @return
     */
    @Override
    public List<Teacher> Findteacher2list(Integer tid) {
     
        List<Teacher> tlist =  teacherMapper.Findteacher1list(tid);
        return tlist;
    }
    /**
     * 查询辅导员老师老师信息
     * @param tid
     * @return
     */
    @Override
    public List<Teacher> Findteacher3list(Integer tid) {
     
        List<Teacher> tlist =  teacherMapper.Findteacher1list(tid);
        return tlist;
    }
    /**
     * 添加班级
     * @param classes
     * @return
     */
    @Override
    public void addClasses(Classes classes) {
     
        classesMapper.insertSelective(classes);
    }
    /**
     * 批量删除数据
     * @param ids
     * @return
     */
    @Override
    public void DeleteClassesByCid(String ids) {
     
        String[] split = ids.split(",");
        for (String s : split) {
     
            classesMapper.deleteByPrimaryKey(Integer.parseInt(s));
        }
    }
    /**
     * 修改第一步:回显数据
     * @param cid
     * @return
     */
    @Override
    public Classes FindByClassesByCid(Integer cid) {
     
        Classes classes =  classesMapper.FindByClassesByCid(cid);
        return classes;
    }
}

mapper

package com.czxy.mapper;

import com.czxy.domain.Classes;
import com.czxy.domain.ClassesPi;
import org.apache.ibatis.annotations.*;
import tk.mybatis.mapper.common.Mapper;

import java.util.List;

public interface ClassesMapper extends Mapper<Classes> {
     
    /**
     * 查询班级列表(分页+条件)
     * @param
     * @param classesPi
     * @return
     */
    @Select(" ")
    @Results(id = "c1",value = {
     
            @Result(property = "cid",column = "cid"),
            @Result(property = "cname",column = "cname"),
            @Result(property = "teacher1_id",column = "teacher1_id"),
            @Result(property = "teacher2_id",column = "teacher2_id"),
            @Result(property = "teacher3_id",column = "teacher3_id"),
            @Result(property = "teacher1",column = "teacher1_id",one = @One(select = "com.czxy.mapper.TeacherMapper.selectByID")),
            @Result(property = "teacher2",column = "teacher2_id",one = @One(select = "com.czxy.mapper.TeacherMapper.selectByID")),
            @Result(property = "teacher3",column = "teacher3_id",one = @One(select = "com.czxy.mapper.TeacherMapper.selectByID"))
    })
    List<Classes> FindClassesForPageNum(@Param("classesPi") ClassesPi classesPi);

    @Select("select * from tb_class where cid=#{cid}")
    @ResultMap( "c1")
    Classes FindByClassesByCid(@Param("cid") Integer cid);
}

2.7 功能7：添加学生

前端代码

后端代码

domain

package com.czxy.domain;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;
@Table(name = "tb_student")
public class Student implements Serializable {
     
    @Id
    private Integer sid;
    private String sname;
    private Integer gender;
    private Integer age;
    private Double salary;
    @Column(name = "`desc`")
    private String desc;
    private Integer class_id;
    private Classes classes;

    @Override
    public String toString() {
     
        return "Student{" +
                "sid=" + sid +
                ", sname='" + sname + '\'' +
                ", gender=" + gender +
                ", age=" + age +
                ", salary=" + salary +
                ", desc='" + desc + '\'' +
                ", class_id=" + class_id +
                ", classes=" + classes +
                '}';
    }

    public Integer getSid() {
     
        return sid;
    }

    public void setSid(Integer sid) {
     
        this.sid = sid;
    }

    public String getSname() {
     
        return sname;
    }

    public void setSname(String sname) {
     
        this.sname = sname;
    }

    public Integer getGender() {
     
        return gender;
    }

    public void setGender(Integer gender) {
     
        this.gender = gender;
    }

    public Integer getAge() {
     
        return age;
    }

    public void setAge(Integer age) {
     
        this.age = age;
    }

    public Double getSalary() {
     
        return salary;
    }

    public void setSalary(Double salary) {
     
        this.salary = salary;
    }

    public String getDesc() {
     
        return desc;
    }

    public void setDesc(String desc) {
     
        this.desc = desc;
    }

    public Integer getClass_id() {
     
        return class_id;
    }

    public void setClass_id(Integer class_id) {
     
        this.class_id = class_id;
    }

    public Classes getClasses() {
     
        return classes;
    }

    public void setClasses(Classes classes) {
     
        this.classes = classes;
    }

    public Student(Integer sid, String sname, Integer gender, Integer age, Double salary, String desc, Integer class_id, Classes classes) {
     

        this.sid = sid;
        this.sname = sname;
        this.gender = gender;
        this.age = age;
        this.salary = salary;
        this.desc = desc;
        this.class_id = class_id;
        this.classes = classes;
    }

    public Student() {
     

    }
}

mapper

package com.czxy.mapper;
import tk.mybatis.mapper.common.Mapper;

import java.util.List;

public interface StudentMapper extends Mapper<Student> {
     
 
}

service

package com.czxy.service;
import com.czxy.domain.Student;
import java.util.List;

public interface StudentService {
     
    /**
     *  添加一个学生
     * @param student
     * @return
     */
    void addStudent(Student student);
   
}

serviceImpl

package com.czxy.service.impl;


import com.czxy.domain.Student;

import com.czxy.mapper.ClassesMapper;
import com.czxy.mapper.StudentMapper;
import com.czxy.mapper.TeacherMapper;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;


@Service
@Transactional
public class StudentServiceImpl implements StudentService {
     
    @Resource
    private ClassesMapper classesMapper;
    @Resource
    private TeacherMapper teacherMapper;
    @Resource
    private StudentMapper studentMapper;
    /**
     *  添加一个学生
     * @param student
     * @return
     */
    @Override
    public void addStudent(Student student) {
     
        studentMapper.insertSelective(student);
    }

controller

package com.czxy.controller;


import com.czxy.domain.Student;

import com.czxy.service.StudentService;
import com.czxy.vo.BaseResult;

import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;


@RestController
@RequestMapping("/student")
public class StudentController {
     
    @Resource
    private StudentService studentService;


    /**
     *  添加一个学生
     * @param student
     * @return
     */
    @PostMapping("/addStudent")
    private BaseResult addStudent(@RequestBody Student student){
     
        studentService.addStudent(student);
        return BaseResult.ok("添加成功");
    }


}

2.8 功能8：学生列表（基本列表+分页+条件）

前端代码

后端代码

package com.czxy.controller;

        import com.czxy.domain.Classes;
        import com.czxy.domain.Student;
        import com.czxy.domain.StudentPi;
        import com.czxy.service.StudentService;
        import com.czxy.vo.BaseResult;
        import com.github.pagehelper.PageInfo;
        import org.springframework.web.bind.annotation.*;

        import javax.annotation.Resource;
        import java.util.List;

@RestController
@RequestMapping("/student")
public class StudentController {
     
    @Resource
    private StudentService studentService;

    /**
     *  学生列表(分页+多条件)
     * @param studentPi
     * @return
     */
    @GetMapping("/FindStudentListForPageNum")
    public BaseResult FindStudentListForPageNum( StudentPi studentPi){
     
        PageInfo<Student> pageInfo =  studentService.FindStudentListForPageNum(studentPi);
        return BaseResult.ok("查询成功",pageInfo);
    }

    /**
     *  添加一个学生
     * @param student
     * @return
     */
    @PostMapping("/addStudent")
    private BaseResult addStudent(@RequestBody Student student){
     
        studentService.addStudent(student);
        return BaseResult.ok("添加成功");
    }
}

service

package com.czxy.service;

import com.czxy.domain.Classes;
import com.czxy.domain.Student;
import com.czxy.domain.StudentPi;
import com.github.pagehelper.PageInfo;

import java.util.List;

public interface StudentService {
     
    /**
     * 学生列表(分页+多条件)
     * @param studentPi
     * @return
     */
    PageInfo<Student> FindStudentListForPageNum(StudentPi studentPi);
    /**
     *  添加一个学生
     * @param student
     * @return
     */
    void addStudent(Student student);

}

serviceImpl

package com.czxy.service.impl;

import com.czxy.domain.Classes;
import com.czxy.domain.Student;
import com.czxy.domain.StudentPi;
import com.czxy.mapper.ClassesMapper;
import com.czxy.mapper.StudentMapper;
import com.czxy.mapper.TeacherMapper;
import com.czxy.service.StudentService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;

@Service
@Transactional
public class StudentServiceImpl implements StudentService {
     
    @Resource
    private ClassesMapper classesMapper;
    @Resource
    private TeacherMapper teacherMapper;
    @Resource
    private StudentMapper studentMapper;
    /**
     * 学生列表(分页+多条件)
     * @param studentPi
     * @return
     */
    @Override
    public PageInfo<Student> FindStudentListForPageNum(StudentPi studentPi) {
     
        PageHelper.startPage(studentPi.getPageNum(),studentPi.getPageSize());
    //    设置姓名
        if (studentPi.getSname() != null && !"" .equals(studentPi.getSname())){
     
            studentPi.setSname("%"+studentPi.getSname()+"%");
        }
        List<Student> slist =  studentMapper.FindStudentListForPageNum(studentPi);
        PageInfo<Student> pageInfo = new PageInfo<>(slist);
        return pageInfo;
    }

    /**
     *  添加一个学生
     * @param student
     * @return
     */
    @Override
    public void addStudent(Student student) {
     
        studentMapper.insertSelective(student);
    }

mapper

package com.czxy.mapper;

        import com.czxy.domain.Student;
        import com.czxy.domain.StudentPi;
        import org.apache.ibatis.annotations.*;
        import tk.mybatis.mapper.common.Mapper;

        import java.util.List;

public interface StudentMapper extends Mapper<Student> {
     
    /**
     * 学生列表(分页+多条件)
     * @param studentPi
     * @return
     */
    @Select("")
    @Results(id = "s1",value = {
     
            @Result(property = "class_id",column = "class_id"),
            @Result(property = "classes",column = "class_id",one = @One(select = "com.czxy.mapper.ClassesMapper.FindByClassesByCid"))
    })
    List<Student> FindStudentListForPageNum(@Param("studentPi") StudentPi studentPi);


}

2.9 功能9：批量删除

前段代码

后端代码

controller

package com.czxy.controller;

        import com.czxy.domain.Classes;
        import com.czxy.domain.Student;
        import com.czxy.domain.StudentPi;
        import com.czxy.service.StudentService;
        import com.czxy.vo.BaseResult;
        import com.github.pagehelper.PageInfo;
        import org.springframework.web.bind.annotation.*;

        import javax.annotation.Resource;
        import java.util.List;

@RestController
@RequestMapping("/student")
public class StudentController {
     
    @Resource
    private StudentService studentService;

    /**
     *  学生列表(分页+多条件)
     * @param studentPi
     * @return
     */
    @GetMapping("/FindStudentListForPageNum")
    public BaseResult FindStudentListForPageNum( StudentPi studentPi){
     
        PageInfo<Student> pageInfo =  studentService.FindStudentListForPageNum(studentPi);
        return BaseResult.ok("查询成功",pageInfo);
    }
    /**
     *  添加一个学生
     * @param student
     * @return
     */
    @PostMapping("/addStudent")
    private BaseResult addStudent(@RequestBody Student student){
     
        studentService.addStudent(student);
        return BaseResult.ok("添加成功");
    }

    /**
     *  批量删除
     * @param ids
     * @return
     */
    @DeleteMapping("/deleteStudentBysid/{ids}")
    public BaseResult deleteStudentBysid(@PathVariable("ids") String ids){
     
        studentService.deleteStudentBysid(ids);
        return BaseResult.ok("删除成功");
    }

 

}

service

package com.czxy.service;

import com.czxy.domain.Classes;
import com.czxy.domain.Student;
import com.czxy.domain.StudentPi;
import com.github.pagehelper.PageInfo;

import java.util.List;

public interface StudentService {
     
    /**
     * 学生列表(分页+多条件)
     * @param studentPi
     * @return
     */
    PageInfo<Student> FindStudentListForPageNum(StudentPi studentPi);

    /**
     *  添加一个学生
     * @param student
     * @return
     */
    void addStudent(Student student);
    /**
     *  批量删除
     * @param ids
     * @return
     */
    void deleteStudentBysid(String ids);

}

serviceImpl

package com.czxy.service.impl;

import com.czxy.domain.Classes;
import com.czxy.domain.Student;
import com.czxy.domain.StudentPi;
import com.czxy.mapper.ClassesMapper;
import com.czxy.mapper.StudentMapper;
import com.czxy.mapper.TeacherMapper;
import com.czxy.service.StudentService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;

@Service
@Transactional
public class StudentServiceImpl implements StudentService {
     
    @Resource
    private ClassesMapper classesMapper;
    @Resource
    private TeacherMapper teacherMapper;
    @Resource
    private StudentMapper studentMapper;
    /**
     * 学生列表(分页+多条件)
     * @param studentPi
     * @return
     */
    @Override
    public PageInfo<Student> FindStudentListForPageNum(StudentPi studentPi) {
     
        PageHelper.startPage(studentPi.getPageNum(),studentPi.getPageSize());
    //    设置姓名
        if (studentPi.getSname() != null && !"" .equals(studentPi.getSname())){
     
            studentPi.setSname("%"+studentPi.getSname()+"%");
        }
        List<Student> slist =  studentMapper.FindStudentListForPageNum(studentPi);
        PageInfo<Student> pageInfo = new PageInfo<>(slist);
        return pageInfo;
    }
    /**
     *  添加一个学生
     * @param student
     * @return
     */
    @Override
    public void addStudent(Student student) {
     
        studentMapper.insertSelective(student);
    }
    /**
     *  批量删除
     * @param ids
     * @return
     */
    @Override
    public void deleteStudentBysid(String ids) {
     
        String[] split = ids.split(",");
        for (String s : split) {
     
            studentMapper.deleteByPrimaryKey(Integer.parseInt(s));
        }
    }

2.10 功能10：修改学生

前端代码

后端代码

controller

package com.czxy.controller;

        import com.czxy.domain.Classes;
        import com.czxy.domain.Student;
        import com.czxy.domain.StudentPi;
        import com.czxy.service.StudentService;
        import com.czxy.vo.BaseResult;
        import com.github.pagehelper.PageInfo;
        import org.springframework.web.bind.annotation.*;

        import javax.annotation.Resource;
        import java.util.List;

@RestController
@RequestMapping("/student")
public class StudentController {
     
    @Resource
    private StudentService studentService;

    /**
     *  学生列表(分页+多条件)
     * @param studentPi
     * @return
     */
    @GetMapping("/FindStudentListForPageNum")
    public BaseResult FindStudentListForPageNum( StudentPi studentPi){
     
        PageInfo<Student> pageInfo =  studentService.FindStudentListForPageNum(studentPi);
        return BaseResult.ok("查询成功",pageInfo);
    }

    /**
     *  查询班级信息
     * @return
     */
    @GetMapping("/Findclasses")
    public BaseResult Findclasses(){
     
        List<Classes> clist = studentService.Findclasses();
        return BaseResult.ok("查询成功",clist);
    }

    /**
     *  添加一个学生
     * @param student
     * @return
     */
    @PostMapping("/addStudent")
    private BaseResult addStudent(@RequestBody Student student){
     
        studentService.addStudent(student);
        return BaseResult.ok("添加成功");
    }

    /**
     *  批量删除
     * @param ids
     * @return
     */
    @DeleteMapping("/deleteStudentBysid/{ids}")
    public BaseResult deleteStudentBysid(@PathVariable("ids") String ids){
     
        studentService.deleteStudentBysid(ids);
        return BaseResult.ok("删除成功");
    }

    /**
     *  修改第一步: 回显对象
     * @param sid
     * @return
     */
    @GetMapping("/FindStudent/{sid}")
    public BaseResult FindStudent(@PathVariable("sid") Integer sid){
     
        Student student =  studentService.FindStudent(sid);
        return BaseResult.ok("查询成功",student);
    }


}

service

package com.czxy.service;

import com.czxy.domain.Classes;
import com.czxy.domain.Student;
import com.czxy.domain.StudentPi;
import com.github.pagehelper.PageInfo;

import java.util.List;

public interface StudentService {
     
    /**
     * 学生列表(分页+多条件)
     * @param studentPi
     * @return
     */
    PageInfo<Student> FindStudentListForPageNum(StudentPi studentPi);
    /**
     * 查询班级信息
     * @return
     */
    List<Classes> Findclasses();
    /**
     *  添加一个学生
     * @param student
     * @return
     */
    void addStudent(Student student);
    /**
     *  批量删除
     * @param ids
     * @return
     */
    void deleteStudentBysid(String ids);
    /**
     *  修改第一步: 回显对象
     * @param sid
     * @return
     */
    Student FindStudent(Integer sid);
}

serviceImpl

package com.czxy.service.impl;

import com.czxy.domain.Classes;
import com.czxy.domain.Student;
import com.czxy.domain.StudentPi;
import com.czxy.mapper.ClassesMapper;
import com.czxy.mapper.StudentMapper;
import com.czxy.mapper.TeacherMapper;
import com.czxy.service.StudentService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;

@Service
@Transactional
public class StudentServiceImpl implements StudentService {
     
    @Resource
    private ClassesMapper classesMapper;
    @Resource
    private TeacherMapper teacherMapper;
    @Resource
    private StudentMapper studentMapper;
    /**
     * 学生列表(分页+多条件)
     * @param studentPi
     * @return
     */
    @Override
    public PageInfo<Student> FindStudentListForPageNum(StudentPi studentPi) {
     
        PageHelper.startPage(studentPi.getPageNum(),studentPi.getPageSize());
    //    设置姓名
        if (studentPi.getSname() != null && !"" .equals(studentPi.getSname())){
     
            studentPi.setSname("%"+studentPi.getSname()+"%");
        }
        List<Student> slist =  studentMapper.FindStudentListForPageNum(studentPi);
        PageInfo<Student> pageInfo = new PageInfo<>(slist);
        return pageInfo;
    }
    /**
     * 查询班级信息
     * @return
     */
    @Override
    public List<Classes> Findclasses() {
     
        List<Classes> classes = classesMapper.selectAll();
        return classes;
    }
    /**
     *  添加一个学生
     * @param student
     * @return
     */
    @Override
    public void addStudent(Student student) {
     
        studentMapper.insertSelective(student);
    }
    /**
     *  批量删除
     * @param ids
     * @return
     */
    @Override
    public void deleteStudentBysid(String ids) {
     
        String[] split = ids.split(",");
        for (String s : split) {
     
            studentMapper.deleteByPrimaryKey(Integer.parseInt(s));
        }
    }
    /**
     *  修改第一步: 回显对象
     * @param sid
     * @return
     */
    @Override
    public Student FindStudent(Integer sid) {
     
       Student student =  studentMapper.FindStudent(sid);
       return student;
    }
}

mapper

package com.czxy.mapper;

        import com.czxy.domain.Student;
        import com.czxy.domain.StudentPi;
        import org.apache.ibatis.annotations.*;
        import tk.mybatis.mapper.common.Mapper;

        import java.util.List;

public interface StudentMapper extends Mapper<Student> {
     
    /**
     * 学生列表(分页+多条件)
     * @param studentPi
     * @return
     */
    @Select("")
    @Results(id = "s1",value = {
     
            @Result(property = "class_id",column = "class_id"),
            @Result(property = "classes",column = "class_id",one = @One(select = "com.czxy.mapper.ClassesMapper.FindByClassesByCid"))
    })
    List<Student> FindStudentListForPageNum(@Param("studentPi") StudentPi studentPi);

    @Select("select * from tb_student where sid=#{sid}")
    @ResultMap("s1")
    Student FindStudent(@Param("sid") Integer sid);
}

你可能感兴趣的:(SpringCloud)

SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
面试常见题之Spring Cloud 拾光编程 java面试面试 spring cloud 职场和发展
在Java软件工程师的面试中，关于SpringCloud的题目旨在考察候选人对微服务架构的理解、SpringCloud各组件的掌握程度、以及如何在实际项目中应用这些技术来构建可扩展、可靠和高效的服务。本文将概括性地列出20个关于SpringCloud的面试题目，并为每个题目提供一个简要的回答框架或关键点，以便你根据需要进行扩展。1.SpringCloud是什么？它解决了什么问题？回答框架：Spri
springcloud — 微服务鉴权管理Spring Security原理解析(二) RachelHwang springcloud spring java spring security oauth2 springcloud
引言：回顾之前介绍的OAuth2简单分析与介绍，微服务鉴权管理之OAuth2原理解析(一)，前面的部分，我们关注了SpringSecurity是如何完成认证工作的，但是另外一部分核心的内容：过滤器，一直没有提到，我们已经知道SpringSecurity使用了springSecurityFilterChain作为了安全过滤的入口，这一节主要分析一下这个过滤器链都包含了哪些关键的过滤器，并且各自的使命
Open Feign 实战笔记自强-X spring-cloud java spring 微服务 ribbon spring cloud
OpenFeign笔记概念声明式的web服务客户端。使用接口加注解的形式编程。它是对RestTemplate和ribbon做了进一步封装。Feign已经停更，OpenFeign是在Feign的基础上又做了进一步的封装。Feign：Feign是SpringCloud组件中的一个轻量级RESTful的HTTP服务客户端Feign内置了Ribbon，用来做客户端负载均衡，去调用服务注册中心的服务。Fei
微服务架构 | nacos - [自动刷新配置方式 & 失效排查] 问仙长何方蓬莱微服务 java技术 SpringCloud 微服务 java nacos
INDEX§1配置方式§1.1springboot配置§1.2springcloud配置§2失效排查§2.1常见失效场景§2.1.1配置不配套§2.1.2自动刷新未开启§2.1.3依赖冲突§2.1.4改错了配置文件§2.2未知情况关键排查点§1配置方式nacos的配置中心主要有两套配置方式，配置方式不互相共通，需要配套配置springbootspringcloud§1.1springboot配置依
Spring Cloud: Hystrix请求队列线程不足 MeazZa
在SpringCloud中，Feign可以实现本地化的微服务API调用，Hystrix可以实现调用失败时的fallback处理。问题描述：在实际生产环境中使用时，我们遇到了这样一个错误："...,stacktrace:[com.netflix.hystrix.exception.HystrixRuntimeException:QueryNodeImpalaBdService#getQueryRes
工程项目管理系统源码与Spring Cloud：实现高效系统管理与二次开发微服务技术分享 spring cloud java 工程项目管理系统源码
随着企业规模的不断扩大和业务的快速发展，传统的工程项目管理方式已经无法满足现代企业的需求。为了提高工程管理效率、减轻劳动强度、提高信息处理速度和准确性，企业需要借助先进的数字化技术进行转型。本文将介绍一款采用SpringCloud+SpringBoot+Mybatis技术框架的工程项目管理系统，该系统涵盖了项目管理、合同管理、预警管理、竣工管理、质量管理等多个方面，通过数据字典、编码管理、用户管理
论文分享系列（三）——论软件架构风格马斯洛金字塔下的小灵猴儿 #软考高项架构师论软件架构风格论文
论软件架构风格摘要2023年5月，我司启动了精彩购电商系统的开发工作，该项目组中我担任系统架构师岗位，主要负责整体架构设计与中间件选型。本文以该电商平台为例，主要讨论了软件架构风格在该项目中的具体应用。整个系统采用具有三层的层次式软件架构的设计思想，分别是应用层，服务层，数据层。在应用层中的业务逻辑层的设计中，将整个业务系统划分为十余个子系统。服务层以springcloud服务框架为核心，数据采用
论文分享系列（二）——论微服务架构及其应用马斯洛金字塔下的小灵猴儿 #软考高项架构师论微服务架构及其应用论文
论微服务架构及其应用摘要2023年5月，我司启动了精彩购电商系统的开发工作，该项目组中我担任系统架构师岗位，主要负责整体架构设计与中间件选型。本文以该电商平台为例，将介绍微服务架构的特点、应用场景以及实现方法。系统以SpringCloud微服务框架开发，分为前端Web服务、平台保障服务、业务服务三部分。前端Web服务由负载均衡与服务器集群结合，实现高并发的前台界面；平台保障服务以Eureka为中心
【Gateway】Route Predicate Factories 小小小小关同学 SpringCloud gateway
SpringCloudGateway是一个功能强大的API网关框架，广泛用于微服务架构中。它的核心功能之一是路由请求，并根据规则将请求转发到目标服务。要实现这一功能，SpringCloudGateway提供了各种断言工厂（RoutePredicateFactories），用于定义和控制路由的行为。1.Predicate在编程中，Predicate是一个常见的概念，主要用于对输入值进行判断或评估。它
Spring Cloud Gateway的使用介绍与随笔阳爱铭 Spring组件专栏 spring
文章目录第一章API网关相关知识介绍前言1API网关相关知识介绍1.1什么是API网关1.2API网关的组成1.2.1路由转发1.2.2过滤器1.3SpringCloud中的网关解决方案1.3.1SpringCloudNetflixZuul1.3.2SpringCloudGateway前言在微服务架构之下，服务被拆的非常零散，降低了耦合度的同时也给服务的统一管理增加了难度。在旧的服务治理体系之下，
SpringCloud-Alibaba之Seata入门以及踩坑 DN金猿 spring boot java 数据库 seata
前言上一篇文章：➣SpringCloudAlibaba之Seata入门以及踩坑（一）老顾介绍了seata相关的准备工作，以及版本的选择；今天老顾就来介绍一下seata的使用。以及在使用过程中遇到的问题。案例背景今天老顾介绍的案例场景也就是网上常用的场景，用户下单场景。整个流程就是用户下单时：1）创建订单，订单状态为创建中2）扣减商品库存3）扣减用户金额4）更改订单状态，订单状态为已完结从以上业务流
深入探究Spring Framework源码与核心组件纸寿司
本文还有配套的精品资源，点击获取简介：SpringFramework是Java开发中广泛使用的框架，其源码的阅读和理解对于开发者来说是宝贵的学习资源。本文将介绍依赖注入、ApplicationContext、Bean生命周期、AOP、数据访问集成、MVC模式、注解驱动开发、测试支持、SpringBoot以及SpringCloud等关键概念。通过这些核心组件的学习，可以更好地掌握Spring的高级功
Docker部署单点es Javaismymorning ES学习笔记 docker elasticsearch
前言该笔记是根据B站上黑马SpringCloud学习总结的一、ES是什么？Elasticsearch是一个分布式、高扩展、高实时的搜索与数据分析引擎。它能很方便的使大量数据具有搜索、分析和探索的能力。充分利用Elasticsearch的水平伸缩性，能使数据在生产环境变得更有价值二、Docker部署ES步骤1.创建网络因为还要部署Kibana，实现es和Kibana关联，创建一个网络Kibana是为
RocketMQ复习 slh别学了微服务 rocketmq 微服务 java
之前写的博客太杂，最近想把RocketMQ的知识点再系统的过一遍，带着自己的理解使用简短的话把一些问题总结一下，尤其是开发中和面试中的高频问题，基础知识点可以参考之前写的一些博客，这篇不再赘述。SpringCloud入门(3)RabbitMQRocketMQ学习(1)快速入门RocketMQ学习(2)深入学习RocketMQ学习(3)秒杀实战目录MQ技术对比基本概念(消费者组、订阅关系等)消费模式
Fegin超时时间设置的优先级小胖学编程
feign的底层是ribbon、ribbon最终借助的是client完成服务调用，且SpringBoot即可以设置feign的超时时间。又可设置ribbon超时时间，还可以设置client(例如okhttp)超时时间。那么超时时间设置的优先级哪个高呢？版本信息：springBoot2.2.6.RELEASEspringCloudHoxton.RELEASEFeign调用流程如下图所示：feign调
Spring Cloud与Spring Boot有什么关系？用心去追梦 spring cloud spring boot spring
SpringCloud和SpringBoot都是由Pivotal团队（原SpringSource）开发的，它们之间有着密切的关系，但也有各自的特点和用途。下面我将详细介绍这两个项目之间的关系以及它们各自的定位。SpringBootSpringBoot是一个基于Spring框架的子项目，它旨在简化Spring应用程序的创建和部署。SpringBoot提供了以下特点：开箱即用：自动配置Spring应用
2024上学期--实验室学习计划 m0_66357705 javascript 前端 vue.js
阶段周次学习内容实践内容时间安排新增内容/重点基础巩固1-2周Java基础，多线程，TCP/IP网络编程相关练习和小的编程项目每天学习2小时，实践1小时Java20及以上版本新特性学习框架深入学习3-6周Spring，SpringBoot相关练习和小的编程项目每天学习3小时，实践1.5小时学习SpringCloud和微服务架构基础前端技术提升7-8周Vue2，Vue3相关练习和小的编程项目每天学习
seata基本使用，柚子快报邀请码778899 登录成功
把seata的使用在这里做了一个总结，希望能够帮助到大家。本案例在实施过程中，威哥力求简单明了，希望大家在学习过程中能够掌握其中的每个细节。好了，废话不多说，如果我们要学习seata，首先需要具备如下技术储备：数据库事务的基本知识；maven工具的使用；熟悉SpringCloudAlibaba技术栈；掌握SpringDataJPA简单使用；一.Seata基本概念1.seata是什么Seata是阿里
springcloud项目实战家教信息平台系统的设计与实现-微服务-分布式 Python大数据爬虫项目辅导 Java项目 spring cloud 微服务分布式
专业毕设定制，上千套成品任选，所有项目包含开题、答辩PPT、lunwen文末获取源码联系感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人计算机毕设项目java毕业设计源码定做论文定制springcloud的家教信息平台系统_哔哩哔哩_bilibiliIT实战课堂-项目资料网址:www.itszkt.com软件下载地址:https://www
面试Spring Cloud 问了我35个问题，全部分享出来！套马杆的程序员
❝对于目前来说，微服务已经是程序员必会的技能之一了。SpringCloud作为一个优质的微服务框架，已经被很多公司使用。以下小编给大家整理35道SpringCloud的知识点，或者说是面试题都不冲突。后续还会继续更新⛽️❞1.什么是SpringCloud?SpringCloud为开发人员提供了工具，以快速构建分布式系统中的一些常见模式（例如，配置管理，服务发现，断路器，智能路由，微代理，控制总线，
Spring Cloud Gateway：现代微服务架构中的API网关解决方案鹿又笑架构微服务 spring cloud gateway
引言在微服务架构中，API网关作为客户端与后端服务之间的中介，承担着请求路由、负载均衡、认证授权等重要职责。SpringCloudGateway是Spring生态系统中的一款强大且灵活的API网关解决方案，本文将深入探讨其工作原理、核心功能及应用场景。什么是SpringCloudGateway？SpringCloudGateway是SpringCloud项目的一部分，旨在为微服务架构提供高效的AP
eureka核心操作解析：集群间数据同步、自我保护、三级缓存 dejavu111 eureka java
1.什么是注册中心？Eureka是springcloud中的一个负责服务注册与发现的组件。遵循着CAP理论中的A(可用性)P(分区容错性)。一个Eureka中分为eurekaserver和eurekaclient。其中eurekaserver是作为服务的注册与发现中心。eurekaclient既可以作为服务的生产者，又可以作为服务的消费者。具体结构如下图：Eureka是一个基于REST（表述性状态
庖丁解java(一篇文章学java) 庖丁解java java 开发语言
(大家不用收藏这篇文章,因为这篇文章会经常更新,也就是删除后重发)一篇文章学java,这是我滴一个执念...当然,真一篇文章就写完java基础,java架构,java业务实现,java业务扩展,根本不可能.所以,这篇文章,就是一个索引,索什么呢?请看下文.关于决定开始写博文的介绍(一切故事的起点源于这一次反省)中小技术公司的软扩展(微服务扩展是否有必要?)-CSDN博客SpringCloud(一个
【脚手架第一篇章】介绍一下若依微服务版框架蜗牛 | ICU 脚手架专栏微服务架构云原生
若依框架（RuoYi）是一个广泛使用的开源框架，它提供了多种版本以满足不同开发需求。以下是关于若依框架微服务版（RuoYi-Cloud）的详细介绍：一、概述RuoYi-Cloud是基于SpringCloud和SpringBoot的分布式微服务架构平台，专为构建大型分布式系统提供完整的解决方案。它集成了众多微服务特性，如服务发现、配置管理、负载均衡等，适合需要高可扩展性和高可用性的企业级应用。二、技
Spring Cloud Alibaba(5)---Nacos(配置中心） Java代码狗 java spring spring boot 大数据 linux
有关SpringCloudAlibaba之前写过四篇文章，这篇也是在上面项目的基础上进行开发。SpringCloudAlibaba(1)---入门篇SpringCloudAlibaba(2)---RestTemplate微服务项目SpringCloudAlibaba(3)---Nacos概述SpringCloudAlibaba(4)---Nacos(注册中心）前言有关Nacos客户端的搭建和Nac
SpringCloud基于Eureka的服务治理架构搭建与测试：从服务提供者到消费者的完整流程... 暴力小萝莉 spring cloud eureka 架构 spring 后端
SpringCloud微服务框架中的Eureka是一个用于服务发现和注册的基础组件，它基于RESTful风格，为微服务架构提供了关键的服务注册与发现功能。以下是对Eureka的详细解析和搭建举例。一.Eureka基础知识（1）服务治理服务治理是微服务架构中最为核心和基础的模块，主要负责实现各个微服务实例的自动化注册与发现。服务治理能够管理服务之间的依赖关系，实现服务调用、负载均衡、容错等功能。Eu
编程模型咔啡
本节介绍SpringCloudStream的编程模型。SpringCloudStream提供了许多预定义的注释，用于声明绑定的输入和输出通道，以及如何收听频道。声明和绑定频道触发绑定@EnableBinding您可以将Spring应用程序转换为SpringCloudStream应用程序，将@EnableBinding注释应用于应用程序的配置类之一。@EnableBinding注释本身使用@Conf
项目架构设计先熬半个月
架构概述：架构共分为5层，访问层，接入层，网关层，服务层，数据层服务架构涉及26个技术点，部署架构7个技术点服务架构1.LVS：四层负载均衡，将用户分发到不同Nginx服务器上2.Nginx:是一个高性能的HTTP和反向代理的web服务器，用于部署前端应用3.Keepalived:高可用，此处指的是集群4.JWT:全称：JavaWebToken，用户身份校验，鉴权5.SpringCloudGetw
SpringCloud基于Eureka的服务治理架构搭建与测试：从服务提供者到消费者的完整流程招风的黑耳后端 eureka 微服务
SpringCloud微服务框架中的Eureka是一个用于服务发现和注册的基础组件，它基于RESTful风格，为微服务架构提供了关键的服务注册与发现功能。以下是对Eureka的详细解析和搭建举例。一.Eureka基础知识（1）服务治理服务治理是微服务架构中最为核心和基础的模块，主要负责实现各个微服务实例的自动化注册与发现。服务治理能够管理服务之间的依赖关系，实现服务调用、负载均衡、容错等功能。Eu
算法单链的创建与删除换个号韩国红果果 c 算法
先创建结构体 struct student { int data; //int tag;//标记这是第几个 struct student *next; }; // addone 用于将一个数插入已从小到大排好序的链中 struct student *addone(struct student *h,int x){ if(h==NULL) //??????
《大型网站系统与Java中间件实践》第2章读后感白糖_ java中间件
断断续续花了两天时间试读了《大型网站系统与Java中间件实践》的第2章，这章总述了从一个小型单机构建的网站发展到大型网站的演化过程---整个过程会遇到很多困难，但每一个屏障都会有解决方案，最终就是依靠这些个解决方案汇聚到一起组成了一个健壮稳定高效的大型系统。看完整章内容，
zeus持久层spring事务单元测试 deng520159 java DAO spring jdbc
今天把zeus事务单元测试放出来,让大家指出他的毛病, 1.ZeusTransactionTest.java 单元测试 package com.dengliang.zeus.webdemo.test; import java.util.ArrayList; import java.util.List; import org.junit.Test; import
Rss 订阅开发周凡杨 html xml 订阅 rss 规范
RSS是 Really Simple Syndication的缩写（对rss2.0而言，是这三个词的缩写，对rss1.0而言则是RDF Site Summary的缩写，1.0与2.0走的是两个体系）。 RSS
分页查询实现 g21121 分页查询
在查询列表时我们常常会用到分页，分页的好处就是减少数据交换，每次查询一定数量减少数据库压力等等。按实现形式分前台分页和服务器分页：前台分页就是一次查询出所有记录，在页面中用js进行虚拟分页，这种形式在数据量较小时优势比较明显，一次加载就不必再访问服务器了，但当数据量较大时会对页面造成压力，传输速度也会大幅下降。服务器分页就是每次请求相同数量记录，按一定规则排序，每次取一定序号直接的数据
spring jms异步消息处理 510888780 jms
spring JMS对于异步消息处理基本上只需配置下就能进行高效的处理。其核心就是消息侦听器容器，常用的类就是DefaultMessageListenerContainer。该容器可配置侦听器的并发数量，以及配合MessageListenerAdapter使用消息驱动POJO进行消息处理。且消息驱动POJO是放入TaskExecutor中进行处理，进一步提高性能，减少侦听器的阻塞。具体配置如下：
highCharts柱状图布衣凌宇 hightCharts 柱图
第一步：导入 exporting.js,grid.js,highcharts.js;第二步：写controller @Controller@RequestMapping(value="${adminPath}/statistick")public class StatistickController { private UserServi
我的spring学习笔记2-IoC（反向控制依赖注入） aijuans spring mvc Spring 教程 spring3 教程 Spring 入门
IoC（反向控制依赖注入）这是Spring提出来了，这也是Spring一大特色。这里我不用多说，我们看Spring教程就可以了解。当然我们不用Spring也可以用IoC，下面我将介绍不用Spring的IoC。 IoC不是框架，她是java的技术，如今大多数轻量级的容器都会用到IoC技术。这里我就用一个例子来说明：如：程序中有 Mysql.calss 、Oracle.class 、SqlSe
TLS java简单实现 antlove java ssl keystore tls secure
1. SSLServer.java package ssl; import java.io.FileInputStream; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; import java.security.KeyStore; import
Zip解压压缩文件百合不是茶 Zip格式解压 Zip流的使用文件解压
ZIP文件的解压缩实质上就是从输入流中读取数据。Java.util.zip包提供了类ZipInputStream来读取ZIP文件,下面的代码段创建了一个输入流来读取ZIP格式的文件; ZipInputStream in = new ZipInputStream(new FileInputStream(zipFileName)); &n
underscore.js 学习（一） bijian1013 JavaScript underscore
工作中需要用到underscore.js，发现这是一个包括了很多基本功能函数的js库，里面有很多实用的函数。而且它没有扩展 javascript的原生对象。主要涉及对Collection、Object、Array、Function的操作。学
java jvm常用命令工具——jstatd命令(Java Statistics Monitoring Daemon) bijian1013 java jvm jstatd
1.介绍 jstatd是一个基于RMI（Remove Method Invocation）的服务程序，它用于监控基于HotSpot的JVM中资源的创建及销毁，并且提供了一个远程接口允许远程的监控工具连接到本地的JVM执行命令。 jstatd是基于RMI的，所以在运行jstatd的服务
【Spring框架三】Spring常用注解之Transactional bit1129 transactional
Spring可以通过注解@Transactional来为业务逻辑层的方法(调用DAO完成持久化动作)添加事务能力，如下是@Transactional注解的定义： /* * Copyright 2002-2010 the original author or authors. * * Licensed under the Apache License, Version
我(程序员)的前进方向 bitray 程序员
作为一个普通的程序员,我一直游走在java语言中,java也确实让我有了很多的体会.不过随着学习的深入,java语言的新技术产生的越来越多,从最初期的javase,我逐渐开始转变到ssh,ssi,这种主流的码农,.过了几天为了解决新问题,webservice的大旗也被我祭出来了,又过了些日子jms架构的activemq也开始必须学习了.再后来开始了一系列技术学习,osgi,restful.....
nginx lua开发经验总结 ronin47
使用nginx lua已经两三个月了，项目接开发完毕了，这几天准备上线并且跟高德地图对接。回顾下来lua在项目中占得必中还是比较大的，跟PHP的占比差不多持平了，因此在开发中遇到一些问题备忘一下 1：content_by_lua中代码容量有限制，一般不要写太多代码，正常编写代码一般在100行左右（具体容量没有细心测哈哈，在4kb左右），如果超出了则重启nginx的时候会报 too long pa
java-66-用递归颠倒一个栈。例如输入栈{1,2,3,4,5}，1在栈顶。颠倒之后的栈为{5,4,3,2,1}，5处在栈顶 bylijinnan java
import java.util.Stack; public class ReverseStackRecursive { /** * Q 66.颠倒栈。 * 题目：用递归颠倒一个栈。例如输入栈{1,2,3,4,5}，1在栈顶。 * 颠倒之后的栈为{5,4,3,2,1}，5处在栈顶。 *1. Pop the top element *2. Revers
正确理解Linux内存占用过高的问题 cfyme linux
Linux开机后，使用top命令查看，4G物理内存发现已使用的多大3.2G，占用率高达80%以上： Mem: 3889836k total, 3341868k used, 547968k free, 286044k buffers Swap: 6127608k total,&nb
[JWFD开源工作流]当前流程引擎设计的一个急需解决的问题 comsci 工作流
当我们的流程引擎进入IRC阶段的时候，当循环反馈模型出现之后，每次循环都会导致一大堆节点内存数据残留在系统内存中，循环的次数越多，这些残留数据将导致系统内存溢出，并使得引擎崩溃。。。。。。而解决办法就是利用汇编语言或者其它系统编程语言，在引擎运行时，把这些残留数据清除掉。
自定义类的equals函数 dai_lm equals
仅作笔记使用 public class VectorQueue { private final Vector<VectorItem> queue; private class VectorItem { private final Object item; private final int quantity; public VectorI
Linux下安装R语言 datageek R语言 linux
命令如下：sudo gedit /etc/apt/sources.list1、deb http://mirrors.ustc.edu.cn/CRAN/bin/linux/ubuntu/ precise/ 2、deb http://dk.archive.ubuntu.com/ubuntu hardy universesudo apt-key adv --keyserver ke
如何修改mysql 并发数(连接数)最大值 dcj3sjt126com mysql
MySQL的连接数最大值跟MySQL没关系，主要看系统和业务逻辑了方法一：进入MYSQL安装目录打开MYSQL配置文件 my.ini 或 my.cnf查找 max_connections=100 修改为 max_connections=1000 服务里重起MYSQL即可　　方法二：MySQL的最大连接数默认是100客户端登录：mysql -uusername -ppass
单一功能原则 dcj3sjt126com 面向对象的程序设计软件设计编程原则
单一功能原则[ 编辑] SOLID 原则单一功能原则开闭原则 Liskov代换原则接口隔离原则依赖反转原则查论编在面向对象编程领域中，单一功能原则（Single responsibility principle）规定每个类都应该有
POJO、VO和JavaBean区别和联系 fanmingxing VO POJO javabean
POJO和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Plain Old Java Object，中文可以翻译成：普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO，但是JavaBean则比POJO复杂很多，JavaBean是一种组件技术，就好像你做了一个扳子，而这个扳子会在很多地方被
SpringSecurity3.X--LDAP：AD配置 hanqunfeng SpringSecurity
前面介绍过基于本地数据库验证的方式，参考http://hanqunfeng.iteye.com/blog/1155226，这里说一下如何修改为使用AD进行身份验证【只对用户名和密码进行验证，权限依旧存储在本地数据库中】。将配置文件中的如下部分删除：
mac mysql 修改密码 IXHONG mysql
$ sudo /usr/local/mysql/bin/mysqld_safe –user=root & //启动MySQL(也可以通过偏好设置面板来启动)$ sudo /usr/local/mysql/bin/mysqladmin -uroot password yourpassword //设置MySQL密码（注意，这是第一次MySQL密码为空的时候的设置命令，如果是修改密码，还需在-
设计模式--抽象工厂模式 kerryg 设计模式
抽象工厂模式：工厂模式有一个问题就是，类的创建依赖于工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则。我们采用抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。总结：这个模式的好处就是，如果想增加一个功能，就需要做一个实现类，
评"高中女生军训期跳楼” nannan408
首先，先抛出我的观点，各位看官少点砖头。那就是，中国的差异化教育必须做起来。孔圣人有云：有教无类。不同类型的人，都应该有对应的教育方法。目前中国的一体化教育，不知道已经扼杀了多少创造性人才。我们出不了爱迪生，出不了爱因斯坦，很大原因，是我们的培养思路错了，我们是第一要“顺从”。如果不顺从，我们的学校，就会用各种方法，罚站，罚写作业，各种罚。军
scala如何读取和写入文件内容？ qindongliang1922 java jvm scala
直接看如下代码： package file import java.io.RandomAccessFile import java.nio.charset.Charset import scala.io.Source import scala.reflect.io.{File, Path} /** * Created by qindongliang on 2015/
C语言算法之百元买百鸡 qiufeihu c 算法
中国古代数学家张丘建在他的《算经》中提出了一个著名的“百钱买百鸡问题”，鸡翁一，值钱五，鸡母一，值钱三，鸡雏三，值钱一，百钱买百鸡，问翁，母，雏各几何？代码如下： #include <stdio.h> int main() { int cock,hen,chick; /*定义变量为基本整型*/ for(coc
Hadoop集群安全性：Hadoop中Namenode单点故障的解决方案及详细介绍AvatarNode wyz2009107220 NameNode
正如大家所知，NameNode在Hadoop系统中存在单点故障问题，这个对于标榜高可用性的Hadoop来说一直是个软肋。本文讨论一下为了解决这个问题而存在的几个solution。 1. Secondary NameNode 原理：Secondary NN会定期的从NN中读取editlog，与自己存储的Image进行合并形成新的metadata image 优点：Hadoop较早的版本都自带，