乐优商城--服务(三) ： 商品微服务(LyItemApplication)--前半部分

由于是一个全品类的电商购物平台，那么核心自然就是商品。因此我们要搭建的第一个服务，就是商品微服务。其中会包含对于商品相关的一系列内容的管理，包括：

• 商品分类管理
• 品牌管理
• 商品规格参数管理
• 商品管理
• 库存管理

1. 微服务结构(ly-item)

1.0 顶级父工程（le-you）

注： 而所有的工程都属于 顶级父工程：le-you 的子工程。

顶级父工程（leyou）：主要用来管理依赖及其版本

由于整个项目后边很多微服务都会用到一些常用依赖，因此我们将这些依赖配置到顶级父工程中，微服务只需调用自己需要的依赖即可，如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.leyou.parent</groupId>
    <artifactId>leyou</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <modules>
        <module>ly--registry</module>
        <module>ly-gateway</module>
        <module>ly-item</module>
        <module>ly-common</module>
        <module>ly-upload</module>
        <module>ly-search</module>
        <module>ly-page</module>
        <module>ly-sms</module>
        <module>ly-user</module>
        <module>ly-auth</module>
        <module>ly--cart</module>
        <module>ly-order</module>
    </modules>
    <name>leyou</name>
    <description>Demo project for Spring Boot</description>
    <packaging>pom</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.SR1</spring-cloud.version>
        <!--<mybatis.starter.version>1.3.2</mybatis.starter.version>-->
        <mapper.starter.version>2.0.3</mapper.starter.version>
        <!--<druid.starter.version>1.1.9</druid.starter.version>-->
        <mysql.version>5.1.32</mysql.version>
        <pageHelper.starter.version>1.2.5</pageHelper.starter.version>
        <leyou.latest.version>1.0.0-SNAPSHOT</leyou.latest.version>
        <fastDFS.client.version>1.26.1-RELEASE</fastDFS.client.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- springCloud -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- 通用Mapper启动器 -->
            <dependency>
                <groupId>tk.mybatis</groupId>
                <artifactId>mapper-spring-boot-starter</artifactId>
                <version>${mapper.starter.version}</version>
            </dependency>
            <!-- 分页助手启动器 -->
            <dependency>
                <groupId>com.github.pagehelper</groupId>
                <artifactId>pagehelper-spring-boot-starter</artifactId>
                <version>${pageHelper.starter.version}</version>
            </dependency>
            <!-- mysql驱动 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <!--FastDFS客户端-->
            <dependency>
                <groupId>com.github.tobato</groupId>
                <artifactId>fastdfs-client</artifactId>
                <version>${fastDFS.client.version}</version>
            </dependency>
            <!--<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
                <version>2.0.0.RELEASE</version>
            </dependency>-->
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.4</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
</project>

1.1 ly-item

由于商品微服务（ly-item）是一个服务，那么将来肯定会有其它系统需要来调用服务中提供的接口，因此肯定也会使用到接口中关联的实体类。

因此这里我们需要使用聚合工程，将要提供的接口及相关实体类放到独立子工程中，以后别人引用的时候，只需要知道坐标即可。

我们会在ly-item中创建两个子工程：

因此该服务创建的两个工程都是在父工程ly-item下建立的，ly-item的pom为：

调用关系如图所示：

1.1.1 ly-item-interface

ly-item-interface：主要是对外暴露的API接口和相关实体类

1.1.1.1 添加依赖

由于ly-item-interface里主要是对外暴露的接口及实体类，因此普通配置即可。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>ly-item</artifactId>
        <groupId>com.leyou.service</groupId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.leyou.service</groupId>
    <artifactId>ly-item-interface</artifactId>

    <dependencies>
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-core</artifactId>
            <version>1.0.4</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>
        <dependency>
            <groupId>com.leyou.common</groupId>
            <artifactId>ly-common</artifactId>
            <version>1.0.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
  </project>

1.1.2 ly-item-service

ly-item-service：所有业务逻辑及内部使用接口

1.1.2.1 添加依赖

对于我们的商品微服务而言，ly-item-service的pom文件直接引入即可，如顶级父工程（le-you）相同，这里不再重新写一遍。

1.1.2.2 启动类

启动类LyItemApplication：

@SpringBootApplication
@EnableEurekaClient
@MapperScan("com.leyou.item.mapper")  #扫描mapper包，或者在每一个mapper上添加@Mapper注解
public class LyItemApplication {
    public static void main(String[] args) {
        SpringApplication.run(LyItemApplication.class,args);
    }
}

1.1.2.3 配置

server:
  port: 8081  # 端口号(第一个正式的微服务)
spring:
  application:
    name: item-service  # 服务名
  datasource:   # 数据库
    url: jdbc:mysql://localhost:3306/yun6
    username: root
    password: root
  rabbitmq:  # 后边会用到，消息队列：服务间进行通信，采用异步方式；而同步调用采用feign实现
    host: 192.168.184.130  # 虚拟机ip
    username: leyou
    password: leyou
    virtual-host: /leyou
    template:
      retry:
        enabled: true
        initial-interval: 10000ms
        max-interval: 300000ms
        multiplier: 2
      exchange: ly.item.exchange #缺省的交换机名称，此处配置后，发送消息如果不指定交换机就会使用这个
    publisher-confirms: true #生产者确认机制，确保消息会正确发送，如果发送失败会有错误回执，从而触发重试
eureka:  # 注册到eureka上
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka
  instance:
    prefer-ip-address: true
    ip-address: 127.0.0.1
mybatis:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

1.1.2.4 路由规则

同时，要添加路由规则到Zuul中（在网关微服务中我们已写过了）

在网关中application.yml中配置：

2. 工具包

2.1 ly-common工具类

1. 在写正式义务之前，由于某些工具类需要被所有服务去共享，因此将它们抽取出来，创建一个独立的工程：ly-common工具类，即通用的基础服务。包括：通用异常处理、通用mapper、json转换、
   调用它的服务可直接通过坐标去引用，便于访问。
   
   2.引依赖
   引入顶级父工程(le-you)依赖即可，不附图了就。

2.2 数据表

项目完整数据表: 项目数据库sql

3. 域名访问

由于篇幅较多，重新将 使用域名访问项目 写成了一篇新的博客，地址：nginx反向代理

4. 核心业务

4.0 接口实体类

商品微服务用到的API接口和实体类信息。

4.1 实现商品分类查询

商城的核心自然是商品，而商品多了以后，肯定要进行分类，并且不同的商品会有不同的品牌信息，其关系如图所示：

• 一个商品分类下有很多商品
• 一个商品分类下有很多品牌
• 而一个品牌，可能属于不同的分类
• 一个品牌下也会有很多商品

因此，我们需要依次去完成：商品分类、品牌、商品的开发。

4.1.1 category数据表

由于商品分类是有层级顺序的，因此在分类表中应记录一个parent_id，记录父子关系。

4.1.2 category实体类

@Data
@Table(name="tb_category")  #@Table声明此对象映射到数据库的数据表，不同名则以实体类名称作为表名
public class Category {
	@Id
    @KeySql(useGeneratedKeys=true)
	private Long id;
	private String name;
	private Long parentId;
	private Boolean isParent;
	private Integer sort;
}

4.1.3 业务

4.1.3.1 web

4.1.3.1.1 页面分析

编写一个controller一般需要知道四个内容：

• 请求方式：决定我们用GetMapping还是PostMapping
• 请求路径：决定映射路径
• 请求参数：决定方法的参数
• 返回值结果：决定方法的返回值

举例：

• 请求方式：Get
• 请求路径：/api/item/category/list。其中/api是网关前缀，/item是网关的路由映射，真实的路径应该是/category/list
• 请求参数：pid=0，根据tree组件的说明，应该是父节点的id，第一次查询为0，那就是查询一级类目
• 返回结果：在这里为一个json数组

4.1.3.1.2 实现业务

@RestController
@RequestMapping("category")
//这个注解会将 HTTP 请求映射到 MVC 和 REST 控制器的处理方法上。
//就是控制方法的URL地址

public class CategoryController {

    @Autowired
    private CategoryService categoryService;

    //  根据pid查询商品种类
    @GetMapping("list")
    //@GetMapping是一个组合注解，是@RequestMapping(method = RequestMethod.GET)的缩写。
    // ResponseEntity Entity是一个实体，可返回状态码,由于状态码在响应行里，因此不能用@ResponseBody注解（把Java对象序列化放到响应体里）
    public ResponseEntity<List<Category>> queryCategoryListByPid(@RequestParam("pid")Long pid){
        return ResponseEntity.ok(categoryService.queryCategoryListByPid(pid));
    }
}

4.1.3.2 service

@Service
public class CategoryService {

    @Autowired
    private CategoryMapper categoryMapper;
	
	 //  根据pid查询商品种类
    public List<Category> queryCategoryListByPid(Long pid) {
        //查询条件，mapper会把对象中的非空属性作为查询条件
        Category t = new Category();
        t.setParentId(pid);
        List<Category> list = categoryMapper.select(t);

        if(CollectionUtils.isEmpty(list)){
            throw new LyException(ExceptionEnum.CATEGORY_NOT_FOUND);
        }

        return list;
    }
}

4.1.3.3 mapper

public interface CategoryMapper extends Mapper<Category> {
}

在这里我们并没有在mapper接口上声明@Mapper注解，因为在启动类上添加了@MapperScan扫描包功能

4.1.3.4 测试

我们不经过网关，直接访问：127.0.0.1:8081/category/list?pid=0 与经过网关 ： api.leyou.com/api/itemcategory/list?pid=0 都没问题.

但是采用manage.leyou.com如下：

发现报错了！原因：跨域

4.2 跨域问题

4.2.1 什么是跨域

跨域是指跨域名的访问，以下情况都属于跨域：

跨域原因说明	示例
域名不同	www.jd.com 与 www.taobao.com
域名相同，端口不同	www.jd.com:8080 与 www.jd.com:8081
二级域名不同	item.jd.com 与 miaosha.jd.com

如果域名和端口都相同，但是请求路径不同，不属于跨域，如：

www.jd.com/item

www.jd.com/goods

而我们刚才是从 manage.leyou.com去访问 api.leyou.com这属于二级域名不同，跨域了。

4.2.2 为什么有跨域问题？

跨域不一定会有跨域问题。

因为跨域问题是浏览器对于ajax请求的一种安全限制：一个页面发起的ajax请求，只能是于当前页同域名的路径，这能有效的阻止跨站攻击。

因此：跨域问题 是针对ajax的一种限制。

4.2.3 解决跨域问题的方案

目前比较常用的跨域解决方案有3种：

• Jsonp
  最早的解决方案，利用script标签可以跨域的原理实现。
  限制：
  • 需要服务的支持
  • 只能发起GET请求
• nginx反向代理
  思路是：利用nginx反向代理把跨域为不跨域，支持各种请求方式
  缺点：需要在nginx进行额外配置，语义不清晰
• CORS
  规范化的跨域请求解决方案，安全可靠。
  优势：
  • 在服务端进行控制是否允许跨域，可自定义规则
  • 支持各种请求方式
    缺点：
  • 会产生额外的请求

我们这里会采用cors的跨域方案。

4.2.4 cors解决跨域

4.2.4.1 什么是cors

CORS是一个W3C标准，全称是"跨域资源共享"（Cross-origin resource sharing）。

它允许浏览器向跨源服务器，发出XMLHttpRequest请求，从而克服了AJAX只能同源使用的限制。

CORS需要浏览器和服务器同时支持。目前，所有浏览器都支持该功能，IE浏览器不能低于IE10。

• 浏览器端：
  目前，所有浏览器都支持该功能（IE10以下不行）。整个CORS通信过程，都是浏览器自动完成，不需要用户参与。
• 服务端：
  CORS通信与AJAX没有任何差别，因此你不需要改变以前的业务逻辑。只不过，浏览器会在请求中携带一些头信息，我们需要以此判断是否运行其跨域，然后在响应头中加入一些信息即可。这一般通过过滤器完成即可。

4.2.4.2 原理

浏览器会将ajax请求分为两类，其处理方案略有差异：简单请求、特殊请求。

简单请求

只要同时满足以下两大条件，就属于简单请求。：

（1) 请求方法是以下三种方法之一：

• HEAD
• GET
• POST

（2）HTTP的头信息不超出以下几种字段：

• Accept
• Accept-Language
• Content-Language
• Last-Event-ID
• Content-Type：只限于三个值application/x-www-form-urlencoded、multipart/form-data、text/plain

当浏览器发现发现的ajax请求是简单请求时，会在请求头中携带一个字段：Origin.

Origin中会指出当前请求属于哪个域（协议+域名+端口）。服务会根据这个值决定是否允许其跨域。

如果服务器允许跨域，需要在返回的响应头中携带下面信息：

Access-Control-Allow-Origin: http://manage.leyou.com
Access-Control-Allow-Credentials: true
Content-Type: text/html; charset=utf-8

• Access-Control-Allow-Origin：可接受的域，是一个具体域名或者*，代表任意
• Access-Control-Allow-Credentials：是否允许携带cookie，默认情况下，cors不会携带cookie，除非这个值是true

注意：

如果跨域请求要想操作cookie，需要满足3个条件：

• 服务的响应头中需要携带Access-Control-Allow-Credentials并且为true。
• 浏览器发起ajax需要指定withCredentials 为true
• 响应头中的Access-Control-Allow-Origin一定不能为*，必须是指定的域名

特殊请求

不符合简单请求的条件，会被浏览器判定为特殊请求,，例如请求方式为PUT。

预检请求

特殊请求会在正式通信之前，增加一次HTTP查询请求，称为"预检"请求（preflight）。

浏览器先询问服务器，当前网页所在的域名是否在服务器的许可名单之中，以及可以使用哪些HTTP动词和头信息字段。只有得到肯定答复，浏览器才会发出正式的XMLHttpRequest请求，否则就报错。

一个“预检”请求的样板：

OPTIONS /cors HTTP/1.1
Origin: http://manage.leyou.com
Access-Control-Request-Method: PUT
Access-Control-Request-Headers: X-Custom-Header
Host: api.leyou.com
Accept-Language: en-US
Connection: keep-alive
User-Agent: Mozilla/5.0...

与简单请求相比，除了Origin以外，多了两个头：

• Access-Control-Request-Method：接下来会用到的请求方式，比如PUT
• Access-Control-Request-Headers：会额外用到的头信息

预检请求的响应

服务的收到预检请求，如果许可跨域，会发出响应：

 HTTP/1.1 200 OK
 Date: Mon, 01 Dec 2008 01:15:39 GMT
 Server: Apache/2.0.61 (Unix)
 Access-Control-Allow-Origin: http://manage.leyou.com
 Access-Control-Allow-Credentials: true
 Access-Control-Allow-Methods: GET, POST, PUT
 Access-Control-Allow-Headers: X-Custom-Header
 Access-Control-Max-Age: 1728000
 Content-Type: text/html; charset=utf-8
 Content-Encoding: gzip
 Content-Length: 0
 Keep-Alive: timeout=2, max=100
 Connection: Keep-Alive
 Content-Type: text/plain

除了Access-Control-Allow-Origin和Access-Control-Allow-Credentials以外，这里又额外多出3个头：

• Access-Control-Allow-Methods：允许访问的方式
• Access-Control-Allow-Headers：允许携带的头
• Access-Control-Max-Age：本次许可的有效时长，单位是秒，过期之前的ajax请求就无需再次进行预检了

如果浏览器得到上述响应，则认定为可以跨域，后续就跟简单请求的处理是一样的了

4.2.4.3 实现

• 浏览器端都有浏览器自动完成，我们无需操心
• 服务端可以通过拦截器统一实现，不必每次都去进行跨域判定的编写。

事实上，SpringMVC已经帮我们写好了CORS的跨域过滤器：CorsFilter ,内部已经实现了刚才所讲的判定逻辑，我们直接用就好了。

在ly-gateway中编写一个配置类，并且注册CorsFilter：

@Configuration
public class GlobalCorsConfig {
   @Bean
   public CorsFilter corsFilter() {
       //1.添加CORS配置信息
       CorsConfiguration config = new CorsConfiguration();
       //1) 允许的域,不要写*，否则cookie就无法使用了
       config.addAllowedOrigin("http://manage.leyou.com");
       //2) 是否发送Cookie信息
       config.setAllowCredentials(true);
       //3) 允许的请求方式
       config.addAllowedMethod("OPTIONS");
       config.addAllowedMethod("HEAD");
       config.addAllowedMethod("GET");
       config.addAllowedMethod("PUT");
       config.addAllowedMethod("POST");
       config.addAllowedMethod("DELETE");
       config.addAllowedMethod("PATCH");
       // 4）允许的头信息
       config.addAllowedHeader("*");
       // 5) 有效时长
	  config.setMaxAge(3600L);

       //2.添加映射路径，我们拦截一切请求
       UrlBasedCorsConfigurationSource configSource = new UrlBasedCorsConfigurationSource();
       configSource.registerCorsConfiguration("/**", config);

       //3.返回新的CorsFilter.
       return new CorsFilter(configSource);
   }
}

重新访问，ok！

4.3 实现品牌查询

4.3.1 brand数据表

CREATE TABLE `tb_brand` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '品牌id',
  `name` varchar(50) NOT NULL COMMENT '品牌名称',
  `image` varchar(200) DEFAULT '' COMMENT '品牌图片地址',
  `letter` char(1) DEFAULT '' COMMENT '品牌的首字母',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=325400 DEFAULT CHARSET=utf8 COMMENT='品牌表，一个品牌下有多个商品（spu），一对多关系';

由于品牌和商品分类之间是多对多关系。因此我们有一张中间表，来维护两者间关系

CREATE TABLE `tb_category_brand` (
  `category_id` bigint(20) NOT NULL COMMENT '商品类目id',
  `brand_id` bigint(20) NOT NULL COMMENT '品牌id',
  PRIMARY KEY (`category_id`,`brand_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='商品分类和品牌的中间表，两者是多对多关系';

但是，你可能会发现，这张表中并没有设置外键约束，似乎与数据库的设计范式不符。为什么这么做？

• 外键会严重影响数据库读写的效率
• 数据删除时会比较麻烦

我们在代码中通过逻辑来维护表关系，不设置外键。

4.3.2 brand实体类

@Data
@Table(name = "tb_brand")
public class Brand {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;// 品牌名称
    private String image;// 品牌图片
    private Character letter;
}

4.3.3 业务

4.3.3.1 web

4.3.3.1.1 页面分析

• 请求方式：查询，肯定是Get
• 请求路径：分页查询，/brand/page
• 请求参数：根据我们刚才编写的页面，有分页功能，有排序功能，有搜索过滤功能，因此至少要有5个参数：
  • page：当前页，int
  • rows：每页大小，int
  • sortBy：排序字段，String
  • desc：是否为降序，boolean
  • key：搜索关键词，String
• 响应结果：分页结果一般至少需要两个数据
  • total：总条数
  • items：当前页数据
  • totalPage：有些还需要总页数

这里我们封装一个类，来表示分页结果：

@Data
public class PageResult<T> {
    private Long total;// 总条数
    private Long totalPage;// 总页数
    private List<T> items;// 当前页数据

    public PageResult() {
    }
    public PageResult(Long total, List<T> items) {
        this.total = total;
        this.items = items;
    }
    public PageResult(Long total, Long totalPage, List<T> items) {
        this.total = total;
        this.totalPage = totalPage;
        this.items = items;
    }
}

这个PageResult以后可能在其它项目中也有需求，因此我们将其抽取到ly-common中，提高复用性：

我们只需在ly-item-service中引用ly-common依赖即可（在上述已经引过了）

4.3.3.1.2 实现业务

@RestController
@RequestMapping("brand")
public class BrandController {

    @Autowired
    private BrandService brandService;

    // 分页查询品牌
    @GetMapping("page")
    public ResponseEntity<PageResult<Brand>> queryBrandByPage(
            @RequestParam(value = "page" , defaultValue = "1") Integer page,
            @RequestParam(value = "rows" , defaultValue = "5") Integer rows,
            @RequestParam(value = "sortBy" , required = false) String sortBy,
            @RequestParam(value = "desc" , defaultValue = "false") boolean desc,
            @RequestParam(value = "key" , required = false) String key

    ){
        return ResponseEntity.ok( brandService.queryBrandByPage(page,rows,sortBy,desc,key));
    }
}

@RequestParam注解：获取参数

主要参数：

• value：参数名字，即入参的请求参数名字，如username表示请求的参数区中的名字为username的参数的值将传入；
• required：是否必须，默认是true，表示请求中一定要有相应的参数，否则将报404错误码；
• defaultValue：默认值，表示如果请求中没有同名参数时的默认值

在SpringMVC后台控制层获取参数的方式主要有两种:

• request.getParameter("name")
• 注解@RequestParam直接获取

RequestParam可以接受简单类型的属性，也可以接受对象类型。
get 方式中queryString的值，和post方式中 body data的值都会被Servlet接受到并转化到 Request.getParameter()参数集中，所以@RequestParam可以获取的到

@PathVariable注解：绑定URI模板变量值

• @PathVariable是用来获得请求url中的动态参数的

• @PathVariable用于将请求URL中的模板变量映射到功能处理方法的参数上。
  //配置url和方法的一个关系@RequestMapping(“item/{itemId}”)

@RequestParam 和 @PathVariable 都能够完成类似的功能——因为本质上，它们都是用户的输入，只不过输入的部分不同，一个在URL路径部分，另一个在参数部分。

   通过@PathVariable，例如/blogs/1

   通过@RequestParam，例如blogs?blogId=1

4.3.3.1 service

@Service
public class BrandService {
    @Autowired
    private BrandMapper brandMapper;

	// 分页查询品牌
    public PageResult<Brand> queryBrandByPage(Integer page, Integer rows, String sortBy, boolean desc, String key) {
        //分页
        PageHelper.startPage(page,rows);

        //过滤: 过滤条件(模糊查询+准确查询(首字母))
        Example example = new Example(Brand.class);
        if(StringUtils.isNotBlank(key)){
            example.createCriteria().orLike("name","%"+key+"%").orEqualTo("letter",key.toUpperCase());
        }

        //排序
        if(StringUtils.isNotBlank(sortBy)){
            String orderByClause = sortBy + (desc ? " DESC" : " ASC"); //注：" DESC"，DESC前有空格
            example.setOrderByClause(orderByClause);
        }

        //查询
        List<Brand> list = brandMapper.selectByExample(example);
        if(CollectionUtils.isEmpty(list)){
            throw new LyException(ExceptionEnum.BRAND_NOT_FOUND);
        }

        //解析分页结果
        PageInfo<Brand> pageInfo = new PageInfo<>(list);
        return new PageResult<>(pageInfo.getTotal(),list);
    }
}

• 分页

  • pagehelper：通过配置了一个mybaits拦截器，拦截到PageHelper.startPage(page, rows);之后第一个查询语句，然后将其拼接成不同的sql再进行查询。

• 过滤

  • 将Brand.class字节码文件传给Example，通过反射机制得到实体类中的表的名字，主键等信息。
  • example.createCriteria().orLike("name","%"+key+"%").orEqualTo("letter",key.toUpperCase()) 动态拼接sql语句

• 排序

  • example.setOrderByClause(orderByClause);
    ORDER BY关键字是可以自动生成的，重点是后面的 根据什么排序 sql语句不知道，所以要写一个orderByClause——排序子句
    注意： " DESC" : " ASC"关键字前要有空格。

• 查询

  • List list = brandMapper.selectByExample(example);

• 解析分页结果

  • PageInfo<Brand> pageInfo = new PageInfo<>(list);

    return new PageResult<>(pageInfo.getTotal(),list);

  分页助手会对list做一个拦截，将list转换成一个Page对象，Page就是一个list集合，里面有当前页信息等等…所以可以对list进行分页解析

4.3.3.1 mapper

public interface BrandMapper extends Mapper<Brand> {
}

4.4 实现品牌新增

4.4.1 web

4.4.1.1 页面分析

• 请求方式：由前端页面看出是POST
• 请求路径：/brand
• 请求参数：brand对象，外加商品分类的id数组cids
• 返回值：无

4.4.1.2 实现业务

// 品牌新增
@PostMapping
    public ResponseEntity<Void> saveBrand(Brand brand,@RequestParam("cids")List<Long> cids){       
        brandService.saveBrand(brand,cids);
        return ResponseEntity.status(HttpStatus.CREATED).build();//无返回体选择build
    }

4.4.2 service

这里要注意，我们不仅要新增品牌，还要维护品牌和商品分类的中间表。

	// 品牌新增
    @Transactional
    public void saveBrand(Brand brand, List<Long> cids) {
        //新增品牌
        brand.setId(null);//初始设置成null，新增之后回显
        int count = brandMapper.insert(brand);
        if(count != 1){
            throw new LyException(ExceptionEnum.BRAND_NOT_FOUND);
        }
        //中间表新增。但是中间表没有实体类，没有通用mapper
        for (Long cid : cids){
            count = brandMapper.insertCategoryBrand(cid,brand.getId());
            if(count != 1){
                throw new LyException(ExceptionEnum.BRAND_NOT_FOUND);
            }
        }
    }

这里调用了brandMapper中的一个自定义方法，来实现中间表的数据新增。

@Transactional注解

• 在配置文件中做相关的事务规则声明(或通过基于@Transactional注解的方式)，便可以将事务规则应用到业务逻辑中
• 声明式事务管理也有两种常用的方式，一种是基于tx和aop名字空间的xml配置文件，另一种就是基于@Transactional注解
• 当作用于类上时，该类的所有 public 方法将都具有该类型的事务属性，同时，我们也可以在方法级别使用该标注来覆盖类级别的定义
• 如果被注解的数据库操作方法中发生了unchecked异常，所有的数据库操作将rollback

4.4.3 mapper

通用Mapper只能处理单表，也就是Brand的数据，因此我们手动编写一个方法及sql，实现中间表的新增：

public interface BrandMapper extends Mapper<Brand> {
    /**
     * 新增商品分类和品牌中间表数据
     * @param cid 商品分类id
     * @param bid 品牌id
     * @return
     */
    @Insert("INSERT INTO tb_category_brand (category_id, brand_id) VALUES (#{cid},#{bid})")
    int insertCategoryBrand(@Param("cid") Long cid, @Param("bid") Long bid);
}

4.5 图片上传

由于上传在很多微服务中都可能需要，因此我们将其创建为一个独立的微服务，专门处理各种上传：上传服务

注：由于商品微服务内容太多，所以做了优化，拆分成两部分写。地址：商品微服务–后半部分