// yourEndpoint填写Bucket所在地域对应的Endpoint。以华东1（杭州）为例，Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。
String endpoint = "yourEndpoint";
// 阿里云账号AccessKey拥有所有API的访问权限，风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维，请登录RAM控制台创建RAM用户。
String accessKeyId = "yourAccessKeyId";
String accessKeySecret = "yourAccessKeySecret";

// 创建OSSClient实例。
OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);

// 填写本地文件的完整路径。如果未指定本地路径，则默认从示例程序所属项目对应本地路径中上传文件流。
InputStream inputStream = new FileInputStream("D:\\localpath\\examplefile.txt");
// 依次填写Bucket名称（例如examplebucket）和Object完整路径（例如exampledir/exampleobject.txt）。Object完整路径中不能包含Bucket名称。
ossClient.putObject("examplebucket", "exampledir/exampleobject.txt", inputStream);

// 关闭OSSClient。
ossClient.shutdown();

@RunWith(SpringRunner.class)
@SpringBootTest
public class GulimallThirdPartyApplicationTests {
    @Autowired
    OSSClient ossClient;
    @Test
    public void aliyunOssTest() throws FileNotFoundException {
        InputStream inputStream = new FileInputStream("C:\\Users\\卢荟\\Desktop\\谷粒电商\\1\\docs\\pics\\6a1b2703a9ed8737.jpg");
        // 依次填写Bucket名称（例如examplebucket）和Object完整路径（例如exampledir/exampleobject.txt）。Object完整路径中不能包含Bucket名称。
        ossClient.putObject("lh-demo-gulimall", "test2.jpg", inputStream);
        // 关闭OSSClient。
        ossClient.shutdown();
        System.out.println("上传完成");
    }
}

@RestController
public class OssController {
     // 这里debug好快啊，不愧是老师，
    // OSS接口，OSSClient是实现类已经写好的，要自动注入接口
    @Autowired
    OSS ossClient;
    @Value("${spring.cloud.alicloud.oss.endpoint}")
    private String endpoint;
    @Value("${spring.cloud.alicloud.oss.bucket}")
    private String bucket;
    @Value("${spring.cloud.alicloud.access-key}")
    private String accessId;
    @RequestMapping("/oss/policy")
    public R policy() {
        String host = "https://" + bucket + "." + endpoint; // host的格式为 bucketname.endpoint
        // callbackUrl为上传回调服务器的URL，请将下面的IP和Port配置为您自己的真实信息。
        // String callbackUrl = "http://88.88.88.88:8888";
        // 以当前日期分类
        String format = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
        String dir = format + "/"; // 用户上传文件时指定的前缀。
        Map<String, String> respMap = null;
        try {
            long expireTime = 30;
            long expireEndTime = System.currentTimeMillis() + expireTime * 1000;
            Date expiration = new Date(expireEndTime);
            // PostObject请求最大可支持的文件大小为5 GB，即CONTENT_LENGTH_RANGE为5*1024*1024*1024。
            PolicyConditions policyConds = new PolicyConditions();
            policyConds.addConditionItem(PolicyConditions.COND_CONTENT_LENGTH_RANGE, 0, 1048576000);
            policyConds.addConditionItem(MatchMode.StartWith, PolicyConditions.COND_KEY, dir);
            String postPolicy = ossClient.generatePostPolicy(expiration, policyConds);
            byte[] binaryData = postPolicy.getBytes("utf-8");
            String encodedPolicy = BinaryUtil.toBase64String(binaryData);
            String postSignature = ossClient.calculatePostSignature(postPolicy);
            respMap = new LinkedHashMap<String, String>();
            respMap.put("accessid", accessId);
            respMap.put("policy", encodedPolicy);
            respMap.put("signature", postSignature);
            respMap.put("dir", dir);
            respMap.put("host", host);
            respMap.put("expire", String.valueOf(expireEndTime / 1000));
            // respMap.put("expire", formatISO8601Date(expiration));
        } catch (Exception e) {
            // Assert.fail(e.getMessage());
            System.out.println(e.getMessage());
        } finally {
            ossClient.shutdown();
        }
        return R.ok().put("data", respMap);
    }
}

@Data
@TableName("pms_brand")
public class BrandEntity implements Serializable {
    private static final long serialVersionUID = 1L;
    /**
     * 品牌id
     */
    @TableId
    private Long brandId;
    /**
     * 品牌名
     */
    @NotEmpty       // 验证规则，String类型非空
    @NotBlank(message = "品牌名不能为空")    // 验证规则，至少包含一个非空字符，msg为出错时的提示信息
    private String name;
    /**
     * 品牌logo地址
     */
    @NotEmpty
    @URL(message = "LOGO必须是合法的URL地址")    // 验证规则，必须是url
    private String logo;
    /**
     * 介绍
     */
    @NotEmpty
    private String descript;
    /**
     * 显示状态[0-不显示；1-显示]
     */
    @NotNull           // 验证规则，Integer类型非空
    private Integer showStatus;
    /**
     * 检索首字母
     */
    @NotEmpty
    @Pattern(regexp = "/^[a-zA-Z]$/", message = "检索字母必须是a-z或者A-Z中的单个字母")    // 使用自定义校验规则，可以写正则表达式
    private String firstLetter;
    /**
     * 排序
     */
    @NotEmpty
    @Min(value = 0) // 验证规则，最小不能小于value
    private Integer sort;
}

@RestController
@RequestMapping("product/brand")
public class BrandController {
    @Autowired
    private BrandService brandService;
    /**
     * 保存
     */
    @RequestMapping("/save")
    //@RequiresPermissions("product:brand:save")
    public R save(@Valid @RequestBody BrandEntity brand) {
        brandService.save(brand);
        return R.ok();
    }
}

/**
 * 保存
 */
@RequestMapping("/save")
//BindingResult result封装了紧跟着的对象的校验结果
public R save(@Valid @RequestBody BrandEntity brand, BindingResult result) {
       // 判断校验是否出错
        if (result.hasErrors()) {
            Map<String, String> map = new HashMap<>();
            // 获取校验结果并且封装到map
            result.getFieldErrors().forEach((fieldError) -> {
                String message = fieldError.getDefaultMessage();
                String fieldName = fieldError.getField();
                map.put(fieldName, message);
            });
            return R.error(400, "递交的数据不合法").put("data", map);
        } else {
            brandService.save(brand);
            return R.ok();
        }
}

/**
 * 品牌id
 */
@NotNull(message = "修改必须指定id", groups = {UpdateGroup.class})
@Null(message = "新增不能指定id", groups = {AddGroup.class})
@TableId
private Long brandId;
 /**
 * 品牌名
 */
@NotEmpty       // 验证规则，String类型非空
@NotBlank(message = "品牌名不能为空",, groups = {AddGroup.class, UpdateGroup.class})    // 验证规则，至少包含一个非空字符，msg为出错时的提示信息
private String name;

/**
 * 保存
 */
@RequestMapping("/save")
//BindingResult result封装了紧跟着的对象的校验结果
public R save(@Validated({AddGroup.class}) @RequestBody BrandEntity brand) {
    // 使用统一异常处理，当有异常的时候直接抛出异常即可
    brandService.save(brand);
    return R.ok();
}

/**
 * 自定义校验器
 */
// ConstraintValidator接口《校验注解名，字段名》
public class ListValueConstraintValidator implements ConstraintValidator<ListValue, Integer> {

    private Set<Integer> set = new HashSet<>();

    @Override
    public void initialize(ListValue constraintAnnotation) {
        int[] vals = constraintAnnotation.vals();
        for (int val : vals) {
            set.add(val);
        }
    }

    // 判断是否校验成功(是否包含在注解的val值中)
    @Override
    public boolean isValid(Integer value, ConstraintValidatorContext context) {
        return set.contains(value);
    }
}

@Documented
@Constraint(validatedBy = {ListValueConstraintValidator.class}) // 放入自定义校验器
@Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE})
@Retention(RUNTIME)
public @interface ListValue {

    // 需要从配置文件中获取
    String message() default "{com.atguigu.common.valid.ListValue.message}";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

    int[] vals() default {};

}

/**
 * 显示状态[0-不显示；1-显示]
 */
@NotNull(message = "必须指定显示状态[0-不显示；1-显示]", groups = {AddGroup.class, UpdateGroup.class})    // 验证规则，Integer类型非空
@ListValue(vals = {0, 1}, groups = {AddGroup.class})// 自定义验证规则，必须为0或1
private Integer showStatus;

/**
 * 保存
 */
@RequestMapping("/save")
//BindingResult result封装了紧跟着的对象的校验结果
public R save(@Validated({AddGroup.class}) @RequestBody BrandEntity brand) {
    // 使用统一异常处理，当有异常的时候直接抛出异常即可
    brandService.save(brand);
    return R.ok();
}

/**
 * 统一异常处理
 */
@ResponseBody
@Slf4j  // 日志
@RestControllerAdvice(basePackages = "com.atguigu.gulimall.product.controller")
// 标志这是一个REST风格的ControllerAdvice，即增强的controller，可以用于全局异常处理，后跟需要处理的包名
public class GulimallExceptionControllerAdvice {

    @ExceptionHandler(value = MethodArgumentNotValidException.class)  // 异常处理，value为指定处理的异常
    public R handleValidException(MethodArgumentNotValidException e) {
        log.error("数据校验有误{},异常类型{}", e.getMessage(), e.getClass()); // 用于测试，先写Exception然后主动出错,就可以获得异常的类型
        Map<String, String> errorMap = new HashMap<>();
        BindingResult bindingResult = e.getBindingResult();
        bindingResult.getFieldErrors().forEach((item) -> {
            errorMap.put(item.getField(), item.getDefaultMessage());
        });
        return R.error(400, "数据校验有误").put("data", errorMap);
    }
    
}

/**
 * 枚举，错误码
 */
public enum BizCodeEnum {
    UNKNOWN_EXCEPTION(10000, "系统未知异常"),
    VALID_EXCEPTION(10001, "参数格式校验失败");

    private Integer code;
    private String msg;

    BizCodeEnum(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public Integer getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }
}

/**
 * 统一异常处理
 */
@ResponseBody
@Slf4j  // 日志
@RestControllerAdvice(basePackages = "com.atguigu.gulimall.product.controller")
// 标志这是一个REST风格的ControllerAdvice，即增强的controller，可以用于全局异常处理，后跟需要处理的包名
public class GulimallExceptionControllerAdvice {

    @ExceptionHandler(value = MethodArgumentNotValidException.class)  // 异常处理，value为指定处理的异常
    public R handleValidException(MethodArgumentNotValidException e) {
        log.error("数据校验有误{},异常类型{}", e.getMessage(), e.getClass()); // 用于测试，先写Exception然后主动出错,就可以获得异常的类型
        Map<String, String> errorMap = new HashMap<>();
        BindingResult bindingResult = e.getBindingResult();
        bindingResult.getFieldErrors().forEach((item) -> {
            errorMap.put(item.getField(), item.getDefaultMessage());
        });
        return R.error(BizCodeEnum.VALID_EXCEPTION.getCode(), BizCodeEnum.VALID_EXCEPTION.getMsg()).put("data", errorMap);
    }

    @ExceptionHandler(value = Throwable.class)
    public R handleException(Throwable throwable) {
        return R.error(BizCodeEnum.UNKNOWN_EXCEPTION.getCode(), BizCodeEnum.UNKNOWN_EXCEPTION.getMsg());
    }
}

/**
 * 列表
 */
@RequestMapping("/list/{catelogId}")
//@RequiresPermissions("product:attrgroup:list")
public R list(@RequestParam Map<String, Object> params, @PathVariable Long catelogId) {
    PageUtils page = attrGroupService.queryPage(params, catelogId);
    return R.ok().put("page", page);
}

@Override
public PageUtils queryPage(Map<String, Object> params, Long catelogId) {
    if (catelogId == 0) {
        // 未指定分类
        IPage<AttrGroupEntity> page = this.page(new Query<AttrGroupEntity>().getPage(params), new QueryWrapper<>());
        return new PageUtils(page);
    } else {
        // key是检索条件，已经封装好的
        String key = (String) params.get("key");
        QueryWrapper<AttrGroupEntity> wrapper = new QueryWrapper<AttrGroupEntity>().eq("catelog_id", catelogId);
        // 如果有key,那么再加上and条件，条件中判断如下
        if (!StringUtils.isEmpty(key)) {
            wrapper.and((obj) -> {
                obj.eq("attr_group_id", key).or().like("attr_group_name", key);
            });
        }
        IPage<AttrGroupEntity> page = this.page(new Query<AttrGroupEntity>().getPage(params), wrapper);
        return new PageUtils(page);
    }
}

/**
 * 子分类
 */
@JsonInclude(JsonInclude.Include.NON_EMPTY) // 当该字段不为空时才返回字段kv
@TableField(exist = false)    // 表示该属性在数据表中不存在
private List<CategoryEntity> children;

/**
 * 所属分类id的完整路径
 */
@TableField(exist = false)    // 不是数据库中存在的字段
private Long[] catelogPath;

@RestController
@RequestMapping("product/attrgroup")
public class AttrGroupController {
    /**
     * 信息
     */
    @RequestMapping("/info/{attrGroupId}")
    //@RequiresPermissions("product:attrgroup:info")
    public R info(@PathVariable("attrGroupId") Long attrGroupId) {
        AttrGroupEntity attrGroup = attrGroupService.getById(attrGroupId);

        Long catelogId = attrGroup.getCatelogId();
        // 获取完整分类路径（前端所需）
        Long[] path = categoryService.findCategoryPath(catelogId);
        attrGroup.setCatelogPath(path);

        return R.ok().put("attrGroup", attrGroup);
    }
}

@Override
public Long[] findCategoryPath(Long catelogId) {
    List<Long> path = new ArrayList<>();
    List<Long> parentPath = findParentPath(catelogId, path);
    // 这里需要逆序一下（因为是倒着找的）
    Collections.reverse(parentPath);
    return parentPath.toArray(new Long[0]);
}

private List<Long> findParentPath(Long catelogId, List<Long> path) {
    path.add(catelogId);
    CategoryEntity byId = this.getById(catelogId);
    if (byId.getParentCid() != 0) {
        findParentPath(byId.getParentCid(), path);
    }
    return path;
}

package com.atguigu.gulimall.product.config;

import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration                  // 配置类
@EnableTransactionManagement    // 开启事务功能
@MapperScan("com.atguigu.gulimall.product.dao")
public class MybatisPlusConfig {
    // 引入分页插件（注意这里是旧版本，如果版本较新需要自行去官网查看最新写法）
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求  默认false
        paginationInterceptor.setOverflow(true);
        // 设置最大单页限制数量，默认 500 条，-1 不受限制
        paginationInterceptor.setLimit(1000);
        return paginationInterceptor;
    }
}

@Service("brandService")
public class BrandServiceImpl extends ServiceImpl<BrandDao, BrandEntity> implements BrandService {
    @Override
    public PageUtils queryPage(Map<String, Object> params) {
        QueryWrapper<BrandEntity> queryWrapper = new QueryWrapper<>();
        // 模糊查询
        String key = (String) params.get("key");
        if (!StringUtils.isEmpty(key)) {
            queryWrapper.eq("brand_id", key).or().like("name", key);
        }
        IPage<BrandEntity> page = this.page(
                new Query<BrandEntity>().getPage(params),
                queryWrapper
        );
        return new PageUtils(page);
    }
}

@RestController
@RequestMapping("product/categorybrandrelation")
public class CategoryBrandRelationController {
    @Autowired
    private CategoryBrandRelationService categoryBrandRelationService;
    /**
     * 获取品牌关联的所有分类列表
     */
    @GetMapping("/catelog/list")
    public R relationList(@RequestParam("brandId") Long brandId) {
        List<CategoryBrandRelationEntity> data = categoryBrandRelationService.list(
                new QueryWrapper<CategoryBrandRelationEntity>().eq("brand_id", brandId));

        return R.ok().put("data", data);
    }
    /**
     * 保存品牌关联的所有分类
     */
    @PostMapping("/save")
    public R save(@RequestBody CategoryBrandRelationEntity categoryBrandRelation) {
        categoryBrandRelationService.mySave(categoryBrandRelation);
        return R.ok();
    }
}

@Service("categoryBrandRelationService")
public class CategoryBrandRelationServiceImpl extends ServiceImpl<CategoryBrandRelationDao, CategoryBrandRelationEntity> implements CategoryBrandRelationService {
    @Autowired
    BrandDao brandDao;
    @Autowired
    CategoryDao categoryDao;
    /**
     * 保存品牌关联的所有分类
     */
    @Override
    public void mySave(CategoryBrandRelationEntity categoryBrandRelation) {
        Long brandId = categoryBrandRelation.getBrandId();
        Long catelogId = categoryBrandRelation.getCatelogId();
        // 查询对应name
        BrandEntity brandEntity = brandDao.selectById(brandId);
        categoryBrandRelation.setBrandName(brandEntity.getName());
        CategoryEntity categoryEntity = categoryDao.selectById(catelogId);
        categoryBrandRelation.setCatelogName(categoryEntity.getName());
        // 保存
        baseMapper.insert(categoryBrandRelation);
    }
}

@Service("brandService")
public class BrandServiceImpl extends ServiceImpl<BrandDao, BrandEntity> implements BrandService {
	/**
	 * 修改品牌信息相关所有表的信息
	 *
	 * @param brand
	 */
	@Override
	public void updateDetail(BrandEntity brand) {
	    this.updateById(brand);
	    if (!StringUtils.isEmpty(brand.getName())) {
	        // 更新其他关联表中的数据
	        categoryBrandRelationService.updateBrand(brand.getBrandId(), brand.getName());
	    }
	        // TODO 更新其他关联表
	}
}

@Service("categoryBrandRelationService")
public class CategoryBrandRelationServiceImpl extends ServiceImpl<CategoryBrandRelationDao, CategoryBrandRelationEntity> implements CategoryBrandRelationService {
    /**
     * 由于brand信息的更新，所以需要更新关联数据
     *
     * @param brandId
     * @param name
     */
    @Override
    public void updateBrand(Long brandId, String name) {
        CategoryBrandRelationEntity entity = new CategoryBrandRelationEntity();
        entity.setBrandName(name);
        entity.setBrandId(brandId);
        this.update(entity, new UpdateWrapper<CategoryBrandRelationEntity>().eq("brand_id", brandId));
    }
}

@Service("categoryService")
public class CategoryServiceImpl extends ServiceImpl<CategoryDao, CategoryEntity> implements CategoryService {
/**
 * 修改(级联更新，连表更新)
 */
@Override
public void updateDetail(CategoryEntity category) {
    this.updateById(category);
    categoryBrandRelationService.updateCategory(category.getCatId(), category.getName());
}
}

@Service("categoryBrandRelationService")
public class CategoryBrandRelationServiceImpl extends ServiceImpl<CategoryBrandRelationDao, CategoryBrandRelationEntity> implements CategoryBrandRelationService {
    /**
     * 由于catogory信息的更新，所以需要更新关联数据
     *
     * @param catId
     * @param name
     */
    @Override
    public void updateCategory(Long catId, String name) {
        baseMapper.updateCategory(catId, name);
    }

}

@Mapper
public interface CategoryBrandRelationDao extends BaseMapper<CategoryBrandRelationEntity> {
    void updateCategory(@Param("catId") Long catId, @Param("name") String name);
}