1. day01 项目搭建

2. 前后端分离

01. day01 项目搭建 - 图1

3. 技术架构

01. day01 项目搭建 - 图2

4. 系统架构

01. day01 项目搭建 - 图3

5. 项目分层

01. day01 项目搭建 - 图4

changgou_gateway

  1. 网关模块，根据网站的规模和需要，可以将综合逻辑相关的服务用网关路由组合到一起。在这里还可以做鉴权和限流相关操作。

changgou_service

  1. 微服务模块，该模块用于存放所有独立的微服务工程。

changgou_service_api

  1. 对应工程的JavaBean、Feign、以及Hystrix配置，该工程主要对外提供依赖。

changgou_transaction_fescar

  1. 分布式事务模块，将分布式事务抽取到该工程中，任何工程如需要使用分布式事务，只需依赖该工程即可。

changgou_web

  1. web服务工程，对应功能模块如需要调用多个微服务，可以将他们写入到该模块中，例如网站后台、网站前台等

6. 项目搭建

6.1. 一级父工程搭建

创建父工程 changgou_parent 修改pom文件 并删除src目录

此项目工程为父工程 无需编写编码

  1. <parent>
  2.         <groupId>org.springframework.boot</groupId>
  3.         <artifactId>spring-boot-starter-parent</artifactId>
  4.         <version>2.1.4.RELEASE</version>
  5.     </parent>
  7.     <properties>
  8.         <skipTests>true</skipTests>
  9.     </properties>
  11.     <!--依赖包-->
  12.     <dependencies>
  13.         <!--测试包-->
  14.         <dependency>
  15.             <groupId>org.springframework.boot</groupId>
  16.             <artifactId>spring-boot-starter-test</artifactId>
  17.             <scope>test</scope>
  18.         </dependency>
  19.     </dependencies>
  21.     <dependencyManagement>
  22.         <dependencies>
  23.             <dependency>
  24.                 <groupId>org.springframework.cloud</groupId>
  25.                 <artifactId>spring-cloud-dependencies</artifactId>
  26.                 <version>Greenwich.SR1</version>
  27.                 <type>pom</type>
  28.                 <scope>import</scope>
  29.             </dependency>
  30.         </dependencies>
  31.     </dependencyManagement>

6.2. 创建二级父工程项目

依次创建各个二级父工程 并删除项目中的src目录

  • changgou_gateway
  • changgou_service
  • changgou_service_api
  • changgou_transaction_fescar
  • changgou_web

6.3. Eureka微服务搭建

创建二级父工程 changgou_eureka 并编辑pom

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.springframework.cloud</groupId>
  4.         <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
  5.     </dependency>
  6. </dependencies>
  • 创建启动类并注解开启eurekasever
  1. package com.changgou.eureka;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
  7. @SpringBootApplication
  8. @EnableEurekaServer  //声明为eureka注册中心 服务端
  9. public class EurekaApplication {
  10.     public static void main(String[] args) {
  11.         SpringApplication.run(EurekaApplication.class, args);
  12.     }
  13. }
  • application 配置文件
  1. server:
  2.   port: 6868
  3. eureka:
  4.   client:
  5.     register-with-eureka: false #是否将自己注册到eureka中
  6.     fetch-registry: false #是否从eureka中获取信息
  7.     service-url:
  8.       defaultZone: http://127.0.0.1:${server.port}/eureka/

测试启动 运行启动类

访问http://localhost:6868/

6.4. 全局公共模块

创建子模块changgou_common pom引入模块

  1. <dependencies>
  2.     <!--web起步依赖-->
  3.     <dependency>
  4.         <groupId>org.springframework.boot</groupId>
  5.         <artifactId>spring-boot-starter-web</artifactId>
  6.     </dependency>
  7.     <!-- redis 使用-->
  8.     <dependency>
  9.         <groupId>org.springframework.boot</groupId>
  10.         <artifactId>spring-boot-starter-data-redis</artifactId>
  11.     </dependency>
  12.     <dependency>
  13.         <groupId>com.alibaba</groupId>
  14.         <artifactId>fastjson</artifactId>
  15.         <version>1.2.51</version>
  16.     </dependency>
  17.     <dependency>
  18.         <groupId>org.springframework.cloud</groupId>
  19.         <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  20.     </dependency>
  21.     <dependency>
  22.         <groupId>org.springframework.cloud</groupId>
  23.         <artifactId>spring-cloud-starter-openfeign</artifactId>
  24.     </dependency>
  25. </dependencies>

创建常用对象 分页pojo 页面返回对象 返回结果对象 状态码

在com.changgou.common.pojo下创建

page

  1. package com.changgou.common.pojo;
  3. import java.io.Serializable;
  4. import java.util.List;
  6. /**
  7.  * 分页对象
  8.  * @param <T>
  9.  */
  10. public class Page <T> implements Serializable{
  12.     //当前默认为第一页
  13.     public static final Integer pageNum = 1;
  14.     //默认每页显示条件
  15.     public static final Integer pageSize = 20;
  18.     //判断当前页是否为空或是小于1
  19.     public static Integer cpn(Integer pageNum){
  20.         if(null == pageNum || pageNum < 1){
  21.             pageNum = 1;
  22.         }
  23.         return pageNum;
  24.     }
  27.     // 页数（第几页）
  28.     private long currentpage;
  30.     // 查询数据库里面对应的数据有多少条
  31.     private long total;// 从数据库查处的总记录数
  33.     // 每页查5条
  34.     private int size;
  36.     // 下页
  37.     private int next;
  39.     private List<T> list;
  41.     // 最后一页
  42.     private int last;
  44.     private int lpage;
  46.     private int rpage;
  48.     //从哪条开始查
  49.     private long start;
  51.     //全局偏移量
  52.     public int offsize = 2;
  54.     public Page() {
  55.         super();
  56.     }
  58.     /****
  59.      *
  60.      * @param currentpage
  61.      * @param total
  62.      * @param pagesize
  63.      */
  64.     public void setCurrentpage(long currentpage,long total,long pagesize) {
  65.         //可以整除的情况下
  66.         long pagecount =  total/pagesize;
  68.         //如果整除表示正好分N页，如果不能整除在N页的基础上+1页
  69.         int totalPages = (int) (total%pagesize==0? total/pagesize : (total/pagesize)+1);
  71.         //总页数
  72.         this.last = totalPages;
  74.         //判断当前页是否越界,如果越界，我们就查最后一页
  75.         if(currentpage>totalPages){
  76.             this.currentpage = totalPages;
  77.         }else{
  78.             this.currentpage=currentpage;
  79.         }
  81.         //计算start
  82.         this.start = (this.currentpage-1)*pagesize;
  83.     }
  85.     //上一页
  86.     public long getUpper() {
  87.         return currentpage>1? currentpage-1: currentpage;
  88.     }
  90.     //总共有多少页，即末页
  91.     public void setLast(int last) {
  92.         this.last = (int) (total%size==0? total/size : (total/size)+1);
  93.     }
  95.     /****
  96.      * 带有偏移量设置的分页
  97.      * @param total
  98.      * @param currentpage
  99.      * @param pagesize
  100.      * @param offsize
  101.      */
  102.     public Page(long total,int currentpage,int pagesize,int offsize) {
  103.         this.offsize = offsize;
  104.         initPage(total, currentpage, pagesize);
  105.     }
  107.     /****
  108.      *
  109.      * @param total   总记录数
  110.      * @param currentpage    当前页
  111.      * @param pagesize    每页显示多少条
  112.      */
  113.     public Page(long total,int currentpage,int pagesize) {
  114.         initPage(total,currentpage,pagesize);
  115.     }
  117.     /****
  118.      * 初始化分页
  119.      * @param total
  120.      * @param currentpage
  121.      * @param pagesize
  122.      */
  123.     public void initPage(long total,int currentpage,int pagesize){
  124.         //总记录数
  125.         this.total = total;
  126.         //每页显示多少条
  127.         this.size=pagesize;
  129.         //计算当前页和数据库查询起始值以及总页数
  130.         setCurrentpage(currentpage, total, pagesize);
  132.         //分页计算
  133.         int leftcount =this.offsize,    //需要向上一页执行多少次
  134.                 rightcount =this.offsize;
  136.         //起点页
  137.         this.lpage =currentpage;
  138.         //结束页
  139.         this.rpage =currentpage;
  141.         //2点判断
  142.         this.lpage = currentpage-leftcount;            //正常情况下的起点
  143.         this.rpage = currentpage+rightcount;        //正常情况下的终点
  145.         //页差=总页数和结束页的差
  146.         int topdiv = this.last-rpage;                //判断是否大于最大页数
  148.         /***
  149.          * 起点页
  150.          * 1、页差<0  起点页=起点页+页差值
  151.          * 2、页差>=0 起点和终点判断
  152.          */
  153.         this.lpage=topdiv<0? this.lpage+topdiv:this.lpage;
  155.         /***
  156.          * 结束页
  157.          * 1、起点页<=0   结束页=|起点页|+1
  158.          * 2、起点页>0    结束页
  159.          */
  160.         this.rpage=this.lpage<=0? this.rpage+(this.lpage*-1)+1: this.rpage;
  162.         /***
  163.          * 当起点页<=0  让起点页为第一页
  164.          * 否则不管
  165.          */
  166.         this.lpage=this.lpage<=0? 1:this.lpage;
  168.         /***
  169.          * 如果结束页>总页数   结束页=总页数
  170.          * 否则不管
  171.          */
  172.         this.rpage=this.rpage>last? this.last:this.rpage;
  173.     }
  175.     public long getNext() {
  176.         return  currentpage<last? currentpage+1: last;
  177.     }
  179.     public void setNext(int next) {
  180.         this.next = next;
  181.     }
  183.     public long getCurrentpage() {
  184.         return currentpage;
  185.     }
  187.     public long getTotal() {
  188.         return total;
  189.     }
  191.     public void setTotal(long total) {
  192.         this.total = total;
  193.     }
  195.     public long getSize() {
  196.         return size;
  197.     }
  199.     public void setSize(int size) {
  200.         this.size = size;
  201.     }
  203.     public long getLast() {
  204.         return last;
  205.     }
  207.     public long getLpage() {
  208.         return lpage;
  209.     }
  211.     public void setLpage(int lpage) {
  212.         this.lpage = lpage;
  213.     }
  215.     public long getRpage() {
  216.         return rpage;
  217.     }
  219.     public void setRpage(int rpage) {
  220.         this.rpage = rpage;
  221.     }
  223.     public long getStart() {
  224.         return start;
  225.     }
  227.     public void setStart(long start) {
  228.         this.start = start;
  229.     }
  231.     public void setCurrentpage(long currentpage) {
  232.         this.currentpage = currentpage;
  233.     }
  235.     /**
  236.      * @return the list
  237.      */
  238.     public List<T> getList() {
  239.         return list;
  240.     }
  242.     /**
  243.      * @param list the list to set
  244.      */
  245.     public void setList(List<T> list) {
  246.         this.list = list;
  247.     }
  249.     public static void main(String[] args) {
  250.             //总记录数
  251.             //当前页
  252.             //每页显示多少条
  253.             int cpage =17;
  254.             Page page = new Page(1001,cpage,50,7);
  255.             System.out.println("开始页:"+page.getLpage()+"__当前页："+page.getCurrentpage()+"__结束页"+page.getRpage()+"____总页数："+page.getLast());
  256.     }
  257. }

PageResult

  1. package com.changgou.common.pojo;
  2. import java.util.List;
  3. public class PageResult<T> {
  5.     private Long total;//总记录数
  6.     private List<T> rows;//记录
  8.     public PageResult(Long total, List<T> rows) {
  9.         this.total = total;
  10.         this.rows = rows;
  11.     }
  13.     public PageResult() {
  14.     }
  16.     public Long getTotal() {
  17.         return total;
  18.     }
  20.     public void setTotal(Long total) {
  21.         this.total = total;
  22.     }
  24.     public List<T> getRows() {
  25.         return rows;
  26.     }
  28.     public void setRows(List<T> rows) {
  29.         this.rows = rows;
  30.     }
  31. }

Result

  1. package com.changgou.common.pojo;
  3. /**
  4.  * 返回结果实体类
  5.  */
  6. public class Result<T> {
  8.     private boolean flag;//是否成功
  9.     private Integer code;//返回码
  10.     private String message;//返回消息
  12.     private T data;//返回数据
  14.     public Result(boolean flag, Integer code, String message, Object data) {
  15.         this.flag = flag;
  16.         this.code = code;
  17.         this.message = message;
  18.         this.data = (T)data;
  19.     }
  21.     public Result(boolean flag, Integer code, String message) {
  22.         this.flag = flag;
  23.         this.code = code;
  24.         this.message = message;
  25.     }
  27.     public Result() {
  28.         this.flag = true;
  29.         this.code = StatusCode.OK;
  30.         this.message = "执行成功";
  31.     }
  33.     public boolean isFlag() {
  34.         return flag;
  35.     }
  37.     public void setFlag(boolean flag) {
  38.         this.flag = flag;
  39.     }
  41.     public Integer getCode() {
  42.         return code;
  43.     }
  45.     public void setCode(Integer code) {
  46.         this.code = code;
  47.     }
  49.     public String getMessage() {
  50.         return message;
  51.     }
  53.     public void setMessage(String message) {
  54.         this.message = message;
  55.     }
  57.     public T getData() {
  58.         return data;
  59.     }
  61.     public void setData(T data) {
  62.         this.data = data;
  63.     }
  64. }

StatusCode

  1. package com.changgou.common.pojo;
  3. /**
  4.  * 返回码
  5.  */
  6. public class StatusCode {
  8.     public static final int OK=20000;//成功
  9.     public static final int ERROR =20001;//失败
  10.     public static final int LOGINERROR =20002;//用户名或密码错误
  11.     public static final int ACCESSERROR =20003;//权限不足
  12.     public static final int REMOTEERROR =20004;//远程调用失败
  13.     public static final int REPERROR =20005;//重复操作
  15. }

6.5. 数据访问公共模块搭建

这个公共模块是连接mysql数据库的公共微服务模块，所以需要连接mysql的微服务都继承自此工程。

创建公共模块changgou_common_db，pom文件引入依赖

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>com.changgou</groupId>
  4.         <artifactId>changgou_common</artifactId>
  5.         <version>1.0-SNAPSHOT</version>
  6.     </dependency>
  7.     <!--通用mapper起步依赖-->
  8.     <dependency>
  9.         <groupId>tk.mybatis</groupId>
  10.         <artifactId>mapper-spring-boot-starter</artifactId>
  11.         <version>2.0.4</version>
  12.     </dependency>
  13.     <!--MySQL数据库驱动-->
  14.     <dependency>
  15.         <groupId>mysql</groupId>
  16.         <artifactId>mysql-connector-java</artifactId>
  17.     </dependency>
  18.     <!--mybatis分页插件-->
  19.     <dependency>
  20.         <groupId>com.github.pagehelper</groupId>
  21.         <artifactId>pagehelper-spring-boot-starter</artifactId>
  22.         <version>1.2.3</version>
  23.     </dependency>
  24. </dependencies>

6.6. 商品微服务API工程搭建

创建 changgou_service_api 模块

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.springframework.cloud</groupId>
  4.         <artifactId>spring-cloud-starter-openfeign</artifactId>
  5.         <scope>provided</scope>
  6.     </dependency>
  7.     <dependency>
  8.         <groupId>javax.persistence</groupId>
  9.         <artifactId>persistence-api</artifactId>
  10.         <version>1.0</version>
  11.         <scope>compile</scope>
  12.     </dependency>
  13. </dependencies>

6.6.1. 在api工程下创建goods_api子模块

changgou_service_api 下创建changgou_service_goods_api子模块并添加common依赖

  1.  <dependencies>
  2.         <dependency>
  3.             <groupId>com.changgou</groupId>
  4.             <artifactId>changgou_common</artifactId>
  5.             <version>1.0-SNAPSHOT</version>
  6.         </dependency>
  7.     </dependencies>

6.7. 微服务工程搭建

changgou_service下创建changgou_service_goods子模块

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>com.changgou</groupId>
  4.         <artifactId>changgou_common_db</artifactId>
  5.         <version>1.0-SNAPSHOT</version>
  6.     </dependency>
  7.     <dependency>
  8.         <groupId>com.changgou</groupId>
  9.         <artifactId>changgou_service_goods_api</artifactId>
  10.         <version>1.0-SNAPSHOT</version>
  11.     </dependency>
  12.     <dependency>
  13.         <groupId>org.springframework.cloud</groupId>
  14.         <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  15.     </dependency>
  16. </dependencies>

application.yml

  1. server:
  2.   port: 9011
  3. spring:
  4.   application:
  5.     name: goods
  6.   datasource:
  7.     driver-class-name: com.mysql.cj.jdbc.Driver
  8.     url: jdbc:mysql://192.168.130.128:3306/changgou_goods?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
  9.     username: root
  10.     password: root
  11. eureka:
  12.   client:
  13.     service-url:
  14.       defaultZone: http://127.0.0.1:6868/eureka
  15.   instance:
  16.     prefer-ip-address: true
  17. feign:
  18.   hystrix:
  19.     enabled: true
  21. #hystrix 配置
  22. hystrix:
  23.   command:
  24.     default:
  25.       execution:
  26.         timeout:
  27.           #如果enabled设置为false，则请求超时交给ribbon控制
  28.           enabled: true
  29.         isolation:
  30.           strategy: SEMAPHORE

创建启动类 并声明为eureka客户端 并开启mapper扫描

  1. package com.changgou.service.goods;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
  7. import tk.mybatis.spring.annotation.MapperScan;
  9. @SpringBootApplication
  10. @EnableEurekaClient  //声明为eureka客户端
  11. @MapperScan(basePackages = {"com.changgou.service.goods.dao"})  //扫描指定路径下的dao层接口
  12. public class GoodsApplication {
  13.     public static void main(String[] args) {
  14.         SpringApplication.run(GoodsApplication.class, args);
  15.     }
  16. }

7. 增删改查

  • 在changou_service_api中的changou_service_goods_api 用于放置 pojo

创建品牌的映射类

  1. package com.changgou.goods.pojo;
  3. import javax.persistence.Id;
  4. import javax.persistence.Table;
  5. import java.io.Serializable;
  7. @Table(name = "tb_brand")
  8. public class Brand implements Serializable {
  9.     @Id
  10.     private Integer id;//品牌id
  11.     private String name;//品牌名称
  12.     private String image;//品牌图片地址
  13.     private String letter;//品牌的首字母
  14.     private Integer seq;//排序
  16.     public Integer getId() {
  17.         return id;
  18.     }
  20.     public void setId(Integer id) {
  21.         this.id = id;
  22.     }
  24.     public String getName() {
  25.         return name;
  26.     }
  28.     public void setName(String name) {
  29.         this.name = name;
  30.     }
  32.     public String getImage() {
  33.         return image;
  34.     }
  36.     public void setImage(String image) {
  37.         this.image = image;
  38.     }
  40.     public String getLetter() {
  41.         return letter;
  42.     }
  44.     public void setLetter(String letter) {
  45.         this.letter = letter;
  46.     }
  48.     public Integer getSeq() {
  49.         return seq;
  50.     }
  52.     public void setSeq(Integer seq) {
  53.         this.seq = seq;
  54.     }
  55. }
  • 在changogu_service中的changogu_service_goods 创建 dao层并继承Mapper序列化 泛型为映射类
  1. package com.changgou.service.goods.dao;
  3. import com.changgou.goods.pojo.Brand;
  4. import tk.mybatis.mapper.common.Mapper;
  7. public interface BrandMapper extends Mapper<Brand> {
  8. }
  • 创建service 层 接口 调用dao层
  1. package com.changgou.service.goods.service;
  3. import com.changgou.goods.pojo.Brand;
  4. import com.github.pagehelper.Page;
  6. import java.util.List;
  7. import java.util.Map;
  9. public interface BrandService {
  10.     //品牌列表查询
  11.     List<Brand> findList();
  13.     //根据id查询
  14.     Brand findById(Integer id);
  16.     //品牌新增
  17.     void add(Brand brand);
  19.     //品牌修改
  20.     void update(Brand brand);
  22.     //品牌删除
  23.     void delById(Integer id);
  25.     //品牌列表条件查询
  26.     List<Brand> list(Map<String,Object> searchMap);
  28.     //品牌列表分页查询
  29.     Page<Brand> findPage(int page,int size);
  31.     //品牌列表分页+条件查询
  32.     Page<Brand> findPage(Map<String,Object> searchMap,int page,int size);
  33. }
  • 创建service 层的实现类 impl
  1. package com.changgou.service.goods.service.impl;
  3. import com.changgou.goods.pojo.Brand;
  4. import com.changgou.service.goods.dao.BrandMapper;
  5. import com.changgou.service.goods.service.BrandService;
  6. import com.github.pagehelper.Page;
  7. import com.github.pagehelper.PageHelper;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.stereotype.Service;
  10. import org.springframework.transaction.annotation.Transactional;
  11. import tk.mybatis.mapper.entity.Example;
  13. import java.util.List;
  14. import java.util.Map;
  16. @Service
  17. public class BrandServiceImpl implements BrandService {
  19.     @Autowired
  20.     private BrandMapper brandMapper;
  22.     //品牌列表查询
  23.     @Override
  24.     public List<Brand> findList() {
  25.         List<Brand> brandList = brandMapper.selectAll();
  26.         return brandList;
  27.     }
  29.     //根据id查询
  30.     @Override
  31.     public Brand findById(Integer id) {
  32.         Brand brand = brandMapper.selectByPrimaryKey(id);
  33.         return brand;
  34.     }
  36.     //添加品牌
  37.     @Override
  38.     public void add(Brand brand) {
  39.         brandMapper.insert(brand);
  40.     }
  42.     //更新品牌
  43.     @Override
  44.     public void update(Brand brand) {
  45.         brandMapper.updateByPrimaryKey(brand);
  46.     }
  48.     //根据ids删除
  49.     @Override
  50.     @Transactional
  51.     public void delById(Integer id) {
  52.         brandMapper.deleteByPrimaryKey(id);
  53.     }
  55.     //品牌列表条件查询
  56.     @Override
  57.     public List<Brand> list(Map<String, Object> searchMap) {
  58.         Example example = new Example(Brand.class);
  59.         //封装查询条件
  60.         Example.Criteria criteria = example.createCriteria();
  61.         if (searchMap != null) {
  62.             //品牌名称 like模糊查询
  63.             if (searchMap.get("name") != null && !"".equals(searchMap.get("name"))) {
  64.                 //andLike like品牌  property属性名  value为查询条件
  65.                 criteria.andLike("name", "%" + searchMap.get("name") + "%");
  66.             }
  67.             //按品牌首字母进行查询 精确查询
  68.             if (searchMap.get("letter") != null && !"".equals(searchMap.get("letter"))) {
  69.                 criteria.andEqualTo("letter", searchMap.get("letter"));
  70.             }
  72.         }
  73.         List<Brand> brandList = brandMapper.selectByExample(example);
  74.         return brandList;
  75.     }
  77.     @Override
  78.     public Page<Brand> findPage(int page, int size) {
  79.         PageHelper.startPage(page, size);
  80.         Page<Brand> page1 = (Page<Brand>) brandMapper.selectAll();
  81.         return page1;
  82.     }
  84.     @Override
  85.     public Page<Brand> findPage(Map<String, Object> searchMap, int page, int size) {
  86.         //分页
  87.         PageHelper.startPage(page, size);
  88.         //设置查询条件
  89.         Example example = new Example(Brand.class);
  90.         Example.Criteria criteria = example.createCriteria();
  91.         if (searchMap != null) {
  92.             //设置品牌模糊查询
  93.             if (searchMap.get("name") != null && !"".equals(searchMap.get("name"))) {
  94.                 //模糊查询
  95.                 criteria.andLike("name", "%" + searchMap.get("name") + "%");
  96.             }
  97.             //设置品牌首字母的精确查询
  98.             if (searchMap.get("letter") != null && !"".equals(searchMap.get("letter"))) {
  99.                 criteria.andEqualTo("letter", searchMap.get("letter"));
  100.             }
  101.         }
  102.         Page<Brand> pageInfo = (Page<Brand>) brandMapper.selectByExample(example);
  103.         return pageInfo;
  104.     }
  107. }
  • controller层
  1. package com.changgou.service.goods.controller;
  3. import com.changgou.common.pojo.PageResult;
  4. import com.changgou.common.pojo.Result;
  5. import com.changgou.common.pojo.StatusCode;
  6. import com.changgou.goods.pojo.Brand;
  7. import com.changgou.service.goods.service.BrandService;
  8. import com.github.pagehelper.Page;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.web.bind.annotation.*;
  12. import java.util.List;
  13. import java.util.Map;
  15. @RequestMapping("/brand")
  16. @RestController
  17. public class BrandController {
  19.     @Autowired
  20.     private BrandService brandService;
  23.     @GetMapping
  24.     public Result<List<Brand>> findList() {
  25.         List<Brand> brandList = brandService.findList();
  26.         return new Result<>(true, StatusCode.OK, "查询成功", brandList);
  27.     }
  30.     @GetMapping("/{id}")
  31.     public Result<Brand> findById(@PathVariable("id") Integer id) {
  32.         Brand brand = brandService.findById(id);
  33.         return new Result<>(true, StatusCode.OK, "查询成功", brand);
  34.     }
  36.     @PostMapping
  37.     private Result add(@RequestBody Brand brand) {
  38.         brandService.add(brand);
  39.         return new Result(true, StatusCode.OK, "添加成功");
  40.     }
  42.     @PutMapping("/{id}")
  43.     public Result update(@PathVariable("id") Integer id, @RequestBody Brand brand) {
  44.         brand.setId(id);
  45.         brandService.update(brand);
  46.         return new Result(true, StatusCode.OK, "更新成功");
  47.     }
  49.     @DeleteMapping("/{id}")
  50.     public Result delById(@PathVariable("id") Integer id) {
  51.         brandService.delById(id);
  52.         return new Result(true, StatusCode.OK, "删除成功");
  53.     }
  55.     @GetMapping("/search")
  56.     public Result<List<Brand>> search(@RequestParam Map searchMap) {
  57.         List<Brand> list = brandService.list(searchMap);
  58.         return new Result<>(true, StatusCode.OK, "查询成功", list);
  59.     }
  61.     @GetMapping("/search/{page}/{size}")
  62.     public Result findPage(
  63.             @PathVariable("page") int page,
  64.             @PathVariable("size") int size
  65.     ) {
  66.         Page<Brand> pageInfo = brandService.findPage(page, size);
  67.         PageResult pageResult = new PageResult(pageInfo.getTotal(), pageInfo.getResult());
  68.         return new Result(true, StatusCode.OK, "查询成功", pageResult);
  69.     }
  71.     @GetMapping("/searchPage/{page}/{size}")
  72.     public Result findPage(@RequestParam Map searchMap, @PathVariable("page") int page,
  73.                            @PathVariable("size") int size) {
  74.         Page pageInfo = brandService.findPage(searchMap, page, size);
  75.         PageResult pageResult = new PageResult(pageInfo.getTotal(), pageInfo.getResult());
  76.         return new Result(true, StatusCode.OK, "查询成功", pageResult);
  77.     }
  80. }

8. 公共异常处理

上面的接口我们都是直接返回结果给前端 如果后端出现异常会直接返回java中异常错误结果

为了使我们代码更加容易维护 我们创建一个公共异常处理类 来进行处理

通过@ControllerAdvice 声明类为增强类

通过@ExceptionHandler(value = Exception.class) 捕抓指定的异常

  1. package com.changgou.service.goods.handler;
  3. import com.changgou.common.pojo.Result;
  4. import com.changgou.common.pojo.StatusCode;
  5. import org.springframework.web.bind.annotation.ControllerAdvice;
  6. import org.springframework.web.bind.annotation.ExceptionHandler;
  7. import org.springframework.web.bind.annotation.ResponseBody;
  9. //统一异常处理类
  10. @ControllerAdvice //声明该类是一个增强类
  11. public class BaseExceptionHandler {
  12.     @ExceptionHandler(value = Exception.class) //声明为异常处理的handler
  13.     @ResponseBody
  14.     public Result error(Exception e) {
  15.         e.printStackTrace();
  16.         return new Result(false, StatusCode.ERROR, "当前系统繁忙,请您稍后重试");
  17.     }
  18. }

9. 跨域解决

出于浏览器的同源策略限制。同源策略（Sameoriginpolicy）是一种约定，它是浏览器最核心也最基本的安全功能，如果缺少了同源策略，则浏览器的正常功能可能都会受到影响。可以说Web是构建在同源策略基础之上的，浏览器只是针对同源策略的一种实现。同源策略会阻止一个域的javascript脚本和另外一个域的内容进行交互。所谓同源（即指在同一个域）就是两个页面具有相同的协议（protocol），主机（host）和端口号（port）

如果跨域调用，会出现如下错误：

No ‘Access-Control-Allow-Origin’ header is present on the requested resource. Origin ‘http://localhost:9100‘ is therefore not allowed access. The response had HTTP status code 400.

由于我们采用的是前后端分离的编程方式，前端和后端必定存在跨域问题。解决跨域问题可以采用CORS

9.1. CORS

CORS 是一个 W3C 标准，全称是”跨域资源共享”（Cross-origin resource sharing）。CORS需要浏览器和服务器同时支持。目前，所有浏览器都支持该功能，IE 浏览器不能低于 IE10。它允许浏览器向跨源服务器，发出 XMLHttpRequest 请求，从而克服了 AJAX 只能同源使用的限制。整个 CORS 通信过程，都是浏览器自动完成，不需要用户参与。对于开发者来说，CORS 通信与同源的 AJAX 通信没有差别，代码完全一样。浏览器一旦发现 AJAX 请求跨源，就会自动添加一些附加的头信息，有时还会多出一次附加的请求，但用户不会有感觉。因此，实现 CORS 通信的关键是服务器。只要服务器实现了 CORS 接口，就可以跨源通信。

01. day01 项目搭建 - 图5

01. day01 项目搭建 - 图6

springMVC的版本在4.2或以上版本，可以使用注解实现跨域。 我们只需要在Controller类上添加注解@CrossOrigin 就可以了。

  1. @RequestMapping("/brand")
  2. @RestController
  3. @CrossOrigin //开启跨域请求操作
  4. public class BrandController {
  5. }