spring-cloud+ nacos+feign 增删改查（多表）

spring-cloud+ nacos+feign 增删改查（多表）环境准备

数据库
学生自行创建数据库，根据提供的sql创建表和数据,每个表单独一个数据库
后台
学生自行搭建SpringCloud+Feign+Nacos+GateWay+MyBatis后台环境
前台
学生自行创建前台vue环境，实现测试要求

后端：以book和category为例如图所示：book 是主，category是从

book.pom文件和category.pom文件

    
        8
        8
    
    
         
        
            book-parent
            feign-api
            1.0-SNAPSHOT
        
        
        
            com.alibaba.cloud
            spring-cloud-starter-alibaba-nacos-discovery
        
        
        
            tk.mybatis
            mapper-spring-boot-starter
        
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            mysql
            mysql-connector-java
        
        
        
            org.mybatis.spring.boot
            mybatis-spring-boot-starter
        
        
        
            com.alibaba.cloud
            spring-cloud-starter-alibaba-nacos-config
        
    
    
        app
        
            
                org.springframework.boot
                spring-boot-maven-plugin

feign（远程调用）和getaway（网关）

红色的不用写那是过滤器

feign 和getaway的pom文件

 
        8
        8
    

    

        
            com.alibaba.cloud
            spring-cloud-alibaba-dependencies
            2.2.6.RELEASE
            pom
            import
        

        
        
            org.springframework.cloud
            spring-cloud-starter-openfeign
            2.2.6.RELEASE
        

        
        
            com.alibaba.cloud
            spring-cloud-starter-alibaba-nacos-discovery
        

        
        
            org.mybatis.spring.boot
            mybatis-spring-boot-starter
        
        
        
            tk.mybatis
            mapper-spring-boot-starter
        

        
            com.github.pagehelper
            pagehelper-spring-boot-starter
            1.2.5

getaway·：内容

   
    
    
    
        org.springframework.cloud
        spring-cloud-starter-gateway
        2.2.6.RELEASE
    
    
    
        com.alibaba.cloud
        spring-cloud-starter-alibaba-nacos-discovery
        2.2.6.RELEASE

父类（项目类）

    
        org.springframework.boot
        spring-boot-starter-parent
        2.3.9.RELEASE
        
    

    
        8
        8
        UTF-8
        UTF-8
        1.8
        Hoxton.SR10
        8.0.27
        2.1.1
        2.0.2
    

    
        
            
            
                com.alibaba.cloud
                spring-cloud-alibaba-dependencies
                2.2.6.RELEASE
                pom
                import
            
            
            
                mysql
                mysql-connector-java
                ${mysql.version}
            
            
            
                org.mybatis.spring.boot
                mybatis-spring-boot-starter
                ${mybatis.version}
            
            
            
                tk.mybatis
                mapper-spring-boot-starter
                ${mapper.starter.version}
            
        
    
    
        
            org.projectlombok
            lombok

创建数据库：一个表一个数据库

好了环境准备，已经做完了下面就是写代码了

BookController.java

package com.czxy.controller;

import com.czxy.Vo.BookVo;
import com.czxy.domain.Book;
import com.czxy.service.BookService;
import com.github.pagehelper.PageInfo;
import org.springframework.web.bind.annotation.*;

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

@RestController
@RequestMapping("/book")
public class BookController {

    @Resource
    private BookService bookService;

    @GetMapping
    public List findSchoolAll(){
        List list = bookService.findSchoolAll();
        return list;
    }
    @GetMapping("/{id}")
    public Book findSchoolById(@PathVariable("id") Integer id){
        Book book = bookService.findSchoolById(id);
        return book;
    }

    @PutMapping
    Integer Up(@RequestBody Book book){
        Integer up = bookService.Up(book);
        return up;
    }
    @PostMapping("/{pageNum}/{pageSize}")
    PageInfo pageIn(
            @PathVariable Integer pageNum,
            @PathVariable Integer pageSize,
            @RequestBody BookVo bookVo
    ){
        PageInfo bookPageInfo = bookService.pageIn(pageNum, pageSize, bookVo);
        return bookPageInfo;
    }


    @PostMapping
    Integer insert(@RequestBody Book book){
        Integer insert = bookService.insert(book);
        return insert;
    }


    @DeleteMapping("/{id}")
    Integer daleTe(@PathVariable("id") Integer id){
        Integer daleTe = bookService.daleTe(id);
        return daleTe;
    }

    @DeleteMapping("/batchDelete/{ids}")
    void daleAll(@PathVariable("ids") String ids){
        bookService.daleAll(ids);
    }

}

BookMapper.java

package com.czxy.dao;

import com.czxy.domain.Book;
import com.czxy.domain.Category;
import tk.mybatis.mapper.common.Mapper;

@org.apache.ibatis.annotations.Mapper
public interface BookMapper extends Mapper {
}

bookservice.java

package com.czxy.service;

import com.czxy.Vo.BookVo;
import com.czxy.dao.BookMapper;
import com.czxy.domain.Book;
import com.czxy.domain.Category;
import com.czxy.feign.BookFeign;
import com.czxy.feign.CategoryClient;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import tk.mybatis.mapper.entity.Example;

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

@Service
@Transactional
public class BookService implements BookFeign {

    @Resource
    private BookMapper bookMapper;

    @Resource
    private CategoryClient categoryClient;
    @Override
    public List findSchoolAll() {
        List list = bookMapper.selectAll();
        for (Book book : list) {
            Category category = categoryClient.queryByTid(book.getCid());
            book.setCategory(category);
        }
        return list;
    }

    @Override
    public Book findSchoolById(Integer id) {
        Book book = bookMapper.selectByPrimaryKey(id);
        Category category = categoryClient.queryByTid(book.getCid());
        book.setCategory(category);
        return book;
    }

    @Override
    public Integer Up(Book book) {
        int i = bookMapper.updateByPrimaryKey(book);
        return i;
    }

    @Override
    public Integer daleTe(Integer id) {
        int i = bookMapper.deleteByPrimaryKey(id);
        return i;
    }

    @Override
    public void daleAll(String ids) {
        String[] split = ids.split(",");
        for (String s : split) {
            bookMapper.deleteByPrimaryKey(s);
        }
    }

    @Override
    public PageInfo pageIn(Integer pageNum, Integer pageSize, BookVo bookVo) {

        Example example = new Example(Book.class);

        Example.Criteria criteria = example.createCriteria();

        if (bookVo.getCid()!=null && !"".equals(bookVo.getCid())){
            criteria.andEqualTo("cid",bookVo.getCid());
        }

        if (bookVo.getName()!=null&& !"".equals(bookVo.getName())){
            criteria.andLike("name","%"+bookVo.getName()+"%");
        }
        if (bookVo.getStaPrice()!= null && !"".equals(bookVo.getStaPrice())){
            criteria.andGreaterThanOrEqualTo("price",bookVo.getStaPrice());
        }
        if (bookVo.getEntPrice()!= null && !"".equals(bookVo.getEntPrice())){
            criteria.andLessThanOrEqualTo("price",bookVo.getEntPrice());
        }

        PageHelper.startPage(pageNum,pageSize);

        List list = bookMapper.selectByExample(example);
        for (Book book : list) {
            Category category = categoryClient.queryByTid(book.getCid());
            book.setCategory(category);
        }


        return new PageInfo<>(list);
    }

    @Override
    public Integer insert(Book book) {
        int insert = bookMapper.insert(book);
        return insert;
    }

}

启动类：BookApplication

package com.czxy;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

@EnableFeignClients(basePackages = "com.czxy.feign")
@SpringBootApplication
public class BookApplication {
    public static void main(String[] args) {
        SpringApplication.run(BookApplication.class,args);
    }
}

B：application.yml

server:
  port: 8081
spring:
  application:
    name: bookservice
  datasource:
    url: jdbc:mysql://localhost:3306/cloud-book?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC&useSSL=false
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
  cloud:
    nacos:
      server-addr: localhost:8848 # Nacos地址
      config:
        file-extension: yaml # 文件后缀名
mybatis:
  type-aliases-package: com.czxy.domain
  configuration:
    map-underscore-to-camel-case: true
logging:
  level:
    cn.itcast: debug
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS
feign:
  client:
    config:
      default: # 这里用default就是全局配置，如果是写服务名称，则是针对某个微服务的配置
        loggerLevel: FULL #  日志级别

CategoryController.java

package com.czxy.controller;

import com.czxy.dao.CategoryMapper;
import com.czxy.domain.Book;
import com.czxy.domain.Category;
import com.czxy.service.CategoryService;
import org.springframework.web.bind.annotation.*;

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

@RestController
@RequestMapping("/category")
public class CategoryController {

    @Resource
    private CategoryService categoryService;



    @GetMapping
    List All(){
        List all = categoryService.All();
        return all;
    }

    @PostMapping
    Integer insert(@RequestBody Category category){
        return categoryService.insert(category);
    }

    @GetMapping("/{cid}")
    Category queryByTid(@PathVariable Integer cid){
        Category category = categoryService.queryByTid(cid);
        return category;
    }
    @PutMapping
    Integer Up(@RequestBody Category category){
        return categoryService.Up(category);
    }

    @DeleteMapping("/{cid}")
    Integer Up(@PathVariable("cid")  Integer cid){
        return categoryService.date(cid);
    }
}

CategoryService.java

package com.czxy.service;

import com.czxy.dao.CategoryMapper;
import com.czxy.domain.Category;
import com.czxy.feign.CategoryClient;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

@Service
@Transactional
public class CategoryService implements CategoryClient {

    @Resource
    private CategoryMapper categoryMapper;


    @Override
    public Category queryByTid(Integer cid) {
        Category category = categoryMapper.selectByPrimaryKey(cid);
        return category;
    }

    @Override
    public List All() {
        List categories = categoryMapper.selectAll();
        return categories;
    }

    @Override
    public Integer insert(Category category) {
        return categoryMapper.insert(category);
    }
    @Override
    public Integer Up(Category category) {
        return categoryMapper.updateByPrimaryKey(category);
    }
    @Override
    public Integer date(Integer cid) {
        return categoryMapper.deleteByPrimaryKey(cid);
    }
}

CategoryMapper.java

package com.czxy.dao;

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

@org.apache.ibatis.annotations.Mapper
public interface CategoryMapper extends Mapper {
}

CategoryApplication.java

package com.czxy;

import org.springframework.boot.SpringApplication;
        import org.springframework.boot.autoconfigure.SpringBootApplication;
        import org.springframework.cloud.openfeign.EnableFeignClients;

@EnableFeignClients(basePackages = "com.czxy.feign")
@SpringBootApplication
public class CategoryApplication {
    public static void main(String[] args) {
        SpringApplication.run(CategoryApplication.class,args);
    }
}

C：application.yml

server:
  port: 8082
spring:
  application:
    name: categoryservice
  datasource:
    url: jdbc:mysql://localhost:3306/cloud-category?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC&useSSL=false
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
  cloud:
    nacos:
      server-addr: localhost:8848 # Nacos地址
      config:
        file-extension: yaml # 文件后缀名
mybatis:
  type-aliases-package: com.czxy.domain
  configuration:
    map-underscore-to-camel-case: true
logging:
  level:
    cn.itcast: debug
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS
feign:
  client:
    config:
      default: # 这里用default就是全局配置，如果是写服务名称，则是针对某个微服务的配置
        loggerLevel: FULL #  日志级别

在feign中创建实体类：book

在feign中创建实体类：category

BookFeign.java

package com.czxy.feign;

import com.czxy.Vo.BookVo;
import com.czxy.domain.Book;
import com.github.pagehelper.PageInfo;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.*;

import java.util.List;

//微服务的地址
@FeignClient(value="bookservice")
public interface BookFeign {
    //todo 查询所有
    @GetMapping("/book")
    public List findSchoolAll();

    //todo 分页查询+ 模糊查询
    @PostMapping("/book/{pageNum}/{pageSize}")
    PageInfopageIn(
            @PathVariable Integer pageNum,
            @PathVariable Integer pageSize,
            @RequestBody  BookVo bookVo
            );

    //todo 添加
    @PostMapping("/book")
    Integer insert(@RequestBody Book book);

    //todo 根据id 查询
    @GetMapping("/book/{id}")
    public Book findSchoolById(@PathVariable("id") Integer id);

    //todo 修改
    @PutMapping("/book")
    Integer Up(@RequestBody Book book);

    //todo 删除
    @DeleteMapping("/book/{id}")
    Integer daleTe(@PathVariable("id") Integer id);

    //todo 批量删除
    @DeleteMapping("/book/batchDelete/{ids}")
    void daleAll(@PathVariable("ids") String ids);

}

CategoryClient.java

package com.czxy.feign;

import com.czxy.domain.Category;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.*;

import java.util.List;

//微服务的地址
@FeignClient(value = "categoryservice")
public interface CategoryClient {

    //todo 根据id 查询
    @GetMapping("/category/{cid}")
    Category queryByTid(@PathVariable Integer cid);

    //todo 查询所有
    @GetMapping("/category")
    List All();

    //todo 添加
    @PostMapping("/category")
    Integer insert(@RequestBody Category category);

    //todo 修改
    @PutMapping("/category")
    Integer Up(@RequestBody Category category);

    //todo 删除
    @DeleteMapping("/category/{cid}")
    Integer date(@PathVariable Integer cid);
}

分页所需要的Vo类

getaway的启动类

G：application.yml

server:
  port: 10010 # 网关端口
spring:
  application:
    name: gateway # 服务名称
  cloud:
    nacos:
      server-addr: localhost:8848 # Nacos地址
    gateway:
      routes: # 网关路由配置
        - id: book-service # 路由id，自定义，只要唯一即可
            # uri: http://127.0.0.1:8082 # 路由的目标地址 http就是固定地址
          uri: lb://bookservice/ # 路由的目标地址 lb就是负载均衡，后面跟服务名称
          predicates: # 路由断言，也就是判断请求是否符合路由规则的条件
            - Path=/book/** # 这个是按照路径匹配，只要以/user/开头就符合要求
        - id: category-service # 路由id，自定义，只要唯一即可
                  # uri: http://127.0.0.1:8082 # 路由的目标地址 http就是固定地址
          uri: lb://categoryservice/ # 路由的目标地址 lb就是负载均衡，后面跟服务名称
          predicates: # 路由断言，也就是判断请求是否符合路由规则的条件
          - Path=/category/** # 这个是按照路径匹配，只要以/user/开头就符合要求
      # 网关解决跨域
      globalcors: # 全局的跨域处理
        add-to-simple-url-handler-mapping: true # 解决options请求被拦截问题
        corsConfigurations:
          '[/**]':
            allowedOrigins: # 允许哪些网站的跨域请求
              - "http://localhost:8080"
            allowedMethods: # 允许的跨域ajax的请求方式
              - "GET"
              - "POST"
              - "DELETE"
              - "PUT"
              - "OPTIONS"
            allowedHeaders: "*" # 允许在请求中携带的头信息
            allowCredentials: true # 是否允许携带cookie
            maxAge: 360000 # 这次跨域检测的有效期

spring-cloud+ nacos+feign 增删改查（多表）

Java相关栏目本月热门文章