xml复制代码<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

xml复制代码spring:
  application:
    name: demo-config
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
      config:
        server-addr: 127.0.0.1:8848
        file-extension: yaml
        group: DEFAULT_GROUP
        prefix: ${spring.application.name}

python复制代码pip install baidu-aip

python复制代码# 导入需要用的模块
from aip import AipFace

# 准备AppID、API Key、Secret Key
APP_ID = '18101974'
API_KEY = 'HG5NFSFpfBiqqmBYVBpXQFKs'
SECRET_KEY = 'ytdOFrcBxZvvGlMKGtmkmpBQ6arbjupx'

# 调用人脸检测
client = AipFace(APP_ID, API_KEY, SECRET_KEY)

# 图片的类型，三种可选BASE64、URL、FACE_TOKEN
image_type = 'URL'
# 图片的url
iamge = 'https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1577292322895&di=f7fa123b95016762f1f0c3d2999328c4&imgtype=0&src=http%3A%2F%2Fww1.sinaimg.cn%2Flarge%2Fc7b64b24jw1f7k7i3aap4j20qo1407ck.jpg'

# 识别人脸
face_data = client.detect(iamge, image_type)

python复制代码pip install pillow

python复制代码# 从Pillow中导入Image模块
from PIL import Image
import urllib

# 将image保存到本地文件
resp = urllib.request.urlopen(image_url)
f = open('im.jpg', 'wb')
f.write(resp.read())

# 使用Image模块，打开刚刚保存的图像
im = Image.open('im.jpg')

# 获取face_data中人脸的位置
left = face_data['result']['face_list'][0]['location']['left']
top = face_data['result']['face_list'][0]['location']['top']
width = face_data['result']['face_list'][0]['location']['width']
height = face_data['result']['face_list'][0]['location']['height']

# 截取人脸
face_im = im.crop((left, top, left+width, top+height))
face_im.save('face_im.jpg')

python复制代码# 类型依旧是URL
image_type = 'URL'
# 一张包含多个人脸的image
image = 'https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1577296093031&di=f88c884ea4440935055c704fd20c0549&imgtype=0&src=http%3A%2F%2F5b0988e595225.cdn.sohucs.com%2Fimages%2F20180209%2F3a8e9aca0b8c481298246a26451bf242.jpeg'

# 准备参数
options = {}
options['max_face_num'] = '4'

# 识别人脸，比之前多了个options，options为字典类型
face_data = client.detect(image, image_type, options)

python复制代码# 将url中的图片保存到本地
resp = urllib.request.urlopen(image_url)
f = open('im.jpg', 'wb')
f.write(resp.read())

# 打开图片
im = Image.open('im.jpg')
# 用于区分图片
n = 0
# 遍历face_list
for i in face_data['result']['face_list']:
    n += 1
    left = i['location']['left']
    top = i['location']['top']
    width = i['location']['width']
    height = i['location']['height']

    # 截图并保存
    face_im = im.crop((left, top, left + width, top + height))
    face_im.save('face_im' + str(n) + '.jpg')

python复制代码# 准备参数
options = {}
options['face_field'] = 'expression'

csharp复制代码输入： root = [1,3,null,null,2]
输出： [3,1,null,null,2]
解释： 3 不能是 1 左孩子，因为 3 > 1 。交换 1 和 3 使二叉搜索树有效。

java复制代码    TreeNode x=null, y=null; // 下标

    public void recoverTree(TreeNode root) {
        dfs(root, new LinkedList<>());
        // 交换x,y的值（两种情况）
        int temp = x.val;
        x.val = y.val;
        y.val = temp;
    }

    public void dfs(TreeNode node, Deque<TreeNode> stack) {
        if (node == null) {
            return;
        }
        dfs(node.left, stack);
        if (!stack.isEmpty() && node.val < stack.peek().val) {
            if (x == null) {
                x = stack.peek();
            }
            y = node;
        }
        stack.push(node);
        dfs(node.right, stack);
    }

java复制代码    public static void main(String[] args) {
        TreeNode treeNode = new TreeNode(1, new TreeNode(3, null, new TreeNode(2)), null);
        new Number99().recoverTree(treeNode);
    }

javascript复制代码const fs = require('fs');
axios.get(img_url, { responseType: Buffer })
            .then(async function (response) {
                let d = response.data;
                fs.writeFileSync(`${fileName}.png`, d);
            }).catch(e => {
                console.error(e);
            });

javascript复制代码        const writer = fs.createWriteStream(img_save_path)
        let response  = await axios.get(url, {
            responseType:"stream"
        })
        response.data.pipe(writer)

复制代码192.168.200.20 kafka1
192.168.200.20 kafka2
192.168.200.20 kafka3

xml复制代码<dependencies>
    <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients -->
    <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka-clients</artifactId>
        <version>1.0.0</version>
    </dependency>
</dependencies>

<build>
    <plugins>
        <!-- java编译插件 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.2</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
    </plugins>
</build>

java复制代码public class ProducerDemo {

    public static String topic = "test";//定义主题

    public static void main(String[] args) throws Exception {
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.200.20:9092,192.168.200.20:9093,192.168.200.20:9094");
        //网络传输,对key和value进行序列化
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        //创建消息生产对象，需要从properties对象或者从properties文件中加载信息
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

        try {
            while (true) {
                //设置消息内容
                String msg = "Hello," + new Random().nextInt(100);
                //将消息内容封装到ProducerRecord中
                ProducerRecord<String, String> record = new ProducerRecord<String, String>(topic, msg);
                kafkaProducer.send(record);
                System.out.println("消息发送成功:" + msg);
                Thread.sleep(500);
            }
        } finally {
            kafkaProducer.close();
        }
    }
}

java复制代码public class ConsumerDemo {

    public static void main(String[] args){
        Properties p = new Properties();
        p.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.200.20:9092,192.168.200.20:9093,192.168.200.20:9094");
        p.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        p.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        //指定组名
        p.put(ConsumerConfig.GROUP_ID_CONFIG, "test");

        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(p);
        kafkaConsumer.subscribe(Collections.singletonList(ProducerDemo.topic));// 订阅消息

        while (true) {
            ConsumerRecords<String, String> records = kafkaConsumer.poll(100);
            for (ConsumerRecord<String, String> record : records) {
                System.out.println(String.format("topic:%s,offset:%d,消息:%s", record.topic(), record.offset(), record.value()));
            }
        }
    }

}

java复制代码//producer无需等待来自broker的确认而继续发送下一批消息。
//这种情况下数据传输效率最高，但是数据可靠性确是最低的。
properties.put(ProducerConfig.ACKS_CONFIG,"0");

//producer只要收到一个分区副本成功写入的通知就认为推送消息成功了。
//这里有一个地方需要注意，这个副本必须是leader副本。
//只有leader副本成功写入了，producer才会认为消息发送成功。
properties.put(ProducerConfig.ACKS_CONFIG,"1");

//ack=-1，简单来说就是，producer只有收到分区内所有副本的成功写入的通知才认为推送消息成功了。
properties.put(ProducerConfig.ACKS_CONFIG,"-1");

java复制代码properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"false");

java复制代码public interface Partitioner extends Configurable, Closeable {

    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster);

    /**
    * This is called when partitioner is closed.
    */
    public void close();

}

java复制代码
public ProducerRecord(String topic, Integer partition, K key, V value) {
    this(topic, partition, null, key, value, null);
}

java复制代码public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
    //获取该topic的分区列表
    List<PartitionInfo> partitions = cluster.partitionsForTopic(topic);
    //获得分区的个数
    int numPartitions = partitions.size();
    //如果key值为null
    if (keyBytes == null) {//如果没有指定key，那么就是轮询
        //维护一个key为topic的ConcurrentHashMap，并通过CAS操作的方式对value值执行递增+1操作
        int nextValue = nextValue(topic);
        //获取该topic的可用分区列表
        List<PartitionInfo> availablePartitions = cluster.availablePartitionsForTopic(topic);
        if (availablePartitions.size() > 0) {//如果可用分区大于0
            //执行求余操作，保证消息落在可用分区上
            int part = Utils.toPositive(nextValue) % availablePartitions.size();
            return availablePartitions.get(part).partition();
        } else {
            // 没有可用分区的话，就给出一个不可用分区
            return Utils.toPositive(nextValue) % numPartitions;
        }
    } else {//不过指定了key，key肯定就不为null
        // 通过计算key的hash，确定消息分区
        return Utils.toPositive(Utils.murmur2(keyBytes)) % numPartitions;
    }
}

java复制代码@SpringBootApplication

css复制代码@EnableEurekaClient

java复制代码@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
      @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

java复制代码@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)

java复制代码@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {

java复制代码@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {

java复制代码@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {

java复制代码private void collectImports(SourceClass sourceClass, Set<SourceClass> imports, Set<SourceClass> visited)
      throws IOException {

   if (visited.add(sourceClass)) {
      for (SourceClass annotation : sourceClass.getAnnotations()) {
         String annName = annotation.getMetadata().getClassName();
         if (!annName.equals(Import.class.getName())) {
            collectImports(annotation, imports, visited);
         }
      }
      imports.addAll(sourceClass.getAnnotationAttributes(Import.class.getName(), "value"));
   }
}

java复制代码For example, it is common for a @Configuration class to declare direct
 @Import s in addition to meta-imports originating from an @Enable
annotation.

java复制代码// Process any @Import annotations
processImports(configClass, sourceClass, getImports(sourceClass), filter, true);

java复制代码private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
      Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
      boolean checkForCircularImports) {

    //如果你要import的东西都没有，那我就不处理了
   if (importCandidates.isEmpty()) {
      return;
   }

    //这里就是判断是否有循环import的说法了
    //我们知道Spring会给你处理循环的bean，但是这里如果出现循环就直接报错了
   if (checkForCircularImports && isChainedImportOnStack(configClass)) {
      this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
   }
    
    //其实这里都不用写else，上面的卫语句已经处理掉了
   else {
       //上面判断是不是有循环的stack，在这里做更新
      this.importStack.push(configClass);
      try {
         for (SourceClass candidate : importCandidates) {
             //如果我们import的类是个ImportSelector：实例化这个selector【A1】
            if (candidate.isAssignable(ImportSelector.class)) {
               // Candidate class is an ImportSelector -> delegate to it to determine imports
               Class<?> candidateClass = candidate.loadClass();
               ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
                     this.environment, this.resourceLoader, this.registry);
               Predicate<String> selectorFilter = selector.getExclusionFilter();
                //这里就是加上了selector中指定的判断了
               if (selectorFilter != null) {
                  exclusionFilter = exclusionFilter.or(selectorFilter);
               }
                //看名字也知道：延迟importSelector，把这个行为往后延迟，等到后面再处理【A2】
               if (selector instanceof DeferredImportSelector) {
                  this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
               }
                //这里对应的是：是importSelector，但不是延迟的，那么就直接处理这个importSelector了呗
               else {
                   //调用selectIimports方法，获取需要import的类名称
                  String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                   //封装
                  Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
                   //递归了，原因跟上面的collectImports类似
                  processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
               }
            }
             //这里的else对应的是：sourceClass不是ImportSelector，而是：ImportBeanDefinitionRegistrar【A3】
            else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
               // Candidate class is an ImportBeanDefinitionRegistrar ->
               // delegate to it to register additional bean definitions
               Class<?> candidateClass = candidate.loadClass();
               ImportBeanDefinitionRegistrar registrar =
                     ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
                           this.environment, this.resourceLoader, this.registry);
               configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
            }
             //这里看注释就知道是来处理@Configuration的【2】
            else {
               // Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
               // process it as an @Configuration class
               this.importStack.registerImport(
                     currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
               processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
            }
         }
      }
      catch (BeanDefinitionStoreException ex) {
         throw ex;
      }
      catch (Throwable ex) {
         throw new BeanDefinitionStoreException(
               "Failed to process import candidates for configuration class [" +
               configClass.getMetadata().getClassName() + "]", ex);
      }
      finally {
         this.importStack.pop();
      }
   }
}

typescript复制代码/**
 * <p>
 * 前端控制器
 * </p>
 */
@RestController
@RequestMapping("/goods")
public class GoodsController {
 
 
    @Autowired
    private GoodsService goodsService;
 
    @Autowired
    private ProviderService providerService;
 
    @Autowired
    private CategoryService categoryService;
 
    /**
     * 商品模糊查询
     *
     * @param
     * @return
     */
    @SysLog("商品查询操作")
    @RequestMapping("/goodsList")
    public DataGridViewResult goodsList(GoodsVO goodsVO) {
        //创建分页信息    参数1 当前页  参数2 每页显示条数
        IPage<Goods> page = new Page<>(goodsVO.getPage(), goodsVO.getLimit());
        QueryWrapper<Goods> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq(goodsVO.getProviderid() != null && goodsVO.getProviderid() != 0, "providerid", goodsVO.getProviderid());
        queryWrapper.like(!StringUtils.isEmpty(goodsVO.getGname()), "gname", goodsVO.getGname());
        IPage<Goods> goodsIPage = goodsService.page(page, queryWrapper);
        List<Goods> records = goodsIPage.getRecords();
        for (Goods goods : records) {
            Provider provider = providerService.getById(goods.getProviderid());
            if (null != provider) {
                goods.setProvidername(provider.getProvidername());
            }
        }
        return new DataGridViewResult(goodsIPage.getTotal(), records);
    }
 
 
    /**
     * 添加商品信息
     *
     * @param goods
     * @return
     */
    @SysLog("商品添加操作")
    @PostMapping("/addgoods")
    public Result addGoods(Goods goods) {
        String id = RandomStringUtils.randomAlphanumeric(8);
        if (goods.getGoodsimg()!=null&&goods.getGoodsimg().endsWith("_temp")){
            String newName = AppFileUtils.renameFile(goods.getGoodsimg());
            goods.setGoodsimg(newName);
        }
        goods.setGnumbering(id);
        boolean bool = goodsService.save(goods);
        if (bool) {
            return Result.success(true, "200", "添加成功！");
        }
        return Result.error(false, null, "添加失败！");
    }
 
    /**
     * 修改商品信息
     *
     * @param goods
     * @return
     */
    @SysLog("商品修改操作")
    @PostMapping("/updategoods")
    public Result updateGoods(Goods goods) {
        //商品图片不是默认图片
        if (!(goods.getGoodsimg()!=null&&goods.getGoodsimg().equals(Constast.DEFAULT_IMG))){
            if (goods.getGoodsimg().endsWith("_temp")){
                String newName = AppFileUtils.renameFile(goods.getGoodsimg());
                goods.setGoodsimg(newName);
                //删除原先的图片
                String oldPath = goodsService.getById(goods.getGid()).getGoodsimg();
                AppFileUtils.removeFileByPath(oldPath);
            }
        }
        boolean bool = goodsService.updateById(goods);
        if (bool) {
            return Result.success(true, "200", "修改成功！");
        }
        return Result.error(false, null, "修改失败！");
    }
 
 
    /**
     * 删除单条数据
     *
     * @param id
     * @return
     */
    @SysLog("商品删除操作")
    @RequestMapping("/deleteOne")
    public Result deleteOne(int id) {
 
        boolean bool = goodsService.removeById(id);
        if (bool) {
            return Result.success(true, "200", "删除成功！");
        }
        return Result.error(false, null, "删除失败！");
    }
 
    /**
     * 根据id查询当前商品拥有的类别
     *
     * @param id
     * @return
     */
    @RequestMapping("/initGoodsByCategoryId")
    public DataGridViewResult initGoodsByCategoryId(int id) {
        List<Map<String, Object>> mapList = null;
        try {
            //查询所有类别列表
            mapList = categoryService.listMaps();
            //根据商品id查询商品拥有的类别
            Set<Integer> cateIdList = categoryService.findGoodsByCategoryId(id);
            for (Map<String, Object> map : mapList) {
                //定义标记 默认不选中
                boolean flag = false;
                int cateId = (int) map.get("cateid");
                for (Integer cid : cateIdList) {
                    if (cid == cateId) {
                        flag = true;
                        break;
                    }
                }
                map.put("LAY_CHECKED", flag);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return new DataGridViewResult(Long.valueOf(mapList.size()), mapList);
 
    }
 
    /**
     * 根据商品id加载商品信息
     * @param goodsid
     * @return
     */
    @GetMapping("/loadGoodsById")
    public DataGridViewResult loadGoodsById(int goodsid) {
 
 
        QueryWrapper<Goods> goodsQueryWrapper = new QueryWrapper<>();
        goodsQueryWrapper.eq(goodsid != 0, "gid", goodsid);
        Goods goods = goodsService.getById(goodsid);
 
        return new DataGridViewResult(goods);
 
    }
 
    /**
     * 为商品分配类别
     *
     * @param categoryids
     * @param goodsid
     * @return
     */
    @SysLog("类别添加操作")
    @RequestMapping("/saveGoodsCategory")
    public Result saveGoodsCategory(String categoryids, int goodsid) {
 
        try {
            if (goodsService.saveGoodsCategory(goodsid, categoryids)) {
                return Result.success(true, null, "分配成功");
            }
 
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Result.error(false, null, "分配失败");
 
    }
 
    /**
     * 加载下拉框
     *
     * @return
     */
    @RequestMapping("/loadAllGoods")
    public DataGridViewResult loadAllGoods() {
        QueryWrapper<Goods> queryWrapper = new QueryWrapper<>();
        List<Goods> list = goodsService.list(queryWrapper);
        return new DataGridViewResult(list);
 
    }
 
 
    /**
     * 根据供应商查商品下拉框
     *
     * @param providerid
     * @return
     */
    @RequestMapping("/loadGoodsByProvidreId")
    public DataGridViewResult loadGoodsByProvidreId(Integer providerid) {
        QueryWrapper<Goods> goodsQueryWrapper = new QueryWrapper<>();
        goodsQueryWrapper.eq(providerid != null, "providerid", providerid);
        List<Goods> list = goodsService.list(goodsQueryWrapper);
        for (Goods goods : list) {
            Provider provider = providerService.getById(goods.getProviderid());
            if (null != provider) {
                goods.setProvidername(provider.getProvidername());
            }
 
        }
        return new DataGridViewResult(list);
 
    }
}

kotlin复制代码/**
 * <p>
 *  前端控制器
 * </p>
 */
@RestController
@RequestMapping("/sale")
public class SaleController {
    @Autowired
    private SaleService saleService;
 
    @Autowired
    private GoodsService goodsService;
    
    @Autowired
    private CustomerService customerService;
 
    /**
     * 销售查询
     *
     * @param
     * @return
     */
    @SysLog("销售查询操作")
    @RequestMapping("/saleList")
    public DataGridViewResult saleList(SaleVO saleVO) {
 
        //创建分页信息    参数1 当前页  参数2 每页显示条数
        IPage<Sale> page = new Page<>(saleVO.getPage(), saleVO.getLimit());
        QueryWrapper<Sale> queryWrapper = new QueryWrapper<>();
        queryWrapper.like(!StringUtils.isEmpty(saleVO.getNumbering()),"numbering", saleVO.getNumbering());
        queryWrapper.eq(saleVO.getGid() != null && saleVO.getGid() != 0, "gid", saleVO.getGid());
        queryWrapper.ge(saleVO.getStartTime() != null, "buytime", saleVO.getStartTime());
        queryWrapper.le(saleVO.getEndTime() != null, "buytime", saleVO.getEndTime());
 
        queryWrapper.orderByDesc("buytime");
 
        IPage<Sale> saleIPage = saleService.page(page, queryWrapper);
 
        List<Sale> records = saleIPage.getRecords();
 
        for (Sale sale : records) {
            sale.setAllmoney(sale.getMoney()*sale.getBuyquantity());
            Customer customer = customerService.getById(sale.getCustid());
 
            if (null != customer) {
                sale.setCustomervip(customer.getCustvip());
                sale.setCustomername(customer.getCustname());
            }
            Goods goods = goodsService.getById(sale.getGid());
            if (null != goods) {
 
                sale.setGoodsname(goods.getGname());
                sale.setGnumbering(goods.getGnumbering());
            }
        }
 
        return new DataGridViewResult(saleIPage.getTotal(), records);
 
    }
 
 
    /**
     * 添加销售单信息
     *
     * @param sale
     * @return
     */
    @SysLog("销售添加操作")
    @PostMapping("/addsale")
    public Result addsale(Sale sale, HttpSession session) {
        if (sale.getGid()==0){
            return Result.error(false, null, "添加失败！未选商品");
        }
        Goods goods = goodsService.getById(sale.getGid());
        Integer gquantity = goods.getGquantity();
        if(gquantity<sale.getBuyquantity()){
            return Result.error(false, null, "添加失败！库存不足,库存为："+gquantity);
        }
        User user = (User) session.getAttribute("username");
        String num = RandomStringUtils.randomAlphanumeric(7);
        sale.setNumbering(num);
        sale.setPerson(user.getUsername());
        sale.setBuytime(new Date());
        sale.setRealnumber(sale.getBuyquantity());
        boolean bool = saleService.save(sale);
        if (bool) {
            return Result.success(true, "200", "添加成功！");
        }
        return Result.error(false, null, "添加失败！库存不足");
    }
 
 
    /**
     * 修改销售单信息
     *
     * @param sale
     * @return
     */
    @SysLog("销售修改操作")
    @PostMapping("/updatesale")
    public Result updatesale(Sale sale, HttpSession session) {
 
        User user = (User) session.getAttribute("username");
        sale.setPerson(user.getUsername());
        sale.setBuytime(new Date());
        boolean bool = saleService.updateById(sale);
        if (bool) {
            return Result.success(true, "200", "修改成功！");
        }
        return Result.error(false, null, "修改失败！");
    }
    /**
     * 删除单条数据
     *
     * @param id
     * @return
     */
    @SysLog("销售删除操作")
    @RequestMapping("/deleteOne")
    public Result deleteOne(int id) {
 
        boolean bool = saleService.removeById(id);
        if (bool) {
            return Result.success(true, "200", "删除成功！");
        }
        return Result.error(false, null, "删除失败！");
    }
 
 
 
}

java复制代码@Configuration
@RibbonClient(name = "foo", configuration = FooConfiguration.class)
public class TestConfiguration {
}

xml复制代码 <!--引入ribbon-->
 <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-ribbon</artifactId>
       <version>1.4.6.RELEASE</version>
 </dependency>
 <!--引入erueka-->
 <dependency>
     <groupId>org.springframework.cloud</groupId>
     <artifactId>spring-cloud-starter-eureka</artifactId>
     <version>1.4.6.RELEASE</version>
</dependency>

yml复制代码# 配置eureka
eureka:
  client:
    register-with-eureka: false # 不向eureka注册自己
    service-url:    # 获取服务的地址
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/

java复制代码@SpringBootApplication
@EnableEurekaClient // eureka客户端
@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT",configuration = MyRule.class )
public class DeptConsumer {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer.class,args);
    }
}

java复制代码@Configuration // 表明其为基本的配置类
public class MyRule {
     @Bean // 把组件放入ioc容器中
     public IRule myrule(){
         return  new  MyRandomRule();
     }
}