第1章 框架搭建

元动力二奢交易平台：一线互联网大厂的一个二手奢侈品交易平台项目

总共16章 ：每章都是相对独立的，难度由简单到复杂。

前置技术：springboot springcloud(alibaba) es rabbitmq 支付 短信

学习目标

目标1：了解电商的技术特点和主要电商模式

目标2：理解元动力二奢平台的需求与系统设计

目标3：能够完成元动力二奢平台工程框架的搭建

目标4：能够完成商品微服务品牌增删改查功能

1. 走进电商-面试了解

1.1 电商行业分析

我国电商发展很快

    **萌芽初生阶段**（1991-1999 年）。EDI 电子商务是电商行业的最初雏形。1997 年，我国最早的两家电子商务公司：中国商品交易中心和中国化工网分别上线，B2B 业务开始逐步得到发展。1999年，国内第一家 C2C 电商 8848 正式成立。同年8 月，易趣网成立。11 月，当当网成立。1999 年9 月，招商银行率先在国内全面启动“一网通”网上银行服务，成为国内首先实现全国联通“网上银行”的商业银行。这一时期的中国电商行业仍处于萌芽引入阶段，真正的互联网应用市场还没有形成雏形，电子商务环境远未成熟，网络零售也才刚刚起步。
    **初期竞争阶段**（2000-2009年）。2000 年国际范围内的互联网泡沫破灭导致了我国电子商务也受到巨大的影响，8848 逐步没落，易趣被 eBay 收购，一大批新兴的电商网站关闭。但是机遇与挑战并存，2003 年，中国电商发展史上最为重要的两家企业淘宝网、京东相继成立。易趣与淘宝之争是电商发展史上第一次激烈的同业竞争，淘宝网以免费策略与行业老大易趣开展竞争，在 3 年的时间里，淘宝在这次竞争中大获全胜。在这一阶段中，C2C 也逐步成为当时我国网络购物市场（包括 B2C 和 C2C）的主流商业模式。2008 年我国成为全球网民最多的国家，电子商务交易额突破 3 万亿元，2009 年网购人数突破 1 亿。
    **高速成长阶段**（2010-2014 年）。2010 年，淘宝迎来第二个双十一购物节，GMV 规模从 2009 年的 0.5 亿元猛增至 9.36 亿元，双十一当天共有 2100 万用户参与了这次历史级别的购物节，全天诞生了 181 家百万级店铺。 2011-2014 年电商交易额继续高速增长，其中网络购物市场依然火爆，占社会商品零售总额的比例大幅度提高，双十一已经成为行业独有的网络购物节。在这一时期，苏宁易购、京东、国美等电商巨头发起了最为激烈的电商价格战，行业在竞争中高速成长。截止 2014年年底，中国电商行业已经全面超越欧盟、日本等经济体，部分领域甚至超越了美国。
    **稳定发展阶段**（2015-2017 年）。以腾讯和京东的战略合作达成成为标志，2015 年起，资本推动下的激烈竞争正式结束，多领域的电商平台纷纷走向合作。2015 年出现的从美团大众点评、携程去哪儿、滴滴快的、58 与赶集等生活服务电商均实现了合并。2015-2017 年网购人数、电商交易总额、网络零售交易额与 2010-2014 年相比规模明显增大，但增长速度放缓。电商市场由蓝海逐渐变为红海，发展进入相对稳定的阶段。
    **新的变化阶段**（2018-2020 年）。这一阶段之前，淘系与腾讯系京东已经基本坐稳了行业的前两位座次，随着行业发展逐步成熟，两家巨头的规模逐渐扩大，整体增长速度慢慢放缓。进入 2018 年，拼多多的迅速崛起打破了这一平衡，2018 年，成立仅 2 年的拼多多的用户数突破 3 亿，GMV 突破 4700 亿。2019 年，拼多多推出“百亿补贴”这一在电商发展历史上具有重要意义的营销活动，也拉开了又一轮电商行业的激烈竞争。也是在 2018-2020 年，短视频领域迎来爆发，两大巨头纷纷入局电商领域，成为行业在几年内少有的新进大型玩家。电商行业在经历短暂几年的平稳后，持续迎来新的变化。

    我们盯住一个垂直行业做
    **二手奢侈品行业成新蓝海**
    《中国二手奢侈品市场发展研究报告2020》（以下简称报告）显示，二奢的消费主力军**已逐渐从高收入、高阶层群体向普通大众靠拢，呈现年轻化趋势**。2019年，**76%的二奢**被36岁以下的人群买走。
    实体店生意如火如荼，二手奢侈品线上赛道也很火热，刺激了资本的入局。

●去年5月12日，二手奢侈品流通服务商胖虎科技完成1.75亿元B轮融资。据悉，胖虎成立于2015年，是一家闲置奢侈品线上平台。2019年胖虎营收约6亿元，GMV（网站成交金额）超过10亿元。截至2020年4月，胖虎APP用户数超过120万。

●另一家二手奢侈品平台妃鱼也在去年2月完成了千万美元的A轮融资。记者了解到，相较于胖虎，妃鱼更专注于二手奢侈品直播电商。早在2018年，妃鱼就开始在淘宝直播卖二手奢侈品。2019年妃鱼整体销售额近十亿元。在60名自营主播中，月销百万的高达50%以上。

●红布林也是二手奢侈品赛道中的一个重量级选手。2019年8月，红布林已完成两千万美元B+轮融资。据悉，红布林采取C2B2C模式，从卖家手中回收，经过鉴定和重新定价之后，再进行售卖。2019年，Plum红布林平台交易量实现了数十倍的增长，月GMV（网站成交金额）数千万。

●除了垂直二手奢侈品电商外，越来越多的时尚或电商平台也加入了这一赛道。例如，时尚电商平台寺库同时售卖全新和二手奢侈品，以分级标注区分两者；奢侈品服务平台包大师由奢侈品养护切入，后延展至二手奢侈品和新品交易；京东2019年7月开设了售价奢侈品服务体验中心“京东奢护”，店内设有二手奢侈品售卖区。

1.2 电商系统技术特点

技术新：单体架构-》微服务 dubbo mycat

技术范围广: java go python 阿里招聘物理学博士 阿里云，改进光纤，水冷、油冷。

分布式：分开部署 user 北京机房

                                 user  上海机房

高并发: 秒杀 玛莎拉蒂 500w->500块 100w请求—》order

集群: 一件事儿->按照逻辑分成多个微服务 下单—-减库存99（10份） 支付 物流服务

负载均衡: 10wqps—— 5w-北京 5w-上海 F5 nginx

高可用: 北京机房 上海机房 深圳机房

海量数据：1亿 10亿 100亿的订单 TB——>PB——->EB

业务复杂：大数据分析 打标签 ：手机淘宝 长腿小姐姐 ———》 手机淘宝 小米粥 卫生纸

系统安全：支付宝 改钱：1进去了 2进淘宝了

1.3 主要电商模式

B2B

B2B （ Business to Business）是指进行电子商务交易的供需双方都是商家（或企业、公司），她（他）们使用了互联网的技术或各种商务网络平台，完成商务交易的过程。电子商务是现代 B2B marketing的一种具体主要的表现形式。
案例：阿里巴巴（1688）

C2C

C2C即 Customer to Customer，意思就是消费者个人间的电子商务行为。比如一个消费者有一台电脑，通过网络进行交易，把它出售给另外一个消费者，此种交易类型就称为C2C电子商务。
案例：咸鱼、转转、瓜子二手车

B2C

B2C是Business-to-Customer的缩写，而其中文简称为“商对客”。“商对客”是电子商务的一种模式，也就是通常说的直接面向消费者销售产品和服务商业零售模式。这种形式的电子商务一般以网络零售业为主，主要借助于互联网开展在线销售活动。B2C即企业通过互联网为消费者提供一个新型的购物环境——网上商店，消费者通过网络在网上购物、网上支付等消费行为。
案例：唯品会、乐蜂网

C2B

C2B（Consumer to Business，即消费者到企业），是互联网经济时代新的商业模式。这一模式改变了原有生产者（企业和机构）和消费者的关系，是一种消费者贡献价值（Create Value）， 企业和机构消费价值（Consume Value）。
C2B模式和我们熟知的供需模式（DSM, Demand SupplyModel）恰恰相反，真正的C2B 应该先有消费者需求产生而后有企业生产，即先有消费者提出需求，后有生产企业按需求组织生产。通常情况为消费者根据自身需求定制产品和价格，或主动参与产品设计、生产和定价，产品、价格等彰显消费者的个性化需求，生产企业进行定制化生产。
案例：海尔商城

O2O

O2O即Online To Offline（在线离线/线上到线下），是指将线下的商务机会与互联网结合，让互联网成为线下交易的平台，这个概念最早来源于美国。O2O的概念非常广泛，既可涉及到线上，又可涉及到线下,可以通称为O2O。主流商业管理课程均对O2O这种新型的商业模式有所介绍及关注。
案例：美团、饿了吗

F2C

F2C指的是Factory to customer，即从厂商到消费者的电子商务模式。
案例：代工厂

B2B2C

B2B2C（Business to Business to Consumer）是一种电子商务类型的网络购物商业模式，B是BUSINESS的简称，C是CUSTOMER的简称，第一个B指的是商品或服务的供应商，第二个B指的是从事电子商务的企业，C则是表示消费者。
案例：京东商城、天猫商城

2. 元动力二奢-需求分析与系统设计

2.1 需求分析

网站前台：静态原型全流程演示，打开资料\静态原型\前台，首页index.html

里面的功能可以依次点击搜索

商品详情页：

加入购物车：

下单页面：

选择支付页面：

微信支付页面：

支付成功页面：

这一整套购物流程。

还包括秒杀流程：

网站管理后台（商家所见页面）：

静态原型演示，打开资料\静态原型\后台,首页登录界面.html

商家所见页面：

其中有商品的上下架功能，报表统计功能。

我们的动力二奢平台采用的模式为：B2B2C 模式。

补充：企业开发流程

0 项目（产品）经理。UI 原型图 需求文档：登录页面 商品详情页
1项目经理让美工做出原型页面
2项目经理 拉着后端开发 前端开发工程师 讨论
3定义业务（业务）接口  post   [http://ip](http://ip):port/goods/add  {name:手表,price:200}
4前后端分离开发
5前后端联调   dev  服务器
6测试环境发布，测试部门测试
7预发布环境（业务部门老大 、技术部门老大）
8运维人员 正式上线 生产环境
9线上bug：快速修复，当天晚上11-12 部署上线。程序员回不了家原因。

2.2 系统设计

2.2.1 前后端分离

网站后台的部分采用前后端分离方式。

以前的JavaWeb项目大多数都是java程序员又当爹又当妈，又搞前端jsp，又搞后端。随着时代的发展，渐渐的许多大中小公司开始把前后端的界限分的越来越明确，前端工程师只管前端的事情，后端工程师只管后端的事情。正所谓术业有专攻，一个人如果什么都会，那么他毕竟什么都不精。

对于后端java工程师：

把精力放在设计模式，spring+springmvc，linux，mysql事务隔离与锁机制，mongodb，http/tcp，多线程，分布式架构，弹性计算架构，微服务架构，java性能优化，以及相关的项目管理等等。

对于前端工程师：

把精力放在html5，css3，vuejs，webpack，nodejs，Google V8引擎，javascript多线程，模块化，面向切面编程，设计模式，浏览器兼容性，性能优化等等。

我们在本课程中提供与项目课程配套的管理后台的前端代码，但是不讲解前端的内容。这样我们会将更多的精力放在后端代码的开发上！

以往：jsp页面

特点：包含后端代码，页面html等混杂。
缺点：不利于大型项目协作

现在：术业有专攻。

前端：各种js（angular.js vue.js react.js） ajax axios 异步请求。
后端：spring全家桶 中间件
交互格式：json

2.2.2 技术架构-面试

面试：你们上个项目中，技术架构，用到哪些技术呢？

2.2.3 系统架构图-面试

面试：你们上个项目中，业务架构？

3. 元动力二奢-框架搭建

3.1 环境准备

导入虚拟机

补充：虚拟机：复制了？选移动了？

IP:192.168.200.128

root 123456

ifconfig 显示ip

导入虚拟机：注意修改相关号段

1修改vmware vmnet8

子网IP:192.168.200.0

DHCP设置：起始结束号段 200

NAT设置：网关 192.168.200.2

2修改本机vmnet8 地址

右键网络打开共享中心
修改适配器设置

vnet8网卡 右键 属性
ipv4协议 修改
本机IP 192.168.200.1
网关 192.168.200.2
dns 192.168.200.2

3启动虚拟机

root 123456

4xshell crt finalshell 连接到虚拟机

作业：linux 相关命令复习 vim命令

3.2 项目结构说明

结构说明：

ydleses_gateway

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

ydleses_service

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

ydleses_service_api bean feign

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

ydleses_transaction_fescar

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

ydleses_web

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

面试问题：

1微服务好处：

2分布式事务：

3.3 父工程搭建

3.3.1 一级父工程搭建

创建java maven父工程 ydles_parent 注意：com.ydles

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
    </parent>
    <properties>
        <skipTests>true</skipTests>
    </properties>
    <!--依赖包-->
    <dependencies>
        <!--测试包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Greenwich.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

删除src

3.3.2 二级父工程模块搭建

创建ydles_gateway、ydles_service、ydles_service_api、ydles_web工程，工程全部为pom工程，并将所有工程的src文件删除。

3.4 Eureka微服务搭建

（1）pom.xml依赖

创建模块ydles_eureka，pom.xml引入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>
</dependencies>

（2） application.yml配置

创建配置文件application.yml

server:
  port: 6868
eureka:
  client:
    register-with-eureka: false #是否将自己注册到eureka中
    fetch-registry: false #是否从eureka中获取信息
    service-url:
      defaultZone: http://127.0.0.1:${server.port}/eureka/

（3）启动类配置

创建包com.ydles.eureka 包下创建启动类

@SpringBootApplication
@EnableEurekaServer
public class EurekaApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication.class);
    }
}

3.5 公共模块搭建

3.5.1 全局公共模块

（1）pom.xml依赖

创建公共子模块ydles_common，pom.xml引入依赖

<dependencies>
    <!--web起步依赖-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- redis 使用-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.51</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
</dependencies>

（2）常用对象

创建com.ydles.entity包 ，包下封装相关公共实体类。将’资源/common_entity’下的相关资源导入工程

package com.ydles.entity;
/**
 * 返回结果实体类
 */
public class Result<T> {
    private boolean flag;//是否成功
    private Integer code;//返回码
    private String message;//返回消息
    private T data;//返回数据
    public Result(boolean flag, Integer code, String message, Object data) {
        this.flag = flag;
        this.code = code;
        this.message = message;
        this.data = (T)data;
    }
    public Result(boolean flag, Integer code, String message) {
        this.flag = flag;
        this.code = code;
        this.message = message;
    }
    public Result() {
        this.flag = true;
        this.code = StatusCode.OK;
        this.message = "执行成功";
    }
    //getter and setter..
}

建立类用于承载分页的数据结果

/**
 * 分页结果类
 */
public class PageResult<T> {
    private Long total;//总记录数
    private List<T> rows;//记录
    public PageResult(Long total, List<T> rows) {
        this.total = total;
        this.rows = rows;
    }
    public PageResult() {
    }
    //getter and setter ......
}

创建返回状态码实体类

/**
 * 返回码
 */
public class StatusCode {
    public static final int OK=20000;//成功
    public static final int ERROR =20001;//失败
    public static final int LOGINERROR =20002;//用户名或密码错误
    public static final int ACCESSERROR =20003;//权限不足
    public static final int REMOTEERROR =20004;//远程调用失败
    public static final int REPERROR =20005;//重复操作
}

3.5.2 数据访问公共模块搭建

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

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

<dependencies>
    <dependency>
        <groupId>com.ydles</groupId>
        <artifactId>ydles_common</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <!--通用mapper起步依赖-->
    <dependency>
        <groupId>tk.mybatis</groupId>
        <artifactId>mapper-spring-boot-starter</artifactId>
        <version>2.0.4</version>
    </dependency>
    <!--MySQL数据库驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!--mybatis分页插件-->
    <dependency>
        <groupId>com.github.pagehelper</groupId>
        <artifactId>pagehelper-spring-boot-starter</artifactId>
        <version>1.2.3</version>
    </dependency>
</dependencies>

3.6 商品微服务搭建

3.6.1 商品微服务API工程搭建

（1）ydles_service_api 引入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.persistence</groupId>
        <artifactId>persistence-api</artifactId>
        <version>1.0</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

（2）ydles_service_api 下创建ydles_service_goods_api子模块并添加common依赖

3.6.2 微服务工程搭建

项目结构中：

1ydles_service_api 微服务的feignClient,实体类。
2ydles_service 微服务：启动类 controller service dao。

ydles_service_api：微服务接口工程。

<dependencies>
        <dependency>
            <groupId>javax.persistence</groupId>
            <artifactId>persistence-api</artifactId>
            <version>1.0</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

ydles_service_goods_api：商品微服务工程,实体类。

    <dependencies>
        <dependency>
            <groupId>com.ydles</groupId>
            <artifactId>ydles_common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

ydles_service_goods工程

    <dependencies>
        <dependency>
            <groupId>com.ydles</groupId>
            <artifactId>ydles_common_db</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>com.ydles</groupId>
            <artifactId>ydles_service_goods_api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

application.yml

server:
  port: 9011
spring:
  application:
    name: goods
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.200.128:3306/ydles_goods?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
    username: root
    password: root
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:6868/eureka
  instance:
    prefer-ip-address: true
feign:
  hystrix:
    enabled: true
#hystrix 配置
hystrix:
  command:
    default:
      execution:
        timeout:
          #如果enabled设置为false，则请求超时交给ribbon控制
          enabled: true
        isolation:
          strategy: SEMAPHORE

com.ydles.goods

@SpringBootApplication
@EnableEurekaClient
@MapperScan(basePackages = "com.ydles.goods.dao")
public class GoodsApplication {
    public static void main(String[] args) {
        SpringApplication.run(GoodsApplication.class,args);
    }
}

注意：@MapperScan是tk.mybatis.spring.annotation包下的，用于扫描Mapper接口

4. 商品微服务-品牌增删改查

4.1 需求分析

创建商品微服务，实现对品牌表的增删改查功能。具体包括

（1）查询全部列表数据

（2）根据ID查询实体数据

（3）增加

（4）修改

（5）删除

（6）条件查询

（7）分页查询

（8）分页+条件查询

写一个测试controller

@RequestMapping("/demo")
@RestController //组合注解
public class DemoController {
    @GetMapping("/test")
    public String demo(){
        return "demo mesage";
    }
}

测试时先启动注册中心

4.2 表结构分析

4.3 代码实现

注意：写代码要由底往上写。

定义接口：

GET ip:port/brand/findAll
返回
{
flag:true
code:20000
msg:"成功"，
data:[]
}

4.3.1 品牌列表

（1）在ydles_service_goods_api创建com.ydles.goods.pojo包，包下创建Brand实体类

@Table(name="tb_brand")
public class Brand implements Serializable{
    @Id
    private Integer id;//品牌id
    private String name;//品牌名称
    private String image;//品牌图片地址
    private String letter;//品牌的首字母
    private Integer seq;//排序
    // getter and setter  .....(省略)
}

@Table和@Id都是JPA注解，@Table用于配置表与实体类的映射关系，@Id用于标识主键属性。

（2）Dao创建

在ydles_service_goods微服务下创建com.ydles.goods.dao.BrandMapper接口，代码如下：

public interface BrandMapper extends Mapper<Brand> {
}

继承了Mapper接口，就自动实现了增删改查的常用方法。

（3）业务层

创建com.ydles.goods.service.BrandService接口，代码如下：

public interface BrandService {
    /***
     * 查询所有品牌
     * @return
     */
  public  List<Brand> findAll();
}

创建com.ydles.goods.service.impl包，包下创建服务实现类 BrandServiceImpl，代码如下：

@Service
public class BrandServiceImpl implements BrandService {
    @Autowired
    private BrandMapper brandMapper;
    @Override
    public List<Brand> findAll() {
        return brandMapper.selectAll();
    }   
}

（3）控制层

控制层 com.ydles.goods包下创建controller包 ，包下创建类

@RestController
@RequestMapping("/brand")
public class BrandController {
    @Autowired
    private BrandService brandService;
    @GetMapping
    public Result findAll(){
        List<Brand> brandList = brandService.findAll();
        return new Result(true, StatusCode.OK,"查询成功",brandList) ;
    }
}

最后测试 http://localhost:9011/brand

可用postman测试

4.3.2 根据ID查询品牌

GET ip:port/brand/102
{
flag:true
code:20000
msg:"成功"，
data:{}
}

套路代码

（1） 业务层接口

修改com.ydles.goods.service.BrandService接口，添加根据ID查询品牌数据方法，代码如下：

/**
 * 根据ID查询
 * @param id
 * @return
 */
public Brand findById(Integer id);

（2）业务层实现

修改com.ydles.goods.service.impl.BrandServiceImpl新增方法，代码如下：

/**
 * 根据ID查询
 * @param id
 * @return
 */
@Override
public Brand findById(Integer id){
    return  brandMapper.selectByPrimaryKey(id);
}

（3） 控制层

BrandController新增方法

/***
 * 根据ID查询品牌数据
 * @param id
 * @return
 */
@GetMapping("/{id}")
public Result findById(@PathVariable Integer id){
    Brand brand = brandService.findById(id);
    return new Result(true,StatusCode.OK,"查询成功",brand);
}

测试http://localhost:9011/brand/102

4.3.3 新增品牌

需求：POST http://localhost:9011/brand/insert

json

{
    "name": "Cartier",
    "image": "123"
}

返回
{
flag:true
code:20000
msg:"成功"
}

（1）业务层接口 修改com.ydles.goods.service.BrandService，新增方法

/***
 * 新增品牌
 * @param brand
 */
public void add(Brand brand);

（2）业务层实现 修改com.ydles.goods.service.impl.BrandServiceImpl，新增增加品牌方法代码如下：

/**
 * 增加
 * @param brand
 */
@Override
public void add(Brand brand){
    brandMapper.insertSelective(brand);
}

（3）控制层 BrandController新增方法

/***
 * 新增品牌数据
 * @param brand
 * @return
 */
@PostMapping
public Result add(@RequestBody Brand brand){
    brandService.add(brand);
    return new Result(true,StatusCode.OK,"添加成功");
}

4.3.4 修改品牌

需求：PUT http://localhost:9011/brand/update/102

{
  "name": "卡地亚"
}

修改某一个品牌时，只修改传进来的数据。

（1） 业务层接口

需改com.ydles.goods.service.BrandService,添加修改品牌方法，代码如下：

/***
 * 修改品牌数据
 * @param brand
 */
public void update(Brand brand);

（2）业务层实现 修改com.ydles.goods.service.impl.BrandServiceImpl，添加修改品牌方法，代码如下：

/**
 * 修改
 * @param brand
 */
@Override
public void update(Brand brand){
    brandMapper.updateByPrimaryKeySelective(brand);
}

（3）控制层

BrandController新增方法

/***
 * 修改品牌数据
 * @param brand
 * @param id
 * @return
 */
@PutMapping(value="/{id}")
public Result update(@RequestBody Brand brand,@PathVariable Integer id){
    brand.setId(id);
    brandService.update(brand);
    return new Result(true,StatusCode.OK,"修改成功");
}

4.3.5 删除品牌

需求：DELETE http://localhost:9011/brand/325414

（1）业务层接口

修改com.ydles.goods.service.BrandService，添加删除品牌方法，代码如下：

/***
 * 删除品牌
 * @param id
 */
public void delete(Integer id);

（2）业务层实现 修改com.ydles.goods.service.impl.BrandServiceImpl，新增删除品牌方法，代码如下：

/**
 * 删除
 * @param id
 */
@Override
public void delete(Integer id){
    brandMapper.deleteByPrimaryKey(id);
}

（3）控制层 BrandController新增方法

/***
 * 根据ID删除品牌数据
 * @param id
 * @return
 */
@DeleteMapping(value = "/{id}" )
public Result delete(@PathVariable Integer id){
    brandService.delete(id);
    return new Result(true,StatusCode.OK,"删除成功");
}

代码优化：

1代码里的魔法值 ——》常量或者枚举

2resful风格 ：

前后端交互中，json传递数据。
数据的增删改查，使用http的不同方法。

查询 GET  
新增 POST
修改 PUT
删除 DELETE

4.3.6 品牌列表条件查询

需求：Get http://localhost:9011/brand/search?name=奈儿&letter=C

sql:select * from tb_brand where name like ‘%奈儿%’ and letter=C

（1） 业务层接口

修改com.ydles.goods.service.BrandService，增加根据条件搜索品牌方法，代码如下：

/***
 * 多条件搜索品牌方法
 * @param searchMap
 * @return
 */
public List<Brand> findList(Map<String, Object> searchMap);

（2）业务层实现 修改com.ydles.goods.service.impl.BrandServiceImpl，添加根据多条件搜索品牌方法的实现，代码如下：

//缺啥补啥
    @Override
    public List<Brand> search(Map<String, String> searchMap) {
        //sql: select * from tb_brand where letter=C and name like "%奈儿%"
        Example example=new Example(Brand.class);
        //criteria 放搜索条件
        Example.Criteria criteria = example.createCriteria();
        if(searchMap!=null){
            if(StringUtils.isNotBlank(searchMap.get("name"))){
                //and name like "%奈儿%"
                criteria.andLike("name","%"+searchMap.get("name")+"%");
            }
            if(StringUtils.isNotBlank(searchMap.get("letter"))){
                //and name like "%奈儿%"
                criteria.andEqualTo("letter",searchMap.get("letter"));
            }
        }
        List<Brand> brandList = brandMapper.selectByExample(example);
        return brandList;
    }

（3） 控制层 BrandController新增方法

/***
 * 多条件搜索品牌数据
 * @param searchMap
 * @return
 */
@GetMapping(value = "/search" )
public Result findList(@RequestParam Map searchMap){
    List<Brand> list = brandService.findList(searchMap);
    return new Result(true,StatusCode.OK,"查询成功",list);
}

postman测试 http://localhost:9011/brand/search?name=

4.3.7 品牌列表分页查询

需求 GET http://localhost:9011/brand/search/3/5

sql:select * from tb_brand limit 20,10

（1） 业务层接口 修改com.ydles.goods.service.BrandService添加分页方法，代码如下：

/***
 * 分页查询
 * @param page
 * @param size
 * @return
 */
public Page<Brand> findPage(int page, int size);

（2）业务层实现 修改com.ydles.goods.service.impl.BrandServiceImpl添加分页方法实现，代码如下：

/**
 * 分页查询
 * @param pagejava
 * @param size
 * @return
 */
@Override
public Page<Brand> findPage(int page, int size){
    PageHelper.startPage(page,size);
    return (Page<Brand>)brandMapper.selectAll();
}

（3） 控制层 BrandController新增方法

/***
 * 分页搜索实现
 * @param page
 * @param size
 * @return
 */
@GetMapping(value = "/search/{page}/{size}" )
public Result findPage(@PathVariable  int page, @PathVariable  int size){
    Page<Brand> pageList = brandService.findPage(page, size);
    PageResult pageResult=new PageResult(pageList.getTotal(),pageList.getResult());
    return new Result(true,StatusCode.OK,"查询成功",pageResult);
}

4.3.8 品牌列表条件+分页查询

需求： GET http://localhost:9011/brand/searchPage/2/5?lettrt=I&name="奈儿“

（1） 业务层接口 修改com.ydles.goods.service.BrandService，增加多条件分页查询方法，代码如下：

/***
 * 多条件分页查询
 * @param searchMap
 * @param page
 * @param size
 * @return
 */
Page<Brand> findPage(Map<String, Object> searchMap, int page, int size);

（2）业务层实现 修改com.ydles.goods.service.impl.BrandServiceImpl，添加多条件分页查询方法代码如下：

/**
     * 条件+分页查询
     * @param searchMap 查询条件
     * @param page 页码
     * @param size 页大小
     * @return 分页结果
     */
@Override
public Page<Brand> findPage(Map<String,Object> searchMap, int page, int size){
    PageHelper.startPage(page,size);
    Example example=new Example(Brand.class);
    Example.Criteria criteria = example.createCriteria();
    if(searchMap!=null){
        // 品牌名称
        if(searchMap.get("name")!=null && !"".equals(searchMap.get("name"))){
            criteria.andLike("name","%"+searchMap.get("name")+"%");
        }
        // 品牌的首字母
        if(searchMap.get("letter")!=null && !"".equals(searchMap.get("letter"))){
            criteria.andEqualTo("letter",searchMap.get("letter"));
        }
    }
    return (Page<Brand>)brandMapper.selectByExample(example);
}

（3）控制层 BrandController新增方法

/***
 * 分页搜索实现
 * @param searchMap
 * @param page
 * @param size
 * @return
 */
@GetMapping(value = "/search/{page}/{size}" )
public Result findPage(@RequestParam Map searchMap, @PathVariable  int page, @PathVariable  int size){
    Page<Brand> pageList = brandService.findPage(searchMap, page, size);
    PageResult pageResult=new PageResult(pageList.getTotal(),pageList.getResult());
    return new Result(true,StatusCode.OK,"查询成功",pageResult);
}

5. 公共异常处理

为了使我们的代码更容易维护，我们创建一个类集中处理异常

在com.ydles.goods.handler包下创建公共异常处理类BaseExceptionHandler

/**
 * 统一异常处理类
 */
@ControllerAdvice
public class BaseExceptionHandler {
    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public Result error( Exception e) {
        e.printStackTrace();        
        return new Result(false, StatusCode.ERROR, e.getMessage());
    }
}

拓展：java 异常错误分类

总结：

1走进电商 元动力二奢 -面试

电商是什么 有技术特点

二奢市场地位

2元动力二奢 需求

技术架构

业务架构

3搭建项目

导入虚拟机

代码架构

父工程 二级父工程 注册中心

商品微服务

4品牌的crud

查询：tk.mybatis

条件查询：example

分页：pageHelper

5公共异常处理

异常分类

第2章 分布式文件存储

角色：商品 后端开发

学习目标

目标1：能够CORS解决跨域问题

目标2：理解规格参数模板与商品分类表结构

目标3：掌握通用mapper自定义方法的使用

目标4：能够使用分布式文件存储FastDFS上传文件

1. 跨域解决方案CORS-面试

1.1 什么是跨域

面试：

1什么是跨域问题：浏览器的同源策略，导致不能向其他域名发送异步请求。

2同源策略：具有相同的协议（protocol），主机（host）和端口号（port）

                页面：[http://192.168.1.1:8080/search](http://192.168.1.1:8080/search)    商品搜索页面
                https://192.168.1.1:8080/search?name=手表    ----->no
                [http://192.168.1.2:8080/search](http://192.168.1.2:8080/search)            ------------->no
                [http://192.168.1.1:8081/goods/add](http://192.168.1.1:8081/goods/add)  ------------->no
                [http://192.168.1.1:8080/goods/add](http://192.168.1.1:8080/goods/add)  -------------> YES

出于浏览器的同源策略限制。同源策略（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

1.2 CORS简介

CORS:跨域资源共享

条件：IE10以上

本质：请求头增加一个参数，开启跨域请求。

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

请求过程如下图:

Preflight Request：

然后服务器端给我们返回一个PreflightResponse

我们怎么做：那么具体如何实现呢？springMVC的版本在4.2或以上版本，可以使用注解实现跨域。 我们只需要在Controller类上添加注解@CrossOrigin就可以了。

2. 导入基础架构项目（了解）

需求：刚进一家新公司，你会拿到是代码呢？几十个人写了几年。

解压项目基础架构包 即可。

使用idea打开，观察项目架构。

2.1 导入项目

在idea下点击file菜单中的open项, 找到ydles_parent位置打开

3.规格参数与分类管理（后台）-重点

我们本小节只需同学们理解管理后台规格参数与分类管理的需求和表结构的设计，没有代码实现，因为管理后台所需的代码在基础工程中已经帮我们生成了，无需自己编写。

打开day01静态页面-后台首页。查看商品-规格参数。

分类：分类 衣物—-》裙子—-》连衣裙、百褶裙、婚纱

模板：裙子模板———》大小：s m l 裙子颜色：黑色、红色 胸围：100 腰围：100 臀围：100

        手机模板----》手机颜色：黑色、红色 内存：4G 6G  存储：128G 256G

参数：量变 胸围：110 腰围：100 臀围：100 内存：4G 6G 存储：128G 256G

规格：质变 大小：s m l 手机颜色：黑色、红色

分类：手机 电脑 电视

品牌：华为 小米 苹果

表：

3.1 规格参数管理

3.1.1 需求分析

规格参数模板是用于管理规格参数的单元。

前端交互方式见管理后台的静态原型

3.1.2 表结构分析

规格参数模板相关的表有3个

tb_template表（模板表）

tb_spec表（规格表）

tb_para表（参数表）

模板与规格是一对多关系 ，模板与参数是一对多关系

3.2 分类管理

3.2.1 需求分析

商品分类一共分三级管理，主要作用是在网站首页中显示商品导航，以及在管理后台管理商品时使用。

3.2.2 表结构分析

tb_category 表 （商品分类）

商品分类与模板是多对一关系

4.通用mapper自定义方法-重点掌握

4.1 根据商品分类名称查询品牌列表

需求：根据商品分类名称查询品牌列表

http://localhost:9001/brand/category/女士包袋

4.1.1 表结构分析

基于上述的讲解已知分类与品牌之间的关系属于多对多关系，这里通过tb_category_brand表来建立关联关系。

分类-品牌中间表

4.1.2 代码实现

写出sql

SELECT NAME,image FROM tb_brand WHERE id IN ( SELECT brand_id FROM tb_category_brand WHERE category_id IN ( SELECT id FROM tb_category WHERE NAME = '女士包袋' ) )

（1）修改BrandMapper，新增方法定义

    /**
     * 根据分类名称查询品牌列表
     * @param categoryName
     * @return
     */
    @Select("SELECT name,img FROM tb_brand WHERE id  IN (SELECT brand_id FROM tb_category_brand WHERE  category_id IN (SELECT id FROM tb_category WHERE NAME=#{name}) )order by seq")
    public List<Map> findListByCategoryName(@Param("name") String categoryName);

（2）修改BrandService，新增方法定义

/**
     * 根据商品分类名称查询品牌列表
     * @param categoryName
     * @return
     */
public List<Map> findListByCategoryName(String categoryName);

（3）BrandServiceImpl实现方法

@Override
public List<Map> findListByCategoryName(String categoryName) {
    return brandMapper.findListByCategoryName(categoryName);
}

（4）BrandController新增方法

/**
 * 根据分类名称查询品牌列表
 * @param category
 * @return
 */
@GetMapping("/category/{category}")
public Result  findListByCategoryName(@PathVariable String category){
    System.out.println(category);
    List<Map> brandList = brandService.findListByCategoryName(category);
    return new Result(true,StatusCode.OK,"查询成功",brandList);
}

测试： http://localhost:9001/brand/category/女士包袋

4.2 根据商品分类名称查询规格列表

http://localhost:9001/spec/category/女士包袋

4.2.1 表结构分析

我们这里会用到规格表、模板表、分类表 注意：以下表结构已省略无关字段

tb_template 表（模板表）

tb_spec 表（ 规格表）

tb_category 表 （商品分类）

4.2.2 代码实现

sql:

select name,options from tb_spec where template_id in (select template_id from tb_category where name = '女士包袋') order by seq

（1）SpecMapper新增方法定义

 @Select("SELECT name,options FROM tb_spec WHERE template_id IN ( SELECT template_id FROM tb_category WHERE NAME=#{categoryName}) order by seq")
    public List<Map> findListByCategoryName(@Param("categoryName") String categoryName);

（2）SpecService新增方法定义

/**
     * 根据商品分类名称查询规格列表
     * @param categoryName
     * @return
     */
public List<Map> findListByCategoryName(String categoryName);

（3）SpecServiceImpl实现方法

@Override
public List<Map> findListByCategoryName(String categoryName) {
    List<Map> specList = specMapper.findListByCategoryName(categoryName);
    for(Map spec:specList){
        String[] options = ((String) spec.get("options")).split(",");//规格选项列表
        spec.put("options",options);
    }
    return specList;
}

（4）SpecController新增方法

/**
     * 根据商品分类名称查询规格列表
     * @param category
     * @return
     */
@GetMapping("/category/{category}")
public Result findListByCategoryName(@PathVariable  String category){
    List<Map> specList = specService.findListByCategoryName(category);
    return new Result(true,StatusCode.OK,"",specList);
}

测试： http://localhost:9001/spec/category/女士包袋

5. 分布式文件存储-FastDFS

FastDFS:Fast distribite file system 有小有多的小文件

HDFS:hadoop distribite file system 大文件

5.1 FastDFS简介

5.1.1 FastDFS体系结构

FastDFS是一个开源的轻量级分布式文件系统，它对文件进行管理，功能包括：文件存储、文件同步、文件访问（文件上传、文件下载）等，解决了大容量存储和负载均衡的问题。特别适合以文件为载体的在线服务，如相册网站、视频网站等等。

作者：阿里 P8 200w年薪 余庆大神

FastDFS为互联网量身定制，充分考虑了冗余备份、负载均衡、线性扩容等机制，并注重高可用、高性能等指标，使用FastDFS很容易搭建一套高性能的文件服务器集群提供文件上传、下载等服务。

FastDFS 架构包括 Tracker server 和 Storage server。客户端请求 Tracker server 进行文件上传、下载，通过Tracker server 调度最终由 Storage server 完成文件上传和下载。

Tracker server 作用是负载均衡和调度，通过 Tracker server 在文件上传时可以根据一些策略找到Storage server 提供文件上传服务。可以将 tracker 称为追踪服务器或调度服务器。Storage server 作用是文件存储，客户端上传的文件最终存储在 Storage 服务器上，Storageserver 没有实现自己的文件系统而是利用操作系统的文件系统来管理文件。可以将storage称为存储服务器。

tracker: 元数据信息，文件上传时间、地址、大小。

            记录storage集群信息。

storage:存数据。

5.1.2 上传流程

客户端上传文件后存储服务器将文件 ID 返回给客户端，此文件 ID 用于以后访问该文件的索引信息。文件索引信息包括：组名，虚拟磁盘路径，数据两级目录，文件名。

fileId: group1/M00/00/00/asdfsadfsadfsadfsadfsadfsa.png

组名：文件上传后所在的 storage 组名称，在文件上传成功后有storage 服务器返回，需要客户端自行保存。

虚拟磁盘路径：storage 配置的虚拟路径，与磁盘选项store_path对应。如果配置了

/data/00-ff/00-ff/——->/M00

/data2——>/M01

数据两级目录：storage 服务器在每个虚拟磁盘路径下创建的两级目录，用于存储数据

文件。

文件名：与文件上传时不同。是由存储服务器根据特定信息生成，文件名包含：源存储

服务器 IP 地址、文件创建时间戳、文件大小、随机数和文件拓展名等信息。

5.2 FastDFS搭建-了解

已经在虚拟机中搭建完毕。

我们使用Docker搭建FastDFS的开发环境

拉取镜像

docker pull morunchang/fastdfs

运行tracker

docker run -d --name tracker --net=host morunchang/fastdfs sh tracker.sh

运行storage

docker run -d --name storage --net=host -e TRACKER_IP=<your tracker server address>:22122 -e GROUP_NAME=<group name> morunchang/fastdfs sh storage.sh

• 使用的网络模式是–net=host, 替换为你机器的Ip即可
• 是组名，即storage的组
• 如果想要增加新的storage服务器，再次运行该命令，注意更换 新组名

（4）修改nginx的配置

进入storage的容器内部，修改nginx.conf

docker exec -it storage  /bin/bash

进入后

vi /data/nginx/conf/nginx.conf

添加以下内容

location /group1/M00 {
   proxy_next_upstream http_502 http_504 error timeout invalid_header;
     proxy_cache http-cache;
     proxy_cache_valid  200 304 12h;
     proxy_cache_key $uri$is_args$args;
     proxy_pass http://fdfs_group1;
     expires 30d;
 }

（5）退出容器

exit

（6）重启storage容器

docker restart storage

5.3 文件存储微服务

创建文件管理微服务ydles_service_file，该工程主要用于实现文件上传以及文件删除等功能。

（1）修改pom.xml，引入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>net.oschina.zcx7878</groupId>
        <artifactId>fastdfs-client-java</artifactId>
        <version>1.27.0.0</version>
    </dependency>
    <dependency>
        <groupId>com.ydles</groupId>
        <artifactId>ydles_common</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
</dependencies>

（2）在resources文件夹下创建fasfDFS的配置文件fdfs_client.conf

connect_timeout = 60
network_timeout = 60
charset = UTF-8
http.tracker_http_port = 8080
tracker_server = 192.168.200.128:22122

connect_timeout：连接超时时间，单位为秒。

network_timeout：通信超时时间，单位为秒。发送或接收数据时。假设在超时时间后还不能发送或接收数据，则本次网络通信失败

charset： 字符集

http.tracker_http_port ：.tracker的http端口

tracker_server： tracker服务器IP和端口设置

（3）在resources文件夹下创建application.yml

spring:
  servlet:
    multipart:
      max-file-size: 10MB
      max-request-size: 10MB
server:
  port: 9008
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:6868/eureka
  instance:
    prefer-ip-address: true
feign:
  hystrix:
    enabled: true

max-file-size是单个文件大小，max-request-size是设置总上传的数据大小

（4）创建com.ydles.file包，创建启动类FileApplication

@SpringBootApplication
@EnableEurekaClient
public class FileApplication {
    public static void main(String[] args) {
        SpringApplication.run(FileApplication.class);
    }
}

5.4 文件上传-重点

5.4.1 文件信息封装

文件上传一般都有文件的名字、文件的内容、文件的扩展名、文件的md5值、文件的作者等相关属性，我们可以创建一个对象封装这些属性，代码如下：

FastDFSFile：文件实体类

FastDFSClient：文件工具类，封装底层方法。

FileController：接口

创建com.ydles.file.pojo.FastDFSFile

public class FastDFSFile {
    //文件名字
    private String name;
    //文件内容
    private byte[] content;
    //文件扩展名
    private String ext;
    //文件MD5摘要值
    private String md5;
    //文件创建作者
    private String author;
    public FastDFSFile(String name, byte[] content, String ext, String height,
                       String width, String author) {
        super();
        this.name = name;
        this.content = content;
        this.ext = ext;
        this.author = author;
    }
    public FastDFSFile(String name, byte[] content, String ext) {
        super();
        this.name = name;
        this.content = content;
        this.ext = ext;
    }
    // getter and setter ...
}

5.4.2 文件操作

创建FastDFSClient类,放在com.ydles.file.util下在该类中实现FastDFS信息获取以及文件的相关操作，

代码如下：

public class FastDFSClient {
    private static org.slf4j.Logger logger = LoggerFactory.getLogger(FastDFSClient.class);
    /***
     * 初始化加载FastDFS的TrackerServer配置
     */
    static {
        try {
            String filePath = new ClassPathResource("fdfs_client.conf").getFile().getAbsolutePath();
            ClientGlobal.init(filePath);
        } catch (Exception e) {
            logger.error("FastDFS Client Init Fail!",e);
        }
    }
    /***
     * 文件上传
     * @param file
     * @return
     */
    public static String[] upload(FastDFSFile file) {
        //获取文件的作者
        NameValuePair[] meta_list = new NameValuePair[1];
        meta_list[0] = new NameValuePair("author", file.getAuthor());
        //接收返回数据
        String[] uploadResults = null;
        StorageClient storageClient=null;
        try {
            //创建StorageClient客户端对象
            storageClient = getTrackerClient();
            /***
             * 文件上传
             * 1)文件字节数组
             * 2)文件扩展名
             * 3)文件作者
             */
            uploadResults = storageClient.upload_file(file.getContent(), file.getExt(), meta_list);
        } catch (Exception e) {
            logger.error("Exception when uploadind the file:" + file.getName(), e);
        }
        if (uploadResults == null && storageClient!=null) {
            logger.error("upload file fail, error code:" + storageClient.getErrorCode());
        }
        //获取组名
        String groupName = uploadResults[0];
        //获取文件存储路径
        String remoteFileName = uploadResults[1];
        return uploadResults;
    }
    /***
     * 获取文件信息
     * @param groupName:组名
     * @param remoteFileName：文件存储完整名
     * @return
     */
    public static FileInfo getFile(String groupName, String remoteFileName) {
        try {
            StorageClient storageClient = getTrackerClient();
            return storageClient.get_file_info(groupName, remoteFileName);
        } catch (Exception e) {
            logger.error("Exception: Get File from Fast DFS failed", e);
        }
        return null;
    }
    /***
     * 文件下载
     * @param groupName
     * @param remoteFileName
     * @return
     */
    public static InputStream downFile(String groupName, String remoteFileName) {
        try {
            //创建StorageClient
            StorageClient storageClient = getTrackerClient();
            //下载文件
            byte[] fileByte = storageClient.download_file(groupName, remoteFileName);
            InputStream ins = new ByteArrayInputStream(fileByte);
            return ins;
        } catch (Exception e) {
            logger.error("Exception: Get File from Fast DFS failed", e);
        }
        return null;
    }
    /***
     * 文件删除
     * @param groupName
     * @param remoteFileName
     * @throws Exception
     */
    public static void deleteFile(String groupName, String remoteFileName)
            throws Exception {
        //创建StorageClient
        StorageClient storageClient = getTrackerClient();
        //删除文件
        int i = storageClient.delete_file(groupName, remoteFileName);
    }
    /***
     * 获取Storage组
     * @param groupName
     * @return
     * @throws IOException
     */
    public static StorageServer[] getStoreStorages(String groupName)
            throws IOException {
        //创建TrackerClient
        TrackerClient trackerClient = new TrackerClient();
        //获取TrackerServer
        TrackerServer trackerServer = trackerClient.getConnection();
        //获取Storage组
        return trackerClient.getStoreStorages(trackerServer, groupName);
    }
    /***
     * 获取Storage信息,IP和端口
     * @param groupName
     * @param remoteFileName
     * @return
     * @throws IOException
     */
    public static ServerInfo[] getFetchStorages(String groupName,
                                                String remoteFileName) throws IOException {
        TrackerClient trackerClient = new TrackerClient();
        TrackerServer trackerServer = trackerClient.getConnection();
        return trackerClient.getFetchStorages(trackerServer, groupName, remoteFileName);
    }
    /***
     * 获取Tracker服务地址
     * @return
     * @throws IOException
     */
    public static String getTrackerUrl() throws IOException {
        return "http://"+getTrackerServer().getInetSocketAddress().getHostString()+":"+ClientGlobal.getG_tracker_http_port()+"/";
    }
    /***
     * 获取Storage客户端
     * @return
     * @throws IOException
     */
    private static StorageClient getTrackerClient() throws IOException {
        TrackerServer trackerServer = getTrackerServer();
        StorageClient storageClient = new StorageClient(trackerServer, null);
        return  storageClient;
    }
    /***
     * 获取Tracker
     * @return
     * @throws IOException
     */
    private static TrackerServer getTrackerServer() throws IOException {
        TrackerClient trackerClient = new TrackerClient();
        TrackerServer trackerServer = trackerClient.getConnection();
        return  trackerServer;
    }
}

5.4.3 文件上传

创建一个FileController，在该控制器中实现文件上传操作，代码如下：

@RestController
@RequestMapping("/file")
public class FileController {
    @PostMapping("/upload")
    public Result uploadFile(MultipartFile file){
        try{
            //判断文件是否存在
            if (file == null){
                throw new RuntimeException("文件不存在");
            }
            //获取文件的完整名称
            String originalFilename = file.getOriginalFilename();
            if (StringUtils.isEmpty(originalFilename)){
                throw new RuntimeException("文件不存在");
            }
            //获取文件的扩展名称  abc.jpg   jpg
            String extName = originalFilename.substring(originalFilename.lastIndexOf(".") + 1);
            //获取文件内容
            byte[] content = file.getBytes();
            //创建文件上传的封装实体类
            FastDFSFile fastDFSFile = new FastDFSFile(originalFilename,content,extName);
            //基于工具类进行文件上传,并接受返回参数  String[]
            String[] uploadResult = FastDFSClient.upload(fastDFSFile);
            //封装返回结果
            String url = FastDFSClient.getTrackerUrl()+uploadResult[0]+"/"+uploadResult[1];
            return new Result(true,StatusCode.OK,"文件上传成功",url);
        }catch (Exception e){
            e.printStackTrace();
        }
        return new Result(false, StatusCode.ERROR,"文件上传失败");
    }
}